oh-my-opencode 5.1.47 → 5.1.48

package/dist/skills/ulw-research/scripts/copy-returns-polish.test.ts

@@ -78,7 +78,7 @@ describe("the polish edit contract is polish-apply's", () => {
 					return "refused"
 				}
 			})()
-			const cli = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "out.html")]))
+			const cli = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "out.html")]))
 			expect(cli === "ok" ? "ok" : "refused").toBe(direct)
 			if (cli !== "ok") expect(cli).toContain(editsPath)
 		})
@@ -87,7 +87,7 @@ describe("the polish edit contract is polish-apply's", () => {
 
 describe("the ledger loader is one shared helper", () => {
 	const pairs = (extra: string[]) => () => runFactMeaning("pairs", [reportPath, "--brief", BRIEF, "--out", join(dir, "pairs.json"), ...extra])
-	const diff = (extra: string[]) => () => runFactPolish("polish-diff", ["--before", reportPath, "--after", reportPath, ...extra])
+	const diff = (extra: string[]) => () => runFactPolish("polish-diff", ["--before", reportPath, "--after", reportPath, "--brief", BRIEF, ...extra])
 
 	test("#given the command modules #when read #then neither defines its own ledger loader or session resolver", () => {
 		expect(polishCommand.ledgerFrom).toBe(ledgerFrom)
@@ -122,7 +122,7 @@ describe("the edition format comes from verify's grammar", () => {
 		expect(source("fact-commands-polish.mjs")).not.toMatch(/md\|markdown/u)
 		for (const name of ["r.md", "R.MD", "r.markdown", "R.Markdown", "r.html", "r.HTML"]) {
 			const path = file(name, readFileSync(reportPath, "utf8"))
-			const result = outcome(() => runFactPolish("polish-apply", [path, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "out.html")]))
+			const result = outcome(() => runFactPolish("polish-apply", [path, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "out.html")]))
 			expect(result.includes("takes the filled HTML edition"), name).toBe(editionFormatOf(path, undefined) === "md")
 		}
 	})
@@ -130,7 +130,7 @@ describe("the edition format comes from verify's grammar", () => {
 
 describe("polish-diff counts with contracts and exits on blockers only", () => {
 	type DiffRun = { exitCode: number; json: { counts: Record<string, number>; defects: { severity: string }[] } }
-	const run = (before: string, after: string) => runFactPolish("polish-diff", ["--before", file("b.html", doc(before)), "--after", file("a.html", doc(after)), "--ledger", ledgerPath]) as unknown as DiffRun
+	const run = (before: string, after: string) => runFactPolish("polish-diff", ["--before", file("b.html", doc(before)), "--after", file("a.html", doc(after)), "--ledger", ledgerPath, "--brief", BRIEF]) as unknown as DiffRun
 
 	test("#given every registry code #when polishDiffFails classifies it #then only registry blockers fail", () => {
 		for (const [code, entry] of Object.entries(DEFECT_CODES) as [string, { severity: string }][]) expect(polishDiffFails([{ code, severity: "minor" }]), code).toBe(entry.severity === "blocker")
@@ -161,7 +161,7 @@ describe("fact polish-apply prints every rejection reason verbatim", () => {
 	test("#given an edit holding & #when fact polish-apply runs #then the printed line carries polish-apply's own markup reason", () => {
 		const before = "Revenue & profit rose across the year"
 		const editsPath = file("edits-markup-ampersand.json", JSON.stringify([{ before, after: "Revenue and profit rose across the year", reason: "wording" }]))
-		const run = runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "ampersand.html")]) as unknown as ApplyRun
+		const run = runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "ampersand.html")]) as unknown as ApplyRun
 
 		expect(run.exitCode).toBe(0)
 		expect(run.json.data.rejected).toBe(1)
@@ -203,7 +203,7 @@ describe("polish-apply writes atomically and honours --format", () => {
 
 	test("#given --format md on an .html report #when polish-apply runs #then it refuses the Markdown edition", () => {
 		const editsPath = file("edits-format.json", "[]")
-		const result = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "fmt.html"), "--format", "md"]))
+		const result = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "fmt.html"), "--format", "md"]))
 		expect(result).toContain("takes the filled HTML edition")
 	})
 })

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

@@ -0,0 +1,86 @@
+// fact-commands-fill.mjs - `fact fill`, the reader-facing fill of a placeholder source.
+//
+// It refuses an unlocked brief (fidelity_interview_incomplete) and applies the locked `## Fidelity`
+// fields: `derived numbers: none` and the source floor refuse rows (derived_not_allowed,
+// source_outside_floor, evaluated at every fill), `languages` decides whether a translation after a
+// quote binds to it, and `fallback` picks the block quote or omission for --replace-failed. Any
+// error writes no edition, fill map, or state; the one write that survives a refusal is the
+// ledger's cached outside_floor per row (skipped under --view). The fill map records brief_sha256,
+// the locked block fact verify checks it against. node: builtins and sibling imports only.
+
+import { readFileSync, writeFileSync } from "node:fs"
+import { dirname, extname, resolve } from "node:path"
+
+import { CliError, sha256Of, writeJsonAtomic } from "./cli-support.mjs"
+import { DEFECT_CODES } from "./contracts.mjs"
+import { FILL_FORMATS, fill } from "./fact-fill.mjs"
+import { readLedger, writeLedger } from "./fact-ledger.mjs"
+import { briefHashOf, fillPolicy, lockedBrief, policyErrors } from "./fidelity-policy.mjs"
+import { readState, writeState } from "./fidelity-state.mjs"
+import { findPlaceholders } from "./placeholder.mjs"
+import { sessionDirOf } from "./source-commands.mjs"
+
+/** The CLI's input vocabulary: fill's output formats plus aliases (tex is filled as md), and the extension defaults. */
+export const FILL_INPUT_FORMAT_RULES = Object.freeze({
+	aliases: Object.freeze({ tex: "md" }),
+	extensions: Object.freeze({ ".md": "md", ".tex": "tex" }),
+})
+export const FILL_INPUT_FORMATS = Object.freeze([...FILL_FORMATS, ...Object.keys(FILL_INPUT_FORMAT_RULES.aliases)])
+const fillFormatOf = (format) => FILL_INPUT_FORMAT_RULES.aliases[format] ?? format
+
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8")
+	} catch (error) {
+		throw new CliError(`cannot read ${path}: ${error.code ?? error.message}`)
+	}
+}
+
+/** 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))
+}
+
+/** @param {{ positionals: string[], flags: Record<string, any> }} args parsed by runFact */
+export function runFactFill(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] [--brief brief.md]")
+	const format = flags.format ?? FILL_INPUT_FORMAT_RULES.extensions[extname(source).toLowerCase()] ?? "html"
+	if (!FILL_INPUT_FORMATS.includes(format)) throw new CliError(`--format must be ${FILL_INPUT_FORMATS.slice(0, -1).join(", ")}, or ${FILL_INPUT_FORMATS.at(-1)}`)
+	if (flags.inline && format !== "html") throw new CliError("--inline applies to the html edition only")
+	const sessionDir = sessionDirOf(flags)
+	const { parsed, refusal } = lockedBrief("fact fill", flags)
+	if (refusal) return refusal
+	const policy = fillPolicy(parsed)
+	const text = readText(source)
+	const ledger = readLedger(sessionDir)
+	const refused = policyErrors(text, findPlaceholders(text), ledger, sessionDir, policy)
+	if (refused.cacheChanged && !flags.view) writeLedger(sessionDir, ledger)
+	const state = flags["replace-failed"] ? readState(sessionDir) : null
+	const result = fill(text, ledger, { format: fillFormatOf(format), view: flags.view === true, fallback: policy.fallback, ...(state ? { replaceFailed: state } : {}) })
+	const warnings = result.warnings
+	if (result.out === null || refused.errors.length > 0) {
+		const filled = result.errors.map((error) => ({ ...error, severity: DEFECT_CODES[error.code]?.severity ?? "blocker", hint: DEFECT_CODES[error.code]?.hint ?? null }))
+		const defects = [...refused.errors, ...filled]
+		return { json: { command: "fact fill", status: "fail", exitCode: 1, defects, warnings }, summary: `fact fill: FAIL - ${defects.length} error(s), nothing written`, exitCode: 1 }
+	}
+	const entries = policy.translations ? result.fillMap : result.fillMap.filter((entry) => entry.translates === undefined)
+	const out = flags.inline ? inlineAssets(result.out, dirname(resolve(source))) : result.out
+	if (flags.view) return { text: out, summary: `fact fill --view: ${entries.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`
+	const brief = briefHashOf(parsed)
+	writeJsonAtomic(map, { schemaVersion: 1, format, artifact: resolve(flags.out), artifact_sha256: artifact, brief_sha256: brief, entries })
+	const data = { out: resolve(flags.out), map, artifact_sha256: artifact, brief_sha256: brief, occurrences: entries.length, warnings }
+	return { json: { command: "fact fill", status: "pass", exitCode: 0, defects: [], data }, summary: `fact fill: wrote ${flags.out} (${entries.length} pointer(s))`, exitCode: 0 }
+}

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

@@ -8,7 +8,8 @@
 // fidelity-calibration.jsonl: a header with the promotion criterion on first write, then per run
 // one run line plus one line per flagged pair. The run id hashes the inputs only, so a rerun or a
 // --dispute rerun of the same inputs replaces that run's lines in place (disputes carry forward)
-// instead of counting a second run. Neither command calls a model or the network.
+// instead of counting a second run. Both refuse an unlocked brief (fidelity_interview_incomplete) before
+// reading anything else. Neither command calls a model or the network.
 
 import { existsSync, readFileSync } from "node:fs"
 import { dirname, join, resolve } from "node:path"
@@ -18,7 +19,8 @@ import { countDefects } from "./contracts.mjs"
 import { ledgerFrom, markdownAsHtml, readEdition, sessionOf } from "./fact-commands-verify.mjs"
 import { pairsChangedSince } from "./fact-commands-polish.mjs"
 import { extractPairs, PAIR_KINDS } from "./fact-pairs.mjs"
-import { FIDELITY_INCOMPLETE, meaningCheckEnabled, requireLockedBrief } from "./fidelity-brief.mjs"
+import { FIDELITY_INCOMPLETE } from "./fidelity-brief.mjs"
+import { briefPathOf, lockedBrief, meaningCheckEnabled } from "./fidelity-policy.mjs"
 import { MEANING_RECORD, writeFidelityRecord } from "./fidelity-records.mjs"
 import { blocksDelivery } from "./gates-fidelity.mjs"
 import { ingestVerdicts, unverifiedDefects, VERDICT_SCHEMA } from "./meaning-check.mjs"
@@ -36,25 +38,15 @@ const inSession = (session, name, flag) => {
 	return join(session, name)
 }
 
-function briefState(flags, session) {
-	const path = flags.brief ?? inSession(session, "brief.md", "--brief")
-	const lock = requireLockedBrief(path)
-	if (lock.exitCode === 2) throw new CliError(`${path}: malformed ## Fidelity block: ${lock.errors.join("; ")}`)
-	return { path, locked: lock.locked, off: !meaningCheckEnabled(lock.parsed) }
-}
-
 function runPairs(args) {
 	const [report] = args.positionals
 	const { flags } = args
 	if (!report) throw new CliError("usage: fact pairs <report> [--format html|md] [--ledger F] [--claims claims.json] [--changed-since <fill-map.json>] [--brief brief.md] [--out pairs.json]")
 	const session = sessionOf(flags)
 	const out = resolve(flags.out ?? inSession(session, PAIRS_FILE, "--out"))
-	const brief = briefState(flags, session)
-	if (!brief.locked) {
-		const json = { command: "fact pairs", status: "fail", exitCode: 1, error: "fidelity_interview_incomplete", message: `${brief.path} has no locked ## Fidelity block` }
-		return { json, summary: `fact pairs: ${json.message}`, exitCode: 1 }
-	}
-	if (brief.off) {
+	const { parsed, refusal } = lockedBrief("fact pairs", flags)
+	if (refusal) return refusal
+	if (!meaningCheckEnabled(parsed)) {
 		const record = { schemaVersion: 1, skipped: true, reason: "meaning check: off", pairs: [] }
 		writeJsonAtomic(out, record)
 		return { json: { command: "fact pairs", status: "skipped", exitCode: 0, data: { out, ...record } }, summary: "fact pairs: skipped (meaning check: off)", exitCode: 0 }
@@ -125,23 +117,23 @@ function recordCalibration(path, lines, runId, pairsSha) {
 }
 
 /** A `{ skipped: true }` pairs file is accepted only when the locked brief turns the meaning check off. */
-function skippedRefusal(flags, session) {
-	const brief = briefState(flags, session)
-	if (!brief.locked) return { error: FIDELITY_INCOMPLETE, message: `${brief.path} has no locked ## Fidelity block, so a skipped meaning check cannot be accepted` }
-	if (!brief.off) return { error: "meaning_check_required", message: `${flags.pairs} says skipped but ${brief.path} has meaning check on; rerun fact pairs` }
+function skippedRefusal(flags, parsed) {
+	if (meaningCheckEnabled(parsed)) return { error: "meaning_check_required", message: `${flags.pairs} says skipped but ${briefPathOf(flags)} has meaning check on; rerun fact pairs` }
 	return null
 }
 
 function runMeaningCheck(args) {
 	const { flags } = args
-	const usage = "usage: fact meaning-check --pairs pairs.json --verdicts cheap.json [--verdicts strong.json] [--dispute P<n> --reason TEXT] [--run-id ID] [--calibration F] [--out F]"
+	const usage = "usage: fact meaning-check --pairs pairs.json --verdicts cheap.json [--verdicts strong.json] [--dispute P<n> --reason TEXT] [--run-id ID] [--calibration F] [--brief brief.md] [--out F]"
 	if (flags.pairs === undefined || !Array.isArray(flags.verdicts)) throw new CliError(usage)
 	const session = sessionOf(flags)
+	const { parsed, refusal } = lockedBrief("fact meaning-check", flags)
+	if (refusal) return { ...refusal, json: { ...refusal.json, error: FIDELITY_INCOMPLETE } }
 	const pairsText = readFileSync(flags.pairs, "utf8")
 	const pairsDoc = readJsonFile(flags.pairs)
 	if (pairsDoc?.skipped === true) {
-		const refusal = skippedRefusal(flags, session)
-		if (refusal !== null) return { json: { command: "fact meaning-check", status: "fail", exitCode: 1, ...refusal }, summary: `fact meaning-check: ${refusal.message}`, exitCode: 1 }
+		const skipped = skippedRefusal(flags, parsed)
+		if (skipped !== null) return { json: { command: "fact meaning-check", status: "fail", exitCode: 1, ...skipped }, summary: `fact meaning-check: ${skipped.message}`, exitCode: 1 }
 		return { json: { command: "fact meaning-check", status: "skipped", exitCode: 0, defects: [] }, summary: JSON.stringify({ command: "fact meaning-check", status: "skipped" }), exitCode: 0 }
 	}
 	if (typeof pairsDoc?.artifact_sha256 !== "string" || typeof pairsDoc.report !== "string") throw new CliError(`${flags.pairs} names no artifact_sha256 and report, so the meaning record cannot be bound to an edition; rerun fact pairs`)

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

@@ -19,6 +19,7 @@ import { CliError, parseArgs, readJsonFile, sha256Of, writeJsonAtomic, writeText
 import { countDefects, DEFECT_CODES } from "./contracts.mjs"
 import { editionFormatOf, ledgerFrom, markdownAsHtml, sessionOf } from "./fact-commands-verify.mjs"
 import { extractPairs } from "./fact-pairs.mjs"
+import { lockedBrief } from "./fidelity-policy.mjs"
 import { applyEdits, POLISH_EDIT_FIELDS, validatePolishEdits } from "./polish-apply.mjs"
 import { diffPolish } from "./polish-diff.mjs"
 import { normalizeText } from "./text-normalize.mjs"
@@ -57,8 +58,10 @@ const rejectionLine = (entry, edit) => `  rejected edit ${entry.index} ("${befor
 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 (!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] [--brief brief.md] [--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 { refusal } = lockedBrief("fact polish-apply", flags)
+	if (refusal) return refusal
 	const html = readText(report)
 	const editsText = readText(flags.edits)
 	const edits = readJsonFile(flags.edits)
@@ -79,7 +82,9 @@ function runPolishApply(args) {
 
 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]")
+	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] [--brief brief.md] [--session-dir D]")
+	const { refusal } = lockedBrief("fact polish-diff", flags)
+	if (refusal) return refusal
 	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)

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

@@ -8,6 +8,11 @@
 // 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 locked brief is re-judged here, not only at fill: the edition's fill map (--fill-map, else
+// `<report>.fill-map.json` when present) must carry the current brief's brief_sha256
+// (brief_changed), and policyErrors re-runs over every data-fact the edition carries, so an
+// edition that violates the current derived-numbers or source-floor rule fails here too.
+//
 // The delivery barrier that reads these records (and every other fidelity record) is
 // fidelity-records.mjs.
 
@@ -19,6 +24,7 @@ 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 { briefBindingErrors, fillPolicy, lockedBrief, policyErrors } from "./fidelity-policy.mjs"
 import { FIDELITY_RECORD, writeFidelityRecord } from "./fidelity-records.mjs"
 import { blocksDelivery, checkFidelity } from "./gates-fidelity.mjs"
 import { parseMarkdown } from "./md-lite.mjs"
@@ -159,8 +165,11 @@ 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 { parsed, refusal } = lockedBrief("fact verify", flags)
+	if (refusal) return refusal
+	const policy = fillPolicy(parsed)
+	const edition = readEdition(report, flags)
 	const claimsPath = flags.claims ?? join(sessionDir, "claims.json")
 	const briefPath = flags.brief ?? join(sessionDir, "brief.md")
 	const ledger = readLedger(sessionDir)
@@ -174,10 +183,15 @@ export function runFactVerify(args) {
 		baseDir: dirname(resolve(report)),
 		recompute,
 	})
-	const counts = countDefects(result.defects)
-	const status = result.defects.some(blocksDelivery) ? "fail" : "pass"
+	const checked = projected?.html ?? edition.text
+	const pointers = [...checked.matchAll(/\bdata-fact="([^"]+)"/gu)].map((match) => ({ token: match[0], start: match.index, parsed: { id: match[1] } }))
+	const mapPath = flags["fill-map"] ?? `${report}.fill-map.json`
+	const bound = existsSync(mapPath) ? briefBindingErrors(readJsonFile(mapPath), mapPath, parsed) : []
+	const defects = [...bound, ...policyErrors(checked, pointers, ledger, sessionDir, policy).errors, ...result.defects]
+	const counts = countDefects(defects)
+	const status = 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 })
+	const record = writeFidelityRecord(out, "fidelity", { command: "fact verify", status, exitCode, format: edition.format, report: resolve(report), artifact_sha256: sha256Of(edition.text), 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

@@ -1,22 +1,19 @@
-// 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
+// fact-commands.mjs - the `fact` subcommands of report-tools: add, quote, retract, export, derive,
+// fill (fact-commands-fill.mjs), 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 { join, resolve } from "node:path"
 
-import { CliError, parseArgs, sha256Of, writeJsonAtomic } from "./cli-support.mjs"
-import { DEFECT_CODES } from "./contracts.mjs"
+import { CliError, parseArgs, sha256Of } from "./cli-support.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"
 
@@ -157,44 +154,6 @@ function runExport(args) {
 	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")
@@ -230,7 +189,7 @@ export async function runFact(argv) {
 		case "export":
 			return runExport(args)
 		case "fill":
-			return runFill(args)
+			return (await import("./fact-commands-fill.mjs")).runFactFill(args)
 		case "derive":
 			return runDerive(args)
 		case "verify":

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

@@ -10,7 +10,8 @@ import { failureCount, markReplaced, sentenceKey } from "./fidelity-state.mjs"
 import { findPlaceholders, lead, qualifiedText, renderBlockquote, renderQuote, renderValueHtml, subSpan, valueParts } from "./placeholder.mjs"
 import { splitSentences } from "./sentence-split.mjs"
 
-const FORMATS = Object.freeze(["html", "md"])
+/** The output formats fill renders. */
+export const FILL_FORMATS = Object.freeze(["html", "md"])
 const TRANSLATION = Object.freeze({
 	html: /^\s*<span data-translates="(Q\d+)">[\s\S]*?<\/span>/u,
 	md: /^\s*<!-- translates: (Q\d+) -->[^\n]*/u,
@@ -166,7 +167,7 @@ function assemble(text, parts, context) {
  */
 export function fill(sourceText, ledger, options = {}) {
 	const format = options.format ?? "html"
-	if (!FORMATS.includes(format)) throw new TypeError(`format must be one of ${FORMATS.join(", ")}`)
+	if (!FILL_FORMATS.includes(format)) throw new TypeError(`format must be one of ${FILL_FORMATS.join(", ")}`)
 	const rows = new Map(ledger.rows.map((row) => [row.fact_id, row]))
 	const found = findPlaceholders(sourceText)
 	const errors = []

package/dist/skills/ulw-research/scripts/fidelity-policy.mjs

@@ -0,0 +1,183 @@
+// fidelity-policy.mjs - what the locked `## Fidelity` block of brief.md means to the CLI stages.
+//
+// lockedBrief is the gate the six reader-facing stages (fact fill, verify, pairs, meaning-check,
+// polish-apply, polish-diff) run before reading or writing anything: an unlocked brief returns
+// one fidelity_interview_incomplete defect (exit 1), a malformed block is a usage error (exit 2).
+// fillPolicy reads the fields fact fill consumes (a value off its table is a usage error, exit 2),
+// and policyErrors refuses a placeholder whose row the brief forbids: derived_not_allowed
+// (`derived numbers: none` against a derived, converted, or assumed row) and source_outside_floor
+// (the source floor is evaluated live against each source's meta.json at every fill and verify;
+// under any floor but `standard` a row resting on no source is refused too; a row's outside_floor
+// is only the cached result). briefHashOf binds the locked block into the fill map, and
+// briefBindingErrors refuses an edition whose map was filled under another brief (brief_changed).
+// Collection stages never call this module. node: builtins and sibling imports only.
+
+import { existsSync, readFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+
+import { CliError, sha256Of } from "./cli-support.mjs"
+import { DEFECT_CODES } from "./contracts.mjs"
+import { KIND_RULES } from "./fact-ledger-kinds.mjs"
+import { FIDELITY_FIELDS, meaningCheckEnabled, requireLockedBrief } from "./fidelity-brief.mjs"
+
+export { meaningCheckEnabled }
+
+/**
+ * Ledger kinds a brief with `derived numbers: none` refuses. A policy list, not the ledger's
+ * derivation set: it also names assumed. Every name must be a KIND_RULES kind (checked at load).
+ */
+const DERIVED_KINDS = Object.freeze(["derived", "converted", "assumed"])
+for (const kind of DERIVED_KINDS) {
+	if (!Object.hasOwn(KIND_RULES, kind)) throw new Error(`fidelity-policy: ${kind} is not a KIND_RULES kind`)
+}
+
+/** Fields whose only legal values are a closed table: value (any case) -> its reading. */
+const VALUE_TABLES = Object.freeze({
+	"derived numbers": Object.freeze({ allowed: false, none: true }),
+	fallback: Object.freeze({ "block-quote": "quote", omit: "omit" }),
+})
+
+/** The reading of a table value; any other text is a usage error naming the field and the value. */
+function tableValue(field, value) {
+	const table = VALUE_TABLES[field]
+	const key = value.trim().toLowerCase()
+	if (Object.hasOwn(table, key)) return table[key]
+	throw new CliError(`${field} "${value}" is not ${Object.keys(table).join(", ")}`)
+}
+
+/** How each field value the fill stages consume is read; the single owner of those readings. */
+export const FIDELITY_VALUE_RULES = Object.freeze({
+	tables: VALUE_TABLES,
+	derivedKinds: DERIVED_KINDS,
+	derivedRefused: (kind) => DERIVED_KINDS.includes(kind),
+	derivedNone: (value) => tableValue("derived numbers", value),
+	fallback: (value) => tableValue("fallback", value),
+	translations: (value) => /with translation beside/iu.test(value),
+	meaningCheck: (value) => meaningCheckEnabled({ fields: { "meaning check": value } }),
+})
+
+/** The `source floor` forms: `pattern` reads one, `listed` forms carry a comma list. */
+export const SOURCE_FLOOR_RULES = Object.freeze([
+	Object.freeze({ kind: "standard", form: "standard", pattern: /^standard$/iu, listed: false }),
+	Object.freeze({ kind: "primary", form: "primary only", pattern: /^primary only$/iu, listed: false }),
+	Object.freeze({ kind: "pointed", form: "pointed only: <list>", pattern: /^pointed only:\s*(.+)$/iu, listed: true }),
+	Object.freeze({ kind: "classes", form: "classes: <list>", pattern: /^classes:\s*(.+)$/iu, listed: true }),
+])
+const lineOf = (text, at) => text.slice(0, at).split("\n").length
+const listOf = (text) => text.split(",").map((entry) => entry.trim()).filter(Boolean)
+
+/** brief.md from --brief, else the session's; a usage error when neither is known. */
+export function briefPathOf(flags) {
+	if (flags.brief !== undefined && flags.brief !== true) return resolve(flags.brief)
+	const dir = flags["session-dir"] ?? process.env.SESSION_DIR
+	if (!dir || dir === true) throw new CliError("--brief is required without --session-dir (or SESSION_DIR)")
+	return join(resolve(dir), "brief.md")
+}
+
+/**
+ * @returns {{ parsed: object, refusal: null } | { parsed: null, refusal: { json: object, summary: string, exitCode: 1 } }}
+ */
+export function lockedBrief(command, flags) {
+	const path = briefPathOf(flags)
+	const lock = requireLockedBrief(path)
+	if (lock.exitCode === 2) throw new CliError(`${path}: ${lock.errors.join("; ")}`)
+	if (lock.locked) return { parsed: lock.parsed, refusal: null }
+	const json = { command, status: "fail", exitCode: 1, defects: lock.defects }
+	return { parsed: null, refusal: { json, summary: `${command}: ${lock.defects[0].message}`, exitCode: 1 } }
+}
+
+/**
+ * The source floor as a rule, or null for `standard`; a usage error for any other text.
+ * @returns {null | { kind: "primary" } | { kind: "pointed" | "classes", list: string[] }}
+ */
+export function parseSourceFloor(value) {
+	const text = value.trim()
+	for (const rule of SOURCE_FLOOR_RULES) {
+		const match = rule.pattern.exec(text)
+		if (!match) continue
+		if (rule.kind === "standard") return null
+		return rule.listed ? { kind: rule.kind, list: listOf(match[1]) } : { kind: rule.kind }
+	}
+	throw new CliError(`source floor "${value}" is not ${SOURCE_FLOOR_RULES.map((rule) => rule.form).join(", ")}`)
+}
+
+function hostOf(url) {
+	return typeof url === "string" && URL.canParse(url) ? new URL(url).hostname.toLowerCase() : null
+}
+
+/** Whether one source (id and meta.json) satisfies a parsed floor rule. */
+export function sourceInsideFloor(rule, sourceId, meta) {
+	if (rule.kind === "primary") return meta.provenance === "primary"
+	if (rule.kind === "pointed") return rule.list.includes(sourceId) || rule.list.includes(meta.url)
+	const host = hostOf(meta.url)
+	return host !== null && rule.list.some((entry) => host === entry.toLowerCase() || host.endsWith(`.${entry.toLowerCase()}`))
+}
+
+/** The fields fact fill consumes: the fallback form and whether a translation binds to its quote. */
+export function fillPolicy(parsed) {
+	const field = (name) => parsed.fields[name]
+	return {
+		fallback: FIDELITY_VALUE_RULES.fallback(field("fallback")),
+		translations: FIDELITY_VALUE_RULES.translations(field("languages")),
+		derivedNone: FIDELITY_VALUE_RULES.derivedNone(field("derived numbers")),
+		floor: parseSourceFloor(field("source floor")),
+	}
+}
+
+/** Source ids behind a row: its own, or for a derived row its operands' sources; null marks a leaf with no source. */
+function sourcesOf(row, rows, seen = new Set()) {
+	if (seen.has(row.fact_id)) return []
+	seen.add(row.fact_id)
+	if (row.source_id) return [row.source_id]
+	const inputs = [...(row.operands ?? []), ...(row.derived_from ?? [])]
+	if (inputs.length === 0) return [null]
+	return inputs.flatMap((id) => (rows.has(id) ? sourcesOf(rows.get(id), rows, seen) : [null]))
+}
+
+/** sha256 of the locked `## Fidelity` block normalized: the seven fields in FIDELITY_FIELDS order, `field: value` per line. */
+export const briefHashOf = (parsed) => sha256Of(FIDELITY_FIELDS.map((field) => `${field}: ${parsed.fields[field]}`).join("\n"))
+
+/** brief_changed when a fill map was not written under the current brief (or predates the binding). */
+export function briefBindingErrors(map, mapPath, parsed) {
+	if (map.brief_sha256 === briefHashOf(parsed)) return []
+	const why = typeof map.brief_sha256 === "string" ? "was filled under a different ## Fidelity block" : "records no brief_sha256"
+	return [{ code: "brief_changed", token: null, line: null, message: `${mapPath} ${why}; re-run fact fill under the current brief`, severity: DEFECT_CODES.brief_changed.severity, integrity: DEFECT_CODES.brief_changed.integrity, hint: DEFECT_CODES.brief_changed.hint }]
+}
+
+function metaOf(sessionDir, sourceId, cache) {
+	if (!cache.has(sourceId)) {
+		const file = join(sessionDir, "sources", sourceId, "meta.json")
+		cache.set(sourceId, existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : { url: null, provenance: "unknown" })
+	}
+	return cache.get(sourceId)
+}
+
+const defect = (code, pointer, text, message) => ({ code, token: pointer.token, line: lineOf(text, pointer.start), message, severity: DEFECT_CODES[code].severity, hint: DEFECT_CODES[code].hint })
+
+/**
+ * Refusals for the placeholders of one fill source (or the data-fact elements of one edition at
+ * verify). Sets each referenced row's outside_floor to this evaluation and reports whether any
+ * cached value changed.
+ * @param {{ token: string, start: number, parsed: { id?: string } }[]} found findPlaceholders output
+ * @returns {{ errors: object[], cacheChanged: boolean }}
+ */
+export function policyErrors(text, found, ledger, sessionDir, policy) {
+	const rows = new Map(ledger.rows.map((row) => [row.fact_id, row]))
+	const metas = new Map()
+	const errors = []
+	let cacheChanged = false
+	for (const pointer of found) {
+		const row = rows.get(pointer.parsed?.id)
+		if (row === undefined || row.status !== "active") continue
+		if (policy.derivedNone && FIDELITY_VALUE_RULES.derivedRefused(row.kind)) {
+			errors.push(defect("derived_not_allowed", pointer, text, `${row.fact_id} is ${row.kind}; the brief records derived numbers: none`))
+		}
+		const sources = sourcesOf(row, rows)
+		const outside = policy.floor === null ? [] : [...new Set(sources.filter((id) => id === null || !sourceInsideFloor(policy.floor, id, metaOf(sessionDir, id, metas))))]
+		if (row.outside_floor !== outside.length > 0) cacheChanged = true
+		row.outside_floor = outside.length > 0
+		const named = outside.map((id) => id ?? "no source").join(", ")
+		if (outside.length > 0) errors.push(defect("source_outside_floor", pointer, text, `${row.fact_id} rests on ${named}, outside the source floor`))
+	}
+	return { errors, cacheChanged }
+}