@fusengine/harness 0.1.91 → 0.1.93

package/README.md

@@ -64,6 +64,9 @@ don't assume either the old or the "everything in one place" story):
 | `harness check` | cli-mode: check staged files in a pre-commit step, exit non-zero on a violation. For harnesses without hooks. |
 | `harness doctor` | Print the version + resolved path of the harness *actually executing*, and compare it to npm's latest — the fast way to catch a stale global (see Pinning). |
 | `harness --version` | Print the running version (bare, on stdout) and exit. |
+| `harness prd status [--json]` | Read-only, works without `FUSE_PRD=1`. Print each task's router status and sub-task progress. |
+| `harness prd validate <task> [agent]` | Requires `FUSE_PRD=1`. Cross-check a task PRD against agent reports and promote matching sub-tasks/router entries to `validated`. |
+| `harness prd compact <task>` | Requires `FUSE_PRD=1`. Collapse a fully-validated task PRD to its compacted shape. |
 
 Every invocation writes a `@fusengine/harness vX.Y.Z` banner to **stderr** (never
 stdout — the hook JSON contract stays clean) so you can see which version ran.
@@ -313,6 +316,7 @@ non-zero exit is swallowed — a broken or absent player can never break a hook
 | `FUSE_LESSONS_THROTTLE_MIN` | Lessons-injection throttle, minutes (default `5`). |
 | `FUSE_ENFORCE_GEMINI_MCP` | **Opt-in (default off).** Blocks hand-written Tailwind UI (`.tsx/.jsx/.vue/.svelte`) until a `mcp__gemini-design__*` call is made this session. Read fresh per call (`src/policy/gemini-mcp-gate.ts`). |
 | `FUSE_DESIGN_GEMINI` | **Opt-in (default off), a *different* gate from the one above.** Enables the design-pipeline's own Gemini gates (`create_frontend` validation + "generate before hand-writing HTML/CSS") — inert unless a design agent is active (`src/policy/design/gates.ts:58-60`, see [docs/design.md](docs/design.md)). |
+| `FUSE_PRD` | **Opt-in (default off).** Set to exactly `1` to activate task/agent PRD ownership coordination — still inert without a `prd.json` router under `<homeSeg>/apex/`. See [PRD coordination](#prd-coordination-opt-in) below and [docs/prd.md](docs/prd.md). |
 | `FUSE_MCP_TTL_SEC` | MCP (Context7/Exa) cache freshness, seconds (default 48h, `src/runtime/mcp-key.ts`). |
 | `FUSE_WEBFETCH_TTL_SEC` | WebFetch cache freshness, seconds (default 24h — pages stale faster than docs). |
 | `FUSE_CONFIRM_SUBAGENT_WINDOW_SEC` | G0 cool-down (seconds, default `300`) for the `CONFIRM <code>` mechanism above — no token can be placed within this window of the last SubagentStart/Stop seen for the session. |
@@ -358,6 +362,18 @@ registerGuard(({ tool, command }) =>
     : null);
 ```
 
+## PRD coordination (opt-in)
+
+Set `FUSE_PRD=1` and write a router file so a lead can split one task
+across several sub-agents, each restricted to writing only its own
+report. Full walkthrough, guard behavior, and the CLI: [docs/prd.md](docs/prd.md).
+
+Minimal example — `.claude/apex/prd.json`:
+
+```json
+{ "auth-refactor": { "prd": "prd/auth-refactor-prd.json", "status": "assigned" } }
+```
+
 ## Subpath exports
 
 | Subpath | What |
@@ -386,6 +402,7 @@ registerGuard(({ tool, command }) =>
 | [docs/modules.md](https://github.com/fusengine/harness/blob/main/docs/modules.md) | cache · refs · state · memory · statusline · util |
 | [docs/adapters.md](https://github.com/fusengine/harness/blob/main/docs/adapters.md) | adapters, compatibility, `harness init`/`hook` wiring |
 | [docs/design.md](https://github.com/fusengine/harness/blob/main/docs/design.md) | design-agent pipeline — state machine, gates, opt-in Gemini |
+| [docs/prd.md](https://github.com/fusengine/harness/blob/main/docs/prd.md) | PRD task/agent ownership coordination — opt-in, `FUSE_PRD=1` |
 | [CHANGELOG.md](https://github.com/fusengine/harness/blob/main/CHANGELOG.md) | release history |
 
 Run `bun run docs:api` for the generated typedoc API reference.

package/dist/adapters/claude/index.mjs

@@ -1,2 +1,2 @@
-import { a as fileSizeGuard, c as readClaudeInput, i as denyResponse, l as systemMessage, n as blockResponse, o as guard, r as contextResponse, s as informResponse, t as attachSystemMessage, u as toClaudeResponse } from "../../claude-Ckv2_TgP.mjs";
+import { a as fileSizeGuard, c as readClaudeInput, i as denyResponse, l as systemMessage, n as blockResponse, o as guard, r as contextResponse, s as informResponse, t as attachSystemMessage, u as toClaudeResponse } from "../../claude-D62hkUfS.mjs";
 export { attachSystemMessage, blockResponse, contextResponse, denyResponse, fileSizeGuard, guard, informResponse, readClaudeInput, systemMessage, toClaudeResponse };

package/dist/adapters/codex/index.mjs

@@ -3,7 +3,7 @@ import { f as countLines } from "../../home-state-oUGFB4ds.mjs";
 import { t as formatPrompt } from "../../types-ernB1Dy3.mjs";
 import { i as parseApplyPatch, n as canonicalizeMcpToolName, r as canonicalizeCodexShellTool, t as isBypassPermissions } from "../../permission-mode-B-SFyR0X.mjs";
 import { t as commandToString } from "../../command-string-CALMTnwN.mjs";
-import { c as readClaudeInput, i as denyResponse, r as contextResponse, s as informResponse } from "../../claude-Ckv2_TgP.mjs";
+import { c as readClaudeInput, i as denyResponse, r as contextResponse, s as informResponse } from "../../claude-D62hkUfS.mjs";
 //#region src/adapters/codex/index.ts
 /**
 * OpenAI Codex CLI adapter (hook-mode). Codex's `PreToolUse` hook (since 2026)

package/dist/adapters/cursor/index.mjs

@@ -1,6 +1,6 @@
 import { t as evaluate } from "../../evaluate-CMiIqHeH.mjs";
 import { t as formatPrompt } from "../../types-ernB1Dy3.mjs";
-import { t as extractCursorEvent } from "../../normalize-BjG6unTj.mjs";
+import { t as extractCursorEvent } from "../../normalize-Dy8g9Ybl.mjs";
 //#region src/adapters/cursor/index.ts
 /** Cursor hook adapter; post-edit handling remains observe-only. */
 function guardCursor(payload) {

package/dist/adapters/hermes/index.mjs

@@ -1,2 +1,2 @@
-import { n as readHermesInput, r as toHermesResponse, t as guard } from "../../hermes-B9-p_3IF.mjs";
+import { n as readHermesInput, r as toHermesResponse, t as guard } from "../../hermes-ByopGx6C.mjs";
 export { guard, readHermesInput, toHermesResponse };

package/dist/adapters/kimi/index.mjs

@@ -1,2 +1,2 @@
-import { i as toKimiResponse, n as kimiDenyResponse, r as readKimiInput, t as guard } from "../../kimi-G2wcSh5-.mjs";
+import { i as toKimiResponse, n as kimiDenyResponse, r as readKimiInput, t as guard } from "../../kimi-C-Oia9q-.mjs";
 export { guard, kimiDenyResponse, readKimiInput, toKimiResponse };

package/dist/apex-target-Xc2M32Pl.mjs

@@ -0,0 +1,48 @@
+import { t as HOME_DIR } from "./dotenv-C1LkcfW-.mjs";
+//#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
+export { apexPlanTool as n, harnessHomeSegment as r, apexDocName as t };

package/dist/apex-task-store-Cb65rE5i.mjs

@@ -0,0 +1,467 @@
+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
+export { withRouterStatus as C, prdDir as D, isPrdScopedPath as E, prdRouterPath as O, subTasksOf as S, classifyPrdPath as T, readTaskFileSync as _, isPrdEnabled as a, filesOf as b, crossCheckTask as c, readAgentReport as d, readAgentReportSync as f, readTaskFile as g, readRouterSync as h, taskStart as i, hasAnyViolations as l, readRouter as m, taskComplete as n, isPrdFlagSet as o, readAllTaskFiles as p, taskCreate as r, prdProjectRoot as s, acquireLock as t, incompleteSubTasks as u, writeRouter as v, withSubTaskValidated as w, isCompacted as x, writeTaskFile as y };