@deftai/directive-core 0.82.0 → 0.83.0

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

@@ -72,6 +72,13 @@ 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,20 @@ 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());
+}
 export function projectRootFromHookPayload(payload, fallback) {
     const input = record(payload);
+    const fallbackResolved = resolve(fallback);
     if (input === null)
-        return resolve(fallback);
+        return fallbackResolved;
     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);
+    const candidate = firstString(input.workspaceRoot, input.workspace_root, Array.isArray(workspaceRoots) ? workspaceRoots[0] : null, input.cwd);
+    if (candidate === null || isWindowsDriveOnlyRoot(candidate)) {
+        return fallbackResolved;
+    }
+    return resolve(candidate);
 }
 export function isHookHost(value) {
     return HOOK_HOSTS.includes(value);
@@ -411,10 +418,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":

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./cursor-hooks.js";
 export * from "./dispatcher.js";
 export * from "./scope.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -1,3 +1,4 @@
+export * from "./cursor-hooks.js";
 export * from "./dispatcher.js";
 export * from "./scope.js";
 //# sourceMappingURL=index.js.map

package/dist/init-deposit/agent-hooks.d.ts

@@ -1,5 +1,7 @@
 import type { HookHost } from "../hooks/dispatcher.js";
+import { type HostHooksPolicy } from "../policy/host-hooks.js";
 import type { InitDepositIo } from "./constants.js";
+export { CURSOR_GENERIC_WRITE_HOOK_MATCHER, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 export { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
 export declare const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
 export declare const AGENT_HOOK_PATHS: readonly [".claude/settings.json", ".grok/hooks/deft.json", ".cursor/hooks.json", ".codex/hooks.json"];
@@ -19,7 +21,7 @@ export interface AgentHookDepositResult {
     readonly changedPaths: AgentHookPath[];
 }
 /** Merge Directive-owned project hook entries without replacing user configuration. */
-export declare function writeAgentHookDeposit(projectRoot: string, io?: InitDepositIo): AgentHookDepositResult;
+export declare function writeAgentHookDeposit(projectRoot: string, io?: InitDepositIo, hostHooksPolicy?: HostHooksPolicy): AgentHookDepositResult;
 /** Read-only registration probe shared by verify and doctor. */
-export declare function inspectAgentHookDeposit(projectRoot: string): AgentHookInspection[];
+export declare function inspectAgentHookDeposit(projectRoot: string, hostHooksPolicy?: HostHooksPolicy): AgentHookInspection[];
 //# sourceMappingURL=agent-hooks.d.ts.map

package/dist/init-deposit/agent-hooks.js

@@ -1,7 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { assertDepositContained } from "../deposit/contain.js";
+import { assertCursorApplyPatchMatchersDisjoint, CURSOR_APPLY_PATCH_ADAPTER_RELATIVE, CURSOR_APPLY_PATCH_ADAPTER_SOURCE, CURSOR_GENERIC_WRITE_HOOK_MATCHER, cursorApplyPatchAdapterEntry, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 import { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
+import { isHostHookDepositEnabled, loadHostHooksPolicyFromProject, } from "../policy/host-hooks.js";
+export { CURSOR_GENERIC_WRITE_HOOK_MATCHER, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 export { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
 export const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
 export const AGENT_HOOK_PATHS = [
@@ -63,9 +66,18 @@ function nestedCommands(value) {
 function isManagedNestedGroup(value) {
     return nestedCommands(value).some((value) => value.includes(DEFT_HOOK_COMMAND_MARKER));
 }
+function isManagedNestedGroupForHost(value, host) {
+    return nestedCommands(value).some((command) => command.includes(DEFT_HOOK_COMMAND_MARKER) && command.includes(`--host ${host}`));
+}
 function isManagedCursorEntry(value) {
     const entry = object(value);
-    return typeof entry?.command === "string" && entry.command.includes(DEFT_HOOK_COMMAND_MARKER);
+    if (typeof entry?.command !== "string")
+        return false;
+    return (entry.command.includes(DEFT_HOOK_COMMAND_MARKER) ||
+        entry.command.includes(DEFT_CURSOR_ADAPTER_COMMAND_MARKER));
+}
+function isManagedCursorEntryForHost(value) {
+    return isManagedCursorEntry(value);
 }
 function nestedGroup(host, event, matcher) {
     return {
@@ -97,7 +109,40 @@ function mergeNestedConfig(config, path, host, options = {}) {
     }
     return { ...config, hooks };
 }
+function stripManagedNestedConfig(config, path, host) {
+    const hooks = hooksObject(config, path);
+    const nextHooks = {};
+    for (const key of ["SessionStart", "PreToolUse", "PreCompact", "PostCompact"]) {
+        if (!(key in hooks))
+            continue;
+        const filtered = eventArray(hooks, key, path).filter((entry) => !isManagedNestedGroupForHost(entry, host));
+        if (filtered.length > 0)
+            nextHooks[key] = filtered;
+    }
+    if (Object.keys(nextHooks).length === 0) {
+        const { hooks: _hooks, ...rest } = config;
+        return rest;
+    }
+    return { ...config, hooks: nextHooks };
+}
+function stripManagedCursorConfig(config, path) {
+    const hooks = hooksObject(config, path);
+    const nextHooks = {};
+    for (const key of ["sessionStart", "preToolUse", "preCompact"]) {
+        if (!(key in hooks))
+            continue;
+        const filtered = eventArray(hooks, key, path).filter((entry) => !isManagedCursorEntryForHost(entry));
+        if (filtered.length > 0)
+            nextHooks[key] = filtered;
+    }
+    if (Object.keys(nextHooks).length === 0) {
+        const { hooks: _hooks, version: _version, ...rest } = config;
+        return rest;
+    }
+    return { ...config, version: 1, hooks: nextHooks };
+}
 function mergeCursorConfig(config, path) {
+    assertCursorApplyPatchMatchersDisjoint();
     const hooks = hooksObject(config, path);
     const session = eventArray(hooks, "sessionStart", path).filter((entry) => !isManagedCursorEntry(entry));
     const preTool = eventArray(hooks, "preToolUse", path).filter((entry) => !isManagedCursorEntry(entry));
@@ -105,9 +150,10 @@ function mergeCursorConfig(config, path) {
     hooks.sessionStart = [...session, { command: command("cursor", "session.start"), timeout: 5 }];
     hooks.preToolUse = [
         ...preTool,
+        cursorApplyPatchAdapterEntry(),
         {
             command: command("cursor", "tool.before"),
-            matcher: DIRECT_WRITE_HOOK_MATCHER,
+            matcher: CURSOR_GENERIC_WRITE_HOOK_MATCHER,
             failClosed: true,
             timeout: 5,
         },
@@ -121,6 +167,15 @@ function mergeCursorConfig(config, path) {
     hooks.preCompact = [...preCompact, { command: command("cursor", "session.compact"), timeout: 5 }];
     return { ...config, version: 1, hooks };
 }
+function writeTextIfChanged(path, contents) {
+    if (existsSync(path) && readFileSync(path, "utf8") === contents)
+        return false;
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.deft-${process.pid}.tmp`;
+    writeFileSync(temporary, contents, "utf8");
+    renameSync(temporary, path);
+    return true;
+}
 function writeJsonIfChanged(path, payload) {
     const next = `${JSON.stringify(payload, null, 2)}\n`;
     if (existsSync(path) && readFileSync(path, "utf8") === next)
@@ -132,41 +187,93 @@ function writeJsonIfChanged(path, payload) {
     return true;
 }
 /** Merge Directive-owned project hook entries without replacing user configuration. */
-export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefined }) {
+export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefined }, hostHooksPolicy = loadHostHooksPolicyFromProject(projectRoot)) {
     const changedPaths = [];
+    const strippedPaths = [];
     const definitions = [
         {
+            host: "claude",
             path: AGENT_HOOK_PATHS[0],
             merge: (config, path) => mergeNestedConfig(config, path, "claude", { compact: true }),
+            strip: (config, path) => stripManagedNestedConfig(config, path, "claude"),
         },
         {
+            host: "grok",
             path: AGENT_HOOK_PATHS[1],
             merge: (config, path) => mergeNestedConfig(config, path, "grok", { compact: true }),
+            strip: (config, path) => stripManagedNestedConfig(config, path, "grok"),
+        },
+        {
+            host: "cursor",
+            path: AGENT_HOOK_PATHS[2],
+            merge: mergeCursorConfig,
+            strip: stripManagedCursorConfig,
         },
-        { path: AGENT_HOOK_PATHS[2], merge: mergeCursorConfig },
         {
+            host: "codex",
             path: AGENT_HOOK_PATHS[3],
             merge: (config, path) => mergeNestedConfig(config, path, "codex", { compact: false }),
+            strip: (config, path) => stripManagedNestedConfig(config, path, "codex"),
         },
     ];
     const prepared = definitions.map((definition) => {
         const absolute = join(projectRoot, definition.path);
         assertDepositContained(projectRoot, absolute);
-        const merged = definition.merge(readConfig(absolute), absolute);
-        return { ...definition, absolute, merged };
+        if (!isHostHookDepositEnabled(definition.host, hostHooksPolicy)) {
+            if (!existsSync(absolute))
+                return { mode: "skip" };
+            return {
+                mode: "strip",
+                absolute,
+                path: definition.path,
+                payload: definition.strip(readConfig(absolute), absolute),
+            };
+        }
+        return {
+            mode: "merge",
+            absolute,
+            path: definition.path,
+            payload: definition.merge(readConfig(absolute), absolute),
+        };
     });
-    for (const definition of prepared) {
-        if (writeJsonIfChanged(definition.absolute, definition.merged)) {
-            changedPaths.push(definition.path);
+    for (const item of prepared) {
+        if (item.mode === "skip")
+            continue;
+        if (writeJsonIfChanged(item.absolute, item.payload)) {
+            if (item.mode === "strip")
+                strippedPaths.push(item.path);
+            else
+                changedPaths.push(item.path);
+        }
+    }
+    const adapterAbsolute = join(projectRoot, CURSOR_APPLY_PATCH_ADAPTER_RELATIVE);
+    assertDepositContained(projectRoot, adapterAbsolute);
+    if (isHostHookDepositEnabled("cursor", hostHooksPolicy)) {
+        if (writeTextIfChanged(adapterAbsolute, CURSOR_APPLY_PATCH_ADAPTER_SOURCE)) {
+            if (!changedPaths.includes(AGENT_HOOK_PATHS[2])) {
+                changedPaths.push(AGENT_HOOK_PATHS[2]);
+            }
+        }
+    }
+    else if (existsSync(adapterAbsolute)) {
+        rmSync(adapterAbsolute, { force: true });
+        if (!strippedPaths.includes(AGENT_HOOK_PATHS[2])) {
+            strippedPaths.push(AGENT_HOOK_PATHS[2]);
         }
     }
     if (changedPaths.length > 0) {
         io.printf(`Installed Directive agent hooks: ${changedPaths.join(", ")}\n`);
     }
-    else {
+    if (strippedPaths.length > 0) {
+        io.printf(`Removed Directive-managed agent hooks (plan.policy.hostHooks opt-out): ${strippedPaths.join(", ")}\n`);
+    }
+    if (changedPaths.length === 0 && strippedPaths.length === 0) {
         io.printf("Directive agent hooks already current.\n");
     }
-    return { changed: changedPaths.length > 0, changedPaths };
+    return {
+        changed: changedPaths.length + strippedPaths.length > 0,
+        changedPaths: [...changedPaths, ...strippedPaths],
+    };
 }
 function hasNestedRegistration(config, host, options = {}) {
     const hooks = object(config.hooks);
@@ -202,11 +309,18 @@ function hasCursorRegistration(config) {
     const session = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
     const preTool = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
     const preCompact = Array.isArray(hooks.preCompact) ? hooks.preCompact : [];
+    const adapter = cursorApplyPatchAdapterEntry();
     return (session.some((entry) => object(entry)?.command === command("cursor", "session.start")) &&
         preTool.some((entry) => {
             const hook = object(entry);
             return (hook?.command === command("cursor", "tool.before") &&
-                hook.matcher === DIRECT_WRITE_HOOK_MATCHER &&
+                hook.matcher === CURSOR_GENERIC_WRITE_HOOK_MATCHER &&
+                hook.failClosed === true);
+        }) &&
+        preTool.some((entry) => {
+            const hook = object(entry);
+            return (hook?.command === adapter.command &&
+                hook.matcher === adapter.matcher &&
                 hook.failClosed === true);
         }) &&
         preTool.some((entry) => {
@@ -218,7 +332,7 @@ function hasCursorRegistration(config) {
         preCompact.some((entry) => object(entry)?.command === command("cursor", "session.compact")));
 }
 /** Read-only registration probe shared by verify and doctor. */
-export function inspectAgentHookDeposit(projectRoot) {
+export function inspectAgentHookDeposit(projectRoot, hostHooksPolicy = loadHostHooksPolicyFromProject(projectRoot)) {
     const definitions = [
         {
             host: "claude",
@@ -250,6 +364,15 @@ export function inspectAgentHookDeposit(projectRoot) {
         const compactNote = definition.compactSupport === "unsupported"
             ? " Compact re-arm is not deposited for Codex (no native compact hook surface)."
             : " PreCompact/PostCompact or preCompact compact re-arm is deposited.";
+        if (!isHostHookDepositEnabled(definition.host, hostHooksPolicy)) {
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "healthy",
+                compactSupport: definition.compactSupport,
+                detail: `plan.policy.hostHooks.${definition.host} is false — Directive hook deposit is skipped for this host.`,
+            };
+        }
         if (!existsSync(absolute)) {
             return {
                 host: definition.host,

package/dist/init-deposit/hygiene.js

@@ -24,6 +24,7 @@ export function installerManagedMatchers() {
         { exact: ".claude/settings.json" },
         { exact: ".grok/hooks/deft.json" },
         { exact: ".cursor/hooks.json" },
+        { exact: ".cursor/hooks/deft-cursor-hook-adapter.mjs" },
         { exact: ".codex/hooks.json" },
         { exact: ".gitattributes" },
         { exact: ".gitignore" },

package/dist/lifecycle/events.d.ts

@@ -32,6 +32,7 @@ export interface BehavioralEventRecord {
 export declare function emit(name: string, payload: Record<string, unknown>, options?: {
     logPath?: string | null;
     detectedAt?: string | null;
+    projectRoot?: string | null;
 }): BehavioralEventRecord;
 /** Return all events from the log in emission order. */
 export declare function readEvents(logPath?: string | null): BehavioralEventRecord[];

package/dist/lifecycle/events.js

@@ -1,9 +1,10 @@
 import { randomBytes } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, writeSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { contentRoot } from "../content-root.js";
 import { ATTRIBUTION_REQUIRED_PAYLOAD } from "../events/attribution-constants.js";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 /** Default event log location (project-local). */
 export const DEFAULT_EVENT_LOG = join(".deft-cache", "events.jsonl");
 const BEHAVIORAL_CATEGORY = "behavioral";
@@ -125,15 +126,62 @@ function sortKeysDeep(value) {
 function jsonStringifySorted(value) {
     return JSON.stringify(sortKeysDeep(value));
 }
-function resolveLogPath(logPath) {
+function resolveLogPath(logPath, projectRoot) {
     if (logPath !== undefined && logPath !== null) {
-        return resolve(logPath);
+        return isAbsolute(logPath) ? resolve(logPath) : resolve(projectRoot, logPath);
     }
     const envPath = process.env.DEFT_EVENT_LOG;
     if (envPath !== undefined && envPath.length > 0) {
-        return resolve(envPath);
+        return isAbsolute(envPath) ? resolve(envPath) : resolve(projectRoot, envPath);
+    }
+    return resolve(projectRoot, DEFAULT_EVENT_LOG);
+}
+function isNestedUnder(parent, child) {
+    const rel = relative(resolve(parent), resolve(child));
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function assertPathComponentsNotSymlinks(projectDir, targetPath) {
+    const targetAbs = resolve(targetPath);
+    const projectAbs = resolve(projectDir);
+    let current = targetAbs;
+    const chain = [];
+    while (true) {
+        chain.unshift(current);
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    for (const segment of chain) {
+        let info;
+        try {
+            info = lstatSync(segment);
+        }
+        catch {
+            continue;
+        }
+        if (info.isSymbolicLink()) {
+            throw new ProjectionContainmentError(`projection write refused: ${segment} is a symlink on the write path`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: segment });
+        }
+    }
+}
+/** Refuse symlink write targets for project-owned and explicit event logs (#2766). */
+function assertEventLogTargetSafe(projectRoot, targetPath) {
+    if (isNestedUnder(projectRoot, targetPath)) {
+        assertWriteTargetSafe(projectRoot, targetPath);
+        return;
+    }
+    assertPathComponentsNotSymlinks(projectRoot, targetPath);
+}
+function appendLineNoFollow(target, line) {
+    const fd = openSync(target, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW, 0o644);
+    try {
+        writeSync(fd, Buffer.from(line, "utf8"));
+    }
+    finally {
+        closeSync(fd);
     }
-    return resolve(DEFAULT_EVENT_LOG);
 }
 function newEventId() {
     const wallNs = BigInt(Date.now()) * 1000000n;
@@ -160,14 +208,16 @@ export function emit(name, payload, options = {}) {
         detected_at: options.detectedAt ?? `${iso.slice(0, 19)}Z`,
         payload: { ...payload },
     };
-    const target = resolveLogPath(options.logPath);
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const target = resolveLogPath(options.logPath, projectRoot);
+    assertEventLogTargetSafe(projectRoot, target);
     mkdirSync(dirname(target), { recursive: true });
-    appendFileSync(target, `${jsonStringifySorted(record)}\n`, "utf8");
+    appendLineNoFollow(target, `${jsonStringifySorted(record)}\n`);
     return record;
 }
 /** Return all events from the log in emission order. */
 export function readEvents(logPath) {
-    const target = resolveLogPath(logPath);
+    const target = resolveLogPath(logPath, process.cwd());
     if (!existsSync(target)) {
         return [];
     }

package/dist/policy/host-hooks.d.ts

@@ -0,0 +1,21 @@
+import type { HookHost } from "../hooks/dispatcher.js";
+export declare const FIELD_HOST_HOOKS = "plan.policy.hostHooks";
+export declare const FIELD_HOST_HOOKS_CLI_ALIAS = "hostHooks";
+/** Per-host Directive hook deposit toggles (#2752). */
+export type HostHooksPolicy = Record<HookHost, boolean>;
+export declare const DEFAULT_HOST_HOOKS_POLICY: HostHooksPolicy;
+export interface HostHooksPolicyField {
+    readonly name: string;
+    readonly current: HostHooksPolicy;
+    readonly default: HostHooksPolicy;
+    readonly source: string;
+}
+/** Resolve typed host hook deposit policy from raw PROJECT-DEFINITION value. */
+export declare function resolveHostHooksPolicy(raw: unknown): HostHooksPolicy;
+export declare function validateHostHooks(value: unknown): string[];
+export declare function isHostHookDepositEnabled(host: HookHost, policy?: HostHooksPolicy): boolean;
+/** Inspector row for `policy:show --field=hostHooks`. */
+export declare function inspectHostHooks(data: Record<string, unknown> | null): HostHooksPolicyField;
+/** Resolve host hook deposit policy from PROJECT-DEFINITION on disk. */
+export declare function loadHostHooksPolicyFromProject(projectRoot: string): HostHooksPolicy;
+//# sourceMappingURL=host-hooks.d.ts.map

package/dist/policy/host-hooks.js

@@ -0,0 +1,96 @@
+import { HOOK_HOSTS } from "../hooks/dispatcher.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_HOST_HOOKS = "plan.policy.hostHooks";
+export const FIELD_HOST_HOOKS_CLI_ALIAS = "hostHooks";
+export const DEFAULT_HOST_HOOKS_POLICY = {
+    claude: true,
+    cursor: true,
+    grok: true,
+    codex: true,
+};
+function readHostBoolean(rec, host, fallback) {
+    if (host in rec && typeof rec[host] === "boolean") {
+        return rec[host];
+    }
+    return fallback;
+}
+/** Resolve typed host hook deposit policy from raw PROJECT-DEFINITION value. */
+export function resolveHostHooksPolicy(raw) {
+    if (raw === null || raw === undefined) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    const rec = raw;
+    return {
+        claude: readHostBoolean(rec, "claude", DEFAULT_HOST_HOOKS_POLICY.claude),
+        cursor: readHostBoolean(rec, "cursor", DEFAULT_HOST_HOOKS_POLICY.cursor),
+        grok: readHostBoolean(rec, "grok", DEFAULT_HOST_HOOKS_POLICY.grok),
+        codex: readHostBoolean(rec, "codex", DEFAULT_HOST_HOOKS_POLICY.codex),
+    };
+}
+export function validateHostHooks(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_HOST_HOOKS} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const host of HOOK_HOSTS) {
+        if (host in rec && typeof rec[host] !== "boolean") {
+            errors.push(`${FIELD_HOST_HOOKS}.${host} must be a boolean`);
+        }
+    }
+    for (const key of Object.keys(rec)) {
+        if (!HOOK_HOSTS.includes(key)) {
+            errors.push(`${FIELD_HOST_HOOKS}.${key} is not a deposited host (${HOOK_HOSTS.join(", ")})`);
+        }
+    }
+    return errors;
+}
+export function isHostHookDepositEnabled(host, policy = DEFAULT_HOST_HOOKS_POLICY) {
+    return policy[host];
+}
+function fieldFromResolved(resolved, source) {
+    return {
+        name: FIELD_HOST_HOOKS,
+        current: resolved,
+        default: DEFAULT_HOST_HOOKS_POLICY,
+        source,
+    };
+}
+/** Inspector row for `policy:show --field=hostHooks`. */
+export function inspectHostHooks(data) {
+    if (data === null) {
+        return fieldFromResolved(DEFAULT_HOST_HOOKS_POLICY, "default");
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostHooks" in policyBlock)) {
+        return fieldFromResolved(DEFAULT_HOST_HOOKS_POLICY, "default");
+    }
+    const resolved = resolveHostHooksPolicy(policyBlock.hostHooks);
+    return fieldFromResolved(resolved, "typed");
+}
+/** Resolve host hook deposit policy from PROJECT-DEFINITION on disk. */
+export function loadHostHooksPolicyFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostHooks" in policyBlock)) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    return resolveHostHooksPolicy(policyBlock.hostHooks);
+}
+//# sourceMappingURL=host-hooks.js.map

package/dist/policy/index.d.ts

@@ -3,6 +3,7 @@ export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
+export * from "./host-hooks.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";

package/dist/policy/index.js

@@ -1,3 +1,4 @@
+import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
@@ -10,6 +11,7 @@ export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
+export * from "./host-hooks.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
@@ -258,6 +260,15 @@ function inspectRuntimeAuthorityField(data) {
         source: field.source,
     };
 }
+function inspectHostHooksField(data) {
+    const field = inspectHostHooks(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -270,6 +281,7 @@ const REGISTERED_POLICIES = [
         emptyIsTyped: true,
     }),
     inspectSwarmSubagentBackend,
+    inspectHostHooksField,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
@@ -290,7 +302,9 @@ export function inspectOnePolicy(name, projectRoot) {
                 ? FIELD_STALENESS_TICKLER
                 : name === FIELD_RUNTIME_AUTHORITY_CLI_ALIAS
                     ? FIELD_RUNTIME_AUTHORITY
-                    : name;
+                    : name === FIELD_HOST_HOOKS_CLI_ALIAS
+                        ? FIELD_HOST_HOOKS
+                        : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/product-signal/consent.d.ts

@@ -1,12 +1,14 @@
 export declare const PRODUCT_SIGNAL_CONSENT_FILENAME = "product-signal-consent.json";
-/** Consent record schema version (#2693 D2). */
-export declare const PRODUCT_SIGNAL_CONSENT_VERSION = 1;
+/** Consent record schema version (#2693 D2, #2767 v2 sink binding). */
+export declare const PRODUCT_SIGNAL_CONSENT_VERSION = 2;
 /** Phase-1 consent tier permitting qualitative outbound (#2693 D2). */
 export declare const PRODUCT_SIGNAL_CONSENT_TIER = "product-signal";
 export interface ProductSignalConsentRecord {
     readonly consentVersion: number;
     readonly grantedAt: string;
     readonly tier: string;
+    /** Normalized owner/repo sink authorized by v2 consent (#2767). */
+    readonly sinkRepo?: string;
     readonly revokedAt?: string;
 }
 export interface ResolveConsentPathOptions {
@@ -14,16 +16,31 @@ export interface ResolveConsentPathOptions {
     readonly env?: NodeJS.ProcessEnv;
     readonly homeDir?: string;
 }
+export interface SinkAuthorizationResult {
+    readonly authorized: boolean;
+    readonly configuredSink: string;
+    readonly consentedSink: string | null;
+    readonly sinksMatch: boolean;
+    readonly message: string;
+}
 /** Platform-config consent path adjacent to USER.md (#2693 D2). */
 export declare function resolveProductSignalConsentPath(options?: ResolveConsentPathOptions): string;
+/** Normalize sinkRepo to lowercase owner/repo (#2767). */
+export declare function normalizeProductSignalSinkRepo(raw: string): string;
+/** Resolve the sink authorized by a consent record (#2767). */
+export declare function resolveConsentedProductSignalSink(consent: ProductSignalConsentRecord | null): string | null;
+/** Authorize configured sink against install consent (#2767). */
+export declare function authorizeProductSignalSink(configuredSink: string, consent: ProductSignalConsentRecord | null): SinkAuthorizationResult;
 /** Read consent file; returns null when absent, invalid, or revoked. */
 export declare function readProductSignalConsent(options?: ResolveConsentPathOptions): ProductSignalConsentRecord | null;
 /** True when a non-revoked consent grant exists. */
 export declare function isProductSignalConsented(options?: ResolveConsentPathOptions): boolean;
 export interface WriteConsentOptions extends ResolveConsentPathOptions {
     readonly now?: Date;
+    /** Normalized sink to bind into v2 consent (#2767). Defaults to baked-in sink. */
+    readonly sinkRepo?: string;
 }
-/** Write a fresh consent grant (#2693 D17 yes path). */
+/** Write a fresh consent grant (#2693 D17 yes path, #2767 v2 sink binding). */
 export declare function grantProductSignalConsent(options?: WriteConsentOptions): ProductSignalConsentRecord;
 /** Revoke consent by setting revokedAt (#2693 D2). */
 export declare function revokeProductSignalConsent(options?: WriteConsentOptions): boolean;

package/dist/product-signal/consent.js

@@ -1,10 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { DEFAULT_PRODUCT_SIGNAL_SINK_REPO } from "../policy/product-signal.js";
 import { platformUserConfigDir } from "../user-config/resolve-user-md.js";
 export const PRODUCT_SIGNAL_CONSENT_FILENAME = "product-signal-consent.json";
-/** Consent record schema version (#2693 D2). */
-export const PRODUCT_SIGNAL_CONSENT_VERSION = 1;
+/** Consent record schema version (#2693 D2, #2767 v2 sink binding). */
+export const PRODUCT_SIGNAL_CONSENT_VERSION = 2;
+/** Legacy consent schema — authorizes default sink only (#2767). */
+const PRODUCT_SIGNAL_CONSENT_VERSION_V1 = 1;
 /** Phase-1 consent tier permitting qualitative outbound (#2693 D2). */
 export const PRODUCT_SIGNAL_CONSENT_TIER = "product-signal";
 function resolveHomeDirForConsent(options) {
@@ -32,25 +35,76 @@ export function resolveProductSignalConsentPath(options = {}) {
     const homeDir = resolveHomeDirForConsent(options);
     return join(platformUserConfigDir(platform, env, homeDir), PRODUCT_SIGNAL_CONSENT_FILENAME);
 }
+/** Normalize sinkRepo to lowercase owner/repo (#2767). */
+export function normalizeProductSignalSinkRepo(raw) {
+    const sink = raw.trim().replace(/^https?:\/\/github\.com\//i, "");
+    return sink.replace(/\/+$/, "").toLowerCase();
+}
 function parseConsentRecord(raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
         return null;
     }
     const rec = raw;
-    if (typeof rec.consentVersion !== "number" || typeof rec.grantedAt !== "string") {
+    if (typeof rec.consentVersion !== "number" ||
+        typeof rec.grantedAt !== "string" ||
+        typeof rec.tier !== "string") {
         return null;
     }
-    if (typeof rec.tier !== "string") {
+    const revokedAt = typeof rec.revokedAt === "string" ? rec.revokedAt : undefined;
+    let sinkRepo;
+    if (rec.consentVersion >= PRODUCT_SIGNAL_CONSENT_VERSION) {
+        if (typeof rec.sinkRepo !== "string" || rec.sinkRepo.trim().length === 0) {
+            return null;
+        }
+        sinkRepo = normalizeProductSignalSinkRepo(rec.sinkRepo);
+        if (sinkRepo.length === 0) {
+            return null;
+        }
+    }
+    else if (rec.consentVersion !== PRODUCT_SIGNAL_CONSENT_VERSION_V1) {
         return null;
     }
-    const revokedAt = typeof rec.revokedAt === "string" ? rec.revokedAt : undefined;
     return {
         consentVersion: rec.consentVersion,
         grantedAt: rec.grantedAt,
         tier: rec.tier,
+        sinkRepo,
         revokedAt,
     };
 }
+/** Resolve the sink authorized by a consent record (#2767). */
+export function resolveConsentedProductSignalSink(consent) {
+    if (consent === null) {
+        return null;
+    }
+    if (consent.consentVersion >= PRODUCT_SIGNAL_CONSENT_VERSION) {
+        return consent.sinkRepo ?? null;
+    }
+    if (consent.consentVersion === PRODUCT_SIGNAL_CONSENT_VERSION_V1) {
+        return normalizeProductSignalSinkRepo(DEFAULT_PRODUCT_SIGNAL_SINK_REPO);
+    }
+    return null;
+}
+/** Authorize configured sink against install consent (#2767). */
+export function authorizeProductSignalSink(configuredSink, consent) {
+    const configured = normalizeProductSignalSinkRepo(configuredSink);
+    const consented = resolveConsentedProductSignalSink(consent);
+    const sinksMatch = consented !== null && configured === consented;
+    let message = "sink authorized";
+    if (!sinksMatch) {
+        message =
+            consented === null
+                ? "product-signal requires consent (`task product-signal:consent -- --grant`)."
+                : `product-signal skipped (sink-unconsented): configured sink=${configured} does not match consented sink=${consented}. Re-run \`task product-signal:consent -- --grant\` after confirming the destination.`;
+    }
+    return {
+        authorized: sinksMatch,
+        configuredSink: configured,
+        consentedSink: consented,
+        sinksMatch,
+        message,
+    };
+}
 /** Read consent file; returns null when absent, invalid, or revoked. */
 export function readProductSignalConsent(options = {}) {
     const path = resolveProductSignalConsentPath(options);
@@ -76,13 +130,16 @@ export function readProductSignalConsent(options = {}) {
 export function isProductSignalConsented(options = {}) {
     return readProductSignalConsent(options) !== null;
 }
-/** Write a fresh consent grant (#2693 D17 yes path). */
+/** Write a fresh consent grant (#2693 D17 yes path, #2767 v2 sink binding). */
 export function grantProductSignalConsent(options = {}) {
     const now = options.now ?? new Date();
+    const normalizedSink = normalizeProductSignalSinkRepo((options.sinkRepo ?? DEFAULT_PRODUCT_SIGNAL_SINK_REPO).trim());
+    const sinkRepo = normalizedSink || normalizeProductSignalSinkRepo(DEFAULT_PRODUCT_SIGNAL_SINK_REPO);
     const record = {
         consentVersion: PRODUCT_SIGNAL_CONSENT_VERSION,
         grantedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
         tier: PRODUCT_SIGNAL_CONSENT_TIER,
+        sinkRepo,
     };
     const path = resolveProductSignalConsentPath(options);
     mkdirSync(dirname(path), { recursive: true });

package/dist/product-signal/gates.d.ts

@@ -1,4 +1,4 @@
-export type ProductSignalOutcome = "submitted" | "dry-run" | "disabled" | "no-consent" | "no-network" | "non-interactive" | "sink-unreachable" | "sink-unauthorized" | "validation" | "error-config";
+export type ProductSignalOutcome = "submitted" | "dry-run" | "disabled" | "no-consent" | "no-network" | "non-interactive" | "sink-unconsented" | "sink-unreachable" | "sink-unauthorized" | "validation" | "error-config";
 export interface GateEvaluation {
     readonly allowed: boolean;
     readonly outcome: ProductSignalOutcome;

package/dist/product-signal/submit.d.ts

@@ -32,7 +32,11 @@ export declare function runProductSignalEnable(projectRoot: string | null, confi
     exitCode: 0 | 1 | 2;
     text: string;
 };
-export declare function runProductSignalConsent(action: "grant" | "revoke"): {
+export interface ProductSignalConsentRunOptions {
+    readonly action: "grant" | "revoke";
+    readonly projectRoot?: string | null;
+}
+export declare function runProductSignalConsent(options: ProductSignalConsentRunOptions): {
     exitCode: 0 | 1;
     text: string;
 };

package/dist/product-signal/submit.js

@@ -3,7 +3,7 @@ import { join, resolve } from "node:path";
 import { enableProductSignal, formatProductSignalStatusLine, resolveProductSignal, } from "../policy/product-signal.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveActorName } from "./actor-name.js";
-import { grantProductSignalConsent, isProductSignalConsented, readProductSignalConsent, revokeProductSignalConsent, } from "./consent.js";
+import { authorizeProductSignalSink, grantProductSignalConsent, readProductSignalConsent, revokeProductSignalConsent, } from "./consent.js";
 import { evaluateProductSignalGates } from "./gates.js";
 import { GitHubPrivateSinkAdapter } from "./github-private-sink-adapter.js";
 import { collectInstallContext } from "./install-context.js";
@@ -105,15 +105,25 @@ export async function submitProductSignal(options) {
             payload,
         };
     }
+    const policy = resolveProductSignal(root);
+    const consent = readProductSignalConsent();
+    const sinkAuth = authorizeProductSignalSink(policy.sinkRepo, consent);
+    if (!sinkAuth.authorized) {
+        return {
+            outcome: "sink-unconsented",
+            exitCode: 0,
+            message: `${sinkAuth.message}\n`,
+            payload,
+        };
+    }
     if (options.dryRun) {
         return {
             outcome: "dry-run",
             exitCode: 0,
-            message: `[dry-run] payload valid for ${payload.surface}\n`,
+            message: `[dry-run] payload valid for ${payload.surface} (sink=${sinkAuth.configuredSink})\n`,
             payload,
         };
     }
-    const policy = resolveProductSignal(root);
     const adapter = new GitHubPrivateSinkAdapter({ sinkRepo: policy.sinkRepo });
     const result = await adapter.submit(payload, { gapText: options.gapText });
     if (result.outcome === "submitted") {
@@ -131,11 +141,13 @@ export async function submitProductSignal(options) {
 export function runProductSignalStatus(projectRoot) {
     const root = resolveProjectRoot(projectRoot ?? undefined) ?? process.cwd();
     const policy = resolveProductSignal(root);
-    const consented = isProductSignalConsented();
+    const consent = readProductSignalConsent();
+    const configuredSink = policy.sinkRepo;
+    const sinkAuth = authorizeProductSignalSink(configuredSink, consent);
     const last = readLastSubmitSummary(root);
     const lines = [
         formatProductSignalStatusLine(policy),
-        `[deft product-signal] consented=${String(consented)}`,
+        `[deft product-signal] consented=${String(consent !== null)} configuredSink=${configuredSink} consentedSink=${sinkAuth.consentedSink ?? "none"} sinksMatch=${String(sinkAuth.sinksMatch)}`,
         last ? `[deft product-signal] ${last}` : "[deft product-signal] last submit: none",
     ];
     return { exitCode: 0, text: `${lines.join("\n")}\n` };
@@ -148,12 +160,15 @@ export function runProductSignalEnable(projectRoot, confirm) {
     const result = enableProductSignal(root, { confirm });
     return { exitCode: result.exitCode, text: result.stdout };
 }
-export function runProductSignalConsent(action) {
-    if (action === "grant") {
-        const record = grantProductSignalConsent();
+export function runProductSignalConsent(options) {
+    if (options.action === "grant") {
+        const root = resolveProjectRoot(options.projectRoot ?? undefined);
+        const sinkRepo = root !== null ? resolveProductSignal(root).sinkRepo : undefined;
+        const record = grantProductSignalConsent({ sinkRepo });
         return {
             exitCode: 0,
-            text: `product-signal consent granted (tier=${record.tier}, version=${record.consentVersion}).\n`,
+            text: `product-signal consent granted (tier=${record.tier}, version=${record.consentVersion}, ` +
+                `sinkRepo=${record.sinkRepo ?? "unknown"}).\n`,
         };
     }
     const ok = revokeProductSignalConsent();
@@ -216,24 +231,29 @@ export function parseProductSignalSubmitArgs(argv) {
     }
     return { surface, dryRun, json, projectRoot, nps };
 }
+function parseOptionalProjectRootArg(argv, fallback) {
+    const rootIdx = argv.indexOf("--project-root");
+    if (rootIdx >= 0) {
+        return argv[rootIdx + 1] ?? fallback;
+    }
+    const eqArg = argv.find((a) => a.startsWith("--project-root="));
+    if (eqArg !== undefined) {
+        return eqArg.slice("--project-root=".length) || fallback;
+    }
+    return fallback;
+}
 /** CLI module entrypoint for dispatch (#2693). */
 export async function productSignalMain(argv = process.argv.slice(2)) {
     const sub = argv[0];
     if (sub === "status") {
-        const rootIdx = argv.indexOf("--project-root");
-        const root = rootIdx >= 0
-            ? (argv[rootIdx + 1] ?? ".")
-            : (argv.find((a) => a.startsWith("--project-root="))?.split("=")[1] ?? ".");
+        const root = parseOptionalProjectRootArg(argv, ".") ?? ".";
         const result = runProductSignalStatus(root);
         process.stdout.write(result.text);
         return result.exitCode;
     }
     if (sub === "enable") {
         const confirm = argv.includes("--confirm");
-        const rootIdx = argv.indexOf("--project-root");
-        const root = rootIdx >= 0
-            ? (argv[rootIdx + 1] ?? ".")
-            : (argv.find((a) => a.startsWith("--project-root="))?.split("=")[1] ?? ".");
+        const root = parseOptionalProjectRootArg(argv, ".") ?? ".";
         const result = runProductSignalEnable(root, confirm);
         process.stdout.write(result.text);
         return result.exitCode;
@@ -245,7 +265,11 @@ export async function productSignalMain(argv = process.argv.slice(2)) {
             process.stderr.write("usage: product-signal consent -- --grant|--revoke\n");
             return 1;
         }
-        const result = runProductSignalConsent(grant ? "grant" : "revoke");
+        const root = parseOptionalProjectRootArg(argv, null);
+        const result = runProductSignalConsent({
+            action: grant ? "grant" : "revoke",
+            projectRoot: root,
+        });
         process.stdout.write(result.text);
         return result.exitCode;
     }

package/dist/vbrief-validate/plan-hooks.d.ts

@@ -6,6 +6,8 @@ export declare function validateSessionRitualStalenessHoursOnPlan(plan: unknown,
 export declare function validateTriageRankingLabelsOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.runtimeAuthority`` (#1394). */
 export declare function validateRuntimeAuthorityOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook: validate ``plan.policy.hostHooks`` (#2752). */
+export declare function validateHostHooksOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.stalenessTickler`` (#2489). */
 export declare function validateStalenessTicklerOnPlan(plan: unknown, filepath: string): string[];
 /** Run all PROJECT-DEFINITION policy hooks (mirrors lazy-import block in Python). */

package/dist/vbrief-validate/plan-hooks.js

@@ -1,3 +1,4 @@
+import { validateHostHooks } from "../policy/host-hooks.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
 import { validateRuntimeAuthority } from "../policy/runtime-authority.js";
 import { validateStalenessTickler } from "../policy/staleness-tickler.js";
@@ -121,6 +122,24 @@ export function validateRuntimeAuthorityOnPlan(plan, filepath) {
     }
     return out;
 }
+/** vbrief_validate hook: validate ``plan.policy.hostHooks`` (#2752). */
+export function validateHostHooksOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("hostHooks" in policy)) {
+        return [];
+    }
+    const out = [];
+    for (const err of validateHostHooks(policy.hostHooks)) {
+        out.push(`${filepath}: ${err} (#2752)`);
+    }
+    return out;
+}
 /** vbrief_validate hook: validate ``plan.policy.stalenessTickler`` (#2489). */
 export function validateStalenessTicklerOnPlan(plan, filepath) {
     if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
@@ -191,6 +210,12 @@ export function runProjectDefinitionHooks(plan, filepath) {
     catch {
         /* hook must not break validation */
     }
+    try {
+        errors.push(...validateHostHooksOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
     return errors;
 }
 //# sourceMappingURL=plan-hooks.js.map

package/dist/verify-env/agent-hooks.d.ts

@@ -1,4 +1,5 @@
 import { type AgentHookInspection } from "../init-deposit/agent-hooks.js";
+import type { HostHooksPolicy } from "../policy/host-hooks.js";
 import type { OutputStream } from "./verify-hooks-installed.js";
 export interface AgentHookHealthResult {
     readonly code: 0 | 1 | 2;
@@ -7,5 +8,5 @@ export interface AgentHookHealthResult {
     readonly registrations: readonly AgentHookInspection[];
 }
 /** Read-only P0 agent-host registration health, independent of git hooks. */
-export declare function evaluateAgentHooks(projectRoot: string): AgentHookHealthResult;
+export declare function evaluateAgentHooks(projectRoot: string, hostHooksPolicy?: HostHooksPolicy): AgentHookHealthResult;
 //# sourceMappingURL=agent-hooks.d.ts.map

package/dist/verify-env/agent-hooks.js

@@ -1,6 +1,7 @@
 import { statSync } from "node:fs";
 import { resolve } from "node:path";
 import { inspectAgentHookDeposit } from "../init-deposit/agent-hooks.js";
+import { loadHostHooksPolicyFromProject } from "../policy/host-hooks.js";
 function isDirectory(path) {
     try {
         return statSync(path).isDirectory();
@@ -10,7 +11,7 @@ function isDirectory(path) {
     }
 }
 /** Read-only P0 agent-host registration health, independent of git hooks. */
-export function evaluateAgentHooks(projectRoot) {
+export function evaluateAgentHooks(projectRoot, hostHooksPolicy = loadHostHooksPolicyFromProject(projectRoot)) {
     const root = resolve(projectRoot);
     if (!isDirectory(root)) {
         return {
@@ -20,7 +21,7 @@ export function evaluateAgentHooks(projectRoot) {
             registrations: [],
         };
     }
-    const registrations = inspectAgentHookDeposit(root);
+    const registrations = inspectAgentHookDeposit(root, hostHooksPolicy);
     const unhealthy = registrations.filter((entry) => entry.status !== "healthy");
     if (unhealthy.length > 0) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.82.0",
+  "version": "0.83.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -313,8 +313,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.82.0",
-    "@deftai/directive-types": "^0.82.0",
+    "@deftai/directive-content": "^0.83.0",
+    "@deftai/directive-types": "^0.83.0",
     "archiver": "^8.0.0"
   },
   "scripts": {