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/fact-unit-rules.test.ts

View on GitHub
import { describe, expect, test } from "bun:test"
import { display, recompute } from "./fact-derive.mjs"
import { derive } from "./tests/derive-clock"
import { parseExpr } from "./fact-expr.mjs"
import { addRow, emptyLedger, OPERATIONS } from "./fact-ledger.mjs"
import { canonicalUnit, expectedUnit, isAffine, OPERATION_RULES, renderPrecision } from "./unit-rules.mjs"
import {
  Row,
  Ledger,
  Spec,
  HASH,
  measured,
  ledger,
  PCT_SUM,
  VALID,
  PRECISION,
  RELABELS,
  Mutation,
  generic,
  repeatFirst,
  operands,
  MALFORMED,
  REPEATED,
  rowOf,
  relabel,
  OPS,
} from "./tests/fact-unit-rules-support"

test("the case tables cover exactly the registry's operations, which are the ledger schema's operations", () => {
  expect([...OPS].sort()).toEqual([...OPERATIONS].sort())
  for (const table of [VALID, MALFORMED]) expect(Object.keys(table).sort()).toEqual([...OPS].sort())
})

describe.each(OPS)("%s", (op) => {
  test("valid typed operands derive, and the stored row recomputes ok", () => {
    for (const { spec, unit } of VALID[op]) {
      const book = ledger()
      const row = rowOf(derive(book, spec))
      expect(row.unit).toBe(unit)
      expect(recompute(book, row)).toMatchObject({ ok: true })
    }
  })

  test("every other unit, alias, or null is a relabel: recompute names the expected unit and derive refuses it", () => {
    for (const { spec, unit } of VALID[op]) {
      const book = ledger()
      const row = rowOf(derive(book, spec))
      for (const other of RELABELS.filter((candidate) => candidate !== unit)) {
        const [plain, ...withContext] = relabel(row, other)
        const result = recompute(book, plain)
        expect({ other, ok: result.ok }).toEqual({ other, ok: false })
        expect(result.detail).toContain(`expected unit ${JSON.stringify(unit)}`)
        for (const variant of withContext) {
          // A rewritten convert target is ok only when it is exactly the row an honest derive to that target writes
          // (0 m to cm is 0 cm); an alias target, or any other rewrite, is ok:false.
          const honest = op === "convert" ? derive(ledger(), { ...spec, to: other }).row : undefined
          const consistent =
            honest !== undefined &&
            ["unit", "exact", "value", "render", "formula", "factor", "precision", "compatibility"].every(
              (key) => JSON.stringify(honest[key]) === JSON.stringify(variant[key]),
            )
          const rewritten = recompute(book, variant)
          expect({ other, context: variant.context, ok: rewritten.ok }).toEqual({
            other,
            context: variant.context,
            ok: consistent,
          })
        }
        const declared = derive(ledger(), { ...spec, unit: other })
        if (other !== "bp" && canonicalUnit(other) === unit) expect(declared.row?.unit).toBe(unit)
        else expect({ other, error: declared.error }).toEqual({ other, error: "incompatible_operands" })
      }
    }
  })

  test("render precision follows invariant 5: sum, diff, a +/- expr root, and %p by decimal places; the rest by significant figures", () => {
    for (const { spec, unit, precision } of VALID[op]) {
      const row = rowOf(derive(ledger(), spec))
      const ast = op === "expr" ? parseExpr(spec.formula) : null
      expect({ spec, precision: renderPrecision(op, row.unit, ast) }).toEqual({
        spec,
        precision: precision ?? PRECISION[op],
      })
    }
  })

  test("the malformed cases are exactly the registry's malformed shapes", () => {
    expect(MALFORMED[op].map((mutation) => mutation.name).sort()).toEqual([...OPERATION_RULES[op].malformed].sort())
  })

  test("operand identity: derive refuses a repeated operand id; only expr may repeat an id, and only inside its formula", () => {
    const spec = REPEATED[op]
    const result = derive(ledger(), spec)
    if (op === "expr") {
      expect(rowOf(result).operands).toEqual(["F1", "F2"])
      return
    }
    expect({ error: result.error, detail: result.detail }).toEqual({
      error: "incompatible_operands",
      detail: expect.stringContaining("is repeated"),
    })
  })

  test("each malformed shape is ok:false for its own reason and never throws", () => {
    for (const { name, base, mutate, reason } of MALFORMED[op]) {
      const book = ledger()
      const row = rowOf(derive(book, base))
      let result: { ok: boolean; detail?: string } = { ok: true }
      expect(() => {
        result = recompute(book, mutate(row, book))
      }).not.toThrow()
      expect({ name, ok: result.ok }).toEqual({ name, ok: false })
      expect(result).toMatchObject({ shape: expect.any(String), expected: expect.anything() })
      expect({ name, detail: result.detail }).toEqual({ name, detail: expect.stringContaining(reason) })
    }
  })
})

describe("units", () => {
  test("aliases canonicalize at input and composites cancel", () => {
    expect(canonicalUnit("pp")).toBe("%p")
    expect(canonicalUnit("bp")).toBe("%p")
    expect(canonicalUnit("kilometre")).toBe("km")
    expect(canonicalUnit("USD/(USD/person)")).toBe("person")
    expect(canonicalUnit("USD / kg")).toBe("USD/kg")
    expect(canonicalUnit("m/m")).toBeNull()
    expect(canonicalUnit(null)).toBeNull()
    expect(isAffine("C")).toBe(true)
    expect(isAffine("F")).toBe(true)
    expect(isAffine("m")).toBe(false)
  })

  test("unit text with no registered alias is stored as given, inner whitespace kept", () => {
    expect(canonicalUnit("USD / million people")).toBe("USD/million people")
    for (const unit of ["million people", "metric ton", "USD per person"]) {
      expect(canonicalUnit(` ${unit} `)).toBe(unit)
      const book = emptyLedger() as Ledger
      addRow(book, measured("F1", "5", unit))
      addRow(book, measured("F2", "7", unit))
      const row = rowOf(derive(book, { op: "sum", operands: ["F1", "F2"], unit }))
      expect(row).toMatchObject({ unit, render: `12 ${unit}` })
      expect(recompute(book, row)).toMatchObject({ ok: true })
    }
  })

  test("review r6 LOW 2: a scale word is never a unit atom; plain unit text that contains one is stored as given", () => {
    for (const unit of ["million", "M", "bn", "billion", "e6", "thousand", "USD/M", "million*person"]) {
      expect(() => canonicalUnit(unit)).toThrow("scale word")
      const book = emptyLedger() as Ledger
      expect(() => addRow(book, measured("F1", "5", unit))).toThrow("scale word")
      addRow(book, measured("F1", "5", "m"))
      addRow(book, measured("F2", "7", "m"))
      book.rows[0].unit = unit
      const result = derive(book, { op: "sum", operands: ["F1", "F2"], unit: "m" })
      expect({ unit, error: result.error, detail: result.detail }).toEqual({
        unit,
        error: "incompatible_operands",
        detail: expect.stringContaining("scale word"),
      })
    }
    expect(canonicalUnit("million people")).toBe("million people")
  })

  test("expectedUnit is the registry's answer for stored operand rows", () => {
    const book = ledger()
    const rows = (ids: string[]) => ids.map((id) => book.rows.find((row) => row.fact_id === id) as Row)
    expect(expectedUnit("diff", rows(["F3", "F4"]), {})).toBe("%p")
    expect(expectedUnit("ratio", rows(["F10", "F11"]), {})).toBe("person")
    expect(expectedUnit("convert", rows(["F12"]), { context: { target: "km" } })).toBe("km")
  })

  test("nested derived operands are verified recursively; a cycle is refused", () => {
    const book = ledger()
    const inner = rowOf(derive(book, { op: "sum", operands: ["F1", "F2"], unit: "m" }))
    const outer = rowOf(derive(book, { op: "convert", operands: [inner.fact_id as string], to: "km" }))
    expect(recompute(book, outer).ok).toBe(true)
    inner.exact = { num: "5", den: "1" }
    const tampered = recompute(book, outer)
    expect(tampered.ok).toBe(false)
    expect(tampered.detail).toContain(String(inner.fact_id))
    const a = { ...inner, fact_id: "F90", label: "cycle-a", operands: ["F91", "F1"], exact: { num: "4", den: "1" } }
    const b = { ...inner, fact_id: "F91", label: "cycle-b", operands: ["F90", "F1"], exact: { num: "4", den: "1" } }
    book.rows.push(a, b)
    let cycle: { ok: boolean; detail?: string } = { ok: true }
    expect(() => {
      cycle = recompute(book, a)
    }).not.toThrow()
    expect(cycle.ok).toBe(false)
    expect(cycle.detail).toContain("cycle")
    const through = derive(book, { op: "sum", operands: ["F90", "F2"], unit: "m" })
    expect({ error: through.error, detail: through.detail }).toEqual({
      error: "incompatible_operands",
      detail: expect.stringContaining("cycle"),
    })
    const self = { ...inner, fact_id: "F92", label: "self", operands: ["F92", "F1"] }
    book.rows.push(self)
    expect(recompute(book, self)).toMatchObject({ ok: false, detail: expect.stringContaining("cites itself") })
    const onSelf = derive(book, { op: "convert", operands: ["F92"], to: "km" })
    expect({ error: onSelf.error, detail: onSelf.detail }).toEqual({
      error: "incompatible_operands",
      detail: expect.stringContaining("cites itself"),
    })
  })
})
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