Skip to content

code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research

ulw-research

Unverified

Runs maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.

FileKindSize
AGENTS.mdmarkdown9.2 KB
ATTRIBUTION.mdmarkdown2.4 KB
SKILL.mdskill md42.2 KB
references/deliverable-phase.mdmarkdown49.1 KB
references/fact-ledger-grammar.mdmarkdown6.8 KB
references/fact-ledger.mdmarkdown24.4 KB
references/fidelity-claim-kinds.mdmarkdown5.2 KB
references/markdown-blocks.mdmarkdown721 B
references/report-gates.mdmarkdown32.0 KB
references/report-visualization.mdmarkdown15.4 KB
references/research-collection.mdmarkdown26.8 KB
references/research-delivery.mdmarkdown14.3 KB
references/unit-rules.mdmarkdown16.3 KB
scripts/claim-kinds.mjsscript11.2 KB
scripts/claim-kinds.test.tsscript13.5 KB
scripts/claim-prefix.test.tsscript4.9 KB
scripts/claims-index.mjsscript5.3 KB
scripts/claims-index.test.tsscript5.7 KB
scripts/cli-support.mjsscript4.1 KB
scripts/cli-support.test.tsscript4.3 KB
scripts/contracts-validation.test.tsscript3.3 KB
scripts/contracts.mjsscript26.1 KB
scripts/contracts.test.tsscript7.9 KB
scripts/conversion-altered.test.tsscript11.0 KB
scripts/conversion-originals.test.tsscript22.7 KB
scripts/conversion-probe-classes.test.tsscript45.2 KB
scripts/conversion-probe.mjsscript13.5 KB
scripts/conversion-probe.test.tsscript11.6 KB
scripts/copy-returns-fidelity-policy.test.tsscript10.4 KB
scripts/copy-returns-polish.test.tsscript12.1 KB
scripts/copy-returns.test.tsscript10.6 KB
scripts/css-hiding.mjsscript9.1 KB
scripts/css-lite.mjsscript7.6 KB
scripts/css-lite.test.tsscript6.4 KB
scripts/delivery-barrier-meaning.test.tsscript12.3 KB
scripts/delivery-barrier.test.tsscript11.4 KB
scripts/design-spec.mjsscript7.2 KB
scripts/design-spec.test.tsscript6.7 KB
scripts/entities.mjsscript2.5 KB
scripts/entry-guard.mjsscript794 B
scripts/fact-commands-fill.mjsscript6.6 KB
scripts/fact-commands-meaning.mjsscript12.6 KB
scripts/fact-commands-polish.mjsscript10.3 KB
scripts/fact-commands-verify.mjsscript12.6 KB
scripts/fact-commands.mjsscript13.8 KB
scripts/fact-derive-2.test.tsscript7.2 KB
scripts/fact-derive.mjsscript4.9 KB
scripts/fact-derive.test.tsscript10.8 KB
scripts/fact-expr.mjsscript4.5 KB
scripts/fact-fill.mjsscript11.7 KB
scripts/fact-fill.test.tsscript10.7 KB
scripts/fact-ledger-grammar.test.tsscript11.8 KB
scripts/fact-ledger-kinds.mjsscript16.5 KB
scripts/fact-ledger-kinds.test.tsscript9.3 KB
scripts/fact-ledger-legacy.test.tsscript8.9 KB
scripts/fact-ledger-schema.mjsscript11.9 KB
scripts/fact-ledger-schema.test.tsscript1.5 KB
scripts/fact-ledger.mjsscript5.5 KB
scripts/fact-ledger.test.tsscript9.7 KB
scripts/fact-locate.mjsscript12.1 KB
scripts/fact-locate.test.tsscript7.2 KB
scripts/fact-pairs.mjsscript8.3 KB
scripts/fact-pairs.test.tsscript6.6 KB
scripts/fact-recompute.mjsscript4.8 KB
scripts/fact-unit-dimensions-2.test.tsscript8.4 KB
scripts/fact-unit-dimensions.test.tsscript11.9 KB
scripts/fact-unit-rules.test.tsscript8.9 KB
scripts/fidelity-binding.mjsscript6.7 KB
scripts/fidelity-binding.test.tsscript4.0 KB
scripts/fidelity-brief.mjsscript6.4 KB
scripts/fidelity-brief.test.tsscript7.8 KB
scripts/fidelity-claims.mjsscript5.1 KB
scripts/fidelity-csv.mjsscript1.1 KB
scripts/fidelity-lexicon.mjsscript8.1 KB
scripts/fidelity-lexicon.test.tsscript6.0 KB
scripts/fidelity-originals.mjsscript9.9 KB
scripts/fidelity-policy.mjsscript10.1 KB
scripts/fidelity-records.mjsscript13.4 KB
scripts/fidelity-snapshot-readability.mjsscript2.2 KB
scripts/fidelity-sources.mjsscript4.3 KB
scripts/fidelity-state.mjsscript2.1 KB
scripts/fidelity-state.test.tsscript1.7 KB
scripts/fidelity-trace.mjsscript6.1 KB
scripts/fidelity-trace.test.tsscript3.3 KB
scripts/fidelity-value-unit.mjsscript13.3 KB
scripts/fidelity-values.mjsscript16.1 KB
scripts/fidelity-values.test.tsscript15.8 KB
scripts/format-extract-css.mjsscript5.1 KB
scripts/format-extract.mjsscript10.3 KB
scripts/format-extract.test.tsscript11.2 KB
scripts/gates-context.test.tsscript2.6 KB
scripts/gates-fidelity.mjsscript6.3 KB
scripts/gates-fidelity.test.tsscript3.3 KB
scripts/gates-figures.mjsscript9.9 KB
scripts/gates-layout.mjsscript6.6 KB
scripts/gates-layout.test.tsscript12.4 KB
scripts/gates-static-headings.test.tsscript961 B
scripts/gates-static.mjsscript8.1 KB
scripts/gates-static.test.tsscript14.9 KB
scripts/gates-structure.mjsscript4.7 KB
scripts/gates-text.mjsscript7.2 KB
scripts/glossary-vocabulary.test.tsscript1.7 KB
scripts/html-foreign-object.mjsscript2.8 KB
scripts/html-lite.mjsscript9.7 KB
scripts/html-lite.test.tsscript7.9 KB
scripts/html-markup.mjsscript7.0 KB
scripts/html-text-map.mjsscript4.8 KB
scripts/html-text-map.test.tsscript15.2 KB
scripts/layout-probe.mjsscript4.6 KB
scripts/layout-probe.test.tsscript4.2 KB
scripts/lexicon.mjsscript2.6 KB
scripts/lexicon.test.tsscript3.2 KB
scripts/markdown-closers.mjsscript4.9 KB
scripts/md-lite-boundaries.test.tsscript2.2 KB
scripts/md-lite.mjsscript7.8 KB
scripts/md-lite.test.tsscript10.3 KB
scripts/meaning-check.mjsscript9.7 KB
scripts/meaning-check.test.tsscript12.0 KB
scripts/number-grammar.mjsscript2.1 KB
scripts/number-grammar.test.tsscript1.8 KB
scripts/numerals.mjsscript12.0 KB
scripts/numerals.test.tsscript6.1 KB
scripts/outcome-start.mjsscript3.8 KB
scripts/outcome-start.test.tsscript5.0 KB
scripts/outcome.mjsscript10.5 KB
scripts/outcome.test.tsscript12.8 KB
scripts/page-source-locator.test.tsscript11.7 KB
scripts/particles-ko.mjsscript4.8 KB
scripts/particles-ko.test.tsscript4.3 KB
scripts/placeholder.mjsscript9.3 KB
scripts/placeholder.test.tsscript3.8 KB
scripts/polish-apply.mjsscript6.8 KB
scripts/polish-apply.test.tsscript19.7 KB
scripts/polish-diff.mjsscript1.7 KB
scripts/polish-diff.test.tsscript10.1 KB
scripts/polish-markup.test.tsscript14.0 KB
scripts/polish-partial.test.tsscript2.5 KB
scripts/polish-project.mjsscript5.8 KB
scripts/polish-rules.mjsscript9.8 KB
scripts/rational.mjsscript5.2 KB
scripts/rational.test.tsscript1.9 KB
scripts/raw-decode.mjsscript4.5 KB
scripts/raw-locator.mjsscript2.4 KB
scripts/raw-snapshot.test.tsscript7.3 KB
scripts/references-fences.test.tsscript1.2 KB
scripts/repair-tracker.mjsscript7.5 KB
scripts/repair-tracker.test.tsscript10.8 KB
scripts/report-tools-2.test.tsscript16.1 KB
scripts/report-tools-3.test.tsscript9.3 KB
scripts/report-tools-4.test.tsscript10.1 KB
scripts/report-tools-5.test.tsscript14.6 KB
scripts/report-tools-commands.mjsscript12.9 KB
scripts/report-tools.mjsscript2.6 KB
scripts/report-tools.test.tsscript12.1 KB
scripts/sentence-split.mjsscript3.0 KB
scripts/sentence-split.test.tsscript4.5 KB
scripts/snapshot-readability.test.tsscript7.0 KB
scripts/source-commands.mjsscript12.4 KB
scripts/source-integrity.test.tsscript18.1 KB
scripts/source-refresh.mjsscript5.2 KB
scripts/source-snapshot.mjsscript9.9 KB
scripts/source-snapshot.test.tsscript6.3 KB
scripts/source-view.mjsscript5.0 KB
scripts/sources-citation.mjsscript12.1 KB
scripts/sources-citation.test.tsscript14.8 KB
scripts/tests/contracts-support.tsscript3.5 KB
scripts/tests/delivery-barrier-session.tsscript3.3 KB
scripts/tests/derive-clock.tsscript341 B
scripts/tests/fact-derive-support.tsscript1.9 KB
scripts/tests/fact-unit-dimensions-support.tsscript1.5 KB
scripts/tests/fact-unit-rules-support.tsscript16.8 KB
scripts/tests/fidelity-values-support.tsscript1.6 KB
scripts/tests/fixtures/assets/figure-1.svgother141 B
scripts/tests/fixtures/bad-report.htmlother2.1 KB
scripts/tests/fixtures/boxes.jsonconfig3.2 KB
scripts/tests/fixtures/conversion-probe.htmlother485 B
scripts/tests/fixtures/design-spec.mdmarkdown458 B
scripts/tests/fixtures/fidelity-brief-locked.mdmarkdown571 B
scripts/tests/fixtures/fidelity-brief-pending.mdmarkdown574 B
scripts/tests/fixtures/fidelity/assets/share.csvother40 B
scripts/tests/fixtures/fidelity/claim-graph.mdmarkdown449 B
scripts/tests/fixtures/fidelity/gen-legacy-dev.mjsscript5.0 KB
scripts/tests/fixtures/fidelity/ledger-basic.jsonconfig5.1 KB
scripts/tests/fixtures/fidelity/ledger-legacy-dev.jsonconfig18.3 KB
scripts/tests/fixtures/fidelity/ledger-verify.jsonconfig9.1 KB
scripts/tests/fixtures/fidelity/polish-edits.jsonconfig303 B
scripts/tests/fixtures/fidelity/report-bad.htmlother821 B
scripts/tests/fixtures/fidelity/report-good.htmlother2.4 KB
scripts/tests/fixtures/fidelity/sources/S4.htmlother680 B
scripts/tests/fixtures/fidelity/sources/S4/acronyms.jsonconfig36 B
scripts/tests/fixtures/fidelity/sources/S4/meta.jsonconfig256 B
scripts/tests/fixtures/fidelity/sources/S4/sentences.jsonlother623 B
scripts/tests/fixtures/fidelity/sources/S4/text.txtmarkdown300 B
scripts/tests/fixtures/fidelity/sources/S5/acronyms.jsonconfig3 B
scripts/tests/fixtures/fidelity/sources/S5/meta.jsonconfig235 B
scripts/tests/fixtures/fidelity/sources/S5/sentences.jsonlother53 B
scripts/tests/fixtures/fidelity/sources/S5/text.txtmarkdown10 B
scripts/tests/fixtures/fidelity/sources/S9.txtmarkdown128 B
scripts/tests/fixtures/good-report.htmlother2.7 KB
scripts/tests/fixtures/reference-report.htmlother2.5 KB

scripts/fidelity-value-unit.mjs

View on GitHub
// Value-mode units live outside the fact element. The documented form is the value then its unit,
// with or without a space, a Korean particle allowed after it ({{F1:span:value}} m, {{F3:rate:value}}%,
// {{F21:rev:value}}\uC5B5 \uC6D0\uC73C\uB85C); a currency sign right before the value; the :unit element
// right after it; or the same visual column's table header. A currency the element's own text carries (fill renders a
// prefix currency value from its raw text, $<data>$12</data>) binds too: every bound sign, outside or inside, must agree. Unknown words are advisory, never guessed units,
// unless fill recorded a bound unit for the value: then losing it is a unit edit.
import { cellsOf, rowsOf } from "./fact-locate.mjs"
import { unitKey } from "./fidelity-binding.mjs"
import { parseHtml, proseText } from "./html-lite.mjs"
import { NUMBER_SOURCE } from "./number-grammar.mjs"
import { QUALIFIERS_AFTER } from "./numerals.mjs"
import { dimensionOf, normalizeUnit, spacedAliasUnit } from "./units.mjs"

// Korean particles a unit may carry (eun/neun, i/ga, eul/reul, ui, e, eseo, ege, euro/ro, wa/gwa, do, man,
// kkaji, buteo, boda, ssik, in, ida/yeotda/ieotda, imyeo, igo), longest first.
const PARTICLES = [
  "\uC774\uC5C8\uB2E4",
  "\uC600\uB2E4",
  "\uC774\uB2E4",
  "\uC774\uBA70",
  "\uC774\uACE0",
  "\uC73C\uB85C",
  "\uC5D0\uC11C",
  "\uC5D0\uAC8C",
  "\uAE4C\uC9C0",
  "\uBD80\uD130",
  "\uBCF4\uB2E4",
  "\uC740",
  "\uB294",
  "\uC774",
  "\uAC00",
  "\uC744",
  "\uB97C",
  "\uC758",
  "\uC5D0",
  "\uB85C",
  "\uC640",
  "\uACFC",
  "\uB3C4",
  "\uB9CC",
  "\uC529",
  "\uC778",
]
/** The displayed value, read with the one grouped-number grammar; text around it is sign and unit. */
const NUMBER = new RegExp(NUMBER_SOURCE, "u")
const SIGNS = ["US$", "$", "\u20AC", "\u20A9", "\u00A3", "\u00A5", "USD", "EUR", "GBP", "JPY", "KRW"]

const withoutSuffix = (word, suffixes) => {
  const suffix = suffixes.find((cur) => word.endsWith(cur) && word.length > cur.length)
  return suffix ? word.slice(0, -suffix.length) : word
}
const withoutParticle = (word) => withoutSuffix(word, PARTICLES)
/** Words written after a value that bound or soften it (the numeral qualifiers, jeongdo, garyang, jjeum, gwaban). */
const QUALIFIER_WORDS = [...QUALIFIERS_AFTER, "\uC815\uB3C4", "\uAC00\uB7C9", "\uCBE4", "\uACFC\uBC18"]
/** A unit, with a particle and/or a qualifier glued on ("m\uC774\uC0C1\uC758"); a whole qualifier word is never a unit (chogwa is not cho + gwa). */
const stemsOf = (word) => {
  const bare = withoutParticle(word)
  return QUALIFIER_WORDS.includes(word)
    ? []
    : [word, bare, withoutSuffix(word, QUALIFIER_WORDS), withoutSuffix(bare, QUALIFIER_WORDS)].filter(
        (stem) => !QUALIFIER_WORDS.includes(stem),
      )
}
const stemOf = (word) => stemsOf(word).find((stem) => normalizeUnit(stem)) ?? null
const unitOf = (word) => normalizeUnit(stemOf(word))
/** Unit aliases that are also ordinary English words ("won awards", "second place"): read only as the row's own unit. */
const ORDINARY_WORDS = new Set(["won", "second", "pound", "pounds"])
/** An ordinary word, or an all-caps acronym that only matches a unit case-insensitively ("SEC filings", "WON"). */
const ordinary = (word) =>
  ORDINARY_WORDS.has(word.toLowerCase()) || (/^[A-Z]{3,}$/.test(word) && normalizeUnit(word) !== word)
/** Inline elements the text after a value is read through; any other element, or another fact, ends it. */
const INLINE = new Set([
  "a",
  "abbr",
  "b",
  "bdi",
  "cite",
  "code",
  "data",
  "dfn",
  "em",
  "i",
  "ins",
  "kbd",
  "mark",
  "samp",
  "small",
  "span",
  "strong",
  "sub",
  "sup",
  "time",
  "u",
  "var",
])
/** "3 bun-ui 1" is the fraction one third, not 3 minutes. */
const FRACTION = /^\uBD84\uC758\s?\d/u
const scaleOf = (unit) => /-(e\d+)$/.exec(unit ?? "")?.[1] ?? null

/** English words stay apart: letter-only words join only as a spaced alias ("percentage points"), so "m in" is m, then in. */
const LETTERS = /^[A-Za-z]+$/u
/** The unit the words spell together: a spaced alias, or (with a symbol or Hangul in them) the words joined ("% p", "\uD37C\uC13C\uD2B8 \uD3EC\uC778\uD2B8"). */
function unitOfWords(words) {
  if (words.length === 1) return unitOf(words[0])
  const spaced = stemsOf(words.at(-1))
    .map((last) => spacedAliasUnit([...words.slice(0, -1), last].join(" ")))
    .find(Boolean)
  return spaced ?? (words.every((word) => LETTERS.test(word)) ? null : unitOf(words.join("")))
}

/** The unit written right after the value: the longest known unit its first words spell ("% \uD3EC\uC778\uD2B8" is %p, not %), else the next word. */
function unitAfter(text, row) {
  const lead = text.replace(/^[\s\u00A0]+/u, "")
  if (FRACTION.test(lead)) return null
  const bracketed = /^\(([^()]{1,40})\)/u.exec(lead)
  if (bracketed) return unitAfter(bracketed[1], row)
  const clause = lead.split(/[,.;:!?()[\]"]/u)[0]
  const words = clause
    .split(/[\s\u00A0]+/u)
    .filter(Boolean)
    .slice(0, 3)
  if (words.length === 0) return null
  for (let n = words.length; n > 1; n--) {
    const unit = unitOfWords(words.slice(0, n))
    if (unit) return { token: unit }
  }
  const first = unitOf(words[0])
  if (!first) return null
  // An ordinary word ("pounds", "won awards") counts only as the row's unit or beside a sign or header of its kind (boundUnits).
  if (unitKey(first) !== unitKey(row.unit) && ordinary(stemOf(words[0]))) return { token: first, ordinary: true }
  const currency = words[1] ? unitOf(words[1]) : null
  if (dimensionOf(first) === "scale" && dimensionOf(currency)?.startsWith("currency:"))
    return { token: `${currency} ${words[0]}`, dimension: dimensionOf(currency), scale: first }
  return { token: first }
}

function signBefore(text) {
  const trimmed = text.replace(/[\s\u00A0]+$/u, "")
  // A letter sign is a whole word: "USD 12", never "XUSD 12".
  const sign = SIGNS.find(
    (s) => trimmed.endsWith(s) && !(/^[A-Z]/u.test(s) && /[A-Za-z]$/u.test(trimmed.slice(0, -s.length))),
  )
  return sign ? { token: normalizeUnit(sign), sign: true } : null
}

/** A currency written after the number inside the element ("12\u20AC", "12\uC6D0"); any other unit there is part of the value. */
function currencyAfter(text, row) {
  const found = unitAfter(text, row)
  const dimension = found && !found.ordinary ? (found.dimension ?? dimensionOf(found.token)) : null
  return dimension?.startsWith("currency:")
    ? { token: found.scale ? dimension.slice("currency:".length) : found.token, sign: true }
    : null
}

function agrees(found, row) {
  if (found.scale) return dimensionOf(row.unit) === found.dimension && scaleOf(row.unit) === found.scale
  if (unitKey(found.token) === unitKey(row.unit)) return true
  if (dimensionOf(found.token) === "scale") return scaleOf(row.unit) === found.token
  if (dimensionOf(found.token)?.startsWith("currency:") && found.sign)
    return dimensionOf(row.unit) === dimensionOf(found.token)
  return unitKey(found.token) === unitKey(row.unit)
}

const closest = (node, test) => {
  for (let cur = node.parent; cur; cur = cur.parent) if (test(cur)) return cur
  return null
}
/** All text under a node, code included: a unit may be set in code ("320 <code>ms</code>"). */
const plainText = (node) => (node.tag === "#text" ? node.text : node.children.map(plainText).join(""))

/** A column-header row: a thead row or a row made only of th cells. A th first in a body row is a row header. */
const isHeaderRow = (row) =>
  row.parent?.tag === "thead" || (cellsOf(row).length > 0 && cellsOf(row).every((cur) => cur.tag === "th"))

/** The header of the cell's visual column; nothing binds in a table with a rowspan or without a header row. */
function headerUnit(node) {
  const cell = closest(node, (cur) => cur.tag === "td")
  const table = cell && closest(cell, (cur) => cur.tag === "table")
  if (!table || cell.attrs.colspan || cell.attrs.rowspan) return null
  const rows = rowsOf(table)
  if (rows.some((row) => row.children.some((cur) => cur.attrs?.rowspan && cur.attrs.rowspan !== "1"))) return null
  const header = rows.find(isHeaderRow)
  if (!header || header === cell.parent) return null
  const head = cellsOf(header)[cellsOf(cell.parent).indexOf(cell)]
  if (!head) return null
  const text = proseText(head)
  const label = (/\(([^()]+)\)\s*$/u.exec(text)?.[1] ?? text).trim()
  const unit = unitOf(label) ?? unitOf(label.split(/\s+/u).at(-1) ?? "")
  return unit ? { token: unit } : null
}

/** The documented split form: the next element is this fact's own :unit element. */
function unitElementAfter(siblings, at, row) {
  const next = siblings.slice(at + 1).find((cur) => !(cur.tag === "#text" && !cur.text.trim()))
  return next?.attrs?.["data-fact"] === row.fact_id && unitKey(proseText(next)) === unitKey(row.unit)
}

/** The text after the element within its block, read through inline wrappers and line breaks ("320 <b>m</b>", "<b>320</b> m", "320<br>m"). */
function textAfter(node) {
  let text = ""
  for (let cur = node; text.length < 80;) {
    const next = cur.parent?.children[cur.parent.children.indexOf(cur) + 1]
    if (next === undefined) {
      if (!INLINE.has(cur.parent?.tag) || cur.parent.attrs["data-fact"] !== undefined) break
      cur = cur.parent
    } else if (
      next.tag === "#text" ||
      next.tag === "br" ||
      (INLINE.has(next.tag) && next.attrs["data-fact"] === undefined)
    ) {
      text += next.tag === "br" ? "\n" : plainText(next)
      cur = next
    } else break
  }
  return text
}

const INSIDE = "written inside with"
/**
 * Every unit bound to a value-mode element: a currency sign before it, the unit after it (or its :unit element), its
 * column header, and a currency sign or word inside it (prefix or suffix of the number).
 */
function boundUnits(node, row) {
  const siblings = node.parent.children
  const at = siblings.indexOf(node)
  const prev = siblings[at - 1]
  const shown = proseText(node)
  const number = NUMBER.exec(shown)
  const before = signBefore(prev?.tag === "#text" ? prev.text : "")
  // The element's own text is the row's render: a scale word in it ("3,234\uC5B5", "12 million") is part of the value.
  const inside = number
    ? [signBefore(shown.slice(0, number.index)), currencyAfter(shown.slice(number.index + number[0].length), row)]
    : []
  const read = unitAfter(textAfter(node), row) ?? (unitElementAfter(siblings, at, row) ? { token: row.unit } : null)
  const header = headerUnit(node)
  const kind = (unit) => dimensionOf(unit.token)?.split(":")[0]
  const after =
    read?.ordinary && ![before, ...inside, header].some((unit) => unit && kind(unit) === kind(read)) ? null : read
  return [
    ["preceded by", before],
    ["followed by", after],
    ["headed with", header],
    ...inside.map((unit) => [INSIDE, unit]),
  ].filter(([, unit]) => unit)
}

/** Each data-fact element's own fill-map entry: fill writes one element per entry, so ids pair up in document order. */
export function fillEntriesByNode(nodes, entries) {
  const queues = new Map()
  for (const entry of entries ?? [])
    if (entry.replaced === undefined && entry.translates === undefined)
      queues.set(entry.fact_id, [...(queues.get(entry.fact_id) ?? []), entry])
  return new Map(
    nodes
      .filter((node) => node.attrs["data-replaced"] === undefined)
      .flatMap((node) => {
        const entry = queues.get(node.attrs["data-fact"])?.shift()
        return entry ? [[node, entry]] : []
      }),
  )
}

/** Fill's record of the unit bound to each value-mode pointer (unit_bound), read off the filled edition (HTML, or the Markdown projection). */
export function withBoundUnits(html, entries, rows) {
  const all = (node) => [node, ...node.children.flatMap(all)]
  const filled = fillEntriesByNode(
    all(parseHtml(html)).filter((node) => node.attrs?.["data-fact"] !== undefined),
    entries,
  )
  const units = new Map(
    [...filled].flatMap(([node, entry]) => {
      const row = rows.get(entry.fact_id)
      // Only a unit outside the element: the element's own text is the row's render, so it can be no record of a unit beside it.
      const unit =
        entry.mode === "value" && row && unitKey(row.unit)
          ? boundUnits(node, row).find(([where]) => where !== INSIDE)?.[1].token
          : null
      return unit ? [[entry, unit]] : []
    }),
  )
  return entries.map((entry) => (units.has(entry) ? { ...entry, unit_bound: units.get(entry) } : entry))
}

/**
 * Value mode comes from fill: the element's data-fact-mode, or its fill-map entry when the edition has one
 * (so deleting the attribute changes nothing). `entry.unit_bound` is the unit fill saw bound to the value.
 */
export function valueUnitProblem(node, row, entry = null) {
  if ((entry?.mode !== "value" && node.attrs["data-fact-mode"] !== "value") || !unitKey(row.unit)) return null
  const found = boundUnits(node, row)
  if (entry?.unit_bound && found.every(([where]) => where === INSIDE))
    return [
      "unit_mismatch",
      `value-mode ${row.fact_id} had the unit "${entry.unit_bound}" beside it when filled, but no recognizable unit is bound beside it now; its row is in "${row.unit}"`,
    ]
  if (found.length === 0)
    return [
      "unit_unbound",
      `${row.fact_id} has unit "${row.unit}" but no recognizable unit right after its value, before it as a currency sign, or in its column header`,
    ]
  const wrong = found.find(([, unit]) => !agrees(unit, row))
  return wrong
    ? ["unit_mismatch", `value-mode ${row.fact_id} is ${wrong[0]} "${wrong[1].token}", but its row is in "${row.unit}"`]
    : null
}
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall