@fusengine/harness 0.1.54 → 0.1.56

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

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

@@ -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
@@ -2334,11 +2360,35 @@ function bodyText(block) {
 function firstSentence(s) {
 	return (s.split(/(?<=\.)\s/)[0] ?? s).trim();
 }
-/** Collapse one older bullet to `- [date] <rule>`: first sentence after last "→", capped. */
+/**
+* The bullet's `narrative → rule` delimiter: a SPACED arrow only. A GLUED arrow
+* between tokens (e.g. `120s→300s`, `s→3`) is prose the author wrote, never a
+* delimiter — matching on `→` alone chopped rules mid-token (bug: `300s) pensant
+* corriger…`). Also used to split rule-internal clauses.
+*/
+const RULE_ARROW = /\s+→\s+/;
+/**
+* Distil the actionable rule from a bullet body. With no spaced arrow the whole
+* bullet is the rule → its first sentence. Otherwise the rule is everything after
+* the FIRST spaced arrow; its spaced-arrow-delimited segments are kept whole
+* except for TRAILING short asides (< {@link MIN_RULE} chars, e.g. `→ (cf.
+* lecture).`) which are dropped — so an arrow used as PROSE inside a rule (`maps
+* X → Y doit…`) is preserved intact rather than chopped at the arrow. When the
+* kept rule is still under {@link MIN_RULE} chars, fall back to the first sentence
+* of the WHOLE rule part (never the narrative), avoiding an illegible stub.
+*/
+function distillRule(text) {
+	const sep = text.search(RULE_ARROW);
+	if (sep < 0) return firstSentence(text);
+	const rulePart = text.slice(sep).replace(RULE_ARROW, "").trim();
+	const segments = rulePart.split(RULE_ARROW).map((s) => s.trim()).filter(Boolean);
+	while (segments.length > 1 && (segments[segments.length - 1]?.length ?? 0) < 40) segments.pop();
+	const rule = firstSentence(segments.join(" → "));
+	return rule.length >= 40 ? rule : firstSentence(rulePart);
+}
+/** Collapse one older bullet to `- [date] <rule>`: {@link distillRule}, capped. */
 function compressBullet(block) {
-	const text = bodyText(block);
-	const arrow = text.lastIndexOf("→");
-	let rule = firstSentence((arrow >= 0 ? text.slice(arrow + 1) : text).trim());
+	let rule = distillRule(bodyText(block));
 	if (rule.length > 200) rule = `${rule.slice(0, 199).trimEnd()}…`;
 	const date = stamp(block);
 	return `- ${date ? `[${date}] ` : ""}${rule}`;
@@ -2641,14 +2691,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,
@@ -2782,6 +2850,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
@@ -2829,12 +2930,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 {}
@@ -5494,6 +5596,50 @@ function frameworkSkillGate(input, refsRead, existingCodeLines) {
 	return skillTriggerGate(input.framework, content, refsRead, forced, input.cwd, input.filePath);
 }
 //#endregion
+//#region src/freshness/ref-evidence.ts
+/**
+* Platform-transcript reconciliation for `.md` reference reads — the durable
+* counterpart to {@link agentsRanFromTranscript} for agent freshness.
+*
+* WHY: the session track is persisted by a non-atomic load→mutate→save. Under
+* the multi-plugin hook fan-out (one hook process per installed plugin, ×N) plus
+* back-to-back tool events, concurrent writers clobber each other (lost update).
+* `agents`/`authorizations` self-heal — every explore/research/doc call rewrites
+* them, so a lost update lands again on the next of hundreds of writes — but a
+* `refsRead` entry is written ONCE (when the `.md` is Read), so a single lost
+* update erases it permanently, and the lead has no SubagentStop
+* {@link harvestAgentEvidence} pass to reconcile it (sub-agents do, which is why
+* only the LEAD's solidReadGate never credited). The Claude-authored transcript
+* is append-only and race-immune, so folding its `.md` Reads back into the track
+* restores the lost evidence; each gate still applies its own TTL/session policy.
+*/
+/**
+* Fold every `.md` `Read` in the transcript into `track` as a timestamped ref
+* read (immutably). PURE reconciliation — the caller owns the track; each read
+* is stamped with its transcript timestamp (unstamped → `now`, lenient, matching
+* {@link agentsRanFromTranscript}), and an existing MORE-recent stamp is never
+* rolled back. Fail-open: an absent/unreadable transcript returns `track`
+* unchanged (same reference).
+* @param track - The current (possibly race-damaged) session track.
+* @param transcriptPath - Claude `transcript_path` for this session.
+* @param now - Fallback epoch-ms for transcript entries the platform left unstamped.
+* @returns The track with transcript `.md` reads merged into `refsRead`/`refsReadAt`.
+*/
+function reconcileRefReadsFromTranscript(track, transcriptPath, now) {
+	const uses = readAgentToolUses(transcriptPath);
+	if (!uses) return track;
+	let next = track;
+	for (const u of uses) {
+		if (u.name !== "Read") continue;
+		const path = String(u.input?.file_path ?? u.input?.path ?? "");
+		if (!path.endsWith(".md")) continue;
+		const ts = u.ts ?? now;
+		const prev = next.refsReadAt?.[path];
+		if (prev === void 0 || prev < ts) next = recordRefRead(next, path, ts);
+	}
+	return next;
+}
+//#endregion
 //#region src/policy/shadcn-skill-gate.ts
 /** File extensions the shadcn gate polices (source: `\.(tsx|jsx|css|scss|json)$`). */
 const SHADCN_FILE_RE = /\.(tsx|jsx|css|scss|json)$/;
@@ -5854,17 +6000,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.
@@ -5909,12 +6066,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. */
@@ -5942,8 +6101,7 @@ async function runGates(input) {
 	if (modular) return modular;
 	if (!input.filePath) return null;
 	const filePath = input.filePath;
-	const window = input.windowMs ?? 12e4;
-	const track = await loadTrack(input.trackFile);
+	const track = reconcileRefReadsFromTranscript(await loadTrack(input.trackFile), input.transcriptPath, input.now);
 	const solidOrSkill = frameworkSkillGate(input, track.refsRead, existingCodeLines);
 	if (solidOrSkill) return solidOrSkill;
 	if (isShadcnWrite(input.tool, filePath)) {
@@ -5964,7 +6122,7 @@ async function runGates(input) {
 	});
 	if (geminiBlock) return geminiBlock;
 	if (isApexScoped(input.filePath)) {
-		const apex = await apexScopedGate(input, track, window);
+		const apex = await apexScopedGate(input, track, input.windowMs ?? 12e4);
 		if (apex) return apex;
 	}
 	return dryGate(input.tool, input.filePath, input.content, input.cwd);

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 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-CVvp1yuc.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-CoyvRORV.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.54",
+  "version": "0.1.56",
   "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",