oh-my-opencode 5.1.48 → 5.1.51

package/packages/shared-skills/skills/ulw-research/references/research-delivery.md

@@ -0,0 +1,123 @@
+## Phase 3 — Verify contested claims by running code
+
+Settle with executed code, not judgment, whenever sources disagree, a behavior is undocumented, a claim is performance- or compatibility-shaped, or the honest answer is "it should work". Spawn one verification worker per claim:
+
+```
+task(category="deep-low", run_in_background=true, prompt="TASK: verify by execution: <claim>.
+SOURCE: <where it came from>; CONTRADICTION: <opposing source, if any>.
+Write a minimal self-contained script that tests the claim; run it (uv run --with <deps> python / bun / direct compile); capture full stdout+stderr; pin versions.
+Reply with: the exact code, the full output, environment (OS, runtime, dependency versions), and a verdict — CONFIRMED / REFUTED / PARTIAL — grounded in the output.")
+```
+
+Journal each verdict to `verify-<slug>.md`.
+
+## Phase 3b — Lock non-code claims through the claim graph
+
+Code settles code-shaped claims (Phase 3). Numeric, market-share, legal, dated, causal, and financial claims cannot be run — so they pass through a data-flow-lock instead (the verification idea adapted from fivetaku/insane-research): the synthesis may assert a high-risk non-code claim **only** if it cleared this gate, and the gate's output is the sole allowlist the synthesis draws from. Skip the gate and there is nothing to synthesize — the lock is self-enforcing.
+
+The claim graph is orchestrator-owned. Workers only return verified-claim markers, observation candidates, and claim candidates as message text, the same channel as EXPAND markers — never a file (except a mass-research dag node's handoff file). As leads resolve, you record one node per asserted claim in `claim-graph.md` and compute its status; workers report claim candidates in their replies, and you decide. The graph is the single claim store: final synthesis may not draw from free-form claims that skipped it.
+
+A high-risk claim clears the gate to `verified-claims` only when all hold:
+
+- **>= 2 independent source domains** corroborate it (two pages on the same domain count once).
+- **>= 2 independent observation groups** converge on it, unless the graph records why a primary-only source is the correct single-source exception.
+- **One counter-search** actively looked for a refutation and did not find a stronger one.
+- **A primary source** (the standard, filing, dataset, or first-party doc) backs it, not only secondary commentary.
+- **Temporal evidence is explicit**: each supporting observation records `observed_at` and either `valid_at` or `claim_valid_at`, so branch-only, historical, release, and current-runtime claims cannot be conflated.
+
+Anything that fails goes to an `Unresolved` (insufficient evidence) or `Refuted` (counter-search won) annex — abstention is a correct outcome, not a gap to paper over. Record each gate outcome on the claim node itself — risk tier, independent source domains, counter-search result, primary source backing, and status — and mirror the cleared nodes into the `verified-claims` digest section at the top of `claim-graph.md`. Worker reply marker (message text, same channel as EXPAND):
+
+```
+## CLAIMS
+- CLAIM: <non-code assertion> — RISK: high|normal — SOURCES: <domain1, domain2> — COUNTER: <refutation search result> — PRIMARY: <primary source or none>
+```
+
+**The claim table is machine-read.** Keep the nodes of `claim-graph.md` in one Markdown table whose header names `claim_id | statement | risk tier | status` (plus `fact_ids`, the ledger rows the node rests on, and any other node fields as further columns), one row per node: ids `C<n>`, risk `high` or `normal`, status `supported`, `partial`, `refuted`, or `unresolved`. List the nodes that clear the Phase 3b gate under a `## verified-claims` heading as `- C<n>: <statement>`. `node "$SKILL_DIR/scripts/report-tools.mjs" claims index "$SESSION_DIR/claim-graph.md" --out "$SESSION_DIR/claims.json"` indexes it, and the fidelity gate reads `claims.json` to check every `data-claim` binding in the report.
+
+## Phase 4 — Synthesize
+
+After convergence and all verifications, re-read the whole journal, start from `intent-diff.md`, `claim-graph.md`, and `observation-manifest.md`, then write `SYNTHESIS.md`:
+
+```
+# ULW-Research Synthesis: <query>
+Workers: <total> · Waves: <count> · Excursions: <count> · Sources: <count> (<unique domains> domains) · Verifications: <count> · Elapsed: <minutes> min
+
+## Executive summary        — 2-3 paragraphs answering the core question
+## Findings by theme        — per theme: consensus, evidence links, key quote (<20 words, attributed), verified yes/no
+## Codebase findings        — absolute paths with line references
+## Sources (ranked)         — URL, what it contains, reliability, access date
+## Verified claims          — code: claim | verdict | verify-<slug>.md · non-code: only rows cleared into verified-claims
+## Epistemic instrumentation — intent-vs-reality diff closure, claim graph coverage, observation manifest coverage, independent-observation convergence, verification economics summary, cause-disappearance records
+## Contradictions           — source A vs source B, resolution with evidence
+## Gaps                     — what saturation could not answer · unresolved/refuted claim-graph nodes
+## Expansion trace          — per wave: workers → markers; convergence reason
+```
+
+`SYNTHESIS.md` is the citation source of truth for final materials: every claim carries inline `[Source N]` citations, and every high-risk non-code claim you assert must be a verified-claims row from Phase 3b. Assert nothing the gate left in the unresolved/refuted annex.
+
+**Write numbers and quotes by reference.** `SYNTHESIS.md` and every report source carry placeholders, never typed values: `{{F12:span_len}}` renders the row's value and unit, `{{F12:span_len:value}}` or `:unit` one part, `:q` the value with its source qualifier (up to, at least, about); `{{Q7:completion}}` renders the whole quotation, `{{Q7:completion:lead=8}}` its first words, `{{Q7:completion:from="no earlier":to="2027"}}` one span of it. A derived number is computed by the script, never by hand: `fact derive --op sum|diff|growth|ratio|share|convert|expr ...` checks the operands' units, periods, and populations, refuses an incompatible operation, and prints the new row id the placeholder uses. A value nobody measured is registered with `fact add --assumed <value> --unit <unit> --rationale <why> --label <label>` and renders as ASSUMED. Every findings sentence binds to a fact, a quote, a `[S<n>]` citation, or a claim node (`data-claim="C3"`). Reviewers and the refinement team read the rendered text through `node "$SKILL_DIR/scripts/report-tools.mjs" fact fill "$SESSION_DIR/SYNTHESIS.md" --view --session-dir "$SESSION_DIR"`, never the raw placeholders.
+
+**Write the skeleton early and fill it as claims lock.** The moment the brief records the deliverable, create the deliverable file with its section headings and a `STATUS: draft — <n> sections open` line as line 2 (an HTML comment in HTML); that line is the partial-state marker `outcome state` reads, removed only when the deliverable is complete. An interrupted run must leave a partial report on disk, never an empty directory and a lost conversation.
+
+**Keep sourced numbers, assumptions, and derived results visibly apart.** Every quantitative claim carries its lineage: `MEASURED` (a number a source states, cited), `ASSUMED` (a coefficient, distribution, or scope you chose — say why), `DERIVED` (computed from those, showing the formula), plus a sensitivity line whenever the assumption moves the answer. Presenting a derived estimate with the confidence of a measured one is the most damaging thing this mode can ship.
+
+**Search in English, deliver in the user's language.** Retrieval stays English-first (Search craft), but the synthesis and every final material are written in the language the user wrote to you in unless they ask otherwise — and a translated report still quotes its original-language sources verbatim.
+
+
+## Search craft
+
+English first: run every search in English by default — it is the largest, most authoritative corpus on every engine, GitHub, and documentation site. Add a secondary local-language sweep (1-2 librarians) only after the English sweep, when the topic is inherently local, or when the user asks for sources in a specific language.
+
+Vary operators on every query — same query twice wastes a worker:
+
+| Operator | Example | Use |
+|---|---|---|
+| `site:` | `site:github.com <topic>` | Restrict to a domain |
+| `filetype:` | `filetype:pdf <topic> survey` | Papers, specs |
+| `intitle:` / `inurl:` | `intitle:benchmark <topic>` | Targeted pages |
+| `"exact"` / `-term` | `"<exact phrase>" -tutorial` | Precision, exclusion |
+| `OR` | `<a> OR <b> <topic>` | Coverage |
+| `before:` / `after:` | `<topic> after:2025-06-01` | Recency control |
+
+High-yield combinations: official docs (`site:<docs domain>`), GitHub implementations (`site:github.com`), recent discussion (`site:reddit.com OR site:news.ycombinator.com after:<date>`), academic (`site:arxiv.org OR filetype:pdf survey`), changelog hunting (`changelog OR "release notes" <version>`), alternatives (`vs OR alternative OR comparison`).
+
+## Failure modes
+
+| Failure | Correction |
+|---|---|
+| Sequential spawning, or trimming the first wave | All first-wave workers in one turn, background, scaling floor respected |
+| A team member hoards leads for one final dump | Raise law — every lead, finding, and dead end broadcast the moment it surfaces |
+| Worker reply without the EXPAND tail | One follow-up demanding it; the lane stays open until it lands |
+| Stopping after wave 1 because "enough was found" | Convergence rules only: 2+ expansion waves, leads run dry |
+| Obeying a surrounding "stop exploring" rule mid-research | Authority section — those rules do not bind this mode |
+| Asking a worker to write journal or session files | Workers are read-only (except a mass-research dag node's handoff file); you journal every return |
+| Two workers given the same angle | One unique angle per worker, always |
+| A web worker that returned only fetched text, or a `Collection: browser` run whose workers never opened a tab | Sources are read in the user's browser through the `browser` skill; `webfetch` is for raw files; every web worker carries the skill from the first wave |
+| Contested claim settled by judgment | Phase 3 — run code, capture output, verdict |
+| Deliverable claims without citations | Every claim cites a source or a verification artifact |
+| Guessing the deliverable format | Derive it from the request and destination; ask the empty-info interview only for what is still missing, and record `answered_by` for every field |
+| Blocking the collection wave on the format question | Ask non-blocking and start collecting; unanswered fields run on the shown defaults |
+| A roster smaller than the harness ceiling | Fill every member slot; split the broadest axis until the team is full |
+| One tier across the whole roster | Mixed tiers by design — cheap breadth, premium attack |
+| Silently re-routing a "quick"/"fast" instruction | Routing words are literal; journal requested -> spawned -> fallback per slot |
+| A worker or member that starts its own research swarm | Members research one axis and report; orchestration is yours alone |
+| Expanding on an entity the first wave never disambiguated | Settle canonical identity and first-party source before any later spawn asserts it |
+| Batching findings into an end-of-run journal dump | Journal each return as it lands; the journal is what survives a compaction |
+| Ending the run because every worker finished | Reserve the final fifth of the run for synthesis and materials |
+| A derived estimate presented as a measured number | MEASURED / ASSUMED / DERIVED lineage on every quantitative claim, plus a sensitivity line |
+| A number typed into the report or `SYNTHESIS.md` | Register it (`fact add`) and write `{{F<n>:label}}`; `fact verify` reports a typed number as `untraceable_number`, and `outcome verify` refuses delivery until it is a ledger row, an `assumed` row with its rationale, or gone |
+| A filled value edited by hand | Never edit a filled value: fix the ledger row or the placeholder and re-run `fact fill`, then `fact verify` (`value_mismatch`, `unit_mismatch`) |
+| A findings sentence bound to nothing | Bind it to a fact, a quote, a `[S<n>]` citation, or a claim node with `data-claim`; an `unbound_sentence` blocks delivery like an untraceable number |
+| Delivering before the delivery gates pass | Static and layout gates, visual QA on rendered pages, plus the harness's proofread gate — a typo the user finds means a gate did not run |
+| Skipping the static gates | `report-tools check` runs before any pixel review; its defects are cheaper than a visual pass |
+| Delivering with a pending manifest row | `outcome verify` must pass; every promised format ends `delivered`, `blocked_capability`, `skipped`, or `failed` with a reason |
+| Repairing past the tracker's stop decision | `repair decide` owns the budget; `deliver` ships with the residual list, `block` stops delivery |
+| Guessing a design-spec value the extractor marked `TODO: ask` | Fill it from the interview answers or the reference's defaults, never by guessing |
+| Referencing an asset that is not on disk | Verify the asset manifest before rendering; re-render whatever is missing |
+| A figure stretched, cropped, or styled off the report's design language | `design-spec.md` binds every asset: fixed containers, contain-fit with aspect preserved, spec fonts and palette in charts and Mermaid |
+| Chasing an interesting find with no ENTER trigger | Excursions need a named trigger; everything else stays a queued lead |
+| An excursion that never came back, or drifted into a new mission | EXIT rules are unconditional; depth 3 means promote it to an axis or record it as a gap |
+| An excursion whose result was never folded back | Every EXIT writes what it changed in the top-level answer, `none` included, and mirrors into the loop ledger |
+| Ending with file paths while an inline HTML page tool is available | Show the report inline first (the gated `report.html` or its inline edition), then the paths and the summary |
+| A visual reproduction checked only against itself | Reference compare: real source frames next to renders at the same moments, a critique per pair, fixes, and the pairs in the report |
+| Delivering without the closing briefing | Paste the block `outcome briefing` prints; never compute or recall its numbers by hand |

package/packages/shared-skills/skills/ulw-research/scripts/claim-kinds.mjs

@@ -4,7 +4,7 @@
 // emits it as the data-claim-kind attribute on the element it renders, and the fidelity gate
 // (fidelity-claims.mjs) checks that every marked element cites a row the kind accepts. An
 // unmarked element is a plain fact or quote and is checked only by the value and quote checks.
-// The one lexical piece is `unmarked`: a few first-person run patterns that raise a minor warning
+// The one lexical piece is `unmarked`: first-person run and check patterns that raise a minor warning
 // when a sentence reads like the kind but carries no mark; they never raise a major. The table in
 // references/fidelity-claim-kinds.md is rendered from CLAIM_KINDS (`node claim-kinds.mjs --render-doc`).
 // Pure; node: builtins only. Korean phrases are \u escapes.
@@ -23,6 +23,32 @@ const KO_WE_RUN = "(?:\uC2E4\uD589(?:\uD588|\uD558\uC5EC|\uD574)|\uB3CC[\uB838\u
 const KO_RUN = "(?:\uC2E4\uD589|\uB3CC[\uB9AC\uB824\uB838\uB9B0\uB9B4])"
 const KO_SUBJECT = "[^\\s,.;!?]*(?:[\uAC00\uC774\uC740\uB294]|\uAED8\uC11C)(?=\\s)"
 
+// One cue list; the rule text below is built from it. A check verb fires only in first person with
+// a result object (a result noun or a digit) in its clause, and never when that clause names a document.
+// The document guard ends where the clause ends (a comma, a semicolon, "as", a relative pronoun; in Korean a
+// comma, a semicolon, cheoreom, deusi, gati), and a document word followed by a number is a locator ("page 3").
+const EN_RUN = ["ran", "run", "re-ran", "re-run", "executed", "verified by"]
+const EN_CHECK = ["verified", "checked", "confirmed", "measured", "tested", "double-checked", "cross-checked"]
+const EN_RESULT = ["value", "values", "result", "results", "figure", "figures", "number", "numbers", "total", "totals", "count", "counts", "measurement", "measurements", "reading", "readings", "output", "outputs", "span", "length", "rate", "rates", "latency", "throughput", "score", "scores", "benchmark", "benchmarks", "metric", "metrics", "data", "estimate", "estimates", "speed", "duration", "size", "ratio", "growth"]
+const EN_DOCUMENT = ["report", "reports", "filing", "filings", "document", "documents", "paper", "papers", "article", "articles", "publication", "statement", "disclosure", "website", "page", "docs", "documentation"]
+// KO_CHECK = hwagin, geomjeung, cheukjeong, jeomgeom (+ haet/hayeot/hayeo/hae/han); KO_RESULT = gyeolgwa, gap, suchi, gil-i, hapgye,
+// biyul, sokdo, jipyo, deiteo; KO_DOCUMENT = bogoseo, munseo, gongsi, nonmun, gisa, jaryo.
+const KO_CHECK = ["\uD655\uC778", "\uAC80\uC99D", "\uCE21\uC815", "\uC810\uAC80"]
+const KO_DONE = ["\uD588", "\uD558\uC600", "\uD558\uC5EC", "\uD574", "\uD55C"]
+const KO_RESULT = ["\uACB0\uACFC", "\uAC12", "\uC218\uCE58", "\uAE38\uC774", "\uD569\uACC4", "\uBE44\uC728", "\uC18D\uB3C4", "\uC9C0\uD45C", "\uB370\uC774\uD130"]
+const KO_DOCUMENT = ["\uBCF4\uACE0\uC11C", "\uBB38\uC11C", "\uACF5\uC2DC", "\uB17C\uBB38", "\uAE30\uC0AC", "\uC790\uB8CC"]
+const any = (words) => words.map((word) => word.replace(/-/g, "-?").replace(/ /g, "\\s+")).join("|")
+const EN_WE = "(?:\\b[Ww]e|\\bI)(?:'ve|'d)?\\s+(?:(?:have|had|also|then|first|just|again|independently|manually|directly)\\s+)*"
+const CLAUSE = "(?:[^.;!?]|\\.\\d)*?"
+const EN_BOUNDARY = ["as", "which", "who", "whom", "whose", "where"]
+const KO_BOUNDARY = ["\uCC98\uB7FC", "\uB4EF\uC774", "\uAC19\uC774"]
+const EN_GUARD = `(?:(?!,|\\b(?:${any(EN_BOUNDARY)})\\b)[^.;!?]|\\.\\d)*?`
+const KO_GUARD = `(?:(?!,|${any(KO_BOUNDARY)})[^.;!?]|\\.\\d)*?`
+const EN_OBJECT = `(?=${CLAUSE}(?:\\b(?:${any(EN_RESULT)})\\b|\\d))(?!${EN_GUARD}\\b(?:${any(EN_DOCUMENT)})\\b(?!\\s*\\d))`
+const KO_OBJECT = `(?=${CLAUSE}(?:${any(KO_RESULT)}|\\d))(?!${KO_GUARD}(?:${any(KO_DOCUMENT)})(?!\\s*\\d))`
+const escapes = (text) => text.replace(/[^\x00-\x7f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`)
+const list = (words) => escapes(words.join(", "))
+
 /**
  * kind -> { prefix: placeholder prefix (null = the default form), placeholder: an example,
  *   rowKinds: ledger row kinds it accepts, sourceKinds: meta.json kinds the snapshot holding the
@@ -50,11 +76,13 @@ export const CLAIM_KINDS = Object.freeze({
 		note: "The cited row itself must have a locator artifact inside `sources/<source_id>/` whose `meta.json` kind is `command`; another command row in the sentence never counts. Whether it is the right command for the claim is the meaning verifier's call (minor), not this gate's.",
 		unmarked: {
 			code: "verification_claim_unmarked",
-			rule: "a first-person run: we/I (have) ran, run, executed, verified by (not ran out of); by running after we/our in the sentence; \\uC6B0\\uB9AC or \\uC800\\uD76C as the subject word (+ \\uAC00, \\uB294, or \\uD300\\uC774), then \\uC2E4\\uD589\\uD588, \\uC2E4\\uD589\\uD558\\uC5EC, \\uC2E4\\uD589\\uD574, \\uB3CC\\uB838, or \\uB3CC\\uB824 in the clause with no third-party subject between; \\uC9C1\\uC811 with no third-party subject, then \\uC2E4\\uD589 or \\uB3CC\\uB9AC in the clause",
+			rule: `a first-person run: we/I (have) ${list(EN_RUN)} (not ran out of), or by running after we/our in the sentence; a first-person check: we/I (have) ${list(EN_CHECK)} (not checked in/into/out) with a result object in the clause (${list(EN_RESULT)}, or a digit) and no document named before the clause ends (${list(EN_DOCUMENT)}; a comma, a semicolon, or ${list(EN_BOUNDARY)} ends it, and a document word followed by a number is a locator); \\uC6B0\\uB9AC or \\uC800\\uD76C as the subject word (+ \\uAC00, \\uB294, or \\uD300\\uC774), then \\uC2E4\\uD589\\uD588, \\uC2E4\\uD589\\uD558\\uC5EC, \\uC2E4\\uD589\\uD574, \\uB3CC\\uB838, or \\uB3CC\\uB824 in the clause with no third-party subject between, or then ${list(KO_CHECK)} + ${list(KO_DONE)} with a result object in the clause (${list(KO_RESULT)}, or a digit) and no document before the clause ends (${list(KO_DOCUMENT)}; a comma, a semicolon, or ${list(KO_BOUNDARY)} ends it, and a document word followed by a number is a locator); \\uC9C1\\uC811 with no third-party subject, then \\uC2E4\\uD589 or \\uB3CC\\uB9AC in the clause; a curly apostrophe reads as a straight one`,
 			patterns: [
-				/\b(?:we|I)(?:'ve)?\s+(?:(?:have|had|also|then|first|just|again)\s+)*(?:ran|run|re-?ran|re-?run|executed|verified\s+by)\b(?!\s+out\s+of\b)/i,
-				/\b(?:we|our)\b.*?\bby\s+running\b/i,
+				new RegExp(`${EN_WE}(?:${any(EN_RUN)})\\b(?!\\s+out\\s+of\\b)`),
+				new RegExp(`${EN_WE}(?:${any(EN_CHECK)})\\b(?!\\s+(?:in|into|out)\\b)${EN_OBJECT}`),
+				/\b(?:[Ww]e|[Oo]ur)\b.*?\bby\s+running\b/,
 				new RegExp(`${KO_WE_SUBJECT}(?:(?!${KO_SUBJECT})[^\\s,.;!?]+\\s+)*?${KO_WE_RUN}`),
+				new RegExp(`${KO_WE_SUBJECT}${KO_OBJECT}(?:(?!${KO_SUBJECT})[^\\s,.;!?]+\\s+)*?(?:${any(KO_CHECK)})(?:${any(KO_DONE)})`),
 				new RegExp(`(?:^|[,.;!?])\\s*(?:(?!${KO_SUBJECT})[^\\s,.;!?]+\\s+)*\uC9C1\uC811\\s*(?:[^\\s,.;!?]+\\s*)??${KO_RUN}`),
 			],
 		},
@@ -86,7 +114,7 @@ export function unmarkedRequires(row) {
 /** The kinds whose unmarked patterns match the sentence. */
 export function unmarkedKinds(text) {
 	return Object.entries(CLAIM_KINDS)
-		.filter(([, entry]) => entry.unmarked?.patterns.some((re) => re.test(text)))
+		.filter(([, entry]) => entry.unmarked?.patterns.some((re) => re.test(String(text).replace(/\u2019/g, "'"))))
 		.map(([name]) => name)
 }
 

package/packages/shared-skills/skills/ulw-research/scripts/claim-kinds.test.ts

@@ -127,7 +127,7 @@ describe("design-check regressions", () => {
 	test("#given the assumed row F9 unmarked or marked fact #then both refuse it, and the unmarked message names the A mark", () => {
 		expect(codes(prose(value(F9)))).toEqual(["claim_kind_mismatch"])
 		expect(codes(prose(value(F9, "fact")))).toEqual(["claim_kind_mismatch"])
-		expect(JSON.stringify(claims(prose(value(F9))))).toContain("{{A:F9}}")
+		expect(JSON.stringify(claims(prose(value(F9))))).toContain("{{A:F9:growth_rate}}")
 	})
 
 	test("#given the assumed row F9 marked {{A:F9}} (data-claim-kind=assumed) #then no claim defect", () => {
@@ -155,6 +155,21 @@ describe("unmarked phrases", () => {
 		"우리 팀이 벤치마크를 돌려 얻은 값",
 		"그래서 우리는 스크립트를 실행했다",
 		"직접 실행한 결과",
+		"우리는 결과를 확인했다",
+		"We confirmed the result.",
+		"We verified the span against the field log.",
+		"We double-checked the totals.",
+		"We cross-checked the values.",
+		"We\u2019ve confirmed the result.",
+		"We confirmed that the recorded span is up to 320 m.",
+		"We measured 42 ms.",
+		"저희는 측정값 320 m를 검증했다",
+		"We measured a latency of 40 ms, as this report shows.",
+		"We verified the value on page 3.",
+		"We checked the totals, which the filing also lists.",
+		"우리는 결과를 확인하였다",
+		"우리는 실행 결과를 검증하였다",
+		"우리는 지연 시간 40 ms를 측정했고, 보고서도 같은 값을 적었다",
 	]
 	const quiet = [
 		"The tests showed a 12 % drop.",
@@ -169,12 +184,32 @@ describe("unmarked phrases", () => {
 		"우리나라에서 실행된 정책은 320개다",
 		"우리 정부가 실행한 예산",
 		"우리가 의뢰한 업체가 테스트를 돌렸다",
-		"우리는 결과를 확인했다",
+		"We checked the box to opt in.",
+		"As we observed in Section 2, demand is seasonal.",
+		"The values we observed were higher than the 2023 baseline.",
+		"We checked into the hotel.",
+		"We checked in at the hotel.",
+		"In Phase I observed values rose.",
+		"We confirmed the figure against the 2024 annual report.",
+		"We use confirmed values, validated inputs, checked references, observed events, and measured responses.",
+		"The authors confirmed that the value was measured.",
+		"우리는 보고서의 수치를 확인했다",
+		"우리는 일정을 확인했다",
+		"우리는 공시 자료의 수치를 확인하였다",
+		"We measured the latency in the published report.",
 	]
 	for (const text of fires) test(`#given "${text}" #then verified`, () => expect(unmarkedKinds(text)).toEqual(["verified"]))
 	for (const text of quiet) test(`#given "${text}" #then nothing`, () => expect(unmarkedKinds(text)).toEqual([]))
 })
 
+describe("references/report-gates.md lists the shipped cue rule", () => {
+	test("the verification_claim_unmarked glossary row carries CLAIM_KINDS.verified.unmarked.rule verbatim", () => {
+		const glossary = readFileSync(join(import.meta.dir, "..", "references", "report-gates.md"), "utf8")
+		const row = glossary.split("\n").find((line) => line.startsWith("| `verification_claim_unmarked` |")) ?? ""
+		expect(row).toContain(CLAIM_KINDS.verified.unmarked?.rule ?? "missing rule")
+	})
+})
+
 describe("references/fidelity-claim-kinds.md is rendered from CLAIM_KINDS", () => {
 	const doc = readFileSync(join(import.meta.dir, "..", "references", "fidelity-claim-kinds.md"), "utf8")
 

package/packages/shared-skills/skills/ulw-research/scripts/claim-prefix.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { markdownAsHtml } from "./fact-commands-verify.mjs"
+import { fill } from "./fact-fill.mjs"
+import { valueChecks } from "./fidelity-values.mjs"
+import { buildContext } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+import { parsePlaceholder, renderValueHtml } from "./placeholder.mjs"
+
+type Row = Record<string, unknown> & { fact_id: string }
+const FIX = join(import.meta.dir, "tests", "fixtures", "fidelity")
+const BASE: { rows: Row[] } = JSON.parse(readFileSync(join(FIX, "ledger-verify.json"), "utf8"))
+const row = (id: string) => BASE.rows.find((r) => r.fact_id === id) as Row
+const converted = { ...row("F8"), raw: "320,000 mm (320 m)", render: "320,000 mm (320 m)", derived_from: ["F1"] }
+const assumed = { ...row("F8"), fact_id: "F9", kind: "assumed", label: "plan", raw: "15%", render: null, value: "15", unit: "%", derived_from: [], operands: [], operation: null }
+const ledger = { ...BASE, rows: [...BASE.rows.filter((r) => r.fact_id !== "F8"), converted, assumed] }
+const check = (html: string) => valueChecks(buildContext(parseHtml(`<h2>Findings</h2>${html}`), { baseDir: FIX }), ledger, null, join(FIX, "sources"))
+
+describe("claim prefixes come from the CLAIM_KINDS registry and combine with the pointer grammar", () => {
+	test("#given a prefix before a value mode or a quote selector #when parsed #then the pointer keeps its mode and gains the claim kind", () => {
+		expect(parsePlaceholder("{{D:F12:label}}")).toEqual({ id: "F12", kind: "F", label: "label", mode: "full", claimKind: "derived" })
+		expect(parsePlaceholder("{{D:F12:label:value}}")).toEqual({ id: "F12", kind: "F", label: "label", mode: "value", claimKind: "derived" })
+		expect(parsePlaceholder("{{V:Q7:label:lead=3}}")).toMatchObject({ id: "Q7", mode: "lead", lead: 3, claimKind: "verified" })
+		expect(parsePlaceholder("{{A:F9:plan}}")).toMatchObject({ id: "F9", claimKind: "assumed" })
+	})
+
+	for (const token of ["{{D:F12}}", "{{D:F12:}}", "{{D:F12:a:b}}", "{{V:F7}}", "{{A:}}", "{{X:F8:span_mm}}", "{{V:V:F7:test_pass}}", "{{D:F0:label}}"]) {
+		test(`#given the malformed ${token} #when filled #then unresolved_placeholder`, () => {
+			const result = fill(token, ledger)
+			expect(result.out).toBeNull()
+			expect((result.errors as { code: string }[]).map((e) => e.code)).toEqual(["unresolved_placeholder"])
+		})
+	}
+
+	for (const [token, code] of [["{{A:F8:span_mm}}", "claim_kind_mismatch"], ["{{V:F8:span_mm}}", "unsupported_verification"]]) {
+		test(`#given ${token} on a row its kind refuses #when filled #then the kind's documented defect ${code}`, () => {
+			const result = fill(token, ledger)
+			expect(result.out).toBeNull()
+			expect((result.errors as { code: string }[]).map((e) => e.code)).toEqual([code])
+		})
+	}
+})
+
+describe("renderValueHtml takes { mode, claimKind }", () => {
+	test("#given a value-mode fact with a D claim #when rendered #then both the mode marker and the claim attribute are emitted", () => {
+		const html = renderValueHtml(converted, "320,000", { mode: "value", claimKind: "derived" })
+		expect(html).toContain('data-fact-mode="value"')
+		expect(html).toContain('data-claim-kind="derived"')
+		expect(renderValueHtml(converted, "320,000 mm")).not.toMatch(/data-fact-mode|data-claim-kind/)
+	})
+
+	test("#given {{D:F8:span_mm:value}} #when filled to HTML #then the element carries both attributes and the fill map records the mode", () => {
+		const result = fill("<p>{{D:F8:span_mm:value}} mm</p>", ledger)
+		expect(result.errors).toEqual([])
+		expect(result.out).toContain('data-fact-mode="value"')
+		expect(result.out).toContain('data-claim-kind="derived"')
+		expect(result.fillMap[0]).toMatchObject({ mode: "value", claimKind: "derived" })
+	})
+})
+
+describe("prefixed fills verify clean in HTML and Markdown", () => {
+	for (const [token, kind] of [["{{V:F7:test_pass}}", "verified"], ["{{A:F9:plan}}", "assumed"], ["{{D:F8:span_mm}}", "derived"]]) {
+		for (const format of ["html", "md"] as const) {
+			test(`#given ${token} filled as ${format} #when verified #then it carries ${kind} and raises nothing`, () => {
+				const result = fill(format === "html" ? `<p>${token} [S4].</p>` : `${token} [S4].`, ledger, { format })
+				expect(result.errors).toEqual([])
+				if (result.out === null) throw new Error("fill failed")
+				const html = format === "html" ? result.out : markdownAsHtml(result.out, result.fillMap as Parameters<typeof markdownAsHtml>[1], ledger).html
+				expect(html).toContain(`data-claim-kind="${kind}"`)
+				expect(check(html)).toEqual([])
+			})
+		}
+	}
+})

package/packages/shared-skills/skills/ulw-research/scripts/contracts-validation.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test"
+
+import { SCHEMA_VERSION, normalizeManifest, validateOutcomeManifest, validateRepairState } from "./contracts.mjs"
+
+function fourGateManifest() {
+	const manifest = sampleManifest()
+	const { fidelity: _dropped, ...gates } = manifest.gates
+	return { ...manifest, gates }
+}
+
+function sampleManifest() {
+	return {
+		schemaVersion: SCHEMA_VERSION,
+		sessionDir: "/tmp/session/20260101-120000",
+		startedAt: "2026-01-01T12:00:00.000Z",
+		finishedAt: null,
+		elapsedMinutes: null,
+		lane: "no-format",
+		interview: null,
+		deliverables: [
+			{ format: "pdf", status: "pending", promised: true, updatedAt: "2026-01-01T12:00:00.000Z" },
+		],
+		renders: [],
+		gates: { static: "not_run", fidelity: "not_run", layout: "not_run", visual: "not_run", proofread: "not_run" },
+		residualDefects: [],
+		repair: null,
+		sources: null,
+	}
+}
+
+describe("validateOutcomeManifest", () => {
+	test("#given an empty object #when validated #then it fails naming schemaVersion", () => {
+		const result = validateOutcomeManifest({})
+		expect(result.ok).toBe(false)
+		expect(result.errors.some((e) => e.includes("schemaVersion"))).toBe(true)
+	})
+
+	test("#given a well-formed manifest #when validated #then it passes", () => {
+		expect(validateOutcomeManifest(sampleManifest())).toEqual({ ok: true, errors: [] })
+	})
+
+	test("#given a deliverable with an unknown status #when validated #then the error names the row", () => {
+		const m = sampleManifest()
+		m.deliverables[0].status = "done"
+		const result = validateOutcomeManifest(m)
+		expect(result.ok).toBe(false)
+		expect(result.errors.join("\n")).toMatch(/deliverables\[0\]\.status/)
+	})
+
+	test("#given a manifest written before the fidelity gate #when validated raw and after normalizeManifest #then only the normalized copy passes, with fidelity not_run", () => {
+		const old = fourGateManifest()
+		expect(validateOutcomeManifest(old).ok).toBe(false)
+		const normalized = normalizeManifest(old)
+		expect(normalized.gates.fidelity).toBe("not_run")
+		expect(normalized.gates.static).toBe("not_run")
+		expect(validateOutcomeManifest(normalized)).toEqual({ ok: true, errors: [] })
+		expect(old.gates).not.toHaveProperty("fidelity")
+		const failed = { ...old, gates: { ...old.gates, visual: "fail" } }
+		expect(normalizeManifest(failed).gates.visual).toBe("fail")
+	})
+
+	test("#given a gate with an unknown value #when validated #then it fails", () => {
+		const m = sampleManifest()
+		m.gates.static = "ok"
+		expect(validateOutcomeManifest(m).ok).toBe(false)
+	})
+})
+
+describe("validateRepairState", () => {
+	test("#given a well-formed state #when validated #then it passes, and a bad measure fails", () => {
+		const good = {
+			schemaVersion: SCHEMA_VERSION,
+			startedAt: "2026-01-01T12:00:00.000Z",
+			budget: { maxAttempts: 3, plateauLimit: 2, wallClockMs: 900_000 },
+			attempts: [{ at: "2026-01-01T12:01:00.000Z", measure: [1, 2, 0], signature: "em_dash_in_prose|unsourced_number" }],
+			consecutiveNonProgress: 0,
+			seenSignatures: ["em_dash_in_prose|unsourced_number"],
+		}
+		expect(validateRepairState(good)).toEqual({ ok: true, errors: [] })
+		const bad = { ...good, attempts: [{ at: "x", measure: [1, 2], signature: "" }] }
+		expect(validateRepairState(bad).ok).toBe(false)
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/contracts.mjs

@@ -31,7 +31,7 @@ export const DEFECT_CODES = deepFreeze({
 	en_dash_in_prose: { severity: "minor", integrity: false, hint: "Use a hyphen for compounds; keep the en dash only between numbers." },
 	heading_too_long: { severity: "minor", integrity: false, hint: "Shorten the heading to one line (26 Korean characters or 12 English words)." },
 	heading_generic: { severity: "minor", integrity: false, hint: "Make the heading carry the section's claim instead of a generic label." },
-	unsourced_number: { severity: "major", integrity: false, hint: "Tag the number MEASURED / ASSUMED / DERIVED or cite its source in the same paragraph." },
+	unsourced_number: { severity: "major", integrity: false, hint: "Tag the number MEASURED / ASSUMED / DERIVED or cite its source in the same paragraph; under Sources only citation-field numbers and names (a hash, #12, GPT-4, Q3, 10-Q) are exempt, so quote a reference title that carries a code or a figure, or wrap it in <cite>: an unquoted one is checked, and 10-K / 8-K stay numerals because K is a multiplier. A slashed N/M reads as a month/day, so a fraction or a score (2/3, 7/12) under Sources is not checked (#11386): write it as a percent or tag it." },
 	chart_without_figure: { severity: "major", integrity: false, hint: "Wrap the image or chart in a figure container with a caption." },
 	chart_svg_no_text: { severity: "major", integrity: false, hint: "Give the chart a title, axis labels, units, and value labels as SVG text." },
 	chart_svg_missing_labels: { severity: "minor", integrity: false, hint: "Add the missing title, axis ticks, or unit label to the chart." },
@@ -58,12 +58,14 @@ export const DEFECT_CODES = deepFreeze({
 	pointer_label_mismatch: { severity: "blocker", integrity: true, hint: "The placeholder's label is not the row's label; check the id, then the label." },
 	quote_anchor_unresolved: { severity: "blocker", integrity: true, hint: "A from or to anchor is missing or occurs more than once in the quote; pick unique anchor words." },
 	unit_duplicated: { severity: "blocker", integrity: true, hint: "The unit after the placeholder repeats the row's unit; use :value or remove the unit." },
+	conversion_altered_number: { severity: "blocker", integrity: true, hint: "The source conversion altered this number (sources/S<n>/conversion.json lists it); snapshot a verified text of the source over it with `source snapshot --id S<n> --text <verified.txt> --replace` (refused while an active row cites S<n>; then retract those rows or use a new id), then re-add the fact." },
 	polish_diff_fail: { severity: "blocker", integrity: true, hint: "The polish pass changed numbers, tickers, table rows, claim ids, markup, or hidden content; revert to the pre-polish artifact and apply the language fixes only." },
 	fidelity_interview_incomplete: { severity: "blocker", integrity: true, hint: "A fidelity field is pending or missing in brief.md; answer the open question or record its default, then rerun." },
 	derived_not_allowed: { severity: "blocker", integrity: true, hint: "The brief allows no derived or assumed numbers; cite a source row directly or change the brief with the requester." },
 	source_outside_floor: { severity: "blocker", integrity: true, hint: "The row's source is outside the source floor the brief records; use a source the brief allows or remove the fact." },
 	brief_changed: { severity: "blocker", integrity: true, hint: "The edition's fill map was not written under the current ## Fidelity block (it changed after fill, or the map predates the binding); re-run fact fill, then fact verify." },
-	snapshot_hash_mismatch: { severity: "blocker", integrity: true, hint: "The source snapshot changed after it was pinned; re-snapshot the source and re-register its rows." },
+	snapshot_hash_mismatch: { severity: "blocker", integrity: true, hint: "The source snapshot changed after it was pinned or cannot be read; restore it, or run source refresh to re-anchor its rows." },
+	snapshot_not_raw: { severity: "blocker", integrity: true, hint: "Measured rows need the original bytes: snapshot the source with --url, --html, or --raw <bytes> --text <extraction>; converted-only sources support warned quotations only." },
 	chart_value_untraceable: { severity: "blocker", integrity: true, hint: "A chart value, tick, or data file does not match its ledger-backed data source; re-render the chart from the exported data." },
 	quote_unbound: { severity: "blocker", integrity: true, hint: "A direct quotation has no ledger quote row; register it with fact quote and insert it through its placeholder." },
 	edition_unverified: { severity: "blocker", integrity: true, hint: "The delivered file has no matching fact verify record; run fact verify on that edition and record it with --verified-by." },
@@ -82,13 +84,18 @@ export const DEFECT_CODES = deepFreeze({
 	polish_hedging_decreased: { severity: "major", integrity: false, hint: "The polish pass removed qualifiers; restore them." },
 	polish_text_churn: { severity: "major", integrity: false, hint: "More than half the text changed during polish; the pass composed instead of proofreading." },
 	snapshot_mismatch: { severity: "major", integrity: false, hint: "The operands come from different collection windows; use rows from one window or state the windows separately." },
+	operand_timestamp_missing: { severity: "major", integrity: false, hint: "Record the operand's observed_at timestamp before checking its collection window." },
+	operand_missing: { severity: "major", integrity: false, hint: "A windowed operation names an operand that is not in the fact ledger; restore the row or re-derive from existing rows." },
 	join_integrity_fail: { severity: "major", integrity: false, hint: "A table row combines facts from different source observations; keep each row to one observation or split it." },
 	quote_stale_version: { severity: "major", integrity: false, hint: "The quoted source revision differs from the revision the report targets; re-snapshot the target revision or date the quote." },
 	quote_fuzzy_match: { severity: "minor", integrity: false, hint: "The source text is OCR-noisy; confirm the snapshot and prefer the raw document." },
+	relocated: { severity: "minor", integrity: false, hint: "After source refresh the exact quote and context sit at one new byte range; review the old and new offsets (verification never rewrites the row)." },
+	quote_converted_only: { severity: "minor", integrity: false, hint: "The quote comes from a converted-only source with no raw bytes; re-snapshot the original with --raw and --text, or keep the warned quote." },
 	name_outside_quote: { severity: "minor", integrity: false, hint: "A name in the sentence is not in the cited quote; add the source or remove the name." },
 	verification_claim_unmarked: { severity: "minor", integrity: false, hint: "The sentence reads as a check we ran but carries no verified mark; mark it {{V:F<n>:label}} on a recorded command-output row, or reword it." },
 	scope_widened_warn: { severity: "minor", integrity: false, hint: "The sentence uses a broader scope word than the quote; confirm the scope or narrow it." },
 	particle_unverified: { severity: "minor", integrity: false, hint: "The particle after this value could not be checked; read it aloud and fix it by hand if wrong." },
+	unit_unbound: { severity: "minor", integrity: false, hint: "Use the full fact placeholder, or write the unit right after :value (with or without a space; a Korean particle may follow), as its :unit element, or in the matching table column header." },
 	fallback_without_entity: { severity: "minor", integrity: false, hint: "The replacement quote has no entity for attribution; set one on the row." },
 	meaning_drift_warn: { severity: "minor", integrity: false, hint: "A separate reader found the sentence changes scope, subject, or certainty; rewrite from the quote." },
 	polish_edit_unlocated: { severity: "minor", integrity: false, hint: "The edit's before-text was not found exactly once; re-propose against the current text." },
@@ -98,15 +105,17 @@ export const DEFECT_CODES = deepFreeze({
 
 /** Codes only the fidelity verifier raises (fact ledger, fill, verify, meaning, polish). */
 export const FIDELITY_CODES = Object.freeze([
+	"unit_unbound",
 	"unresolved_placeholder", "value_mismatch", "unit_mismatch", "quote_not_verbatim", "claim_status_invalid",
 	"incompatible_operands", "pointer_label_mismatch", "quote_anchor_unresolved", "unit_duplicated", "polish_diff_fail",
 	"fidelity_interview_incomplete", "derived_not_allowed", "source_outside_floor", "brief_changed", "snapshot_hash_mismatch",
+	"conversion_altered_number",
 	"chart_value_untraceable", "quote_unbound", "edition_unverified", "untraceable_number", "unsupported_verification", "claim_kind_mismatch",
 	"conflicting_readings", "hedge_dropped", "direction_flipped", "causality_added", "qualifier_dropped", "unbound_sentence",
 	"meaning_drift_confirmed", "meaning_unverified", "polish_edit_rejected", "polish_hedging_decreased", "polish_text_churn", "snapshot_mismatch",
-	"join_integrity_fail", "quote_stale_version", "quote_fuzzy_match", "name_outside_quote", "verification_claim_unmarked", "scope_widened_warn",
+	"operand_timestamp_missing", "operand_missing", "join_integrity_fail", "quote_stale_version", "quote_fuzzy_match", "name_outside_quote", "verification_claim_unmarked", "scope_widened_warn",
 	"particle_unverified", "fallback_without_entity", "meaning_drift_warn", "polish_edit_unlocated", "polish_link_changed",
-	"polish_name_changed",
+	"polish_name_changed", "snapshot_not_raw", "relocated", "quote_converted_only",
 ])
 const FIDELITY_SET = new Set(FIDELITY_CODES)