@deftai/directive-core 0.82.0 → 0.84.0

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/gitignore.js

@@ -22,6 +22,7 @@ const DEFT_CORE_COVERING_LINES = new Set([".deft/core/", ".deft/core"]);
  */
 export const CANONICAL_GITIGNORE_BASELINE = [
     ".deft-cache/",
+    ".deft/cache/",
     ".deft/.cli/",
     ".deft/ritual-state.json",
     ".deft/last-session.json",

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;