@try-works/dsh-recursive-mode 0.1.4 → 0.1.6

package/lib/index.js

@@ -1,50 +1,11 @@
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { defineTool } from "@deepseek-ai/dsh-tools";
-//#region src/bootstrap.ts
-/**
-* Idempotent scaffold installer (R3). TS port of install-recursive-mode.py's
-* core: bootstrap the FULL canonical /.recursive/ control plane + cross-tool
-* bridges byte-identically (RECURSIVE.md marker-wrapped, AGENTS.md, STATE/
-* DECISIONS, memory routers + shards, config/recursive-router.json, .gitignore,
-* vendored runtime scripts copied into .recursive/scripts/), plus the
-* agent/session-start Stage B (new vs resume) workspace-scoped to the session's
-* control-plane root (R1).
-*
-* Templates + bodies + runtime scripts are SHIPPED package files under
-* references/ (never inlined TS string literals) and resolved relative to this
-* module (package install location), never process.cwd().
-*/
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-/** Package root: <package>/src/.. — references/ sits next to src/. */
-const PACKAGE_ROOT = join(MODULE_DIR, "..");
-/** references/ root (shipped package files). */
-function referencesRoot() {
-	return join(PACKAGE_ROOT, "references");
-}
-/**
-* Enumerate runs as directory names only (bounded O(#dirs)). Never reads
-* run docs; never returns file paths.
-*/
-function enumerateRuns(root) {
-	const runRoot = join(root, ".recursive", "run");
-	if (!existsSync(runRoot)) return [];
-	return readdirSync(runRoot, { withFileTypes: true }).filter((d) => {
-		if (d.isDirectory()) return true;
-		if (!d.isSymbolicLink()) return false;
-		try {
-			return statSync(join(runRoot, d.name)).isDirectory();
-		} catch {
-			return false;
-		}
-	}).map((d) => d.name).sort();
-}
-//#endregion
+import { fileURLToPath } from "node:url";
 //#region src/phase-rules.ts
 /**
 * Phase rules (R5): canonical parity port of lint-recursive-run.py's
@@ -55,7 +16,14 @@ function enumerateRuns(root) {
 * mode-audit-v2).
 */
 const CURRENT_WORKFLOW_PROFILE$1 = "recursive-mode-audit-v2";
-const STRICT_WORKFLOW_PROFILES$1 = /* @__PURE__ */ new Set([CURRENT_WORKFLOW_PROFILE$1, "recursive-mode-audit-v1"]);
+const STRICT_WORKFLOW_PROFILE$1 = "recursive-mode-audit-v1";
+const COMPAT_WORKFLOW_PROFILE$1 = "memory-phase8";
+const STRICT_WORKFLOW_PROFILES$1 = /* @__PURE__ */ new Set([CURRENT_WORKFLOW_PROFILE$1, STRICT_WORKFLOW_PROFILE$1]);
+const LATE_PHASE_ARTIFACTS = [
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+];
 const AUDITED_PHASE_FILES$2 = /* @__PURE__ */ new Set([
 	"01-as-is.md",
 	"01.5-root-cause.md",
@@ -74,6 +42,27 @@ const PRIOR_RECURSIVE_EVIDENCE_FILES = /* @__PURE__ */ new Set([
 	"07-state-update.md",
 	"08-memory-impact.md"
 ]);
+const DIFF_AUDITED_FILES = /* @__PURE__ */ new Set([
+	"02-to-be-plan.md",
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md",
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+]);
+const TRACEABILITY_REQUIRED_FILES = /* @__PURE__ */ new Set([
+	"01-as-is.md",
+	"01.5-root-cause.md",
+	"02-to-be-plan.md",
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md",
+	"05-manual-qa.md",
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+]);
 const AUDIT_REQUIRED_HEADINGS = [
 	"Audit Context",
 	"Effective Inputs Re-read",
@@ -85,6 +74,14 @@ const AUDIT_REQUIRED_HEADINGS = [
 	"Requirement Completion Status",
 	"Audit Verdict"
 ];
+const DIFF_BASIS_FIELDS = [
+	"Baseline type",
+	"Baseline reference",
+	"Comparison reference",
+	"Normalized baseline",
+	"Normalized comparison",
+	"Normalized diff command"
+];
 const SECTION_MAP = {
 	"00-worktree.md": [
 		"TODO",
@@ -267,351 +264,430 @@ function phaseLintRulesMessage(fileName, workflowProfile = CURRENT_WORKFLOW_PROF
 	].join("\n");
 }
 //#endregion
-//#region src/init-templates.ts
+//#region src/lock.ts
 /**
-* Init templates (R5): canonical-parity port of recursive-init.py's
-* requirements_content / worktree_content / detect_git_context, plus full
-* per-phase templates derived from the canonical artifact-template sections
-* (get_artifact_required_sections) + TODO + Coverage/Approval FAIL gates.
+* Lock-hash + lock-chain validation for recursive-mode runs.
 *
-* 00-requirements.md + 00-worktree.md are byte-identical to canonical
-* recursive-init.py output (LF, no BOM). Later phases are structural: every
-* required section heading + the two FAIL gates, so lint fails honestly until
-* the phase is actually worked.
-*/
-/**
-* detect_git_context(): canonical parity. Returns {context, error} — never
-* throws on missing git; error is surfaced in the worktree template note.
+* Ports recursive-lock.py / verify-locks.py / recursive_phase_rules.py
+* semantics (byte-for-byte where observable):
+* - lockHashFromContent: LF-normalize, strip LockHash lines, SHA-256 hex
+* - getLockStatus: MISSING / DRAFT / STALE_LOCK / LOCKED
+* - getPrerequisites / getPrerequisiteBlockers: sequence ordering
+* - validateChain: per-phase validity + break + next legal phase
+* - receipts: read/write/invalidate with Python-identical JSON
+*
+* R3 (run 02).
 */
-function detectGitContext(repoRoot) {
-	const run = (args) => {
-		try {
-			return execFileSync("git", args, {
-				cwd: repoRoot,
-				encoding: "utf8",
-				stdio: [
-					"ignore",
-					"pipe",
-					"ignore"
-				]
-			}).trim();
-		} catch {
-			return null;
-		}
-	};
-	const headSha = run([
-		"rev-parse",
-		"--verify",
-		"HEAD^{commit}"
-	]);
-	if (!headSha) return {
-		context: {},
-		error: "Unable to resolve HEAD commit for Phase 0 diff basis prefill: git rev-parse returned no output"
-	};
-	const branch = run([
-		"symbolic-ref",
-		"--quiet",
-		"--short",
-		"HEAD"
-	]) || "(detached HEAD)";
-	return {
-		context: {
-			baselineType: "local commit",
-			baselineReference: headSha,
-			comparisonReference: "working-tree",
-			normalizedBaseline: headSha,
-			normalizedComparison: "working-tree",
-			normalizedDiffCommand: "git diff --name-only " + headSha,
-			baseBranch: branch,
-			worktreeBranch: branch,
-			baseCommit: headSha,
-			notes: "recursive-init prefilled this executable diff basis from the current HEAD commit. If Phase 0 later changes the chosen baseline, update every diff-basis field and rerun lint before locking."
-		},
-		error: null
-	};
+const PHASE_SEQUENCE = [
+	"00-requirements.md",
+	"00-worktree.md",
+	"01-as-is.md",
+	"01.5-root-cause.md",
+	"02-to-be-plan.md",
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md",
+	"05-manual-qa.md",
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+];
+const OPTIONAL_PHASES = /* @__PURE__ */ new Set([
+	"01-as-is.md",
+	"01.5-root-cause.md",
+	"02-to-be-plan.md",
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md",
+	"05-manual-qa.md"
+]);
+const LOCK_HASH_LINE_RE$1 = /^[ \t]*LockHash:.*(?:\n|$)/gm;
+const STATUS_RE = /* @__PURE__ */ new RegExp("^[ \\t]*Status:\\s*(?:`|\")?(\\w+)(?:`|\")?\\s*$", "m");
+const LOCK_HASH_RE = /* @__PURE__ */ new RegExp("^[ \\t]*LockHash:\\s*(?:`|\")?([a-fA-F0-9]{64})(?:`|\")?\\s*$", "m");
+const LOCKED_AT_RE = /* @__PURE__ */ new RegExp("^[ \\t]*LockedAt:\\s*(?:`|\")?([^`\"\\r\\n]+)(?:`|\")?\\s*$", "m");
+/** LF-normalize, strip every LockHash: line, return the normalized content. */
+function normalizeForLockHash(content) {
+	return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(LOCK_HASH_LINE_RE$1, "");
+}
+/** SHA-256 hex over the UTF-8 bytes of the normalized content. */
+function lockHashFromContent(content) {
+	const normalized = normalizeForLockHash(content);
+	return createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+function phaseIndex(artifactFile) {
+	return PHASE_SEQUENCE.indexOf(artifactFile);
+}
+function isCoreArtifact(artifactFile) {
+	return phaseIndex(artifactFile) >= 0;
 }
 /**
-* requirements_content(run_id, template, from_issue): byte-identical to the
-* canonical recursive-init.py function (LF, template flavor in Scope note).
+* Every earlier phase in PHASE_SEQUENCE that exists on disk.
+* Mirrors: [phase for phase in PHASE_SEQUENCE[:idx] if (run_dir / phase).exists()]
 */
-function requirementsContent(runId, template = "feature", fromIssue = "") {
-	const inputs = ["- [chat summary or source notes if captured in repo]"];
-	if (fromIssue.trim()) inputs.push("- Source: " + fromIssue.trim());
-	const inputsBlock = inputs.join("\n");
-	return [
-		"Run: `/.recursive/run/" + runId + "/`",
-		"Phase: `00 Requirements`",
-		"Status: `DRAFT`",
-		"Workflow version: `recursive-mode-audit-v2`",
-		"Inputs:",
-		inputsBlock,
-		"Outputs:",
-		"- `/.recursive/run/" + runId + "/00-requirements.md`",
-		"Scope note: This document defines stable requirement identifiers and acceptance criteria. (Template: " + template + ")",
-		"",
-		"## TODO",
-		"",
-		"- [ ] Elicit requirements from user/context",
-		"- [ ] Define requirement identifiers (R1, R2, ...)",
-		"- [ ] Write acceptance criteria for each requirement",
-		"- [ ] Document out of scope items (OOS1, OOS2, ...)",
-		"- [ ] List constraints and assumptions",
-		"- [ ] Complete Coverage Gate checklist",
-		"- [ ] Complete Approval Gate checklist",
-		"",
-		"## Requirements",
-		"",
-		"### `R1` <short title>",
-		"",
-		"Description:",
-		"Acceptance criteria:",
-		"- [observable condition 1]",
-		"- [observable condition 2]",
-		"",
-		"## Out of Scope",
-		"",
-		"- `OOS1`: ...",
-		"",
-		"## Constraints",
-		"",
-		"- ...",
-		"",
-		"## Coverage Gate",
-		"...",
-		"Coverage: FAIL",
-		"",
-		"## Approval Gate",
-		"...",
-		"Approval: FAIL"
-	].join("\n") + "\n";
+function getPrerequisites(runDir, artifactFile) {
+	const idx = phaseIndex(artifactFile);
+	if (idx <= 0) return [];
+	const prereqs = [];
+	for (const phase of PHASE_SEQUENCE.slice(0, idx)) if (existsSync(join(runDir, phase))) prereqs.push(phase);
+	return prereqs;
 }
 /**
-* worktree_content(run_id, repo_root, git_context, prefill_error): byte-identical
-* to the canonical recursive-init.py function.
+* Canonical lock-validity classifier:
+* MISSING (no file) / DRAFT (not LOCKED) / STALE_LOCK (missing or mismatched hash fields) / LOCKED.
 */
-function worktreeContent(runId, repoRoot, git, prefillError) {
-	const baseBranch = git.baseBranch ?? "(resolve during Phase 0)";
-	const worktreeBranch = git.worktreeBranch ?? "(resolve during Phase 0)";
-	const baseCommit = git.baseCommit ?? "<resolve-before-locking>";
-	const baselineType = git.baselineType ?? "local commit";
-	const baselineReference = git.baselineReference ?? "<resolve-before-locking>";
-	const comparisonReference = git.comparisonReference ?? "working-tree";
-	const normalizedBaseline = git.normalizedBaseline ?? "<resolve-before-locking>";
-	const normalizedComparison = git.normalizedComparison ?? "working-tree";
-	const normalizedDiffCommand = git.normalizedDiffCommand ?? "git diff --name-only <resolve-before-locking>";
-	const notes = git.notes ?? "Populate an executable diff basis before locking Phase 0. Lint and lock will fail until the normalized basis matches live git state.";
-	const setupNote = prefillError ? "recursive-init could not prefill the Phase 0 diff basis automatically: " + prefillError : "recursive-init detected the current repository context and prefilled the Phase 0 diff basis.";
-	return [
-		"Run: `/.recursive/run/" + runId + "/`",
-		"Phase: `00 Worktree`",
-		"Status: `DRAFT`",
-		"Inputs:",
-		"- `/.recursive/run/" + runId + "/00-requirements.md`",
-		"- Current git repository state",
-		"Outputs:",
-		"- `/.recursive/run/" + runId + "/00-worktree.md`",
-		"Scope note: This document records the Phase 0 worktree context and the executable diff basis that all later audited phases must reuse.",
-		"",
-		"## TODO",
-		"",
-		"- [ ] Confirm the selected worktree location and isolation approach",
-		"- [ ] Confirm the base branch and worktree branch values",
-		"- [ ] Run setup and verify the clean test baseline",
-		"- [ ] Confirm the diff basis fields still match live git state",
-		"- [ ] Complete Coverage Gate checklist",
-		"- [ ] Complete Approval Gate checklist",
-		"",
-		"## Directory Selection",
-		"",
-		"- Repository root: `" + repoRoot + "`",
-		"- Preferred worktree location: `.worktrees/" + runId + "/`",
-		"- Update this section with the actual selected location before locking Phase 0.",
-		"",
-		"## Safety Verification",
-		"",
-		"- Original branch / repo state observed at init time: `" + baseBranch + "`",
-		"- Isolation still must be confirmed after the actual worktree is created.",
-		"",
-		"## Worktree Creation",
-		"",
-		"- Intended worktree branch: `" + worktreeBranch + "`",
-		"- Record the actual worktree creation command and output before locking.",
-		"",
-		"## Main Branch Protection",
-		"",
-		"- Base branch source of truth at init time: `" + baseBranch + "`",
-		"- Explicitly document any deviation from isolated worktree execution before locking.",
-		"",
-		"## Project Setup",
-		"",
-		"- Init-time note: " + setupNote,
-		"- Replace this section with the actual setup commands and results during Phase 0.",
-		"",
-		"## Test Baseline Verification",
-		"",
-		"- Record the baseline commands and results after setup completes.",
-		"",
-		"## Worktree Context",
-		"",
-		"- Base branch: `" + baseBranch + "`",
-		"- Worktree branch: `" + worktreeBranch + "`",
-		"- Base commit: `" + baseCommit + "`",
-		"",
-		"## Diff Basis For Later Audits",
-		"",
-		"- Baseline type: `" + baselineType + "`",
-		"- Baseline reference: `" + baselineReference + "`",
-		"- Comparison reference: `" + comparisonReference + "`",
-		"- Normalized baseline: `" + normalizedBaseline + "`",
-		"- Normalized comparison: `" + normalizedComparison + "`",
-		"- Normalized diff command: `" + normalizedDiffCommand + "`",
-		"- Base branch: `" + baseBranch + "`",
-		"- Worktree branch: `" + worktreeBranch + "`",
-		"- Diff basis notes: `" + notes + "`",
-		"",
-		"## Traceability",
-		"",
-		"- Recursive workflow safety -> Phase 0 records a reusable executable diff basis before audited phases begin.",
-		"",
-		"## Coverage Gate",
-		"",
-		"- [ ] Worktree location and branch context are recorded",
-		"- [ ] Setup and clean baseline verification are recorded",
-		"- [ ] Diff basis fields are executable against live git state",
-		"",
-		"Coverage: FAIL",
-		"",
-		"## Approval Gate",
-		"",
-		"- [ ] Phase 0 context is ready for downstream audited phases",
-		"- [ ] No unresolved setup or diff-basis inconsistencies remain",
-		"",
-		"Approval: FAIL"
-	].join("\n") + "\n";
+function getLockStatus(artifactPath) {
+	if (!existsSync(artifactPath)) return "MISSING";
+	let content;
+	try {
+		content = readFileSync(artifactPath, "utf8");
+	} catch {
+		return "MISSING";
+	}
+	const statusMatch = STATUS_RE.exec(content);
+	if (!statusMatch || statusMatch[1] !== "LOCKED") return "DRAFT";
+	const hashMatch = LOCK_HASH_RE.exec(content);
+	const lockedAtMatch = LOCKED_AT_RE.exec(content);
+	if (!hashMatch || !lockedAtMatch) return "STALE_LOCK";
+	if (hashMatch[1].toLowerCase() !== lockHashFromContent(content)) return "STALE_LOCK";
+	return "LOCKED";
 }
-/**
-* Later-phase template: required sections (canonical get_artifact_required_
-* sections) as ## headings + TODO + FAIL gates. Structural scaffold: the phase
-* author fills each section; lint stays FAIL until Coverage/Approval are set.
-*/
-function laterPhaseContent(runId, fileName, workflowProfile = "recursive-mode-audit-v2") {
-	const sections = getArtifactRequiredSections(fileName, workflowProfile);
-	const lines = [
-		"Run: `/.recursive/run/" + runId + "/`",
-		"Phase: `" + fileName.replace(/\.md$/, "").replace(/^0?/, "") + "`",
-		"Status: `DRAFT`",
-		"Workflow version: `" + workflowProfile + "`",
-		"Inputs:",
-		"- (list upstream artifacts re-read for this phase)",
-		"Outputs:",
-		"- `/.recursive/run/" + runId + "/" + fileName + "`",
-		"Scope note: Scaffold generated by the recursive-mode plugin (R5). Fill every required section before lint.",
-		"",
-		"## TODO",
-		"",
-		"- [ ] Work through every required section below",
-		"- [ ] Record evidence and traceability",
-		"- [ ] Complete Coverage Gate checklist",
-		"- [ ] Complete Approval Gate checklist"
-	];
-	for (const section of sections) {
-		if (section === "TODO") continue;
-		lines.push("", "## " + section, "", "- (fill)");
+/** Every prerequisite whose status is not LOCKED, in PHASE_SEQUENCE order. */
+function getPrerequisiteBlockers(runDir, artifactFile) {
+	const blockers = [];
+	for (const prereq of getPrerequisites(runDir, artifactFile)) {
+		const status = getLockStatus(join(runDir, prereq));
+		if (status !== "LOCKED") blockers.push({
+			artifact: prereq,
+			status,
+			path: join(runDir, prereq)
+		});
 	}
-	lines.push("", "## Coverage Gate", "", "Coverage: FAIL", "", "## Approval Gate", "", "Approval: FAIL", "");
-	return lines.join("\n");
+	return blockers;
 }
-/**
-* Scaffold dirs under a run (addenda/subagents/router-prompts/evidence + subs).
-* Mirrors canonical recursive-init.py's ensure_directory sequence.
-*/
-const RUN_SCAFFOLD_DIRS = [
-	"addenda",
-	"subagents",
-	"router-prompts",
-	"evidence",
-	"evidence/screenshots",
-	"evidence/logs",
-	"evidence/perf",
-	"evidence/traces",
-	"evidence/review-bundles",
-	"evidence/router",
-	"evidence/other"
-];
-//#endregion
-//#region src/run.ts
-/**
-* List run ids under <repoRoot>/.recursive/run/, excluding non-directories.
-* Mirrors: runs = [p for p in run_root.iterdir() if p.is_dir()]
-*/
-function discoverRuns(repoRoot) {
-	const runRoot = join(repoRoot, ".recursive", "run");
-	let runs = [];
+function receiptPath(runDir, artifactFile) {
+	const stem = artifactFile.replace(/\.md$/, "");
+	return join(runDir, "locks", stem + ".receipt.json");
+}
+function readReceipt(runDir, artifactFile) {
+	const rpath = receiptPath(runDir, artifactFile);
+	if (!existsSync(rpath)) return null;
 	try {
-		runs = readdirSync(runRoot, { withFileTypes: true }).filter((d) => {
-			if (d.isDirectory()) return true;
-			if (!d.isSymbolicLink()) return false;
-			try {
-				return statSync(join(runRoot, d.name)).isDirectory();
-			} catch {
-				return false;
-			}
-		}).map((d) => d.name);
+		return JSON.parse(readFileSync(rpath, "utf8"));
 	} catch {
-		return [];
+		return null;
 	}
-	return runs;
 }
 /**
-* Resolve the run directory for an explicit run id, or the latest run by mtime.
-* Mirrors get_latest_run_directory: sort by st_mtime descending, stable sort
-* (ties preserve discovery order — no name-based tie-break).
+* Write a lock receipt with Python-identical JSON semantics.
 */
-function resolveRunDir(repoRoot, runId) {
-	const runRoot = join(repoRoot, ".recursive", "run");
-	if (runId && runId.trim() !== "") return {
-		runDir: join(runRoot, runId.trim()),
-		runId: runId.trim()
+function writeReceipt(runDir, artifactFile, artifactPath) {
+	const artifactHash = lockHashFromContent(readFileSync(artifactPath, "utf8"));
+	const prereqHashes = {};
+	for (const prereq of getPrerequisites(runDir, artifactFile)) {
+		const prereqPath = join(runDir, prereq);
+		if (existsSync(prereqPath)) {
+			const prereqStatus = getLockStatus(prereqPath);
+			if (prereqStatus !== "LOCKED") throw new Error(`Cannot write receipt for '${artifactFile}': prerequisite '${prereq}' is not LOCKED (status: ${prereqStatus})`);
+			prereqHashes[prereq] = lockHashFromContent(readFileSync(prereqPath, "utf8"));
+		}
+	}
+	const existing = readReceipt(runDir, artifactFile);
+	const prevReceiptHash = existing ? existing.receipt_hash : null;
+	const base = {
+		artifact: artifactFile,
+		artifact_path: artifactPath,
+		artifact_hash: artifactHash,
+		locked_at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+		prerequisite_hashes: prereqHashes,
+		previous_receipt_hash: prevReceiptHash
 	};
-	const latest = getLatestRunDirectory(runRoot);
-	if (!latest) return null;
-	return {
-		runDir: join(runRoot, latest),
-		runId: latest
+	const receiptHash = createHash("sha256").update(pythonJsonDumps(base), "utf8").digest("hex");
+	const receipt = {
+		...base,
+		receipt_hash: receiptHash
 	};
+	const locksDir = join(runDir, "locks");
+	mkdirSync(locksDir, { recursive: true });
+	const rpath = receiptPath(runDir, artifactFile);
+	writeFileSync(rpath, pythonJsonDumpsIndent(receipt), "utf8");
+	return receipt;
+}
+function invalidateReceipt(runDir, artifactFile) {
+	const rpath = receiptPath(runDir, artifactFile);
+	if (existsSync(rpath)) {
+		rmSync(rpath, { force: true });
+		return true;
+	}
+	return false;
 }
 /**
-* Latest run directory by mtime (descending), stable sort preserving
-* discovery order for exact ties. Returns null when no runs exist.
+* Downstream phases (strictly after artifactFile in PHASE_SEQUENCE) whose
+* receipt's prerequisite_hashes[artifactFile] differs from the current hash
+* (or the artifact no longer exists).
 */
-function getLatestRunDirectory(runRoot) {
-	let runs = [];
-	try {
-		runs = readdirSync(runRoot, { withFileTypes: true }).filter((d) => {
-			if (d.isDirectory()) return true;
-			if (!d.isSymbolicLink()) return false;
-			try {
-				return statSync(join(runRoot, d.name)).isDirectory();
-			} catch {
-				return false;
-			}
-		}).map((d) => d.name);
-	} catch {
-		return null;
+function getStaleDownstreamPhases(runDir, artifactFile) {
+	const idx = phaseIndex(artifactFile);
+	if (idx < 0) return [];
+	let currentHash = null;
+	const artifactPath = join(runDir, artifactFile);
+	if (existsSync(artifactPath)) currentHash = lockHashFromContent(readFileSync(artifactPath, "utf8"));
+	const stale = [];
+	for (const downstream of PHASE_SEQUENCE.slice(idx + 1)) {
+		const receipt = readReceipt(runDir, downstream);
+		if (!receipt) continue;
+		const prereqHashes = receipt.prerequisite_hashes ?? {};
+		if (!(artifactFile in prereqHashes)) continue;
+		const storedHash = prereqHashes[artifactFile];
+		if (currentHash === null || storedHash !== currentHash) stale.push({
+			artifact: downstream,
+			reason: `prerequisite '${artifactFile}' hash changed`
+		});
 	}
-	if (runs.length === 0) return null;
-	runs.sort((a, b) => {
-		try {
-			return statSync(join(runRoot, b)).mtimeMs - statSync(join(runRoot, a)).mtimeMs;
-		} catch {
-			return 0;
+	return stale;
+}
+function getNextLegalPhase(runDir) {
+	for (const phase of PHASE_SEQUENCE) {
+		const phasePath = join(runDir, phase);
+		if (getLockStatus(phasePath) === "LOCKED") continue;
+		if (!existsSync(phasePath) && OPTIONAL_PHASES.has(phase)) continue;
+		if (getPrerequisiteBlockers(runDir, phase).length > 0) return null;
+		return phase;
+	}
+	return null;
+}
+/** All receipts whose prerequisite_hashes reference a missing or changed artifact. */
+function getAllStaleReceipts(runDir) {
+	const stale = [];
+	for (const phase of PHASE_SEQUENCE) {
+		const receipt = readReceipt(runDir, phase);
+		if (!receipt) continue;
+		const prereqHashes = receipt.prerequisite_hashes ?? {};
+		for (const [prereq, storedHash] of Object.entries(prereqHashes)) {
+			const prereqPath = join(runDir, prereq);
+			if (!existsSync(prereqPath)) {
+				stale.push({
+					artifact: phase,
+					reason: `prerequisite '${prereq}' no longer exists`
+				});
+				continue;
+			}
+			if (storedHash !== lockHashFromContent(readFileSync(prereqPath, "utf8"))) stale.push({
+				artifact: phase,
+				reason: `prerequisite '${prereq}' content changed since lock at ${receipt.locked_at}`
+			});
 		}
-	});
-	return runs[0];
+	}
+	return stale;
+}
+/**
+* Validate the full lock chain of a run: per-phase lock status, break phase,
+* next legal phase, completion, and stale receipts.
+*/
+function validateChain(runDir, runId) {
+	const phases = [];
+	let breakPhase = null;
+	let complete = true;
+	for (const phase of PHASE_SEQUENCE) {
+		const status = getLockStatus(join(runDir, phase));
+		const problems = [];
+		const lockValid = status === "LOCKED";
+		if (!lockValid && breakPhase === null) {
+			breakPhase = phase;
+			complete = false;
+		}
+		if (!lockValid && status !== "MISSING") {
+			if (status === "DRAFT") problems.push(`Status is not LOCKED (${status})`);
+			else if (status === "STALE_LOCK") problems.push("LockHash mismatch or missing lock fields");
+		}
+		phases.push({
+			file: phase,
+			status,
+			lockValid,
+			lockProblems: problems
+		});
+	}
+	const nextLegalPhase = getNextLegalPhase(runDir);
+	const staleReceipts = getAllStaleReceipts(runDir);
+	return {
+		runId,
+		phases,
+		breakPhase,
+		nextLegalPhase,
+		complete,
+		staleReceipts
+	};
+}
+/** Python json.dumps(obj, sort_keys=True) compact serialization (receipt_hash input). */
+function pythonJsonDumps(obj) {
+	const rec = obj;
+	return "{" + Object.keys(rec).sort().map((key) => {
+		const value = rec[key];
+		return `${jsonString(key)}: ${jsonValue(value)}`;
+	}).join(", ") + "}";
+}
+/** Python json.dumps(obj, indent=2, sort_keys=True) disk serialization. */
+function pythonJsonDumpsIndent(obj) {
+	const rec = obj;
+	return "{\n" + Object.keys(rec).sort().map((key) => {
+		const value = rec[key];
+		return "  " + jsonString(key) + ": " + jsonValueIndent(value, 2);
+	}).join(",\n") + "\n}";
+}
+function jsonString(s) {
+	return JSON.stringify(s);
+}
+function jsonValue(value) {
+	if (value === null) return "null";
+	if (typeof value === "string") return jsonString(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return "[" + value.map(jsonValue).join(", ") + "]";
+	if (typeof value === "object") return pythonJsonDumps(value);
+	return "null";
+}
+function jsonValueIndent(value, depth) {
+	if (value === null) return "null";
+	if (typeof value === "string") return jsonString(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return "[" + value.map((v) => jsonValueIndent(v, depth)).join(", ") + "]";
+	if (typeof value === "object") {
+		const obj = value;
+		const keys = Object.keys(obj).sort();
+		const pad = "  ".repeat(depth);
+		return "{\n" + keys.map((key) => pad + "  " + jsonString(key) + ": " + jsonValueIndent(obj[key], depth + 1)).join(",\n") + "\n" + pad + "}";
+	}
+	return "null";
 }
 //#endregion
-//#region src/status.ts
-const RUN_ARTIFACT_SEQUENCE = [
+//#region src/ts-lint.ts
+/**
+* ts-lint.ts (R1, run 09): FULL TS port of the canonical lint-recursive-run.py.
+* In-process lint with byte-identical [FAIL]/[WARN] verdicts + Summary.
+* No python is shelled out anywhere in the plugin.
+*
+* Constants + per-phase required sections are imported from phase-rules.ts
+* (single source of truth, already at 14/14 canonical parity).
+*/
+/** get_prerequisite_blockers: reuse lock.ts chain validation for phase-sequence checks. */
+const PRODUCT_DIFF_PHASE_FILES = /* @__PURE__ */ new Set([
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md"
+]);
+const DECISIONS_DIFF_PHASE_FILES = /* @__PURE__ */ new Set(["06-decisions-update.md"]);
+const STATE_DIFF_PHASE_FILES = /* @__PURE__ */ new Set(["07-state-update.md"]);
+const MEMORY_DIFF_PHASE_FILES = /* @__PURE__ */ new Set(["08-memory-impact.md"]);
+const MEMORY_ALLOWED_TYPES = /* @__PURE__ */ new Set([
+	"index",
+	"domain",
+	"pattern",
+	"incident",
+	"episode"
+]);
+const MEMORY_ALLOWED_STATUSES = /* @__PURE__ */ new Set([
+	"CURRENT",
+	"SUSPECT",
+	"STALE",
+	"DEPRECATED",
+	"DRAFT"
+]);
+const MEMORY_REQUIRED_FIELDS = [
+	"Type",
+	"Status",
+	"Scope",
+	"Owns-Paths",
+	"Watch-Paths",
+	"Source-Runs",
+	"Validated-At-Commit",
+	"Last-Validated",
+	"Tags"
+];
+const TDD_MODES = /* @__PURE__ */ new Set(["strict", "pragmatic"]);
+const QA_EXECUTION_MODES = /* @__PURE__ */ new Set([
+	"human",
+	"agent-operated",
+	"hybrid"
+]);
+const TRANSIENT_RUNTIME_DIR_MARKERS = /* @__PURE__ */ new Set([
+	"__pycache__",
+	".pytest_cache",
+	".mypy_cache",
+	".ruff_cache",
+	".hypothesis",
+	".tox",
+	".nox",
+	".target",
+	".playwright-mcp",
+	".cargo-target-dir"
+]);
+const TRANSIENT_RUNTIME_FILE_NAMES = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
+const TRANSIENT_RUNTIME_SUFFIXES = [
+	".pyc",
+	".pyo",
+	".pyd"
+];
+const DIFF_BASIS_ALLOWED_TYPES = /* @__PURE__ */ new Set([
+	"local commit",
+	"local branch",
+	"remote ref",
+	"merge-base derived"
+]);
+const WORKING_TREE_COMPARISON_REFS = /* @__PURE__ */ new Set([
+	"working-tree",
+	"working-tree@head",
+	"worktree",
+	"working-tree+head"
+]);
+const INVENTORY_DISPOSITIONS = /* @__PURE__ */ new Set([
+	"in-scope",
+	"out-of-scope",
+	"constraint",
+	"quality-gate"
+]);
+const PHASE2_REQUIREMENT_DISPOSITION_STATUSES = /* @__PURE__ */ new Set([
+	"planned",
+	"planned-via-merge",
+	"planned-indirectly",
+	"deferred",
+	"out-of-scope",
+	"blocked",
+	"superseded by approved addendum"
+]);
+const REQUIREMENT_DISPOSITION_STATUSES = /* @__PURE__ */ new Set([
+	"implemented",
+	"verified",
+	"deferred",
+	"out-of-scope",
+	"blocked",
+	"superseded by approved addendum"
+]);
+const SKILL_USAGE_RELEVANCE_STATUSES = /* @__PURE__ */ new Set([
+	"relevant",
+	"not-relevant",
+	"yes",
+	"no"
+]);
+const FINAL_REQUIREMENT_DISPOSITION_FILES = /* @__PURE__ */ new Set([
+	"04-test-summary.md",
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+]);
+const REQUIREMENT_CHANGED_FILE_ACCOUNTING_FILES = /* @__PURE__ */ new Set([
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md"
+]);
+const SUBAGENT_ACTION_REQUIRED_HEADINGS = [
+	"Metadata",
+	"Inputs Provided",
+	"Claimed Actions Taken",
+	"Claimed File Impact",
+	"Claimed Artifact Impact",
+	"Claimed Findings",
+	"Verification Handoff"
+];
+const SKILL_MEMORY_ROUTER_NAMES = /* @__PURE__ */ new Set(["MEMORY.md", "SKILLS.md"]);
+const RUN_ARTIFACT_SEQUENCE$1 = [
 	"00-requirements.md",
 	"00-worktree.md",
 	"01-as-is.md",
@@ -625,122 +701,24 @@ const RUN_ARTIFACT_SEQUENCE = [
 	"07-state-update.md",
 	"08-memory-impact.md"
 ];
-const PHASES = [
-	{
-		key: "00R",
-		label: "Phase 0 (Requirements)",
-		file: "00-requirements.md",
-		optional: false,
-		phaseName: "0 (Requirements)"
-	},
-	{
-		key: "00W",
-		label: "Phase 0 (Worktree)",
-		file: "00-worktree.md",
-		optional: false,
-		phaseName: "0 (Worktree)"
-	},
-	{
-		key: "01",
-		label: "Phase 1 (AS-IS)",
-		file: "01-as-is.md",
-		optional: false,
-		phaseName: "1 (AS-IS)"
-	},
-	{
-		key: "01.5",
-		label: "Phase 1.5 (Root Cause)",
-		file: "01.5-root-cause.md",
-		optional: true,
-		phaseName: "1.5 (Root Cause)"
-	},
-	{
-		key: "02",
-		label: "Phase 2 (TO-BE Plan)",
-		file: "02-to-be-plan.md",
-		optional: false,
-		phaseName: "2 (TO-BE Plan)"
-	},
-	{
-		key: "03",
-		label: "Phase 3 (Implementation)",
-		file: "03-implementation-summary.md",
-		optional: false,
-		phaseName: "3 (Implementation)"
-	},
-	{
-		key: "03.5",
-		label: "Phase 3.5 (Code Review)",
-		file: "03.5-code-review.md",
-		optional: true,
-		phaseName: "3.5 (Code Review)"
-	},
-	{
-		key: "04",
-		label: "Phase 4 (Test Summary)",
-		file: "04-test-summary.md",
-		optional: false,
-		phaseName: "4 (Test Summary)"
-	},
-	{
-		key: "05",
-		label: "Phase 5 (Manual QA)",
-		file: "05-manual-qa.md",
-		optional: false,
-		phaseName: "5 (Manual QA)"
-	},
-	{
-		key: "06",
-		label: "Phase 6 (Decisions)",
-		file: "06-decisions-update.md",
-		optional: false,
-		phaseName: "6 (Decisions Update)"
-	},
-	{
-		key: "07",
-		label: "Phase 7 (State)",
-		file: "07-state-update.md",
-		optional: false,
-		phaseName: "7 (State Update)"
-	},
-	{
-		key: "08",
-		label: "Phase 8 (Memory)",
-		file: "08-memory-impact.md",
-		optional: false,
-		phaseName: "8 (Memory Impact)"
+const REQUIREMENT_ID_RE = /^(R\d+|SRC-\d{3})$/;
+/** write_issue: collect [severity] path: message + remediation lines. */
+const issues = [];
+function writeIssue(severity, filePath, message, remediationLines) {
+	issues.push({
+		severity,
+		filePath,
+		message
+	});
+	console.log(`[${severity}] ${filePath}: ${message}`);
+	if (remediationLines) {
+		console.log("Remediation (copy/paste):");
+		for (const line of remediationLines) console.log("  " + line);
 	}
-];
-const LOCK_HASH_LINE_RE$1 = /^[ \t]*LockHash:.*(?:\n|$)/gm;
-const STRICT_WORKFLOW_PROFILES = /* @__PURE__ */ new Set(["recursive-mode-audit-v1", "recursive-mode-audit-v2"]);
-const AUDITED_PHASE_FILES$1 = /* @__PURE__ */ new Set([
-	"01-as-is.md",
-	"01.5-root-cause.md",
-	"02-to-be-plan.md",
-	"03-implementation-summary.md",
-	"03.5-code-review.md",
-	"04-test-summary.md",
-	"06-decisions-update.md",
-	"07-state-update.md",
-	"08-memory-impact.md"
-]);
-const CURRENT_WORKFLOW_PROFILE = "recursive-mode-audit-v2";
-const STRICT_WORKFLOW_PROFILE = "recursive-mode-audit-v1";
-const COMPAT_WORKFLOW_PROFILE = "memory-phase8";
-const LATE_PHASE_FILES = [
-	"06-decisions-update.md",
-	"07-state-update.md",
-	"08-memory-impact.md"
-];
-const LATE_PHASE_KEYS = /* @__PURE__ */ new Set([
-	"06",
-	"07",
-	"08"
-]);
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	console.log();
 }
-function trimMdValue(value) {
+/** trim_md_value: strip surrounding quotes/backticks. */
+function trimMdValue$1(value) {
 	let trimmed = value.trim();
 	for (const quote of [
 		"`",
@@ -752,22 +730,50 @@ function trimMdValue(value) {
 	}
 	return trimmed;
 }
-function getMdFieldValue(content, fieldName) {
-	const match = new RegExp(`^[ \\t]*(?:[-*][ \\t]+)?${escapeRegExp(fieldName)}:[ \\t]*(.+?)\\s*$`, "m").exec(content);
-	if (!match) return null;
-	return trimMdValue(match[1]);
+/** get_md_field_value: first `Field: value` line. */
+function getMdFieldValue$1(content, fieldName) {
+	const re = new RegExp(`^[ \\t]*(?:[-*][ \\t]+)?${escapeRegExp$3(fieldName)}:[ \\t]*(.+?)\\s*$`, "m");
+	const m = content.match(re);
+	if (!m) return null;
+	return trimMdValue$1(m[1]);
 }
-function getGateStatus(content, gateName) {
-	const match = new RegExp(`^[ \\t]*${escapeRegExp(gateName)}:\\s*(PASS|FAIL)\\s*$`, "m").exec(content);
-	return match ? match[1].toUpperCase() : "MISSING";
+/** has_header_field: any `Field:` line. */
+function hasHeaderField(content, fieldName) {
+	return new RegExp(`^[ \\t]*(?:[-*][ \\t]+)?${escapeRegExp$3(fieldName)}:`, "m").test(content);
 }
-function getTodoStats(content) {
+/** has_heading: `## Heading` line. */
+function hasHeading(content, headingText) {
+	return new RegExp(`^[ \\t]*##\\s+${escapeRegExp$3(headingText)}\\s*$`, "m").test(content);
+}
+/** get_heading_body: text under `## Heading` until next heading or end. */
+function getHeadingBody(content, headingText) {
+	const re = new RegExp(`^[ \\t]*##\\s+${escapeRegExp$3(headingText)}\\s*$\\n?(.*?)(?=^[ \\t]*##\\s+|\Z)`, "ms");
+	const m = content.match(re);
+	if (!m) return "";
+	return (m[1] ?? "").trim();
+}
+/** get_subheading_body: text under `### Heading` (or level N) until next N-or-less heading. */
+function getSubheadingBody(content, headingText, level = 3) {
+	const hashes = "#".repeat(level);
+	const re = new RegExp(`^[ \\t]*${escapeRegExp$3(hashes)}\\s+${escapeRegExp$3(headingText)}\\s*$\\n?(.*?)(?=^[ \\t]*#{1,${level}}\\s+|\Z)`, "ms");
+	const m = content.match(re);
+	if (!m) return "";
+	return (m[1] ?? "").trim();
+}
+/** has_gate_line: `Gate: PASS|FAIL` line. */
+function hasGateLine(content, gateName) {
+	return new RegExp(`^[ \\t]*${escapeRegExp$3(gateName)}:\\s*(PASS|FAIL)\\s*$`, "m").test(content);
+}
+/** get_gate_status: PASS|FAIL|MISSING. */
+function getGateStatus$1(content, gateName) {
+	const re = new RegExp(`^[ \\t]*${escapeRegExp$3(gateName)}:\\s*(PASS|FAIL)\\s*$`, "m");
+	const m = content.match(re);
+	return m ? m[1].toUpperCase() : "MISSING";
+}
+/** get_todo_stats: [has_todo, total, checked, unchecked] under ## TODO. */
+function getTodoStats$1(content) {
 	const lines = content.split(/\r?\n/);
-	let inTodo = false;
-	let hasTodo = false;
-	let checked = 0;
-	let unchecked = 0;
-	let total = 0;
+	let inTodo = false, hasTodo = false, checked = 0, unchecked = 0, total = 0;
 	for (const line of lines) {
 		if (!inTodo) {
 			if (/^\s*##\s+TODO\s*$/.test(line)) {
@@ -777,452 +783,2595 @@ function getTodoStats(content) {
 			continue;
 		}
 		if (/^\s*##\s+/.test(line) || /^\s*#\s+/.test(line)) break;
-		const item = /^\s*[-*]\s+\[([ xX])\]\s+/.exec(line);
+		const item = line.match(/^\s*[-*]\s+\[([ xX])\]\s+/);
 		if (item) {
 			total += 1;
 			if (item[1].toLowerCase() === "x") checked += 1;
 			else unchecked += 1;
 		}
 	}
-	return {
+	return [
 		hasTodo,
 		total,
 		checked,
 		unchecked
-	};
-}
-function lockHashFromContent$1(content) {
-	const stripped = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(LOCK_HASH_LINE_RE$1, "");
-	return createHash("sha256").update(stripped, "utf8").digest("hex");
+	];
 }
-function getWorkflowProfile(runDir) {
-	const requirementsPath = join(runDir, "00-requirements.md");
-	try {
-		const workflowVersion = getMdFieldValue(readFileSync(requirementsPath, "utf8"), "Workflow version");
-		if (workflowVersion === CURRENT_WORKFLOW_PROFILE) return CURRENT_WORKFLOW_PROFILE;
-		if (workflowVersion === STRICT_WORKFLOW_PROFILE) return STRICT_WORKFLOW_PROFILE;
-		if (workflowVersion === COMPAT_WORKFLOW_PROFILE) return COMPAT_WORKFLOW_PROFILE;
-	} catch {}
-	if (LATE_PHASE_FILES.some((file) => {
-		try {
-			statSync(join(runDir, file));
-			return true;
-		} catch {
-			return false;
-		}
-	})) return COMPAT_WORKFLOW_PROFILE;
+/** get_workflow_profile: from Workflow version field or late-phase presence. */
+function getWorkflowProfile$1(runDir) {
+	const reqPath = join(runDir, "00-requirements.md");
+	if (existsSync(reqPath)) {
+		const wf = getMdFieldValue$1(readFileSync(reqPath, "utf8"), "Workflow version");
+		if (wf === "recursive-mode-audit-v2") return CURRENT_WORKFLOW_PROFILE$1;
+		if (wf === "recursive-mode-audit-v1") return STRICT_WORKFLOW_PROFILE$1;
+		if (wf === "memory-phase8") return COMPAT_WORKFLOW_PROFILE$1;
+	}
+	if (LATE_PHASE_ARTIFACTS.some((a) => existsSync(join(runDir, a)))) return COMPAT_WORKFLOW_PROFILE$1;
 	return "legacy";
 }
-function getArtifactState(artifactPath, workflowProfile) {
-	let content = null;
+/** is_placeholder_only: empty or placeholder token. */
+function isPlaceholderOnly(text) {
+	const compact = text.trim();
+	if (!compact) return true;
+	return compact === "..." || compact === "<content>" || compact === "[...]" || compact === "[same structure]";
+}
+/** parse_requirement_ids: Rd+ ids from Requirements heading. */
+function parseRequirementIds(requirementsContent) {
+	const body = getHeadingBody(requirementsContent, "Requirements") || requirementsContent;
+	const ids = [...new Set(body.match(/\bR\d+\b/g) ?? [])];
+	ids.sort((a, b) => parseInt(a.slice(1), 10) - parseInt(b.slice(1), 10));
+	return ids;
+}
+/** requirement_sort_key: Rd+ < SRC-d{3} < other. */
+function requirementSortKey(value) {
+	if (/^R\d+$/.test(value)) return [
+		0,
+		parseInt(value.slice(1), 10),
+		value
+	];
+	if (/^SRC-\d{3}$/.test(value)) return [
+		1,
+		parseInt(value.split("-")[1], 10),
+		value
+	];
+	return [
+		2,
+		value,
+		value
+	];
+}
+/** normalize_source_text: collapse whitespace, strip quotes/backticks, lowercase. */
+function normalizeSourceText(value) {
+	return value.replace(/`/g, "").replace(/"/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+/** source_quote_matches: normalized quote appears in requirements content. */
+function sourceQuoteMatches(sourceQuote, requirementsContent) {
+	const nq = normalizeSourceText(sourceQuote);
+	const nr = normalizeSourceText(requirementsContent);
+	return Boolean(nq) && nr.includes(nq);
+}
+/** escapeRegExp helper. */
+function escapeRegExp$3(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** content_sha256: sha256 hex of UTF-8 content (LF-normalized). */
+function contentSha256$1(content) {
+	return createHash("sha256").update(content.replace(/\r\n/g, "\n"), "utf8").digest("hex");
+}
+/** extract_paths_from_text: backtick paths with / or . in name, non-git, non-placeholder. */
+function extractPathsFromText(text) {
+	const paths = /* @__PURE__ */ new Set();
+	const re = /`([^`\n]+)`/g;
+	let m;
+	while ((m = re.exec(text)) !== null) {
+		const candidate = m[1].trim().replace(/\\/g, "/").replace(/^\/+/, "");
+		if (!candidate || candidate.toLowerCase().startsWith("git ")) continue;
+		if (candidate.startsWith("<") && candidate.endsWith(">")) continue;
+		const name = candidate.split("/").pop() ?? "";
+		if (candidate.includes("/") || name.includes(".")) paths.add(candidate);
+	}
+	return paths;
+}
+/** extract_paths_from_field_value: backtick paths, else split on ,; newline. */
+function extractPathsFromFieldValue(text) {
+	const paths = extractPathsFromText(text);
+	if (paths.size > 0) return paths;
+	const discovered = /* @__PURE__ */ new Set();
+	for (const candidateRaw of trimMdValue$1(text).split(/[,;\n]/)) {
+		const candidate = candidateRaw.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+		if (!candidate || candidate.toLowerCase().startsWith("git ")) continue;
+		if (candidate.startsWith("<") && candidate.endsWith(">")) continue;
+		const name = candidate.split("/").pop() ?? "";
+		if (candidate.includes("/") || name.includes(".")) discovered.add(candidate);
+	}
+	return discovered;
+}
+/** extract_paths_from_named_field: inline value or block body until next field. */
+function extractPathsFromNamedField(content, fieldName) {
+	const inlineValue = getMdFieldValue$1(content, fieldName);
+	if (inlineValue !== null) return extractPathsFromFieldValue(inlineValue);
+	const re = new RegExp(`^[ \\t]*(?:[-*][ \\t]+)?${escapeRegExp$3(fieldName)}:[ \\t]*$\\n(.*?)(?=^[ \\t]*(?:[-*][ \\t]+)?[A-Za-z][^:\\n]*:[ \\t]*|\Z)`, "ms");
+	const m = content.match(re);
+	if (!m) return /* @__PURE__ */ new Set();
+	const out = /* @__PURE__ */ new Set();
+	for (const path of extractPathsFromText(m[1] ?? "")) {
+		const normalized = normalizeRepoPath(path);
+		if (normalized) out.add(normalized);
+	}
+	return out;
+}
+/** get_named_field_text: inline value or block body until next field. */
+function getNamedFieldText(content, fieldName) {
+	const inlineValue = getMdFieldValue$1(content, fieldName);
+	if (inlineValue !== null) return inlineValue;
+	const re = new RegExp(`^[ \\t]*(?:[-*][ \\t]+)?${escapeRegExp$3(fieldName)}:[ \\t]*$\\n(.*?)(?=^[ \\t]*(?:[-*][ \\t]+)?[A-Za-z][^:\\n]*:[ \\t]*|\Z)`, "ms");
+	const m = content.match(re);
+	if (!m) return null;
+	return (m[1] ?? "").trim();
+}
+/** has_meaningful_value: non-empty and not in disallowed set. */
+function hasMeaningfulValue(value, disallowed) {
+	if (value === null) return false;
+	const normalized = trimMdValue$1(value).trim();
+	if (!normalized) return false;
+	return !(disallowed ?? /* @__PURE__ */ new Set()).has(normalized.toLowerCase());
+}
+/** collect_subagent_delegation_issues: audit-context consistency rules. */
+function collectSubagentDelegationIssues(auditContext) {
+	const issues = [];
+	const mode = getMdFieldValue$1(auditContext, "Audit Execution Mode");
+	const availability = getMdFieldValue$1(auditContext, "Subagent Availability");
+	const overrideReason = getMdFieldValue$1(auditContext, "Delegation Override Reason");
+	if (availability === "unavailable" && mode === "subagent") issues.push("Audit Context cannot claim Audit Execution Mode: subagent when Subagent Availability is unavailable");
+	if (availability === "available" && mode === "self-audit") {
+		if (!hasMeaningfulValue(overrideReason, /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Audit Context is missing Delegation Override Reason even though subagents were available and self-audit was chosen");
+	}
+	return issues;
+}
+/** collect_paths_under_prefix: sorted paths under a prefix. */
+function collectPathsUnderPrefix(text, prefix) {
+	return [...extractPathsFromText(text)].filter((p) => p.startsWith(prefix)).sort();
+}
+/** find_missing_repo_paths: paths not existing under repo_root. */
+function findMissingRepoPaths(repoRoot, paths) {
+	return paths.filter((p) => !existsSync(join(repoRoot, p)));
+}
+/** normalize_repo_path: backslash->slash, strip leading /. */
+function normalizeRepoPath(rawPath) {
+	return rawPath.replace(/\\/g, "/").trim().replace(/^\/+/, "");
+}
+/** is_addendum_artifact: file name contains .addendum-. */
+function isAddendumArtifact(fileName) {
+	return fileName.includes(".addendum-");
+}
+/** is_transient_runtime_path: __pycache__, .pyc, etc. */
+function isTransientRuntimePath(normalizedPath) {
+	const candidate = normalizeRepoPath(normalizedPath);
+	if (!candidate) return false;
+	const parts = candidate.split("/");
+	if (parts.some((p) => TRANSIENT_RUNTIME_DIR_MARKERS.has(p))) return true;
+	const fileName = parts[parts.length - 1].toLowerCase();
+	if (TRANSIENT_RUNTIME_FILE_NAMES.has(fileName)) return true;
+	return TRANSIENT_RUNTIME_SUFFIXES.some((s) => fileName.endsWith(s));
+}
+/** filter_runtime_changed_files: drop the run's own dir + transient paths. */
+function filterRuntimeChangedFiles(paths, runId) {
+	const filtered = [];
+	for (const rawPath of paths) {
+		const normalized = normalizeRepoPath(rawPath);
+		if (!normalized) continue;
+		if (normalized.startsWith(`.recursive/run/${runId}/`)) continue;
+		if (isTransientRuntimePath(normalized)) continue;
+		filtered.push(normalized);
+	}
+	return [...new Set(filtered)].sort();
+}
+/** run_git: run git -C repo args, return [stdout, error]. */
+function runGit(repoRoot, ...args) {
 	try {
-		content = readFileSync(artifactPath, "utf8");
-	} catch {}
-	if (content === null) return {
-		exists: false,
-		status: "PENDING",
-		lockValid: false,
-		lockProblems: ["File missing"],
-		blockers: ["File missing"],
-		lockedAt: null,
-		storedHash: null,
-		actualHash: null,
-		coverage: "MISSING",
-		approval: "MISSING",
-		audit: "MISSING",
-		todoHasSection: false,
-		todoUnchecked: 0
-	};
-	const status = getMdFieldValue(content, "Status") ?? "UNKNOWN";
-	const todo = getTodoStats(content);
-	const coverage = getGateStatus(content, "Coverage");
-	const approval = getGateStatus(content, "Approval");
-	const audit = getGateStatus(content, "Audit");
-	const tddCompliance = getGateStatus(content, "TDD Compliance");
-	const lockedAt = getMdFieldValue(content, "LockedAt");
-	const storedHash = getMdFieldValue(content, "LockHash");
-	let actualHash = null;
-	const lockProblems = [];
-	const blockers = [];
-	let lockValid = false;
-	const fileName = artifactPath.split(/[\\/]/).pop() ?? "";
-	if (status !== "LOCKED") lockProblems.push(`Status is '${status}' (expected LOCKED for lock-valid)`);
-	else {
-		if (!lockedAt) lockProblems.push("Missing LockedAt");
-		if (!storedHash) lockProblems.push("Missing LockHash");
-		if (storedHash) {
-			actualHash = lockHashFromContent$1(content);
-			if (storedHash.toLowerCase() !== actualHash.toLowerCase()) lockProblems.push("LockHash mismatch");
+		const out = execFileSync("git", [
+			"-C",
+			repoRoot,
+			...args
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return [String(out).trim(), null];
+	} catch (err) {
+		const e = err;
+		if (e && typeof e === "object" && "status" in e) {
+			const stderr = (e.stderr ?? "").toString().trim();
+			const stdout = (e.stdout ?? "").toString().trim();
+			return [null, stderr || stdout || `git ${args.join(" ")} failed`];
 		}
-		if (coverage !== "PASS") lockProblems.push(`Coverage gate is ${coverage}`);
-		if (approval !== "PASS") lockProblems.push(`Approval gate is ${approval}`);
-		if (STRICT_WORKFLOW_PROFILES.has(workflowProfile) && AUDITED_PHASE_FILES$1.has(fileName) && audit !== "PASS") lockProblems.push(`Audit gate is ${audit}`);
-		if (fileName === "03-implementation-summary.md" && tddCompliance !== "PASS") lockProblems.push(`TDD Compliance gate is ${tddCompliance}`);
-		if (!todo.hasTodo) lockProblems.push("Missing ## TODO section");
-		else if (todo.unchecked > 0) lockProblems.push(`Unchecked TODO items: ${todo.unchecked}`);
-		if (lockProblems.length === 0) lockValid = true;
+		return [null, `Unable to execute git: ${String(err)}`];
 	}
-	if (!todo.hasTodo) blockers.push("Missing ## TODO section");
-	else if (todo.unchecked > 0) blockers.push(`Unchecked TODO items: ${todo.unchecked}`);
-	if (coverage !== "PASS") blockers.push(`Coverage gate is ${coverage}`);
-	if (approval !== "PASS") blockers.push(`Approval gate is ${approval}`);
-	if (fileName === "03-implementation-summary.md" && tddCompliance !== "PASS") blockers.push(`TDD Compliance gate is ${tddCompliance}`);
-	const dedupedBlockers = [];
-	for (const blocker of blockers) if (!dedupedBlockers.includes(blocker)) dedupedBlockers.push(blocker);
+}
+/** normalize_baseline_type: canonicalize baseline type with aliases. */
+function normalizeBaselineType(value) {
+	if (value === null) return null;
+	const compact = trimMdValue$1(value).trim().toLowerCase().replace(/-/g, " ").replace(/\s+/g, " ");
+	if (DIFF_BASIS_ALLOWED_TYPES.has(compact)) return compact;
 	return {
-		exists: true,
-		status,
-		lockValid,
-		lockProblems,
-		blockers: dedupedBlockers,
-		lockedAt,
-		storedHash,
-		actualHash,
-		coverage,
-		approval,
-		audit,
-		todoHasSection: todo.hasTodo,
-		todoUnchecked: todo.unchecked
+		"commit": "local commit",
+		"branch": "local branch",
+		"remote": "remote ref",
+		"remote branch": "remote ref",
+		"merge base": "merge-base derived"
+	}[compact] ?? null;
+}
+/** normalize_comparison_reference: map working-tree refs. */
+function normalizeComparisonReference(value) {
+	if (value === null) return null;
+	const compact = trimMdValue$1(value).trim();
+	if (!compact) return null;
+	if (WORKING_TREE_COMPARISON_REFS.has(compact.toLowerCase())) return "working-tree";
+	return compact;
+}
+/** parse_diff_basis_source: heading body of Diff Basis For Later Audits / Diff Basis. */
+function parseDiffBasisSource(content) {
+	let body = getHeadingBody(content, "Diff Basis For Later Audits");
+	if (body) return body;
+	body = getHeadingBody(content, "Diff Basis");
+	if (body) return body;
+	return content;
+}
+/** get_run_diff_basis: read diff-basis fields from 00-worktree.md. */
+function getRunDiffBasis(runDir) {
+	const worktreePath = join(runDir, "00-worktree.md");
+	if (!existsSync(worktreePath)) return {
+		baseline_type: null,
+		baseline_reference: null,
+		comparison_reference: null,
+		normalized_baseline: null,
+		normalized_comparison: null,
+		normalized_diff_command: null,
+		base_branch: null,
+		worktree_branch: null,
+		notes: null
+	};
+	const source = parseDiffBasisSource(readFileSync(worktreePath, "utf8"));
+	return {
+		baseline_type: getMdFieldValue$1(source, "Baseline type"),
+		baseline_reference: getMdFieldValue$1(source, "Baseline reference"),
+		comparison_reference: getMdFieldValue$1(source, "Comparison reference"),
+		normalized_baseline: getMdFieldValue$1(source, "Normalized baseline") ?? getMdFieldValue$1(source, "Normalized baseline commit") ?? getMdFieldValue$1(source, "Base commit"),
+		normalized_comparison: getMdFieldValue$1(source, "Normalized comparison") ?? getMdFieldValue$1(source, "Normalized comparison reference") ?? getMdFieldValue$1(source, "Worktree branch"),
+		normalized_diff_command: getMdFieldValue$1(source, "Normalized diff command") ?? getMdFieldValue$1(source, "Diff command convention"),
+		base_branch: getMdFieldValue$1(source, "Base branch"),
+		worktree_branch: getMdFieldValue$1(source, "Worktree branch"),
+		notes: getMdFieldValue$1(source, "Diff basis notes") ?? getMdFieldValue$1(source, "Notes")
 	};
 }
-function foldRun(runDir, runId) {
-	const workflowProfile = getWorkflowProfile(runDir);
-	const states = /* @__PURE__ */ new Map();
-	for (const phase of PHASES) {
-		const state = getArtifactState(join(runDir, phase.file), workflowProfile);
-		if (phase.optional && !state.exists) state.status = "SKIPPED";
-		else if (workflowProfile === "legacy" && LATE_PHASE_KEYS.has(phase.key) && !state.exists) state.status = "SKIPPED";
-		states.set(phase.key, state);
+/** normalize_diff_basis: validate + compute the executable diff basis. */
+function normalizeDiffBasis(repoRoot, diffBasis) {
+	const baselineType = normalizeBaselineType(diffBasis.baseline_type);
+	const baselineReference = trimMdValue$1(diffBasis.baseline_reference ?? "");
+	const comparisonReference = normalizeComparisonReference(diffBasis.comparison_reference);
+	const normalizedBaseline = trimMdValue$1(diffBasis.normalized_baseline ?? "");
+	const normalizedComparison = normalizeComparisonReference(diffBasis.normalized_comparison);
+	const normalizedDiffCommand = trimMdValue$1(diffBasis.normalized_diff_command ?? "");
+	const missingFields = [];
+	if (!baselineType) missingFields.push("Baseline type");
+	if (!baselineReference) missingFields.push("Baseline reference");
+	if (!comparisonReference) missingFields.push("Comparison reference");
+	if (!normalizedBaseline) missingFields.push("Normalized baseline");
+	if (!normalizedComparison) missingFields.push("Normalized comparison");
+	if (!normalizedDiffCommand) missingFields.push("Normalized diff command");
+	if (missingFields.length > 0) return [null, `Diff basis is missing required field(s): ${missingFields.join(", ")}`];
+	const baselineTypeN = baselineType;
+	const baselineReferenceN = baselineReference;
+	const comparisonReferenceN = comparisonReference;
+	const normalizedBaselineN = normalizedBaseline;
+	const normalizedComparisonN = normalizedComparison;
+	const normalizedDiffCommandN = normalizedDiffCommand;
+	const comparisonGitRef = normalizedComparisonN === "working-tree" ? "HEAD" : normalizedComparisonN;
+	let computedBaseline;
+	let error;
+	if (baselineType === "merge-base derived") {
+		const [out, err] = runGit(repoRoot, "merge-base", comparisonGitRef, baselineReferenceN);
+		computedBaseline = out;
+		error = err ? `Unable to compute merge-base for diff basis: ${err}` : null;
+	} else {
+		const [out, err] = runGit(repoRoot, "rev-parse", "--verify", `${baselineReferenceN}^{commit}`);
+		computedBaseline = out;
+		error = err ? `Unable to resolve baseline reference '${baselineReference}': ${err}` : null;
 	}
-	let currentPhase = null;
-	for (const phase of PHASES) {
-		const state = states.get(phase.key);
-		if (state.status === "SKIPPED") continue;
-		if (!state.exists || !state.lockValid) {
-			currentPhase = {
-				key: phase.key,
-				label: phase.label,
-				phaseName: phase.phaseName,
-				status: state.status
-			};
-			break;
+	if (error || computedBaseline === null) return [null, error ?? "Unable to compute diff basis"];
+	if (normalizedBaselineN !== computedBaseline) return [null, `Recorded Normalized baseline does not match the executable diff basis (${normalizedBaselineN} != ${computedBaseline})`];
+	let expectedCommand;
+	let gitArgs;
+	if (normalizedComparisonN === "working-tree") {
+		expectedCommand = `git diff --name-only ${computedBaseline}`;
+		gitArgs = [
+			"diff",
+			"--name-only",
+			computedBaseline
+		];
+	} else {
+		const [computedComparison, cmpError] = runGit(repoRoot, "rev-parse", "--verify", `${normalizedComparisonN}^{commit}`);
+		if (cmpError || computedComparison === null) return [null, `Unable to resolve comparison reference '${normalizedComparison}': ${cmpError}`];
+		expectedCommand = `git diff --name-only ${computedBaseline}..${computedComparison}`;
+		gitArgs = [
+			"diff",
+			"--name-only",
+			`${computedBaseline}..${computedComparison}`
+		];
+		if (normalizedComparisonN !== computedComparison) return [null, `Recorded Normalized comparison does not match the executable diff basis (${normalizedComparisonN} != ${computedComparison})`];
+	}
+	if (normalizedDiffCommandN !== expectedCommand) return [null, `Recorded Normalized diff command does not match the executable diff basis (${normalizedDiffCommandN} != ${expectedCommand})`];
+	return [{
+		baseline_type: baselineTypeN,
+		baseline_reference: baselineReferenceN,
+		comparison_reference: comparisonReferenceN,
+		normalized_baseline: computedBaseline,
+		normalized_comparison: normalizedComparisonN,
+		normalized_diff_command: expectedCommand,
+		comparison_git_ref: comparisonGitRef,
+		git_args: gitArgs.join(" ")
+	}, null];
+}
+/** get_git_changed_files: git diff --name-only + untracked (--relative). */
+function getGitChangedFiles(repoRoot, diffBasis) {
+	const [normalizedBasis, basisError] = normalizeDiffBasis(repoRoot, diffBasis);
+	if (basisError) return [null, basisError];
+	const gitArgs = (normalizedBasis.git_args ?? "").split(" ").filter(Boolean);
+	try {
+		const diffOut = execFileSync("git", [
+			"-C",
+			repoRoot,
+			...gitArgs,
+			"--relative"
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const untrackedOut = execFileSync("git", [
+			"-C",
+			repoRoot,
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const tracked = String(diffOut).split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+		const untracked = String(untrackedOut).split(/\r?\n/).map((s) => s.trim()).filter((s) => s && !isTransientRuntimePath(s));
+		return [[.../* @__PURE__ */ new Set([...tracked, ...untracked])].sort(), null];
+	} catch (err) {
+		return [null, `Unable to execute git: ${String(err)}`];
+	}
+}
+/** get_phase_owned_actual_changed_files: which changed files belong to this phase. */
+function getPhaseOwnedActualChangedFiles(fileName, actualChangedFiles, repoRoot) {
+	if (actualChangedFiles === null) return null;
+	if (fileName === "02-to-be-plan.md") return null;
+	const ownedPaths = [];
+	for (const path of actualChangedFiles) {
+		if (path === ".recursive/DECISIONS.md") {
+			if (DECISIONS_DIFF_PHASE_FILES.has(fileName)) ownedPaths.push(path);
+			continue;
+		}
+		if (path === ".recursive/STATE.md") {
+			if (STATE_DIFF_PHASE_FILES.has(fileName)) ownedPaths.push(path);
+			continue;
 		}
+		if (path.startsWith(".recursive/memory/")) {
+			if (MEMORY_DIFF_PHASE_FILES.has(fileName)) ownedPaths.push(path);
+			continue;
+		}
+		ownedPaths.push(path);
 	}
-	const phases = PHASES.map((phase) => {
-		const state = states.get(phase.key);
-		return {
-			key: phase.key,
-			label: phase.label,
-			file: phase.file,
-			optional: phase.optional,
-			exists: state.exists,
-			status: state.status,
-			lockValid: state.lockValid,
-			lockProblems: state.lockProblems,
-			blockers: state.blockers
-		};
-	});
-	return {
-		runId,
-		currentPhase,
-		phases,
-		workflowProfile
-	};
+	if (PRODUCT_DIFF_PHASE_FILES.has(fileName)) {
+		if (repoRoot === void 0) return ownedPaths;
+		return ownedPaths.filter((p) => existsSync(join(repoRoot, p)));
+	}
+	if (DECISIONS_DIFF_PHASE_FILES.has(fileName) || STATE_DIFF_PHASE_FILES.has(fileName) || MEMORY_DIFF_PHASE_FILES.has(fileName)) return ownedPaths;
+	return null;
 }
-//#endregion
-//#region src/lock.ts
-/**
-* Lock-hash + lock-chain validation for recursive-mode runs.
-*
-* Ports recursive-lock.py / verify-locks.py / recursive_phase_rules.py
-* semantics (byte-for-byte where observable):
-* - lockHashFromContent: LF-normalize, strip LockHash lines, SHA-256 hex
-* - getLockStatus: MISSING / DRAFT / STALE_LOCK / LOCKED
-* - getPrerequisites / getPrerequisiteBlockers: sequence ordering
-* - validateChain: per-phase validity + break + next legal phase
-* - receipts: read/write/invalidate with Python-identical JSON
-*
-* R3 (run 02).
-*/
-const PHASE_SEQUENCE = [
-	"00-requirements.md",
-	"00-worktree.md",
-	"01-as-is.md",
-	"01.5-root-cause.md",
-	"02-to-be-plan.md",
-	"03-implementation-summary.md",
-	"03.5-code-review.md",
-	"04-test-summary.md",
-	"05-manual-qa.md",
-	"06-decisions-update.md",
-	"07-state-update.md",
-	"08-memory-impact.md"
-];
-const OPTIONAL_PHASES = /* @__PURE__ */ new Set([
-	"01-as-is.md",
-	"01.5-root-cause.md",
-	"02-to-be-plan.md",
-	"03-implementation-summary.md",
-	"03.5-code-review.md",
-	"04-test-summary.md",
-	"05-manual-qa.md"
-]);
-const LOCK_HASH_LINE_RE = /^[ \t]*LockHash:.*(?:\n|$)/gm;
-const STATUS_RE = /* @__PURE__ */ new RegExp("^[ \\t]*Status:\\s*(?:`|\")?(\\w+)(?:`|\")?\\s*$", "m");
-const LOCK_HASH_RE = /* @__PURE__ */ new RegExp("^[ \\t]*LockHash:\\s*(?:`|\")?([a-fA-F0-9]{64})(?:`|\")?\\s*$", "m");
-const LOCKED_AT_RE = /* @__PURE__ */ new RegExp("^[ \\t]*LockedAt:\\s*(?:`|\")?([^`\"\\r\\n]+)(?:`|\")?\\s*$", "m");
-/** LF-normalize, strip every LockHash: line, return the normalized content. */
-function normalizeForLockHash(content) {
-	return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(LOCK_HASH_LINE_RE, "");
-}
-/** SHA-256 hex over the UTF-8 bytes of the normalized content. */
-function lockHashFromContent(content) {
-	const normalized = normalizeForLockHash(content);
-	return createHash("sha256").update(normalized, "utf8").digest("hex");
-}
-function phaseIndex(artifactFile) {
-	return PHASE_SEQUENCE.indexOf(artifactFile);
-}
-function isCoreArtifact(artifactFile) {
-	return phaseIndex(artifactFile) >= 0;
+/** get_related_addenda_paths: run_dir/addenda/<base>.addendum-*.md (+ upstream-gap). */
+function getRelatedAddendaPaths(runDir, artifactName) {
+	const addendaDir = join(runDir, "addenda");
+	if (!existsSync(addendaDir)) return [];
+	const baseName = artifactName.endsWith(".md") ? artifactName.slice(0, -3) : artifactName;
+	let matches = [];
+	try {
+		matches = readdirSync(addendaDir).filter((n) => n.startsWith(baseName + ".addendum-") && n.endsWith(".md")).sort();
+		const upstream = readdirSync(addendaDir).filter((n) => n.startsWith(baseName + ".upstream-gap.") && n.includes(".addendum-") && n.endsWith(".md")).sort();
+		matches.push(...upstream);
+	} catch {
+		return [];
+	}
+	return matches;
 }
-/**
-* Every earlier phase in PHASE_SEQUENCE that exists on disk.
-* Mirrors: [phase for phase in PHASE_SEQUENCE[:idx] if (run_dir / phase).exists()]
-*/
-function getPrerequisites(runDir, artifactFile) {
-	const idx = phaseIndex(artifactFile);
-	if (idx <= 0) return [];
-	const prereqs = [];
-	for (const phase of PHASE_SEQUENCE.slice(0, idx)) if (existsSync(join(runDir, phase))) prereqs.push(phase);
-	return prereqs;
+/** get_stage_local_addenda_paths: run_dir/addenda/<base>.addendum-*.md. */
+function getStageLocalAddendaPaths(runDir, artifactName) {
+	const addendaDir = join(runDir, "addenda");
+	if (!existsSync(addendaDir)) return [];
+	const baseName = artifactName.endsWith(".md") ? artifactName.slice(0, -3) : artifactName;
+	try {
+		return readdirSync(addendaDir).filter((n) => n.startsWith(baseName + ".addendum-") && n.endsWith(".md")).sort();
+	} catch {
+		return [];
+	}
 }
-/**
-* Canonical lock-validity classifier:
-* MISSING (no file) / DRAFT (not LOCKED) / STALE_LOCK (missing or mismatched hash fields) / LOCKED.
-*/
-function getLockStatus(artifactPath) {
-	if (!existsSync(artifactPath)) return "MISSING";
-	let content;
+/** get_current_phase_upstream_gap_addenda_paths: run_dir/addenda/<base>.upstream-gap.*.addendum-*.md. */
+function getCurrentPhaseUpstreamGapAddendaPaths(runDir, artifactName) {
+	const addendaDir = join(runDir, "addenda");
+	if (!existsSync(addendaDir)) return [];
+	const baseName = artifactName.endsWith(".md") ? artifactName.slice(0, -3) : artifactName;
 	try {
-		content = readFileSync(artifactPath, "utf8");
+		return readdirSync(addendaDir).filter((n) => n.startsWith(baseName + ".upstream-gap.") && n.includes(".addendum-") && n.endsWith(".md")).sort();
 	} catch {
-		return "MISSING";
+		return [];
 	}
-	const statusMatch = STATUS_RE.exec(content);
-	if (!statusMatch || statusMatch[1] !== "LOCKED") return "DRAFT";
-	const hashMatch = LOCK_HASH_RE.exec(content);
-	const lockedAtMatch = LOCKED_AT_RE.exec(content);
-	if (!hashMatch || !lockedAtMatch) return "STALE_LOCK";
-	if (hashMatch[1].toLowerCase() !== lockHashFromContent(content)) return "STALE_LOCK";
-	return "LOCKED";
 }
-/** Every prerequisite whose status is not LOCKED, in PHASE_SEQUENCE order. */
-function getPrerequisiteBlockers(runDir, artifactFile) {
-	const blockers = [];
-	for (const prereq of getPrerequisites(runDir, artifactFile)) {
-		const status = getLockStatus(join(runDir, prereq));
-		if (status !== "LOCKED") blockers.push({
-			artifact: prereq,
-			status,
-			path: join(runDir, prereq)
-		});
+/** get_header_field_block: lines under `Field:` until a stop field. */
+function getHeaderFieldBlock(content, fieldName, stopFields) {
+	const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+	let collecting = false;
+	const captured = [];
+	const stopPatterns = stopFields.map((sf) => new RegExp(`^\\s*${escapeRegExp$3(sf)}:`));
+	const fieldPattern = new RegExp(`^\\s*${escapeRegExp$3(fieldName)}:\\s*$`);
+	for (const line of lines) {
+		if (!collecting) {
+			if (fieldPattern.test(line)) collecting = true;
+			continue;
+		}
+		if (stopPatterns.some((p) => p.test(line))) break;
+		captured.push(line);
 	}
-	return blockers;
+	return captured.join("\n").trim();
 }
-function receiptPath(runDir, artifactFile) {
-	const stem = artifactFile.replace(/\.md$/, "");
-	return join(runDir, "locks", stem + ".receipt.json");
+/** get_header_input_paths: paths under Inputs:. */
+function getHeaderInputPaths(content) {
+	return extractPathsFromText(getHeaderFieldBlock(content, "Inputs", ["Outputs", "Scope note"]));
 }
-function readReceipt(runDir, artifactFile) {
-	const rpath = receiptPath(runDir, artifactFile);
-	if (!existsSync(rpath)) return null;
-	try {
-		return JSON.parse(readFileSync(rpath, "utf8"));
-	} catch {
-		return null;
+/** get_phase_expected_input_artifact_names: expected input artifacts for a phase. */
+function getPhaseExpectedInputArtifactNames(fileName, runDir) {
+	const present = new Set(RUN_ARTIFACT_SEQUENCE$1.filter((a) => existsSync(join(runDir, a))));
+	let candidates = [];
+	if (fileName === "00-worktree.md") candidates = ["00-requirements.md"];
+	else if (fileName === "01-as-is.md") candidates = ["00-requirements.md"];
+	else if (fileName === "01.5-root-cause.md") candidates = ["01-as-is.md"];
+	else if (fileName === "02-to-be-plan.md") {
+		candidates = ["00-requirements.md", "01-as-is.md"];
+		if (present.has("01.5-root-cause.md")) candidates.push("01.5-root-cause.md");
+	} else if (fileName === "03-implementation-summary.md") candidates = ["02-to-be-plan.md"];
+	else if (fileName === "03.5-code-review.md") candidates = ["02-to-be-plan.md", "03-implementation-summary.md"];
+	else if (fileName === "04-test-summary.md") {
+		candidates = ["02-to-be-plan.md", "03-implementation-summary.md"];
+		if (present.has("03.5-code-review.md")) candidates.push("03.5-code-review.md");
+	} else if (fileName === "05-manual-qa.md") candidates = ["02-to-be-plan.md"];
+	else if (fileName === "06-decisions-update.md") candidates = RUN_ARTIFACT_SEQUENCE$1.filter((a) => present.has(a) && a !== "06-decisions-update.md");
+	else if (fileName === "07-state-update.md") candidates = ["06-decisions-update.md"];
+	else if (fileName === "08-memory-impact.md") candidates = RUN_ARTIFACT_SEQUENCE$1.filter((a) => present.has(a) && a !== "08-memory-impact.md");
+	return candidates.filter((a) => present.has(a));
+}
+/** get_expected_effective_input_addenda_paths: expected addenda cited in Inputs. */
+function getExpectedEffectiveInputAddendaPaths(runDir, fileName) {
+	if (isAddendumArtifact(fileName)) return [];
+	const expectedPaths = [];
+	const runPrefix = `.recursive/run/${basename(runDir)}/`;
+	for (const artifactName of getPhaseExpectedInputArtifactNames(fileName, runDir)) for (const addendumPath of getStageLocalAddendaPaths(runDir, artifactName)) expectedPaths.push(`${runPrefix}addenda/${addendumPath}`);
+	for (const addendumPath of getCurrentPhaseUpstreamGapAddendaPaths(runDir, fileName)) expectedPaths.push(`${runPrefix}addenda/${addendumPath}`);
+	return [...new Set(expectedPaths)].sort();
+}
+/** parse_requirement_completion_entries: `- R1 | Status: ... | ...` rows. */
+function parseRequirementCompletionEntries(sectionBody) {
+	const entries = {};
+	const issues = [];
+	for (const rawLine of sectionBody.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line.startsWith("-") && !line.startsWith("*")) continue;
+		const parts = trimMdValue$1(line.slice(1).trim()).split("|").map((p) => trimMdValue$1(p.trim())).filter(Boolean);
+		if (parts.length < 2) continue;
+		const requirementId = trimMdValue$1(parts[0]);
+		if (!REQUIREMENT_ID_RE.test(requirementId)) continue;
+		const fields = { "Requirement ID": requirementId };
+		for (const part of parts.slice(1)) {
+			const idx = part.indexOf(":");
+			if (idx < 0) continue;
+			fields[part.slice(0, idx).trim()] = trimMdValue$1(part.slice(idx + 1).trim());
+		}
+		if (requirementId in entries) {
+			issues.push(`Requirement Completion Status contains duplicate entries for ${requirementId}`);
+			continue;
+		}
+		entries[requirementId] = fields;
 	}
+	return [entries, issues];
 }
-/**
-* Write a lock receipt with Python-identical JSON semantics.
-*/
-function writeReceipt(runDir, artifactFile, artifactPath) {
-	const artifactHash = lockHashFromContent(readFileSync(artifactPath, "utf8"));
-	const prereqHashes = {};
-	for (const prereq of getPrerequisites(runDir, artifactFile)) {
-		const prereqPath = join(runDir, prereq);
-		if (existsSync(prereqPath)) {
-			const prereqStatus = getLockStatus(prereqPath);
-			if (prereqStatus !== "LOCKED") throw new Error(`Cannot write receipt for '${artifactFile}': prerequisite '${prereq}' is not LOCKED (status: ${prereqStatus})`);
-			prereqHashes[prereq] = lockHashFromContent(readFileSync(prereqPath, "utf8"));
+/** is_meaningful_requirement_field: non-empty, not placeholder/none/n/a/tbd/todo. */
+function isMeaningfulRequirementField(value) {
+	if (value === null) return false;
+	const normalized = trimMdValue$1(value).trim();
+	if (!normalized) return false;
+	return ![
+		"...",
+		"none",
+		"n/a",
+		"tbd",
+		"todo"
+	].includes(normalized.toLowerCase());
+}
+/** collect_requirement_field_paths: normalized repo paths from field values. */
+function collectRequirementFieldPaths(fields, fieldNames) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const fieldName of fieldNames) {
+		const rawValue = fields[fieldName] ?? "";
+		for (const path of extractPathsFromFieldValue(rawValue)) {
+			const normalized = normalizeRepoPath(path);
+			if (normalized) paths.add(normalized);
 		}
 	}
-	const existing = readReceipt(runDir, artifactFile);
-	const prevReceiptHash = existing ? existing.receipt_hash : null;
-	const base = {
-		artifact: artifactFile,
-		artifact_path: artifactPath,
-		artifact_hash: artifactHash,
-		locked_at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
-		prerequisite_hashes: prereqHashes,
-		previous_receipt_hash: prevReceiptHash
-	};
-	const receiptHash = createHash("sha256").update(pythonJsonDumps(base), "utf8").digest("hex");
-	const receipt = {
-		...base,
-		receipt_hash: receiptHash
+	return paths;
+}
+/** collect_meaningful_requirement_fields: drop ID/Status + placeholders. */
+function collectMeaningfulRequirementFields(fields) {
+	const meaningful = {};
+	for (const [key, value] of Object.entries(fields)) {
+		if (key === "Requirement ID" || key === "Status") continue;
+		if (isMeaningfulRequirementField(value)) meaningful[key] = value;
+	}
+	return meaningful;
+}
+/** normalize_skill_usage_relevance: yes->relevant, no->not-relevant. */
+function normalizeSkillUsageRelevance(value) {
+	const normalized = trimMdValue$1(value ?? "").trim().toLowerCase();
+	if (normalized === "yes") return "relevant";
+	if (normalized === "no") return "not-relevant";
+	return normalized;
+}
+/** lint_requirement_disposition_fields: per-status field requirements (implemented/verified/deferred/...). */
+function lintRequirementDispositionFields(requirementId, status, fields, fileName, runDir, repoRoot, actualChangedFiles) {
+	const issues = [];
+	const actualChangedScope = new Set(actualChangedFiles ?? []);
+	const meaningfulFields = collectMeaningfulRequirementFields(fields);
+	const allowedFieldsByStatus = {
+		"implemented": /* @__PURE__ */ new Set([
+			"Changed Files",
+			"Implementation Evidence",
+			"Audit Note"
+		]),
+		"verified": /* @__PURE__ */ new Set([
+			"Changed Files",
+			"Implementation Evidence",
+			"Verification Evidence",
+			"Audit Note"
+		]),
+		"deferred": /* @__PURE__ */ new Set([
+			"Rationale",
+			"Deferred By",
+			"Addendum",
+			"Audit Note"
+		]),
+		"out-of-scope": /* @__PURE__ */ new Set([
+			"Rationale",
+			"Scope Decision",
+			"Addendum",
+			"Audit Note"
+		]),
+		"blocked": /* @__PURE__ */ new Set([
+			"Rationale",
+			"Blocking Evidence",
+			"Audit Note"
+		]),
+		"superseded by approved addendum": /* @__PURE__ */ new Set(["Addendum", "Audit Note"])
 	};
-	const locksDir = join(runDir, "locks");
-	mkdirSync(locksDir, { recursive: true });
-	const rpath = receiptPath(runDir, artifactFile);
-	writeFileSync(rpath, pythonJsonDumpsIndent(receipt), "utf8");
-	return receipt;
+	const unexpected = Object.keys(meaningfulFields).filter((k) => !(allowedFieldsByStatus[status] ?? /* @__PURE__ */ new Set()).has(k)).sort();
+	if (unexpected.length > 0) issues.push(`Requirement ${requirementId} with Status ${status} contains contradictory field(s): ${unexpected.join(", ")}`);
+	if (status === "implemented") {
+		const changedFiles = fields["Changed Files"] ?? "";
+		const changedPaths = collectRequirementFieldPaths(fields, ["Changed Files"]);
+		const implEvidence = fields["Implementation Evidence"] ?? "";
+		const implPaths = collectRequirementFieldPaths(fields, ["Implementation Evidence"]);
+		if (!isMeaningfulRequirementField(changedFiles)) issues.push(`Requirement ${requirementId} with Status implemented must cite Changed Files`);
+		else if (changedPaths.size === 0) issues.push(`Requirement ${requirementId} with Status implemented must cite repo paths in Changed Files`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...changedPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} Changed Files path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+			if (actualChangedScope.size > 0) {
+				const unexplained = [...changedPaths].filter((p) => !actualChangedScope.has(p)).sort();
+				if (unexplained.length > 0) issues.push(`Requirement ${requirementId} Changed Files are outside the current diff scope: ${unexplained.slice(0, 5).join(", ")}`);
+			}
+		}
+		if (!isMeaningfulRequirementField(implEvidence)) issues.push(`Requirement ${requirementId} with Status implemented must cite Implementation Evidence`);
+		else if (implPaths.size === 0) issues.push(`Requirement ${requirementId} with Status implemented must cite file or artifact paths in Implementation Evidence`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...implPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} Implementation Evidence path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+			if (changedPaths.size > 0 && [...implPaths].every((p) => !changedPaths.has(p)) && ![...implPaths].some((p) => p.startsWith(`.recursive/run/${basename(runDir)}/`))) issues.push(`Requirement ${requirementId} Implementation Evidence must reference the changed files or a current-run artifact that does so`);
+		}
+	} else if (status === "verified") {
+		const changedFiles = fields["Changed Files"] ?? "";
+		const changedPaths = collectRequirementFieldPaths(fields, ["Changed Files"]);
+		const implEvidence = fields["Implementation Evidence"] ?? "";
+		const verifEvidence = fields["Verification Evidence"] ?? "";
+		const implPaths = collectRequirementFieldPaths(fields, ["Implementation Evidence"]);
+		const verifPaths = collectRequirementFieldPaths(fields, ["Verification Evidence"]);
+		if (!isMeaningfulRequirementField(changedFiles)) issues.push(`Requirement ${requirementId} with Status verified must cite Changed Files`);
+		else if (changedPaths.size === 0) issues.push(`Requirement ${requirementId} with Status verified must cite repo paths in Changed Files`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...changedPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} Changed Files path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+			if (actualChangedScope.size > 0) {
+				const unexplained = [...changedPaths].filter((p) => !actualChangedScope.has(p)).sort();
+				if (unexplained.length > 0) issues.push(`Requirement ${requirementId} Changed Files are outside the current diff scope: ${unexplained.slice(0, 5).join(", ")}`);
+			}
+		}
+		if (!isMeaningfulRequirementField(implEvidence)) issues.push(`Requirement ${requirementId} with Status verified must cite Implementation Evidence`);
+		else if (implPaths.size === 0) issues.push(`Requirement ${requirementId} with Status verified must cite file or artifact paths in Implementation Evidence`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...implPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} Implementation Evidence path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+			if (changedPaths.size > 0 && [...implPaths].every((p) => !changedPaths.has(p)) && ![...implPaths].some((p) => p.startsWith(`.recursive/run/${basename(runDir)}/`))) issues.push(`Requirement ${requirementId} Implementation Evidence must reference the changed files or a current-run artifact that does so`);
+		}
+		if (!isMeaningfulRequirementField(verifEvidence)) issues.push(`Requirement ${requirementId} with Status verified must cite Verification Evidence`);
+		else if (verifPaths.size === 0) issues.push(`Requirement ${requirementId} with Status verified must cite test, review, QA, or artifact paths in Verification Evidence`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...verifPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} Verification Evidence path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+			if (changedPaths.size > 0 && [...verifPaths].every((p) => changedPaths.has(p))) issues.push(`Requirement ${requirementId} Verification Evidence must cite verification artifacts, review receipts, or evidence paths distinct from the changed files`);
+			if (implPaths.size > 0 && [...verifPaths].every((p) => implPaths.has(p))) issues.push(`Requirement ${requirementId} Verification Evidence cannot be satisfied by restating only the implementation evidence`);
+		}
+	} else if (status === "deferred") {
+		const rationale = fields["Rationale"] ?? "";
+		const deferredBy = fields["Deferred By"] ?? fields["Addendum"] ?? "";
+		const deferredPaths = collectRequirementFieldPaths(fields, ["Deferred By", "Addendum"]);
+		if (!isMeaningfulRequirementField(rationale)) issues.push(`Requirement ${requirementId} with Status deferred is missing Rationale`);
+		if (!isMeaningfulRequirementField(deferredBy)) issues.push(`Requirement ${requirementId} with Status deferred must cite Deferred By or Addendum`);
+		else if (deferredPaths.size === 0) issues.push(`Requirement ${requirementId} with Status deferred must cite an approved deferral path`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...deferredPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} deferral reference path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+		}
+	} else if (status === "out-of-scope") {
+		const rationale = fields["Rationale"] ?? "";
+		const scopeDecision = fields["Scope Decision"] ?? fields["Addendum"] ?? "";
+		const scopePaths = collectRequirementFieldPaths(fields, ["Scope Decision", "Addendum"]);
+		if (!isMeaningfulRequirementField(rationale)) issues.push(`Requirement ${requirementId} with Status out-of-scope is missing Rationale`);
+		if (!isMeaningfulRequirementField(scopeDecision)) issues.push(`Requirement ${requirementId} with Status out-of-scope must cite Scope Decision or Addendum`);
+		else if (scopePaths.size === 0) issues.push(`Requirement ${requirementId} with Status out-of-scope must cite an approved scope decision path`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...scopePaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} scope decision path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+		}
+	} else if (status === "blocked") {
+		const rationale = fields["Rationale"] ?? "";
+		const blockingEvidence = fields["Blocking Evidence"] ?? "";
+		const blockingPaths = collectRequirementFieldPaths(fields, ["Blocking Evidence"]);
+		if (!isMeaningfulRequirementField(rationale)) issues.push(`Requirement ${requirementId} with Status blocked is missing Rationale`);
+		if (!isMeaningfulRequirementField(blockingEvidence)) issues.push(`Requirement ${requirementId} with Status blocked must cite Blocking Evidence`);
+		else if (blockingPaths.size === 0) issues.push(`Requirement ${requirementId} with Status blocked must cite file, artifact, or evidence paths in Blocking Evidence`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...blockingPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} Blocking Evidence path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+		}
+	} else if (status === "superseded by approved addendum") {
+		const addendumPath = normalizeRepoPath(fields["Addendum"] ?? "");
+		if (!addendumPath) issues.push(`Requirement ${requirementId} superseded by approved addendum must cite Addendum`);
+		else if (!addendumPath.startsWith(`.recursive/run/${basename(runDir)}/addenda/`)) issues.push(`Requirement ${requirementId} addendum reference must live under the current run addenda/`);
+		else if (!existsSync(join(repoRoot, addendumPath))) issues.push(`Requirement ${requirementId} addendum reference does not exist: ${addendumPath}`);
+	}
+	if (FINAL_REQUIREMENT_DISPOSITION_FILES.has(fileName)) {
+		if (status === "implemented") issues.push(`Requirement ${requirementId} cannot remain implemented in ${fileName}; final closeout phases require verification`);
+		if (status === "blocked") issues.push(`Requirement ${requirementId} cannot remain blocked in ${fileName} while the phase is approaching closeout`);
+	}
+	return issues;
 }
-function invalidateReceipt(runDir, artifactFile) {
-	const rpath = receiptPath(runDir, artifactFile);
-	if (existsSync(rpath)) {
-		rmSync(rpath, { force: true });
-		return true;
+/** lint_source_requirement_inventory: 01-as-is Source Requirement Inventory rules. */
+function lintSourceRequirementInventory(filePath, content, workflowProfile, runDir) {
+	if (workflowProfile !== "recursive-mode-audit-v2" || basename(filePath) !== "01-as-is.md") return [];
+	const issues = [];
+	const requirementsPath = join(runDir, "00-requirements.md");
+	const requirementsContent = existsSync(requirementsPath) ? readFileSync(requirementsPath, "utf8") : "";
+	const body = getHeadingBody(content, "Source Requirement Inventory");
+	if (!body) return ["Missing or empty section: ## Source Requirement Inventory"];
+	const [entries, entryIssues] = parseSourceRequirementInventoryEntries(body);
+	issues.push(...entryIssues);
+	if (Object.keys(entries).length === 0) {
+		issues.push("Source Requirement Inventory must contain at least one requirement inventory entry");
+		return [...new Set(issues)].sort();
 	}
-	return false;
+	const missingExplicit = parseRequirementIds(requirementsContent).filter((id) => !(id in entries));
+	if (missingExplicit.length > 0) issues.push(`Source Requirement Inventory is missing explicit requirement IDs from 00-requirements.md: ${missingExplicit.join(", ")}`);
+	for (const [requirementId, fields] of Object.entries(entries)) {
+		const disposition = trimMdValue$1(fields["Disposition"] ?? "").toLowerCase();
+		const sourceQuote = fields["Source Quote"] ?? "";
+		const summary = fields["Summary"] ?? "";
+		if (!INVENTORY_DISPOSITIONS.has(disposition)) issues.push(`Source Requirement Inventory for ${requirementId} has invalid Disposition '${fields["Disposition"] ?? ""}'`);
+		if (!isMeaningfulRequirementField(sourceQuote)) issues.push(`Source Requirement Inventory for ${requirementId} is missing Source Quote`);
+		else if (!sourceQuoteMatches(sourceQuote, requirementsContent)) issues.push(`Source Requirement Inventory for ${requirementId} cites a Source Quote that does not appear in 00-requirements.md`);
+		if (!isMeaningfulRequirementField(summary)) issues.push(`Source Requirement Inventory for ${requirementId} is missing Summary`);
+	}
+	return [...new Set(issues)].sort();
 }
-/**
-* Downstream phases (strictly after artifactFile in PHASE_SEQUENCE) whose
-* receipt's prerequisite_hashes[artifactFile] differs from the current hash
-* (or the artifact no longer exists).
-*/
-function getStaleDownstreamPhases(runDir, artifactFile) {
-	const idx = phaseIndex(artifactFile);
-	if (idx < 0) return [];
-	let currentHash = null;
-	const artifactPath = join(runDir, artifactFile);
-	if (existsSync(artifactPath)) currentHash = lockHashFromContent(readFileSync(artifactPath, "utf8"));
-	const stale = [];
-	for (const downstream of PHASE_SEQUENCE.slice(idx + 1)) {
-		const receipt = readReceipt(runDir, downstream);
-		if (!receipt) continue;
-		const prereqHashes = receipt.prerequisite_hashes ?? {};
-		if (!(artifactFile in prereqHashes)) continue;
-		const storedHash = prereqHashes[artifactFile];
-		if (currentHash === null || storedHash !== currentHash) stale.push({
-			artifact: downstream,
-			reason: `prerequisite '${artifactFile}' hash changed`
-		});
+/** lint_requirement_mapping: 02-to-be-plan Requirement Mapping rules. */
+function lintRequirementMapping(content, workflowProfile, runDir, repoRoot) {
+	if (workflowProfile !== "recursive-mode-audit-v2") return [];
+	const issues = [];
+	const phase1Path = join(runDir, "01-as-is.md");
+	const requirementsPath = join(runDir, "00-requirements.md");
+	if (!existsSync(phase1Path) || !existsSync(requirementsPath)) return ["Requirement Mapping requires existing 00-requirements.md and 01-as-is.md inputs"];
+	const inventoryBody = getHeadingBody(readFileSync(phase1Path, "utf8"), "Source Requirement Inventory");
+	if (!inventoryBody) return ["Requirement Mapping requires 01-as-is.md to contain ## Source Requirement Inventory"];
+	const [inventoryEntries, inventoryIssues] = parseSourceRequirementInventoryEntries(inventoryBody);
+	issues.push(...inventoryIssues);
+	const body = getHeadingBody(content, "Requirement Mapping");
+	if (!body) {
+		issues.push("Missing or empty section: ## Requirement Mapping");
+		return [...new Set(issues)].sort();
 	}
-	return stale;
+	const [mappingEntries, mappingIssues] = parseRequirementMappingEntries(body);
+	issues.push(...mappingIssues);
+	const missingEntries = Object.keys(inventoryEntries).filter((id) => !(id in mappingEntries));
+	if (missingEntries.length > 0) issues.push(`Requirement Mapping is missing source inventory items: ${missingEntries.join(", ")}`);
+	const requirementsContent = readFileSync(requirementsPath, "utf8");
+	for (const [requirementId, fields] of Object.entries(mappingEntries)) {
+		const coverage = trimMdValue$1(fields["Coverage"] ?? "").toLowerCase();
+		const sourceQuote = fields["Source Quote"] ?? "";
+		const implementationSurface = fields["Implementation Surface"] ?? "";
+		const verificationSurface = fields["Verification Surface"] ?? "";
+		const qaSurface = fields["QA Surface"] ?? "";
+		const rationale = fields["Rationale"] ?? fields["Merge Rationale"] ?? "";
+		if (![
+			"direct",
+			"merged",
+			"indirect",
+			"deferred",
+			"out-of-scope",
+			"blocked"
+		].includes(coverage)) {
+			issues.push(`Requirement Mapping for ${requirementId} has invalid Coverage '${fields["Coverage"] ?? ""}'`);
+			continue;
+		}
+		if (!isMeaningfulRequirementField(sourceQuote)) issues.push(`Requirement Mapping for ${requirementId} is missing Source Quote`);
+		else if (requirementId in inventoryEntries) {
+			const inventoryQuote = inventoryEntries[requirementId]["Source Quote"] ?? "";
+			if (normalizeSourceText(sourceQuote) !== normalizeSourceText(inventoryQuote)) issues.push(`Requirement Mapping for ${requirementId} must preserve the Source Quote recorded in Source Requirement Inventory`);
+		} else if (!sourceQuoteMatches(sourceQuote, requirementsContent)) issues.push(`Requirement Mapping for ${requirementId} cites a Source Quote that does not appear in 00-requirements.md`);
+		if ([
+			"direct",
+			"merged",
+			"indirect"
+		].includes(coverage)) {
+			if (!isMeaningfulRequirementField(implementationSurface)) issues.push(`Requirement Mapping for ${requirementId} is missing Implementation Surface`);
+			else issues.push(...validatePlannedSurfacePaths(requirementId, "Implementation Surface", implementationSurface, repoRoot));
+			if (!isMeaningfulRequirementField(verificationSurface)) issues.push(`Requirement Mapping for ${requirementId} is missing Verification Surface`);
+			if (!isMeaningfulRequirementField(qaSurface)) issues.push(`Requirement Mapping for ${requirementId} is missing QA Surface`);
+		}
+		if (coverage === "merged" && !isMeaningfulRequirementField(rationale)) issues.push(`Requirement Mapping for ${requirementId} with Coverage merged must cite Merge Rationale or Rationale`);
+		if (coverage === "indirect" && !isMeaningfulRequirementField(rationale)) issues.push(`Requirement Mapping for ${requirementId} with Coverage indirect must cite Rationale`);
+		if ([
+			"deferred",
+			"out-of-scope",
+			"blocked"
+		].includes(coverage) && !isMeaningfulRequirementField(rationale)) issues.push(`Requirement Mapping for ${requirementId} with Coverage ${coverage} must cite Rationale`);
+	}
+	return [...new Set(issues)].sort();
 }
-function getNextLegalPhase(runDir) {
-	for (const phase of PHASE_SEQUENCE) {
-		const phasePath = join(runDir, phase);
-		if (getLockStatus(phasePath) === "LOCKED") continue;
-		if (!existsSync(phasePath) && OPTIONAL_PHASES.has(phase)) continue;
-		if (getPrerequisiteBlockers(runDir, phase).length > 0) return null;
-		return phase;
+/** lint_plan_drift_check: Plan Drift Check merge/rationale rule. */
+function lintPlanDriftCheck(content, workflowProfile) {
+	if (workflowProfile !== "recursive-mode-audit-v2") return [];
+	const body = getHeadingBody(content, "Plan Drift Check");
+	if (!body) return ["Missing or empty section: ## Plan Drift Check"];
+	if (/\bmerge\b/i.test(body) && !/\brationale\b/i.test(body)) return ["Plan Drift Check mentions merged obligations without explaining why the merge is lossless"];
+	return [];
+}
+/** lint_phase2_requirement_disposition_fields: 02 phase-2 status rules. */
+function lintPhase2RequirementDispositionFields(requirementId, status, fields, runDir, repoRoot) {
+	const issues = [];
+	const allowedFieldsByStatus = {
+		"planned": /* @__PURE__ */ new Set([
+			"Implementation Surface",
+			"Verification Surface",
+			"QA Surface",
+			"Audit Note"
+		]),
+		"planned-via-merge": /* @__PURE__ */ new Set([
+			"Implementation Surface",
+			"Verification Surface",
+			"QA Surface",
+			"Rationale",
+			"Audit Note"
+		]),
+		"planned-indirectly": /* @__PURE__ */ new Set([
+			"Implementation Surface",
+			"Verification Surface",
+			"QA Surface",
+			"Rationale",
+			"Audit Note"
+		]),
+		"deferred": /* @__PURE__ */ new Set([
+			"Rationale",
+			"Deferred By",
+			"Addendum",
+			"Audit Note"
+		]),
+		"out-of-scope": /* @__PURE__ */ new Set([
+			"Rationale",
+			"Scope Decision",
+			"Addendum",
+			"Audit Note"
+		]),
+		"blocked": /* @__PURE__ */ new Set([
+			"Rationale",
+			"Blocking Evidence",
+			"Audit Note"
+		]),
+		"superseded by approved addendum": /* @__PURE__ */ new Set(["Addendum", "Audit Note"])
+	};
+	const meaningfulFields = collectMeaningfulRequirementFields(fields);
+	const unexpected = Object.keys(meaningfulFields).filter((k) => !(allowedFieldsByStatus[status] ?? /* @__PURE__ */ new Set()).has(k)).sort();
+	if (unexpected.length > 0) issues.push(`Requirement ${requirementId} with Status ${status} contains contradictory field(s): ${unexpected.join(", ")}`);
+	if ([
+		"planned",
+		"planned-via-merge",
+		"planned-indirectly"
+	].includes(status)) {
+		const implSurface = fields["Implementation Surface"] ?? "";
+		const verifSurface = fields["Verification Surface"] ?? "";
+		const qaSurface = fields["QA Surface"] ?? "";
+		const rationale = fields["Rationale"] ?? "";
+		if (!isMeaningfulRequirementField(implSurface)) issues.push(`Requirement ${requirementId} with Status ${status} must cite Implementation Surface`);
+		else issues.push(...validatePlannedSurfacePaths(requirementId, "Implementation Surface", implSurface, repoRoot));
+		if (!isMeaningfulRequirementField(verifSurface)) issues.push(`Requirement ${requirementId} with Status ${status} must cite Verification Surface`);
+		if (!isMeaningfulRequirementField(qaSurface)) issues.push(`Requirement ${requirementId} with Status ${status} must cite QA Surface`);
+		if (["planned-via-merge", "planned-indirectly"].includes(status) && !isMeaningfulRequirementField(rationale)) issues.push(`Requirement ${requirementId} with Status ${status} must cite Rationale`);
+	} else if (status === "deferred") {
+		const deferredBy = fields["Deferred By"] ?? fields["Addendum"] ?? "";
+		const deferredPaths = collectRequirementFieldPaths(fields, ["Deferred By", "Addendum"]);
+		if (!isMeaningfulRequirementField(fields["Rationale"] ?? "")) issues.push(`Requirement ${requirementId} with Status deferred is missing Rationale`);
+		if (!isMeaningfulRequirementField(deferredBy)) issues.push(`Requirement ${requirementId} with Status deferred must cite Deferred By or Addendum`);
+		else if (deferredPaths.size === 0) issues.push(`Requirement ${requirementId} with Status deferred must cite an approved deferral path`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...deferredPaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} deferral reference path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+		}
+	} else if (status === "out-of-scope") {
+		const scopeDecision = fields["Scope Decision"] ?? fields["Addendum"] ?? "";
+		const scopePaths = collectRequirementFieldPaths(fields, ["Scope Decision", "Addendum"]);
+		if (!isMeaningfulRequirementField(fields["Rationale"] ?? "")) issues.push(`Requirement ${requirementId} with Status out-of-scope is missing Rationale`);
+		if (!isMeaningfulRequirementField(scopeDecision)) issues.push(`Requirement ${requirementId} with Status out-of-scope must cite Scope Decision or Addendum`);
+		else if (scopePaths.size === 0) issues.push(`Requirement ${requirementId} with Status out-of-scope must cite an approved scope decision path`);
+		else {
+			const missing = findMissingRepoPaths(repoRoot, [...scopePaths].sort());
+			if (missing.length > 0) issues.push(`Requirement ${requirementId} scope decision path(s) do not exist: ${missing.slice(0, 5).join(", ")}`);
+		}
+	} else if (status === "blocked") {
+		const blockingEvidence = fields["Blocking Evidence"] ?? "";
+		const blockingPaths = collectRequirementFieldPaths(fields, ["Blocking Evidence"]);
+		if (!isMeaningfulRequirementField(fields["Rationale"] ?? "")) issues.push(`Requirement ${requirementId} with Status blocked is missing Rationale`);
+		if (!isMeaningfulRequirementField(blockingEvidence)) issues.push(`Requirement ${requirementId} with Status blocked must cite Blocking Evidence`);
+		else if (blockingPaths.size === 0) issues.push(`Requirement ${requirementId} with Status blocked must cite file, artifact, or evidence paths in Blocking Evidence`);
+	} else if (status === "superseded by approved addendum") {
+		const addendumPath = normalizeRepoPath(fields["Addendum"] ?? "");
+		if (!addendumPath) issues.push(`Requirement ${requirementId} superseded by approved addendum must cite Addendum`);
+		else if (!addendumPath.startsWith(`.recursive/run/${basename(runDir)}/addenda/`)) issues.push(`Requirement ${requirementId} addendum reference must live under the current run addenda/`);
+		else if (!existsSync(join(repoRoot, addendumPath))) issues.push(`Requirement ${requirementId} addendum reference does not exist: ${addendumPath}`);
 	}
-	return null;
+	return issues;
 }
-/** All receipts whose prerequisite_hashes reference a missing or changed artifact. */
-function getAllStaleReceipts(runDir) {
-	const stale = [];
-	for (const phase of PHASE_SEQUENCE) {
-		const receipt = readReceipt(runDir, phase);
-		if (!receipt) continue;
-		const prereqHashes = receipt.prerequisite_hashes ?? {};
-		for (const [prereq, storedHash] of Object.entries(prereqHashes)) {
-			const prereqPath = join(runDir, prereq);
-			if (!existsSync(prereqPath)) {
-				stale.push({
-					artifact: phase,
-					reason: `prerequisite '${prereq}' no longer exists`
+/** parse_source_requirement_inventory_entries: `- R1 | Disposition: ... | Source Quote: ... | Summary: ...` rows. */
+function parseSourceRequirementInventoryEntries(sectionBody) {
+	const entries = {};
+	const issues = [];
+	for (const rawLine of sectionBody.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line.startsWith("-") && !line.startsWith("*")) continue;
+		const parts = trimMdValue$1(line.slice(1).trim()).split("|").map((p) => trimMdValue$1(p.trim())).filter(Boolean);
+		if (parts.length < 2) continue;
+		const requirementId = trimMdValue$1(parts[0]);
+		if (!REQUIREMENT_ID_RE.test(requirementId)) continue;
+		const fields = { "Requirement ID": requirementId };
+		for (const part of parts.slice(1)) {
+			const idx = part.indexOf(":");
+			if (idx < 0) continue;
+			fields[part.slice(0, idx).trim()] = trimMdValue$1(part.slice(idx + 1).trim());
+		}
+		if (requirementId in entries) {
+			issues.push(`Source Requirement Inventory contains duplicate entries for ${requirementId}`);
+			continue;
+		}
+		entries[requirementId] = fields;
+	}
+	return [entries, issues];
+}
+/** parse_requirement_mapping_entries: `- R1 | Source Quote: ... | Coverage: ... | ...` rows. */
+function parseRequirementMappingEntries(sectionBody) {
+	const entries = {};
+	const issues = [];
+	for (const rawLine of sectionBody.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line.startsWith("-") && !line.startsWith("*")) continue;
+		const parts = trimMdValue$1(line.slice(1).trim()).split("|").map((p) => trimMdValue$1(p.trim())).filter(Boolean);
+		if (parts.length < 2) continue;
+		const requirementId = trimMdValue$1(parts[0]);
+		if (!REQUIREMENT_ID_RE.test(requirementId)) continue;
+		const fields = { "Requirement ID": requirementId };
+		for (const part of parts.slice(1)) {
+			const idx = part.indexOf(":");
+			if (idx < 0) continue;
+			fields[part.slice(0, idx).trim()] = trimMdValue$1(part.slice(idx + 1).trim());
+		}
+		if (requirementId in entries) {
+			issues.push(`Requirement Mapping contains duplicate entries for ${requirementId}`);
+			continue;
+		}
+		entries[requirementId] = fields;
+	}
+	return [entries, issues];
+}
+/** get_run_requirement_ids: R ids from 00-requirements or 01-as-is inventory (current profile). */
+function getRunRequirementIds(runDir, workflowProfile) {
+	const requirementsPath = join(runDir, "00-requirements.md");
+	let explicitIds = [];
+	if (existsSync(requirementsPath)) explicitIds = parseRequirementIds(readFileSync(requirementsPath, "utf8"));
+	if (workflowProfile === "recursive-mode-audit-v2") {
+		const phase1Path = join(runDir, "01-as-is.md");
+		if (existsSync(phase1Path)) {
+			const inventoryBody = getHeadingBody(readFileSync(phase1Path, "utf8"), "Source Requirement Inventory");
+			if (inventoryBody) {
+				const [entries] = parseSourceRequirementInventoryEntries(inventoryBody);
+				if (Object.keys(entries).length > 0) return Object.keys(entries).sort((a, b) => {
+					const [ka, va, sa] = requirementSortKey(a);
+					const [kb, vb, sb] = requirementSortKey(b);
+					return ka !== kb ? ka - kb : typeof va === "number" && typeof vb === "number" ? va - vb : String(va).localeCompare(String(vb));
 				});
+			}
+		}
+	}
+	return explicitIds;
+}
+/** validate_planned_surface_paths: implementation-surface paths must resolve or have an existing parent. */
+function validatePlannedSurfacePaths(requirementId, fieldName, rawValue, repoRoot) {
+	const issues = [];
+	const extracted = collectRequirementFieldPaths({ [fieldName]: rawValue }, [fieldName]);
+	if (extracted.size === 0) {
+		issues.push(`Requirement ${requirementId} ${fieldName} must cite concrete repo paths or file names`);
+		return issues;
+	}
+	const unresolved = [];
+	for (const path of [...extracted].sort()) {
+		const candidate = join(repoRoot, path);
+		if (existsSync(candidate)) continue;
+		if (existsSync(dirname(candidate))) continue;
+		unresolved.push(path);
+	}
+	if (unresolved.length > 0) issues.push(`Requirement ${requirementId} ${fieldName} contains unresolved planned path(s): ${unresolved.slice(0, 5).join(", ")}`);
+	return issues;
+}
+/** lint_effective_input_addenda: Inputs / Effective Inputs Re-read / Earlier Phase Reconciliation addenda citations. */
+function lintEffectiveInputAddenda(filePath, content, workflowProfile, runDir) {
+	if (![...STRICT_WORKFLOW_PROFILES$1, "memory-phase8"].includes(workflowProfile)) return [];
+	if (isAddendumArtifact(basename(filePath))) return [];
+	const expectedAddenda = getExpectedEffectiveInputAddendaPaths(runDir, basename(filePath));
+	if (expectedAddenda.length === 0) return [];
+	const issues = [];
+	const headerInputs = new Set([...getHeaderInputPaths(content)].map(normalizeRepoPath));
+	const missingInputs = expectedAddenda.filter((p) => !headerInputs.has(p));
+	if (missingInputs.length > 0) issues.push(`Inputs is missing relevant addenda: ${missingInputs.slice(0, 5).join(", ")}`);
+	if (STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) && AUDITED_PHASE_FILES$2.has(basename(filePath))) {
+		const rereadPaths = new Set([...extractPathsFromText(getHeadingBody(content, "Effective Inputs Re-read"))].map(normalizeRepoPath));
+		const missingReread = expectedAddenda.filter((p) => !rereadPaths.has(p));
+		if (missingReread.length > 0) issues.push(`Effective Inputs Re-read is missing relevant addenda: ${missingReread.slice(0, 5).join(", ")}`);
+		const reconciliationPaths = new Set([...extractPathsFromText(getHeadingBody(content, "Earlier Phase Reconciliation"))].map(normalizeRepoPath));
+		const missingRecon = expectedAddenda.filter((p) => !reconciliationPaths.has(p));
+		if (missingRecon.length > 0) issues.push(`Earlier Phase Reconciliation is missing relevant addenda: ${missingRecon.slice(0, 5).join(", ")}`);
+	}
+	return issues;
+}
+/** lint_requirement_completion_status: RCS section rules for audited phases. */
+function lintRequirementCompletionStatus(filePath, content, requirementIds, runDir, workflowProfile, actualChangedFiles) {
+	if (!STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) || !AUDITED_PHASE_FILES$2.has(basename(filePath))) return [];
+	const body = getHeadingBody(content, "Requirement Completion Status");
+	if (!body) return ["Missing or empty section: ## Requirement Completion Status"];
+	const [entries, issues] = parseRequirementCompletionEntries(body);
+	const missing = requirementIds.filter((id) => !(id in entries));
+	if (missing.length > 0) issues.push(`Requirement Completion Status is missing in-scope requirements: ${missing.join(", ")}`);
+	const repoRoot = dirname(dirname(dirname(runDir)));
+	if (workflowProfile === "recursive-mode-audit-v2" && basename(filePath) === "02-to-be-plan.md") {
+		for (const [requirementId, fields] of Object.entries(entries)) {
+			const status = trimMdValue$1(fields["Status"] ?? "").toLowerCase();
+			if (!PHASE2_REQUIREMENT_DISPOSITION_STATUSES.has(status)) {
+				issues.push(`Requirement Completion Status for ${requirementId} has invalid Phase 2 Status '${fields["Status"] ?? ""}'`);
 				continue;
 			}
-			if (storedHash !== lockHashFromContent(readFileSync(prereqPath, "utf8"))) stale.push({
-				artifact: phase,
-				reason: `prerequisite '${prereq}' content changed since lock at ${receipt.locked_at}`
-			});
+			issues.push(...lintPhase2RequirementDispositionFields(requirementId, status, fields, runDir, repoRoot));
 		}
+		return [...new Set(issues)].sort();
 	}
-	return stale;
+	for (const [requirementId, fields] of Object.entries(entries)) {
+		const status = trimMdValue$1(fields["Status"] ?? "").toLowerCase();
+		if (!REQUIREMENT_DISPOSITION_STATUSES.has(status)) {
+			issues.push(`Requirement Completion Status for ${requirementId} has invalid Status '${fields["Status"] ?? ""}'`);
+			continue;
+		}
+		issues.push(...lintRequirementDispositionFields(requirementId, status, fields, basename(filePath), runDir, repoRoot, actualChangedFiles));
+	}
+	if (REQUIREMENT_CHANGED_FILE_ACCOUNTING_FILES.has(basename(filePath))) {
+		const expectedScope = new Set(getPhaseOwnedActualChangedFiles(basename(filePath), actualChangedFiles, repoRoot) ?? []);
+		if (expectedScope.size > 0) {
+			const claimedChangedFiles = /* @__PURE__ */ new Set();
+			for (const fields of Object.values(entries)) {
+				const status = trimMdValue$1(fields["Status"] ?? "").toLowerCase();
+				if (["implemented", "verified"].includes(status)) for (const p of collectRequirementFieldPaths(fields, ["Changed Files"])) claimedChangedFiles.add(p);
+			}
+			const missingClaims = [...expectedScope].filter((p) => !claimedChangedFiles.has(p)).sort();
+			if (missingClaims.length > 0) issues.push("Requirement Completion Status leaves diff-owned changed file(s) unaccounted for: " + missingClaims.slice(0, 5).join(", "));
+		}
+	}
+	return [...new Set(issues)].sort();
 }
-/**
-* Validate the full lock chain of a run: per-phase lock status, break phase,
-* next legal phase, completion, and stale receipts.
-*/
-function validateChain(runDir, runId) {
-	const phases = [];
-	let breakPhase = null;
-	let complete = true;
-	for (const phase of PHASE_SEQUENCE) {
-		const status = getLockStatus(join(runDir, phase));
-		const problems = [];
-		const lockValid = status === "LOCKED";
-		if (!lockValid && breakPhase === null) {
-			breakPhase = phase;
-			complete = false;
+/** lint_prior_recursive_evidence: Prior Recursive Evidence Reviewed rules. */
+function lintPriorRecursiveEvidence(content, runDir, workflowProfile, repoRoot, fileName) {
+	if (!STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) || !PRIOR_RECURSIVE_EVIDENCE_FILES.has(fileName)) return [];
+	const body = getHeadingBody(content, "Prior Recursive Evidence Reviewed");
+	if (!body) return ["Missing or empty section: ## Prior Recursive Evidence Reviewed"];
+	const referencedPaths = /* @__PURE__ */ new Set();
+	for (const path of extractPathsFromText(body)) {
+		const normalized = normalizeRepoPath(path);
+		if (normalized.startsWith(".recursive/run/") || normalized.startsWith(".recursive/memory/")) referencedPaths.add(normalized);
+	}
+	if (referencedPaths.size > 0) {
+		const missing = findMissingRepoPaths(repoRoot, [...referencedPaths].sort());
+		if (missing.length > 0) return [`Prior Recursive Evidence Reviewed references missing path(s): ${missing.slice(0, 5).join(", ")}`];
+		return [];
+	}
+	if (/\bnone\b/i.test(body) && /\b(justification|reason|because)\b/i.test(body)) return [];
+	return ["Prior Recursive Evidence Reviewed must contain structured run/memory paths or an explicit no-relevant-evidence justification"];
+}
+/** get_subagent_action_record_paths: subagents/ paths cited in Subagent Contribution Verification. */
+function getSubagentActionRecordPaths(content, runDir) {
+	const body = getHeadingBody(content, "Subagent Contribution Verification");
+	if (!body) return [];
+	const expectedPrefix = `.recursive/run/${basename(runDir)}/subagents/`;
+	return [...new Set([...extractPathsFromText(body)].map(normalizeRepoPath).filter((p) => p.startsWith(expectedPrefix)))].sort();
+}
+/** get_all_subagent_action_record_paths: any run subagents/ path cited. */
+function getAllSubagentActionRecordPaths(content) {
+	const body = getHeadingBody(content, "Subagent Contribution Verification");
+	if (!body) return [];
+	return [...new Set([...extractPathsFromText(body)].map(normalizeRepoPath).filter((p) => /^\.recursive\/run\/[^/]+\/subagents\/.+\.md$/.test(p)))].sort();
+}
+/** lint_subagent_action_record_file: validate a subagent action record file. */
+function lintSubagentActionRecordFile(filePath, repoRoot, runDir, actualChangedFiles) {
+	const content = readFileSync(filePath, "utf8");
+	const issues = [];
+	if (!content.includes("# Subagent Action Record")) issues.push("Missing title: # Subagent Action Record");
+	for (const heading of SUBAGENT_ACTION_REQUIRED_HEADINGS) if (!getHeadingBody(content, heading)) issues.push(`Missing or empty section: ## ${heading}`);
+	const metadata = getHeadingBody(content, "Metadata");
+	const inputs = getHeadingBody(content, "Inputs Provided");
+	const claimedActions = getHeadingBody(content, "Claimed Actions Taken");
+	const claimedFileImpact = getHeadingBody(content, "Claimed File Impact");
+	const claimedArtifactImpact = getHeadingBody(content, "Claimed Artifact Impact");
+	if (dirname(filePath) !== join(runDir, "subagents")) issues.push(`Subagent action record must live under \`/.recursive/run/${basename(runDir)}/subagents/\``);
+	for (const fieldName of [
+		"Subagent ID",
+		"Run ID",
+		"Phase",
+		"Purpose",
+		"Execution Mode",
+		"Timestamp"
+	]) if (!hasMeaningfulValue(getMdFieldValue$1(metadata, fieldName))) issues.push(`Metadata is missing ${fieldName}`);
+	const runId = getMdFieldValue$1(metadata, "Run ID");
+	if (runId && runId !== basename(runDir)) issues.push(`Run ID mismatch: ${runId} != ${basename(runDir)}`);
+	const currentArtifact = normalizeRepoPath(getMdFieldValue$1(inputs, "Current Artifact") ?? "");
+	if (!currentArtifact) issues.push("Inputs Provided is missing Current Artifact");
+	else if (!existsSync(join(repoRoot, currentArtifact))) issues.push(`Current Artifact does not exist: ${currentArtifact}`);
+	const artifactHash = trimMdValue$1(getMdFieldValue$1(inputs, "Artifact Content Hash") ?? "");
+	if (currentArtifact && existsSync(join(repoRoot, currentArtifact))) {
+		const currentHash = contentSha256$1(readFileSync(join(repoRoot, currentArtifact), "utf8"));
+		if (!artifactHash) issues.push("Inputs Provided is missing Artifact Content Hash");
+		else if (artifactHash !== currentHash) issues.push("Inputs Provided Artifact Content Hash does not match the current artifact content");
+	}
+	const reviewBundle = normalizeRepoPath(getMdFieldValue$1(inputs, "Review Bundle") ?? "");
+	if (reviewBundle && !existsSync(join(repoRoot, reviewBundle))) issues.push(`Review Bundle does not exist: ${reviewBundle}`);
+	if (!(getMdFieldValue$1(inputs, "Diff Basis") ?? "").trim()) issues.push("Inputs Provided is missing Diff Basis");
+	const upstreamArtifacts = new Set([...extractPathsFromNamedField(inputs, "Upstream Artifacts")].filter((p) => p.startsWith(`.recursive/run/${basename(runDir)}/`)));
+	const codeRefs = extractPathsFromNamedField(inputs, "Code Refs");
+	const memoryRefs = new Set([...extractPathsFromNamedField(inputs, "Memory Refs")].filter((p) => p.startsWith(".recursive/memory/")));
+	const auditQuestionText = getMdFieldValue$1(inputs, "Audit / Task Questions") ?? inputs;
+	if (upstreamArtifacts.size === 0 && !reviewBundle) issues.push("Inputs Provided must cite upstream artifacts or the review bundle used for delegation");
+	if (isPlaceholderOnly(auditQuestionText)) issues.push("Inputs Provided is missing concrete Audit / Task Questions");
+	const claimedCreated = new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Created"))].map(normalizeRepoPath));
+	const claimedModified = new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Modified"))].map(normalizeRepoPath));
+	const claimedReviewed = new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Reviewed"))].map(normalizeRepoPath));
+	const claimedRelevantUntouched = new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Relevant but Untouched"))].map(normalizeRepoPath));
+	if (isPlaceholderOnly(claimedActions)) issues.push("Claimed Actions Taken must contain concrete delegated work details");
+	const claimedFileRefs = /* @__PURE__ */ new Set([
+		...claimedCreated,
+		...claimedModified,
+		...claimedReviewed,
+		...claimedRelevantUntouched
+	]);
+	if (claimedFileRefs.size === 0) issues.push("Claimed File Impact must cite at least one created, modified, reviewed, or relevant untouched file");
+	for (const createdPath of [...claimedCreated].sort()) if (!existsSync(join(repoRoot, createdPath))) issues.push(`Claimed created file does not exist: ${createdPath}`);
+	for (const reviewedPath of [.../* @__PURE__ */ new Set([
+		...claimedModified,
+		...claimedReviewed,
+		...claimedRelevantUntouched
+	])].sort()) if (!existsSync(join(repoRoot, reviewedPath))) issues.push(`Claimed file reference does not exist: ${reviewedPath}`);
+	if (actualChangedFiles !== null) {
+		const actualChanged = new Set(actualChangedFiles);
+		const missingChangedClaims = [.../* @__PURE__ */ new Set([...claimedModified, ...claimedCreated])].filter((p) => !actualChanged.has(p));
+		if (missingChangedClaims.length > 0) issues.push(`Claimed modified/created files are not present in the current diff: ${[...new Set(missingChangedClaims)].sort().slice(0, 5).join(", ")}`);
+	}
+	if (reviewBundle && existsSync(join(repoRoot, reviewBundle))) {
+		const bundleContent = readFileSync(join(repoRoot, reviewBundle), "utf8");
+		const bundleArtifactPath = normalizeRepoPath(getMdFieldValue$1(bundleContent, "Artifact Path") ?? "");
+		const bundleUpstream = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Upstream Artifacts To Re-read"))].map(normalizeRepoPath).filter(Boolean));
+		const bundleChanged = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Changed Files Reviewed"))].map(normalizeRepoPath).filter(Boolean));
+		const bundleCodeRefs = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Targeted Code References"))].map(normalizeRepoPath).filter(Boolean));
+		const allowedArtifacts = new Set([bundleArtifactPath, ...bundleUpstream].filter(Boolean));
+		if (currentArtifact && allowedArtifacts.size > 0 && !allowedArtifacts.has(currentArtifact)) issues.push(`Inputs Provided Current Artifact must match the review bundle Artifact Path or a cited upstream artifact: ${currentArtifact}`);
+		const missingBundleUpstream = [...bundleUpstream].filter((p) => !upstreamArtifacts.has(p)).sort();
+		if (missingBundleUpstream.length > 0) issues.push(`Inputs Provided Upstream Artifacts omit bundle upstream artifact(s): ${missingBundleUpstream.slice(0, 5).join(", ")}`);
+		const requiredBundleFileScope = /* @__PURE__ */ new Set([...bundleCodeRefs, ...bundleChanged]);
+		if (requiredBundleFileScope.size > 0) {
+			const missingBundleScope = [...requiredBundleFileScope].filter((p) => !claimedFileRefs.has(p)).sort();
+			if (missingBundleScope.length > 0) issues.push(`Claimed File Impact omits targeted file scope present in the review bundle: ${missingBundleScope.slice(0, 5).join(", ")}`);
+		}
+	}
+	const artifactRefs = new Set([...extractPathsFromText(claimedArtifactImpact)].map(normalizeRepoPath).filter((p) => p.startsWith(".recursive/")));
+	const evidenceRefs = new Set([...extractPathsFromText(claimedArtifactImpact)].map(normalizeRepoPath).filter((p) => p.startsWith(`.recursive/run/${basename(runDir)}/evidence/`)));
+	if (artifactRefs.size === 0 && evidenceRefs.size === 0) issues.push("Claimed Artifact Impact must cite recursive artifacts or evidence paths used by the subagent");
+	const missingArtifactRefs = findMissingRepoPaths(repoRoot, [...artifactRefs].sort());
+	if (missingArtifactRefs.length > 0) issues.push(`Claimed artifact references do not exist: ${missingArtifactRefs.slice(0, 5).join(", ")}`);
+	const missingCodeRefs = findMissingRepoPaths(repoRoot, [...codeRefs].sort());
+	if (missingCodeRefs.length > 0) issues.push(`Inputs Provided code refs do not exist: ${missingCodeRefs.slice(0, 5).join(", ")}`);
+	const missingMemoryRefs = findMissingRepoPaths(repoRoot, [...memoryRefs].sort());
+	if (missingMemoryRefs.length > 0) issues.push(`Inputs Provided memory refs do not exist: ${missingMemoryRefs.slice(0, 5).join(", ")}`);
+	const verificationHandoff = getHeadingBody(content, "Verification Handoff");
+	if (verificationHandoff && extractPathsFromText(verificationHandoff).size === 0) issues.push("Verification Handoff must cite files, diffs, or artifacts to inspect");
+	return [...new Set(issues)].sort();
+}
+/** parse_subagent_action_record_claims: extract claims from an action record. */
+function parseSubagentActionRecordClaims(actionContent) {
+	const inputs = getHeadingBody(actionContent, "Inputs Provided");
+	const claimedFileImpact = getHeadingBody(actionContent, "Claimed File Impact");
+	const claimedArtifactImpact = getHeadingBody(actionContent, "Claimed Artifact Impact");
+	return {
+		current_artifact: normalizeRepoPath(getMdFieldValue$1(inputs, "Current Artifact") ?? ""),
+		review_bundle: normalizeRepoPath(getMdFieldValue$1(inputs, "Review Bundle") ?? ""),
+		upstream_artifacts: extractPathsFromNamedField(inputs, "Upstream Artifacts"),
+		created: new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Created"))].map(normalizeRepoPath).filter(Boolean)),
+		modified: new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Modified"))].map(normalizeRepoPath).filter(Boolean)),
+		reviewed: new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Reviewed"))].map(normalizeRepoPath).filter(Boolean)),
+		relevant_untouched: new Set([...extractPathsFromText(getSubheadingBody(claimedFileImpact, "Relevant but Untouched"))].map(normalizeRepoPath).filter(Boolean)),
+		artifact_refs: new Set([...extractPathsFromText(claimedArtifactImpact)].map(normalizeRepoPath).filter((p) => p.startsWith(".recursive/")))
+	};
+}
+/** lint_subagent_contribution_verification: SCV section rules for audited phases. */
+function lintSubagentContributionVerification(filePath, content, workflowProfile, runDir, repoRoot, actualChangedFiles) {
+	if (!STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) || !AUDITED_PHASE_FILES$2.has(basename(filePath))) return [];
+	const body = getHeadingBody(content, "Subagent Contribution Verification");
+	if (!body) return ["Missing or empty section: ## Subagent Contribution Verification"];
+	const issues = [];
+	const actionRecordPaths = getSubagentActionRecordPaths(content, runDir);
+	const allActionRecordPaths = getAllSubagentActionRecordPaths(content);
+	const auditMode = getMdFieldValue$1(getHeadingBody(content, "Audit Context"), "Audit Execution Mode") ?? "";
+	const currentPhase = getMdFieldValue$1(content, "Phase") ?? "";
+	const reviewedActionRecordsField = getNamedFieldText(body, "Reviewed Action Records") ?? "";
+	const mainAgentVerification = getNamedFieldText(body, "Main-Agent Verification Performed") ?? "";
+	const acceptanceDecision = trimMdValue$1(getMdFieldValue$1(body, "Acceptance Decision") ?? "").toLowerCase();
+	const refreshHandling = getNamedFieldText(body, "Refresh Handling") ?? "";
+	const repairPerformed = getNamedFieldText(body, "Repair Performed After Verification") ?? "";
+	const verificationPaths = new Set([...extractPathsFromFieldValue(mainAgentVerification)].map(normalizeRepoPath).filter(Boolean));
+	const repairPaths = new Set([...extractPathsFromFieldValue(repairPerformed)].map(normalizeRepoPath).filter(Boolean));
+	const currentBundlePath = normalizeRepoPath(getMdFieldValue$1(getHeadingBody(content, "Review Metadata"), "Review Bundle Path") ?? getMdFieldValue$1(content, "Review Bundle Path") ?? "");
+	if (auditMode === "subagent" && actionRecordPaths.length === 0) issues.push("Audit Execution Mode subagent requires at least one reviewed subagent action record");
+	const outOfRunRecords = allActionRecordPaths.filter((p) => !actionRecordPaths.includes(p)).sort();
+	if (outOfRunRecords.length > 0) issues.push(`Subagent Contribution Verification may only reference action records under the current run subagents/: ${outOfRunRecords.slice(0, 5).join(", ")}`);
+	if (actionRecordPaths.length > 0) {
+		const reviewedRecordPaths = new Set([...extractPathsFromFieldValue(reviewedActionRecordsField)].map(normalizeRepoPath).filter((p) => p.startsWith(`.recursive/run/${basename(runDir)}/subagents/`)));
+		if (!reviewedActionRecordsField.trim()) issues.push("Subagent Contribution Verification must record Reviewed Action Records");
+		else {
+			const missingReviewed = actionRecordPaths.filter((p) => !reviewedRecordPaths.has(p)).sort();
+			if (missingReviewed.length > 0) issues.push(`Reviewed Action Records is missing referenced action record path(s): ${missingReviewed.slice(0, 5).join(", ")}`);
+		}
+		if (!hasMeaningfulValue(mainAgentVerification, /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Subagent Contribution Verification must record Main-Agent Verification Performed");
+		else if (verificationPaths.size === 0) issues.push("Main-Agent Verification Performed must cite files, artifacts, or diff-owned paths that were checked");
+		else {
+			const missingVerification = findMissingRepoPaths(repoRoot, [...verificationPaths].sort());
+			if (missingVerification.length > 0) issues.push(`Main-Agent Verification Performed references missing path(s): ${missingVerification.slice(0, 5).join(", ")}`);
+		}
+		if (![
+			"accepted",
+			"partially accepted",
+			"rejected"
+		].includes(acceptanceDecision)) issues.push("Subagent Contribution Verification must record Acceptance Decision: accepted|partially accepted|rejected");
+		if (!hasMeaningfulValue(refreshHandling, /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Subagent Contribution Verification must record Refresh Handling");
+		if (!trimMdValue$1(repairPerformed)) issues.push("Subagent Contribution Verification must record Repair Performed After Verification");
+		else if (repairPaths.size > 0) {
+			const missingRepair = findMissingRepoPaths(repoRoot, [...repairPaths].sort());
+			if (missingRepair.length > 0) issues.push(`Repair Performed After Verification references missing path(s): ${missingRepair.slice(0, 5).join(", ")}`);
+		}
+	}
+	for (const actionRecordPath of actionRecordPaths) {
+		if (!existsSync(join(repoRoot, actionRecordPath))) {
+			issues.push(`Referenced subagent action record does not exist: ${actionRecordPath}`);
+			continue;
+		}
+		const actionContent = readFileSync(join(repoRoot, actionRecordPath), "utf8");
+		const actionPhase = getMdFieldValue$1(getHeadingBody(actionContent, "Metadata"), "Phase") ?? "";
+		const actionClaims = parseSubagentActionRecordClaims(actionContent);
+		if (currentPhase && actionPhase && currentPhase !== actionPhase) issues.push(`Subagent action record phase mismatch: ${actionRecordPath} -> ${actionPhase}`);
+		if (currentBundlePath) {
+			const actionBundlePath = String(actionClaims["review_bundle"]);
+			if (actionBundlePath && actionBundlePath !== currentBundlePath) issues.push(`Subagent action record review bundle mismatch: ${actionRecordPath} -> ${actionBundlePath}`);
+		}
+		issues.push(...lintSubagentActionRecordFile(join(repoRoot, actionRecordPath), repoRoot, runDir, actualChangedFiles));
+		if (["accepted", "partially accepted"].includes(acceptanceDecision)) {
+			const claimedDiffScope = new Set([
+				"created",
+				"modified",
+				"reviewed"
+			].flatMap((k) => [...actionClaims[k]]));
+			let expectedVerifiedPaths = new Set(claimedDiffScope);
+			if (actualChangedFiles !== null) expectedVerifiedPaths = new Set([...expectedVerifiedPaths].filter((p) => actualChangedFiles.includes(p)));
+			const missingVerified = [...expectedVerifiedPaths].filter((p) => !verificationPaths.has(p) && !repairPaths.has(p)).sort();
+			if (missingVerified.length > 0) issues.push(`Main-Agent Verification Performed does not reconcile delegated file-impact claims against the actual diff scope: ${missingVerified.slice(0, 5).join(", ")}`);
+			const verificationArtifactScope = /* @__PURE__ */ new Set([
+				String(actionClaims["current_artifact"]),
+				...actionClaims["upstream_artifacts"],
+				...actionClaims["artifact_refs"]
+			]);
+			if (actionClaims["review_bundle"]) verificationArtifactScope.add(String(actionClaims["review_bundle"]));
+			verificationArtifactScope.delete("");
+			if (verificationArtifactScope.size > 0 && ![...verificationArtifactScope].some((p) => verificationPaths.has(p))) issues.push("Main-Agent Verification Performed must cite the reviewed artifact, bundle, or upstream recursive artifacts used to verify the delegated work");
+		}
+	}
+	return [...new Set(issues)].sort();
+}
+/** collect_reviewed_paths: paths from Worktree Diff Audit + related addenda. */
+function collectReviewedPaths(runDir, artifactName, content) {
+	const reviewed = extractPathsFromText(getHeadingBody(content, "Worktree Diff Audit"));
+	for (const addendumPath of getRelatedAddendaPaths(runDir, artifactName)) {
+		const full = join(runDir, "addenda", addendumPath);
+		if (existsSync(full)) for (const p of extractPathsFromText(readFileSync(full, "utf8"))) reviewed.add(p);
+	}
+	return reviewed;
+}
+/** lint_review_bundle_reference: 03.5 review-bundle validation. */
+function lintReviewBundleReference(content, runDir, repoRoot) {
+	const issues = [];
+	const bundlePath = (getMdFieldValue$1(getHeadingBody(content, "Review Metadata"), "Review Bundle Path") ?? getMdFieldValue$1(content, "Review Bundle Path") ?? "").trim();
+	const expectedPrefix = `.recursive/run/${basename(runDir)}/evidence/review-bundles/`;
+	if (!bundlePath) {
+		issues.push("Review Metadata is missing Review Bundle Path");
+		return issues;
+	}
+	const normalizedBundlePath = normalizeRepoPath(bundlePath);
+	if (!normalizedBundlePath.startsWith(expectedPrefix)) {
+		issues.push(`Review Bundle Path must live under \`/${expectedPrefix}\``);
+		return issues;
+	}
+	if (!existsSync(join(repoRoot, normalizedBundlePath))) {
+		issues.push(`Review Bundle Path does not exist: ${normalizedBundlePath}`);
+		return issues;
+	}
+	const bundleContent = readFileSync(join(repoRoot, normalizedBundlePath), "utf8");
+	const artifactPath = normalizeRepoPath(getMdFieldValue$1(bundleContent, "Artifact Path") ?? "");
+	const artifactHash = trimMdValue$1(getMdFieldValue$1(bundleContent, "Artifact Content Hash") ?? "");
+	if (!artifactPath) issues.push("Review bundle is missing Artifact Path");
+	else if (!existsSync(join(repoRoot, artifactPath))) issues.push(`Review bundle Artifact Path does not exist: ${artifactPath}`);
+	if (artifactPath) {
+		const currentHash = existsSync(join(repoRoot, artifactPath)) ? contentSha256$1(readFileSync(join(repoRoot, artifactPath), "utf8")) : null;
+		if (artifactHash && currentHash && artifactHash !== currentHash) issues.push("Review bundle is stale: Artifact Content Hash no longer matches the current artifact");
+	}
+	if (!artifactHash) issues.push("Review bundle is missing Artifact Content Hash");
+	const missingHeadings = [];
+	for (const heading of [
+		"Diff Basis",
+		"Changed Files Reviewed",
+		"Upstream Artifacts To Re-read",
+		"Relevant Addenda",
+		"Prior Recursive Evidence",
+		"Targeted Code References",
+		"Audit Questions",
+		"Required Output"
+	]) if (!getHeadingBody(bundleContent, heading)) missingHeadings.push(heading);
+	if (missingHeadings.length > 0) issues.push(`Review bundle is missing required section(s): ${missingHeadings.join(", ")}`);
+	const reviewNarrative = [
+		getHeadingBody(content, "Review Scope"),
+		getHeadingBody(content, "Requirement And Plan Reconciliation"),
+		getHeadingBody(content, "Plan Alignment Assessment"),
+		getHeadingBody(content, "Code Quality Assessment"),
+		getHeadingBody(content, "Issues Found"),
+		getHeadingBody(content, "Verdict")
+	].join("\n");
+	const citedPaths = new Set([...extractPathsFromText(content)].map(normalizeRepoPath));
+	const citedReviewPaths = new Set([...extractPathsFromText(reviewNarrative)].map(normalizeRepoPath));
+	const upstreamPaths = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Upstream Artifacts To Re-read"))].map(normalizeRepoPath));
+	const addendaPaths = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Relevant Addenda"))].map(normalizeRepoPath));
+	const priorPaths = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Prior Recursive Evidence"))].map(normalizeRepoPath));
+	const changedPaths = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Changed Files Reviewed"))].map(normalizeRepoPath));
+	const codeRefPaths = new Set([...extractPathsFromText(getHeadingBody(bundleContent, "Targeted Code References"))].map(normalizeRepoPath));
+	if (isPlaceholderOnly(getHeadingBody(bundleContent, "Audit Questions"))) issues.push("Review bundle Audit Questions cannot be placeholder-only");
+	const diffBasisBody = getHeadingBody(bundleContent, "Diff Basis");
+	for (const fieldName of DIFF_BASIS_FIELDS) if (getMdFieldValue$1(diffBasisBody, fieldName) === null) issues.push(`Review bundle Diff Basis is missing ${fieldName}`);
+	if (changedPaths.size === 0) issues.push("Review bundle Changed Files Reviewed cannot be empty");
+	else {
+		const missingChanged = findMissingRepoPaths(repoRoot, [...changedPaths].sort());
+		if (missingChanged.length > 0) issues.push(`Review bundle changed file path(s) do not exist: ${missingChanged.slice(0, 5).join(", ")}`);
+	}
+	if (codeRefPaths.size === 0) issues.push("Review bundle Targeted Code References cannot be empty");
+	else {
+		const missingCode = findMissingRepoPaths(repoRoot, [...codeRefPaths].sort());
+		if (missingCode.length > 0) issues.push(`Review bundle code ref path(s) do not exist: ${missingCode.slice(0, 5).join(", ")}`);
+		else if (changedPaths.size > 0 && ![...codeRefPaths].some((p) => changedPaths.has(p))) issues.push("Review bundle Targeted Code References do not overlap the changed-file scope");
+	}
+	const missingBundleAddenda = [...new Set(getExpectedEffectiveInputAddendaPaths(runDir, "03.5-code-review.md"))].filter((p) => !addendaPaths.has(p)).sort();
+	if (missingBundleAddenda.length > 0) issues.push(`Review bundle is missing effective-input addenda: ${missingBundleAddenda.slice(0, 5).join(", ")}`);
+	if (upstreamPaths.size > 0 && ![...upstreamPaths].some((p) => citedReviewPaths.has(p))) issues.push("Code review narrative does not cite any upstream artifact from the review bundle");
+	if (addendaPaths.size > 0 && ![...addendaPaths].some((p) => citedReviewPaths.has(p))) issues.push("Code review narrative does not cite any relevant addendum from the review bundle");
+	if (priorPaths.size > 0 && ![...priorPaths].some((p) => citedReviewPaths.has(p))) issues.push("Code review narrative does not cite any prior recursive evidence from the review bundle");
+	if ((changedPaths.size > 0 || codeRefPaths.size > 0) && ![.../* @__PURE__ */ new Set([...changedPaths, ...codeRefPaths])].some((p) => citedReviewPaths.has(p))) issues.push("Code review narrative does not cite any changed file or code reference from the review bundle");
+	if (!citedPaths.has(normalizedBundlePath)) issues.push("Code review must cite the Review Bundle Path in its written review artifact");
+	const verdictBody = getHeadingBody(content, "Verdict");
+	if (!verdictBody || isPlaceholderOnly(verdictBody)) issues.push("Verdict section must contain a concrete review verdict grounded in the review bundle");
+	return issues;
+}
+/** lint_phase8_skill_usage_capture: 08 Run-Local Skill Usage Capture rules. */
+function lintPhase8SkillUsageCapture(content) {
+	const issues = [];
+	const usageBody = getHeadingBody(content, "Run-Local Skill Usage Capture");
+	if (!usageBody) return ["Missing or empty section: ## Run-Local Skill Usage Capture"];
+	for (const fieldName of [
+		"Skill Usage Relevance",
+		"Available Skills",
+		"Skills Sought",
+		"Skills Attempted",
+		"Skills Used",
+		"Worked Well",
+		"Issues Encountered",
+		"Future Guidance",
+		"Promotion Candidates"
+	]) if (getMdFieldValue$1(usageBody, fieldName) === null) issues.push(`Run-Local Skill Usage Capture is missing ${fieldName}`);
+	const relevance = normalizeSkillUsageRelevance(getMdFieldValue$1(usageBody, "Skill Usage Relevance"));
+	if (!SKILL_USAGE_RELEVANCE_STATUSES.has(relevance)) {
+		issues.push("Run-Local Skill Usage Capture must declare Skill Usage Relevance: relevant|not-relevant");
+		return issues;
+	}
+	if (["relevant", "yes"].includes(relevance)) {
+		for (const fieldName of [
+			"Available Skills",
+			"Skills Attempted",
+			"Skills Used",
+			"Future Guidance"
+		]) if (!isMeaningfulRequirementField(getMdFieldValue$1(usageBody, fieldName))) issues.push(`Run-Local Skill Usage Capture must record ${fieldName} when skill usage is relevant`);
+		const attempted = trimMdValue$1(getMdFieldValue$1(usageBody, "Skills Attempted") ?? "").toLowerCase();
+		const used = trimMdValue$1(getMdFieldValue$1(usageBody, "Skills Used") ?? "").toLowerCase();
+		if (["none", "n/a"].includes(attempted) && ["none", "n/a"].includes(used)) issues.push("Run-Local Skill Usage Capture cannot mark skill usage relevant while claiming no attempted or used skills");
+	}
+	const promotionBody = getHeadingBody(content, "Skill Memory Promotion Review");
+	if (!promotionBody) {
+		issues.push("Missing or empty section: ## Skill Memory Promotion Review");
+		return issues;
+	}
+	for (const fieldName of [
+		"Durable Skill Lessons Promoted",
+		"Generalized Guidance Updated",
+		"Run-Local Observations Left Unpromoted",
+		"Promotion Decision Rationale"
+	]) if (getMdFieldValue$1(promotionBody, fieldName) === null) issues.push(`Skill Memory Promotion Review is missing ${fieldName}`);
+	if (["relevant", "yes"].includes(relevance) && !isMeaningfulRequirementField(getMdFieldValue$1(promotionBody, "Promotion Decision Rationale"))) issues.push("Skill Memory Promotion Review must explain why relevant run-local observations were or were not promoted");
+	return issues;
+}
+/** lint_phase_specific_rules: per-phase rules dispatched from the artifact file. */
+function lintPhaseSpecificRules(filePath, content, workflowProfile, runDir, repoRoot, requirementIds, actualChangedFiles) {
+	const issues = [];
+	const fileName = basename(filePath);
+	issues.push(...lintEffectiveInputAddenda(filePath, content, workflowProfile, runDir));
+	issues.push(...lintSourceRequirementInventory(filePath, content, workflowProfile, runDir));
+	if (fileName === "02-to-be-plan.md") {
+		issues.push(...lintRequirementMapping(content, workflowProfile, runDir, repoRoot));
+		issues.push(...lintPlanDriftCheck(content, workflowProfile));
+	}
+	issues.push(...lintRequirementCompletionStatus(filePath, content, requirementIds, runDir, workflowProfile, actualChangedFiles));
+	issues.push(...lintPriorRecursiveEvidence(content, runDir, workflowProfile, repoRoot, fileName));
+	issues.push(...lintSubagentContributionVerification(filePath, content, workflowProfile, runDir, repoRoot, actualChangedFiles));
+	if (!STRICT_WORKFLOW_PROFILES$1.has(workflowProfile)) return issues;
+	if (fileName === "00-worktree.md") {
+		const [diffBasis, diffBasisError] = normalizeDiffBasis(repoRoot, getRunDiffBasis(runDir));
+		if (diffBasisError) issues.push(`Phase 0 diff basis is not executable: ${diffBasisError}`);
+		else if (diffBasis === null) issues.push("Phase 0 diff basis could not be normalized");
+	}
+	if (fileName === "03-implementation-summary.md") {
+		const tddBody = getHeadingBody(content, "TDD Compliance Log");
+		const tddMode = (getMdFieldValue$1(tddBody, "TDD Mode") ?? getMdFieldValue$1(content, "TDD Mode") ?? "").toLowerCase();
+		if (!hasGateLine(content, "TDD Compliance")) issues.push("Missing required gate line: TDD Compliance: PASS|FAIL");
+		if (!TDD_MODES.has(tddMode)) issues.push("TDD Compliance Log is missing TDD Mode: strict|pragmatic");
+		else if (tddMode === "strict") {
+			if (!tddBody.includes("RED Evidence:")) issues.push("Strict TDD is missing RED Evidence in ## TDD Compliance Log");
+			if (!tddBody.includes("GREEN Evidence:")) issues.push("Strict TDD is missing GREEN Evidence in ## TDD Compliance Log");
+			const redPrefix = `.recursive/run/${basename(runDir)}/evidence/logs/red/`;
+			const greenPrefix = `.recursive/run/${basename(runDir)}/evidence/logs/green/`;
+			const redPaths = collectPathsUnderPrefix(tddBody, redPrefix);
+			const greenPaths = collectPathsUnderPrefix(tddBody, greenPrefix);
+			if (redPaths.length === 0) issues.push(`Strict TDD requires at least one RED evidence path under \`/${redPrefix}\``);
+			else {
+				const missingRed = findMissingRepoPaths(repoRoot, redPaths);
+				if (missingRed.length > 0) issues.push(`Strict TDD RED evidence path(s) do not exist: ${missingRed.slice(0, 5).join(", ")}`);
+			}
+			if (greenPaths.length === 0) issues.push(`Strict TDD requires at least one GREEN evidence path under \`/${greenPrefix}\``);
+			else {
+				const missingGreen = findMissingRepoPaths(repoRoot, greenPaths);
+				if (missingGreen.length > 0) issues.push(`Strict TDD GREEN evidence path(s) do not exist: ${missingGreen.slice(0, 5).join(", ")}`);
+			}
+		} else {
+			const exceptionBody = getHeadingBody(content, "Pragmatic TDD Exception");
+			if (!exceptionBody) issues.push("TDD Mode pragmatic requires ## Pragmatic TDD Exception");
+			else {
+				if (!hasMeaningfulValue(getMdFieldValue$1(exceptionBody, "Exception reason"), /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Pragmatic TDD Exception is missing Exception reason");
+				if (!hasMeaningfulValue(getMdFieldValue$1(exceptionBody, "Compensating validation"), /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Pragmatic TDD Exception is missing Compensating validation");
+				const pragmaticPaths = collectPathsUnderPrefix(exceptionBody, `.recursive/run/${basename(runDir)}/evidence/`);
+				if (pragmaticPaths.length === 0) issues.push(`Pragmatic TDD Exception requires compensating evidence paths under \`/.recursive/run/${basename(runDir)}/evidence/\``);
+				else {
+					const missingPragmatic = findMissingRepoPaths(repoRoot, pragmaticPaths);
+					if (missingPragmatic.length > 0) issues.push(`Pragmatic TDD compensating evidence path(s) do not exist: ${missingPragmatic.slice(0, 5).join(", ")}`);
+				}
+			}
+		}
+	}
+	if (fileName === "05-manual-qa.md") {
+		const qaRecord = getHeadingBody(content, "QA Execution Record");
+		const evidenceBody = getHeadingBody(content, "Evidence and Artifacts");
+		const signoffBody = getHeadingBody(content, "User Sign-Off");
+		const qaMode = (getMdFieldValue$1(qaRecord, "QA Execution Mode") ?? getMdFieldValue$1(content, "QA Execution Mode") ?? "").toLowerCase();
+		if (!qaRecord) issues.push("Missing or empty section: ## QA Execution Record");
+		if (!QA_EXECUTION_MODES.has(qaMode)) issues.push("QA Execution Record is missing QA Execution Mode: human|agent-operated|hybrid");
+		else {
+			if (["human", "hybrid"].includes(qaMode)) {
+				if (!hasMeaningfulValue(getMdFieldValue$1(signoffBody, "Approved by"), /* @__PURE__ */ new Set([
+					"n/a",
+					"not required",
+					"none"
+				]))) issues.push(`QA Execution Mode ${qaMode} requires User Sign-Off -> Approved by`);
+				if (!hasMeaningfulValue(getMdFieldValue$1(signoffBody, "Date"), /* @__PURE__ */ new Set([
+					"n/a",
+					"not required",
+					"none"
+				]))) issues.push(`QA Execution Mode ${qaMode} requires User Sign-Off -> Date`);
+			}
+			if (["agent-operated", "hybrid"].includes(qaMode)) {
+				if (!hasMeaningfulValue(getMdFieldValue$1(qaRecord, "Agent Executor"), /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push(`QA Execution Mode ${qaMode} requires QA Execution Record -> Agent Executor`);
+				if (!hasMeaningfulValue(getMdFieldValue$1(qaRecord, "Tools Used"), /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push(`QA Execution Mode ${qaMode} requires QA Execution Record -> Tools Used`);
+				const qaPaths = collectPathsUnderPrefix(`${qaRecord}\n${evidenceBody}`, `.recursive/run/${basename(runDir)}/evidence/`);
+				if (qaPaths.length === 0) issues.push(`QA Execution Mode ${qaMode} requires evidence paths under \`/.recursive/run/${basename(runDir)}/evidence/\``);
+				else {
+					const missingQa = findMissingRepoPaths(repoRoot, qaPaths);
+					if (missingQa.length > 0) issues.push(`QA evidence path(s) do not exist: ${missingQa.slice(0, 5).join(", ")}`);
+				}
+			}
+		}
+	}
+	if (fileName === "03.5-code-review.md") issues.push(...lintReviewBundleReference(content, runDir, repoRoot));
+	if (fileName === "08-memory-impact.md") issues.push(...lintPhase8SkillUsageCapture(content));
+	return [...new Set(issues)].sort();
+}
+/** get_header_remediation_lines: copy/paste lines for missing header fields. */
+function getHeaderRemediationLines(missingFields) {
+	const out = [];
+	for (const field of missingFields) if (field === "Run") out.push("Run: `/.recursive/run/<run-id>/`");
+	else if (field === "Phase") out.push("Phase: `<phase name>`");
+	else if (field === "Status") out.push("Status: `DRAFT`");
+	else if (field === "Inputs") {
+		out.push("Inputs:");
+		out.push("- `<path>`");
+	} else if (field === "Outputs") {
+		out.push("Outputs:");
+		out.push("- `<path>`");
+	} else if (field === "Scope note") out.push("Scope note: <one sentence describing what this artifact decides/enables>.");
+	else if (field === "LockedAt") out.push("LockedAt: `YYYY-MM-DDTHH:mm:ssZ`");
+	else if (field === "LockHash") out.push("LockHash: `<sha256-hex>`");
+	return out;
+}
+/** lint_traceability: Traceability section coverage of requirement IDs. */
+function lintTraceability(filePath, content, requirementIds) {
+	const issues = [];
+	if (!TRACEABILITY_REQUIRED_FILES.has(basename(filePath))) return issues;
+	const traceabilityBody = getHeadingBody(content, "Traceability");
+	if (!traceabilityBody) {
+		issues.push("Missing Traceability section content");
+		return issues;
+	}
+	const missingIds = requirementIds.filter((id) => !traceabilityBody.includes(id));
+	if (missingIds.length > 0) issues.push(`Traceability is missing explicit coverage for: ${missingIds.join(", ")}`);
+	if (requirementIds.length > 0 && !/\bR\d+\b/.test(traceabilityBody)) issues.push("Traceability is vague and does not mention any requirement IDs");
+	return issues;
+}
+/** lint_audit_sections: audited-phase audit section rules. */
+function lintAuditSections(filePath, content, workflowProfile, actualChangedFiles, diffBasisError, runId, runDir) {
+	const issues = [];
+	if (!STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) || !AUDITED_PHASE_FILES$2.has(basename(filePath))) return issues;
+	const auditStatus = getGateStatus$1(content, "Audit");
+	const coverageStatus = getGateStatus$1(content, "Coverage");
+	const approvalStatus = getGateStatus$1(content, "Approval");
+	if (auditStatus === "MISSING") issues.push("Missing required audit verdict line: Audit: PASS|FAIL");
+	if (coverageStatus === "PASS" && auditStatus !== "PASS") issues.push("Coverage: PASS is invalid without Audit: PASS");
+	if (approvalStatus === "PASS" && auditStatus !== "PASS") issues.push("Approval: PASS is invalid without Audit: PASS");
+	const auditContext = getHeadingBody(content, "Audit Context");
+	if (!auditContext) issues.push("Audit Context section is empty");
+	else {
+		if (!["subagent", "self-audit"].includes(getMdFieldValue$1(auditContext, "Audit Execution Mode") ?? "")) issues.push("Audit Context is missing a valid Audit Execution Mode: subagent|self-audit");
+		if (!["available", "unavailable"].includes(getMdFieldValue$1(auditContext, "Subagent Availability") ?? "")) issues.push("Audit Context is missing a valid Subagent Availability: available|unavailable");
+		if (!hasMeaningfulValue(getMdFieldValue$1(auditContext, "Subagent Capability Probe"), /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Audit Context is missing Subagent Capability Probe");
+		if (!hasMeaningfulValue(getMdFieldValue$1(auditContext, "Delegation Decision Basis"), /* @__PURE__ */ new Set(["n/a", "none"]))) issues.push("Audit Context is missing Delegation Decision Basis");
+		if (getMdFieldValue$1(auditContext, "Audit Inputs Provided") === null && !auditContext.includes("Audit Inputs Provided:")) issues.push("Audit Context is missing Audit Inputs Provided");
+		issues.push(...collectSubagentDelegationIssues(auditContext));
+	}
+	for (const heading of AUDIT_REQUIRED_HEADINGS) {
+		const sectionBody = getHeadingBody(content, heading);
+		if (!sectionBody) issues.push(`Missing or empty audited-phase section: ## ${heading}`);
+		else if (isPlaceholderOnly(sectionBody)) issues.push(`Audited-phase section still contains placeholder-only content: ## ${heading}`);
+	}
+	const diffAuditBody = getHeadingBody(content, "Worktree Diff Audit");
+	for (const field of DIFF_BASIS_FIELDS) if (getMdFieldValue$1(diffAuditBody, field) === null) issues.push(`Worktree Diff Audit is missing: ${field}:`);
+	const gapsBody = getHeadingBody(content, "Gaps Found");
+	if (auditStatus === "PASS" && gapsBody && !/\bnone\b/i.test(gapsBody)) issues.push("Audit: PASS is invalid while Gaps Found still lists unresolved in-scope gaps");
+	const expectedChangedFiles = getPhaseOwnedActualChangedFiles(basename(filePath), actualChangedFiles, dirname(dirname(dirname(runDir))));
+	if (DIFF_AUDITED_FILES.has(basename(filePath)) && expectedChangedFiles !== null) {
+		if (diffBasisError) issues.push(`Cannot verify git diff basis: ${diffBasisError}`);
+		else {
+			const reviewedPaths = collectReviewedPaths(runDir, basename(filePath), content);
+			const missingPaths = expectedChangedFiles.filter((p) => !reviewedPaths.has(p));
+			if (missingPaths.length > 0) {
+				const preview = missingPaths.slice(0, 5).join(", ");
+				const suffix = missingPaths.length > 5 ? " ..." : "";
+				issues.push(`Worktree Diff Audit does not account for actual changed files from git diff: ${preview}${suffix}`);
+			}
+		}
+	}
+	return issues;
+}
+/** lint_artifact_file: full per-artifact lint (canonical lint_artifact_file parity). */
+function lintArtifactFile(filePath, runDir, repoRoot, workflowProfile, requirementIds, actualChangedFiles, diffBasisError) {
+	const content = readFileSync(filePath, "utf8");
+	const fileName = basename(filePath);
+	const status = getMdFieldValue$1(content, "Status") ?? "UNKNOWN";
+	const missingHeaderFields = [
+		"Run",
+		"Phase",
+		"Status",
+		"Inputs",
+		"Outputs",
+		"Scope note"
+	].filter((f) => !hasHeaderField(content, f));
+	if (missingHeaderFields.length > 0) {
+		writeIssue("FAIL", filePath, `Missing required header field(s): ${missingHeaderFields.join(", ")}`, getHeaderRemediationLines(missingHeaderFields));
+		return [1, 0];
+	}
+	let failCount = 0;
+	let warnCount = 0;
+	if (!["DRAFT", "LOCKED"].includes(status)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `Invalid Status value '${status}' (expected DRAFT or LOCKED)`, ["Status: `DRAFT`"]);
+	}
+	if (status === "LOCKED") {
+		const lockMissing = ["LockedAt", "LockHash"].filter((f) => !hasHeaderField(content, f));
+		if (lockMissing.length > 0) {
+			failCount += 1;
+			writeIssue("FAIL", filePath, `Status is LOCKED but missing: ${lockMissing.join(", ")}`, getHeaderRemediationLines(lockMissing));
+		}
+	}
+	const [hasTodo, , , unchecked] = getTodoStats$1(content);
+	if (!hasTodo) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, "Missing required section: ## TODO", [
+			"## TODO",
+			"",
+			"- [ ] <task 1>",
+			"- [ ] <task 2>"
+		]);
+	} else if (status === "LOCKED" && unchecked > 0) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `LOCKED artifact has unchecked TODO items: ${unchecked}`, ["# Option A: check all TODO boxes under ## TODO", "# Option B: set Status back to `DRAFT` until TODOs are complete"]);
+	}
+	for (const heading of getArtifactRequiredSections(fileName, workflowProfile)) if (!hasHeading(content, heading)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `Missing required section heading: ## ${heading}`, [
+			`## ${heading}`,
+			"",
+			"<content>"
+		]);
+	}
+	for (const gate of ["Coverage", "Approval"]) if (!hasGateLine(content, gate)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `Missing required gate line: ${gate}: PASS|FAIL`, [`${gate}: FAIL`]);
+	}
+	for (const issue of lintTraceability(filePath, content, requirementIds)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, issue);
+	}
+	for (const issue of lintAuditSections(filePath, content, workflowProfile, actualChangedFiles, diffBasisError, basename(runDir), runDir)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, issue);
+	}
+	for (const issue of lintPhaseSpecificRules(filePath, content, workflowProfile, runDir, repoRoot, requirementIds, actualChangedFiles)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, issue);
+	}
+	if (["04-test-summary.md", "05-manual-qa.md"].includes(fileName)) {
+		const evidenceDir = join(runDir, "evidence");
+		const requiredSubdirs = [
+			"screenshots",
+			"logs",
+			"perf",
+			"traces"
+		];
+		if (!existsSync(evidenceDir)) {
+			warnCount += 1;
+			writeIssue("WARN", filePath, `Evidence directory missing at ${evidenceDir}`, [
+				`mkdir -p "${join(evidenceDir, "screenshots")}"`,
+				`mkdir -p "${join(evidenceDir, "logs")}"`,
+				`mkdir -p "${join(evidenceDir, "perf")}"`,
+				`mkdir -p "${join(evidenceDir, "traces")}"`,
+				`mkdir -p "${join(evidenceDir, "other")}"`
+			]);
+		} else {
+			const missingSubdirs = requiredSubdirs.filter((s) => !existsSync(join(evidenceDir, s)));
+			if (missingSubdirs.length > 0) {
+				warnCount += 1;
+				writeIssue("WARN", filePath, `Evidence subfolder(s) missing under ${evidenceDir}: ${missingSubdirs.join(", ")}`, missingSubdirs.map((s) => `mkdir -p "${join(evidenceDir, s)}"`));
+			}
+		}
+	}
+	return [failCount, warnCount];
+}
+/** is_lock_valid_for_lint: canonical lock-validity check (used for late-phase sequencing). */
+function isLockValidForLint(filePath, workflowProfile) {
+	if (!existsSync(filePath)) return false;
+	const content = readFileSync(filePath, "utf8");
+	const status = getMdFieldValue$1(content, "Status") ?? "";
+	const [hasTodo, , , unchecked] = getTodoStats$1(content);
+	const auditOk = !(STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) && AUDITED_PHASE_FILES$2.has(basename(filePath))) || getGateStatus$1(content, "Audit") === "PASS";
+	const runDir = dirname(filePath);
+	const repoRoot = dirname(dirname(dirname(runDir)));
+	const requirementIds = existsSync(join(runDir, "00-requirements.md")) ? getRunRequirementIds(runDir, workflowProfile) : [];
+	let actualChangedFiles = null;
+	if (STRICT_WORKFLOW_PROFILES$1.has(workflowProfile)) {
+		const [rawChanged] = getGitChangedFiles(repoRoot, getRunDiffBasis(runDir));
+		if (rawChanged !== null) actualChangedFiles = filterRuntimeChangedFiles(rawChanged, basename(runDir));
+	}
+	const phaseSpecificIssues = lintPhaseSpecificRules(filePath, content, workflowProfile, runDir, repoRoot, requirementIds, actualChangedFiles);
+	const tddGateOk = basename(filePath) !== "03-implementation-summary.md" || getGateStatus$1(content, "TDD Compliance") === "PASS";
+	return status === "LOCKED" && hasHeaderField(content, "LockedAt") && hasHeaderField(content, "LockHash") && getGateStatus$1(content, "Coverage") === "PASS" && getGateStatus$1(content, "Approval") === "PASS" && auditOk && tddGateOk && hasTodo && unchecked === 0 && phaseSpecificIssues.length === 0;
+}
+/** lint_memory_doc: validate a memory shard's metadata frontmatter. */
+function lintMemoryDoc(filePath) {
+	const content = readFileSync(filePath, "utf8");
+	let failCount = 0;
+	let warnCount = 0;
+	const missingFields = MEMORY_REQUIRED_FIELDS.filter((f) => !hasHeaderField(content, f));
+	if (missingFields.length > 0) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `Missing required memory metadata field(s): ${missingFields.join(", ")}`);
+		return [failCount, warnCount];
+	}
+	const memoryType = (getMdFieldValue$1(content, "Type") ?? "").toLowerCase();
+	if (!MEMORY_ALLOWED_TYPES.has(memoryType)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `Invalid memory Type '${memoryType}' (expected one of: ${[...MEMORY_ALLOWED_TYPES].sort().join(", ")})`);
+	}
+	const memoryStatus = (getMdFieldValue$1(content, "Status") ?? "").toUpperCase();
+	if (!MEMORY_ALLOWED_STATUSES.has(memoryStatus)) {
+		failCount += 1;
+		writeIssue("FAIL", filePath, `Invalid memory Status '${memoryStatus}' (expected one of: ${[...MEMORY_ALLOWED_STATUSES].sort().join(", ")})`);
+	}
+	if (hasHeaderField(content, "Parent") && !getMdFieldValue$1(content, "Parent")) {
+		warnCount += 1;
+		writeIssue("WARN", filePath, "Parent metadata field is present but empty");
+	}
+	if (hasHeaderField(content, "Superseded-By") && !getMdFieldValue$1(content, "Superseded-By")) {
+		warnCount += 1;
+		writeIssue("WARN", filePath, "Superseded-By metadata field is present but empty");
+	}
+	return [failCount, warnCount];
+}
+/** lint_memory_plane: validate the .recursive/memory/ plane. */
+function lintMemoryPlane(repoRoot) {
+	let failCount = 0;
+	let warnCount = 0;
+	const memoryRoot = join(repoRoot, ".recursive", "memory");
+	const routerPath = join(memoryRoot, "MEMORY.md");
+	if (!existsSync(memoryRoot)) {
+		writeIssue("FAIL", memoryRoot, "Memory plane directory is missing");
+		return [1, 0];
+	}
+	if (!existsSync(routerPath)) {
+		failCount += 1;
+		writeIssue("FAIL", routerPath, "Memory router file is missing");
+	}
+	for (const subdir of [
+		"domains",
+		"patterns",
+		"incidents",
+		"episodes",
+		"archive",
+		"skills"
+	]) {
+		const full = join(memoryRoot, subdir);
+		if (!existsSync(full)) {
+			warnCount += 1;
+			writeIssue("WARN", full, "Memory subdirectory is missing");
+		}
+	}
+	const skillRouterPath = join(memoryRoot, "skills", "SKILLS.md");
+	if (!existsSync(skillRouterPath)) {
+		warnCount += 1;
+		writeIssue("WARN", skillRouterPath, "Skill memory router file is missing");
+	} else for (const subdir of [
+		"availability",
+		"usage",
+		"issues",
+		"patterns"
+	]) {
+		const full = join(memoryRoot, "skills", subdir);
+		if (!existsSync(full)) {
+			warnCount += 1;
+			writeIssue("WARN", full, "Skill memory subdirectory is missing");
+		}
+	}
+	const walk = (dir) => {
+		const out = [];
+		for (const e of readdirSync(dir, { withFileTypes: true })) {
+			const full = join(dir, e.name);
+			if (e.isDirectory()) out.push(...walk(full));
+			else if (e.name.endsWith(".md")) out.push(full);
+		}
+		return out;
+	};
+	let docs = [];
+	try {
+		docs = walk(memoryRoot).sort();
+	} catch {
+		docs = [];
+	}
+	for (const doc of docs) {
+		if (SKILL_MEMORY_ROUTER_NAMES.has(basename(doc))) continue;
+		const [docFail, docWarn] = lintMemoryDoc(doc);
+		failCount += docFail;
+		warnCount += docWarn;
+	}
+	return [failCount, warnCount];
+}
+/**
+* lintRun(repoRoot, runId): FULL canonical lint of a recursive run (in-process).
+* Mirrors lint-recursive-run.py main():
+*   - resolve run dir (runId or latest), derive workflow profile + requirement ids
+*   - validate the diff basis + collect actual changed files (git)
+*   - lint each artifact in RUN_ARTIFACT_SEQUENCE order (WARN if missing),
+*     then addenda, then subagent action records
+*   - phase-sequence prerequisite checks + late-phase requirement checks
+*   - lint the memory plane
+*   - print Summary + return verdict
+*/
+function lintRun(repoRoot, runId) {
+	issues.length = 0;
+	const root = repoRoot;
+	const runRoot = join(root, ".recursive", "run");
+	if (!existsSync(runRoot)) {
+		const msg = `recursive run directory not found at: ${runRoot}\n       Is this the project repo root? (Expected .recursive/run/)`;
+		console.log(`[FAIL] ${msg}`);
+		return {
+			errors: [msg],
+			warnings: [],
+			failCount: 1,
+			warnCount: 0,
+			passed: false,
+			summary: "Summary\n- FAIL: 1\n- WARN: 0"
+		};
+	}
+	const runDirs = readdirSync(runRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+	const selectedRuns = runId ? [runId] : runDirs.length > 0 ? [runDirs[runDirs.length - 1]] : [];
+	if (selectedRuns.length === 0) {
+		const msg = "no recursive runs found under .recursive/run/";
+		console.log(`[FAIL] ${msg}`);
+		return {
+			errors: [msg],
+			warnings: [],
+			failCount: 1,
+			warnCount: 0,
+			passed: false,
+			summary: "Summary\n- FAIL: 1\n- WARN: 0"
+		};
+	}
+	let totalFail = 0;
+	let totalWarn = 0;
+	for (const selectedRun of selectedRuns) {
+		const runDir = join(runRoot, selectedRun);
+		if (!existsSync(runDir)) {
+			totalFail += 1;
+			writeIssue("FAIL", runDir, `recursive run directory not found: ${runDir}`);
+			continue;
+		}
+		console.log(`Linting run: ${selectedRun}`);
+		console.log(`Path: ${runDir}`);
+		const workflowProfile = getWorkflowProfile$1(runDir);
+		console.log(`Workflow Profile: ${workflowProfile}`);
+		console.log();
+		const requirementIds = getRunRequirementIds(runDir, workflowProfile);
+		let actualChangedFiles = null;
+		let diffBasisError = null;
+		if (STRICT_WORKFLOW_PROFILES$1.has(workflowProfile)) {
+			const diffBasis = getRunDiffBasis(runDir);
+			if (diffBasis.baseline_reference || diffBasis.normalized_baseline) {
+				const [rawChanged, gitError] = getGitChangedFiles(root, diffBasis);
+				if (gitError) {
+					diffBasisError = gitError;
+					totalFail += 1;
+					writeIssue("FAIL", runDir, `Unable to verify git diff basis: ${gitError}`);
+				} else if (rawChanged !== null) actualChangedFiles = filterRuntimeChangedFiles(rawChanged, selectedRun);
+			}
+		}
+		const expectedArtifacts = RUN_ARTIFACT_SEQUENCE$1;
+		for (const artifact of expectedArtifacts) {
+			const artifactPath = join(runDir, artifact);
+			if (!existsSync(artifactPath)) {
+				if (getLockStatus(artifactPath) === "MISSING") {
+					issues.push({
+						severity: "WARN",
+						filePath: "",
+						message: `Missing artifact (ok if not reached yet): ${artifactPath}`
+					});
+					console.log(`[WARN] Missing artifact (ok if not reached yet): ${artifactPath}`);
+					totalWarn += 1;
+					continue;
+				}
+				totalFail += 1;
+				writeIssue("FAIL", artifactPath, `Artifact exists but cannot be read: ${artifact}`);
+				continue;
+			}
+			const [failCount, warnCount] = lintArtifactFile(artifactPath, runDir, root, workflowProfile, requirementIds, actualChangedFiles, diffBasisError);
+			totalFail += failCount;
+			totalWarn += warnCount;
+		}
+		const addendaDir = join(runDir, "addenda");
+		if (existsSync(addendaDir)) {
+			const addenda = readdirSync(addendaDir).filter((n) => n.endsWith(".md")).sort();
+			for (const addendum of addenda) {
+				const [failCount, warnCount] = lintArtifactFile(join(addendaDir, addendum), runDir, root, workflowProfile, requirementIds, actualChangedFiles, diffBasisError);
+				totalFail += failCount;
+				totalWarn += warnCount;
+			}
+		}
+		const subagentsDir = join(runDir, "subagents");
+		if (existsSync(subagentsDir)) {
+			const actionRecords = readdirSync(subagentsDir).filter((n) => n.endsWith(".md")).sort();
+			for (const actionRecord of actionRecords) {
+				const issuesFound = lintSubagentActionRecordFile(join(subagentsDir, actionRecord), root, runDir, actualChangedFiles);
+				for (const issue of issuesFound) {
+					totalFail += 1;
+					writeIssue("FAIL", join(subagentsDir, actionRecord), issue);
+				}
+			}
+		}
+		for (const artifact of expectedArtifacts) {
+			const artifactPath = join(runDir, artifact);
+			if (!existsSync(artifactPath)) continue;
+			const blockers = getPrerequisiteBlockers(runDir, artifact);
+			for (const blocker of blockers) {
+				totalFail += 1;
+				writeIssue("FAIL", artifactPath, `Phase-sequence violation: '${artifact}' exists but prerequisite '${blocker.artifact}' is ${blocker.status} (must be LOCKED first)`);
+			}
+		}
+		if (STRICT_WORKFLOW_PROFILES$1.has(workflowProfile) || workflowProfile === "memory-phase8") {
+			for (const [priorArtifact, nextArtifact] of [
+				["05-manual-qa.md", "06-decisions-update.md"],
+				["06-decisions-update.md", "07-state-update.md"],
+				["07-state-update.md", "08-memory-impact.md"]
+			]) if (isLockValidForLint(join(runDir, priorArtifact), workflowProfile) && !existsSync(join(runDir, nextArtifact))) {
+				totalFail += 1;
+				writeIssue("FAIL", join(runDir, nextArtifact), `Run profile ${workflowProfile} requires ${nextArtifact} after ${priorArtifact} locks`);
+			}
+			const [memoryFail, memoryWarn] = lintMemoryPlane(root);
+			totalFail += memoryFail;
+			totalWarn += memoryWarn;
+		}
+		console.log("----");
+		console.log();
+	}
+	console.log("Summary");
+	console.log(`- FAIL: ${totalFail}`);
+	console.log(`- WARN: ${totalWarn}`);
+	console.log();
+	if (totalFail > 0) console.log("[FAIL] Lint failed");
+	else console.log("[OK] Lint passed");
+	const errors = [];
+	const warnings = [];
+	for (const issue of issues) if (issue.severity === "FAIL") errors.push(`[FAIL] ${issue.filePath}: ${issue.message}`);
+	else if (issue.filePath === "") warnings.push(`[WARN] ${issue.message}`);
+	else warnings.push(`[WARN] ${issue.filePath}: ${issue.message}`);
+	const summary = `Summary\n- FAIL: ${totalFail}\n- WARN: ${totalWarn}`;
+	return {
+		errors,
+		warnings,
+		failCount: totalFail,
+		warnCount: totalWarn,
+		passed: totalFail === 0,
+		summary
+	};
+}
+//#endregion
+//#region src/init-templates.ts
+/**
+* Init templates (R5): canonical-parity port of recursive-init.py's
+* requirements_content / worktree_content / detect_git_context, plus full
+* per-phase templates derived from the canonical artifact-template sections
+* (get_artifact_required_sections) + TODO + Coverage/Approval FAIL gates.
+*
+* 00-requirements.md + 00-worktree.md are byte-identical to canonical
+* recursive-init.py output (LF, no BOM). Later phases are structural: every
+* required section heading + the two FAIL gates, so lint fails honestly until
+* the phase is actually worked.
+*/
+/**
+* detect_git_context(): canonical parity. Returns {context, error} — never
+* throws on missing git; error is surfaced in the worktree template note.
+*/
+function detectGitContext(repoRoot) {
+	const run = (args) => {
+		try {
+			return execFileSync("git", args, {
+				cwd: repoRoot,
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim();
+		} catch {
+			return null;
+		}
+	};
+	const headSha = run([
+		"rev-parse",
+		"--verify",
+		"HEAD^{commit}"
+	]);
+	if (!headSha) return {
+		context: {},
+		error: "Unable to resolve HEAD commit for Phase 0 diff basis prefill: git rev-parse returned no output"
+	};
+	const branch = run([
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"HEAD"
+	]) || "(detached HEAD)";
+	return {
+		context: {
+			baselineType: "local commit",
+			baselineReference: headSha,
+			comparisonReference: "working-tree",
+			normalizedBaseline: headSha,
+			normalizedComparison: "working-tree",
+			normalizedDiffCommand: "git diff --name-only " + headSha,
+			baseBranch: branch,
+			worktreeBranch: branch,
+			baseCommit: headSha,
+			notes: "recursive-init prefilled this executable diff basis from the current HEAD commit. If Phase 0 later changes the chosen baseline, update every diff-basis field and rerun lint before locking."
+		},
+		error: null
+	};
+}
+/**
+* requirements_content(run_id, template, from_issue): byte-identical to the
+* canonical recursive-init.py function (LF, template flavor in Scope note).
+*/
+function requirementsContent(runId, template = "feature", fromIssue = "") {
+	const inputs = ["- [chat summary or source notes if captured in repo]"];
+	if (fromIssue.trim()) inputs.push("- Source: " + fromIssue.trim());
+	const inputsBlock = inputs.join("\n");
+	return [
+		"Run: `/.recursive/run/" + runId + "/`",
+		"Phase: `00 Requirements`",
+		"Status: `DRAFT`",
+		"Workflow version: `recursive-mode-audit-v2`",
+		"Inputs:",
+		inputsBlock,
+		"Outputs:",
+		"- `/.recursive/run/" + runId + "/00-requirements.md`",
+		"Scope note: This document defines stable requirement identifiers and acceptance criteria. (Template: " + template + ")",
+		"",
+		"## TODO",
+		"",
+		"- [ ] Elicit requirements from user/context",
+		"- [ ] Define requirement identifiers (R1, R2, ...)",
+		"- [ ] Write acceptance criteria for each requirement",
+		"- [ ] Document out of scope items (OOS1, OOS2, ...)",
+		"- [ ] List constraints and assumptions",
+		"- [ ] Complete Coverage Gate checklist",
+		"- [ ] Complete Approval Gate checklist",
+		"",
+		"## Requirements",
+		"",
+		"### `R1` <short title>",
+		"",
+		"Description:",
+		"Acceptance criteria:",
+		"- [observable condition 1]",
+		"- [observable condition 2]",
+		"",
+		"## Out of Scope",
+		"",
+		"- `OOS1`: ...",
+		"",
+		"## Constraints",
+		"",
+		"- ...",
+		"",
+		"## Coverage Gate",
+		"...",
+		"Coverage: FAIL",
+		"",
+		"## Approval Gate",
+		"...",
+		"Approval: FAIL"
+	].join("\n") + "\n";
+}
+/**
+* worktree_content(run_id, repo_root, git_context, prefill_error): byte-identical
+* to the canonical recursive-init.py function.
+*/
+function worktreeContent(runId, repoRoot, git, prefillError) {
+	const baseBranch = git.baseBranch ?? "(resolve during Phase 0)";
+	const worktreeBranch = git.worktreeBranch ?? "(resolve during Phase 0)";
+	const baseCommit = git.baseCommit ?? "<resolve-before-locking>";
+	const baselineType = git.baselineType ?? "local commit";
+	const baselineReference = git.baselineReference ?? "<resolve-before-locking>";
+	const comparisonReference = git.comparisonReference ?? "working-tree";
+	const normalizedBaseline = git.normalizedBaseline ?? "<resolve-before-locking>";
+	const normalizedComparison = git.normalizedComparison ?? "working-tree";
+	const normalizedDiffCommand = git.normalizedDiffCommand ?? "git diff --name-only <resolve-before-locking>";
+	const notes = git.notes ?? "Populate an executable diff basis before locking Phase 0. Lint and lock will fail until the normalized basis matches live git state.";
+	const setupNote = prefillError ? "recursive-init could not prefill the Phase 0 diff basis automatically: " + prefillError : "recursive-init detected the current repository context and prefilled the Phase 0 diff basis.";
+	return [
+		"Run: `/.recursive/run/" + runId + "/`",
+		"Phase: `00 Worktree`",
+		"Status: `DRAFT`",
+		"Inputs:",
+		"- `/.recursive/run/" + runId + "/00-requirements.md`",
+		"- Current git repository state",
+		"Outputs:",
+		"- `/.recursive/run/" + runId + "/00-worktree.md`",
+		"Scope note: This document records the Phase 0 worktree context and the executable diff basis that all later audited phases must reuse.",
+		"",
+		"## TODO",
+		"",
+		"- [ ] Confirm the selected worktree location and isolation approach",
+		"- [ ] Confirm the base branch and worktree branch values",
+		"- [ ] Run setup and verify the clean test baseline",
+		"- [ ] Confirm the diff basis fields still match live git state",
+		"- [ ] Complete Coverage Gate checklist",
+		"- [ ] Complete Approval Gate checklist",
+		"",
+		"## Directory Selection",
+		"",
+		"- Repository root: `" + repoRoot + "`",
+		"- Preferred worktree location: `.worktrees/" + runId + "/`",
+		"- Update this section with the actual selected location before locking Phase 0.",
+		"",
+		"## Safety Verification",
+		"",
+		"- Original branch / repo state observed at init time: `" + baseBranch + "`",
+		"- Isolation still must be confirmed after the actual worktree is created.",
+		"",
+		"## Worktree Creation",
+		"",
+		"- Intended worktree branch: `" + worktreeBranch + "`",
+		"- Record the actual worktree creation command and output before locking.",
+		"",
+		"## Main Branch Protection",
+		"",
+		"- Base branch source of truth at init time: `" + baseBranch + "`",
+		"- Explicitly document any deviation from isolated worktree execution before locking.",
+		"",
+		"## Project Setup",
+		"",
+		"- Init-time note: " + setupNote,
+		"- Replace this section with the actual setup commands and results during Phase 0.",
+		"",
+		"## Test Baseline Verification",
+		"",
+		"- Record the baseline commands and results after setup completes.",
+		"",
+		"## Worktree Context",
+		"",
+		"- Base branch: `" + baseBranch + "`",
+		"- Worktree branch: `" + worktreeBranch + "`",
+		"- Base commit: `" + baseCommit + "`",
+		"",
+		"## Diff Basis For Later Audits",
+		"",
+		"- Baseline type: `" + baselineType + "`",
+		"- Baseline reference: `" + baselineReference + "`",
+		"- Comparison reference: `" + comparisonReference + "`",
+		"- Normalized baseline: `" + normalizedBaseline + "`",
+		"- Normalized comparison: `" + normalizedComparison + "`",
+		"- Normalized diff command: `" + normalizedDiffCommand + "`",
+		"- Base branch: `" + baseBranch + "`",
+		"- Worktree branch: `" + worktreeBranch + "`",
+		"- Diff basis notes: `" + notes + "`",
+		"",
+		"## Traceability",
+		"",
+		"- Recursive workflow safety -> Phase 0 records a reusable executable diff basis before audited phases begin.",
+		"",
+		"## Coverage Gate",
+		"",
+		"- [ ] Worktree location and branch context are recorded",
+		"- [ ] Setup and clean baseline verification are recorded",
+		"- [ ] Diff basis fields are executable against live git state",
+		"",
+		"Coverage: FAIL",
+		"",
+		"## Approval Gate",
+		"",
+		"- [ ] Phase 0 context is ready for downstream audited phases",
+		"- [ ] No unresolved setup or diff-basis inconsistencies remain",
+		"",
+		"Approval: FAIL"
+	].join("\n") + "\n";
+}
+/**
+* Later-phase template: required sections (canonical get_artifact_required_
+* sections) as ## headings + TODO + FAIL gates. Structural scaffold: the phase
+* author fills each section; lint stays FAIL until Coverage/Approval are set.
+*/
+function laterPhaseContent(runId, fileName, workflowProfile = "recursive-mode-audit-v2") {
+	const sections = getArtifactRequiredSections(fileName, workflowProfile);
+	const lines = [
+		"Run: `/.recursive/run/" + runId + "/`",
+		"Phase: `" + fileName.replace(/\.md$/, "").replace(/^0?/, "") + "`",
+		"Status: `DRAFT`",
+		"Workflow version: `" + workflowProfile + "`",
+		"Inputs:",
+		"- (list upstream artifacts re-read for this phase)",
+		"Outputs:",
+		"- `/.recursive/run/" + runId + "/" + fileName + "`",
+		"Scope note: Scaffold generated by the recursive-mode plugin (R5). Fill every required section before lint.",
+		"",
+		"## TODO",
+		"",
+		"- [ ] Work through every required section below",
+		"- [ ] Record evidence and traceability",
+		"- [ ] Complete Coverage Gate checklist",
+		"- [ ] Complete Approval Gate checklist"
+	];
+	for (const section of sections) {
+		if (section === "TODO") continue;
+		lines.push("", "## " + section, "", "- (fill)");
+	}
+	lines.push("", "## Coverage Gate", "", "Coverage: FAIL", "", "## Approval Gate", "", "Approval: FAIL", "");
+	return lines.join("\n");
+}
+/**
+* Scaffold dirs under a run (addenda/subagents/router-prompts/evidence + subs).
+* Mirrors canonical recursive-init.py's ensure_directory sequence.
+*/
+const RUN_SCAFFOLD_DIRS = [
+	"addenda",
+	"subagents",
+	"router-prompts",
+	"evidence",
+	"evidence/screenshots",
+	"evidence/logs",
+	"evidence/perf",
+	"evidence/traces",
+	"evidence/review-bundles",
+	"evidence/router",
+	"evidence/other"
+];
+//#endregion
+//#region src/run.ts
+/**
+* List run ids under <repoRoot>/.recursive/run/, excluding non-directories.
+* Mirrors: runs = [p for p in run_root.iterdir() if p.is_dir()]
+*/
+function discoverRuns(repoRoot) {
+	const runRoot = join(repoRoot, ".recursive", "run");
+	let runs = [];
+	try {
+		runs = readdirSync(runRoot, { withFileTypes: true }).filter((d) => {
+			if (d.isDirectory()) return true;
+			if (!d.isSymbolicLink()) return false;
+			try {
+				return statSync(join(runRoot, d.name)).isDirectory();
+			} catch {
+				return false;
+			}
+		}).map((d) => d.name);
+	} catch {
+		return [];
+	}
+	return runs;
+}
+/**
+* Resolve the run directory for an explicit run id, or the latest run by mtime.
+* Mirrors get_latest_run_directory: sort by st_mtime descending, stable sort
+* (ties preserve discovery order — no name-based tie-break).
+*/
+function resolveRunDir(repoRoot, runId) {
+	const runRoot = join(repoRoot, ".recursive", "run");
+	if (runId && runId.trim() !== "") return {
+		runDir: join(runRoot, runId.trim()),
+		runId: runId.trim()
+	};
+	const latest = getLatestRunDirectory(runRoot);
+	if (!latest) return null;
+	return {
+		runDir: join(runRoot, latest),
+		runId: latest
+	};
+}
+/**
+* Latest run directory by mtime (descending), stable sort preserving
+* discovery order for exact ties. Returns null when no runs exist.
+*/
+function getLatestRunDirectory(runRoot) {
+	let runs = [];
+	try {
+		runs = readdirSync(runRoot, { withFileTypes: true }).filter((d) => {
+			if (d.isDirectory()) return true;
+			if (!d.isSymbolicLink()) return false;
+			try {
+				return statSync(join(runRoot, d.name)).isDirectory();
+			} catch {
+				return false;
+			}
+		}).map((d) => d.name);
+	} catch {
+		return null;
+	}
+	if (runs.length === 0) return null;
+	runs.sort((a, b) => {
+		try {
+			return statSync(join(runRoot, b)).mtimeMs - statSync(join(runRoot, a)).mtimeMs;
+		} catch {
+			return 0;
+		}
+	});
+	return runs[0];
+}
+//#endregion
+//#region src/status.ts
+const RUN_ARTIFACT_SEQUENCE = [
+	"00-requirements.md",
+	"00-worktree.md",
+	"01-as-is.md",
+	"01.5-root-cause.md",
+	"02-to-be-plan.md",
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md",
+	"05-manual-qa.md",
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+];
+const PHASES = [
+	{
+		key: "00R",
+		label: "Phase 0 (Requirements)",
+		file: "00-requirements.md",
+		optional: false,
+		phaseName: "0 (Requirements)"
+	},
+	{
+		key: "00W",
+		label: "Phase 0 (Worktree)",
+		file: "00-worktree.md",
+		optional: false,
+		phaseName: "0 (Worktree)"
+	},
+	{
+		key: "01",
+		label: "Phase 1 (AS-IS)",
+		file: "01-as-is.md",
+		optional: false,
+		phaseName: "1 (AS-IS)"
+	},
+	{
+		key: "01.5",
+		label: "Phase 1.5 (Root Cause)",
+		file: "01.5-root-cause.md",
+		optional: true,
+		phaseName: "1.5 (Root Cause)"
+	},
+	{
+		key: "02",
+		label: "Phase 2 (TO-BE Plan)",
+		file: "02-to-be-plan.md",
+		optional: false,
+		phaseName: "2 (TO-BE Plan)"
+	},
+	{
+		key: "03",
+		label: "Phase 3 (Implementation)",
+		file: "03-implementation-summary.md",
+		optional: false,
+		phaseName: "3 (Implementation)"
+	},
+	{
+		key: "03.5",
+		label: "Phase 3.5 (Code Review)",
+		file: "03.5-code-review.md",
+		optional: true,
+		phaseName: "3.5 (Code Review)"
+	},
+	{
+		key: "04",
+		label: "Phase 4 (Test Summary)",
+		file: "04-test-summary.md",
+		optional: false,
+		phaseName: "4 (Test Summary)"
+	},
+	{
+		key: "05",
+		label: "Phase 5 (Manual QA)",
+		file: "05-manual-qa.md",
+		optional: false,
+		phaseName: "5 (Manual QA)"
+	},
+	{
+		key: "06",
+		label: "Phase 6 (Decisions)",
+		file: "06-decisions-update.md",
+		optional: false,
+		phaseName: "6 (Decisions Update)"
+	},
+	{
+		key: "07",
+		label: "Phase 7 (State)",
+		file: "07-state-update.md",
+		optional: false,
+		phaseName: "7 (State Update)"
+	},
+	{
+		key: "08",
+		label: "Phase 8 (Memory)",
+		file: "08-memory-impact.md",
+		optional: false,
+		phaseName: "8 (Memory Impact)"
+	}
+];
+const LOCK_HASH_LINE_RE = /^[ \t]*LockHash:.*(?:\n|$)/gm;
+const STRICT_WORKFLOW_PROFILES = /* @__PURE__ */ new Set(["recursive-mode-audit-v1", "recursive-mode-audit-v2"]);
+const AUDITED_PHASE_FILES$1 = /* @__PURE__ */ new Set([
+	"01-as-is.md",
+	"01.5-root-cause.md",
+	"02-to-be-plan.md",
+	"03-implementation-summary.md",
+	"03.5-code-review.md",
+	"04-test-summary.md",
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+]);
+const CURRENT_WORKFLOW_PROFILE = "recursive-mode-audit-v2";
+const STRICT_WORKFLOW_PROFILE = "recursive-mode-audit-v1";
+const COMPAT_WORKFLOW_PROFILE = "memory-phase8";
+const LATE_PHASE_FILES = [
+	"06-decisions-update.md",
+	"07-state-update.md",
+	"08-memory-impact.md"
+];
+const LATE_PHASE_KEYS = /* @__PURE__ */ new Set([
+	"06",
+	"07",
+	"08"
+]);
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function trimMdValue(value) {
+	let trimmed = value.trim();
+	for (const quote of [
+		"`",
+		"\"",
+		"'"
+	]) if (trimmed.startsWith(quote) && trimmed.endsWith(quote) && trimmed.length >= 2) {
+		const inner = trimmed.slice(1, -1);
+		if (!inner.includes(quote)) return inner.trim();
+	}
+	return trimmed;
+}
+function getMdFieldValue(content, fieldName) {
+	const match = new RegExp(`^[ \\t]*(?:[-*][ \\t]+)?${escapeRegExp(fieldName)}:[ \\t]*(.+?)\\s*$`, "m").exec(content);
+	if (!match) return null;
+	return trimMdValue(match[1]);
+}
+function getGateStatus(content, gateName) {
+	const match = new RegExp(`^[ \\t]*${escapeRegExp(gateName)}:\\s*(PASS|FAIL)\\s*$`, "m").exec(content);
+	return match ? match[1].toUpperCase() : "MISSING";
+}
+function getTodoStats(content) {
+	const lines = content.split(/\r?\n/);
+	let inTodo = false;
+	let hasTodo = false;
+	let checked = 0;
+	let unchecked = 0;
+	let total = 0;
+	for (const line of lines) {
+		if (!inTodo) {
+			if (/^\s*##\s+TODO\s*$/.test(line)) {
+				inTodo = true;
+				hasTodo = true;
+			}
+			continue;
+		}
+		if (/^\s*##\s+/.test(line) || /^\s*#\s+/.test(line)) break;
+		const item = /^\s*[-*]\s+\[([ xX])\]\s+/.exec(line);
+		if (item) {
+			total += 1;
+			if (item[1].toLowerCase() === "x") checked += 1;
+			else unchecked += 1;
+		}
+	}
+	return {
+		hasTodo,
+		total,
+		checked,
+		unchecked
+	};
+}
+function lockHashFromContent$1(content) {
+	const stripped = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(LOCK_HASH_LINE_RE, "");
+	return createHash("sha256").update(stripped, "utf8").digest("hex");
+}
+function getWorkflowProfile(runDir) {
+	const requirementsPath = join(runDir, "00-requirements.md");
+	try {
+		const workflowVersion = getMdFieldValue(readFileSync(requirementsPath, "utf8"), "Workflow version");
+		if (workflowVersion === CURRENT_WORKFLOW_PROFILE) return CURRENT_WORKFLOW_PROFILE;
+		if (workflowVersion === STRICT_WORKFLOW_PROFILE) return STRICT_WORKFLOW_PROFILE;
+		if (workflowVersion === COMPAT_WORKFLOW_PROFILE) return COMPAT_WORKFLOW_PROFILE;
+	} catch {}
+	if (LATE_PHASE_FILES.some((file) => {
+		try {
+			statSync(join(runDir, file));
+			return true;
+		} catch {
+			return false;
+		}
+	})) return COMPAT_WORKFLOW_PROFILE;
+	return "legacy";
+}
+function getArtifactState(artifactPath, workflowProfile) {
+	let content = null;
+	try {
+		content = readFileSync(artifactPath, "utf8");
+	} catch {}
+	if (content === null) return {
+		exists: false,
+		status: "PENDING",
+		lockValid: false,
+		lockProblems: ["File missing"],
+		blockers: ["File missing"],
+		lockedAt: null,
+		storedHash: null,
+		actualHash: null,
+		coverage: "MISSING",
+		approval: "MISSING",
+		audit: "MISSING",
+		todoHasSection: false,
+		todoUnchecked: 0
+	};
+	const status = getMdFieldValue(content, "Status") ?? "UNKNOWN";
+	const todo = getTodoStats(content);
+	const coverage = getGateStatus(content, "Coverage");
+	const approval = getGateStatus(content, "Approval");
+	const audit = getGateStatus(content, "Audit");
+	const tddCompliance = getGateStatus(content, "TDD Compliance");
+	const lockedAt = getMdFieldValue(content, "LockedAt");
+	const storedHash = getMdFieldValue(content, "LockHash");
+	let actualHash = null;
+	const lockProblems = [];
+	const blockers = [];
+	let lockValid = false;
+	const fileName = artifactPath.split(/[\\/]/).pop() ?? "";
+	if (status !== "LOCKED") lockProblems.push(`Status is '${status}' (expected LOCKED for lock-valid)`);
+	else {
+		if (!lockedAt) lockProblems.push("Missing LockedAt");
+		if (!storedHash) lockProblems.push("Missing LockHash");
+		if (storedHash) {
+			actualHash = lockHashFromContent$1(content);
+			if (storedHash.toLowerCase() !== actualHash.toLowerCase()) lockProblems.push("LockHash mismatch");
 		}
-		if (!lockValid && status !== "MISSING") {
-			if (status === "DRAFT") problems.push(`Status is not LOCKED (${status})`);
-			else if (status === "STALE_LOCK") problems.push("LockHash mismatch or missing lock fields");
+		if (coverage !== "PASS") lockProblems.push(`Coverage gate is ${coverage}`);
+		if (approval !== "PASS") lockProblems.push(`Approval gate is ${approval}`);
+		if (STRICT_WORKFLOW_PROFILES.has(workflowProfile) && AUDITED_PHASE_FILES$1.has(fileName) && audit !== "PASS") lockProblems.push(`Audit gate is ${audit}`);
+		if (fileName === "03-implementation-summary.md" && tddCompliance !== "PASS") lockProblems.push(`TDD Compliance gate is ${tddCompliance}`);
+		if (!todo.hasTodo) lockProblems.push("Missing ## TODO section");
+		else if (todo.unchecked > 0) lockProblems.push(`Unchecked TODO items: ${todo.unchecked}`);
+		if (lockProblems.length === 0) lockValid = true;
+	}
+	if (!todo.hasTodo) blockers.push("Missing ## TODO section");
+	else if (todo.unchecked > 0) blockers.push(`Unchecked TODO items: ${todo.unchecked}`);
+	if (coverage !== "PASS") blockers.push(`Coverage gate is ${coverage}`);
+	if (approval !== "PASS") blockers.push(`Approval gate is ${approval}`);
+	if (fileName === "03-implementation-summary.md" && tddCompliance !== "PASS") blockers.push(`TDD Compliance gate is ${tddCompliance}`);
+	const dedupedBlockers = [];
+	for (const blocker of blockers) if (!dedupedBlockers.includes(blocker)) dedupedBlockers.push(blocker);
+	return {
+		exists: true,
+		status,
+		lockValid,
+		lockProblems,
+		blockers: dedupedBlockers,
+		lockedAt,
+		storedHash,
+		actualHash,
+		coverage,
+		approval,
+		audit,
+		todoHasSection: todo.hasTodo,
+		todoUnchecked: todo.unchecked
+	};
+}
+function foldRun(runDir, runId) {
+	const workflowProfile = getWorkflowProfile(runDir);
+	const states = /* @__PURE__ */ new Map();
+	for (const phase of PHASES) {
+		const state = getArtifactState(join(runDir, phase.file), workflowProfile);
+		if (phase.optional && !state.exists) state.status = "SKIPPED";
+		else if (workflowProfile === "legacy" && LATE_PHASE_KEYS.has(phase.key) && !state.exists) state.status = "SKIPPED";
+		states.set(phase.key, state);
+	}
+	let currentPhase = null;
+	for (const phase of PHASES) {
+		const state = states.get(phase.key);
+		if (state.status === "SKIPPED") continue;
+		if (!state.exists || !state.lockValid) {
+			currentPhase = {
+				key: phase.key,
+				label: phase.label,
+				phaseName: phase.phaseName,
+				status: state.status
+			};
+			break;
 		}
-		phases.push({
-			file: phase,
-			status,
-			lockValid,
-			lockProblems: problems
-		});
 	}
-	const nextLegalPhase = getNextLegalPhase(runDir);
-	const staleReceipts = getAllStaleReceipts(runDir);
+	const phases = PHASES.map((phase) => {
+		const state = states.get(phase.key);
+		return {
+			key: phase.key,
+			label: phase.label,
+			file: phase.file,
+			optional: phase.optional,
+			exists: state.exists,
+			status: state.status,
+			lockValid: state.lockValid,
+			lockProblems: state.lockProblems,
+			blockers: state.blockers
+		};
+	});
 	return {
 		runId,
+		currentPhase,
 		phases,
-		breakPhase,
-		nextLegalPhase,
-		complete,
-		staleReceipts
+		workflowProfile
 	};
 }
-/** Python json.dumps(obj, sort_keys=True) compact serialization (receipt_hash input). */
-function pythonJsonDumps(obj) {
-	const rec = obj;
-	return "{" + Object.keys(rec).sort().map((key) => {
-		const value = rec[key];
-		return `${jsonString(key)}: ${jsonValue(value)}`;
-	}).join(", ") + "}";
-}
-/** Python json.dumps(obj, indent=2, sort_keys=True) disk serialization. */
-function pythonJsonDumpsIndent(obj) {
-	const rec = obj;
-	return "{\n" + Object.keys(rec).sort().map((key) => {
-		const value = rec[key];
-		return "  " + jsonString(key) + ": " + jsonValueIndent(value, 2);
-	}).join(",\n") + "\n}";
-}
-function jsonString(s) {
-	return JSON.stringify(s);
-}
-function jsonValue(value) {
-	if (value === null) return "null";
-	if (typeof value === "string") return jsonString(value);
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (Array.isArray(value)) return "[" + value.map(jsonValue).join(", ") + "]";
-	if (typeof value === "object") return pythonJsonDumps(value);
-	return "null";
-}
-function jsonValueIndent(value, depth) {
-	if (value === null) return "null";
-	if (typeof value === "string") return jsonString(value);
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (Array.isArray(value)) return "[" + value.map((v) => jsonValueIndent(v, depth)).join(", ") + "]";
-	if (typeof value === "object") {
-		const obj = value;
-		const keys = Object.keys(obj).sort();
-		const pad = "  ".repeat(depth);
-		return "{\n" + keys.map((key) => pad + "  " + jsonString(key) + ": " + jsonValueIndent(obj[key], depth + 1)).join(",\n") + "\n" + pad + "}";
-	}
-	return "null";
-}
 //#endregion
 //#region src/workspace.ts
 /**
@@ -2911,12 +5060,11 @@ var RecursiveRuntime = class extends Service {
 		};
 	}
 	/**
-	* Lint an artifact with FULL canonical parity: shells out to the vendored
-	* lint-recursive-run.py (byte-identical to canonical) and parses its
-	* [FAIL]/[WARN] lines + Summary counts. `errors` = FAIL lines, `warnings` =
+	* Lint an artifact with FULL canonical parity: runs the in-process ts-lint
+	* port (ts-lint.ts `lintRun`) against the whole run and filters the verdict
+	* lines to the requested artifact. `errors` = FAIL lines, `warnings` =
 	* WARN lines, `passed` = no FAIL (WARN-only passes, matching the canonical
-	* non-strict verdict). Falls back to the structural check only if the vendored
-	* script is unavailable (e.g. bundled lib without references/).
+	* non-strict verdict).
 	*/
 	async lintArtifact(runId, artifact, agent) {
 		const root = await this.resolveRootFor(agent);
@@ -2931,27 +5079,23 @@ var RecursiveRuntime = class extends Service {
 			warnings: [],
 			passed: false
 		};
-		const lintScript = join(referencesRoot(), "scripts", "lint-recursive-run.py");
-		if (existsSync(lintScript)) try {
-			return parseLintOutput(execFileSync("python", [
-				lintScript,
-				"--repo-root",
-				root,
-				"--run-id",
-				runId
-			], {
-				encoding: "utf8",
-				stdio: [
-					"ignore",
-					"pipe",
-					"ignore"
-				],
-				timeout: 6e4
-			}), target, runId);
-		} catch (err) {
-			const stdout = err?.stdout ?? "";
-			if (stdout.includes("Summary")) return parseLintOutput(stdout, target, runId);
-		}
+		const result = lintRun(root, runId);
+		return parseLintOutput([...result.errors, ...result.warnings].join("\n"), target, runId);
+	}
+	/** Legacy structural fallback (kept for type reference; lintArtifact uses lintRun). */
+	async lintArtifactStructuralFallback(runId, artifact, agent) {
+		const root = await this.resolveRootFor(agent);
+		if (!root) throw new Error("cannot resolve workspace control-plane root for this session");
+		const runDir = join(root, ".recursive", "run", runId);
+		const target = artifact ?? getNextLegalPhase(runDir) ?? "00-requirements.md";
+		const artifactPath = join(runDir, target);
+		if (!existsSync(artifactPath)) return {
+			artifact: target,
+			runId,
+			errors: ["Artifact not found"],
+			warnings: [],
+			passed: false
+		};
 		const content = readFileSync(artifactPath, "utf8");
 		const errors = [];
 		const warnings = [];
@@ -3018,18 +5162,18 @@ var RecursiveRuntime = class extends Service {
 /** set_or_insert_field: replace first field occurrence, else insert after the last listed after-field. */
 function setOrInsertField(content, fieldName, value, afterFields) {
 	const line = fieldName + ": `" + value + "`";
-	const fieldRe = new RegExp("^[ \\t]*(?:[-*][ \\t]+)?" + escapeRegExp$1(fieldName) + ":\\s*.*$", "m");
+	const fieldRe = new RegExp("^[ \\t]*(?:[-*][ \\t]+)?" + escapeRegExp$2(fieldName) + ":\\s*.*$", "m");
 	if (fieldRe.test(content)) return content.replace(fieldRe, line);
 	const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
 	let insertAt = 0;
 	for (const afterField of afterFields) {
-		const afterRe = new RegExp("^[ \\t]*(?:[-*][ \\t]+)?" + escapeRegExp$1(afterField) + ":\\s*.*$", "m");
+		const afterRe = new RegExp("^[ \\t]*(?:[-*][ \\t]+)?" + escapeRegExp$2(afterField) + ":\\s*.*$", "m");
 		for (let i = 0; i < lines.length; i++) if (afterRe.test(lines[i])) insertAt = Math.max(insertAt, i + 1);
 	}
 	lines.splice(insertAt, 0, line);
 	return lines.join("\n");
 }
-function escapeRegExp$1(s) {
+function escapeRegExp$2(s) {
 	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 /**
@@ -3267,6 +5411,332 @@ function createRecursiveScratchTool(recursive) {
 	});
 }
 //#endregion
+//#region src/bootstrap.ts
+/**
+* Idempotent scaffold installer (R3). TS port of install-recursive-mode.py's
+* core: bootstrap the FULL canonical /.recursive/ control plane + cross-tool
+* bridges byte-identically (RECURSIVE.md marker-wrapped, AGENTS.md, STATE/
+* DECISIONS, memory routers + shards, config/recursive-router.json, .gitignore,
+* vendored runtime scripts copied into .recursive/scripts/), plus the
+* agent/session-start Stage B (new vs resume) workspace-scoped to the session's
+* control-plane root (R1).
+*
+* Templates + bodies + runtime scripts are SHIPPED package files under
+* references/ (never inlined TS string literals) and resolved relative to this
+* module (package install location), never process.cwd().
+*/
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+/** Package root: <package>/src/.. — references/ sits next to src/. */
+const PACKAGE_ROOT = join(MODULE_DIR, "..");
+/** references/ root (shipped package files). */
+function referencesRoot() {
+	return join(PACKAGE_ROOT, "references");
+}
+const M = {
+	recursiveStart: "<!-- RECURSIVE-MODE-CANONICAL:START -->",
+	recursiveEnd: "<!-- RECURSIVE-MODE-CANONICAL:END -->",
+	memoryStart: "<!-- RECURSIVE-MODE-MEMORY:START -->",
+	memoryEnd: "<!-- RECURSIVE-MODE-MEMORY:END -->",
+	agentsStart: "<!-- RECURSIVE-MODE-AGENTS:START -->",
+	agentsEnd: "<!-- RECURSIVE-MODE-AGENTS:END -->",
+	plansStart: "<!-- RECURSIVE-MODE-PLANS-BRIDGE:START -->",
+	plansEnd: "<!-- RECURSIVE-MODE-PLANS-BRIDGE:END -->",
+	cursorrulesStart: "# RECURSIVE-MODE-MEMORY-POINTERS:START",
+	cursorrulesEnd: "# RECURSIVE-MODE-MEMORY-POINTERS:END",
+	repoMdStart: "<!-- RECURSIVE-MODE-MEMORY-POINTERS:START -->",
+	repoMdEnd: "<!-- RECURSIVE-MODE-MEMORY-POINTERS:END -->"
+};
+/** write_utf8_no_bom: LF newlines, no BOM. */
+function writeUtf8NoBom(path, content) {
+	writeFileSync(path, content, { encoding: "utf8" });
+}
+/** ensure_gitignore_line: add the line when absent (preserving existing). */
+function ensureGitignoreLine(repoRoot, line) {
+	const gitignorePath = join(repoRoot, ".gitignore");
+	const normalized = line.trim();
+	const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf8") : "";
+	if (existing.split(/\r?\n/).some((c) => c.trim() === normalized)) return;
+	let updated = existing;
+	if (updated && !updated.endsWith("\n")) updated += "\n";
+	updated += normalized + "\n";
+	writeUtf8NoBom(gitignorePath, updated);
+}
+/** upsert_marked_block: replace the START..END block, else append after existing. */
+function upsertMarkedBlock(filePath, startMarker, endMarker, blockBody) {
+	const existing = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+	const block = startMarker + "\n" + blockBody + "\n" + endMarker;
+	const pattern = new RegExp(escapeRegExp$1(startMarker) + "[\\s\\S]*?" + escapeRegExp$1(endMarker));
+	let updated;
+	if (pattern.test(existing)) updated = existing.replace(pattern, block);
+	else if (existing.trim() !== "") updated = existing.replace(/\s+$/, "") + "\n\n" + block + "\n";
+	else updated = block + "\n";
+	if (updated !== existing) writeUtf8NoBom(filePath, updated);
+}
+function escapeRegExp$1(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** normalize_plain_or_wrapped_content: strip markers; return plain body when wrapped. */
+function normalizePlainOrWrappedContent(content, startMarker, endMarker) {
+	const startIndex = content.indexOf(startMarker);
+	const endIndex = content.lastIndexOf(endMarker);
+	if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) return content.replace(/\r?\n+$/, "");
+	const prefix = content.slice(0, startIndex).replace(/\r?\n+$/, "");
+	if (prefix.trim() !== "") return prefix;
+	const bodyStart = startIndex + startMarker.length;
+	return content.slice(bodyStart, endIndex).replace(/^\r?\n+|\r?\n+$/g, "");
+}
+/** upsert_or_migrate_canonical: canonical block upsert with plain-file migration. */
+function upsertOrMigrateCanonical(filePath, startMarker, endMarker, canonicalBody) {
+	const existing = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+	const block = startMarker + "\n" + canonicalBody.replace(/\r?\n+$/, "") + "\n" + endMarker;
+	const pattern = new RegExp(escapeRegExp$1(startMarker) + "[\\s\\S]*?" + escapeRegExp$1(endMarker));
+	let updated;
+	if (pattern.test(existing)) updated = existing.replace(pattern, block);
+	else if (existing.trim() === "") updated = block + "\n";
+	else if (existing.replace(/\r?\n+$/, "") === canonicalBody.replace(/\r?\n+$/, "")) updated = block + "\n";
+	else updated = existing.replace(/\s+$/, "") + "\n\n" + block + "\n";
+	if (updated !== existing) writeUtf8NoBom(filePath, updated);
+}
+/** Read a shipped body file (references/bodies/<name>) — CRLF-normalized. */
+function body(name) {
+	return readFileSync(join(referencesRoot(), "bodies", name), "utf8").replace(/\r\n/g, "\n");
+}
+/** Read the canonical RECURSIVE.md template from shipped references/bootstrap/ — CRLF-normalized. */
+function canonicalWorkflowContent() {
+	return readFileSync(join(referencesRoot(), "bootstrap", "RECURSIVE.md"), "utf8").replace(/\r\n/g, "\n");
+}
+/** Read the agents bridge block from shipped references/ — CRLF-normalized. */
+function agentsBlockContent() {
+	return readFileSync(join(referencesRoot(), "agents-block.md"), "utf8").replace(/\r\n/g, "\n").replace(/\r?\n+$/, "");
+}
+/** default_router_policy(): byte-identical to recursive_router_lib.default_router_policy + pretty_json. */
+function defaultRouterPolicy() {
+	return JSON.stringify({
+		version: 1,
+		defaults: {
+			when_role_unconfigured: "ask",
+			when_cli_unavailable: "fallback-local",
+			when_model_unknown: "ask",
+			allow_auto_assign_if_single_cli: false,
+			probe_timeout_ms: 5e4,
+			invoke_timeout_ms: 18e4
+		},
+		role_routes: {
+			orchestrator: {
+				enabled: true,
+				mode: "local-only",
+				cli: null,
+				model: null,
+				fallback: "local-controller"
+			},
+			analyst: {
+				enabled: true,
+				mode: "external-cli",
+				cli: null,
+				model: null,
+				fallback: "self-audit"
+			},
+			planner: {
+				enabled: true,
+				mode: "external-cli",
+				cli: null,
+				model: null,
+				fallback: "self-audit"
+			},
+			implementer: {
+				enabled: false,
+				mode: "external-cli",
+				cli: null,
+				model: null,
+				fallback: "local-controller"
+			},
+			"code-reviewer": {
+				enabled: true,
+				mode: "external-cli",
+				cli: null,
+				model: null,
+				fallback: "self-audit"
+			},
+			tester: {
+				enabled: true,
+				mode: "external-cli",
+				cli: null,
+				model: null,
+				fallback: "self-audit"
+			},
+			"memory-auditor": {
+				enabled: true,
+				mode: "external-cli",
+				cli: null,
+				model: null,
+				fallback: "self-audit"
+			}
+		},
+		cli_overrides: {},
+		custom_clis: []
+	}, null, 2) + "\n";
+}
+/** ensure_router_scaffold: write config/recursive-router.json when missing. */
+function ensureRouterScaffold(repoRoot) {
+	const configDir = join(repoRoot, ".recursive", "config");
+	const policyPath = join(configDir, "recursive-router.json");
+	if (!existsSync(policyPath)) {
+		mkdirSync(configDir, { recursive: true });
+		writeUtf8NoBom(policyPath, defaultRouterPolicy());
+	}
+}
+/**
+* Idempotent scaffold install: reproduce the canonical installer's 82-file
+* tree byte-for-byte. Never overwrites existing user content; marked blocks
+* are re-upserted in place.
+*/
+function bootstrapScaffold(root) {
+	const created = [];
+	const existing = [];
+	const noteDir = (rel) => {
+		const p = join(root, rel);
+		if (existsSync(p)) existing.push(rel + "/");
+		else {
+			mkdirSync(p, { recursive: true });
+			created.push(rel + "/");
+		}
+	};
+	const noteFile = (rel, content) => {
+		const p = join(root, rel);
+		if (existsSync(p)) {
+			existing.push(rel);
+			return;
+		}
+		if (content !== void 0) {
+			mkdirSync(dirname(p), { recursive: true });
+			writeUtf8NoBom(p, content);
+		} else {
+			mkdirSync(dirname(p), { recursive: true });
+			writeFileSync(p, "");
+		}
+		created.push(rel);
+	};
+	const recursiveRoot = join(root, ".recursive");
+	const memoryRoot = join(recursiveRoot, "memory");
+	const skillMemoryRoot = join(memoryRoot, "skills");
+	for (const rel of [
+		".recursive",
+		".codex",
+		".agent",
+		".github",
+		".recursive/memory",
+		".recursive/memory/training",
+		".recursive/memory/skills",
+		".recursive/run",
+		".recursive/config"
+	]) noteDir(rel);
+	for (const sub of [
+		"domains",
+		"patterns",
+		"incidents",
+		"episodes",
+		"archive"
+	]) noteDir(join(".recursive/memory", sub));
+	for (const sub of [
+		"availability",
+		"usage",
+		"issues",
+		"patterns"
+	]) noteDir(join(".recursive/memory/skills", sub));
+	for (const rel of [
+		".recursive/memory/domains/.gitkeep",
+		".recursive/memory/patterns/.gitkeep",
+		".recursive/memory/incidents/.gitkeep",
+		".recursive/memory/episodes/.gitkeep",
+		".recursive/memory/archive/.gitkeep",
+		".recursive/memory/training/.gitkeep",
+		".recursive/memory/skills/availability/.gitkeep",
+		".recursive/memory/skills/usage/.gitkeep",
+		".recursive/memory/skills/issues/.gitkeep",
+		".recursive/memory/skills/patterns/.gitkeep",
+		".recursive/run/.gitkeep"
+	]) noteFile(rel, "");
+	noteDir(".recursive/scripts");
+	{
+		const scriptsDir = join(recursiveRoot, "scripts");
+		if (existsSync(scriptsDir)) {
+			for (const name of readdirSync(scriptsDir)) if (name.endsWith(".py") || name.endsWith(".ps1")) rmSync(join(scriptsDir, name), { force: true });
+		}
+	}
+	noteFile(".recursive/RECURSIVE.md", "# RECURSIVE.md\n");
+	noteFile(".recursive/AGENTS.md", "# AGENTS.md\n");
+	noteFile(".recursive/STATE.md", body("state.md") + "\n");
+	noteFile(".recursive/DECISIONS.md", body("decisions.md") + "\n");
+	noteFile(".recursive/memory/MEMORY.md", "# MEMORY.md\n");
+	noteFile(".recursive/memory/skills/SKILLS.md", "# SKILLS.md\n");
+	noteFile(".recursive/memory/skills/usage/skill-discovery-and-evaluation.md", body("skill-discovery.md") + "\n");
+	noteFile(".recursive/memory/skills/patterns/delegated-verification-and-refresh.md", body("delegated-verification.md") + "\n");
+	noteFile(".recursive/memory/skills/patterns/phase8-skill-memory-promotion.md", body("phase8-skill-memory.md") + "\n");
+	noteFile(".codex/AGENTS.md", "# AGENTS.md\n");
+	noteFile(".agent/PLANS.md", "# PLANS.md\n");
+	noteFile(".cursorrules", "");
+	noteFile("CLAUDE.md", "");
+	noteFile(".github/copilot-instructions.md", "");
+	ensureGitignoreLine(root, "/.recursive/config/recursive-router-discovered.json");
+	ensureRouterScaffold(root);
+	upsertMarkedBlock(join(recursiveRoot, "AGENTS.md"), M.agentsStart, M.agentsEnd, body("recursive-agents-router.md"));
+	upsertMarkedBlock(join(memoryRoot, "MEMORY.md"), M.memoryStart, M.memoryEnd, body("memory-router.md"));
+	upsertMarkedBlock(join(skillMemoryRoot, "SKILLS.md"), M.memoryStart, M.memoryEnd, body("skill-memory-router.md"));
+	upsertMarkedBlock(join(root, ".cursorrules"), M.cursorrulesStart, M.cursorrulesEnd, body("cursorrules.md"));
+	upsertMarkedBlock(join(root, "CLAUDE.md"), M.repoMdStart, M.repoMdEnd, body("claude.md"));
+	upsertMarkedBlock(join(root, ".github", "copilot-instructions.md"), M.repoMdStart, M.repoMdEnd, body("copilot.md"));
+	upsertMarkedBlock(join(root, ".codex", "AGENTS.md"), M.agentsStart, M.agentsEnd, body("codex-agents.md"));
+	const rootAgents = join(root, "AGENTS.md");
+	if (existsSync(rootAgents)) upsertMarkedBlock(rootAgents, M.agentsStart, M.agentsEnd, agentsBlockContent());
+	upsertMarkedBlock(join(root, ".agent", "PLANS.md"), M.plansStart, M.plansEnd, body("plans-bridge.md"));
+	const canonicalBody = normalizePlainOrWrappedContent(canonicalWorkflowContent(), M.recursiveStart, M.recursiveEnd);
+	upsertOrMigrateCanonical(join(recursiveRoot, "RECURSIVE.md"), M.recursiveStart, M.recursiveEnd, canonicalBody);
+	return {
+		root,
+		bootstrapped: created.length > 0,
+		created,
+		existing
+	};
+}
+/**
+* Enumerate runs as directory names only (bounded O(#dirs)). Never reads
+* run docs; never returns file paths.
+*/
+function enumerateRuns(root) {
+	const runRoot = join(root, ".recursive", "run");
+	if (!existsSync(runRoot)) return [];
+	return readdirSync(runRoot, { withFileTypes: true }).filter((d) => {
+		if (d.isDirectory()) return true;
+		if (!d.isSymbolicLink()) return false;
+		try {
+			return statSync(join(runRoot, d.name)).isDirectory();
+		} catch {
+			return false;
+		}
+	}).map((d) => d.name).sort();
+}
+/**
+* Stage B workflow init at agent/session-start. New: bootstrap if missing +
+* enumerate runs. Resume: idempotent REPAIR (not a full re-bootstrap) — the
+* upsert-only bootstrapScaffold adds missing control-plane files/dirs and
+* re-upserts marked blocks WITHOUT overwriting user content or touching run/
+* artifacts, then enumerates + notes the active run. The repair is safe on
+* fresh, partial, AND complete scaffolds (run 09 R3/R6). Always scoped to the
+* given control-plane root.
+*/
+function stageBWorkflowInit(input) {
+	const { root, source, activeRunId } = input;
+	const bootstrap = bootstrapScaffold(root);
+	const runs = enumerateRuns(root);
+	return {
+		root,
+		source,
+		bootstrapped: source === "new" ? bootstrap.bootstrapped : false,
+		runs,
+		activeRunId
+	};
+}
+//#endregion
 //#region src/commands.ts
 /**
 * /recursive slash command surface (R4). Preset-scoped verbs + global
@@ -3357,6 +5827,13 @@ function executeRecursiveCommand(root, rawInput) {
 			kind: "success",
 			text: HELP_TEXT + " — see /.recursive/RECURSIVE.md"
 		};
+		case "bootstrap": {
+			const result = bootstrapScaffold(root);
+			return {
+				kind: "success",
+				text: "recursive-mode scaffold repair: " + (result.created.length === 0 ? "scaffold already complete (no changes)" : "created " + result.created.length + " item(s), " + result.existing.length + " existing") + " — root " + root
+			};
+		}
 		case "closeout": {
 			const phase = arg.match(/--phase\s+(\d{2})/)?.[1] ?? "";
 			const runId = arg.replace(/--phase\s+\d{2}/, "").trim();
@@ -3444,6 +5921,42 @@ function registerRecursiveCommand(ctx, recursive) {
 	});
 }
 //#endregion
+//#region src/fs-intent.ts
+/**
+* fs-intent.ts — filesystem-derived recursive intent (R5 policy-render fix).
+*
+* SP2 zero-emission retired the recursive/phase-intent SESSION EVENT emitter,
+* so detectTransitionIntent(events) is ALWAYS null and the recursive:policy
+* prompt section rendered ''. This module derives the SAME intent from the
+* filesystem instead: session cwd -> control-plane root -> enumerate runs ->
+* latest run -> current phase (foldRun). Pure read-only fs folding, zero
+* emission — consistent with the per-workspace design + pre-step listener.
+*/
+/**
+* Resolve the recursive policy intent for one agent from the FILESYSTEM.
+* Returns null when no control-plane root or run is present (callers defer,
+* never fail hard). The registry path is async-only in the harness, so when a
+* registry is present this resolves the session cwd directly (B4: the session
+* cwd IS the workspace root when unregistered; a registered workspace resolves
+* to the same cwd via resolveControlPlaneRoot's sync fallback).
+*/
+function fsPolicyIntent(agent, registry, cwdFallback) {
+	const cwd = agent?.session?.header?.cwd ?? cwdFallback ?? null;
+	if (!cwd) return null;
+	const root = registry ? cwd : cwd;
+	const runs = enumerateRuns(root);
+	if (runs.length === 0) return null;
+	const runId = runs[runs.length - 1];
+	const runDir = join(root, ".recursive", "run", runId);
+	if (!existsSync(runDir)) return null;
+	const folded = foldRun(runDir, runId);
+	return {
+		worktreeRoot: root,
+		runId,
+		currentPhaseFile: folded.currentPhase ? folded.currentPhase.phaseName : null
+	};
+}
+//#endregion
 //#region src/snapshot.ts
 /** Resolve a run's lock facts for one artifact file (receipt first, status fallback). */
 function lockFactsOf(runDir, artifact) {
@@ -3682,9 +6195,10 @@ function apply(ctx, config) {
 	ctx.effect(function* () {
 		const workspaceRegistry = ctx.get("workspaceRegistry");
 		const recursive = new RecursiveRuntime(ctx, {
-			repoRoot: process.cwd(),
+			repoRoot: config?.repoRoot ?? process.cwd(),
 			workspaceRegistry
 		});
+		const repairedRoots = /* @__PURE__ */ new Set();
 		const disposers = [
 			ctx.tools.register(createRecursiveStatusTool(recursive)),
 			ctx.tools.register(createRecursiveInitTool(recursive)),
@@ -3702,14 +6216,11 @@ function apply(ctx, config) {
 			text: (context) => {
 				const agent = context?.agent;
 				if (!agent) return "";
-				if (!(agent.session?.header?.cwd ?? "")) return "";
-				const events = agent.session?.events ?? [];
-				const intent = detectTransitionIntent(events);
-				if (!intent || intent.worktreeRoot === "") return "";
+				const intent = fsPolicyIntent(agent, workspaceRegistry);
+				if (!intent) return "";
 				return renderRecursivePolicy({
 					worktreeRoot: intent.worktreeRoot,
 					runId: intent.runId,
-					folded: recursive.foldPhase(events),
 					config: recursive.enforcementConfig
 				});
 			}
@@ -3737,6 +6248,13 @@ function apply(ctx, config) {
 				kind: "enter",
 				messages
 			};
+			if (!repairedRoots.has(root)) {
+				repairedRoots.add(root);
+				stageBWorkflowInit({
+					root,
+					source: "resume"
+				});
+			}
 			const runs = enumerateRuns(root);
 			if (runs.length === 0) return {
 				kind: "enter",