oh-my-opencode 5.1.45 → 5.1.47

package/dist/skills/ulw-research/scripts/fact-commands-polish.mjs

@@ -0,0 +1,127 @@
+// fact-commands-polish.mjs - `fact polish-apply` and `fact polish-diff`, the script half of the
+// proofread gate, plus the --changed-since filter of `fact pairs`.
+//
+// The writing lane returns polish-edits.json ([{before, after, reason}]) and never edits the
+// report. polish-apply applies each edit through polish-apply.mjs and writes the result; a
+// rejected (major) or unlocated (minor) edit leaves its region unchanged and is listed with its
+// index and reason so the orchestrator can re-send it; every rejection reason is printed verbatim, one
+// line per rejected edit (index and the first 60 characters of its before), in the summary and in
+// data.rejected_reasons. It exits 0 whenever it wrote the output.
+// polish-diff is the whole-document backstop (polish-diff.mjs) between the pre-polish artifact
+// and any later copy; it exits 1 on a blocker. pairsChangedSince keeps only the pairs whose
+// sentence text (normalized) is not in the pre-polish artifact that a fill map names, so the
+// meaning readers re-check exactly what polish rewrote. No model, no network.
+
+import { existsSync, readFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+
+import { CliError, parseArgs, readJsonFile, sha256Of, writeJsonAtomic, writeTextAtomic } from "./cli-support.mjs"
+import { countDefects, DEFECT_CODES } from "./contracts.mjs"
+import { editionFormatOf, ledgerFrom, markdownAsHtml, sessionOf } from "./fact-commands-verify.mjs"
+import { extractPairs } from "./fact-pairs.mjs"
+import { applyEdits, POLISH_EDIT_FIELDS, validatePolishEdits } from "./polish-apply.mjs"
+import { diffPolish } from "./polish-diff.mjs"
+import { normalizeText } from "./text-normalize.mjs"
+
+export { ledgerFrom, POLISH_EDIT_FIELDS, validatePolishEdits }
+
+export const POLISH_RECORD = "polish-defects.json"
+
+/**
+ * The polish-diff exit policy: only a registry blocker fails the command; majors are reported.
+ * Fail-closed like the delivery barrier: a code the registry does not know refuses outright,
+ * because a caller-claimed severity may not demote it.
+ */
+export const polishDiffFails = (defects) =>
+	defects.some((defect) => {
+		if (!Object.hasOwn(DEFECT_CODES, defect?.code)) throw new CliError(`unknown defect code ${defect?.code}`)
+		return DEFECT_CODES[defect.code].severity === "blocker"
+	})
+
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8")
+	} catch (error) {
+		throw new CliError(`cannot read ${path}: ${error.code ?? error.message}`)
+	}
+}
+
+const withSeverity = (entry) => ({ ...entry, severity: DEFECT_CODES[entry.code].severity, hint: DEFECT_CODES[entry.code].hint })
+
+/** The first 60 characters of an edit's before, on one line. */
+const beforePreview = (before) => (typeof before === "string" ? before : "").replace(/\s+/gu, " ").slice(0, 60)
+
+/** One line per rejected edit: its index, the start of its before, and its reason verbatim. */
+const rejectionLine = (entry, edit) => `  rejected edit ${entry.index} ("${beforePreview(edit?.before)}"): ${entry.reason}`
+
+function runPolishApply(args) {
+	const [report] = args.positionals
+	const { flags } = args
+	if (!report || flags.edits === undefined || flags.out === undefined) throw new CliError("usage: fact polish-apply <report.html> --edits polish-edits.json --out <report.polished.html> [--ledger F] [--session-dir D]")
+	if (editionFormatOf(report, flags.format) === "md") throw new CliError("fact polish-apply takes the filled HTML edition; polish a Markdown edition through its HTML source")
+	const html = readText(report)
+	const editsText = readText(flags.edits)
+	const edits = readJsonFile(flags.edits)
+	try {
+		validatePolishEdits(edits)
+	} catch (error) {
+		throw new CliError(`${flags.edits} must be an array of {${Object.keys(POLISH_EDIT_FIELDS).join(", ")}} objects: ${error.message}`)
+	}
+	const result = applyEdits(html, edits, ledgerFrom(flags))
+	writeTextAtomic(flags.out, result.out)
+	const defects = [...result.rejected, ...result.unlocated].sort((a, b) => a.index - b.index).map(withSeverity)
+	const counts = { applied: result.applied.length, rejected: result.rejected.length, unlocated: result.unlocated.length }
+	const data = { out: resolve(flags.out), ...counts, applied_indexes: result.applied, input_sha256: sha256Of(html), edits_sha256: sha256Of(editsText), out_sha256: sha256Of(result.out) }
+	const rejected_reasons = result.rejected.map((entry) => rejectionLine(entry, edits[entry.index]))
+	const summary = [`fact polish-apply: ${counts.applied} applied, ${counts.rejected} rejected, ${counts.unlocated} unlocated of ${edits.length} edit(s)`, ...rejected_reasons].join("\n")
+	return { json: { command: "fact polish-apply", status: "pass", exitCode: 0, defects, data: { ...data, rejected_reasons } }, summary, exitCode: 0 }
+}
+
+function runPolishDiff(args) {
+	const { flags } = args
+	if (flags.before === undefined || flags.after === undefined) throw new CliError("usage: fact polish-diff --before <pre-polish.html> --after <polished.html> [--ledger F] [--out polish-defects.json] [--session-dir D]")
+	const after = readText(flags.after)
+	const defects = diffPolish(readText(flags.before), after, ledgerFrom(flags)).map((defect) => ({ ...defect, hint: DEFECT_CODES[defect.code]?.hint ?? null }))
+	const counts = countDefects(defects)
+	const status = polishDiffFails(defects) ? "fail" : "pass"
+	const exitCode = status === "fail" ? 1 : 0
+	const record = { command: "fact polish-diff", status, exitCode, before: resolve(flags.before), artifact: resolve(flags.after), artifact_sha256: sha256Of(after), defects, counts }
+	const session = sessionOf(flags)
+	const out = flags.out ?? (session === null ? null : join(session, POLISH_RECORD))
+	if (out !== null) writeJsonAtomic(resolve(out), record)
+	const summary = `fact polish-diff: ${status.toUpperCase()} - ${counts.blocker} blocker, ${counts.major} major, ${counts.minor} minor`
+	return { json: { ...record, out: out === null ? null : resolve(out) }, summary, exitCode }
+}
+
+const pairKey = (pair) => [pair.kind, pair.sentence_key, pair.claim_id ?? "", normalizeText(pair.sentence)].join("\u0000")
+
+/**
+ * The pairs whose sentence text changed since the pre-polish artifact a fill map names: a pair is
+ * kept unless the same (kind, sentence key, normalized sentence) occurs in that artifact. The map
+ * must carry the artifact's `artifact_sha256` and the bytes must still match it, so the filter is
+ * fail-closed on a hand-made or stale map.
+ * @param {object[]} pairs extractPairs output on the polished edition
+ * @param {string} mapPath the pre-polish fill map (fact fill's `<out>.fill-map.json`)
+ */
+export function pairsChangedSince(pairs, mapPath, ledger, claims) {
+	const map = readJsonFile(mapPath)
+	if (typeof map.artifact !== "string" || !existsSync(map.artifact)) throw new CliError(`${mapPath} names no readable pre-polish artifact`)
+	const text = readText(map.artifact)
+	if (typeof map.artifact_sha256 !== "string") throw new CliError(`${mapPath} fill map has no artifact_sha256; --changed-since needs the pre-polish hash`)
+	if (sha256Of(text) !== map.artifact_sha256) throw new CliError(`${map.artifact} changed after fill; --changed-since needs the pre-polish bytes`)
+	const html = map.format === "md" ? markdownAsHtml(text, map.entries, ledger).html : text
+	const before = new Map()
+	for (const pair of extractPairs(html, ledger, claims)) before.set(pairKey(pair), (before.get(pairKey(pair)) ?? 0) + 1)
+	return pairs.filter((pair) => {
+		const left = before.get(pairKey(pair)) ?? 0
+		if (left === 0) return true
+		before.set(pairKey(pair), left - 1)
+		return false
+	})
+}
+
+/** @param {string[]} argv the arguments after `fact polish-apply` or `fact polish-diff` */
+export function runFactPolish(sub, argv) {
+	const args = parseArgs(argv)
+	return sub === "polish-apply" ? runPolishApply(args) : runPolishDiff(args)
+}

package/dist/skills/ulw-research/scripts/fact-commands-verify.mjs

@@ -0,0 +1,183 @@
+// fact-commands-verify.mjs - `fact verify` and the Markdown projection it checks.
+//
+// fact verify runs the deterministic fidelity gate over one filled HTML or Markdown edition and
+// writes a fidelity record (default $SESSION_DIR/fidelity-defects.json, through
+// writeFidelityRecord) carrying the artifact's sha256. It
+// exits 1 on any blocker or major defect (the orchestrator then records `outcome gate fidelity
+// fail`); minors alone exit 0 and are listed. A Markdown edition is read through md-lite into an
+// escaped HTML projection (same line numbers) and checked with its fill map, which is the only
+// record of where its values sit; LaTeX is verified through its Markdown source.
+//
+// The delivery barrier that reads these records (and every other fidelity record) is
+// fidelity-records.mjs.
+
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+
+import { CliError, readJsonFile, sha256Of } from "./cli-support.mjs"
+import { countDefects } from "./contracts.mjs"
+import { recompute } from "./fact-derive.mjs"
+import { readLedger } from "./fact-ledger.mjs"
+import { validateLedger } from "./fact-ledger-schema.mjs"
+import { FIDELITY_RECORD, writeFidelityRecord } from "./fidelity-records.mjs"
+import { blocksDelivery, checkFidelity } from "./gates-fidelity.mjs"
+import { parseMarkdown } from "./md-lite.mjs"
+import { escapeHtml, parseRenderedQuote, renderQuote, renderValueHtml } from "./placeholder.mjs"
+import { sessionDirOf } from "./source-commands.mjs"
+
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8")
+	} catch (error) {
+		throw new CliError(`cannot read ${path}: ${error.code ?? error.message}`)
+	}
+}
+
+/**
+ * md-lite block kind -> its projection: the element tag (null = h<level>) and, for a run of one kind,
+ * the container that wraps the run. Code and table rows also take the specialized bodies below.
+ */
+export const MD_HTML_BLOCK_RULES = Object.freeze({
+	heading: Object.freeze({ tag: null }),
+	paragraph: Object.freeze({ tag: "p" }),
+	list_item: Object.freeze({ tag: "li", group: Object.freeze(["<ul>", "</ul>"]) }),
+	blockquote: Object.freeze({ tag: "blockquote" }),
+	code: Object.freeze({ tag: "code" }),
+	table_row: Object.freeze({ tag: "tr", group: Object.freeze(["<table>", "</table>"]) }),
+})
+
+/** Escaped text with inline links and code spans kept as elements, so a URL is never read as prose. */
+export const projectMarkdownInline = (text) =>
+	escapeHtml(text)
+		.replace(/\[([^\]]+)\]\(([^)\s]+)\)/gu, '<a href="$2">$1</a>')
+		.replace(/`([^`]+)`/gu, "<code>$1</code>")
+
+/** The element the HTML fill writes for one fill-map entry, or null when its bytes were edited since. */
+function entryHtml(text, entry, rows) {
+	const body = text.slice(entry.start, entry.end)
+	if (body !== entry.rendered) return null
+	const row = rows.get(entry.fact_id)
+	if (entry.translates) return `<span data-translates="${escapeHtml(entry.translates)}">${projectMarkdownInline(body.replace(/^<!--[\s\S]*?-->\s*/u, ""))}</span>`
+	if (!row) return `<data data-fact="${escapeHtml(entry.fact_id)}">${escapeHtml(body)}</data>`
+	const quoted = row.kind === "quote" ? parseRenderedQuote(body) : null
+	if (quoted) return renderQuote(row, entry.selector ?? "full", quoted.text, "html")
+	return row.kind === "quote" ? null : renderValueHtml(row, body)
+}
+
+/** [from, to) of the filled text as HTML, each intact fill-map entry rebuilt as its fill element. */
+function spanHtml(text, from, to, entries, rows, stale) {
+	let html = ""
+	let cursor = from
+	for (const entry of entries) {
+		if (entry.start < cursor || entry.end > to || entry.start < from || entry.replaced !== undefined) continue
+		const element = entryHtml(text, entry, rows)
+		if (element === null) continue
+		stale.delete(entry)
+		html += projectMarkdownInline(text.slice(cursor, entry.start)) + element
+		cursor = entry.end
+	}
+	return html + projectMarkdownInline(text.slice(cursor, to))
+}
+
+/**
+ * An escaped HTML projection of a filled Markdown edition: one element per md-lite block, each on
+ * the source line it starts on, lists and table rows grouped. Never a rendering for readers.
+ * @param {string} text the filled Markdown
+ * @param {{ fact_id: string, start: number, end: number, rendered: string, replaced?: string, translates?: string }[]} entries its fill map
+ * @param {{ rows: object[] }} ledger
+ * @returns {{ html: string, stale: object[] }} stale: entries whose bytes changed after fill (checked by text)
+ */
+export function markdownAsHtml(text, entries, ledger) {
+	const sorted = [...(entries ?? [])].sort((a, b) => a.start - b.start)
+	const rows = new Map((ledger?.rows ?? []).map((row) => [row.fact_id, row]))
+	const stale = new Set(sorted.filter((entry) => entry.replaced === undefined))
+	const lineAt = (offset) => text.slice(0, offset).split("\n").length
+	const parsed = parseMarkdown(text)
+	if (parsed.problems.length > 0) {
+		throw new CliError(`the Markdown edition is malformed: ${parsed.problems.map((problem) => `${problem.code} at line ${problem.line}`).join(", ")}; fix it before verifying`)
+	}
+	let html = "<!doctype html><html><head><title>md</title></head><body>"
+	let line = 1
+	let open = null
+	for (const block of parsed.blocks) {
+		const rule = MD_HTML_BLOCK_RULES[block.kind]
+		if (rule === undefined) throw new CliError(`md-lite block kind ${block.kind} has no projection rule`)
+		if (open && open !== block.kind) html += MD_HTML_BLOCK_RULES[open].group[1]
+		const target = lineAt(block.start)
+		if (target > line) html += "\n".repeat(target - line)
+		line = Math.max(line, target) + (text.slice(block.start, block.end).match(/\n/gu)?.length ?? 0)
+		if (rule.group && open !== block.kind) html += rule.group[0]
+		open = rule.group ? block.kind : null
+		const inner = (from, to) => spanHtml(text, from, to, sorted, rows, stale)
+		if (block.kind === "table_row") html += `<${rule.tag}>${block.cells.map((cell) => `<td>${inner(cell.start, cell.end)}</td>`).join("")}</${rule.tag}>`
+		else if (block.kind === "code") html += `<pre><${rule.tag}>${escapeHtml(block.text)}</${rule.tag}></pre>`
+		else {
+			const tag = rule.tag ?? `h${block.level}`
+			const replaced = block.kind === "blockquote" ? sorted.find((entry) => entry.replaced !== undefined && entry.start <= block.start && entry.end >= block.end) : undefined
+			const attrs = replaced ? ` data-fact="${escapeHtml(replaced.fact_id)}" data-replaced="${escapeHtml(replaced.replaced)}"` : ""
+			html += `<${tag}${attrs}>${inner(block.start, block.end)}</${tag}>`
+		}
+	}
+	return { html: `${html}${open ? MD_HTML_BLOCK_RULES[open].group[1] : ""}</body></html>\n`, stale: [...stale] }
+}
+
+/** The session dir from --session-dir or SESSION_DIR, or null; a bare flag names no session. */
+export const sessionOf = (flags) => {
+	const dir = flags["session-dir"] ?? process.env.SESSION_DIR
+	return dir && dir !== true ? resolve(dir) : null
+}
+
+/** The ledger from --ledger (validated) or from the session dir; every fact command loads it here. */
+export function ledgerFrom(flags, session = sessionOf(flags)) {
+	if (flags.ledger === undefined) {
+		if (session === null) throw new CliError("--ledger is required without --session-dir (or SESSION_DIR)")
+		return readLedger(session)
+	}
+	const ledger = readJsonFile(flags.ledger)
+	const errors = validateLedger(ledger)
+	if (errors.length > 0) throw new CliError(`${flags.ledger} is not a valid fact ledger: ${errors[0]}`)
+	return ledger
+}
+
+const MARKDOWN_EXTENSION = /\.(md|markdown)$/iu
+/** The edition format: the explicit flag, else md for a .md or .markdown path (any case), else html. */
+export const editionFormatOf = (path, flag) => flag ?? (MARKDOWN_EXTENSION.test(path) ? "md" : "html")
+
+/** The report's format (from --format or its extension) and, for Markdown, its fill map entries. */
+export function readEdition(report, flags) {
+	const format = editionFormatOf(report, flags.format)
+	if (format !== "html" && format !== "md") throw new CliError(`--format ${format}: verify html or md (a LaTeX edition is verified through its Markdown source)`)
+	const text = readText(report)
+	if (format === "html") return { format, text, entries: flags["fill-map"] === undefined ? null : readJsonFile(flags["fill-map"]).entries }
+	const map = flags["fill-map"] ?? `${report}.fill-map.json`
+	if (!existsSync(map)) throw new CliError(`a Markdown edition needs its fill map: ${map} is missing (pass --fill-map)`)
+	return { format, text, entries: readJsonFile(map).entries }
+}
+
+/** @param {{ positionals: string[], flags: Record<string, any> }} args parsed by runFact */
+export function runFactVerify(args) {
+	const [report] = args.positionals
+	const { flags } = args
+	if (!report) throw new CliError("usage: fact verify <report> [--format html|md] [--sources D] [--claims claims.json] [--fill-map F] [--brief brief.md] [--out fidelity-defects.json]")
+	const edition = readEdition(report, flags)
+	const sessionDir = sessionDirOf(flags)
+	const claimsPath = flags.claims ?? join(sessionDir, "claims.json")
+	const briefPath = flags.brief ?? join(sessionDir, "brief.md")
+	const ledger = readLedger(sessionDir)
+	const projected = edition.format === "md" ? markdownAsHtml(edition.text, edition.entries, ledger) : null
+	const result = checkFidelity(projected?.html ?? edition.text, {
+		ledger,
+		sourcesDir: resolve(flags.sources ?? join(sessionDir, "sources")),
+		claims: flags.claims !== undefined || existsSync(claimsPath) ? readJsonFile(claimsPath) : null,
+		fillMap: projected?.stale ?? edition.entries,
+		brief: existsSync(briefPath) ? readText(briefPath) : "",
+		baseDir: dirname(resolve(report)),
+		recompute,
+	})
+	const counts = countDefects(result.defects)
+	const status = result.defects.some(blocksDelivery) ? "fail" : "pass"
+	const exitCode = status === "fail" ? 1 : 0
+	const out = resolve(flags.out ?? join(sessionDir, FIDELITY_RECORD))
+	const record = writeFidelityRecord(out, "fidelity", { command: "fact verify", status, exitCode, format: edition.format, report: resolve(report), artifact_sha256: sha256Of(edition.text), defects: result.defects, counts, gatesRun: result.gatesRun })
+	return { json: { ...record, out }, summary: `fact verify: ${status.toUpperCase()} - ${counts.blocker} blocker, ${counts.major} major, ${counts.minor} minor`, exitCode }
+}

package/dist/skills/ulw-research/scripts/fact-commands.mjs

@@ -0,0 +1,241 @@
+// fact-commands.mjs - the `fact` subcommands of report-tools: add, quote, retract, export, fill,
+// derive, verify (fact-commands-verify.mjs), pairs and meaning-check (fact-commands-meaning.mjs), polish-apply and
+// polish-diff (fact-commands-polish.mjs). Every value reaches the ledger from a source
+// snapshot through a deterministic locator or from a declared derivation; nothing here accepts a
+// typed value. add and quote print the row with 60 chars of source context on each side (JSON
+// with --json). Exit 0 ok, 1 semantic failure (fact_not_located, fill errors, a refused
+// derivation), 2 usage. node: builtins and sibling imports only.
+
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, extname, join, resolve } from "node:path"
+
+import { CliError, parseArgs, sha256Of, writeJsonAtomic } from "./cli-support.mjs"
+import { DEFECT_CODES } from "./contracts.mjs"
+import { derive } from "./fact-derive.mjs"
+import { fill } from "./fact-fill.mjs"
+import { addRow, readLedger, retractRow, supersedeRow, writeLedger } from "./fact-ledger.mjs"
+import { locateFind, locateMatch, locatePageLine, locateTable } from "./fact-locate.mjs"
+import { QUALIFIER_FORMS } from "./fidelity-lexicon.mjs"
+import { readState, writeState } from "./fidelity-state.mjs"
+import { exportRows } from "./fidelity-values.mjs"
+import { pointedFlag, sessionDirOf, snapshotOf } from "./source-commands.mjs"
+
+const CONTEXT = 60
+const BOOLEANS = ["json", "csv", "md", "inline", "view", "replace-failed", "disjoint"]
+const QUALIFIER_OF = new Map(Object.entries(QUALIFIER_FORMS).flatMap(([term, forms]) => forms.map((form) => [form, term])))
+const slug = (text) => String(text).toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32) || "fact"
+
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8")
+	} catch (error) {
+		throw new CliError(`cannot read ${path}: ${error.code ?? error.message}`)
+	}
+}
+
+function nowIso(flags) {
+	const date = flags.now === undefined ? new Date() : new Date(flags.now)
+	if (Number.isNaN(date.getTime())) throw new CliError("--now requires an ISO timestamp")
+	return date.toISOString()
+}
+
+function failure(command, error, detail) {
+	const json = { command, status: "fail", exitCode: 1, error, ...detail }
+	return { json, summary: `${command}: ${error}${detail.message ? ` (${detail.message})` : ""}`, exitCode: 1 }
+}
+
+function locate(flags, snapshot, id, quote) {
+	const sourceId = id
+	if (quote) return locateMatch(snapshot.text, { match: flags.match, sourceId })
+	if (flags.find !== undefined) return locateFind(snapshot.text, { find: flags.find, unitExpected: flags["unit-expected"], sourceId })
+	if (flags.table !== undefined) {
+		if (snapshot.html === null) throw new CliError(`source ${id} has no source.html; --table needs a page snapshot`)
+		return locateTable(snapshot.html, { table: flags.table, row: flags.row, col: flags.col, sourceId })
+	}
+	if (flags.page !== undefined) return locatePageLine(snapshot.text, { page: Number(flags.page), line: Number(flags.line), sourceId })
+	throw new CliError("usage: fact add --source S<n> (--find TEXT | --table T --row R --col C | --page P --line L) --label LABEL")
+}
+
+function contextOf(text, row) {
+	const start = row.locator.char_start + (row.value_span?.[0] ?? 0)
+	const end = row.value_span ? row.locator.char_start + row.value_span[1] : row.locator.char_end
+	return { before: text.slice(Math.max(0, start - CONTEXT), start), match: text.slice(start, end), after: text.slice(end, end + CONTEXT) }
+}
+
+/** `fact add --assumed V --rationale R`: a value nobody measured, rendered ASSUMED; the rationale is required. */
+function runAssumed(args) {
+	const sessionDir = sessionDirOf(args.flags)
+	const ledger = readLedger(sessionDir)
+	const value = String(args.flags.assumed)
+	const row = addRow(ledger, { kind: "assumed", value, unit: args.flags.unit ?? null, raw: value, quote: "", extracted_by: "model", observed_at: nowIso(args.flags), label: args.required("label"), rationale: args.required("rationale") })
+	writeLedger(sessionDir, ledger)
+	return { json: { command: "fact add", status: "pass", exitCode: 0, defects: [], data: { row } }, exitCode: 0 }
+}
+
+function runAdd(args, quote) {
+	const command = quote ? "fact quote" : "fact add"
+	const { flags } = args
+	if (!quote && flags.assumed !== undefined) return runAssumed(args)
+	const id = args.required("source")
+	if (quote) args.required("match")
+	const sessionDir = sessionDirOf(flags)
+	const snapshot = snapshotOf(sessionDir, id)
+	const found = locate(flags, snapshot, id, quote)
+	if (found.error === "unit_expected_mismatch") return failure(command, "unit_mismatch", { message: `expected ${found.expected}, found ${found.found}`, candidates: found.candidates })
+	if (found.error) return failure(command, found.error, { message: `no single match in ${id}`, candidates: found.candidates })
+	const { meta } = snapshot
+	const host = URL.canParse(meta.url) ? new URL(meta.url).hostname : null
+	const labelSource = flags.find ?? flags.match ?? (flags.table !== undefined ? `${flags.row}_${flags.col}` : `p${flags.page}_l${flags.line}`)
+	const ledger = readLedger(sessionDir)
+	const row = addRow(ledger, {
+		kind: quote ? "quote" : "measured",
+		...(quote ? {} : { value: found.value, unit: found.unit, value_span: found.value_span, qualifier: QUALIFIER_OF.get(found.qualifier) ?? null }),
+		raw: found.raw,
+		quote: found.quote,
+		source_id: id,
+		locator: { ...found.locator, source_kind: meta.kind, url: meta.url, host, pointed: pointedFlag(sessionDir, meta.url) },
+		snapshot_sha256: meta.sha256,
+		sentence_id: found.sentence_id ?? null,
+		extracted_by: meta.extractor,
+		observed_at: nowIso(flags),
+		label: flags.label ?? slug(labelSource),
+		entity: flags.entity ?? null,
+		valid_at: flags["valid-at"] ?? null,
+		population: flags.population ?? null,
+		accounting_basis: flags["accounting-basis"] ?? null,
+		observation_id: flags.observation ?? null,
+		fuzzy: found.fuzzy === true,
+	})
+	writeLedger(sessionDir, ledger)
+	const context = contextOf(snapshot.text, row)
+	const json = { command, status: "pass", exitCode: 0, defects: [], data: { row, context } }
+	if (flags.json) return { json, exitCode: 0 }
+	const shown = quote ? row.quote : `${row.raw} (value ${row.value}${row.unit ? `, unit ${row.unit}` : ""})`
+	return { text: `${row.fact_id} ${row.label}: ${shown} [${id} ${row.sentence_id ?? "-"}]\n  ...${context.before}[${context.match}]${context.after}...`, exitCode: 0 }
+}
+
+function runRetract(args) {
+	const [id] = args.positionals
+	if (!id) throw new CliError("usage: fact retract <F<n>|Q<n>> --reason TEXT [--replacement ID]")
+	const sessionDir = sessionDirOf(args.flags)
+	const ledger = readLedger(sessionDir)
+	const reason = args.required("reason")
+	const row = args.flags.replacement === undefined ? retractRow(ledger, id, reason) : supersedeRow(ledger, id, args.flags.replacement, reason)
+	writeLedger(sessionDir, ledger)
+	return { json: { command: "fact retract", status: "pass", exitCode: 0, data: { fact_id: id, status: row.status, replacement: args.flags.replacement ?? null } }, exitCode: 0 }
+}
+
+const csvCell = (value) => (/[",\n]/.test(String(value)) ? `"${String(value).replace(/"/g, '""')}"` : String(value))
+
+/** "N of M sources snapshotted, by extractor ...": M also counts sources-ledger ids not yet snapshotted. */
+function coverageLine(sessionDir) {
+	const dir = join(sessionDir, "sources")
+	const snapped = existsSync(dir) ? readdirSync(dir).filter((name) => existsSync(join(dir, name, "meta.json"))) : []
+	const ledgerFile = join(sessionDir, "sources-ledger.md")
+	const listed = existsSync(ledgerFile) ? [...readText(ledgerFile).matchAll(/^\[S(\d+)\]/gm)].map((match) => `S${match[1]}`) : []
+	const byExtractor = {}
+	for (const id of snapped) {
+		const extractor = JSON.parse(readText(join(dir, id, "meta.json"))).extractor
+		byExtractor[extractor] = (byExtractor[extractor] ?? 0) + 1
+	}
+	const total = new Set([...snapped, ...listed]).size
+	const parts = Object.entries(byExtractor).map(([name, count]) => `${name} ${count}`)
+	return `${snapped.length} of ${total} sources snapshotted, by extractor: ${parts.join(", ") || "none"}`
+}
+
+function runExport(args) {
+	const sessionDir = sessionDirOf(args.flags)
+	const ledger = readLedger(sessionDir)
+	const coverage = coverageLine(sessionDir)
+	let text
+	if (args.flags.csv) {
+		const rows = exportRows(ledger)
+		text = `${["fact_id,label,plot_value,unit", ...rows.map((row) => [row.fact_id, row.label, row.plot_value, row.unit].map(csvCell).join(","))].join("\n")}\n`
+	} else text = `${JSON.stringify({ schemaVersion: ledger.schemaVersion, rows: ledger.rows, coverage }, null, 2)}\n`
+	if (args.flags.out === undefined) return { text, summary: coverage, exitCode: 0 }
+	writeFileSync(args.flags.out, text)
+	return { json: { command: "fact export", status: "pass", exitCode: 0, data: { out: resolve(args.flags.out), format: args.flags.csv ? "csv" : "json", sha256: sha256Of(text), coverage } }, summary: coverage, exitCode: 0 }
+}
+
+/** The inline edition: local stylesheets and scripts inlined, relative image paths made absolute. */
+function inlineAssets(html, baseDir) {
+	const local = (ref) => !/^[a-z][a-z0-9+.-]*:|^\/\//i.test(ref)
+	return html
+		.replace(/<link\b[^>]*\brel=["']stylesheet["'][^>]*>/gi, (tag) => {
+			const href = /\bhref=["']([^"']+)["']/i.exec(tag)?.[1]
+			return href && local(href) ? `<style>${readText(resolve(baseDir, href))}</style>` : tag
+		})
+		.replace(/<script\b([^>]*)\bsrc=["']([^"']+)["']([^>]*)><\/script>/gi, (tag, pre, src, post) => (local(src) ? `<script${pre}${post}>${readText(resolve(baseDir, src))}</script>` : tag))
+		.replace(/(<img\b[^>]*\bsrc=["'])([^"']+)(["'])/gi, (tag, pre, src, post) => (local(src) && !src.startsWith("/") ? `${pre}${resolve(baseDir, src)}${post}` : tag))
+}
+
+function runFill(args) {
+	const [source] = args.positionals
+	const { flags } = args
+	if (!source || (flags.out === undefined && !flags.view)) throw new CliError("usage: fact fill <src> (--out <path> | --view) [--format html|md|tex] [--inline] [--replace-failed]")
+	const format = flags.format ?? ({ ".md": "md", ".tex": "tex" }[extname(source).toLowerCase()] ?? "html")
+	if (!["html", "md", "tex"].includes(format)) throw new CliError("--format must be html, md, or tex")
+	if (flags.inline && format !== "html") throw new CliError("--inline applies to the html edition only")
+	const sessionDir = sessionDirOf(flags)
+	const state = flags["replace-failed"] ? readState(sessionDir) : null
+	const result = fill(readText(source), readLedger(sessionDir), { format: format === "tex" ? "md" : format, view: flags.view === true, ...(state ? { replaceFailed: state } : {}) })
+	const warnings = result.warnings
+	if (result.out === null) {
+		const defects = result.errors.map((error) => ({ ...error, severity: DEFECT_CODES[error.code]?.severity ?? "blocker", hint: DEFECT_CODES[error.code]?.hint ?? null }))
+		return { json: { command: "fact fill", status: "fail", exitCode: 1, defects, warnings }, summary: `fact fill: FAIL - ${defects.length} error(s), nothing written`, exitCode: 1 }
+	}
+	const out = flags.inline ? inlineAssets(result.out, dirname(resolve(source))) : result.out
+	if (flags.view) return { text: out, summary: `fact fill --view: ${result.fillMap.length} pointer(s), ${warnings.length} warning(s)`, exitCode: 0 }
+	writeFileSync(flags.out, out)
+	if (state) writeState(sessionDir, state)
+	const artifact = sha256Of(out)
+	const map = `${resolve(flags.out)}.fill-map.json`
+	writeJsonAtomic(map, { schemaVersion: 1, format, artifact: resolve(flags.out), artifact_sha256: artifact, entries: result.fillMap })
+	const data = { out: resolve(flags.out), map, artifact_sha256: artifact, occurrences: result.fillMap.length, warnings }
+	return { json: { command: "fact fill", status: "pass", exitCode: 0, defects: [], data }, summary: `fact fill: wrote ${flags.out} (${result.fillMap.length} pointer(s))`, exitCode: 0 }
+}
+
+function runDerive(args) {
+	const { flags } = args
+	const op = args.required("op")
+	const sessionDir = sessionDirOf(flags)
+	const ledger = readLedger(sessionDir)
+	// The registry refuses any field outside the operation's inputFields, so only the given flags go in; --unit null declares a dimensionless result.
+	const picked = ["to", "from", "num", "den", "part", "whole", "reference", "rationale", "label"].filter((key) => flags[key] !== undefined)
+	const spec = { op, now: nowIso(flags), ...Object.fromEntries(picked.map((key) => [key, flags[key]])) }
+	if (op === "expr") spec.formula = args.positionals[0]
+	else if (args.positionals.length > 0) spec.operands = args.positionals
+	if (flags.disjoint === true) spec.disjoint = true
+	if (flags.unit !== undefined) spec.unit = flags.unit === "null" ? null : flags.unit
+	const result = derive(ledger, spec)
+	if (result.error) return failure("fact derive", result.error, { message: result.detail, ...(result.hint ? { hint: result.hint } : {}) })
+	writeLedger(sessionDir, ledger)
+	const { row } = result
+	const json = { command: "fact derive", status: "pass", exitCode: 0, defects: [], data: { row, compatibility: result.compatibility } }
+	return flags.json ? { json, exitCode: 0 } : { text: `${row.fact_id} ${row.label}: ${row.render} (${row.operation} of ${row.operands.join(", ")}, ${result.compatibility})`, exitCode: 0 }
+}
+
+export async function runFact(argv) {
+	const [sub, ...rest] = argv
+	if (sub === "pairs" || sub === "meaning-check") return (await import("./fact-commands-meaning.mjs")).runFactMeaning(sub, rest)
+	if (sub === "polish-apply" || sub === "polish-diff") return (await import("./fact-commands-polish.mjs")).runFactPolish(sub, rest)
+	const args = parseArgs(rest, { booleans: BOOLEANS })
+	switch (sub) {
+		case "add":
+			return runAdd(args, false)
+		case "quote":
+			return runAdd(args, true)
+		case "retract":
+			return runRetract(args)
+		case "export":
+			return runExport(args)
+		case "fill":
+			return runFill(args)
+		case "derive":
+			return runDerive(args)
+		case "verify":
+			return (await import("./fact-commands-verify.mjs")).runFactVerify(args)
+		default:
+			throw new CliError("usage: fact <add|quote|retract|export|fill|verify|derive|pairs|meaning-check|polish-apply|polish-diff> ...")
+	}
+}

package/dist/skills/ulw-research/scripts/fact-derive.mjs

@@ -0,0 +1,66 @@
+// Public append boundary: dispatch through the operation table, verify transitive trust, append only on success.
+import { leaves, parseExpr } from "./fact-expr.mjs"
+import { readRow } from "./fact-ledger-kinds.mjs"
+import { addRow, nextId, validateLedger } from "./fact-ledger.mjs"
+import { recompute, verifyGraph } from "./fact-recompute.mjs"
+import { canonicalUnit, inputScale, refuse } from "./unit-algebra.mjs"
+import { refusal } from "./unit-errors.mjs"
+import { object, sameDeclared } from "./unit-metadata.mjs"
+import { display, renderValue, resultPrecision, toText } from "./unit-precision.mjs"
+import { expectedUnit, renderPrecision, ruleOf, unitMismatch } from "./unit-rules.mjs"
+export { recompute, display }
+
+/** Arithmetic and generated fields are chosen exclusively by the registry. */
+export function compute(op, rows, unit, ast, context, formula = null) {
+	const rule = ruleOf(op)
+	const out = rule.calculate(rows, context, ast, formula)
+	const mode = renderPrecision(op, unit, ast)
+	const precision = resultPrecision(rows, ast ? leaves(ast).literals : [], out.exact, mode)
+	const value = renderValue(out.exact, precision, mode)
+	const render = rule.render(display(value, unit), rows)
+	return { exact: toText(out.exact), value, render, raw: render, formula: out.formula, factor: out.factor, precision, compatibility: rule.compatibility, ...rule.metadataResult(rows) }
+}
+
+function declaredUnit(spec, rule) {
+	const own = Object.hasOwn(spec, "unit")
+	if ((!own && !rule.defaultUnit) || (own && spec.unit === undefined)) refuse("declare the result unit: pass unit (null for a dimensionless result)", undefined, "missing_unit", "an explicit unit or null")
+	const declared = own ? spec.unit : rule.defaultUnit(spec)
+	if (inputScale(declared)) refuse(`${declared} needs rescaling: declare %p and scale the value`)
+	return canonicalUnit(declared)
+}
+
+export function derive(ledger, spec) {
+	try {
+		if (!object(spec)) refuse("spec must be an object")
+		const errors = validateLedger(ledger)
+		if (errors.length) refuse(errors.join("; "), undefined, "ledger_schema", "a ledger conforming to KIND_RULES and canonical storage")
+		const rule = ruleOf(spec.op)
+		const allowed = ["op", "unit", "rationale", "label", "now", "context", ...rule.inputFields]
+		if (Object.keys(spec).some((key) => !allowed.includes(key))) refuse("spec carries fields outside its operation", undefined, "spec_fields", allowed)
+		const ast = rule.expression ? parseExpr(spec.formula) : null
+		const ids = rule.operandIds(spec, ast)
+		if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string")) refuse(`${spec.op} needs its operand fact ids`, undefined, "operands", "an array of existing fact ids")
+		const verified = verifyGraph(ledger, ids, true)
+		if (!verified.ok) return { error: "incompatible_operands", ...verified }
+		const byId = new Map(ledger.rows.map((r) => [r.fact_id, r]))
+		const rows = ids.map((id) => readRow(byId.get(id)))
+		const context = rule.context(spec)
+		if (Object.hasOwn(spec, "context") && !sameDeclared(spec.context, context)) refuse("supplied context differs from the operation's input fields", undefined, "context", context ?? "explicit null")
+		const shape = rule.shape({ operation: spec.op, operands: ids, formula: spec.formula, context })
+		if (shape) refuse(shape, undefined, "context_or_formula", "the operation's declared context and matching formula operand set")
+		const expected = expectedUnit(spec.op, rows, { ast, context: { ...context, rationale: spec.rationale ?? null } })
+		const declared = declaredUnit(spec, rule)
+		if (declared !== expected) refuse(unitMismatch(spec.op, rows, declared, expected), undefined, "result_unit", { unit: expected })
+		const result = compute(spec.op, rows, expected, ast, context, spec.formula)
+		const row = addRow(ledger, {
+			kind: rule.kind, unit: expected, quote: "", extracted_by: "fact-derive",
+			observed_at: spec.now ?? new Date().toISOString(),
+			label: spec.label ?? `${spec.op}-${nextId(ledger, rule.kind).toLowerCase()}`,
+			...result, operation: spec.op, operands: ids, derived_from: ids,
+			rationale: spec.rationale ?? null, context,
+		})
+		return { row, compatibility: rule.compatibility }
+	} catch (error) {
+		return { error: "incompatible_operands", ...refusal(error) }
+	}
+}