@fusengine/harness 0.1.52 → 0.1.53

package/dist/cli/bin.mjs

@@ -4,11 +4,10 @@ import { t as detectHarness } from "../harness-Cb9xR8dC.mjs";
 import { t as claudeHome } from "../home-state-D0RLWP8J.mjs";
 import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-DZvP_9xB.mjs";
 import { n as writeInitFile, t as initFor } from "../run-Do2JltgU.mjs";
-import { Nt as todayUtc, t as handleHook } from "../handle-QfgfNSh6.mjs";
-import { delimiter, dirname, join } from "node:path";
+import { F as runDoctor, I as runningVersion, It as todayUtc, L as versionBanner, t as handleHook } from "../handle-D93-VIGS.mjs";
+import { delimiter, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
 //#region src/changelog/fetch.ts
 /**
 * Changelog scanner — ports the changelog-watcher plugin's `fetch-changelog`
@@ -354,90 +353,6 @@ function discoverRefs(home, cwd, marketplaces) {
 	return [...bySkill.values()].join(delimiter);
 }
 //#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/cli/bin.ts
 /**
 * harness — CLI for @fusengine/harness.

package/dist/{handle-QfgfNSh6.mjs → handle-D93-VIGS.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;
 }
@@ -2255,35 +2256,107 @@ 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 +2368,77 @@ 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.
+*/
+/** 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 = "";
+	try {
+		content = readFileSync(file, "utf-8").trim();
+	} catch {
+		return "";
+	}
+	if (!content) return "";
+	const { content: curated, report } = curateLessons(content, now, root);
+	if (curated !== content) try {
+		atomicWrite(file, curated);
+		content = curated;
+	} 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);
+}
 /**
 * Route a fuse-lessons event to its handler. Returns the native stdout for
 * context-injecting events (SessionStart/SubagentStart/Stop) or "" for the
@@ -2329,7 +2453,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 +2461,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 = `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/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 +4273,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 +5662,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 +5749,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
 	});
 }
@@ -6420,4 +7038,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 { trackSessionChanges as $, trackSkillRead as A, normalizeEvent as At, lessonsStateFileFor as B, seoPostToolUse as C, projectContext as Ct, postTrackingSideEffects as D, defaultStateDir as Dt, securityAdvisory as E, taskContext as Et, runDoctor as F, securityStatePath as Ft, isProject as G, generateEcosystemMap as H, runningVersion as I, todayUtc as It, mergeLines as J, writeTree as K, versionBanner as L, dispatchLifecycle as M, loadSecurityState as Mt, aipilotPostToolUse as N, saveSecurityState as Nt, trackWatchResearch as O, projectHash$1 as Ot, dispatchAipilot as P, securityStateDir as Pt, postEditTypescript as Q, dispatchLessons as R, postEditContext as S, gitContext as St, dispatchMemory as T, promptSubmitContext as Tt, writePluginMap as U, cartoSessionStart as V, generateProjectMap as W, getFileDesc as X, countFiles as Y, listChildren as Z, preCommitGate as _, pruneEmptyDirs as _t, recordActivity as a, trackAgentMemory as at, extractSymbols as b, trimLogFile as bt, MCP_TTL_MS as c, validateSolidGate as ct, isMcpTool as d, detectSolidProfile as dt, validateRulesLoaded as et, queryOf as f, solidDetectStart as ft, gate as g, sessionStartCore as gt, TRIVIAL_BUDGET as h, runSessionStartCleanups as ht, respond as i, validateTeammateOutput as it, trackEnrichment as j, isoUtc as jt, trackMcpResearch as k, trackFile as kt, WEBFETCH_TTL_MS as l, checkFileSize as lt, REQUIRED_AGENTS as m, readRules as mt, activityFor as n, saveApexState as nt, mcpPostStore as o, subagentCacheContext as ot, DEFAULT_WINDOW_MS as p, injectRules as pt, loadEnriched as q, handlePre as r, logToolFailure as rt, mcpPreIntercept as s, validateTailwind as st, handleHook as t, cleanupSession as tt, cacheQueryOf as u, countLoc as ut, detectDuplication as v, purgeTtlTree as vt, seoPostToolUseResponse as w, claudeMdKey as wt, lifecycleStdout as x, devContext as xt, dryGate as y, removeOldFiles as yt, lessonsFileFor as z };

package/dist/runtime/index.d.mts

@@ -116,9 +116,9 @@ declare const DEFAULT_WINDOW_MS = 12e4;
 /** Trivial edits allowed within the window before the full APEX gates apply. */
 declare 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).
 */
 declare function gate(input: GateInput): Promise<Prompt | null>;
 //#endregion

package/dist/runtime/index.mjs

@@ -1,6 +1,6 @@
 import { r as projectLayout } from "../layout-C0jaaCQC.mjs";
 import { a as sanitizeSessionId, c as sessionsDir, i as loadSessionState, n as fuseHarnessHome, o as saveSessionState, r as fusengineCache, s as sessionStatePath, t as claudeHome } from "../home-state-D0RLWP8J.mjs";
-import { $ as saveApexState, A as trackSkillRead, At as saveSecurityState, B as writePluginMap, C as seoPostToolUse, Ct as taskContext, D as postTrackingSideEffects, Dt as normalizeEvent, E as securityAdvisory, Et as trackFile, F as dispatchLessons, G as mergeLines, H as isProject, I as lessonsFileFor, J as listChildren, K as countFiles, L as lessonsStateFileFor, M as dispatchLifecycle, Mt as securityStatePath, N as aipilotPostToolUse, Nt as todayUtc, O as trackWatchResearch, Ot as isoUtc, P as dispatchAipilot, Q as cleanupSession, R as cartoSessionStart, S as postEditContext, St as promptSubmitContext, T as dispatchMemory, Tt as projectHash, U as writeTree, V as generateProjectMap, W as loadEnriched, X as trackSessionChanges, Y as postEditTypescript, Z as validateRulesLoaded, _ as preCommitGate, _t as trimLogFile, a as recordActivity, at as validateSolidGate, b as extractSymbols, bt as projectContext, c as MCP_TTL_MS, ct as detectSolidProfile, d as isMcpTool, dt as readRules, et as logToolFailure, f as queryOf, ft as runSessionStartCleanups, g as gate, gt as removeOldFiles, h as TRIVIAL_BUDGET, ht as purgeTtlTree, i as respond, it as validateTailwind, j as trackEnrichment, jt as securityStateDir, k as trackMcpResearch, kt as loadSecurityState, l as WEBFETCH_TTL_MS, lt as solidDetectStart, m as REQUIRED_AGENTS, mt as pruneEmptyDirs, n as activityFor, nt as trackAgentMemory, o as mcpPostStore, ot as checkFileSize, p as DEFAULT_WINDOW_MS, pt as sessionStartCore, q as getFileDesc, r as handlePre, rt as subagentCacheContext, s as mcpPreIntercept, st as countLoc, t as handleHook, tt as validateTeammateOutput, u as cacheQueryOf, ut as injectRules, v as detectDuplication, vt as devContext, w as seoPostToolUseResponse, wt as defaultStateDir, x as lifecycleStdout, xt as claudeMdKey, y as dryGate, yt as gitContext, z as generateEcosystemMap } from "../handle-QfgfNSh6.mjs";
+import { $ as trackSessionChanges, A as trackSkillRead, At as normalizeEvent, B as lessonsStateFileFor, C as seoPostToolUse, Ct as projectContext, D as postTrackingSideEffects, Dt as defaultStateDir, E as securityAdvisory, Et as taskContext, Ft as securityStatePath, G as isProject, H as generateEcosystemMap, It as todayUtc, J as mergeLines, K as writeTree, M as dispatchLifecycle, Mt as loadSecurityState, N as aipilotPostToolUse, Nt as saveSecurityState, O as trackWatchResearch, Ot as projectHash, P as dispatchAipilot, Pt as securityStateDir, Q as postEditTypescript, R as dispatchLessons, S as postEditContext, St as gitContext, T as dispatchMemory, Tt as promptSubmitContext, U as writePluginMap, V as cartoSessionStart, W as generateProjectMap, X as getFileDesc, Y as countFiles, Z as listChildren, _ as preCommitGate, _t as pruneEmptyDirs, a as recordActivity, at as trackAgentMemory, b as extractSymbols, bt as trimLogFile, c as MCP_TTL_MS, ct as validateSolidGate, d as isMcpTool, dt as detectSolidProfile, et as validateRulesLoaded, f as queryOf, ft as solidDetectStart, g as gate, gt as sessionStartCore, h as TRIVIAL_BUDGET, ht as runSessionStartCleanups, i as respond, it as validateTeammateOutput, j as trackEnrichment, jt as isoUtc, k as trackMcpResearch, kt as trackFile, l as WEBFETCH_TTL_MS, lt as checkFileSize, m as REQUIRED_AGENTS, mt as readRules, n as activityFor, nt as saveApexState, o as mcpPostStore, ot as subagentCacheContext, p as DEFAULT_WINDOW_MS, pt as injectRules, q as loadEnriched, r as handlePre, rt as logToolFailure, s as mcpPreIntercept, st as validateTailwind, t as handleHook, tt as cleanupSession, u as cacheQueryOf, ut as countLoc, v as detectDuplication, vt as purgeTtlTree, w as seoPostToolUseResponse, wt as claudeMdKey, x as lifecycleStdout, xt as devContext, y as dryGate, yt as removeOldFiles, z as lessonsFileFor } from "../handle-D93-VIGS.mjs";
 //#region src/runtime/storage.ts
 /**
 * The project's single state dir (`<root>/.harness`) — neutral + harness-agnostic,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusengine/harness",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "description": "Harness-agnostic toolkit for AI coding agents: runtime harness detection (Claude Code, Codex, Cursor, Cline, Gemini, Aider...), pure policy core (env config, project/framework detection, SOLID/file-size limits, APEX freshness, guard patterns, portable prompts), cache, project memory, ref routing, state/locks, statusline, per-harness adapters (Claude/Cursor/Cline/Gemini) and a cli-mode harness-check binary. Bun-native, with a built dist for Node + bundlers.",
   "type": "module",
   "module": "src/index.ts",