lazycodex-ai 5.1.48 → 5.1.54

package/packages/shared-skills/skills/ulw-research/scripts/raw-locator.mjs

@@ -0,0 +1,47 @@
+// Byte locators over a source view (source-view.mjs) and exact, context-bound re-anchoring.
+// Matching always happens on the view's text (text nodes of a page, never markup); only the
+// stored offsets are bytes of the view's artifact. value_span remains quote-relative text.
+
+const chars = (text) => [...text]
+
+/** Context is copied before normalization, around the value (or the whole quote for Q rows). */
+export function quoteContext(text, start, end) {
+	return { prefix: chars(text.slice(0, start)).slice(-32).join(""), suffix: chars(text.slice(end)).slice(0, 32).join("") }
+}
+
+/** Convert a text-space locator from fact-locate.mjs into artifact byte offsets. */
+export function rawLocated(view, found) {
+	if (found.error) return found
+	const { char_start: start, char_end: end } = found.locator
+	const from = start + (found.value_span?.[0] ?? 0)
+	const to = found.value_span ? start + found.value_span[1] : end
+	const [byteStart, byteEnd] = view.byteSpan(start, end)
+	return {
+		...found,
+		context: quoteContext(view.text, from, to),
+		locator: { ...found.locator, artifact: view.artifact, unit: "bytes", char_start: byteStart, char_end: byteEnd },
+	}
+}
+
+function contextMatches(text, row, start, end) {
+	if (!row.context) return false
+	const from = row.value_span ? start + row.value_span[0] : start
+	const to = row.value_span ? start + row.value_span[1] : end
+	const { prefix, suffix } = row.context
+	return from >= prefix.length && text.slice(from - prefix.length, from) === prefix && text.slice(to, to + suffix.length) === suffix
+}
+
+/**
+ * The row's quote in the view: unchanged when an exact occurrence sits at the pinned byte range,
+ * else exactly one occurrence whose context matches (relocated), else null. Never rewrites the row.
+ */
+export function reanchor(view, row) {
+	const quote = String(row.quote ?? "")
+	if (quote === "" || !view.byteSpan) return null
+	const { char_start: start, char_end: end } = row.locator
+	const hits = []
+	for (let at = view.text.indexOf(quote); at !== -1; at = view.text.indexOf(quote, at + 1)) hits.push({ at, span: view.byteSpan(at, at + quote.length) })
+	if (hits.some(({ span }) => span[0] === start && span[1] === end)) return { start, end, relocated: false }
+	const matching = hits.filter(({ at }) => contextMatches(view.text, row, at, at + quote.length))
+	return matching.length === 1 ? { start: matching[0].span[0], end: matching[0].span[1], relocated: true } : null
+}

package/packages/shared-skills/skills/ulw-research/scripts/raw-snapshot.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, onTestFinished, test } from "bun:test"
+import { mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { sha256Of } from "./cli-support.mjs"
+import { DEFECT_CODES, INTEGRITY_CODES } from "./contracts.mjs"
+import { readLedger, writeLedger } from "./fact-ledger.mjs"
+import { run } from "./report-tools.mjs"
+import { writeSnapshot } from "./source-snapshot.mjs"
+
+const BRIEF = readFileSync(join(import.meta.dir, "tests/fixtures/fidelity-brief-locked.md"), "utf8")
+
+function session(text: string, kind = "document") {
+	const dir = mkdtempSync(join(tmpdir(), "raw-snapshot-"))
+	onTestFinished(() => rmSync(dir, { recursive: true, force: true }))
+	writeFileSync(join(dir, "brief.md"), BRIEF)
+	writeSnapshot(join(dir, "sources"), "S1", { path: "source.txt", text, kind, extractor: "tool:source-snapshot@1" })
+	return dir
+}
+
+const add = (dir: string) => run(["fact", "add", "--session-dir", dir, "--source", "S1", "--find", "Span", "--label", "span", "--json"])
+
+// fact verify needs the edition's fill map under the current brief, so the edition is filled, not hand-written.
+async function verify(dir: string) {
+	const row = readLedger(dir).rows[0]
+	const [source, report] = [join(dir, "report.src.html"), join(dir, "report.html")]
+	writeFileSync(source, `<h2>Findings</h2><p>{{${row.fact_id}:${row.label}}} [S1].</p>`)
+	await run(["fact", "fill", source, "--out", report, "--session-dir", dir])
+	return run(["fact", "verify", report, "--session-dir", dir])
+}
+
+function refetch(dir: string, text: string) {
+	writeFileSync(join(dir, "sources/S1/raw.bin"), text)
+	const metaPath = join(dir, "sources/S1/meta.json")
+	const meta = JSON.parse(readFileSync(metaPath, "utf8"))
+	meta.sha256 = sha256Of(text)
+	writeFileSync(metaPath, JSON.stringify(meta))
+	const ledger = readLedger(dir)
+	ledger.rows[0].snapshot_sha256 = meta.sha256
+	writeLedger(dir, ledger)
+}
+
+describe("raw snapshot contract", () => {
+	test("text-only source cannot back a measured row", async () => {
+		const dir = session("Span is 320 m.")
+		const raw = join(dir, "sources/S1/raw.bin")
+		try { unlinkSync(raw) } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error }
+		await expect(add(dir)).rejects.toThrow("raw.bin is missing")
+	})
+
+	test("raw bytes determine hash and UTF-8 locator offsets before normalization", async () => {
+		const text = "\u00e9.\nSpan is 320 m."
+		const dir = session(text)
+		writeFileSync(join(dir, "sources/S1/text.txt"), "Span is 999 m.")
+		const result = await add(dir)
+		expect(result.exitCode).toBe(0)
+		const row = result.json.data.row
+		expect(row.value).toBe("320")
+		expect(row.snapshot_sha256).toBe(sha256Of(Buffer.from(text)))
+		expect(row.locator).toMatchObject({ unit: "bytes", artifact: "raw.bin", char_start: 4, char_end: Buffer.byteLength(text) })
+		expect(row.context).toEqual({ prefix: "\u00e9.\nSpan is ", suffix: "." })
+	})
+
+	test("raw drift blocks verification even when quote re-anchors", async () => {
+		const dir = session("Span is 320 m.")
+		await add(dir)
+		writeFileSync(join(dir, "sources/S1/raw.bin"), "   Span is 320 m.")
+		const result = await verify(dir)
+		expect(result.exitCode).toBe(1)
+		expect(result.json.defects.some((d: { code: string }) => d.code === "snapshot_hash_mismatch")).toBe(true)
+	})
+
+	test("explicitly repinned refetch re-anchors with old and new byte offsets", async () => {
+		const dir = session("Span is 320 m.")
+		await add(dir)
+		refetch(dir, "   Span is 320 m.")
+		const result = await verify(dir)
+		expect(result.exitCode).toBe(0)
+		expect(result.json.defects).toContainEqual(expect.objectContaining({ code: "relocated", severity: "minor", message: expect.stringContaining("0:14 -> 3:17") }))
+	})
+
+	test("context disambiguates two exact quotes", async () => {
+		const dir = session("a".repeat(40) + "\nSpan is 320 m.\n" + "b".repeat(40))
+		await add(dir)
+		refetch(dir, "lead\n" + "c".repeat(40) + "\nSpan is 320 m.\n" + "d".repeat(40) + "\n" + "a".repeat(40) + "\nSpan is 320 m.\n" + "b".repeat(40))
+		const result = await verify(dir)
+		expect(result.exitCode).toBe(0)
+		expect(result.json.defects.some((d: { code: string }) => d.code === "relocated")).toBe(true)
+	})
+
+	test("identical contexts refuse ambiguous relocation with existing failure code", async () => {
+		const text = "a".repeat(40) + "\nSpan is 320 m.\n" + "b".repeat(40)
+		const dir = session(text)
+		await add(dir)
+		refetch(dir, `lead\n${text}\n${text}`)
+		const result = await verify(dir)
+		expect(result.exitCode).toBe(1)
+		expect(result.json.defects.some((d: { code: string }) => d.code === "quote_not_verbatim")).toBe(true)
+		expect(result.json.defects.some((d: { code: string }) => d.code === "relocated")).toBe(false)
+	})
+
+	test("snapshot_not_raw is an integrity blocker", () => {
+		expect(DEFECT_CODES.snapshot_not_raw).toMatchObject({ severity: "blocker", integrity: true })
+		expect(INTEGRITY_CODES.has("snapshot_not_raw")).toBe(true)
+	})
+
+	test("HTML snapshots hash unmodified markup rather than extracted prose", () => {
+		const dir = session("unused")
+		const html = "<p>Span&nbsp;is <b>320</b> m.</p>"
+		const saved = writeSnapshot(join(dir, "other"), "S2", { html, path: "source.html", extractor: "model" })
+		expect(readFileSync(join(saved.dir, "raw.bin"), "utf8")).toBe(html)
+		expect(saved.sha256).toBe(sha256Of(html))
+	})
+
+	test("raw table offsets select the labeled cell, not attribute numerals or another value", async () => {
+		const dir = session("unused")
+		const html = '<!--\u00e9--><table id="sizes"><tr><th>Name</th><th>Length</th></tr><tr><td>Deck</td><td><b title="9">320</b> m</td></tr><tr><td>Other</td><td>320 m</td></tr></table>'
+		writeSnapshot(join(dir, "sources"), "S2", { html, path: "source.html", extractor: "model" })
+		const result = await run(["fact", "add", "--session-dir", dir, "--source", "S2", "--table", "sizes", "--row", "Deck", "--col", "Length", "--label", "deck", "--json"])
+		expect(result.exitCode).toBe(0)
+		const row = result.json.data.row
+		expect(row.value).toBe("320")
+		expect(row.unit).toBe("m")
+		expect(row.quote).toBe("320 m")
+		expect(Buffer.from(html).subarray(row.locator.char_start, row.locator.char_end).toString()).toBe("320</b> m")
+		expect(row.quote.slice(...row.value_span)).toBe(row.raw)
+		expect(row.context.prefix).not.toContain("title")
+	})
+
+	test("converted-only sources refuse measured facts but allow warned quotations", async () => {
+		const dir = session("Span is 320 m.", "converted-only")
+		expect((await add(dir)).json.error).toBe("snapshot_not_raw")
+		const result = await run(["fact", "quote", "--session-dir", dir, "--source", "S1", "--match", "Span is 320 m.", "--json"])
+		expect(result.exitCode).toBe(0)
+		expect(result.json.defects).toContainEqual(expect.objectContaining({ code: "quote_converted_only" }))
+		expect(result.json.data.row.context).toEqual({ prefix: "", suffix: "" })
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/report-tools-2.test.ts

@@ -0,0 +1,233 @@
+import { describe, expect, onTestFinished, test } from "bun:test"
+import { createHash } from "node:crypto"
+import { copyFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { delimiter, join } from "node:path"
+import { PROMOTION } from "./fact-commands-meaning.mjs"
+import { writeFidelityRecord } from "./fidelity-records.mjs"
+import { PAIR_KINDS } from "./fact-pairs.mjs"
+import { VERDICT_SCHEMA } from "./meaning-check.mjs"
+import { POLISH_MARKUP_REASON } from "./polish-apply.mjs"
+import { COMMANDS, run } from "./report-tools.mjs"
+import { SCRIPT, FIXTURES, sessionDir, nodeWithoutBun, defectsFile, FIDELITY, sha256, CliRow, CliJson, nodeJson, fidelitySession, verify, codesOf, Pair, pairedSession, verdicts, calibrationRows, runLines, PolishJson, polishSession, polishApply, setField, fillTemplate, textSource, ledgerRow } from "./tests/report-tools-support"
+
+
+
+describe("fact, source, and claims under node", () => {
+	test("#given a fresh session #when snapshot, add, quote, derive, fill, and verify run #then the filled report verifies clean", () => {
+		// given
+		const { dir, s, snap, add, quote, derive, mm } = fidelitySession()
+		// when
+		const filled = nodeJson(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), ...s])
+		const checked = verify(dir, "report.html")
+		// then
+		expect(snap.code).toBe(0)
+		expect(add.code).toBe(0)
+		expect(add.json.data.row.value).toBe("320")
+		expect(add.json.data.context.match).toBe("320 m")
+		expect(quote.code).toBe(0)
+		expect(quote.json.data.row.fact_id).toBe("Q1")
+		expect(derive.code).toBe(0)
+		expect(mm).toBe("F2")
+		expect(filled.code).toBe(0)
+		expect(readFileSync(join(dir, "report.html"), "utf8")).toContain("320,000 mm (320 m)")
+		expect(checked.code).toBe(0)
+		expect(checked.json.defects).toEqual([])
+		const record = JSON.parse(readFileSync(join(dir, "fidelity-defects.json"), "utf8"))
+		expect(record.artifact_sha256).toBe(sha256(join(dir, "report.html")))
+	})
+
+	test("#given a filled report #when a value is hand-edited or a number typed #then verify exits 1 with the code", () => {
+		const { dir, s } = fidelitySession()
+		nodeJson(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), ...s])
+		const html = readFileSync(join(dir, "report.html"), "utf8")
+		writeFileSync(join(dir, "unit.html"), html.replace("320 m", "320 mm"))
+		writeFileSync(join(dir, "typed.html"), html.replace("<h2>How", "<p>Revenue grew 12% [S4].</p>\n<h2>How"))
+		const unit = verify(dir, "unit.html")
+		const typed = verify(dir, "typed.html")
+		expect(unit.code).toBe(1)
+		expect(codesOf(unit.json)).toContain("unit_mismatch")
+		expect(typed.code).toBe(1)
+		expect(codesOf(typed.json)).toContain("untraceable_number")
+	})
+
+	test("#given an anchor that is not in the source #when fact add runs #then it exits 1 with fact_not_located and writes no row", () => {
+		const { dir, s } = fidelitySession()
+		const proc = nodeJson(["fact", "add", "--source", "S4", "--find", "nope", "--label", "x", ...s])
+		expect(proc.code).toBe(1)
+		expect(proc.stdout).toContain("fact_not_located")
+		expect(JSON.parse(readFileSync(join(dir, "fact-ledger.json"), "utf8")).rows.map((r: { fact_id: string }) => r.fact_id)).toEqual(["F1", "Q1", "F2"])
+	})
+
+	test("#given a snapshotted source #when snapshotted again with the same or different content #then same is a no-op and different exits 1", () => {
+		const { dir, s } = fidelitySession()
+		writeFileSync(join(dir, "other.txt"), "Span length: 999 m\n")
+		expect(nodeJson(["source", "snapshot", "--id", "S4", "--html", join(FIDELITY, "sources", "S4.html"), ...s]).code).toBe(0)
+		expect(nodeJson(["source", "snapshot", "--id", "S4", "--text", join(dir, "other.txt"), ...s]).code).toBe(1)
+	})
+
+	test("#given an assumed value with and without a rationale #when added #then the row is kind assumed, and no rationale exits 2", () => {
+		const { s } = fidelitySession()
+		const added = nodeJson(["fact", "add", "--assumed", "12", "--unit", "%", "--rationale", "planning share chosen by the requester", "--label", "share_assumed", "--json", ...s])
+		expect(added.code).toBe(0)
+		expect(added.json.data.row.kind).toBe("assumed")
+		expect(nodeJson(["fact", "add", "--assumed", "12", "--label", "x", ...s]).code).toBe(2)
+	})
+
+	test("#given the fixture claim graph #when claims index runs #then claims.json lists its claims", () => {
+		const dir = sessionDir()
+		const proc = nodeJson(["claims", "index", join(FIDELITY, "claim-graph.md"), "--out", join(dir, "claims.json")])
+		expect(proc.code).toBe(0)
+		expect(JSON.parse(readFileSync(join(dir, "claims.json"), "utf8")).claims.length).toBeGreaterThan(0)
+	})
+
+	test("#given a ledger #when exported as csv #then rows carry fact_id and plot_value and stderr has the coverage line", () => {
+		const { s } = fidelitySession()
+		const proc = nodeJson(["fact", "export", "--csv", ...s])
+		expect(proc.code).toBe(0)
+		expect(proc.stdout.split("\n")[0]).toContain("fact_id")
+		expect(proc.stdout).toContain("F2")
+		expect(proc.stderr).toContain("1 of 1 sources snapshotted")
+	})
+})
+
+describe("meaning verifier under node", () => {
+	test("#given the filled fixture #when fact pairs runs #then pairs.json holds one quote pair per cited ledger quote", () => {
+		const { dir, pairs } = pairedSession()
+		const written = JSON.parse(readFileSync(join(dir, "pairs.json"), "utf8"))
+		expect(pairs.code).toBe(0)
+		expect(written.skipped).toBe(false)
+		expect(written.pairs.map((p: Pair) => [p.pair_id, p.kind, p.fact_ids])).toEqual([
+			["P1", "quote", ["F1"]],
+			["P2", "quote", ["Q1"]],
+		])
+		expect(written.pairs_sha256).toMatch(/^[0-9a-f]{64}$/)
+		expect(Object.keys(written.counts).filter((key) => key !== "total" && key !== "force_strong")).toEqual([...PAIR_KINDS])
+		expect(written.verdict_schema).toEqual(JSON.parse(JSON.stringify(VERDICT_SCHEMA)))
+	})
+
+	test("#given cheap and strong verdicts agreeing on hedge_dropped #when meaning-check runs #then it exits 1 with one confirmed defect and one calibration line", () => {
+		const { dir, s } = pairedSession()
+		const drift = { pair_id: "P2", verdict: "drift", drift_kind: "hedge_dropped", fragment: "no earlier than 2027", source_fragment: "we estimate", explanation: "The estimate reads as a fact." }
+		const cheap = verdicts(dir, "cheap.json", "cheap", [drift, { pair_id: "P1", verdict: "ok" }])
+		const strong = verdicts(dir, "strong.json", "strong", [drift])
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), "--verdicts", cheap, "--verdicts", strong, ...s])
+		const record = JSON.parse(readFileSync(join(dir, "fidelity-meaning-defects.json"), "utf8"))
+		expect(checked.code).toBe(1)
+		expect(codesOf(checked.json)).toEqual(["meaning_drift_confirmed"])
+		expect(codesOf(record)).toEqual(["meaning_drift_confirmed"])
+		expect(calibrationRows(dir)).toHaveLength(1)
+		expect(calibrationRows(dir)[0]).toMatchObject({ pair_id: "P2", drift_kind: "hedge_dropped", confirmed: true, disputed: false })
+		const header = JSON.parse(readFileSync(join(dir, "fidelity-calibration.jsonl"), "utf8").split("\n")[0])
+		expect(header.promotion).toEqual({ ...PROMOTION })
+		const again = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), "--verdicts", cheap, "--verdicts", strong, ...s])
+		expect(again.code).toBe(1)
+		expect(calibrationRows(dir)).toHaveLength(1)
+	})
+
+	test("#given a dispute on the confirmed pair #when meaning-check runs #then the defect stays and the calibration line is disputed", () => {
+		const { dir, s } = pairedSession()
+		const drift = { pair_id: "P2", verdict: "drift", drift_kind: "hedge_dropped", fragment: "no earlier than 2027", source_fragment: "we estimate" }
+		const files = ["--verdicts", verdicts(dir, "cheap.json", "cheap", [drift, { pair_id: "P1", verdict: "ok" }]), "--verdicts", verdicts(dir, "strong.json", "strong", [drift])]
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, "--dispute", "P2", "--reason", "the operator states it", ...s])
+		expect(checked.code).toBe(1)
+		expect(codesOf(checked.json)).toEqual(["meaning_drift_confirmed"])
+		expect(calibrationRows(dir)[0]).toMatchObject({ pair_id: "P2", disputed: true, reason: "the operator states it" })
+	})
+
+	test("#given --edition md #when meaning-check runs #then it writes that edition's record, and an unknown edition refuses", () => {
+		const { dir, s } = pairedSession()
+		const clean = [{ pair_id: "P1", verdict: "ok" }, { pair_id: "P2", verdict: "ok" }]
+		const files = ["--verdicts", verdicts(dir, "cheap.json", "cheap", clean), "--verdicts", verdicts(dir, "strong.json", "strong", clean)]
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, "--edition", "md", ...s])
+		const unknown = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, "--edition", "epub", ...s])
+		expect(checked.code).toBe(0)
+		expect(JSON.parse(readFileSync(join(dir, "fidelity-meaning-defects.md.json"), "utf8"))).toMatchObject({ record_kind: "meaning", artifact_sha256: sha256(join(dir, "report.html")) })
+		expect(existsSync(join(dir, "fidelity-meaning-defects.json"))).toBe(false)
+		expect(unknown.code).toBe(2)
+	})
+
+	test("#given a dropped verdict and an unread pair #when meaning-check runs #then both pairs are meaning_unverified and it exits 1", () => {
+		const { dir, s } = pairedSession()
+		const cheap = verdicts(dir, "cheap.json", "cheap", [{ pair_id: "P2", verdict: "drift", drift_kind: "hedge_dropped", fragment: "certainly by 2027", source_fragment: "we estimate" }])
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), "--verdicts", cheap, ...s])
+		const summary = JSON.parse(checked.stderr.trim().split("\n").at(-1) ?? "{}")
+		expect(checked.code).toBe(1)
+		expect(checked.json.status).toBe("fail")
+		expect(codesOf(checked.json)).toEqual(["meaning_unverified", "meaning_unverified"])
+		expect(checked.json.unverified.map((gap: { pair_id: string }) => gap.pair_id)).toEqual(["P1", "P2"])
+		expect(summary).toMatchObject({ command: "fact meaning-check", defects: 2, dropped: 1, unverified: 2 })
+	})
+
+	test("#given an unreadable verdict file or a malformed pairs file #when meaning-check runs #then it exits 2", () => {
+		const { dir, s } = pairedSession()
+		const broken = join(dir, "broken.json")
+		writeFileSync(broken, "{ not json")
+		expect(nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), "--verdicts", broken, ...s]).code).toBe(2)
+		const ok = verdicts(dir, "cheap.json", "cheap", [])
+		for (const body of ["{}", "null", '{ "pairs": "P1" }']) {
+			writeFileSync(join(dir, "bad-pairs.json"), body)
+			expect(nodeJson(["fact", "meaning-check", "--pairs", join(dir, "bad-pairs.json"), "--verdicts", ok, ...s]).code, body).toBe(2)
+		}
+	})
+
+	test("#given a confirmed run then a dispute on the same inputs #when meaning-check reruns #then the log still holds one run with the dispute", () => {
+		const { dir, s } = pairedSession()
+		const drift = { pair_id: "P2", verdict: "drift", drift_kind: "hedge_dropped", fragment: "no earlier than 2027", source_fragment: "we estimate" }
+		const files = ["--verdicts", verdicts(dir, "cheap.json", "cheap", [drift, { pair_id: "P1", verdict: "ok" }]), "--verdicts", verdicts(dir, "strong.json", "strong", [drift])]
+		const first = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, ...s])
+		const disputed = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, "--dispute", "P2", "--reason", "the operator states it", ...s])
+		expect(disputed.code).toBe(1)
+		expect(disputed.json.run_id).toBe(first.json.run_id)
+		expect(disputed.json.promotion_eligibility).toMatchObject({ runs: 1, confirmed: 1, disputed_confirmed: 1, disputed_to_confirmed: 1 })
+		expect(calibrationRows(dir)).toEqual([expect.objectContaining({ pair_id: "P2", disputed: true, reason: "the operator states it" })])
+		const plain = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, ...s])
+		expect(plain.json.promotion_eligibility).toMatchObject({ runs: 1, disputed_confirmed: 1 })
+	})
+
+	test("#given a run with no flagged pair #when meaning-check runs #then the run is still logged and counted", () => {
+		const { dir, s } = pairedSession()
+		const ok = (pair_id: string) => ({ pair_id, verdict: "ok" })
+		const files = ["--verdicts", verdicts(dir, "cheap.json", "cheap", [ok("P1"), ok("P2")]), "--verdicts", verdicts(dir, "strong.json", "strong", [ok("P1"), ok("P2")])]
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), ...files, ...s])
+		expect(checked.code).toBe(0)
+		expect(calibrationRows(dir)).toEqual([])
+		expect(runLines(dir)).toEqual([expect.objectContaining({ run_id: checked.json.run_id, flagged: 0 })])
+		expect(checked.json.promotion_eligibility.runs).toBe(1)
+	})
+
+	test("#given a corrupt calibration log #when meaning-check runs #then it exits 2 naming the file and line", () => {
+		const { dir, s } = pairedSession()
+		writeFileSync(join(dir, "fidelity-calibration.jsonl"), "{ not json\n")
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs.json"), "--verdicts", verdicts(dir, "cheap.json", "cheap", []), ...s])
+		expect(checked.code).toBe(2)
+		expect(checked.stderr).toContain(`${join(dir, "fidelity-calibration.jsonl")}:1`)
+	})
+
+	test("#given a skipped pairs file #when meaning-check runs #then it is accepted only when the locked brief says off", () => {
+		const { dir, s } = fidelitySession()
+		const skip = join(dir, "skip.json")
+		writeFileSync(skip, JSON.stringify({ schemaVersion: 1, skipped: true, pairs: [] }))
+		const check = () => nodeJson(["fact", "meaning-check", "--pairs", skip, "--verdicts", verdicts(dir, "cheap.json", "cheap", []), ...s])
+		const on = check()
+		expect(on.code).toBe(1)
+		expect(on.json.error).toBe("meaning_check_required")
+		writeFileSync(join(dir, "brief.md"), "# Brief\n")
+		expect(check().json.error).toBe("fidelity_interview_incomplete")
+		expect(check().code).toBe(1)
+		writeFileSync(join(dir, "brief.md"), readFileSync(join(FIXTURES, "fidelity-brief-locked.md"), "utf8").replace("meaning check: on", "meaning check: off"))
+		const off = check()
+		expect(off.code).toBe(0)
+		expect(off.json.status).toBe("skipped")
+	})
+
+	test("#given a brief with meaning check off #when fact pairs runs #then it exits 0 and writes skipped", () => {
+		const { dir, s } = fidelitySession()
+		const brief = readFileSync(join(dir, "brief.md"), "utf8").replace("meaning check: on", "meaning check: off")
+		writeFileSync(join(dir, "brief.md"), brief)
+		nodeJson(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), ...s])
+		const pairs = nodeJson(["fact", "pairs", join(dir, "report.html"), "--out", join(dir, "pairs.json"), ...s])
+		expect(pairs.code).toBe(0)
+		expect(JSON.parse(readFileSync(join(dir, "pairs.json"), "utf8"))).toMatchObject({ skipped: true })
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/report-tools-3.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, onTestFinished, test } from "bun:test"
+import { createHash } from "node:crypto"
+import { copyFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { delimiter, join } from "node:path"
+import { PROMOTION } from "./fact-commands-meaning.mjs"
+import { writeFidelityRecord } from "./fidelity-records.mjs"
+import { PAIR_KINDS } from "./fact-pairs.mjs"
+import { VERDICT_SCHEMA } from "./meaning-check.mjs"
+import { POLISH_MARKUP_REASON } from "./polish-apply.mjs"
+import { COMMANDS, run } from "./report-tools.mjs"
+import { SCRIPT, FIXTURES, sessionDir, nodeWithoutBun, defectsFile, FIDELITY, sha256, CliRow, CliJson, nodeJson, fidelitySession, verify, codesOf, Pair, pairedSession, verdicts, calibrationRows, runLines, PolishJson, polishSession, polishApply, setField, fillTemplate, textSource, ledgerRow } from "./tests/report-tools-support"
+
+
+
+describe("polish wiring under node", () => {
+	test("#given the fixture edits #when fact polish-apply runs #then it exits 0, applies the wording edit, and rejects the numeral edit", () => {
+		const { dir } = polishSession()
+		const applied = polishApply(dir, join(FIDELITY, "polish-edits.json"))
+		const polished = readFileSync(join(dir, "report.polished.html"), "utf8")
+		expect(applied.code).toBe(0)
+		expect(applied.json.data).toMatchObject({ applied: 1, rejected: 1, unlocated: 0 })
+		expect(applied.json.defects.map((d) => [d.code, d.index])).toEqual([["polish_edit_rejected", 1]])
+		expect(polished).toContain("Collected from a single cited public page")
+		expect(polished).toContain("retrieved 2026-10-01")
+		expect(polished).not.toContain("2026-10-02")
+	})
+
+	test("#given an edit that adds an attribute #when polish-apply and polish-diff run #then apply refuses it as markup changed and diff exits 1", () => {
+		const { dir } = polishSession()
+		const html = readFileSync(join(dir, "report.html"), "utf8")
+		const edits = join(dir, "attribute.json")
+		writeFileSync(edits, JSON.stringify([{ before: "<h2>Findings</h2>", after: '<h2 id="findings">Findings</h2>', reason: "anchor" }]))
+		const applied = polishApply(dir, edits)
+		expect(applied.code).toBe(0)
+		expect(applied.json.data).toMatchObject({ applied: 0, rejected: 1, unlocated: 0 })
+		expect(applied.json.defects.map((d) => [d.code, d.index])).toEqual([["polish_edit_rejected", 0]])
+		expect(applied.json.defects[0]?.reason).toContain("markup changed")
+		expect(readFileSync(join(dir, "report.polished.html"), "utf8")).toBe(html)
+		writeFileSync(join(dir, "attribute.html"), html.replace("<h2>Findings</h2>", '<h2 id="findings">Findings</h2>'))
+		const diffed = nodeJson(["fact", "polish-diff", "--before", join(dir, "report.html"), "--after", join(dir, "attribute.html"), "--ledger", join(dir, "fact-ledger.json"), "--session-dir", dir])
+		expect(diffed.code).toBe(1)
+		expect(codesOf(diffed.json)).toContain("polish_diff_fail")
+		expect(JSON.stringify(diffed.json)).toContain("markup changed")
+	})
+
+	test("#given an edit whose before holds & #when fact polish-apply runs #then it prints polish-apply's own markup reason verbatim for that edit", () => {
+		const { dir } = polishSession()
+		const before = "Acme & Bolt"
+		const edits = join(dir, "ampersand.json")
+		writeFileSync(edits, JSON.stringify([{ before, after: "Acme and Bolt", reason: "ampersand" }]))
+		const applied = polishApply(dir, edits)
+		const line = `  rejected edit 0 ("${before}"): ${POLISH_MARKUP_REASON}`
+		expect(applied.code).toBe(0)
+		expect(applied.json.data).toMatchObject({ applied: 0, rejected: 1, unlocated: 0 })
+		expect(applied.json.defects.map((d) => [d.code, d.index, d.reason])).toEqual([["polish_edit_rejected", 0, POLISH_MARKUP_REASON]])
+		expect(applied.stderr.split("\n")).toContain(line)
+	})
+
+	test("#given a polished copy edited by hand #when fact polish-diff runs #then it exits 1 with polish_diff_fail", () => {
+		const { dir } = polishSession()
+		const html = readFileSync(join(dir, "report.html"), "utf8")
+		writeFileSync(join(dir, "hand.html"), html.replace("320 m", "321 m"))
+		const diffed = nodeJson(["fact", "polish-diff", "--before", join(dir, "report.html"), "--after", join(dir, "hand.html"), "--ledger", join(dir, "fact-ledger.json"), "--session-dir", dir])
+		expect(diffed.code).toBe(1)
+		expect(codesOf(diffed.json)).toContain("polish_diff_fail")
+	})
+
+	test("#given an accepted subject and object swap #when fact pairs runs with --changed-since #then only that sentence's pair is emitted, with the new text", () => {
+		const { dir, s } = polishSession()
+		const edits = join(dir, "swap.json")
+		writeFileSync(edits, JSON.stringify([{ before: "Acme acquired Bolt", after: "Bolt acquired Acme", reason: "word order" }]))
+		const applied = polishApply(dir, edits)
+		const map = join(dir, "report.html.fill-map.json")
+		const changed = nodeJson(["fact", "pairs", join(dir, "report.polished.html"), "--changed-since", map, "--out", join(dir, "pairs-changed.json"), ...s])
+		const written = JSON.parse(readFileSync(join(dir, "pairs-changed.json"), "utf8"))
+		expect(applied.json.data).toMatchObject({ applied: 1, rejected: 0 })
+		expect(changed.code).toBe(0)
+		expect(written.pairs.map((p: Pair) => [p.kind, p.fact_ids])).toEqual([["quote", ["F1"]]])
+		expect(written.pairs[0].sentence).toContain("Bolt acquired Acme")
+	})
+})
+
+describe("markdown editions under node", () => {
+	const MD = ["# Bridge", "", "## Findings", "", "The span length is {{F1:span_len}} [S4].", "", "The operator wrote {{Q1:completion}} [S4].", "", "## How this report was made", "", "Collected from one cited public page [S4].", "", "## Sources", "", "1. [S4] Bridge page, retrieved 2026-10-01.", ""].join("\n")
+
+	function mdSession() {
+		const session = fidelitySession()
+		writeFileSync(join(session.dir, "report.src.md"), MD)
+		const filled = nodeJson(["fact", "fill", join(session.dir, "report.src.md"), "--format", "md", "--out", join(session.dir, "report.md"), ...session.s])
+		return { ...session, filled }
+	}
+
+	test("#given a markdown source #when filled and verified as md #then verify passes and records the md bytes", () => {
+		const { dir, filled } = mdSession()
+		const checked = verify(dir, "report.md", ["--format", "md"])
+		expect(filled.code).toBe(0)
+		expect(readFileSync(join(dir, "report.md"), "utf8")).toContain("The span length is 320 m [S4].")
+		expect(checked.code).toBe(0)
+		expect(checked.json.defects).toEqual([])
+		expect(JSON.parse(readFileSync(join(dir, "fidelity-defects.json"), "utf8")).artifact_sha256).toBe(sha256(join(dir, "report.md")))
+	})
+
+	test("#given a filled markdown edition #when a value is hand-edited or a number typed #then md verify exits 1 with the code", () => {
+		const { dir } = mdSession()
+		const md = readFileSync(join(dir, "report.md"), "utf8")
+		writeFileSync(join(dir, "typed.md"), md.replace("## How", "Revenue grew 12% [S4].\n\n## How"))
+		copyFileSync(join(dir, "report.md.fill-map.json"), join(dir, "typed.md.fill-map.json"))
+		const typed = verify(dir, "typed.md", ["--format", "md"])
+		expect(typed.code).toBe(1)
+		expect(codesOf(typed.json)).toContain("untraceable_number")
+	})
+
+	test("#given a filled markdown edition with an unterminated fence #when verified or paired #then both refuse with exit 2", () => {
+		const { dir, s } = mdSession()
+		writeFileSync(join(dir, "fence.md"), `${readFileSync(join(dir, "report.md"), "utf8")}\n\`\`\`\nunclosed code\n`)
+		copyFileSync(join(dir, "report.md.fill-map.json"), join(dir, "fence.md.fill-map.json"))
+		const checked = verify(dir, "fence.md", ["--format", "md"])
+		expect(checked.code).toBe(2)
+		expect(checked.stderr).toContain("unterminated_fence")
+		expect(nodeJson(["fact", "pairs", join(dir, "fence.md"), "--out", join(dir, "pairs.json"), ...s]).code).toBe(2)
+	})
+
+	test("#given a filled markdown edition #when fact pairs runs on it #then it pairs the same quotes as the html edition", () => {
+		const { dir, s } = mdSession()
+		const pairs = nodeJson(["fact", "pairs", join(dir, "report.md"), "--out", join(dir, "pairs.json"), ...s])
+		expect(pairs.code).toBe(0)
+		expect(JSON.parse(readFileSync(join(dir, "pairs.json"), "utf8")).pairs.map((p: Pair) => p.fact_ids)).toEqual([["F1"], ["Q1"]])
+	})
+})
+
+describe("repair decide with several defect files", () => {
+	test("#given two --defects files #when decided #then the attempt signature carries both codes", async () => {
+		const dir = sessionDir()
+		const state = join(dir, "repair-state.json")
+		await run(["repair", "decide", "--state", state, "--defects", defectsFile(dir, "a.json", ["heading_generic"]), "--defects", defectsFile(dir, "b.json", ["untraceable_number"])])
+		const signature = JSON.parse(readFileSync(state, "utf8")).attempts[0].signature
+		expect(signature).toContain("heading_generic")
+		expect(signature).toContain("untraceable_number")
+	})
+})