@fusengine/harness 0.1.91 → 0.1.93

package/dist/runtime/index.d.mts

@@ -1,6 +1,6 @@
 import { t as Prompt } from "../types-Bh0jEF3_.mjs";
 import { t as RefMeta } from "../types-CY5qT2X1.mjs";
-import { t as AgentQuality } from "../session-state-D5gLr66m.mjs";
+import { t as AgentQuality } from "../session-state-COg7Ej_2.mjs";
 //#region src/runtime/paths.d.ts
 /**
  * Compute a stable 8-char hex hash for a project directory path.
@@ -187,6 +187,8 @@ interface NormalizedEvent {
   permissionMode?: string;
   /** Codex logical tool-use identity, shared by sibling hook callbacks. */
   toolUseId?: string;
+  /** Sub-agent identifier, if the tool-use came from one (Claude/Codex only — Cursor/Kimi never send this field, confirmed live). */
+  agentId?: string;
   /** Harness-reported working directory used to scope Codex authorization. */
   cwd?: string;
   /** Validated Cursor multi-root workspace paths in wire order. */
@@ -906,6 +908,16 @@ interface HandleOutcome {
 /**
  * Run one hook and adapt every Cursor scope outcome at the common runtime exit.
  * Other harnesses retain the core handler's stdout and exit status unchanged.
+ * Cursor's shared `additional_context` budget context (see
+ * `../adapters/cursor/context-budget.ts`) is assembled here too — this is
+ * the single point every Cursor stdout passes through exactly once, so it's
+ * also the single point that reserves from and records into the registry.
+ * With no `session_id`/`conversation_id` at all, `sessionId` is `""` — the
+ * registry key would degenerate to one bucket shared by every session-less
+ * call on the same (cwd, event) pair, so `budget` stays `undefined` instead
+ * (falls back to the flat per-response cap in `toCursorLifecycleResponse`,
+ * with zero registry I/O). `stateDir` honors `opts.home` (test-only OS home
+ * override, see `HandleOptions`) so tests never need the real `os.homedir()`.
  */
 declare function handleHook(id: string, payload: Record<string, unknown>, opts: HandleOptions): Promise<HandleOutcome>;
 //#endregion

package/dist/runtime/index.mjs

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

package/dist/runtime-io-DuumUeE6.mjs

@@ -0,0 +1,84 @@
+import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+//#region src/util/runtime-io.ts
+/**
+* Cross-runtime I/O helpers (Node + Bun). The published CLI ships a `node`
+* shebang and is invoked via `npx`/`npm`/`bunx`/`bun`; using only `node:*` APIs
+* here keeps the bundle runnable under EVERY runtime — replacing the Bun-only
+* `Bun.file/write/spawn/sleep/stdin` calls and the `bun` `Glob` import that made
+* the package crash with `Cannot find package 'bun'` under plain Node.
+*/
+/** Read a file as UTF-8 text (throws on missing/unreadable — callers catch). */
+function readText(path) {
+	return readFileSync(path, "utf8");
+}
+/** True when `path` exists. */
+function pathExists(path) {
+	return existsSync(path);
+}
+/** Write `data` to `path`, creating parent dirs (mirrors `Bun.write`). */
+function writeText(path, data) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, data, { encoding: "utf8" });
+}
+/** Resolve after `ms` milliseconds (`Bun.sleep` replacement). */
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Run `cmd args` in `cwd` and capture stdout text ("" on failure/non-zero). */
+function spawnCapture(cmd, args, cwd) {
+	try {
+		const r = spawnSync(cmd, args, {
+			cwd,
+			encoding: "utf8"
+		});
+		return r.status === 0 ? r.stdout ?? "" : "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Read the full process stdin as UTF-8 text (works under Node and Bun).
+* Synchronous fd-0 read — never `for await (const c of process.stdin)` —
+* because Bun has a confirmed Linux-only bug where merely adding a new
+* top-level module import shifts stdin's internal init order and makes
+* that async iterator silently yield zero bytes (oven-sh/bun#25320,
+* #27849): exactly what broke every `harness hook` invocation on CI the
+* moment `figures` became this package's first runtime dependency.
+* `readFileSync(0)` bypasses that stream/ownership machinery entirely and
+* is well-supported for piped (non-TTY) stdin under both runtimes.
+*/
+async function readStdin() {
+	try {
+		return readFileSync(0, "utf8");
+	} catch {
+		return "";
+	}
+}
+/**
+* Recursively collect files under `dir` whose extension is in `exts`, skipping
+* `node_modules` and dot-dirs, capped at `cap`. `Bun.Glob().scan()` replacement.
+* @param dir - Directory to walk.
+* @param exts - Allowed extensions including the dot (e.g. `.ts`).
+* @param out - Accumulator (mutated in place).
+* @param cap - Max files to collect.
+*/
+function collectFiles(dir, exts, out, cap) {
+	if (out.length >= cap) return;
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const e of entries) {
+		if (out.length >= cap) return;
+		if (e.name === "node_modules" || e.name.startsWith(".")) continue;
+		const full = join(dir, e.name);
+		if (e.isDirectory()) collectFiles(full, exts, out, cap);
+		else if (exts.has(e.name.slice(e.name.lastIndexOf(".")))) out.push(full);
+	}
+}
+//#endregion
+export { sleep as a, readText as i, pathExists as n, spawnCapture as o, readStdin as r, writeText as s, collectFiles as t };

package/dist/{session-state-D5gLr66m.d.mts → session-state-COg7Ej_2.d.mts}

@@ -50,7 +50,23 @@ interface SessionTrack {
   brainstormRequired?: boolean;
   /** Verification receipts (tsc/test) at PostToolUse; absent/empty reads as unverified in the TaskCompleted gate (backward compat, fail-closed). See {@link Receipt}. */
   receipts?: Receipt[];
+  /** PRD (task/agent ownership coordination) — `agent_id` bound to its resolved agent-report name. Optional: absent on any track predating the PRD module (backward compat). */
+  prdOwners?: Record<string, string>;
+  /** PRD cross-check violations detected at PostToolUse (capped, append-only). */
+  prdViolations?: PrdViolationRecord[];
+  /** PRD SubagentStop/Stop one-shot block markers, keyed `"sessionId:event[:agent]"` -> the epoch-ms the block fired. */
+  prdStopBlocked?: Record<string, number>;
 }
+/** One PRD cross-check violation, timestamped for the journal/dedup. */
+interface PrdViolationRecord {
+  ts: number;
+  task: string;
+  agent: string;
+  sub: string;
+  reason: string;
+}
+/** Cap on {@link SessionTrack.prdViolations} (mirrors the `receipts` style bound — oldest evicted first). */
+declare const PRD_VIOLATIONS_CAP = 50;
 /** A fresh, empty track. */
 declare function emptyTrack(): SessionTrack;
 /**
@@ -85,5 +101,20 @@ declare function recordTrivialEdit(track: SessionTrack, ts: number, windowMs: nu
 declare function trivialCount(track: SessionTrack, windowMs: number, now: number): number;
 /** Set the brainstorm-required flag (from creation-intent detection). Immutable. */
 declare function recordBrainstormRequired(track: SessionTrack, required: boolean): SessionTrack;
+/** Bind `agentId` to its resolved PRD agent-report `name` (merge; idempotent no-op if already bound to the same name). Immutable. */
+declare function recordPrdOwner(track: SessionTrack, agentId: string, name: string): SessionTrack;
+/**
+ * Append one PRD cross-check violation. Immutable, uncapped in the mutator
+ * itself — same append-only shape as {@link Receipt} — so the journal diff's
+ * prefix comparison (`tail`, track-diff.ts) never sees an eviction it would
+ * mistake for a bulk rewrite. The {@link PRD_VIOLATIONS_CAP} bound is applied
+ * only when the journal is folded/read (track-journal.ts's `foldEvents`),
+ * mirroring how `trivialEdits`'s sliding window is re-derived at fold time.
+ */
+declare function recordPrdViolation(track: SessionTrack, v: PrdViolationRecord): SessionTrack;
+/** Record a PRD SubagentStop/Stop one-shot block marker (merge). Immutable. */
+declare function recordPrdStopBlocked(track: SessionTrack, key: string, ts: number): SessionTrack;
+/** True when the PRD one-shot block for `key` has already fired. */
+declare function prdAlreadyBlocked(track: SessionTrack, key: string): boolean;
 //#endregion
-export { recordAgent as a, recordRefRead as c, trivialCount as d, emptyTrack as i, recordTarget as l, SessionTrack as n, recordBrainstormRequired as o, agentsFresh as r, recordDoc as s, AgentQuality as t, recordTrivialEdit as u };
+export { trivialCount as _, agentsFresh as a, recordAgent as c, recordPrdOwner as d, recordPrdStopBlocked as f, recordTrivialEdit as g, recordTarget as h, SessionTrack as i, recordBrainstormRequired as l, recordRefRead as m, PRD_VIOLATIONS_CAP as n, emptyTrack as o, recordPrdViolation as p, PrdViolationRecord as r, prdAlreadyBlocked as s, AgentQuality as t, recordDoc as u };

package/dist/{skill-path-DVML3zfp.mjs → skill-path-Cz8WFaGu.mjs}

@@ -1,4 +1,4 @@
-import { t as HOME_DIR } from "./dotenv-BLBkBTww.mjs";
+import { t as HOME_DIR } from "./dotenv-C1LkcfW-.mjs";
 import { t as detectHarness } from "./harness-BMuLJ9lm.mjs";
 import { l as PLUGINS_DIR } from "./home-state-oUGFB4ds.mjs";
 import { join } from "node:path";

package/dist/{store-5-ZPKb0u.mjs → store-BVY6gIYM.mjs}

@@ -1,9 +1,9 @@
-import { l as ttlLabel } from "./dotenv-BLBkBTww.mjs";
+import { i as ttlLabel } from "./ttl-Dgwg_QAv.mjs";
 import { n as fuseHarnessHome } from "./home-state-oUGFB4ds.mjs";
 import { a as writeJsonFile, i as readJsonFile, t as atomicWrite } from "./json-io-DisYd2fb.mjs";
 import { i as resolveSessions } from "./doc-helpers-CWZegVdR.mjs";
 import { t as routeReferences } from "./router-PKVNBHge.mjs";
-import { t as resolveSkillPath } from "./skill-path-DVML3zfp.mjs";
+import { t as resolveSkillPath } from "./skill-path-Cz8WFaGu.mjs";
 import { dirname, join } from "node:path";
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHmac, randomBytes } from "node:crypto";
@@ -142,6 +142,8 @@ const apexAuthorizationGate = (ctx) => {
 };
 //#endregion
 //#region src/tracking/session-state.ts
+/** Cap on {@link SessionTrack.prdViolations} (mirrors the `receipts` style bound — oldest evicted first). */
+const PRD_VIOLATIONS_CAP = 50;
 /** A fresh, empty track. */
 function emptyTrack() {
 	return {
@@ -244,6 +246,45 @@ function recordBrainstormRequired(track, required) {
 		brainstormRequired: required
 	};
 }
+/** Bind `agentId` to its resolved PRD agent-report `name` (merge; idempotent no-op if already bound to the same name). Immutable. */
+function recordPrdOwner(track, agentId, name) {
+	if (track.prdOwners?.[agentId] === name) return track;
+	return {
+		...track,
+		prdOwners: {
+			...track.prdOwners,
+			[agentId]: name
+		}
+	};
+}
+/**
+* Append one PRD cross-check violation. Immutable, uncapped in the mutator
+* itself — same append-only shape as {@link Receipt} — so the journal diff's
+* prefix comparison (`tail`, track-diff.ts) never sees an eviction it would
+* mistake for a bulk rewrite. The {@link PRD_VIOLATIONS_CAP} bound is applied
+* only when the journal is folded/read (track-journal.ts's `foldEvents`),
+* mirroring how `trivialEdits`'s sliding window is re-derived at fold time.
+*/
+function recordPrdViolation(track, v) {
+	return {
+		...track,
+		prdViolations: [...track.prdViolations ?? [], v]
+	};
+}
+/** Record a PRD SubagentStop/Stop one-shot block marker (merge). Immutable. */
+function recordPrdStopBlocked(track, key, ts) {
+	return {
+		...track,
+		prdStopBlocked: {
+			...track.prdStopBlocked,
+			[key]: ts
+		}
+	};
+}
+/** True when the PRD one-shot block for `key` has already fired. */
+function prdAlreadyBlocked(track, key) {
+	return track.prdStopBlocked?.[key] !== void 0;
+}
 //#endregion
 //#region src/tracking/integrity.ts
 /**
@@ -572,6 +613,9 @@ function foldEvents(events, base = emptyTrack()) {
 	const at = { ...base.refsReadAt };
 	const receipts = [...base.receipts ?? []];
 	const trivial = new Set(base.trivialEdits ?? []);
+	const prdOwners = { ...base.prdOwners };
+	const prdViolations = [...base.prdViolations ?? []];
+	const prdStopBlocked = { ...base.prdStopBlocked };
 	let targetTs = base.target ? Date.parse(base.target.set_at) || 0 : 0, brainstormTs = 0;
 	for (const ev of [...events].sort((a, b) => a.ts - b.ts)) if (ev.field === "refsRead") {
 		const p = String(ev.value);
@@ -591,9 +635,19 @@ function foldEvents(events, base = emptyTrack()) {
 	} else if (ev.field === "brainstormRequired" && ev.ts >= brainstormTs) {
 		t.brainstormRequired = Boolean(ev.value);
 		brainstormTs = ev.ts;
+	} else if (ev.field === "prdOwners") {
+		const [aid, name] = ev.value;
+		prdOwners[aid] = name;
+	} else if (ev.field === "prdViolations") prdViolations.push(ev.value);
+	else if (ev.field === "prdStopBlocked") {
+		const [key, ts] = ev.value;
+		prdStopBlocked[key] = ts;
 	}
 	if (Object.keys(at).length) t.refsReadAt = at;
 	if (receipts.length) t.receipts = receipts;
+	if (Object.keys(prdOwners).length) t.prdOwners = prdOwners;
+	if (prdViolations.length) t.prdViolations = prdViolations.slice(-50);
+	if (Object.keys(prdStopBlocked).length) t.prdStopBlocked = prdStopBlocked;
 	const maxT = Math.max(0, ...trivial);
 	t.trivialEdits = [...trivial].filter((x) => x > maxT - TRIVIAL_WINDOW_MS).sort((a, b) => a - b);
 	return t;
@@ -673,6 +727,24 @@ function diffTrackEvents(prev, next, now) {
 		value: next.brainstormRequired,
 		ts: now
 	});
+	for (const [aid, name] of Object.entries(next.prdOwners ?? {})) if (prev.prdOwners?.[aid] !== name) out.push({
+		field: "prdOwners",
+		op: "merge",
+		value: [aid, name],
+		ts: now
+	});
+	for (const v of tail(prev.prdViolations ?? [], next.prdViolations ?? [])) out.push({
+		field: "prdViolations",
+		op: "append",
+		value: v,
+		ts: v.ts ?? now
+	});
+	for (const [key, ts] of Object.entries(next.prdStopBlocked ?? {})) if (prev.prdStopBlocked?.[key] !== ts) out.push({
+		field: "prdStopBlocked",
+		op: "merge",
+		value: [key, ts],
+		ts
+	});
 	return out;
 }
 /** The journal log path twin of a track snapshot path. */
@@ -842,4 +914,4 @@ async function withTrack(file, mutate) {
 	}) !== LOCK_FAILED;
 }
 //#endregion
-export { apexAuthorizationGate as C, trivialCount as S, recordBrainstormRequired as _, journalLogPath as a, recordTarget as b, appendEvent as c, signTrack as d, verifyTrack as f, recordAgent as g, emptyTrack as h, withTrack as i, withTrackLockSync as l, agentsFresh as m, saveTrack as n, readTrackSync as o, writeLastNonce as p, trackJournalEnabled as r, diffTrackEvents as s, loadTrack as t, LOCK_FAILED as u, recordDoc as v, recordTrivialEdit as x, recordRefRead as y };
+export { recordPrdViolation as C, trivialCount as D, recordTrivialEdit as E, apexAuthorizationGate as O, recordPrdStopBlocked as S, recordTarget as T, prdAlreadyBlocked as _, journalLogPath as a, recordDoc as b, appendEvent as c, signTrack as d, verifyTrack as f, emptyTrack as g, agentsFresh as h, withTrack as i, withTrackLockSync as l, PRD_VIOLATIONS_CAP as m, saveTrack as n, readTrackSync as o, writeLastNonce as p, trackJournalEnabled as r, diffTrackEvents as s, loadTrack as t, LOCK_FAILED as u, recordAgent as v, recordRefRead as w, recordPrdOwner as x, recordBrainstormRequired as y };

package/dist/tracking/index.d.mts

@@ -1,4 +1,4 @@
-import { a as recordAgent, c as recordRefRead, d as trivialCount, i as emptyTrack, l as recordTarget, n as SessionTrack, o as recordBrainstormRequired, r as agentsFresh, s as recordDoc, t as AgentQuality, u as recordTrivialEdit } from "../session-state-D5gLr66m.mjs";
+import { _ as trivialCount, a as agentsFresh, c as recordAgent, d as recordPrdOwner, f as recordPrdStopBlocked, g as recordTrivialEdit, h as recordTarget, i as SessionTrack, l as recordBrainstormRequired, m as recordRefRead, n as PRD_VIOLATIONS_CAP, o as emptyTrack, p as recordPrdViolation, r as PrdViolationRecord, s as prdAlreadyBlocked, t as AgentQuality, u as recordDoc } from "../session-state-COg7Ej_2.mjs";
 //#region src/tracking/store.d.ts
 /** Journal mode is the default; `FUSE_TRACK_JOURNAL=0` reverts to the legacy locked RMW (see the module NOTE: =0 ignores the uncompacted journal — recoverable, keep the `.log`). */
 declare function trackJournalEnabled(): boolean;
@@ -26,4 +26,4 @@ declare function saveTrack(file: string, track: SessionTrack): Promise<void>;
  */
 declare function withTrack(file: string, mutate: (track: SessionTrack) => SessionTrack | Promise<SessionTrack>): Promise<boolean>;
 //#endregion
-export { AgentQuality, SessionTrack, agentsFresh, emptyTrack, loadTrack, recordAgent, recordBrainstormRequired, recordDoc, recordRefRead, recordTarget, recordTrivialEdit, saveTrack, trackJournalEnabled, trivialCount, withTrack };
+export { AgentQuality, PRD_VIOLATIONS_CAP, PrdViolationRecord, SessionTrack, agentsFresh, emptyTrack, loadTrack, prdAlreadyBlocked, recordAgent, recordBrainstormRequired, recordDoc, recordPrdOwner, recordPrdStopBlocked, recordPrdViolation, recordRefRead, recordTarget, recordTrivialEdit, saveTrack, trackJournalEnabled, trivialCount, withTrack };

package/dist/tracking/index.mjs

@@ -1,2 +1,2 @@
-import { S as trivialCount, _ as recordBrainstormRequired, b as recordTarget, g as recordAgent, h as emptyTrack, i as withTrack, m as agentsFresh, n as saveTrack, r as trackJournalEnabled, t as loadTrack, v as recordDoc, x as recordTrivialEdit, y as recordRefRead } from "../store-5-ZPKb0u.mjs";
-export { agentsFresh, emptyTrack, loadTrack, recordAgent, recordBrainstormRequired, recordDoc, recordRefRead, recordTarget, recordTrivialEdit, saveTrack, trackJournalEnabled, trivialCount, withTrack };
+import { C as recordPrdViolation, D as trivialCount, E as recordTrivialEdit, S as recordPrdStopBlocked, T as recordTarget, _ as prdAlreadyBlocked, b as recordDoc, g as emptyTrack, h as agentsFresh, i as withTrack, m as PRD_VIOLATIONS_CAP, n as saveTrack, r as trackJournalEnabled, t as loadTrack, v as recordAgent, w as recordRefRead, x as recordPrdOwner, y as recordBrainstormRequired } from "../store-BVY6gIYM.mjs";
+export { PRD_VIOLATIONS_CAP, agentsFresh, emptyTrack, loadTrack, prdAlreadyBlocked, recordAgent, recordBrainstormRequired, recordDoc, recordPrdOwner, recordPrdStopBlocked, recordPrdViolation, recordRefRead, recordTarget, recordTrivialEdit, saveTrack, trackJournalEnabled, trivialCount, withTrack };

package/dist/ttl-Dgwg_QAv.mjs

@@ -0,0 +1,26 @@
+import { l as parseEnvInt } from "./limits-DG5pl-5s.mjs";
+//#region src/config/ttl.ts
+/**
+* Default enforcement-freshness window, in seconds (2 minutes). Matches the
+* plugin's original `FUSE_ENFORCE_TTL_SEC` default. This is the constant that
+* actually reaches production (via `resolveTtlSec` -> `bin.ts`); `gate.ts`'s
+* `DEFAULT_WINDOW_MS` is only a fallback for direct programmatic callers that
+* omit `windowMs` (e.g. tests) and never applies on the real CLI path.
+*/
+const DEFAULT_TTL_SEC = 120;
+/** Default env var name carrying the TTL override. */
+const TTL_ENV_KEY = "FUSE_ENFORCE_TTL_SEC";
+/**
+* Resolve the enforcement TTL (seconds) from an env map.
+* @param env - environment map (defaults to `process.env`)
+* @param key - env var name (defaults to `FUSE_ENFORCE_TTL_SEC`)
+*/
+function resolveTtlSec(env = process.env, key = TTL_ENV_KEY) {
+	return parseEnvInt(env[key], 120);
+}
+/** Human label for a TTL: 120 -> "2min", 240 -> "4min", 90 -> "90s". */
+function ttlLabel(sec) {
+	return sec % 60 === 0 ? `${sec / 60}min` : `${sec}s`;
+}
+//#endregion
+export { ttlLabel as i, TTL_ENV_KEY as n, resolveTtlSec as r, DEFAULT_TTL_SEC as t };

package/dist/{validate-KjZ1X9tH.mjs → validate-Dcjl0LUS.mjs}

@@ -1,10 +1,11 @@
 import { a as resolveMaxLines, c as storeBudget, i as hookBudget } from "./limits-DG5pl-5s.mjs";
-import { l as ttlLabel, t as HOME_DIR } from "./dotenv-BLBkBTww.mjs";
+import { i as ttlLabel } from "./ttl-Dgwg_QAv.mjs";
 import { A as moduleAwarePath, S as isHooksPath, T as isStoresPath, _ as rolloutVerdict, at as maskCommentsOnly, it as maskCommentsAndStrings, nt as nearestManifestDir, ot as DEV_KEYWORDS, rt as projectCaps, x as isComponentsPath, y as declaresInterface } from "./evaluate-CMiIqHeH.mjs";
 import { d as countFrameworkCodeLines, l as PLUGINS_DIR, u as SOLID_REF } from "./home-state-oUGFB4ds.mjs";
 import { r as isDocConsulted, t as formatDocDeny } from "./doc-helpers-CWZegVdR.mjs";
 import { t as routeReferences } from "./router-PKVNBHge.mjs";
-import { n as findMarketplacePlugins, r as readPluginMeta, t as resolveSkillPath } from "./skill-path-DVML3zfp.mjs";
+import { n as findMarketplacePlugins, r as readPluginMeta, t as resolveSkillPath } from "./skill-path-Cz8WFaGu.mjs";
+import { n as apexPlanTool, r as harnessHomeSegment, t as apexDocName } from "./apex-target-Xc2M32Pl.mjs";
 import { dirname, extname, join, resolve } from "node:path";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
@@ -1446,52 +1447,6 @@ function getExpertAgent(type, pluginsDirOverride) {
 	return "general-purpose";
 }
 //#endregion
-//#region src/policy/apex-target.ts
-/**
-* Harness-target helpers for the APEX context builders. Single source of
-* truth for the home-dir segment / root doc name / plan-tool idiom that
-* differ between Claude Code and Codex (and beyond), so the builders in
-* `claude-md-context.ts`, `apex-task-context.ts`, and `inject-apex.ts` never
-* hardcode `.claude`/`CLAUDE.md`/`TaskCreate` again. Runtime `id` values flow
-* through the pipeline as plain `string` (see `handleHook(id: string, ...)`),
-* so these helpers accept `string` and narrow internally — same idiom as the
-* existing `HOME_DIR[id] ?? ".claude"` precedent in `cartographer/detect.ts`.
-*/
-/**
-* Home-dir segment for a harness target (".claude", ".codex", ...). Falls
-* back to ".claude" for any harness without a {@link HOME_DIR} entry.
-* @param id - Harness id (e.g. "claude-code", "codex").
-* @returns The home-dir segment, e.g. ".claude".
-*/
-function harnessHomeSegment(id) {
-	return HOME_DIR[id] ?? ".claude";
-}
-/**
-* Root instructions doc name for a harness target: "AGENTS.md" for Codex and
-* Kimi Code CLI (both documented conventions), "CLAUDE.md" for every other
-* target (including the default/unknown fallback).
-* @param id - Harness id.
-* @returns The doc file name.
-*/
-function apexDocName(id) {
-	return id === "codex" || id === "kimi" ? "AGENTS.md" : "CLAUDE.md";
-}
-/**
-* Native plan/track tool name for a harness target: Codex's `update_plan`,
-* Kimi Code CLI's `TodoList`, or Claude's `TaskCreate` (default). Covers only
-* the PLAN-step line — other target-specific tool references (`TaskList`,
-* `TaskUpdate`) are resolved via `apexTaskSteps`/`apexAgentSteps` in
-* `apex-target-steps.ts` since their surrounding prose differs structurally,
-* not just by token.
-* @param id - Harness id.
-* @returns The plan-tool name.
-*/
-function apexPlanTool(id) {
-	if (id === "codex") return "update_plan";
-	if (id === "kimi") return "TodoList";
-	return "TaskCreate";
-}
-//#endregion
 //#region src/policy/detect-claude-md-project-type.ts
 /**
 * Detect the project type from the cwd, reproducing the legacy Python logic:
@@ -1907,4 +1862,4 @@ function missingSeoElements(html) {
 	return missing;
 }
 //#endregion
-export { importsTanstackQuery as A, APEX_GATES as B, detectRequiredSkills as C, frameworkSolidGate as D, SKILL_TRIGGERS as E, isExcludedSwiftPath as F, evaluateApex as G, PRE_AUTH_GATES as H, MAX_EXA_RESULTS as I, freshnessGate as K, MAX_TOKENS as L, countStores as M, declaresStore as N, declaresCustomHook as O, isExcludedJsPath as P, capVerbosity as R, parseField as S, usesTailwindUtilities as T, brainstormGate as U, POST_AUTH_GATES as V, docConsultedGate as W, detectClaudeMdProjectType as _, firstHeading as a, scanPlugin as b, EXCLUDE_DIRS as c, buildApexTaskInjection as d, loadApexTaskState as f, buildClaudeMdContext as g, buildApexInstruction as h, firstComment as i, queryCapActive as j, declaresQueryHook as k, PROJECT_INDICATORS as l, DEV_VERBS as m, missingSeoElements as n, parseEnrichment as o, apexAgentSteps as p, solidReadGate as q, descFromText as r, parseEntry as s, isHtmlLike as t, buildApexTaskContext as u, apexDocName as v, skillTriggerGate as w, parseBodyDesc as x, harnessHomeSegment as y, detectCreationIntent as z };
+export { countStores as A, PRE_AUTH_GATES as B, usesTailwindUtilities as C, declaresQueryHook as D, declaresCustomHook as E, MAX_TOKENS as F, solidReadGate as G, docConsultedGate as H, capVerbosity as I, detectCreationIntent as L, isExcludedJsPath as M, isExcludedSwiftPath as N, importsTanstackQuery as O, MAX_EXA_RESULTS as P, APEX_GATES as R, skillTriggerGate as S, frameworkSolidGate as T, evaluateApex as U, brainstormGate as V, freshnessGate as W, detectClaudeMdProjectType as _, firstHeading as a, parseField as b, EXCLUDE_DIRS as c, buildApexTaskInjection as d, loadApexTaskState as f, buildClaudeMdContext as g, buildApexInstruction as h, firstComment as i, declaresStore as j, queryCapActive as k, PROJECT_INDICATORS as l, DEV_VERBS as m, missingSeoElements as n, parseEnrichment as o, apexAgentSteps as p, descFromText as r, parseEntry as s, isHtmlLike as t, buildApexTaskContext as u, scanPlugin as v, SKILL_TRIGGERS as w, detectRequiredSkills as x, parseBodyDesc as y, POST_AUTH_GATES as z };

package/package.json

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

package/src/adapters/cursor/context-budget.ts

@@ -0,0 +1,144 @@
+/**
+ * @module context-budget
+ * Cursor-only shared `additional_context` budget registry. Cursor 3.18.25
+ * runs every hook plugin configured on an event in its OWN process, then
+ * merges their `additional_context` outputs with a 9-char `"\n\n---\n\n"`
+ * separator and drops the WHOLE merge past 10,000 UTF-16 units — so no
+ * single process can know the total by itself. This module gives every
+ * plugin's process a shared, best-effort view of that total via a small
+ * JSON registry file under the project's state dir (see `../../runtime/paths.ts`),
+ * keyed by `${sessionId}|${event}|${generationId ?? ""}|${toolUseId ?? ""}`
+ * (one key per merge group — Cursor merges preToolUse/postToolUse/
+ * postToolUseFailure PER TOOL CALL, so `toolUseId` joins the key on those
+ * three events), with entries older than 10s ignored (concurrent hooks on one
+ * event fire within the same second). Best-effort, fail-open throughout: any
+ * I/O or JSON error degrades to "no shared budget", i.e. the flat
+ * per-response cap in `./context-limit.ts` alone — never a thrown error, and
+ * never a Cursor-side regression.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWrite } from "../../util/json-io";
+import {
+  ADDITIONAL_CONTEXT_LIMIT, TRUNCATION_MARKER, additionalContextLength, capAdditionalContext, omitAdditionalContext,
+} from "./context-limit";
+import type { CursorBudgetContext } from "./interfaces/context-budget";
+
+const REGISTRY_FILE = "cursor-context-budget.json";
+/** Matches Cursor 3.18.25's observed `"\n\n---\n\n"` merge separator length. */
+const SEPARATOR_LENGTH = 9;
+const ENTRY_WINDOW_MS = 10_000;
+/** Below this, a truncated value would carry more marker than budget — omit the field instead. */
+const OMIT_THRESHOLD = TRUNCATION_MARKER.length + 100;
+
+interface BudgetEntry {
+  at: number;
+  length: number;
+}
+type BudgetRegistry = Record<string, BudgetEntry[]>;
+
+function isRegistry(value: unknown): value is BudgetRegistry {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function registryPath(stateDir: string): string {
+  return join(stateDir, REGISTRY_FILE);
+}
+
+function budgetKey(ctx: Pick<CursorBudgetContext, "sessionId" | "event" | "generationId" | "toolUseId">): string {
+  return `${ctx.sessionId}|${ctx.event}|${ctx.generationId ?? ""}|${ctx.toolUseId ?? ""}`;
+}
+
+function loadRegistry(path: string): BudgetRegistry {
+  try {
+    if (!existsSync(path)) return {};
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    return isRegistry(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function freshEntries(entries: BudgetEntry[] | undefined, now: number): BudgetEntry[] {
+  return (entries ?? []).filter((entry) => now - entry.at <= ENTRY_WINDOW_MS);
+}
+
+/** Sum of a key's fresh entry lengths plus the separators already joining them. */
+function consumed(entries: BudgetEntry[]): number {
+  return entries.reduce((total, entry) => total + entry.length, 0) + SEPARATOR_LENGTH * Math.max(0, entries.length - 1);
+}
+
+/** {@link reserveAdditionalContext} input: budget context plus the length the caller wants to emit. */
+export type ReserveInput = CursorBudgetContext & { wanted: number };
+/** {@link recordAdditionalContext} input: budget context plus the length actually emitted. */
+export type RecordInput = CursorBudgetContext & { emitted: number };
+
+/**
+ * Reserve room in the shared budget for one hook's `additional_context`
+ * contribution to one (session, event, generation) merge group. `wanted` is
+ * accepted for a symmetric call shape with {@link recordAdditionalContext}
+ * but does not shrink `allowed` itself — the ceiling only depends on what
+ * OTHER entries already hold; a smaller `wanted` simply means the caller
+ * won't need all of it. Best-effort, fail-open: any I/O/JSON error returns
+ * the full flat ceiling, as if no other plugin had run.
+ * @param input - Registry location, reservation key, and the wanted length.
+ */
+export function reserveAdditionalContext(input: ReserveInput): { allowed: number } {
+  try {
+    const now = input.now ?? Date.now();
+    const registry = loadRegistry(registryPath(input.stateDir));
+    const fresh = freshEntries(registry[budgetKey(input)], now);
+    const separator = fresh.length > 0 ? SEPARATOR_LENGTH : 0;
+    return { allowed: Math.max(0, ADDITIONAL_CONTEXT_LIMIT - consumed(fresh) - separator) };
+  } catch {
+    return { allowed: ADDITIONAL_CONTEXT_LIMIT };
+  }
+}
+
+/**
+ * Record the length actually emitted for one reservation, best-effort.
+ * Prunes every key's stale entries while it holds the write so the registry
+ * file stays bounded. Silently no-ops on any I/O error (fail-open).
+ * @param input - Registry location, reservation key, and the emitted length.
+ */
+export function recordAdditionalContext(input: RecordInput): void {
+  try {
+    const now = input.now ?? Date.now();
+    const path = registryPath(input.stateDir);
+    const registry = loadRegistry(path);
+    const pruned: BudgetRegistry = {};
+    for (const [key, entries] of Object.entries(registry)) {
+      const fresh = freshEntries(entries, now);
+      if (fresh.length > 0) pruned[key] = fresh;
+    }
+    const key = budgetKey(input);
+    pruned[key] = [...(pruned[key] ?? []), { at: now, length: input.emitted }];
+    atomicWrite(path, JSON.stringify(pruned));
+  } catch {
+    // Best-effort: a lost entry only makes the NEXT reservation over-generous
+    // (never under), which is the safe direction to fail in.
+  }
+}
+
+/**
+ * Cap a Cursor stdout JSON's `additional_context` against the shared budget
+ * instead of the flat per-response ceiling alone. Falls back to the plain
+ * cap (`./context-limit.ts`), unbudgeted, when `budget` is `undefined` or
+ * the stdout carries no `additional_context` at all.
+ * @param stdout - A native Cursor JSON stdout candidate.
+ * @param budget - Shared budget context, or `undefined` to skip it.
+ */
+export function capAdditionalContextWithBudget(stdout: string, budget: CursorBudgetContext | undefined): string {
+  if (!budget) return capAdditionalContext(stdout);
+  const wanted = additionalContextLength(stdout);
+  if (wanted === 0) return stdout;
+  const { allowed } = reserveAdditionalContext({ ...budget, wanted });
+  if (allowed < OMIT_THRESHOLD) {
+    process.stderr.write(`[fuse-harness] cursor: additional_context budget exhausted for ${budget.event} (allowed=${allowed})\n`);
+    return omitAdditionalContext(stdout);
+  }
+  const limit = Math.min(ADDITIONAL_CONTEXT_LIMIT, allowed);
+  const capped = capAdditionalContext(stdout, limit);
+  recordAdditionalContext({ ...budget, emitted: additionalContextLength(capped) });
+  return capped;
+}