@fusengine/harness 0.1.53 → 0.1.55

package/dist/cli/bin.mjs

@@ -4,7 +4,7 @@ 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 { F as runDoctor, I as runningVersion, It as todayUtc, L as versionBanner, t as handleHook } from "../handle-D93-VIGS.mjs";
+import { F as runDoctor, I as runningVersion, L as versionBanner, Lt as todayUtc, t as handleHook } from "../handle-L4ZNmpwN.mjs";
 import { delimiter, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";

package/dist/{handle-D93-VIGS.mjs → handle-L4ZNmpwN.mjs}

@@ -903,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 |",
 		"| --- | --- | --- |"
@@ -1233,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())}`;
 }
@@ -1250,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 });
@@ -1292,6 +1292,28 @@ function validateRulesLoaded(data, home = homedir()) {
 	} catch {}
 }
 //#endregion
+//#region src/runtime/burst-window.ts
+/**
+* @module burst-window
+* Single source of truth for the multi-plugin hook fan-out window.
+*
+* Every DEPLOYED plugin registers its OWN PreToolUse/PostToolUse hook, so ONE
+* Claude tool event spawns ~11 sibling harness processes that each record the
+* same deny / one-shot / sniper reminder within milliseconds. Left unchecked
+* the deny-loop counter jumped by ~11 per real attempt ([REPEAT] "#9" on the
+* FIRST try), the one-shot metric inflated ~11×, and the sniper reminder was
+* injected ~11× (token noise).
+*
+* A record landing within this window after an identical prior one (same
+* operation hash + same `session_id`) is treated as the SAME event and folded
+* into it instead of re-counted. Two REAL agent retries are always spaced
+* further apart than the burst, so this never masks a genuine loop. No env var:
+* the fan-out is a physical property of the installed plugin set, not policy.
+* @packageDocumentation
+*/
+/** Fan-out dedup window (ms). The ~11 sibling hooks for one event land in <2s. */
+const BURST_DEDUP_MS = 2e3;
+//#endregion
 //#region src/runtime/lifecycle/track-changes.ts
 /** Code-file extensions tracked for sniper (mirrors track-session-changes.py). */
 const CODE_EXT$1 = /\.(ts|tsx|js|jsx|py|go|rs|java|php|cpp|c|rb|swift|kt|vue|svelte|astro)$/;
@@ -1326,6 +1348,10 @@ function trackSessionChanges(sessionIdRaw, filePath, home = homedir(), now = Dat
 		lastCheck: new Date(now).toISOString().replace(/\.\d{3}Z$/, "Z")
 	};
 	saveSessionState(sid, state, home);
+	if (!oncePerWindow(`sniper:${sid}:${filePath}`, 2e3, {
+		now,
+		dir: sessionsDir(home)
+	})) return "";
 	return contextResponse("PostToolUse", `SNIPER VALIDATION REQUIRED: Code file '${basename(filePath)}' was modified. You MUST now run the sniper agent (fuse-ai-pilot:sniper) to validate this modification before continuing. This is mandatory per CLAUDE.md rules.`);
 }
 //#endregion
@@ -2136,16 +2162,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) {
@@ -2172,7 +2192,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 = [];
@@ -2193,23 +2217,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) {
@@ -2224,20 +2314,91 @@ 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();
+}
+/**
+* Distil the actionable rule from a bullet body. With no "→" the whole bullet is
+* the rule → its first sentence. Otherwise the rule is everything after the FIRST
+* "→"; among its arrow-delimited segments (trimmed, empty dropped) take the first
+* sentence of the LONGEST — the information-dense clause, not whichever short
+* aside the author appended last. When that clause is under {@link MIN_RULE}
+* chars, fall back to the first sentence of the WHOLE rule part (never the
+* narrative), so a short trailing segment never yields an illegible stub yet a
+* legitimately terse rule is still shown intact.
+*/
+function distillRule(text) {
+	const arrow = text.indexOf("→");
+	if (arrow < 0) return firstSentence(text);
+	const rulePart = text.slice(arrow + 1);
+	const rule = firstSentence(rulePart.split("→").map((s) => s.trim()).filter(Boolean).reduce((a, b) => b.length > a.length ? b : a, ""));
+	return rule.length >= 40 ? rule : firstSentence(rulePart);
+}
+/** Collapse one older bullet to `- [date] <rule>`: {@link distillRule}, capped. */
+function compressBullet(block) {
+	let rule = distillRule(bodyText(block));
+	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
 /**
@@ -2251,6 +2412,10 @@ 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");
@@ -2419,7 +2584,32 @@ function markWrite(payload, now) {
 * 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). */
+/**
+* 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);
@@ -2431,12 +2621,9 @@ function injectMemory(cwd, event, now) {
 		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.`;
+	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);
 }
 /**
@@ -2495,14 +2682,32 @@ function denyHash(tool, 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.
+*
+* When `dedupMs` is set (>0) and an identical prior deny landed within that
+* window, the current call is a sibling hook echoing the SAME event (see
+* {@link module:burst-window}): it returns the prior verdict VERBATIM with
+* `deduped:true` and does NOT bump the count, so all N fan-out processes agree
+* on one number instead of counting to N. Absent `dedupMs` (mono-process
+* callers / unit tests) the historical increment-every-time behaviour holds.
+* @param hash - {@link denyHash}-derived map key of the current call.
 * @param priorDenies - The `{ hash -> DenyEntry }` map, pruned to `now`/`windowMs`.
-* @param opts - Clock + window.
-* @returns `{ isRepeat, count, hash }`.
+* @param opts - Clock + window, plus an optional burst-dedup window.
+* @returns `{ isRepeat, count, hash, deduped? }`.
 */
 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;
+	if (!(prev && typeof prev.lastTs === "number" && opts.now - prev.lastTs < opts.windowMs)) return {
+		isRepeat: false,
+		count: 1,
+		hash
+	};
+	if ((opts.dedupMs ?? 0) > 0 && opts.now - prev.lastTs < (opts.dedupMs ?? 0)) return {
+		isRepeat: prev.count > 1,
+		count: prev.count,
+		hash,
+		deduped: true
+	};
+	const count = prev.count + 1;
 	return {
 		isRepeat: count > 1,
 		count,
@@ -2518,7 +2723,7 @@ function denyLoopCheck(hash, priorDenies, opts) {
 * @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 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,
@@ -2636,6 +2841,39 @@ function formatSummary(s) {
 	return `gates 7d: ${head}${parts.length ? `; ${parts.join("; ")}` : ""}`;
 }
 //#endregion
+//#region src/tracking/one-shot-dedup.ts
+/**
+* @module one-shot-dedup
+* Burst-dedup guard for the one-shot metric ({@link module:one-shot}).
+*
+* ONE Claude tool event fans out to ~11 sibling plugin-hook processes, each
+* calling {@link recordOneShot}; without this the metric would count a single
+* deny/allow ~11×. Reuses the proven {@link oncePerWindow} cooldown sidecar:
+* the FIRST process in the {@link module:burst-window} window mutates the
+* metric, the rest skip. The dedup key includes the outcome KIND (deny-title vs
+* allow) so a deny and its later fix — different kinds — are never folded into
+* each other. No `sessionId` → always the first (mono-process + unit-test
+* parity; a burst can only exist when a real session drives the fan-out).
+* @packageDocumentation
+*/
+/**
+* True when this `(op, kind)` is the FIRST of its burst for the session — the
+* process that should actually mutate the metric. Sibling processes firing the
+* SAME event within {@link BURST_DEDUP_MS} return false and skip the write.
+* @param op - Content-free operation key ({@link denyHash}("op", …)).
+* @param kind - Outcome discriminator (`deny:<title>` or `allow`).
+* @param opts - Clock + state dir + optional session id.
+* @returns `true` to apply the record, `false` to skip (already counted).
+*/
+function burstFirst(op, kind, opts) {
+	const sid = opts.sessionId?.trim();
+	if (!sid) return true;
+	return oncePerWindow(`oneshot:${sid}:${op}:${kind}`, BURST_DEDUP_MS, {
+		now: opts.now,
+		dir: opts.dir
+	});
+}
+//#endregion
 //#region src/tracking/one-shot.ts
 /**
 * @module one-shot
@@ -2683,12 +2921,13 @@ function loadState(path) {
 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
 		});
+		if (!burstFirst(op, prompt ? `deny:${prompt.title}` : "allow", opts)) return;
+		const path = join(opts.dir, SIDECAR$1);
+		let s = pruneState(loadState(path), opts.now, WINDOW_MS);
 		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 {}
@@ -5708,17 +5947,28 @@ function prune(map, now, windowMs) {
 */
 function recordDeny(tool, input, opts) {
 	const hash = denyHash(tool, input);
+	const sid = opts.sessionId?.trim();
+	const key = sid ? `${hash}::${sid}` : hash;
 	const path = join(opts.dir, SIDECAR);
 	const map = prune(loadMap(path), opts.now, opts.windowMs);
-	const res = denyLoopCheck(hash, map, opts);
-	map[hash] = {
-		count: res.count,
-		lastTs: opts.now
+	const res = denyLoopCheck(key, map, {
+		now: opts.now,
+		windowMs: opts.windowMs,
+		dedupMs: sid ? BURST_DEDUP_MS : 0
+	});
+	if (!res.deduped) {
+		map[key] = {
+			count: res.count,
+			lastTs: opts.now
+		};
+		try {
+			atomicWrite(path, JSON.stringify(map));
+		} catch {}
+	}
+	return {
+		...res,
+		hash
 	};
-	try {
-		atomicWrite(path, JSON.stringify(map));
-	} catch {}
-	return res;
 }
 /**
 * Gate tail: record every block deny; on a repeat, return the enriched prompt.
@@ -5763,12 +6013,14 @@ async function gate(input) {
 	const dir = dirname(input.trackFile);
 	recordOneShot(prompt, op, {
 		now: input.now,
-		dir
+		dir,
+		sessionId: input.sessionId
 	});
 	return withDenyLoop(prompt, input.tool, op, {
 		now: input.now,
 		dir,
-		windowMs: input.windowMs ?? 12e4
+		windowMs: input.windowMs ?? 12e4,
+		sessionId: input.sessionId
 	});
 }
 /** Stateless guards, then the trivial fast path, then the stateful APEX gates. */
@@ -5894,7 +6146,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),
@@ -7038,4 +7290,4 @@ async function handleHook(id, payload, opts) {
 	});
 }
 //#endregion
-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 };
+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 };

package/dist/runtime/index.d.mts

@@ -692,6 +692,8 @@ declare function dispatchLessons(event: string, payload: Record<string, unknown>
 //#region src/runtime/lifecycle/lessons/state.d.ts
 /** Absolute `<root>/MEMORY/LESSON.md` — the curated, committable lessons file. */
 declare function lessonsFileFor(root: string): string;
+/** Absolute `<root>/MEMORY/LESSON-archive.md` — cold storage for capped-out bullets. */
+declare function lessonsArchiveFileFor(root: string): string;
 /** Absolute `<root>/MEMORY/state.json` — machine-local throttle counter. */
 declare function lessonsStateFileFor(root: string): string;
 //#endregion
@@ -826,4 +828,4 @@ interface PreContext {
 */
 declare function handlePre(ctx: PreContext): Promise<HandleOutcome>;
 //#endregion
-export { Activity, DEFAULT_WINDOW_MS, DuplicationVerdict, type GateInput, HandleOptions, HandleOutcome, LifecycleInput, MCP_TTL_MS, McpIntercept, NormalizedEvent, PluginScope, PreContext, REQUIRED_AGENTS, SolidProfile, TRIVIAL_BUDGET, ToolEvent, WEBFETCH_TTL_MS, activityFor, aipilotPostToolUse, cacheQueryOf, cartoSessionStart, checkFileSize, claudeHome, claudeMdKey, cleanupSession, countFiles, countLoc, defaultStateDir, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLessons, dispatchLifecycle, dispatchMemory, dryGate, extractSymbols, fuseHarnessHome, fusengineCache, gate, generateEcosystemMap, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lessonsFileFor, lessonsStateFileFor, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, projectHash, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, seoPostToolUse, seoPostToolUseResponse, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateSolidGate, validateTailwind, validateTeammateOutput, writePluginMap, writeTree };
+export { Activity, DEFAULT_WINDOW_MS, DuplicationVerdict, type GateInput, HandleOptions, HandleOutcome, LifecycleInput, MCP_TTL_MS, McpIntercept, NormalizedEvent, PluginScope, PreContext, REQUIRED_AGENTS, SolidProfile, TRIVIAL_BUDGET, ToolEvent, WEBFETCH_TTL_MS, activityFor, aipilotPostToolUse, cacheQueryOf, cartoSessionStart, checkFileSize, claudeHome, claudeMdKey, cleanupSession, countFiles, countLoc, defaultStateDir, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLessons, dispatchLifecycle, dispatchMemory, dryGate, extractSymbols, fuseHarnessHome, fusengineCache, gate, generateEcosystemMap, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lessonsArchiveFileFor, lessonsFileFor, lessonsStateFileFor, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, projectHash, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, seoPostToolUse, seoPostToolUseResponse, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateSolidGate, validateTailwind, validateTeammateOutput, writePluginMap, writeTree };

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusengine/harness",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "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",