@deftai/directive-core 0.94.0 → 0.96.0

package/dist/verify-env/agent-hook-readiness.js

@@ -0,0 +1,150 @@
+import { resolve } from "node:path";
+import { resolveFrameworkRootForProject } from "../doctor/paths.js";
+import { loadHostHooksPolicyFromProject } from "../policy/host-hooks.js";
+import { evaluateAgentHooks } from "./agent-hooks.js";
+import { probeAgentHooksLive, } from "./agent-hooks-live-probe.js";
+/** Stable CLI JSON projection; keep the four readiness dimensions orthogonal. */
+export function agentHookReadinessJson(result) {
+    return {
+        ready: result.code === 0,
+        exit_code: result.code,
+        skipped: result.skipped,
+        live_status: result.liveStatus,
+        hosts: result.hosts.map((entry) => ({ ...entry })),
+        message: result.message,
+    };
+}
+/** Preserve fail-closed readiness semantics when an unexpected evaluator dependency throws. */
+export function evaluateAgentHookReadinessSafely(projectRoot, evaluate = evaluateAgentHookReadiness) {
+    try {
+        return evaluate(projectRoot);
+    }
+    catch (cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        return {
+            code: 2,
+            message: `❌ deft agent hook readiness unavailable: ${detail}`,
+            stream: "stderr",
+            skipped: false,
+            liveStatus: "unavailable",
+            hosts: [],
+            registrations: [],
+            liveProbe: null,
+        };
+    }
+}
+function isConsumerContext(projectRoot) {
+    return resolve(projectRoot) !== resolve(resolveFrameworkRootForProject(projectRoot));
+}
+function registrationState(entry) {
+    if (entry.status === "healthy")
+        return "registered";
+    return entry.status;
+}
+function renderHosts(hosts) {
+    return hosts
+        .map((entry) => `  - ${entry.host}: registration=${entry.registration}; functionality=${entry.functionality}; ` +
+        `trust=${entry.trust}; interception=${entry.interception}`)
+        .join("\n");
+}
+function baseHostResult(entry, policy) {
+    if (!policy[entry.host]) {
+        return {
+            host: entry.host,
+            registration: "disabled",
+            functionality: "disabled",
+            trust: "disabled",
+            interception: "disabled",
+        };
+    }
+    return {
+        host: entry.host,
+        registration: registrationState(entry),
+        functionality: "not-run",
+        trust: entry.host === "codex" ? "manual-review-required" : "not-applicable",
+        interception: "not-directly-verified",
+    };
+}
+/** Fail-closed consumer readiness: structural registration first, installed-shim live probe second. */
+export function evaluateAgentHookReadiness(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const consumerContext = options.consumerContext ?? isConsumerContext;
+    if (!consumerContext(root)) {
+        return {
+            code: 0,
+            message: "✓ deft agent hook readiness skipped: maintainer source checkout; consumer hook deposit is not applicable.",
+            stream: "stdout",
+            skipped: true,
+            liveStatus: "skipped",
+            hosts: [],
+            registrations: [],
+            liveProbe: null,
+        };
+    }
+    const policy = options.hostHooksPolicy ?? loadHostHooksPolicyFromProject(root);
+    const structural = (options.evaluateStructural ?? evaluateAgentHooks)(root, policy);
+    const hosts = structural.registrations.map((entry) => baseHostResult(entry, policy));
+    if (structural.code !== 0) {
+        return {
+            code: structural.code,
+            message: `${structural.message}\n${renderHosts(hosts)}`,
+            stream: "stderr",
+            skipped: false,
+            liveStatus: "not-run",
+            hosts,
+            registrations: structural.registrations,
+            liveProbe: null,
+        };
+    }
+    const enabledHosts = structural.registrations
+        .filter((entry) => policy[entry.host])
+        .map((entry) => entry.host);
+    const liveProbe = (options.probeLive ?? probeAgentHooksLive)(root, {
+        ...options.liveProbeSeams,
+        hosts: enabledHosts,
+    });
+    const liveByHost = new Map(liveProbe.hosts.map((entry) => [entry.host, entry.status]));
+    const evaluatedHosts = hosts.map((entry) => {
+        if (entry.functionality === "disabled")
+            return entry;
+        const liveStatus = liveByHost.get(entry.host);
+        return {
+            ...entry,
+            functionality: liveStatus === "functional"
+                ? "functional"
+                : liveStatus === "unavailable"
+                    ? "unavailable"
+                    : liveStatus === "non-functional"
+                        ? "non-functional"
+                        : "not-run",
+        };
+    });
+    const allDisabled = enabledHosts.length === 0;
+    const liveStatus = allDisabled
+        ? "disabled"
+        : liveProbe.code === 0
+            ? "functional"
+            : liveProbe.code === 2
+                ? "unavailable"
+                : "non-functional";
+    const trustReview = policy.codex
+        ? "\n  Codex trust: manual-review-required. Open `/hooks` and approve the exact project hook commands. " +
+            "The live probe validates the shim and codec, not host interception."
+        : "";
+    return {
+        code: liveProbe.code,
+        message: `${liveProbe.code === 0 ? "✓" : "❌"} deft agent hook readiness: ${liveProbe.message}\n` +
+            renderHosts(evaluatedHosts) +
+            trustReview +
+            (liveProbe.code === 0
+                ? ""
+                : "\n  If an affected host is unused, inspect `deft policy:show --field=hostHooks`, set `plan.policy.hostHooks.<host> = false`, and run `deft update`."),
+        stream: liveProbe.code === 0 ? "stdout" : "stderr",
+        skipped: false,
+        liveStatus,
+        hosts: evaluatedHosts,
+        registrations: structural.registrations,
+        liveProbe,
+    };
+}
+//# sourceMappingURL=agent-hook-readiness.js.map

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

@@ -1,5 +1,6 @@
-import type { HookEvent, HookHost } from "../hooks/dispatcher.js";
-export type AgentHookLiveProbeIssue = "hook-command-missing" | "spawn-failed" | "empty-stdout" | "unparseable-json" | "missing-allow" | "missing-deny";
+import { type HookEvent, type HookHost } from "../hooks/dispatcher.js";
+export declare const LIVE_PROBE_CASE_TIMEOUT_MS = 1500;
+export type AgentHookLiveProbeIssue = "hook-command-missing" | "spawn-failed" | "timed-out" | "empty-stdout" | "unparseable-json" | "missing-allow" | "missing-deny";
 export interface AgentHookLiveProbeCase {
     readonly host: HookHost;
     readonly event: HookEvent;
@@ -7,26 +8,37 @@ export interface AgentHookLiveProbeCase {
     readonly issue: AgentHookLiveProbeIssue;
     readonly detail: string;
 }
+export type AgentHookLiveProbeHostStatus = "functional" | "non-functional" | "unavailable";
+export interface AgentHookLiveProbeHostResult {
+    readonly host: HookHost;
+    readonly status: AgentHookLiveProbeHostStatus;
+}
 export interface AgentHookLiveProbeResult {
     readonly code: 0 | 1 | 2;
     readonly message: string;
     readonly cases: readonly AgentHookLiveProbeCase[];
+    readonly hosts: readonly AgentHookLiveProbeHostResult[];
+    readonly durationMs: number;
 }
 export interface AgentHookLiveProbeSeams {
+    /** Enabled hosts to probe. Defaults to every deposited host. */
+    readonly hosts?: readonly HookHost[];
     readonly resolveCommand?: (name: string) => string | null;
     readonly spawnHook?: (input: {
         readonly command: string;
         readonly args: readonly string[];
         readonly stdin: string;
         readonly cwd: string;
-        readonly env?: NodeJS.ProcessEnv;
+        readonly env: NodeJS.ProcessEnv;
     }) => {
         readonly status: number;
         readonly stdout: string;
         readonly stderr: string;
+        readonly timedOut?: boolean;
     };
 }
+/** Quote one Windows cmd.exe argument used by the installed hook shim. */
 export declare function quoteWindowsCmdArg(value: string): string;
-/** Spawn the configured hook command and assert Cursor tool.before allow/deny behavior. */
+/** Invoke the installed deft-hook shim and validate enabled host allow/deny codecs. */
 export declare function probeAgentHooksLive(projectRoot: string, seams?: AgentHookLiveProbeSeams): AgentHookLiveProbeResult;
 //# sourceMappingURL=agent-hooks-live-probe.d.ts.map

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

@@ -1,27 +1,19 @@
 import { spawnSync } from "node:child_process";
 import { resolve } from "node:path";
+import { HOOK_HOSTS } from "../hooks/dispatcher.js";
 import { READ_ONLY_HOOK_ENV } from "../hooks/tools.js";
 import { DEFT_HOOK_COMMAND_MARKER } from "../init-deposit/agent-hooks.js";
 import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 import { quoteWin32CommandForShell, resolveCommandOnPath, shouldUseShellForCommand, } from "./command-spawn.js";
-const LIVE_PROBE_HOST = "cursor";
+export const LIVE_PROBE_CASE_TIMEOUT_MS = 1_500;
 const LIVE_PROBE_EVENT = "tool.before";
+function elapsedMs(started) {
+    return Math.max(0, Math.round(performance.now() - started));
+}
 function resolveHookCommand(seams) {
-    const resolveCommand = seams.resolveCommand ?? resolveCommandOnPath;
-    const deftHook = resolveCommand(DEFT_HOOK_COMMAND_MARKER);
-    if (deftHook !== null) {
-        return { command: deftHook, argsPrefix: [] };
-    }
-    const deft = resolveCommand("deft");
-    if (deft !== null) {
-        return { command: deft, argsPrefix: ["hook:dispatch"] };
-    }
-    const directive = resolveCommand("directive");
-    if (directive !== null) {
-        return { command: directive, argsPrefix: ["hook:dispatch"] };
-    }
-    return null;
+    return (seams.resolveCommand ?? resolveCommandOnPath)(DEFT_HOOK_COMMAND_MARKER);
 }
+/** Quote one Windows cmd.exe argument used by the installed hook shim. */
 export function quoteWindowsCmdArg(value) {
     const escaped = value.replace(/%/g, "%%");
     if (!/[\s"&|<>^()]/.test(escaped)) {
@@ -31,27 +23,10 @@ export function quoteWindowsCmdArg(value) {
 }
 function spawnHookWithStdin(command, args, stdin, cwd, env = process.env) {
     const shell = shouldUseShellForCommand(command);
-    if (shell && process.platform === "win32") {
-        const cmdLine = [quoteWin32CommandForShell(command), ...args.map(quoteWindowsCmdArg)].join(" ");
-        const proc = spawnSync(cmdLine, [], {
-            input: stdin,
-            cwd,
-            env,
-            encoding: "utf8",
-            stdio: ["pipe", "pipe", "pipe"],
-            shell: true,
-            windowsHide: true,
-            maxBuffer: SUBPROCESS_MAX_BUFFER,
-        });
-        const status = proc.status ?? (proc.error ? 2 : proc.signal ? 128 : 0);
-        return {
-            status,
-            stdout: typeof proc.stdout === "string" ? proc.stdout : "",
-            stderr: typeof proc.stderr === "string" ? proc.stderr : "",
-        };
-    }
-    const spawnCmd = shell && process.platform === "win32" ? quoteWin32CommandForShell(command) : command;
-    const proc = spawnSync(spawnCmd, [...args], {
+    const commandArgs = shell && process.platform === "win32"
+        ? [[quoteWin32CommandForShell(command), ...args.map(quoteWindowsCmdArg)].join(" "), []]
+        : [command, [...args]];
+    const proc = spawnSync(commandArgs[0], commandArgs[1], {
         input: stdin,
         cwd,
         env,
@@ -60,12 +35,14 @@ function spawnHookWithStdin(command, args, stdin, cwd, env = process.env) {
         shell,
         windowsHide: true,
         maxBuffer: SUBPROCESS_MAX_BUFFER,
+        timeout: LIVE_PROBE_CASE_TIMEOUT_MS,
     });
-    const status = proc.status ?? (proc.error ? 2 : proc.signal ? 128 : 0);
+    const timedOut = proc.error?.code === "ETIMEDOUT";
     return {
-        status,
+        status: proc.status ?? (proc.error ? 2 : proc.signal ? 128 : 0),
         stdout: typeof proc.stdout === "string" ? proc.stdout : "",
         stderr: typeof proc.stderr === "string" ? proc.stderr : "",
+        ...(timedOut ? { timedOut: true } : {}),
     };
 }
 function allowFixture(projectRoot) {
@@ -86,131 +63,167 @@ function denyFixture(projectRoot) {
 function denyProbeEnv() {
     return { ...process.env, [READ_ONLY_HOOK_ENV]: "1" };
 }
-function parseCursorDecision(stdout) {
+function parseJsonObject(stdout) {
     const trimmed = stdout.trim();
     if (trimmed.length === 0) {
-        return { ok: false, detail: "empty stdout" };
+        return { value: null, issue: "empty-stdout", detail: "empty stdout" };
     }
     try {
         const parsed = JSON.parse(trimmed);
-        if (parsed !== null &&
-            typeof parsed === "object" &&
-            !Array.isArray(parsed) &&
-            parsed.permission === "allow") {
-            return { ok: true, permission: "allow", detail: "permission allow" };
-        }
-        if (parsed !== null &&
-            typeof parsed === "object" &&
-            !Array.isArray(parsed) &&
-            parsed.permission === "deny") {
-            return { ok: true, permission: "deny", detail: "permission deny" };
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { value: parsed, issue: null, detail: "valid JSON object" };
         }
-        return { ok: false, detail: "stdout JSON missing permission allow/deny" };
+        return { value: null, issue: "unparseable-json", detail: "stdout JSON is not an object" };
     }
     catch {
-        return { ok: false, detail: "stdout is not valid JSON" };
+        return { value: null, issue: "unparseable-json", detail: "stdout is not valid JSON" };
     }
 }
-function runFixtureProbe(resolved, projectRoot, fixture, stdin, env, spawnHook) {
-    const args = [
-        ...resolved.argsPrefix,
-        "--host",
-        LIVE_PROBE_HOST,
-        "--event",
-        LIVE_PROBE_EVENT,
-        "--project-root",
-        projectRoot,
-    ];
-    const spawned = spawnHook({
-        command: resolved.command,
-        args,
-        stdin,
-        cwd: projectRoot,
-        env,
-    });
-    if (spawned.status !== 0) {
+function validatesNestedDeny(value) {
+    const output = value.hookSpecificOutput;
+    if (output === null || typeof output !== "object" || Array.isArray(output))
+        return false;
+    const nested = output;
+    return (nested.hookEventName === "PreToolUse" &&
+        nested.permissionDecision === "deny" &&
+        typeof nested.permissionDecisionReason === "string");
+}
+function validateFixtureOutput(host, fixture, stdout) {
+    if (fixture === "allow" && host !== "cursor") {
+        if (stdout.trim().length === 0)
+            return { ok: true };
+        const parsed = parseJsonObject(stdout);
         return {
-            host: LIVE_PROBE_HOST,
-            event: LIVE_PROBE_EVENT,
-            fixture,
-            issue: "spawn-failed",
-            detail: `hook command exited ${spawned.status}${spawned.stderr.trim() ? `: ${spawned.stderr.trim()}` : ""}`,
+            ok: false,
+            issue: parsed.issue ?? "missing-allow",
+            detail: "expected empty stdout so the host permission flow remains unchanged",
         };
     }
-    const decision = parseCursorDecision(spawned.stdout);
-    if (!decision.ok) {
+    const parsed = parseJsonObject(stdout);
+    if (parsed.value === null) {
         return {
-            host: LIVE_PROBE_HOST,
-            event: LIVE_PROBE_EVENT,
-            fixture,
-            issue: decision.detail.includes("JSON") ? "unparseable-json" : "empty-stdout",
-            detail: decision.detail,
+            ok: false,
+            issue: parsed.issue,
+            detail: parsed.detail,
         };
     }
-    if (fixture === "allow" && decision.permission !== "allow") {
+    const value = parsed.value;
+    if (fixture === "allow") {
+        return value.permission === "allow"
+            ? { ok: true }
+            : { ok: false, issue: "missing-allow", detail: "expected Cursor permission allow" };
+    }
+    const denied = host === "cursor"
+        ? value.permission === "deny"
+        : host === "grok"
+            ? value.decision === "deny" && typeof value.reason === "string"
+            : validatesNestedDeny(value);
+    return denied
+        ? { ok: true }
+        : { ok: false, issue: "missing-deny", detail: `expected ${host} deny envelope` };
+}
+function runFixtureProbe(command, host, projectRoot, fixture, spawnHook) {
+    const spawned = spawnHook({
+        command,
+        args: ["--host", host, "--event", LIVE_PROBE_EVENT, "--project-root", projectRoot],
+        stdin: fixture === "allow" ? allowFixture(projectRoot) : denyFixture(projectRoot),
+        cwd: projectRoot,
+        env: fixture === "allow" ? process.env : denyProbeEnv(),
+    });
+    if (spawned.timedOut === true) {
         return {
-            host: LIVE_PROBE_HOST,
+            host,
             event: LIVE_PROBE_EVENT,
             fixture,
-            issue: "missing-allow",
-            detail: `expected permission allow, got ${decision.permission ?? "none"}`,
+            issue: "timed-out",
+            detail: `hook command exceeded ${LIVE_PROBE_CASE_TIMEOUT_MS}ms`,
         };
     }
-    if (fixture === "deny" && decision.permission !== "deny") {
+    if (spawned.status !== 0) {
         return {
-            host: LIVE_PROBE_HOST,
+            host,
             event: LIVE_PROBE_EVENT,
             fixture,
-            issue: "missing-deny",
-            detail: `expected permission deny, got ${decision.permission ?? "none"}`,
+            issue: "spawn-failed",
+            detail: `hook command exited ${spawned.status}${spawned.stderr.trim() ? `: ${spawned.stderr.trim()}` : ""}`,
         };
     }
-    return null;
+    const validation = validateFixtureOutput(host, fixture, spawned.stdout);
+    return validation.ok
+        ? null
+        : {
+            host,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: validation.issue,
+            detail: validation.detail,
+        };
 }
-/** Spawn the configured hook command and assert Cursor tool.before allow/deny behavior. */
+/** Invoke the installed deft-hook shim and validate enabled host allow/deny codecs. */
 export function probeAgentHooksLive(projectRoot, seams = {}) {
+    const started = performance.now();
     const root = resolve(projectRoot);
-    const resolved = resolveHookCommand(seams);
-    if (resolved === null) {
+    const hosts = [...(seams.hosts ?? HOOK_HOSTS)];
+    if (hosts.length === 0) {
+        return {
+            code: 0,
+            message: "deft agent hooks live probe skipped: every host is intentionally disabled.",
+            cases: [],
+            hosts: [],
+            durationMs: elapsedMs(started),
+        };
+    }
+    const command = resolveHookCommand(seams);
+    if (command === null) {
         return {
             code: 2,
-            message: "deft agent hooks live probe unavailable: neither deft-hook nor deft/directive hook:dispatch is on PATH.",
+            message: `deft agent hooks live probe unavailable: installed ${DEFT_HOOK_COMMAND_MARKER} is not on PATH.`,
             cases: [
                 {
-                    host: LIVE_PROBE_HOST,
+                    host: hosts[0],
                     event: LIVE_PROBE_EVENT,
                     fixture: "allow",
                     issue: "hook-command-missing",
                     detail: `${DEFT_HOOK_COMMAND_MARKER} not found on PATH`,
                 },
             ],
+            hosts: hosts.map((host) => ({ host, status: "unavailable" })),
+            durationMs: elapsedMs(started),
         };
     }
     const spawnHook = seams.spawnHook ??
-        ((input) => spawnHookWithStdin(input.command, input.args, input.stdin, input.cwd, input.env ?? process.env));
+        ((input) => spawnHookWithStdin(input.command, input.args, input.stdin, input.cwd, input.env));
     const failures = [];
-    for (const [fixture, stdin, env] of [
-        ["allow", allowFixture(root), process.env],
-        ["deny", denyFixture(root), denyProbeEnv()],
-    ]) {
-        const failure = runFixtureProbe(resolved, root, fixture, stdin, env, spawnHook);
-        if (failure !== null)
-            failures.push(failure);
+    const hostResults = [];
+    for (const host of hosts) {
+        let hostFailure = null;
+        for (const fixture of ["allow", "deny"]) {
+            hostFailure = runFixtureProbe(command, host, root, fixture, spawnHook);
+            if (hostFailure !== null) {
+                failures.push(hostFailure);
+                break;
+            }
+        }
+        hostResults.push({ host, status: hostFailure === null ? "functional" : "non-functional" });
     }
     if (failures.length === 0) {
         return {
             code: 0,
-            message: "deft agent hooks live probe passed for Cursor tool.before allow and deny fixtures.",
+            message: `deft agent hooks live probe passed allow/deny fixtures for ${hosts.join(", ")}.`,
             cases: [],
+            hosts: hostResults,
+            durationMs: elapsedMs(started),
         };
     }
     const summary = failures
-        .map((entry) => `${entry.fixture}: ${entry.issue} (${entry.detail})`)
+        .map((entry) => `${entry.host}/${entry.fixture}: ${entry.issue} (${entry.detail})`)
         .join("; ");
     return {
         code: 1,
         message: `deft agent hooks live probe FAILED: ${summary}. Recovery: reinstall @deftai/directive and run \`deft update\`.`,
         cases: failures,
+        hosts: hostResults,
+        durationMs: elapsedMs(started),
     };
 }
 //# sourceMappingURL=agent-hooks-live-probe.js.map

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

@@ -22,7 +22,7 @@ export function evaluateAgentHooks(projectRoot, hostHooksPolicy = loadHostHooksP
         };
     }
     const registrations = inspectAgentHookDeposit(root, hostHooksPolicy);
-    const unhealthy = registrations.filter((entry) => entry.status !== "healthy");
+    const unhealthy = registrations.filter((entry) => entry.status === "missing" || entry.status === "drifted");
     if (unhealthy.length > 0) {
         return {
             code: 1,
@@ -30,18 +30,26 @@ export function evaluateAgentHooks(projectRoot, hostHooksPolicy = loadHostHooksP
                 unhealthy
                     .map((entry) => `  - ${entry.host}: ${entry.status} at ${entry.path} — ${entry.detail}`)
                     .join("\n") +
-                "\n  Recovery: run `deft update` (or `directive init`) to refresh project hooks.",
+                "\n  Recovery: run `deft update` (or `directive init`) to refresh project hooks." +
+                " If a failed host is intentionally unused, inspect `deft policy:show --field=hostHooks`, " +
+                "set `plan.policy.hostHooks.<host> = false`, and run `deft update` again.",
             stream: "stderr",
             registrations,
         };
     }
+    const disabledHosts = registrations
+        .filter((entry) => entry.status === "disabled")
+        .map((entry) => entry.host[0]?.toUpperCase() + entry.host.slice(1));
     return {
         code: 0,
         message: "✓ deft agent hooks registered and structurally valid for Claude, Grok, Cursor, Codex " +
             "(SessionStart + PreToolUse direct-write and spawn/Task tools; compact re-arm deposited for Claude/Grok/Cursor; " +
             "Codex has no native compact hook — re-run session ritual manually after compaction). " +
             'Read-only explore: prefer Grok role `default_capability_mode = "read-only"`; hooks also honor ' +
-            "DEFT_HOOK_READ_ONLY=1 and explore subagent_type. Codex runtime trust is user-controlled and must be reviewed with `/hooks`; shell/MCP policy is deferred.",
+            "DEFT_HOOK_READ_ONLY=1 and explore subagent_type. Codex runtime trust is user-controlled and must be reviewed with `/hooks`; shell/MCP policy is deferred." +
+            (disabledHosts.length > 0
+                ? ` Intentional hostHooks disabled: ${disabledHosts.join(", ")}.`
+                : ""),
         stream: "stdout",
         registrations,
     };

package/dist/verify-env/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./agent-hook-readiness.js";
 export * from "./agent-hooks.js";
 export * from "./agent-hooks-live-probe.js";
 export * from "./command-spawn.js";

package/dist/verify-env/index.js

@@ -1,3 +1,4 @@
+export * from "./agent-hook-readiness.js";
 export * from "./agent-hooks.js";
 export * from "./agent-hooks-live-probe.js";
 export * from "./command-spawn.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.94.0",
+  "version": "0.96.0",
   "description": "TypeScript engine core for the Directive framework.",
   "license": "MIT",
   "type": "module",
@@ -243,6 +243,14 @@
       "types": "./dist/capacity/index.d.ts",
       "default": "./dist/capacity/index.js"
     },
+    "./freshness": {
+      "types": "./dist/freshness/index.d.ts",
+      "default": "./dist/freshness/index.js"
+    },
+    "./parent-turn-shape": {
+      "types": "./dist/parent-turn-shape/index.d.ts",
+      "default": "./dist/parent-turn-shape/index.js"
+    },
     "./intake": {
       "types": "./dist/intake/index.d.ts",
       "default": "./dist/intake/index.js"
@@ -342,8 +350,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.94.0",
-    "@deftai/directive-types": "^0.94.0",
+    "@deftai/directive-content": "^0.96.0",
+    "@deftai/directive-types": "^0.96.0",
     "archiver": "^8.0.0"
   },
   "scripts": {