@fusengine/harness 0.1.52 → 0.1.54

package/dist/{handle-QfgfNSh6.mjs → handle-CVvp1yuc.mjs}

@@ -20,7 +20,8 @@ import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, read
 import { homedir } from "node:os";
 import { mkdir, rmdir } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { execFileSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 //#region src/runtime/lifecycle/security/skill-state.ts
 /**
 * Shared security-tracker state: per-UTC-day JSON under
@@ -329,7 +330,7 @@ function designLifecycle(payload, cacheDir, cwd, stamp, now) {
 	return false;
 }
 /** Sidecar basename under the per-project state dir. */
-const SIDECAR$1 = "inject-dedup.json";
+const SIDECAR$2 = "inject-dedup.json";
 /** Load the `{ key -> epochMs }` map, or `{}` when missing/corrupt. */
 function loadMap$1(path) {
 	try {
@@ -361,7 +362,7 @@ function prune$1(map, now, windowMs) {
 */
 function oncePerWindow(key, windowMs, opts = {}) {
 	const now = opts.now ?? Date.now();
-	const path = join(opts.dir ?? defaultStateDir(), SIDECAR$1);
+	const path = join(opts.dir ?? defaultStateDir(), SIDECAR$2);
 	const map = prune$1(loadMap$1(path), now, windowMs);
 	const last = map[key];
 	if (typeof last === "number" && now - last < windowMs) return false;
@@ -417,7 +418,7 @@ function taskContext(cwd) {
 //#endregion
 //#region src/runtime/dev-context.ts
 /** Run a git subcommand in `cwd`, returning trimmed stdout or "" on error. */
-function git(cwd, args) {
+function git$1(cwd, args) {
 	try {
 		return execFileSync("git", args, {
 			cwd,
@@ -432,8 +433,8 @@ function git(cwd, args) {
 /** Build the git portion of the dev context (branch + up to 5 changed files). */
 function gitContext(cwd) {
 	if (!existsSync(join(cwd, ".git"))) return [];
-	const parts = [`Git branch: ${git(cwd, ["branch", "--show-current"]) || "unknown"}`];
-	const status = git(cwd, ["status", "--porcelain"]);
+	const parts = [`Git branch: ${git$1(cwd, ["branch", "--show-current"]) || "unknown"}`];
+	const status = git$1(cwd, ["status", "--porcelain"]);
 	if (status) parts.push("Modified files:\n" + status.split("\n").slice(0, 5).join("\n"));
 	return parts;
 }
@@ -902,10 +903,10 @@ function trunc(text, limit) {
 /** Render fresh cache entries as the markdown injection block. */
 function render(entries) {
 	const lines = [
-		"# MCP Cache disponible cette session",
-		"Avant de lancer mcp__context7/exa, verifie si deja cached.",
-		"Lis le fichier .md via Read pour recuperer le resultat.",
-		"APEX: Read sur cache MCP compte comme research-expert satisfait.",
+		"# MCP cache available this session",
+		"Before calling mcp__context7/exa, check if the result is already cached.",
+		"Read the .md file via Read to retrieve the result.",
+		"APEX: reading the MCP cache via Read satisfies the research-expert step.",
 		"",
 		"| Tool | Query | File |",
 		"| --- | --- | --- |"
@@ -1232,7 +1233,7 @@ function pad(n) {
 	return String(n).padStart(2, "0");
 }
 /** Compact local timestamp `YYYYMMDD-HHMMSS` (mirrors Python strftime). */
-function stamp(now) {
+function stamp$1(now) {
 	const d = new Date(now);
 	return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
@@ -1249,7 +1250,7 @@ function saveApexState(cwd, now = Date.now()) {
 	if (!existsSync(stateFile)) return "";
 	const backupDir = join(apexDir, "backups");
 	mkdirSync(backupDir, { recursive: true });
-	copyFileSync(stateFile, join(backupDir, `task-${stamp(now)}.json`));
+	copyFileSync(stateFile, join(backupDir, `task-${stamp$1(now)}.json`));
 	const backups = readdirSync(backupDir).filter((n) => n.startsWith("task-") && n.endsWith(".json")).sort().reverse();
 	for (const old of backups.slice(5)) try {
 		rmSync(join(backupDir, old), { force: true });
@@ -2135,16 +2136,10 @@ function cartoSessionStart(cwd, now = Date.now()) {
 	return ctx ? contextResponse("SessionStart", ctx) : "";
 }
 //#endregion
-//#region src/runtime/lifecycle/aipilot/curate-lessons.ts
-/**
-* Mechanical, LLM-free curation of `MEMORY/LESSON.md` bullets (anti-obesity):
-* strict-dedup near-identical bullets (keep newest, `[TRIGGERS …]` preserved),
-* flag over-cap + stale (>90d, cited path gone) in a report. Only dedup writes.
-*/
-const CAP = 50;
-const STALE_DAYS = 90;
-const SIM_THRESHOLD = .8;
-const MIN_TOKENS = 4;
+//#region src/runtime/lifecycle/aipilot/lesson-parse.ts
+/** Milliseconds in a day. */
+const DAY_MS = 864e5;
+/** Case-sensitive decision-time tag line (`[TRIGGERS …]`) — opus-lessons format. */
 const TRIG = /^\[TRIGGERS\s+.+\]$/;
 /** Epoch ms for a `[YYYY-MM-DD HH:MM]` stamp; `NaN` if absent or out of range. */
 function parseTs$1(line) {
@@ -2171,7 +2166,11 @@ function citedPaths(text) {
 	for (const m of text.matchAll(/[\w./@-]+\.\w{1,5}/g)) if (m[0]) out.add(m[0]);
 	return [...out].filter((p) => p.includes("/") && /\.\w{1,5}$/.test(p));
 }
-/** Split into a verbatim preamble and one Block per `- ` bullet. */
+/** True when a block carries a `[TRIGGERS …]` continuation line. */
+function hasTrigger(b) {
+	return b.raw.some((l) => TRIG.test(l.trim()));
+}
+/** Split content into a verbatim preamble and one Block per `- ` bullet. */
 function parse(content) {
 	const lines = content.split("\n");
 	const blocks = [];
@@ -2192,23 +2191,89 @@ function parse(content) {
 		blocks
 	};
 }
+//#endregion
+//#region src/runtime/lifecycle/aipilot/lesson-archive.ts
+/**
+* Stage 1 — cap→archive split for LESSON.md. When deduped bullets exceed CAP the
+* OLDEST excess is MOVED (never deleted) to LESSON-archive.md, EXCEPT a
+* `[TRIGGERS …]` bullet younger than STALE_DAYS: archiving it would blind the
+* PreToolUse trigger index (src/policy/lessons/trigger-index reads LESSON.md), so
+* it stays even past the cap. Pure: this module decides the partition and renders
+* the archive block; the fail-safe, archive-first file write is the caller's job.
+*/
+/** Sort key: undated bullets sort oldest, so malformed entries archive first. */
+function age(b) {
+	return Number.isNaN(b.ts) ? -Infinity : b.ts;
+}
+/** A TRIGGERS bullet is protected from archival until older than STALE_DAYS. */
+function isProtected(b, staleBefore) {
+	return hasTrigger(b) && !(b.ts <= staleBefore);
+}
+/**
+* Partition deduped `blocks` (newest-first file order) into the bullets that
+* stay in LESSON.md and the oldest excess to archive. Archives only enough to
+* reach CAP, skipping protected TRIGGERS bullets (so the file MAY stay slightly
+* over cap by design). Order is preserved in both halves; `keep ∪ archive` is
+* exactly `blocks` with no loss and no mutation.
+* @param blocks - Deduped bullets, newest first.
+* @param now - Clock (ms) for the STALE_DAYS protection window.
+* @returns `{ keep, archive }` — a lossless partition of `blocks`.
+*/
+function splitAtCap(blocks, now) {
+	if (blocks.length <= 50) return {
+		keep: blocks,
+		archive: []
+	};
+	const staleBefore = now - 90 * DAY_MS;
+	const oldestFirst = [...blocks].sort((a, b) => age(a) - age(b));
+	const toArchive = /* @__PURE__ */ new Set();
+	let excess = blocks.length - 50;
+	for (const b of oldestFirst) {
+		if (excess <= 0) break;
+		if (isProtected(b, staleBefore)) continue;
+		toArchive.add(b);
+		excess--;
+	}
+	return {
+		keep: blocks.filter((b) => !toArchive.has(b)),
+		archive: blocks.filter((b) => toArchive.has(b))
+	};
+}
+/**
+* Render `archive` bullets as a dated block to PREPEND to LESSON-archive.md
+* (newest archive session on top). Bullets are emitted BYTE-IDENTICAL (raw lines
+* rejoined) — zero mutation, so the move stays reversible/auditable.
+* @param archive - Bullets chosen by {@link splitAtCap}.
+* @param now - Clock (ms) for the archival header date.
+* @returns The block text (trailing newline), or "" when nothing is archived.
+*/
+function formatArchive(archive, now) {
+	if (archive.length === 0) return "";
+	return `${`<!-- archived ${new Date(now).toISOString().slice(0, 10)}: ${archive.length} bullet(s) moved from LESSON.md at cap 50 -->`}\n${archive.map((b) => b.raw.join("\n")).join("\n\n")}\n`;
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/curate-lessons.ts
+/**
+* Stage-0 mechanical, LLM-free dedup of MEMORY/LESSON.md bullets + cap→archive
+* orchestration. Strict-dedup near-identical bullets (keep newest, `[TRIGGERS …]`
+* preserved), then hand the deduped set to lesson-archive's cap split. Returns the
+* rewritten LESSON.md content, the archive block to move out, and a human report.
+* Pure: all file I/O (archive-first, fail-safe) lives in the dispatch caller.
+*/
+const SIM_THRESHOLD = .8;
+const MIN_TOKENS = 4;
 /** Report lines for bullets older than STALE_DAYS whose only cited path is gone. */
 function staleReport(blocks, now, root) {
-	const cutoff = now - STALE_DAYS * 864e5;
+	const cutoff = now - 90 * DAY_MS;
 	return blocks.flatMap((b) => {
 		if (!(b.ts <= cutoff)) return [];
 		const paths = citedPaths(b.raw.join(" "));
 		if (paths.length === 0 || paths.some((p) => existsSync(join(root, p)))) return [];
-		return [`[STALE?] ${(b.raw[0] ?? "").slice(0, 90)} — chemin(s) disparu(s): ${paths.join(", ")}`];
+		return [`[STALE?] ${(b.raw[0] ?? "").slice(0, 90)} — missing path(s): ${paths.join(", ")}`];
 	});
 }
-/**
-* Strict-dedup LESSON.md bullets (keep newest, its `[TRIGGERS …]` line preserved —
-* or carried over from the dropped twin if the kept one lacks it) and report
-* cap/stale. `content` unchanged unless a dedup occurred. Returns content + report.
-*/
-function curateLessons(content, now, root = process.cwd()) {
-	const { preamble, blocks } = parse(content);
+/** Strict-dedup: keep the newest of each near-identical pair (TRIGGERS carried over). Returns kept blocks + merge report lines. */
+function dedup(blocks) {
 	const kept = [];
 	const fused = [];
 	for (const b of blocks) {
@@ -2223,20 +2288,76 @@ function curateLessons(content, now, root = process.cwd()) {
 			const t = drop.raw.find((l) => TRIG.test(l.trim()));
 			if (t) win.raw.push(t);
 		}
-		fused.push(`fusion: gardé ${(win.raw[0] ?? "").slice(0, 60)} · retiré ${(drop.raw[0] ?? "").slice(0, 60)}`);
+		fused.push(`merged: kept ${(win.raw[0] ?? "").slice(0, 60)} · dropped ${(drop.raw[0] ?? "").slice(0, 60)}`);
 	}
-	const old = [...kept].sort((a, b) => a.ts - b.ts).slice(0, Math.max(0, kept.length - CAP));
-	const cap = old.length ? [`${kept.length} bullets (> ${CAP}) — plus anciens candidats à l'archivage:`, ...old.map((b) => `  ${(b.raw[0] ?? "").slice(0, 80)}`)] : [];
+	return {
+		kept,
+		fused
+	};
+}
+/**
+* Dedup LESSON.md bullets, then archive the oldest excess over CAP (via
+* lesson-archive). `content` is byte-identical to the input when nothing is
+* deduped or archived. The `archive` block (possibly "") is what the caller must
+* PREPEND to LESSON-archive.md, archive-first, before writing `content`.
+* @param content - Raw LESSON.md text.
+* @param now - Clock (ms) for stale/archival windows.
+* @param root - Project root, for resolving cited paths in the stale report.
+* @returns The rewritten content, the archive block, and the report.
+*/
+function curateLessons(content, now, root = process.cwd()) {
+	const { preamble, blocks } = parse(content);
+	const { kept, fused } = dedup(blocks);
+	const { keep, archive } = splitAtCap(kept, now);
+	const rebuilt = fused.length > 0 || archive.length > 0 ? `${preamble}\n${keep.map((b) => b.raw.join("\n")).join("\n\n")}\n` : content;
+	const capReport = archive.length ? [`${kept.length} bullets (> 50) — ${archive.length} oldest archived → LESSON-archive.md`] : [];
 	const report = [
 		...fused,
-		...cap,
+		...capReport,
 		...staleReport(blocks, now, root)
 	].join("\n");
 	return {
-		content: fused.length ? `${preamble}\n${kept.map((b) => b.raw.join("\n")).join("\n\n")}\n` : content,
+		content: rebuilt,
+		archive: formatArchive(archive, now),
 		report
 	};
 }
+/** The `[YYYY-MM-DD HH:MM]` (or date-only) stamp of a bullet, "" if absent. */
+function stamp(block) {
+	return (block.raw[0] ?? "").match(/\[(\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2})?)\]/)?.[1] ?? "";
+}
+/** Bullet text: raw lines joined, leading "- ", date stamp & TRIGGERS lines stripped. */
+function bodyText(block) {
+	return block.raw.filter((l) => !/^\s*\[TRIGGERS\s/.test(l)).join(" ").replace(/^-\s*/, "").replace(/\[\d{4}-\d{2}-\d{2}[^\]]*\]\s*/, "").trim();
+}
+/** First sentence of `s` (split on a period + whitespace), whole string if none. */
+function firstSentence(s) {
+	return (s.split(/(?<=\.)\s/)[0] ?? s).trim();
+}
+/** Collapse one older bullet to `- [date] <rule>`: first sentence after last "→", capped. */
+function compressBullet(block) {
+	const text = bodyText(block);
+	const arrow = text.lastIndexOf("→");
+	let rule = firstSentence((arrow >= 0 ? text.slice(arrow + 1) : text).trim());
+	if (rule.length > 200) rule = `${rule.slice(0, 199).trimEnd()}…`;
+	const date = stamp(block);
+	return `- ${date ? `[${date}] ` : ""}${rule}`;
+}
+/**
+* Build the compressed injection body for `content`. The preamble comments are
+* dropped (format docs, noise for the reader); the `recentFull` newest bullets
+* stay whole, every older bullet becomes one distilled rule-line.
+* @param content - Raw LESSON.md text.
+* @param recentFull - Count of newest bullets to keep verbatim.
+* @returns The compressed block (bullets only), or the trimmed content when there are no bullets.
+*/
+function compressInjection(content, recentFull = 10) {
+	const { blocks } = parse(content);
+	if (blocks.length === 0) return content.trim();
+	const full = blocks.slice(0, recentFull).map((b) => b.raw.join("\n"));
+	const rest = blocks.slice(recentFull).map(compressBullet);
+	return [...full, ...rest].join("\n");
+}
 //#endregion
 //#region src/runtime/lifecycle/lessons/state.ts
 /**
@@ -2250,40 +2371,116 @@ function curateLessons(content, now, root = process.cwd()) {
 function lessonsFileFor(root) {
 	return join(root, "MEMORY", "LESSON.md");
 }
+/** Absolute `<root>/MEMORY/LESSON-archive.md` — cold storage for capped-out bullets. */
+function lessonsArchiveFileFor(root) {
+	return join(root, "MEMORY", "LESSON-archive.md");
+}
 /** Absolute `<root>/MEMORY/state.json` — machine-local throttle counter. */
 function lessonsStateFileFor(root) {
 	return join(root, "MEMORY", "state.json");
 }
 //#endregion
-//#region src/runtime/lifecycle/lessons/dispatch.ts
-/**
-* fuse-lessons scope dispatch (TS port of the 4 handler scripts). Routes by
-* event: SessionStart/SubagentStart inject `MEMORY/LESSON.md`; Stop reminds
-* across every project with unsaved code edits; PostToolUse marks the write to
-* arm/silence the per-project throttle. Non-fatal by design.
-*/
-/** Inject `MEMORY/LESSON.md` for `event`, after mechanical curation (a strict dedup rewrites the file in place; any report surfaces to the user via systemMessage). */
-function injectMemory(cwd, event, now) {
-	const root = projectRoot(cwd);
-	const file = lessonsFileFor(root);
-	if (!existsSync(file)) return "";
-	let content = "";
+//#region src/memory/session-roots.ts
+/**
+* Session-scoped lessons roots registry. The flat {@link module:memory/registry}
+* keeps ONE global list of pending roots — correct mono-session, but wrong with
+* several concurrent Claude Code sessions: at Stop, one session lists (and, by
+* bumping the throttle, STEALS) another session's pending lesson on a project it
+* never touched. This registry keys "which project got code edits, and was its
+* Stop reminder already fired" by `session_id`, so each Stop sees and consumes
+* ONLY its own roots. Stored at `$HOME/.fuse-harness/cache/lessons/session-roots.json`;
+* non-fatal on any I/O failure (a missed reminder never blocks a session).
+*/
+/** Registry path (rel. home) + stale-bucket purge horizon (bounds growth). */
+const SUBPATH = ".fuse-harness/cache/lessons/session-roots.json";
+const PURGE_MS = 10080 * 60 * 1e3;
+/** Absolute registry path, or null when home is unusable. */
+function file(home) {
+	const h = home?.trim();
+	return h && h.startsWith("/") ? `${h}/${SUBPATH}` : null;
+}
+/** Read the registry; missing/corrupt/legacy (array) shapes collapse to `{}`. */
+function read(home) {
+	const f = file(home);
+	if (!f) return {};
 	try {
-		content = readFileSync(file, "utf-8").trim();
+		const parsed = JSON.parse(readFileSync(f, "utf8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
 	} catch {
-		return "";
+		return {};
 	}
-	if (!content) return "";
-	const { content: curated, report } = curateLessons(content, now, root);
-	if (curated !== content) try {
-		atomicWrite(file, curated);
-		content = curated;
+}
+/** Purge stale buckets, then atomically persist (unique tmp + rename). Non-throwing. */
+function write(home, reg, now) {
+	const f = file(home);
+	if (!f) return;
+	for (const [sid, entry] of Object.entries(reg)) if (!entry || now - (entry.updatedAt ?? 0) > PURGE_MS) delete reg[sid];
+	try {
+		mkdirSync(dirname(f), { recursive: true });
+		atomicWrite(f, JSON.stringify(reg));
 	} catch {}
-	const ctx = `Project lessons — never reproduce these:\n${content}\nYou may append OR refine/merge/dedupe bullets in MEMORY/LESSON.md — keep it terse.`;
-	return report ? attachSystemMessage(contextResponse(event, ctx), `LESSON.md curation:\n${report}`) : contextResponse(event, ctx);
 }
-/** Select roots with unsaved code edits past the throttle, bumping their state. */
-function collectPending(now, window) {
+/** Record `field` for `(sid, root)`, refreshing the purge cursor. `home` defaults to `$HOME`. */
+function markSessionRoot(sid, root, field, value, home = process.env.HOME) {
+	const reg = read(home);
+	const prev = reg[sid];
+	const entry = prev && typeof prev.roots === "object" && prev.roots !== null ? prev : {
+		updatedAt: value,
+		roots: {}
+	};
+	const mark = entry.roots[root] ?? {
+		editedAt: 0,
+		remindedAt: 0
+	};
+	entry.roots[root] = {
+		...mark,
+		[field]: value
+	};
+	entry.updatedAt = value;
+	reg[sid] = entry;
+	write(home, reg, value);
+}
+/**
+* Roots of `sid` with an unsaved code edit past the `window`; each returned
+* root's `remindedAt` is bumped to `now` so the reminder fires at most once per
+* window and is consumed ONLY by this session. `home` defaults to `$HOME`.
+*/
+function collectSessionPending(sid, now, window, home = process.env.HOME) {
+	const reg = read(home);
+	const entry = reg[sid];
+	if (!entry || typeof entry.roots !== "object" || entry.roots === null) return [];
+	const pending = [];
+	for (const [root, mark] of Object.entries(entry.roots)) {
+		if (mark.editedAt <= mark.remindedAt) continue;
+		if (now - mark.remindedAt < window) continue;
+		pending.push(root);
+		entry.roots[root] = {
+			...mark,
+			remindedAt: now
+		};
+	}
+	if (pending.length > 0) write(home, reg, now);
+	return pending;
+}
+//#endregion
+//#region src/runtime/lifecycle/lessons/reminder.ts
+/**
+* fuse-lessons write-mark + Stop-reminder, scoped by `session_id` when present.
+*
+* WITH a session id (normal Claude Code): each `(session, root)` pair carries
+* its own edit/reminder throttle in {@link module:memory/session-roots}, so a
+* Stop lists and silences ONLY the roots THAT session edited — concurrent
+* sessions on different projects never cross-remind nor steal each other's
+* throttle. WITHOUT a usable session id (a harness that omits it, or the legacy
+* on-disk state) it falls back to the original mono-session behavior: the global
+* flat root registry + the per-project `MEMORY/state.json` throttle.
+*/
+/** Sanitized session id from a raw hook payload, or null (→ legacy fallback). */
+function sessionOf(payload) {
+	return sanitizeSessionId(payload.session_id);
+}
+/** Legacy (no session id): pending roots across the global flat registry. */
+function collectLegacyPending(now, window) {
 	const pending = [];
 	for (const root of readRoots()) {
 		const stateFile = lessonsStateFileFor(root);
@@ -2295,26 +2492,99 @@ function collectPending(now, window) {
 	}
 	return pending;
 }
-/** Stop: emit one reminder covering every project with pending lessons. */
-function remindWrite(now) {
-	const pending = collectPending(now, throttleMs());
+/** Stop reminder body listing each pending project's lessons file. */
+function reminderText(pending) {
+	return `Before ending: if this session hit a mistake/blocker worth never reproducing, append 1-3 COMPACT bullets OR sharpen/merge existing ones (format \`- [${nowStamp()}] what went wrong → do instead\`, use exactly this timestamp) in each project's lessons file below. Skip if nothing notable.\n${pending.map((r) => `- ${r}/MEMORY/LESSON.md`).join("\n")}`;
+}
+/**
+* Stop: emit one reminder covering the stopping session's pending projects.
+* @param payload - Raw hook payload (`session_id` selects the scoped path).
+* @param now - Clock.
+* @returns Native Stop stdout, or "" when nothing is pending.
+*/
+function remindWrite(payload, now) {
+	const window = throttleMs();
+	const sid = sessionOf(payload);
+	const pending = sid ? collectSessionPending(sid, now, window) : collectLegacyPending(now, window);
 	if (pending.length === 0) return "";
-	return contextResponse("Stop", `Before ending: if this session hit a mistake/blocker worth never reproducing, append 1-3 COMPACT bullets OR sharpen/merge existing ones (format \`- [${nowStamp()}] what went wrong → do instead\`, use exactly this timestamp) in each project's lessons file below. Skip if nothing notable.\n${pending.map((r) => `- ${r}/MEMORY/LESSON.md`).join("\n")}`);
+	return contextResponse("Stop", reminderText(pending));
 }
-/** PostToolUse: record the relevant throttle timestamp for the edited file. */
+/**
+* PostToolUse: record the edit against the throttle. A code file arms the
+* reminder; writing `MEMORY/LESSON.md` silences it (the lesson was just saved).
+* Session-scoped when `session_id` is present, else the legacy global path.
+* @param payload - Raw hook payload (`tool_input.file_path`, `session_id`).
+* @param now - Clock.
+*/
 function markWrite(payload, now) {
 	const input = payload.tool_input;
 	if (!input?.file_path) return;
 	const abs = resolve(input.file_path);
 	const root = projectRootOrNull(dirname(abs));
 	if (!root) return;
-	const stateFile = lessonsStateFileFor(root);
-	if (abs === resolve(root, "MEMORY", "LESSON.md")) setStateField(stateFile, "lastRemindedAt", now);
-	else if (isCodeFile(abs)) {
-		setStateField(stateFile, "lastCodeEditAt", now);
+	const isLesson = abs === resolve(root, "MEMORY", "LESSON.md");
+	if (!isLesson && !isCodeFile(abs)) return;
+	const sid = sessionOf(payload);
+	if (sid) markSessionRoot(sid, root, isLesson ? "remindedAt" : "editedAt", now);
+	else if (isLesson) setStateField(lessonsStateFileFor(root), "lastRemindedAt", now);
+	else {
+		setStateField(lessonsStateFileFor(root), "lastCodeEditAt", now);
 		addRoot(root);
 	}
 }
+//#endregion
+//#region src/runtime/lifecycle/lessons/dispatch.ts
+/**
+* fuse-lessons scope dispatch (TS port of the 4 handler scripts). Routes by
+* event: SessionStart/SubagentStart inject `MEMORY/LESSON.md`; Stop reminds the
+* stopping session about ITS OWN projects with unsaved code edits; PostToolUse
+* marks the write to arm/silence the throttle. The reminder + mark logic (incl.
+* the per-`session_id` scoping that fixes the multi-session misdirection) lives
+* in {@link module:runtime/lifecycle/lessons/reminder}; this module keeps the
+* event router + lesson-file injection. Non-fatal by design.
+*/
+/**
+* Persist a curation ATOMICALLY and ARCHIVE-FIRST for zero-loss: prepend the
+* moved bullets to LESSON-archive.md, THEN rewrite LESSON.md. On ANY write error
+* the original file is left untouched (returns `original`) so a bullet is never
+* lost — a rare archive-then-trim-fail leaves a duplicate (never a loss), which
+* the next dedup pass reconciles.
+*/
+function persistCuration(file, root, curated, archive, original) {
+	try {
+		if (archive) {
+			const af = lessonsArchiveFileFor(root);
+			const prev = existsSync(af) ? readFileSync(af, "utf-8") : "";
+			atomicWrite(af, prev ? `${archive}\n${prev}` : archive);
+		}
+		atomicWrite(file, curated);
+		return curated;
+	} catch {
+		return original;
+	}
+}
+/**
+* Inject `MEMORY/LESSON.md` for `event`. Mechanical curation (dedup + cap→archive)
+* rewrites the FILE; the injected BLOCK is then COMPRESSED (newest bullets whole,
+* older ones distilled to their rule) so a growing file never inflates the
+* SessionStart/SubagentStart context. Any curation report surfaces via systemMessage.
+*/
+function injectMemory(cwd, event, now) {
+	const root = projectRoot(cwd);
+	const file = lessonsFileFor(root);
+	if (!existsSync(file)) return "";
+	let content = "";
+	try {
+		content = readFileSync(file, "utf-8").trim();
+	} catch {
+		return "";
+	}
+	if (!content) return "";
+	const { content: curated, archive, report } = curateLessons(content, now, root);
+	if (curated !== content) content = persistCuration(file, root, curated, archive, content);
+	const ctx = `Project lessons — never reproduce these:\n${compressInjection(content)}\nYou may append OR refine/merge/dedupe bullets in MEMORY/LESSON.md — keep it terse.`;
+	return report ? attachSystemMessage(contextResponse(event, ctx), `LESSON.md curation:\n${report}`) : contextResponse(event, ctx);
+}
 /**
 * Route a fuse-lessons event to its handler. Returns the native stdout for
 * context-injecting events (SessionStart/SubagentStart/Stop) or "" for the
@@ -2329,7 +2599,7 @@ function dispatchLessons(event, payload, cwd, now) {
 	switch (event) {
 		case "SessionStart":
 		case "SubagentStart": return injectMemory(cwd, event, now);
-		case "Stop": return remindWrite(now);
+		case "Stop": return remindWrite(payload, now);
 		case "PostToolUse":
 			markWrite(payload, now);
 			return "";
@@ -2337,6 +2607,559 @@ function dispatchLessons(event, payload, cwd, now) {
 	}
 }
 //#endregion
+//#region src/policy/deny-loop.ts
+/**
+* @module deny-loop
+* Pure anti-loop logic: hash a tool-call, decide if it repeats a prior deny, and
+* enrich the repeated block's message.
+*
+* The proprietary rule "NEVER propose the same fix twice" is prose a model under
+* pressure ignores. This makes it machine-enforced: when a call whose
+* `(tool + normalized input)` hash was ALREADY denied in-window is retried, the
+* harness keeps the deny but rewrites the message — `[REPEAT]` title, STOP
+* prefix, forced `research-expert` action. State + wiring live in the sidecar
+* store ({@link module:deny-loop-store}); this file is IO-free and pure.
+* @packageDocumentation
+*/
+/** Stable JSON: keys sorted at every depth so `{a,b}` and `{b,a}` hash identically. */
+function stableStringify(v) {
+	if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
+	if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`;
+	const o = v;
+	return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`).join(",")}}`;
+}
+/**
+* Stable identity hash of a tool-call = tool name + normalized (key-sorted) input,
+* so re-ordered keys never mask a repeat.
+* @param tool - Tool name (e.g. "Write", "Bash").
+* @param input - Identifying tool input (filePath/content/command...).
+* @returns 8-char hex hash.
+*/
+function denyHash(tool, input) {
+	return hashText(`${tool}\n${stableStringify(input)}`);
+}
+/**
+* Pure loop check: given the already-pruned in-window map, compute the running
+* count for `hash` and whether it repeats (count > 1). No IO — the caller persists.
+* @param hash - {@link denyHash} of the current call.
+* @param priorDenies - The `{ hash -> DenyEntry }` map, pruned to `now`/`windowMs`.
+* @param opts - Clock + window.
+* @returns `{ isRepeat, count, hash }`.
+*/
+function denyLoopCheck(hash, priorDenies, opts) {
+	const prev = priorDenies[hash];
+	const count = (prev && typeof prev.lastTs === "number" && opts.now - prev.lastTs < opts.windowMs ? prev.count : 0) + 1;
+	return {
+		isRepeat: count > 1,
+		count,
+		hash
+	};
+}
+/**
+* Enrich a REPEATED block prompt — a NEW object, never a mutation (the input may
+* be a shared const like FAIL_CLOSED). The decision stays `block`; only the
+* message changes, so every harness renders it through the same adapter.
+* @param prompt - The original block prompt.
+* @param count - The running identical-deny count (n).
+* @returns A block prompt with `[REPEAT]` title, STOP-prefixed reason, forced research action.
+*/
+function enrichRepeatDeny(prompt, count) {
+	const stop = `Identical attempt #${count} already denied for the same reason. STOP: do not retry this same call. `;
+	const action = "Launch fuse-ai-pilot:research-expert to find a DIFFERENT approach";
+	return {
+		...prompt,
+		title: prompt.title.startsWith("[REPEAT]") ? prompt.title : `[REPEAT] ${prompt.title}`,
+		reason: stop + prompt.reason,
+		actions: [action, ...prompt.actions ?? []]
+	};
+}
+//#endregion
+//#region src/tracking/one-shot-store.ts
+/** A fresh, empty state — always spread (`{ ...EMPTY }`) so the const is never shared. */
+const EMPTY = {
+	gates: {},
+	firstTry: 0,
+	corrected: 0,
+	pending: {},
+	updatedAt: 0
+};
+/**
+* Drop stale data: whole-state idle reset past the window, else per-entry prune of
+* gates/pending older than `windowMs`. Keeps the "7d" window honest, bounds size.
+*/
+function pruneState(s, now, windowMs) {
+	if (now - s.updatedAt >= windowMs) return { ...EMPTY };
+	const gates = {};
+	for (const [k, g] of Object.entries(s.gates)) if (now - g.lastTs < windowMs) gates[k] = g;
+	const pending = {};
+	for (const [k, p] of Object.entries(s.pending)) if (now - p.ts < windowMs) pending[k] = p;
+	return {
+		...s,
+		gates,
+		pending
+	};
+}
+/**
+* Record a deny for gate `title` on operation `op` (content-free tool identity):
+* bump the gate's deny count and mark `op` pending for a later fix.
+*/
+function applyDeny(s, title, op, now) {
+	const g = s.gates[title] ?? {
+		denies: 0,
+		corrected: 0,
+		lastTs: 0
+	};
+	return {
+		...s,
+		gates: {
+			...s.gates,
+			[title]: {
+				denies: g.denies + 1,
+				corrected: g.corrected,
+				lastTs: now
+			}
+		},
+		pending: {
+			...s.pending,
+			[op]: {
+				title,
+				ts: now
+			}
+		},
+		updatedAt: now
+	};
+}
+/**
+* Record an allow for a gateable `op`. A non-gateable allow (Read/Task/MCP) leaves
+* state untouched — it never counts and never clears a pending deny. Otherwise: a
+* pending deny → `corrected` (a fix, credited to the blocking gate); no pending →
+* `firstTry` (one-shot).
+*/
+function applyAllow(s, op, now, gateable) {
+	if (!gateable) return s;
+	const pend = s.pending[op];
+	if (pend) {
+		const g = s.gates[pend.title] ?? {
+			denies: 0,
+			corrected: 0,
+			lastTs: 0
+		};
+		const { [op]: _drop, ...pending } = s.pending;
+		return {
+			...s,
+			gates: {
+				...s.gates,
+				[pend.title]: {
+					...g,
+					corrected: g.corrected + 1,
+					lastTs: now
+				}
+			},
+			corrected: s.corrected + 1,
+			pending,
+			updatedAt: now
+		};
+	}
+	return gateable ? {
+		...s,
+		firstTry: s.firstTry + 1,
+		updatedAt: now
+	} : s;
+}
+/**
+* Compact injectable summary (one line); "" when there is nothing to report.
+* @returns e.g. `gates 7d: 88% one-shot (44/50 clean); SOLID file-size limit 4den/3fix`.
+*/
+function formatSummary(s) {
+	const keys = Object.keys(s.gates);
+	const total = s.firstTry + s.corrected;
+	if (keys.length === 0 && total === 0) return "";
+	const head = total > 0 ? `${Math.round(s.firstTry / total * 100)}% one-shot (${s.firstTry}/${total} clean)` : "no clean pass yet";
+	const parts = keys.map((k) => ({
+		k,
+		g: s.gates[k]
+	})).sort((a, b) => b.g.denies - a.g.denies).map(({ k, g }) => `${k} ${g.denies}den/${g.corrected}fix`);
+	return `gates 7d: ${head}${parts.length ? `; ${parts.join("; ")}` : ""}`;
+}
+//#endregion
+//#region src/tracking/one-shot.ts
+/**
+* @module one-shot
+* Sidecar store + gate wiring for the per-gate one-shot metric.
+*
+* STATE — a standalone sidecar (`one-shot.json`) in the same per-project state dir
+* as the session track, mirroring {@link module:deny-loop-store} (atomicWrite,
+* prune-by-window, fail-safe). A write error NEVER changes a gate decision nor its
+* prompt — metrics are pure observation.
+*
+* KEY — the operation identity is content-FREE (`tool + filePath/command`): a fix
+* changes the content, so a content hash would make every retry a new op and hide
+* the deny→allow transition this metric exists to see. The pure model lives in
+* {@link module:one-shot-store}; this file is the only IO surface.
+* @packageDocumentation
+*/
+/** Sidecar basename under the per-project state dir. */
+const SIDECAR$1 = "one-shot.json";
+/** Retention window: 7 days. Aggregates and pending denies older than this are pruned. */
+const WINDOW_MS = 10080 * 60 * 1e3;
+/** Load the state, or a fresh copy when missing/corrupt. */
+function loadState(path) {
+	try {
+		if (!existsSync(path)) return { ...EMPTY };
+		const d = JSON.parse(readFileSync(path, "utf8"));
+		return d && typeof d === "object" && !Array.isArray(d) ? {
+			...EMPTY,
+			...d
+		} : { ...EMPTY };
+	} catch {
+		return { ...EMPTY };
+	}
+}
+/**
+* Record a gate outcome: a `block` is a deny for its gate title; a `null` allow is
+* a fix (if the op was pending) or a one-shot (if gateable). `ask`/`inform` are
+* neither and are skipped. Fails silently — a metric write NEVER affects a decision.
+*
+* The op key is tool-INDEPENDENT (`filePath`/`command` only, constant `"op"` tool):
+* a deny (a `Write`) and its fix (an `Edit`) on the same file must link.
+* @param prompt - The gate's outcome (block, allow=null, or ask/inform).
+* @param input - Identifying tool input (content decides gateability only).
+* @param opts - Clock + state dir.
+*/
+function recordOneShot(prompt, input, opts) {
+	try {
+		if (prompt && prompt.kind !== "block") return;
+		const path = join(opts.dir, SIDECAR$1);
+		let s = pruneState(loadState(path), opts.now, WINDOW_MS);
+		const op = denyHash("op", {
+			filePath: input.filePath,
+			command: input.command
+		});
+		s = prompt ? applyDeny(s, prompt.title, op, opts.now) : applyAllow(s, op, opts.now, input.content != null || input.command != null);
+		atomicWrite(path, JSON.stringify(s));
+	} catch {}
+}
+/**
+* Compact, injection-ready one-shot summary for the project rooted at `cwd`. The
+* state dir is derived EXACTLY like the runtime writer ({@link defaultStateDir},
+* mirroring `handle.ts` `trackFile(sid, defaultStateDir(cwd))`), so the file read
+* here is the same one {@link recordOneShot} wrote. "" when no data or read error.
+* @param cwd - The project working directory (Claude `cwd`), NOT the state dir.
+* @returns One line, e.g. `gates 7d: 88% one-shot (44/50 clean); ...`, or "".
+*/
+function oneShotSummary(cwd) {
+	try {
+		return formatSummary(pruneState(loadState(join(defaultStateDir(cwd), SIDECAR$1)), Date.now(), WINDOW_MS));
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/snapshot/git.ts
+/**
+* Run a git subcommand at `root` with a short timeout, returning trimmed stdout.
+* Uses `node:child_process` (the Bun shell can hang on some git plumbing) and
+* swallows every failure — a non-repo, missing git, or timeout yields `""` so
+* the caller omits the section instead of throwing inside the hook.
+* @param root - Directory to run git in.
+* @param args - The git args (e.g. `"log --oneline -3"`).
+* @returns Trimmed stdout, or `""` on any error.
+*/
+function git(root, args) {
+	try {
+		return execSync(`git ${args}`, {
+			cwd: root,
+			encoding: "utf8",
+			timeout: 150,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+/** Count staged/unstaged/untracked files from porcelain v1 output (skips the `##` branch line). */
+function countWip(porcelain) {
+	const w = {
+		staged: 0,
+		unstaged: 0,
+		untracked: 0
+	};
+	for (const line of porcelain.split("\n")) {
+		if (!line || line.startsWith("#")) continue;
+		if (line.startsWith("??")) {
+			w.untracked++;
+			continue;
+		}
+		const x = line[0], y = line[1];
+		if (x && x !== " " && x !== "?") w.staged++;
+		if (y === "M" || y === "D") w.unstaged++;
+	}
+	return w;
+}
+/** Parse the current branch from the leading `## branch...upstream` porcelain line. */
+function parseBranch(porcelain) {
+	const head = porcelain.split("\n")[0] ?? "";
+	if (!head.startsWith("## ")) return "";
+	const rest = head.slice(3);
+	const dots = rest.indexOf("...");
+	return (dots >= 0 ? rest.slice(0, dots) : rest).split(" ")[0] ?? "";
+}
+/**
+* Collect a compact git reconciliation section for `root`: current branch, the
+* last three commits (oneline), and staged/unstaged/untracked WIP counts. When
+* `root` is not a git repo (status fails) the whole section is omitted (`""`).
+* @param root - The project/repo root.
+* @returns The rendered git section body, or `""` when not a repo.
+*/
+function collectGit(root) {
+	const status = git(root, "status --porcelain=v1 --branch");
+	if (!status) return "";
+	const branch = parseBranch(status) || "(unknown)";
+	const w = countWip(status);
+	const log = git(root, "log --oneline -3");
+	const lines = [`- branch: ${branch}`];
+	if (log) lines.push("- recent:", ...log.split("\n").map((l) => `    ${l}`));
+	lines.push(`- WIP: ${w.staged} staged, ${w.unstaged} unstaged, ${w.untracked} untracked`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/doctor.ts
+/**
+* `harness doctor` — diagnose which `@fusengine/harness` is actually running.
+*
+* A confirmed, still-open bun bug (oven-sh/bun #5791; scoped-pkg behaviour
+* reinforced by #32019/#32150) makes `bunx <pkg>` (unpinned) prefer a stale
+* GLOBAL install over npm-latest, so a consumer can silently run an old harness
+* after a publish. This command surfaces the truth: the resolved version +
+* package path of the code executing right now, the runtime binary, and the
+* latest version published on npm. It queries the registry over HTTP (not
+* `npm view`, whose exit code is 0 even on an empty result — npm/cli#6408) and
+* never throws: an offline environment yields `latest: null`, never a crash.
+*/
+const PKG = "@fusengine/harness";
+/** Walk up from `startDir` for the `@fusengine/harness` `package.json`. */
+function findPackage(startDir) {
+	let dir = startDir;
+	for (let depth = 0; depth < 6; depth++) {
+		try {
+			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+			if (pkg.name === PKG) return {
+				version: pkg.version ?? "unknown",
+				path: dir
+			};
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+/** Resolve the running version + package path (no network), from a module URL. */
+function runningVersion(moduleUrl) {
+	const found = findPackage(dirname(fileURLToPath(moduleUrl)));
+	return {
+		version: found?.version ?? "unknown",
+		path: found?.path ?? "unknown"
+	};
+}
+/** One-line `pkg vX.Y.Z` banner (stderr, only on explicit `--version`/`doctor` commands — never on `hook`, to avoid spamming automated invocations). */
+function versionBanner(moduleUrl) {
+	return `${PKG} v${runningVersion(moduleUrl).version}`;
+}
+/** Latest published version via the npm registry HTTP API. `null` on any failure. */
+async function npmLatest() {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${PKG}/latest`, { signal: AbortSignal.timeout(8e3) });
+		if (!res.ok) return null;
+		return (await res.json()).version ?? null;
+	} catch {
+		return null;
+	}
+}
+/** Build the full diagnostic report for the module at `moduleUrl`. */
+async function buildDoctorReport(moduleUrl) {
+	const { version, path } = runningVersion(moduleUrl);
+	const latest = await npmLatest();
+	return {
+		running: version,
+		packagePath: path,
+		runtime: process.execPath,
+		latest,
+		stale: latest !== null && latest !== version
+	};
+}
+/** Render a {@link DoctorReport} as human-readable stdout text. */
+function formatDoctor(r) {
+	const lines = [
+		`${PKG} doctor`,
+		`  running:    ${r.running}`,
+		`  package:    ${r.packagePath}`,
+		`  runtime:    ${r.runtime}`,
+		`  npm latest: ${r.latest ?? "(unavailable — offline or unreachable)"}`
+	];
+	if (r.stale) lines.push(`  ! stale — npm serves ${r.latest}. Pin "@fusengine/harness@${r.latest}" in hooks.json (see README).`);
+	else if (r.latest !== null) lines.push(`  ok — running the latest published version.`);
+	return lines.join("\n");
+}
+/** Run `harness doctor`: print the diagnostic to stdout. Always resolves 0 (pure info). */
+async function runDoctor(moduleUrl) {
+	process.stdout.write(formatDoctor(await buildDoctorReport(moduleUrl)) + "\n");
+	return 0;
+}
+//#endregion
+//#region src/runtime/lifecycle/snapshot/version.ts
+/** Read the `version` field of `<root>/package.json`, or `""` if absent/unreadable. */
+function pkgVersion(root) {
+	try {
+		return JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version ?? "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Collect the version reconciliation section: the harness version actually
+* running (resolved from {@link runningVersion}, no network) and, when `root`
+* carries its own `package.json`, whether that project's version has drifted
+* from the running harness.
+* @param root - The project root (cwd repo).
+* @param moduleUrl - `import.meta.url` of the calling module (locates the running package.json).
+* @returns The rendered version section body (never `""`).
+*/
+function collectVersion(root, moduleUrl) {
+	const running = runningVersion(moduleUrl).version;
+	const lines = [`- harness running: v${running}`];
+	const project = pkgVersion(root);
+	if (project && project !== running) lines.push(`- project package.json: v${project} (DRIFT — running harness differs)`);
+	else if (project) lines.push(`- project package.json: v${project} (in sync)`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/runtime/lifecycle/snapshot/board.ts
+/** Max board characters injected — a persistent board should stay small; over-long boards are truncated. */
+const MAX_BOARD = 4e3;
+/**
+* Collect the persistent task board: the contents of `<root>/.claude/BOARD.md`
+* (truncated to {@link MAX_BOARD}) plus an instruction to keep it current. The
+* board lives on disk so it survives context purges — rehydrated every session.
+* Missing/empty/unreadable board → `""` (section omitted).
+* @param root - The project root.
+* @returns The rendered board section body, or `""` when there is no board.
+*/
+function collectBoard(root) {
+	const path = join(root, ".claude", "BOARD.md");
+	try {
+		if (!existsSync(path)) return "";
+		let body = readFileSync(path, "utf8").trim();
+		if (!body) return "";
+		if (body.length > MAX_BOARD) body = `${body.slice(0, MAX_BOARD)}\n… (truncated)`;
+		return `- .claude/BOARD.md (keep current — Write to it as tasks start/finish):\n\n${body}`;
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/snapshot/format.ts
+/**
+* Render the non-empty `sections` under one reconciliation heading. Empty
+* sections are dropped; when every section is empty the whole snapshot is `""`.
+* @param sections - The collected sections in display order.
+* @returns The assembled markdown block, or `""` when nothing to report.
+*/
+function renderSections(sections) {
+	const parts = sections.filter((s) => s.body.trim()).map((s) => `### ${s.title}\n${s.body.trim()}`);
+	if (!parts.length) return "";
+	return `# Reconciliation snapshot
+Real state of the world at session start — reconcile against this instead of re-discovering it.\n\n${parts.join("\n\n")}`;
+}
+/**
+* Concatenate `snapshot` onto an existing SessionStart stdout's
+* `additionalContext` — it never replaces prior injected context (CLAUDE.md,
+* dev-context). When `stdout` is empty a fresh {@link contextResponse} is made;
+* a non-empty but unparseable `stdout` is returned UNCHANGED (the snapshot is
+* dropped) — fabricating a fresh response there would discard the very CLAUDE.md
+* injection the invariant protects, so preserving prior context always wins.
+* @param stdout - The core SessionStart JSON stdout (may be `""`).
+* @param snapshot - The snapshot markdown to append (no-op when `""`).
+* @returns The merged hook stdout JSON.
+*/
+function attachSnapshot(stdout, snapshot) {
+	if (!snapshot) return stdout;
+	if (!stdout) return contextResponse("SessionStart", snapshot);
+	try {
+		const parsed = JSON.parse(stdout);
+		const prev = parsed.hookSpecificOutput?.additionalContext ?? "";
+		const merged = prev ? `${prev}\n\n${snapshot}` : snapshot;
+		return JSON.stringify({
+			...parsed,
+			hookSpecificOutput: {
+				...parsed.hookSpecificOutput,
+				hookEventName: "SessionStart",
+				additionalContext: merged
+			}
+		});
+	} catch {
+		return stdout;
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/snapshot/index.ts
+/** Run `fn`, swallowing any throw into `""` so no single collector can break the hook. */
+function safe(fn) {
+	try {
+		return fn();
+	} catch {
+		return "";
+	}
+}
+/**
+* Build the reconciliation snapshot markdown for `cwd`: git state, running
+* harness version + drift, the persistent board, and one-shot gate status. Each
+* collector is isolated by {@link safe}; an all-empty result yields `""`.
+* @param cwd - The session working directory.
+* @param moduleUrl - `import.meta.url` of the caller (locates the running package).
+* @returns The snapshot markdown, or `""` when nothing to report.
+*/
+function renderSnapshot(cwd, moduleUrl) {
+	const root = projectRootOrNull(cwd) ?? cwd;
+	return renderSections([
+		{
+			title: "Git",
+			body: safe(() => collectGit(root))
+		},
+		{
+			title: "Version",
+			body: safe(() => collectVersion(root, moduleUrl))
+		},
+		{
+			title: "Board",
+			body: safe(() => collectBoard(root))
+		},
+		{
+			title: "One-shot gates",
+			body: safe(() => oneShotSummary(cwd))
+		}
+	]);
+}
+/**
+* Concatenate the reconciliation snapshot onto a core SessionStart stdout. Fully
+* fail-safe: any error returns `stdout` unchanged so the hook never breaks.
+* @param stdout - The core SessionStart JSON stdout (may be `""`).
+* @param cwd - The session working directory.
+* @param moduleUrl - `import.meta.url` of the caller.
+* @returns The merged hook stdout.
+*/
+function withSnapshot(stdout, cwd, moduleUrl) {
+	try {
+		return attachSnapshot(stdout, renderSnapshot(cwd, moduleUrl));
+	} catch {
+		return stdout;
+	}
+}
+//#endregion
 //#region src/runtime/lifecycle/aipilot/inject-apex.ts
 /**
 * SubagentStart (matcher "") for the ai-pilot scope: inject APEX AGENTS.md +
@@ -3596,7 +4419,8 @@ function sessionStart(input) {
 	if (input.scope === "rules") return injectRules(process.env.CLAUDE_PLUGIN_ROOT ?? input.cwd);
 	if (input.scope === "carto") return cartoSessionStart(input.cwd, input.now);
 	if (input.scope === "lessons") return dispatchLessons("SessionStart", input.payload, input.cwd, input.now);
-	return sessionStartCore(input.cwd, void 0, input.now);
+	const core = sessionStartCore(input.cwd, void 0, input.now);
+	return input.scope === "core" ? withSnapshot(core, input.cwd, import.meta.url) : core;
 }
 /**
 * Route a lifecycle/session/context hook event to its ported handler. Returns
@@ -4984,73 +5808,6 @@ async function apexScopedGate(input, track, window) {
 	}
 }
 //#endregion
-//#region src/policy/deny-loop.ts
-/**
-* @module deny-loop
-* Pure anti-loop logic: hash a tool-call, decide if it repeats a prior deny, and
-* enrich the repeated block's message.
-*
-* The proprietary rule "NEVER propose the same fix twice" is prose a model under
-* pressure ignores. This makes it machine-enforced: when a call whose
-* `(tool + normalized input)` hash was ALREADY denied in-window is retried, the
-* harness keeps the deny but rewrites the message — `[REPEAT]` title, STOP
-* prefix, forced `research-expert` action. State + wiring live in the sidecar
-* store ({@link module:deny-loop-store}); this file is IO-free and pure.
-* @packageDocumentation
-*/
-/** Stable JSON: keys sorted at every depth so `{a,b}` and `{b,a}` hash identically. */
-function stableStringify(v) {
-	if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
-	if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`;
-	const o = v;
-	return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`).join(",")}}`;
-}
-/**
-* Stable identity hash of a tool-call = tool name + normalized (key-sorted) input,
-* so re-ordered keys never mask a repeat.
-* @param tool - Tool name (e.g. "Write", "Bash").
-* @param input - Identifying tool input (filePath/content/command...).
-* @returns 8-char hex hash.
-*/
-function denyHash(tool, input) {
-	return hashText(`${tool}\n${stableStringify(input)}`);
-}
-/**
-* Pure loop check: given the already-pruned in-window map, compute the running
-* count for `hash` and whether it repeats (count > 1). No IO — the caller persists.
-* @param hash - {@link denyHash} of the current call.
-* @param priorDenies - The `{ hash -> DenyEntry }` map, pruned to `now`/`windowMs`.
-* @param opts - Clock + window.
-* @returns `{ isRepeat, count, hash }`.
-*/
-function denyLoopCheck(hash, priorDenies, opts) {
-	const prev = priorDenies[hash];
-	const count = (prev && typeof prev.lastTs === "number" && opts.now - prev.lastTs < opts.windowMs ? prev.count : 0) + 1;
-	return {
-		isRepeat: count > 1,
-		count,
-		hash
-	};
-}
-/**
-* Enrich a REPEATED block prompt — a NEW object, never a mutation (the input may
-* be a shared const like FAIL_CLOSED). The decision stays `block`; only the
-* message changes, so every harness renders it through the same adapter.
-* @param prompt - The original block prompt.
-* @param count - The running identical-deny count (n).
-* @returns A block prompt with `[REPEAT]` title, STOP-prefixed reason, forced research action.
-*/
-function enrichRepeatDeny(prompt, count) {
-	const stop = `Tentative identique n°${count} déjà refusée pour la même raison. STOP: ne retente pas ce même appel. `;
-	const action = "Launch fuse-ai-pilot:research-expert to find a DIFFERENT approach";
-	return {
-		...prompt,
-		title: prompt.title.startsWith("[REPEAT]") ? prompt.title : `[REPEAT] ${prompt.title}`,
-		reason: stop + prompt.reason,
-		actions: [action, ...prompt.actions ?? []]
-	};
-}
-//#endregion
 //#region src/runtime/deny-loop-store.ts
 /**
 * @module deny-loop-store
@@ -5138,18 +5895,25 @@ const DEFAULT_WINDOW_MS = 12e4;
 /** Trivial edits allowed within the window before the full APEX gates apply. */
 const TRIVIAL_BUDGET = 4;
 /**
-* Full gate: {@link runGates} yields the first blocking prompt (or null); the
-* anti-loop tail ({@link withDenyLoop}) rewrites an identical retried deny's
-* message (decision unchanged). Sidecar dir = the track's dir (tests off `$HOME`).
+* Full gate: {@link runGates} yields the first blocking prompt (or null); the tail
+* records the one-shot metric ({@link recordOneShot}, observation-only) then lets
+* {@link withDenyLoop} rewrite an identical retried deny (decision unchanged).
 */
 async function gate(input) {
-	return withDenyLoop(await runGates(input), input.tool, {
+	const prompt = await runGates(input);
+	const op = {
 		filePath: input.filePath,
 		content: input.content,
 		command: input.command
-	}, {
+	};
+	const dir = dirname(input.trackFile);
+	recordOneShot(prompt, op, {
+		now: input.now,
+		dir
+	});
+	return withDenyLoop(prompt, input.tool, op, {
 		now: input.now,
-		dir: dirname(input.trackFile),
+		dir,
 		windowMs: input.windowMs ?? 12e4
 	});
 }
@@ -5276,7 +6040,7 @@ function docSourceOf$1(tool) {
 function cacheHitText(web, hit) {
 	const kb = Math.floor(hit.body.length / 1024) + 1;
 	const hours = Math.floor(hit.ageMs / 36e5);
-	return web ? `CACHE HIT WebFetch (~${kb}KB economise, cached il y a ${hours}h):\n\n${hit.body}\n\nPour forcer un nouveau fetch, modifie l'URL ou la query.` : `CACHE HIT (~${kb}KB economise, cached il y a ${hours}h): ${hit.body}\n\nReformule pour forcer un re-call.`;
+	return web ? `CACHE HIT WebFetch (~${kb}KB saved, cached ${hours}h ago):\n\n${hit.body}\n\nModify the URL or query to force a fresh fetch.` : `CACHE HIT (~${kb}KB saved, cached ${hours}h ago): ${hit.body}\n\nRephrase to force a re-call.`;
 }
 /**
 * Pre-event MCP interception: serve a fresh cache hit (deny + cached content),
@@ -6420,4 +7184,4 @@ async function handleHook(id, payload, opts) {
 	});
 }
 //#endregion
-export { saveApexState as $, trackSkillRead as A, saveSecurityState as At, writePluginMap as B, seoPostToolUse as C, taskContext as Ct, postTrackingSideEffects as D, normalizeEvent as Dt, securityAdvisory as E, trackFile as Et, dispatchLessons as F, mergeLines as G, isProject as H, lessonsFileFor as I, listChildren as J, countFiles as K, lessonsStateFileFor as L, dispatchLifecycle as M, securityStatePath as Mt, aipilotPostToolUse as N, todayUtc as Nt, trackWatchResearch as O, isoUtc as Ot, dispatchAipilot as P, cleanupSession as Q, cartoSessionStart as R, postEditContext as S, promptSubmitContext as St, dispatchMemory as T, projectHash$1 as Tt, writeTree as U, generateProjectMap as V, loadEnriched as W, trackSessionChanges as X, postEditTypescript as Y, validateRulesLoaded as Z, preCommitGate as _, trimLogFile as _t, recordActivity as a, validateSolidGate as at, extractSymbols as b, projectContext as bt, MCP_TTL_MS as c, detectSolidProfile as ct, isMcpTool as d, readRules as dt, logToolFailure as et, queryOf as f, runSessionStartCleanups as ft, gate as g, removeOldFiles as gt, TRIVIAL_BUDGET as h, purgeTtlTree as ht, respond as i, validateTailwind as it, trackEnrichment as j, securityStateDir as jt, trackMcpResearch as k, loadSecurityState as kt, WEBFETCH_TTL_MS as l, solidDetectStart as lt, REQUIRED_AGENTS as m, pruneEmptyDirs as mt, activityFor as n, trackAgentMemory as nt, mcpPostStore as o, checkFileSize as ot, DEFAULT_WINDOW_MS as p, sessionStartCore as pt, getFileDesc as q, handlePre as r, subagentCacheContext as rt, mcpPreIntercept as s, countLoc as st, handleHook as t, validateTeammateOutput as tt, cacheQueryOf as u, injectRules as ut, detectDuplication as v, devContext as vt, seoPostToolUseResponse as w, defaultStateDir as wt, lifecycleStdout as x, claudeMdKey as xt, dryGate as y, gitContext as yt, generateEcosystemMap as z };
+export { postEditTypescript as $, trackSkillRead as A, trackFile as At, lessonsFileFor as B, seoPostToolUse as C, gitContext as Ct, postTrackingSideEffects as D, taskContext as Dt, securityAdvisory as E, promptSubmitContext as Et, runDoctor as F, securityStateDir as Ft, generateProjectMap as G, cartoSessionStart as H, runningVersion as I, securityStatePath as It, loadEnriched as J, isProject as K, versionBanner as L, todayUtc as Lt, dispatchLifecycle as M, isoUtc as Mt, aipilotPostToolUse as N, loadSecurityState as Nt, trackWatchResearch as O, defaultStateDir as Ot, dispatchAipilot as P, saveSecurityState as Pt, listChildren as Q, dispatchLessons as R, postEditContext as S, devContext as St, dispatchMemory as T, claudeMdKey as Tt, generateEcosystemMap as U, lessonsStateFileFor as V, writePluginMap as W, countFiles as X, mergeLines as Y, getFileDesc as Z, preCommitGate as _, sessionStartCore as _t, recordActivity as a, validateTeammateOutput as at, extractSymbols as b, removeOldFiles as bt, MCP_TTL_MS as c, validateTailwind as ct, isMcpTool as d, countLoc as dt, trackSessionChanges as et, queryOf as f, detectSolidProfile as ft, gate as g, runSessionStartCleanups as gt, TRIVIAL_BUDGET as h, readRules as ht, respond as i, logToolFailure as it, trackEnrichment as j, normalizeEvent as jt, trackMcpResearch as k, projectHash$1 as kt, WEBFETCH_TTL_MS as l, validateSolidGate as lt, REQUIRED_AGENTS as m, injectRules as mt, activityFor as n, cleanupSession as nt, mcpPostStore as o, trackAgentMemory as ot, DEFAULT_WINDOW_MS as p, solidDetectStart as pt, writeTree as q, handlePre as r, saveApexState as rt, mcpPreIntercept as s, subagentCacheContext as st, handleHook as t, validateRulesLoaded as tt, cacheQueryOf as u, checkFileSize as ut, detectDuplication as v, pruneEmptyDirs as vt, seoPostToolUseResponse as w, projectContext as wt, lifecycleStdout as x, trimLogFile as xt, dryGate as y, purgeTtlTree as yt, lessonsArchiveFileFor as z };