@fusengine/harness 0.1.92 → 0.1.94

package/dist/prd-compact-BE45t8UR.mjs

@@ -0,0 +1,499 @@
+import { a as writeJsonFile, i as readJsonFile } from "./json-io-DisYd2fb.mjs";
+import { r as harnessHomeSegment } from "./apex-target-Xc2M32Pl.mjs";
+import { a as sleep } from "./runtime-io-DuumUeE6.mjs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, rmdir } from "node:fs/promises";
+//#region src/policy/prd/prd-paths.ts
+/**
+* Pure path builders and classifiers for the PRD file tree
+* (`<root>/<homeSeg>/apex/prd*`). No fs access — string/path compare only.
+*/
+const AGENT_REPORT_SUFFIX = "-prd.json";
+const DOCS_SUFFIX = ".md";
+function apexDir(root, homeSeg) {
+	return join(root, homeSeg, "apex");
+}
+/** Absolute path to the router (`<root>/<homeSeg>/apex/prd.json`). */
+function prdRouterPath(root, homeSeg) {
+	return join(apexDir(root, homeSeg), "prd.json");
+}
+/** Absolute path to the PRD directory (`<root>/<homeSeg>/apex/prd`). */
+function prdDir(root, homeSeg) {
+	return join(apexDir(root, homeSeg), "prd");
+}
+/** Absolute path to a task-PRD file, given the router entry's `prd` field. */
+function prdTaskPath(root, homeSeg, relPrd) {
+	return join(apexDir(root, homeSeg), relPrd);
+}
+/** Absolute path to an agent's own report file (`prd/agents/<agent>-prd.json`). */
+function prdAgentReportPath(root, homeSeg, agent) {
+	return join(prdDir(root, homeSeg), "agents", `${agent}${AGENT_REPORT_SUFFIX}`);
+}
+function resolveAgainstRoot(filePath, root) {
+	return isAbsolute(filePath) ? resolve(filePath) : resolve(root, filePath);
+}
+/**
+* True when `filePath` (absolute or root-relative) resolves under
+* `<root>/<homeSeg>/apex/prd/`, or is exactly the router itself. Normalizes
+* via `path.resolve`/`relative`; a `..` that escapes the PRD dir is rejected.
+*/
+function isPrdScopedPath(filePath, root, homeSeg) {
+	const abs = resolveAgainstRoot(filePath, root);
+	if (abs === resolve(prdRouterPath(root, homeSeg))) return true;
+	const rel = relative(resolve(prdDir(root, homeSeg)), abs);
+	return rel !== "" && rel !== "." && !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+* Classifies an in-scope PRD path into one of the 4 file kinds (router,
+* task, agentReport, docs), or `"other"` when it is textually under
+* `apex/prd/` but matches none of the router-declared task files. `null`
+* when the path is not in scope at all (see {@link isPrdScopedPath}).
+*/
+function classifyPrdPath(filePath, root, homeSeg, router) {
+	if (!isPrdScopedPath(filePath, root, homeSeg)) return null;
+	const abs = resolveAgainstRoot(filePath, root);
+	if (abs === resolve(prdRouterPath(root, homeSeg))) return { kind: "router" };
+	const parts = relative(resolve(prdDir(root, homeSeg)), abs).split(sep);
+	const [first, second] = parts;
+	if (parts.length === 2 && first === "agents" && second?.endsWith(AGENT_REPORT_SUFFIX)) return {
+		kind: "agentReport",
+		agent: second.slice(0, -9)
+	};
+	if (parts.length === 2 && first === "docs" && second?.endsWith(DOCS_SUFFIX)) return {
+		kind: "docs",
+		task: second.slice(0, -3)
+	};
+	if (router) {
+		for (const [task, entry] of Object.entries(router)) if (resolve(prdTaskPath(root, homeSeg, entry.prd)) === abs) return {
+			kind: "task",
+			task
+		};
+	}
+	return { kind: "other" };
+}
+//#endregion
+//#region src/policy/prd/prd-schema.ts
+const ROUTER_STATUSES = [
+	"assigned",
+	"in-progress",
+	"validated"
+];
+function isRecord(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isStringArray(v) {
+	return Array.isArray(v) && v.every((x) => typeof x === "string");
+}
+function parseRouterEntry(v) {
+	if (!isRecord(v)) return null;
+	if (typeof v.prd !== "string") return null;
+	if (typeof v.status !== "string" || !ROUTER_STATUSES.includes(v.status)) return null;
+	const validatedAt = v["validated-at"];
+	if (validatedAt !== void 0 && typeof validatedAt !== "string") return null;
+	return validatedAt === void 0 ? {
+		prd: v.prd,
+		status: v.status
+	} : {
+		prd: v.prd,
+		status: v.status,
+		"validated-at": validatedAt
+	};
+}
+/** Parses the router file (`prd.json`); `null` on any malformed shape. */
+function parseRouter(raw) {
+	if (!isRecord(raw)) return null;
+	const out = {};
+	for (const [task, v] of Object.entries(raw)) {
+		const entry = parseRouterEntry(v);
+		if (!entry) return null;
+		out[task] = entry;
+	}
+	return out;
+}
+function parseSubTask(v) {
+	if (!isRecord(v) || typeof v.status !== "string") return null;
+	if (v.status !== "assigned" && v.status !== "validated") return null;
+	const validatedAt = v["validated-at"];
+	if (validatedAt !== void 0 && typeof validatedAt !== "string") return null;
+	return validatedAt === void 0 ? { status: v.status } : {
+		status: v.status,
+		"validated-at": validatedAt
+	};
+}
+function parseAgentEntry(v) {
+	if (!isRecord(v) || !isStringArray(v.files)) return null;
+	if (v.status === "validated") {
+		if (typeof v["validated-at"] !== "string") return null;
+		return {
+			status: "validated",
+			files: v.files,
+			"validated-at": v["validated-at"]
+		};
+	}
+	if (!isRecord(v["sub-tasks"])) return null;
+	const subTasks = {};
+	for (const [sub, sv] of Object.entries(v["sub-tasks"])) {
+		const parsed = parseSubTask(sv);
+		if (!parsed) return null;
+		subTasks[sub] = parsed;
+	}
+	return {
+		files: v.files,
+		"sub-tasks": subTasks
+	};
+}
+/** Parses a task-PRD file; `null` on any malformed shape. */
+function parseTaskFile(raw) {
+	if (!isRecord(raw)) return null;
+	const out = {};
+	for (const [agent, v] of Object.entries(raw)) {
+		const entry = parseAgentEntry(v);
+		if (!entry) return null;
+		out[agent] = entry;
+	}
+	return out;
+}
+/** Parses an agent's own report file; `null` on any malformed shape. */
+function parseAgentReportFile(raw) {
+	if (!isRecord(raw)) return null;
+	const out = {};
+	for (const [task, subs] of Object.entries(raw)) {
+		if (!isRecord(subs)) return null;
+		const parsedSubs = {};
+		for (const [sub, v] of Object.entries(subs)) {
+			if (!isRecord(v) || v.status !== "done" || !isStringArray(v.modified) || !isStringArray(v.unchanged)) return null;
+			const doneAt = v["done-at"];
+			if (doneAt !== void 0 && typeof doneAt !== "string") return null;
+			parsedSubs[sub] = doneAt === void 0 ? {
+				status: "done",
+				modified: v.modified,
+				unchanged: v.unchanged
+			} : {
+				status: "done",
+				modified: v.modified,
+				unchanged: v.unchanged,
+				"done-at": doneAt
+			};
+		}
+		out[task] = parsedSubs;
+	}
+	return out;
+}
+/** True when `e` is the post-compaction shape. */
+function isCompacted(e) {
+	return "status" in e && e.status === "validated" && !("sub-tasks" in e);
+}
+/** Sub-tasks of an agent entry; `{}` when already compacted. */
+function subTasksOf(e) {
+	return isCompacted(e) ? {} : e["sub-tasks"];
+}
+/** Files owned by an agent entry, expanded or compacted. */
+function filesOf(e) {
+	return e.files;
+}
+/** Returns a new router with `task`'s status (and optional `validated-at`) updated. */
+function withRouterStatus(router, task, status, at) {
+	const existing = router[task];
+	if (!existing) return router;
+	const entry = at === void 0 ? {
+		prd: existing.prd,
+		status
+	} : {
+		prd: existing.prd,
+		status,
+		"validated-at": at
+	};
+	return {
+		...router,
+		[task]: entry
+	};
+}
+/** Returns a new task-PRD file with one agent's sub-task flipped to `validated`. */
+function withSubTaskValidated(taskFile, agent, sub, at) {
+	const entry = taskFile[agent];
+	if (!entry || isCompacted(entry)) return taskFile;
+	if (!entry["sub-tasks"][sub]) return taskFile;
+	const nextSubTasks = {
+		...entry["sub-tasks"],
+		[sub]: {
+			status: "validated",
+			"validated-at": at
+		}
+	};
+	return {
+		...taskFile,
+		[agent]: {
+			files: entry.files,
+			"sub-tasks": nextSubTasks
+		}
+	};
+}
+//#endregion
+//#region src/policy/prd/prd-io.ts
+/**
+* Thin fail-closed wrappers over `util/json-io.ts` + the `prd-schema.ts`
+* parsers. Both async (CLI, PostToolUse) and sync (SubagentStart/Stop, which
+* must not float async work) variants. The only two files in this module
+* that touch disk (besides `prd-enabled.ts`).
+*/
+function readJsonSync(path) {
+	try {
+		if (!existsSync(path)) return null;
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+}
+/** Reads the router file; `null` when missing or malformed. */
+async function readRouter(root, homeSeg) {
+	const raw = await readJsonFile(prdRouterPath(root, homeSeg));
+	return raw === null ? null : parseRouter(raw);
+}
+/** Sync twin of {@link readRouter}, for SubagentStart/Stop call sites. */
+function readRouterSync(root, homeSeg) {
+	const raw = readJsonSync(prdRouterPath(root, homeSeg));
+	return raw === null ? null : parseRouter(raw);
+}
+/** Reads a task-PRD file; `null` when missing or malformed. */
+async function readTaskFile(root, homeSeg, relPrd) {
+	const raw = await readJsonFile(prdTaskPath(root, homeSeg, relPrd));
+	return raw === null ? null : parseTaskFile(raw);
+}
+/** Sync twin of {@link readTaskFile}. */
+function readTaskFileSync(root, homeSeg, relPrd) {
+	const raw = readJsonSync(prdTaskPath(root, homeSeg, relPrd));
+	return raw === null ? null : parseTaskFile(raw);
+}
+/** Reads every task-PRD file named in `router`, keyed by task name (`null` per unreadable/malformed entry). */
+async function readAllTaskFiles(root, homeSeg, router) {
+	const out = {};
+	for (const [task, entry] of Object.entries(router)) out[task] = await readTaskFile(root, homeSeg, entry.prd);
+	return out;
+}
+/** Reads an agent's own report file; `null` when missing or malformed. */
+async function readAgentReport(root, homeSeg, agent) {
+	const raw = await readJsonFile(prdAgentReportPath(root, homeSeg, agent));
+	return raw === null ? null : parseAgentReportFile(raw);
+}
+/** Sync twin of {@link readAgentReport}. */
+function readAgentReportSync(root, homeSeg, agent) {
+	const raw = readJsonSync(prdAgentReportPath(root, homeSeg, agent));
+	return raw === null ? null : parseAgentReportFile(raw);
+}
+/** Atomically writes the router file. */
+async function writeRouter(root, homeSeg, router) {
+	await writeJsonFile(prdRouterPath(root, homeSeg), router);
+}
+/** Atomically writes a task-PRD file. */
+async function writeTaskFile(root, homeSeg, relPrd, file) {
+	await writeJsonFile(prdTaskPath(root, homeSeg, relPrd), file);
+}
+//#endregion
+//#region src/policy/prd/prd-crosscheck.ts
+/**
+* Cross-checks a task-PRD's declared status against the agents' own reports
+* (and, for the router, against the task-PRD's own internal consistency).
+* Pure — no fs.
+*/
+/** Mismatches between a task-PRD's `validated` sub-tasks and the agents' own reports. */
+function crossCheckTask(taskFile, reports, task) {
+	const violations = [];
+	for (const [agent, entry] of Object.entries(taskFile)) {
+		if (isCompacted(entry)) continue;
+		const report = reports[agent];
+		for (const [sub, subTask] of Object.entries(subTasksOf(entry))) {
+			if (subTask.status !== "validated") continue;
+			if (report?.[task]?.[sub]?.status !== "done") violations.push({
+				task,
+				agent,
+				sub,
+				reason: "validated without a matching done report"
+			});
+		}
+	}
+	return violations;
+}
+function taskFullyValidated(taskFile) {
+	return Object.values(taskFile).every((entry) => {
+		if (isCompacted(entry)) return true;
+		return Object.values(subTasksOf(entry)).every((sub) => sub.status === "validated");
+	});
+}
+/**
+* Router-level consistency check: a router entry marked `validated` whose
+* task-PRD is missing/unparseable, or not actually fully validated, is a
+* violation. Non-`validated` router entries are never checked.
+*/
+function crossCheckRouter(router, taskFiles) {
+	const violations = [];
+	for (const [task, entry] of Object.entries(router)) {
+		if (entry.status !== "validated") continue;
+		const taskFile = taskFiles[task];
+		if (!taskFile) violations.push({
+			task,
+			agent: "*",
+			sub: "*",
+			reason: "router marked validated but task-PRD is missing or unparseable"
+		});
+		else if (!taskFullyValidated(taskFile)) violations.push({
+			task,
+			agent: "*",
+			sub: "*",
+			reason: "router marked validated but task-PRD is not fully validated"
+		});
+	}
+	return violations;
+}
+/** Sub-tasks assigned to `agent` in `taskFile` for `task` not `done` in its own report. */
+function incompleteSubTasks(taskFile, agent, task, report) {
+	const entry = taskFile[agent];
+	if (!entry || isCompacted(entry)) return [];
+	const doneSubs = report?.[task] ?? {};
+	return Object.keys(subTasksOf(entry)).filter((sub) => doneSubs[sub]?.status !== "done");
+}
+/** True when the router has any `validated`-vs-task-PRD mismatch. */
+function hasAnyViolations(router, taskFiles) {
+	return crossCheckRouter(router, taskFiles).length > 0;
+}
+//#endregion
+//#region src/policy/prd/prd-enabled.ts
+/**
+* The single activation check for the whole PRD module. Everything
+* downstream short-circuits on `false` here — this is the only place the
+* module's "totally inert when off" contract lives. The other file in this
+* module that touches disk (besides `prd-io.ts`).
+*/
+/** True only when `FUSE_PRD` is the exact string `"1"` — no truthy-string leniency. */
+function isPrdFlagSet(env = process.env) {
+	return env.FUSE_PRD === "1";
+}
+/** `CLAUDE_PROJECT_DIR` then `CURSOR_PROJECT_DIR` (first absolute value wins), else `cwd`. */
+function prdProjectRoot(cwd, env = process.env) {
+	for (const candidate of [env.CLAUDE_PROJECT_DIR, env.CURSOR_PROJECT_DIR]) if (candidate !== void 0 && isAbsolute(candidate)) return candidate;
+	return cwd;
+}
+/** True when the router file exists on disk. */
+function routerExistsSync(root, homeSeg) {
+	return existsSync(prdRouterPath(root, homeSeg));
+}
+/**
+* Activation = `FUSE_PRD=1` AND the router is present. Short-circuits on the
+* env check first, so a disabled module never touches disk.
+*/
+function isPrdEnabled(cwd, id, env = process.env) {
+	if (!isPrdFlagSet(env)) return false;
+	return routerExistsSync(prdProjectRoot(cwd, env), harnessHomeSegment(id));
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/apex-task-store.ts
+/**
+* APEX `task.json` mutation helpers + a directory-based lock for the ai-pilot
+* scope. Ported from the ai-pilot plugin's `apex/state.ts` + `apex/task-helpers.ts`
+* (now removed).
+*/
+/**
+* Acquire a directory-based lock with a timeout.
+* @param lockDir - Path to the lock directory.
+* @param timeoutMs - Max wait in ms (default 5000).
+* @returns A release function, or null if acquisition timed out.
+*/
+async function acquireLock(lockDir, timeoutMs = 5e3) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) try {
+		await mkdir(lockDir, { recursive: false });
+		return async () => {
+			try {
+				await rmdir(lockDir);
+			} catch {}
+		};
+	} catch {
+		await sleep(100);
+	}
+	return null;
+}
+/** Add a new task to `task.json`. */
+async function taskCreate(file, id, subject, desc) {
+	const data = await readJsonFile(file);
+	if (!data) return;
+	data.tasks[id] = {
+		subject,
+		description: desc,
+		status: "pending",
+		phase: "pending",
+		created_at: (/* @__PURE__ */ new Date()).toISOString(),
+		doc_consulted: {},
+		files_modified: [],
+		blockedBy: []
+	};
+	await writeJsonFile(file, data);
+}
+/** Mark a task as in_progress in `task.json`. */
+async function taskStart(file, id, subject, desc, blocked) {
+	const data = await readJsonFile(file);
+	if (!data) return;
+	if (!data.tasks[id]) data.tasks[id] = {
+		subject: "",
+		description: "",
+		status: "in_progress",
+		phase: "analyze",
+		doc_consulted: {},
+		files_modified: []
+	};
+	data.current_task = id;
+	const task = data.tasks[id];
+	Object.assign(task, {
+		status: "in_progress",
+		phase: "analyze",
+		started_at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	if (subject) task.subject = subject;
+	if (desc) task.description = desc;
+	if (blocked) task.blockedBy = blocked.split(",");
+	await writeJsonFile(file, data);
+}
+/** Mark a task as completed in `task.json`. */
+async function taskComplete(file, id) {
+	const data = await readJsonFile(file);
+	if (!data?.tasks[id]) return;
+	Object.assign(data.tasks[id], {
+		status: "completed",
+		phase: "completed",
+		completed_at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	await writeJsonFile(file, data);
+}
+//#endregion
+//#region src/policy/prd/prd-compact.ts
+/** Collapses fully-validated task-PRD agent entries to their compact shape. Pure — no fs. */
+/** Collapses one agent entry to the compacted shape ONLY when every sub-task is `validated`; else returns it unchanged. */
+function compactAgentEntry(e, at) {
+	if (isCompacted(e)) return e;
+	const subTasks = Object.values(subTasksOf(e));
+	if (subTasks.length === 0 || !subTasks.every((s) => s.status === "validated")) return e;
+	return {
+		status: "validated",
+		files: e.files,
+		"validated-at": at
+	};
+}
+/** Compacts every eligible agent entry in a task-PRD; reports which agent names got collapsed. */
+function compactTaskFile(taskFile, at) {
+	const compacted = [];
+	const file = {};
+	for (const [agent, entry] of Object.entries(taskFile)) {
+		const next = compactAgentEntry(entry, at);
+		if (next !== entry) compacted.push(agent);
+		file[agent] = next;
+	}
+	return {
+		file,
+		compacted
+	};
+}
+/** True when every agent in the task-PRD is already compacted+validated. */
+function canPromoteRouterEntry(taskFile) {
+	return Object.values(taskFile).every((entry) => isCompacted(entry));
+}
+//#endregion
+export { prdRouterPath as A, isCompacted as C, classifyPrdPath as D, withSubTaskValidated as E, isPrdScopedPath as O, filesOf as S, withRouterStatus as T, readRouterSync as _, taskCreate as a, writeRouter as b, isPrdFlagSet as c, hasAnyViolations as d, incompleteSubTasks as f, readRouter as g, readAllTaskFiles as h, taskComplete as i, prdDir as k, prdProjectRoot as l, readAgentReportSync as m, compactTaskFile as n, taskStart as o, readAgentReport as p, acquireLock as r, isPrdEnabled as s, canPromoteRouterEntry as t, crossCheckTask as u, readTaskFile as v, subTasksOf as w, writeTaskFile as x, readTaskFileSync as y };

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. */

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-BF1dZFjY.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-CDgBbPRz.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";