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-originals.mjs

View on GitHub
// Check displayed conversion originals against their operands, not the mutable render field.
import { sameValue, unitKey } from "./fidelity-binding.mjs"
import { proseText } from "./html-lite.mjs"
import { parseNumeral } from "./numerals.mjs"
import { normalizeText } from "./text-normalize.mjs"
import { display } from "./unit-precision.mjs"
import { dimensionOf } from "./units.mjs"

const DERIVED = new Set(["converted", "derived"])
/**
 * The one bracket grammar of the skill. After NFKC (fullwidth parentheses and square brackets fold
 * to ASCII), an original is a () [] 【】 「」 or 〔〕 group. Inside a derived or converted element every
 * group is an original, never prose; a dash separator is not an original.
 */
const PAIRS = [
  ["(", ")"],
  ["[", "]"],
  ["\u3010", "\u3011"],
  ["\u300C", "\u300D"],
  ["\u3014", "\u3015"],
]
const [OPEN, CLOSE] = [PAIRS.map((pair) => pair[0]).join(""), PAIRS.map((pair) => pair[1]).join("")]
const inClass = (chars) => chars.replace(/[\\\]\[^-]/g, "\\$&")
const literal = (chars) => chars.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
const ANY = inClass(OPEN + CLOSE)
const GROUP = new RegExp(PAIRS.map(([open, close]) => `${literal(open)}([^${ANY}]*)${literal(close)}`).join("|"), "gu")
const BRACKET = new RegExp(`[${ANY}]`, "u")
const folded = (text) => String(text).normalize("NFKC")
const innerOf = (match) => match.slice(1).find((part) => part !== undefined)
const mismatch = (message) => ["value_mismatch", message, "original"]

const halfFits = (row, half) => {
  const expected = normalizeText(folded(display(String(row.value), row.unit ?? null)))
  const text = normalizeText(half)
  return text === expected || (text.endsWith(` ${expected}`) && !/\d/.test(text.slice(0, -expected.length)))
}

/** The converted half (the text outside the originals) equals display(row.value, row.unit), rebuilt from the row. */
export function convertedHalfFits(row, shown) {
  if (!DERIVED.has(row.kind) || row.value === null || row.value === undefined) return false
  return halfFits(row, folded(shown).replace(GROUP, ""))
}

/** A second number outside the value verify reads and its originals ("320,000 mm - 999 m"). */
function strayNumber(row, half) {
  if (row.value === null || row.value === undefined || halfFits(row, half)) return null
  const read = parseNumeral(half)
  if (!read || !sameValue(read.value, row.value)) return null
  const rest = half.slice(0, read.span[0]) + half.slice(read.span[1])
  return /\d/.test(row.unit ? rest.split(row.unit).join("") : rest)
    ? mismatch(`"${half.trim()}" carries a number besides the value and its originals`)
    : null
}

/** `valueMode`: the element shows the bare value ({{F:x:value}}), so no original is due. */
export function originalProblem(row, shown, rows, valueMode = false) {
  if (!DERIVED.has(row.kind)) return null
  const text = folded(shown)
  const groups = [...text.matchAll(GROUP)]
  const half = text.replace(GROUP, "")
  if (BRACKET.test(half)) return mismatch("original brackets are malformed or nested")
  const operands = (row.derived_from ?? []).map((id) => rows.get(id))
  for (const [index, match] of groups.entries()) {
    const [inner, operand] = [innerOf(match), operands[index]]
    const parsed = parseNumeral(inner)
    if (!operand) return mismatch(`original "${inner}" has no operand of ${row.fact_id}`)
    if (!parsed || !sameValue(parsed.value, operand.value))
      return mismatch(`original "${inner}" differs from operand ${operand.fact_id}`)
    if (unitKey(parsed.unitRaw ?? "") !== unitKey(operand.unit ?? ""))
      return ["unit_mismatch", `original "${inner}" is not in ${operand.unit}`, "original"]
    const expected = normalizeText(folded(display(operand.value, operand.unit ?? null)))
    if (normalizeText(inner) !== expected) return mismatch(`original "${inner}" differs from "${expected}"`)
  }
  if (groups.length > 0 && !/\d/.test(text.slice(0, groups[0].index)))
    return mismatch(`original "${innerOf(groups[0])}" precedes the value`)
  if (row.kind === "converted" && !valueMode && /\d/.test(half) && groups.length < operands.length)
    return mismatch(`the original of ${row.derived_from[groups.length]} is missing after the value`)
  return strayNumber(row, half)
}

/** Stands for a filled element or another fill-map value in the text after a fill site. */
const FILLED = "\uFFFC"
/** After a fill site the grammar also reads the brackets an element never carries as originals. */
const FOLLOW = [...PAIRS, ["\u300E", "\u300F"], ["\u300A", "\u300B"], ["\u3008", "\u3009"], ["\u27E8", "\u27E9"]]
const dimension = (unit) => dimensionOf(String(unit).replace(/-e\d+$/u, "")) ?? unitKey(unit)

/** What the text after a fill site opens: a bracket group's content, or the clause after a separator (`open`); else null. */
function openedGroup(text) {
  const rest = folded(text).trimStart()
  const pair = FOLLOW.find(([open]) => rest.startsWith(open))
  const close = pair ? rest.indexOf(pair[1], 1) : -1
  if (pair) return { group: rest.slice(1, close === -1 ? undefined : close).trim(), open: false }
  return /^[-\u2013\u2014/]/u.test(rest)
    ? {
        group: rest
          .slice(1)
          .split(/[,;:!?)\]]|\.(?!\d)/u)[0]
          .trim(),
        open: true,
      }
    : null
}

/**
 * Whether the text right after a fill site of `row` opens another original: a bracket group or a
 * separator clause that is exactly a numeral with a unit of the row's or an operand's dimension (a
 * separator clause may end in a glued particle, as Korean writes "- 999 m\uC774\uB2E4").
 * A filled element, a fill-map value (`fills`), a placeholder, a unitless number (a year, a
 * footnote) and prose with digits are not originals; untraceable_number still reads a stray number.
 */
export const followsOriginal =
  (row, rows, fills = []) =>
  (text) => {
    if (!DERIVED.has(row?.kind)) return false
    const after = [...fills]
      .filter(Boolean)
      .sort((a, b) => b.length - a.length)
      .reduce((cur, fill) => cur.split(fill).join(FILLED), String(text))
    const { group, open } = openedGroup(after) ?? { group: "" }
    if (!group || group.includes(FILLED) || group.includes("{{")) return false
    const units = [row.unit, ...(row.derived_from ?? []).map((id) => rows.get(id)?.unit)].filter(Boolean)
    return [group, ...(open ? [group.replace(/[\uAC00-\uD7A3]+$/u, "").trim()] : [])].some((body) => {
      const read = parseNumeral(body, 0)
      return (
        Boolean(read?.unitRaw) &&
        read.span[0] === 0 &&
        read.span[1] === body.length &&
        units.some((unit) => dimension(unit) === dimension(read.unitRaw))
      )
    })
  }

/** The prose after `node` in its parent, each filled element (data-fact) read as one FILLED mark. */
export const textAfter = (node) => {
  const siblings = node.parent?.children.slice(node.parent.children.indexOf(node) + 1) ?? []
  return proseText({
    children: siblings.map((child) =>
      child.attrs?.["data-fact"] === undefined ? child : { tag: "#text", text: FILLED },
    ),
  })
}

const SPACE = "[\\s\\u3000]"
const DIGIT = "[0-9\\uFF10-\\uFF19]"
/** Each character with the fullwidth form NFKC folds onto it. */
const wide = (chars) =>
  [...chars].map((ch) => ch + (/[!-~]/.test(ch) ? String.fromCharCode(ch.charCodeAt(0) + 0xfee0) : "")).join("")
const [WIDE_OPEN, WIDE_CLOSE] = [inClass(wide(OPEN)), inClass(wide(CLOSE))]

/** A pattern reading `rendered` modulo the bracket grammar: NFKC fullwidth forms, bracket style, spacing around brackets. */
function renderPattern(rendered) {
  const text = folded(rendered).trim()
  let body = ""
  for (let at = 0; at < text.length; at += 1) {
    const ch = text[at]
    const beside = (OPEN + CLOSE).includes(text.slice(at).trimStart()[0]) || OPEN.includes(text[at - 1])
    if (/\s/.test(ch)) body += beside ? "" : `${SPACE}+`
    else if (OPEN.includes(ch)) body += `${SPACE}*([${WIDE_OPEN}])${SPACE}*`
    else if (CLOSE.includes(ch)) body += `${SPACE}*([${WIDE_CLOSE}])`
    else body += `[${inClass(wide(ch))}]`
  }
  // A digit may not run into a render's leading or trailing digit ("1,320 m" holds no "320 m"); a bracket ends the render.
  return new RegExp(`${/^\d/.test(text) ? `(?<!${DIGIT})` : ""}${body}${/\d$/.test(text) ? `(?!${DIGIT})` : ""}`, "gu")
}

const pairIndex = (ch, side) => [...side].findIndex((open) => open === folded(ch))
/** [start, end) of `rendered` in `text` from `from` under the bracket grammar, not followed by another original (`follows`); or null. */
export function findRender(text, rendered, from = 0, follows = () => false) {
  const pattern = renderPattern(rendered)
  pattern.lastIndex = from
  for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
    const marks = match.slice(1)
    const paired = marks.every(
      (mark, i) => i % 2 === 1 || pairIndex(mark, OPEN) === pairIndex(marks[i + 1] ?? "", CLOSE),
    )
    const end = match.index + match[0].length
    if (paired && !follows(text.slice(end))) return [match.index, end]
    pattern.lastIndex = match.index + 1
  }
  return null
}

/** Where a stale fill-map entry's text sits: derived and converted renders are read under the bracket grammar. */
export const renderLocator = (rows, fillMap) => (entry, text, from) => {
  const row = rows.get(entry.fact_id)
  if (DERIVED.has(row?.kind))
    return findRender(
      text,
      entry.rendered,
      from,
      followsOriginal(
        row,
        rows,
        (fillMap ?? []).map((other) => other.rendered),
      ),
    )
  const hit = text.indexOf(entry.rendered, from)
  return hit === -1 ? null : [hit, hit + entry.rendered.length]
}

/** Null when a stale derived render is still in the report; "original" when only its converted half is; "gone" otherwise. */
export function staleRender(row, rendered, text, follows) {
  if (findRender(text, rendered, 0, follows) !== null) return null
  const half = folded(rendered).replace(GROUP, "").trim()
  return half !== "" && /\d/.test(half) && findRender(text, half) !== null ? "original" : "gone"
}

export const isDerivedRow = (row) => DERIVED.has(row?.kind)
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