@deftai/directive-core 0.82.0 → 0.84.0

package/dist/check/context.js

@@ -0,0 +1,28 @@
+import { existsSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+/** True when `path` is the directive framework source checkout root. */
+export function isFrameworkRepoRoot(path) {
+    const root = resolve(path);
+    return (existsSync(join(root, "packages", "cli", "package.json")) &&
+        existsSync(join(root, "biome.json")) &&
+        existsSync(join(root, "Taskfile.yml")));
+}
+/** Return true when running in the framework's own source checkout (#1519). */
+export function isFrameworkSourceContext(frameworkRoot, projectRoot) {
+    const fw = resolve(frameworkRoot);
+    const pr = resolve(projectRoot);
+    if (fw === pr) {
+        return true;
+    }
+    if (!isFrameworkRepoRoot(fw)) {
+        return false;
+    }
+    return pr.startsWith(`${fw}${sep}`);
+}
+/** Select the Taskfile target for the given context. */
+export function resolveCheckTarget(frameworkRoot, projectRoot) {
+    return isFrameworkSourceContext(frameworkRoot, projectRoot)
+        ? "check:framework-source"
+        : "check:consumer";
+}
+//# sourceMappingURL=context.js.map

package/dist/check/gate-lists.d.ts

@@ -0,0 +1,18 @@
+/** Gate execution order mirrors Taskfile.yml check targets (#1713 dogfood). */
+/**
+ * A check gate is either a bare Taskfile task name, or a public task plus CLI
+ * args (after `--`). Framework-only shims that are `internal: true` in
+ * Taskfile.yml cannot be shelled by name under go-task 3.50 (#2791) — use the
+ * public surface with the shim's flags instead.
+ */
+export type CheckGateSpec = string | {
+    readonly task: string;
+    readonly args?: readonly string[];
+};
+export declare function checkGateId(spec: CheckGateSpec): string;
+/** Args for `task … --taskfile <path>` (optional `--` + public CLI flags). */
+export declare function checkGateSpawnArgs(spec: CheckGateSpec, taskfilePath: string): string[];
+export declare const FRAMEWORK_CHECK_GATES: readonly CheckGateSpec[];
+export declare const CONSUMER_CHECK_GATES: readonly CheckGateSpec[];
+export declare function gatesForCheckTarget(target: string): readonly CheckGateSpec[];
+//# sourceMappingURL=gate-lists.d.ts.map

package/dist/check/gate-lists.js

@@ -0,0 +1,68 @@
+/** Gate execution order mirrors Taskfile.yml check targets (#1713 dogfood). */
+export function checkGateId(spec) {
+    return typeof spec === "string" ? spec : spec.task;
+}
+/** Args for `task … --taskfile <path>` (optional `--` + public CLI flags). */
+export function checkGateSpawnArgs(spec, taskfilePath) {
+    const task = checkGateId(spec);
+    const extra = typeof spec === "string" ? undefined : spec.args;
+    if (extra !== undefined && extra.length > 0) {
+        return [task, "--taskfile", taskfilePath, "--", ...extra];
+    }
+    return [task, "--taskfile", taskfilePath];
+}
+export const FRAMEWORK_CHECK_GATES = [
+    "ts:check-lane",
+    "toolchain:check",
+    "verify:stubs",
+    "verify:links",
+    "verify:rule-ownership",
+    "verify:biome-config",
+    "verify:content-manifest",
+    "verify:skill-external-fetch-gate",
+    "verify:contract-drift",
+    "verify:cursor-tier1",
+    "verify:go-freeze",
+    "verify:bridge-drift",
+    "verify:branch",
+    "verify:encoding",
+    "verify:forward-coverage",
+    "verify:vbrief-conformance",
+    "verify:destructive-gh-verbs",
+    "verify:scm-boundary",
+    "verify:xbrief-drift",
+    "verify:no-task-runtime",
+    "verify:cache-fresh",
+    "verify:pack-drift",
+    // Public surface for Taskfile verify-wip-cap-framework-self-check (#1124 / #2791)
+    { task: "verify:wip-cap", args: ["--allow-over-cap"] },
+    "verify:orphan-active",
+    "verify:agents-md-budget",
+    // Public surfaces for internal eval-relocation framework shims (#2791)
+    { task: "verify:eval-health-relocation", args: ["--base-ref", "origin/master"] },
+    { task: "verify:eval-triggers-relocation", args: ["--base-ref", "origin/master"] },
+    "vbrief:validate",
+    "codebase:validate-structure",
+    "verify:codebase-map-fresh",
+    "verify-strategy-output",
+];
+export const CONSUMER_CHECK_GATES = [
+    "doctor",
+    "toolchain:check-consumer",
+    "verify:branch",
+    "verify:cache-fresh",
+    "verify:wip-cap",
+    "verify:orphan-active",
+    "vbrief:validate",
+    "verify-strategy-output",
+];
+export function gatesForCheckTarget(target) {
+    if (target === "check:framework-source") {
+        return FRAMEWORK_CHECK_GATES;
+    }
+    if (target === "check:consumer") {
+        return CONSUMER_CHECK_GATES;
+    }
+    return [];
+}
+//# sourceMappingURL=gate-lists.js.map

package/dist/check/index.d.ts

@@ -1,3 +1,6 @@
-export type { CheckOrchestratorSeams } from "./orchestrator.js";
+export { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
+export { type CheckGateSpec, CONSUMER_CHECK_GATES, checkGateId, checkGateSpawnArgs, FRAMEWORK_CHECK_GATES, gatesForCheckTarget, } from "./gate-lists.js";
+export type { CheckOrchestratorOptions, CheckOrchestratorSeams } from "./orchestrator.js";
 export { dispatchTaskCheck, isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget, } from "./orchestrator.js";
+export { detectTestRunner, type RunnerDetectResult, runnerDetectionTable, type TestRunnerKind, } from "./runner-detect.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/check/index.js

@@ -1,2 +1,5 @@
+export { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
+export { CONSUMER_CHECK_GATES, checkGateId, checkGateSpawnArgs, FRAMEWORK_CHECK_GATES, gatesForCheckTarget, } from "./gate-lists.js";
 export { dispatchTaskCheck, isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget, } from "./orchestrator.js";
+export { detectTestRunner, runnerDetectionTable, } from "./runner-detect.js";
 //# sourceMappingURL=index.js.map

package/dist/check/orchestrator.d.ts

@@ -11,51 +11,9 @@
  *   1 -- one or more gates failed
  *   2 -- config error (missing args, task spawn error, etc.)
  */
-/** Seams for test isolation (allow injecting a custom task runner). */
-export interface CheckOrchestratorSeams {
-    /** Override the `task` binary path (default: "task"). */
-    readonly taskBin?: string;
-    /** Override the spawnSync implementation for unit testing. */
-    readonly spawnFn?: (cmd: string, args: string[], opts: {
-        cwd: string;
-        stdio: string;
-        env?: NodeJS.ProcessEnv;
-        timeoutMs?: number;
-    }) => {
-        status: number | null;
-        signal?: NodeJS.Signals | null;
-        error?: Error;
-    };
-    /** Child-process environment (default: process.env). */
-    readonly env?: NodeJS.ProcessEnv;
-    /** Wall-clock spawn timeout in milliseconds (default: none). */
-    readonly timeoutMs?: number;
-}
-/**
- * True when `path` is the directive framework source checkout root (not a
- * vendored `.deft/core` content deposit). Used to distinguish a maintainer
- * running `task check` from a subdirectory (#2220) from a consumer install.
- */
-export declare function isFrameworkRepoRoot(path: string): boolean;
-/**
- * Return true when running in the framework's own source checkout (#1519).
- *
- * Mirrors `is_framework_source_context` from _project_context.py with one
- * extension (#2220): when the Taskfile lives at the framework repo root,
- * `task check` may be invoked from a subdirectory (`USER_WORKING_DIR` !=
- * `TASKFILE_DIR`). Those invocations must still route to
- * `check:framework-source` so the biome lane runs. We do NOT resolve
- * symlinks on the framework root -- a consumer project may symlink
- * `.deft/core` to a local framework checkout and should still run the
- * consumer-safe gate (the deposit path lacks `packages/cli`).
- */
-export declare function isFrameworkSourceContext(frameworkRoot: string, projectRoot: string): boolean;
-/**
- * Select the Taskfile target for the given context.
- *
- * Mirrors _project_context.py::dispatch_task_check target selection.
- */
-export declare function resolveCheckTarget(frameworkRoot: string, projectRoot: string): string;
+import { type CheckOrchestratorSeams } from "./context.js";
+export type { CheckOrchestratorOptions, CheckOrchestratorSeams } from "./context.js";
+export { isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget } from "./context.js";
 /**
  * Dispatch to the context-appropriate `task check` aggregate target.
  *

package/dist/check/orchestrator.js

@@ -12,52 +12,10 @@
  *   2 -- config error (missing args, task spawn error, etc.)
  */
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-/**
- * True when `path` is the directive framework source checkout root (not a
- * vendored `.deft/core` content deposit). Used to distinguish a maintainer
- * running `task check` from a subdirectory (#2220) from a consumer install.
- */
-export function isFrameworkRepoRoot(path) {
-    const root = resolve(path);
-    return (existsSync(join(root, "packages", "cli", "package.json")) &&
-        existsSync(join(root, "biome.json")) &&
-        existsSync(join(root, "Taskfile.yml")));
-}
-/**
- * Return true when running in the framework's own source checkout (#1519).
- *
- * Mirrors `is_framework_source_context` from _project_context.py with one
- * extension (#2220): when the Taskfile lives at the framework repo root,
- * `task check` may be invoked from a subdirectory (`USER_WORKING_DIR` !=
- * `TASKFILE_DIR`). Those invocations must still route to
- * `check:framework-source` so the biome lane runs. We do NOT resolve
- * symlinks on the framework root -- a consumer project may symlink
- * `.deft/core` to a local framework checkout and should still run the
- * consumer-safe gate (the deposit path lacks `packages/cli`).
- */
-export function isFrameworkSourceContext(frameworkRoot, projectRoot) {
-    const fw = resolve(frameworkRoot);
-    const pr = resolve(projectRoot);
-    if (fw === pr) {
-        return true;
-    }
-    if (!isFrameworkRepoRoot(fw)) {
-        return false;
-    }
-    return pr.startsWith(`${fw}${sep}`);
-}
-/**
- * Select the Taskfile target for the given context.
- *
- * Mirrors _project_context.py::dispatch_task_check target selection.
- */
-export function resolveCheckTarget(frameworkRoot, projectRoot) {
-    return isFrameworkSourceContext(frameworkRoot, projectRoot)
-        ? "check:framework-source"
-        : "check:consumer";
-}
+import { join, resolve } from "node:path";
+import { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
+import { resolveCheckTarget } from "./context.js";
+export { isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget } from "./context.js";
 /**
  * Dispatch to the context-appropriate `task check` aggregate target.
  *
@@ -69,6 +27,10 @@ export function resolveCheckTarget(frameworkRoot, projectRoot) {
 export function dispatchTaskCheck(frameworkRoot, projectRoot, seams = {}) {
     const resolvedFramework = resolve(frameworkRoot);
     const resolvedProject = resolve(projectRoot);
+    const useTaskCache = seams.useTaskCache !== false && !seams.noCache;
+    if (useTaskCache) {
+        return dispatchCachedTaskCheck(resolvedFramework, resolvedProject, seams);
+    }
     const taskfilePath = join(resolvedFramework, "Taskfile.yml");
     const taskBin = seams.taskBin ?? "task";
     const target = resolveCheckTarget(resolvedFramework, resolvedProject);

package/dist/check/runner-detect.d.ts

@@ -0,0 +1,20 @@
+export type TestRunnerKind = "vitest" | "jest" | "go" | "pytest" | "none";
+export interface RunnerDetectResult {
+    readonly kind: TestRunnerKind;
+    readonly affectedArgs: readonly string[];
+    readonly source: "config" | "heuristic" | "fallback";
+    readonly message?: string;
+}
+export interface RunnerDetectOptions {
+    readonly projectRoot: string;
+    readonly override?: TestRunnerKind;
+}
+/** Auto-detect consumer test runner with explicit override (#1713). */
+export declare function detectTestRunner(options: RunnerDetectOptions): RunnerDetectResult;
+/** Human-readable detection table rows for docs. */
+export declare function runnerDetectionTable(): ReadonlyArray<{
+    runner: TestRunnerKind;
+    detection: string;
+    affectedConvention: string;
+}>;
+//# sourceMappingURL=runner-detect.d.ts.map

package/dist/check/runner-detect.js

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { projectDefinitionPath } from "../policy/index.js";
+const RUNNER_AFFECTED = {
+    vitest: ["--changed"],
+    jest: ["--onlyChanged"],
+    go: [],
+    pytest: ["--testmon"],
+};
+function affectedArgsFor(kind) {
+    if (kind === "none") {
+        return [];
+    }
+    return RUNNER_AFFECTED[kind];
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function detectFromPolicy(projectRoot) {
+    try {
+        const planPath = projectDefinitionPath(projectRoot);
+        const plan = readJson(planPath);
+        const raw = plan?.plan?.policy?.testRunner;
+        if (raw === "vitest" || raw === "jest" || raw === "go" || raw === "pytest" || raw === "none") {
+            return raw;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function detectFromHeuristics(projectRoot) {
+    const root = resolve(projectRoot);
+    if (existsSync(join(root, "go.mod"))) {
+        return "go";
+    }
+    const pkgPath = join(root, "package.json");
+    if (existsSync(pkgPath)) {
+        const pkg = readJson(pkgPath);
+        const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+        if ("vitest" in deps) {
+            return "vitest";
+        }
+        if ("jest" in deps || "@jest/core" in deps) {
+            return "jest";
+        }
+    }
+    if (existsSync(join(root, "pytest.ini")) ||
+        existsSync(join(root, "pyproject.toml")) ||
+        existsSync(join(root, "requirements.txt"))) {
+        return "pytest";
+    }
+    return null;
+}
+/** Auto-detect consumer test runner with explicit override (#1713). */
+export function detectTestRunner(options) {
+    if (options.override !== undefined) {
+        if (options.override === "none") {
+            return {
+                kind: "none",
+                affectedArgs: [],
+                source: "config",
+                message: "Runner override set to full-suite-only.",
+            };
+        }
+        return {
+            kind: options.override,
+            affectedArgs: affectedArgsFor(options.override),
+            source: "config",
+        };
+    }
+    const fromPolicy = detectFromPolicy(options.projectRoot);
+    if (fromPolicy !== null) {
+        return {
+            kind: fromPolicy,
+            affectedArgs: affectedArgsFor(fromPolicy),
+            source: "config",
+        };
+    }
+    const fromHeuristics = detectFromHeuristics(options.projectRoot);
+    if (fromHeuristics !== null) {
+        return {
+            kind: fromHeuristics,
+            affectedArgs: affectedArgsFor(fromHeuristics),
+            source: "heuristic",
+        };
+    }
+    return {
+        kind: "none",
+        affectedArgs: [],
+        source: "fallback",
+        message: "No supported test runner detected — merge gate uses the full suite.",
+    };
+}
+/** Human-readable detection table rows for docs. */
+export function runnerDetectionTable() {
+    return [
+        {
+            runner: "vitest",
+            detection: "package.json lists vitest, or plan.policy.testRunner = vitest",
+            affectedConvention: "vitest --changed",
+        },
+        {
+            runner: "jest",
+            detection: "package.json lists jest / @jest/core, or plan.policy.testRunner = jest",
+            affectedConvention: "jest --onlyChanged",
+        },
+        {
+            runner: "go",
+            detection: "go.mod present, or plan.policy.testRunner = go",
+            affectedConvention: "go test (native package cache)",
+        },
+        {
+            runner: "pytest",
+            detection: "pytest.ini / pyproject.toml / requirements.txt, or plan.policy.testRunner = pytest",
+            affectedConvention: "pytest --testmon",
+        },
+        {
+            runner: "none",
+            detection: "No match after config + heuristics",
+            affectedConvention: "Full suite at merge gate",
+        },
+    ];
+}
+//# sourceMappingURL=runner-detect.js.map

package/dist/eval/readback.js

@@ -1,5 +1,6 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { MAX_LINE_CHARS } from "../triage/welcome/constants.js";
 import { evaluateHealth, healthHistoryPath } from "./health.js";
 /** Repeat-suppression window for the budgeted eval session nudge (#1703 / #1279 parity). */
@@ -124,10 +125,14 @@ function appendEvalReadbackHistory(projectRoot, nudgeKey, line, options = {}) {
         line,
     };
     try {
+        assertWriteTargetSafe(projectRoot, path);
         mkdirSync(join(path, ".."), { recursive: true });
         appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
     }
-    catch {
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            throw err;
+        }
         // observability only
     }
 }

package/dist/hooks/cursor-hooks.d.ts

@@ -0,0 +1,23 @@
+/** Cursor ApplyPatch spellings handled by the project adapter, not generic write dispatch. */
+export declare const APPLY_PATCH_TOOL_NAMES: readonly ["ApplyPatch", "apply_patch"];
+export declare const APPLY_PATCH_HOOK_MATCHER: string;
+/** Generic Cursor write matcher excludes ApplyPatch — adapter owns it (#2764). */
+export declare const CURSOR_GENERIC_WRITE_TOOL_NAMES: ("Edit" | "Write" | "WriteFile" | "CreateFile" | "MultiEdit" | "NotebookEdit" | "StrReplace" | "SearchReplace" | "Delete" | "DeleteFile" | "ApplyPatch" | "apply_patch")[];
+export declare const CURSOR_GENERIC_WRITE_HOOK_MATCHER: string;
+export declare const CURSOR_APPLY_PATCH_ADAPTER_RELATIVE = ".cursor/hooks/deft-cursor-hook-adapter.mjs";
+export declare const DEFT_CURSOR_ADAPTER_COMMAND_MARKER = "deft-cursor-hook-adapter.mjs";
+export declare const CURSOR_APPLY_PATCH_ADAPTER_COMMAND = "node .cursor/hooks/deft-cursor-hook-adapter.mjs ApplyPatch";
+/** Deposited adapter forwards free-form ApplyPatch stdin to hook:dispatch with explicit project root. */
+export declare const CURSOR_APPLY_PATCH_ADAPTER_SOURCE = "#!/usr/bin/env node\nimport { spawnSync } from \"node:child_process\";\nimport { readFileSync } from \"node:fs\";\nimport { resolve } from \"node:path\";\n\nconst projectRoot = resolve(process.cwd());\nconst stdin = readFileSync(0, \"utf8\");\n\nfunction deftCommand() {\n  for (const candidate of [\"deft\", \"directive\"]) {\n    const probe = spawnSync(candidate, [\"--version\"], {\n      encoding: \"utf8\",\n      stdio: \"ignore\",\n      shell: process.platform === \"win32\",\n      windowsHide: true,\n    });\n    if (probe.error === undefined && probe.status === 0) return candidate;\n  }\n  process.stderr.write(\n    \"Directive ApplyPatch adapter: neither deft nor directive is on PATH.\\n\",\n  );\n  process.exit(2);\n}\n\nconst cli = deftCommand();\nconst result = spawnSync(\n  cli,\n  [\n    \"hook:dispatch\",\n    \"--host\",\n    \"cursor\",\n    \"--event\",\n    \"tool.before\",\n    \"--project-root\",\n    projectRoot,\n  ],\n  {\n    input: stdin,\n    encoding: \"utf8\",\n    stdio: [\"pipe\", \"pipe\", \"pipe\"],\n    shell: process.platform === \"win32\",\n    windowsHide: true,\n  },\n);\n\nif (result.stderr) process.stderr.write(result.stderr);\nif (result.error) {\n  process.stderr.write(String(result.error));\n  process.exit(2);\n}\nif (result.status !== 0 && result.status !== null) {\n  if (result.stdout) process.stdout.write(result.stdout);\n  process.exit(result.status);\n}\n// Cursor failClosed treats empty stdout as failure \u2014 normalize allow.\nconst out = (result.stdout ?? \"\").trim();\nprocess.stdout.write((out.length > 0 ? out : '{\"permission\":\"allow\"}') + \"\\n\");\nprocess.exit(0);\n";
+export interface CursorPreToolUseEntry {
+    readonly command: string;
+    readonly matcher?: string;
+    readonly failClosed?: boolean;
+    readonly timeout?: number;
+}
+export declare function cursorApplyPatchAdapterEntry(): CursorPreToolUseEntry;
+/** True when generic and adapter matchers share no tool tokens. */
+export declare function cursorApplyPatchMatchersDisjoint(): boolean;
+/** Fail closed when Cursor hook projection would double-dispatch ApplyPatch (#2764). */
+export declare function assertCursorApplyPatchMatchersDisjoint(): void;
+//# sourceMappingURL=cursor-hooks.d.ts.map

package/dist/hooks/cursor-hooks.js

@@ -0,0 +1,95 @@
+import { DIRECT_WRITE_TOOL_NAMES } from "./tools.js";
+/** Cursor ApplyPatch spellings handled by the project adapter, not generic write dispatch. */
+export const APPLY_PATCH_TOOL_NAMES = ["ApplyPatch", "apply_patch"];
+export const APPLY_PATCH_HOOK_MATCHER = APPLY_PATCH_TOOL_NAMES.join("|");
+const APPLY_PATCH_TOOLS = new Set(APPLY_PATCH_TOOL_NAMES);
+/** Generic Cursor write matcher excludes ApplyPatch — adapter owns it (#2764). */
+export const CURSOR_GENERIC_WRITE_TOOL_NAMES = DIRECT_WRITE_TOOL_NAMES.filter((name) => !APPLY_PATCH_TOOLS.has(name));
+export const CURSOR_GENERIC_WRITE_HOOK_MATCHER = CURSOR_GENERIC_WRITE_TOOL_NAMES.join("|");
+export const CURSOR_APPLY_PATCH_ADAPTER_RELATIVE = ".cursor/hooks/deft-cursor-hook-adapter.mjs";
+export const DEFT_CURSOR_ADAPTER_COMMAND_MARKER = "deft-cursor-hook-adapter.mjs";
+export const CURSOR_APPLY_PATCH_ADAPTER_COMMAND = `node ${CURSOR_APPLY_PATCH_ADAPTER_RELATIVE} ApplyPatch`;
+/** Deposited adapter forwards free-form ApplyPatch stdin to hook:dispatch with explicit project root. */
+export const CURSOR_APPLY_PATCH_ADAPTER_SOURCE = `#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const projectRoot = resolve(process.cwd());
+const stdin = readFileSync(0, "utf8");
+
+function deftCommand() {
+  for (const candidate of ["deft", "directive"]) {
+    const probe = spawnSync(candidate, ["--version"], {
+      encoding: "utf8",
+      stdio: "ignore",
+      shell: process.platform === "win32",
+      windowsHide: true,
+    });
+    if (probe.error === undefined && probe.status === 0) return candidate;
+  }
+  process.stderr.write(
+    "Directive ApplyPatch adapter: neither deft nor directive is on PATH.\\n",
+  );
+  process.exit(2);
+}
+
+const cli = deftCommand();
+const result = spawnSync(
+  cli,
+  [
+    "hook:dispatch",
+    "--host",
+    "cursor",
+    "--event",
+    "tool.before",
+    "--project-root",
+    projectRoot,
+  ],
+  {
+    input: stdin,
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: process.platform === "win32",
+    windowsHide: true,
+  },
+);
+
+if (result.stderr) process.stderr.write(result.stderr);
+if (result.error) {
+  process.stderr.write(String(result.error));
+  process.exit(2);
+}
+if (result.status !== 0 && result.status !== null) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  process.exit(result.status);
+}
+// Cursor failClosed treats empty stdout as failure — normalize allow.
+const out = (result.stdout ?? "").trim();
+process.stdout.write((out.length > 0 ? out : '{"permission":"allow"}') + "\\n");
+process.exit(0);
+`;
+export function cursorApplyPatchAdapterEntry() {
+    return {
+        command: CURSOR_APPLY_PATCH_ADAPTER_COMMAND,
+        matcher: APPLY_PATCH_HOOK_MATCHER,
+        failClosed: true,
+        timeout: 5,
+    };
+}
+/** True when generic and adapter matchers share no tool tokens. */
+export function cursorApplyPatchMatchersDisjoint() {
+    const generic = new Set(CURSOR_GENERIC_WRITE_HOOK_MATCHER.split("|"));
+    for (const token of APPLY_PATCH_HOOK_MATCHER.split("|")) {
+        if (generic.has(token))
+            return false;
+    }
+    return true;
+}
+/** Fail closed when Cursor hook projection would double-dispatch ApplyPatch (#2764). */
+export function assertCursorApplyPatchMatchersDisjoint() {
+    if (!cursorApplyPatchMatchersDisjoint()) {
+        throw new Error("Cursor ApplyPatch and generic direct-write matchers overlap — refusing hook deposit (#2764).");
+    }
+}
+//# sourceMappingURL=cursor-hooks.js.map

package/dist/hooks/dispatcher.d.ts

@@ -67,11 +67,20 @@ export declare function toProjectRelativePosix(projectRoot: string, targetPath:
  * planning, not implementation dispatch — exempt from the active-scope gate (#2625).
  */
 export declare function isProposedLifecycleWrite(projectRoot: string, targetPath: string | null): boolean;
+/** Normalize hook project-root resolution on Windows (doubled drive + MSYS `/c/...`). */
+export declare function normalizeHookProjectRoot(path: string): string;
 export declare function projectRootFromHookPayload(payload: unknown, fallback: string): string;
 export declare function isHookHost(value: string): value is HookHost;
 export declare function isHookEvent(value: string): value is HookEvent;
 /** Decide a normalized event using only the P0 direct-write policy. */
 export declare function decideHook(input: HookDispatchInput, seams?: HookPolicySeams): HookDecision;
-/** Render only authoritative denials; allow preserves the host's own permission flow. */
+/**
+ * Render host-facing hook output.
+ *
+ * Cursor deposits use `failClosed: true`. Cursor treats empty/null stdout as a
+ * hook failure and blocks the tool — so Cursor allows must emit explicit
+ * `{"permission":"allow"}`. Other hosts keep empty allow so the host permission
+ * flow is unchanged.
+ */
 export declare function renderHostDecision(host: HookHost, decision: HookDecision): string;
 //# sourceMappingURL=dispatcher.d.ts.map

package/dist/hooks/dispatcher.js

@@ -161,13 +161,62 @@ export function isProposedLifecycleWrite(projectRoot, targetPath) {
         return false;
     return posix.startsWith("xbrief/proposed/") || posix.startsWith("vbrief/proposed/");
 }
+function isWindowsDriveOnlyRoot(value) {
+    return /^[A-Za-z]:[/\\]?$/.test(value.trim());
+}
+function hookPayloadRootCandidates(input) {
+    const candidates = [];
+    const push = (value) => {
+        if (typeof value === "string" && value.trim().length > 0) {
+            candidates.push(value.trim());
+        }
+    };
+    push(input.workspaceRoot);
+    push(input.workspace_root);
+    const workspaceRoots = input.workspace_roots;
+    if (Array.isArray(workspaceRoots)) {
+        for (const entry of workspaceRoots)
+            push(entry);
+    }
+    push(input.cwd);
+    return candidates;
+}
+/** Collapse join('C:', 'c:\\...') doubled drive prefix on Windows (#2787). */
+function collapseDoubledWindowsDrivePrefix(path) {
+    return path.replace(/^([A-Za-z]:\\)(?=[A-Za-z]:\\)/i, "");
+}
+function msysPathToWin32(path) {
+    const match = /^\/([a-zA-Z])\/(.*)$/.exec(path.trim());
+    if (match === null || match[1] === undefined || match[2] === undefined)
+        return null;
+    return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+}
+/** Normalize hook project-root resolution on Windows (doubled drive + MSYS `/c/...`). */
+export function normalizeHookProjectRoot(path) {
+    if (process.platform !== "win32")
+        return resolve(path);
+    const trimmed = path.trim();
+    const msys = msysPathToWin32(trimmed);
+    let resolved = resolve(msys ?? trimmed);
+    const collapsed = collapseDoubledWindowsDrivePrefix(resolved);
+    if (collapsed !== resolved) {
+        resolved = resolve(collapsed);
+    }
+    if (/^[a-z]:\\/.test(resolved)) {
+        resolved = `${resolved.charAt(0).toUpperCase()}${resolved.slice(1)}`;
+    }
+    return resolved;
+}
 export function projectRootFromHookPayload(payload, fallback) {
+    const fallbackResolved = normalizeHookProjectRoot(fallback);
     const input = record(payload);
     if (input === null)
-        return resolve(fallback);
-    const workspaceRoots = input.workspace_roots;
-    const root = firstString(input.workspaceRoot, input.workspace_root, Array.isArray(workspaceRoots) ? workspaceRoots[0] : null, input.cwd, fallback);
-    return resolve(root ?? fallback);
+        return fallbackResolved;
+    const usable = hookPayloadRootCandidates(input).find((candidate) => !isWindowsDriveOnlyRoot(candidate));
+    if (usable !== undefined) {
+        return normalizeHookProjectRoot(usable);
+    }
+    return fallbackResolved;
 }
 export function isHookHost(value) {
     return HOOK_HOSTS.includes(value);
@@ -411,10 +460,21 @@ export function decideHook(input, seams = {}) {
     }
     return inspectMutationGates(input, toolName, seams, { proposedLifecycleExempt: true });
 }
-/** Render only authoritative denials; allow preserves the host's own permission flow. */
+/**
+ * Render host-facing hook output.
+ *
+ * Cursor deposits use `failClosed: true`. Cursor treats empty/null stdout as a
+ * hook failure and blocks the tool — so Cursor allows must emit explicit
+ * `{"permission":"allow"}`. Other hosts keep empty allow so the host permission
+ * flow is unchanged.
+ */
 export function renderHostDecision(host, decision) {
-    if (decision.verdict === "allow")
+    if (decision.verdict === "allow") {
+        if (host === "cursor") {
+            return JSON.stringify({ permission: "allow" });
+        }
         return "";
+    }
     switch (host) {
         case "claude":
         case "codex":