@deftai/directive-core 0.99.0 → 0.100.0

package/dist/hooks/readonly.js

@@ -123,8 +123,8 @@ export function isAssistPosture(payload, environ = process.env) {
     if (posture !== null && ASSIST_POSTURE_MARKERS.has(normalizePostureToken(posture))) {
         return true;
     }
-    // Shared taxonomy with #3080 ephemeral spawn markers.
-    if (isEphemeralSpawn(payload))
+    // Shared taxonomy with #3080 / #3259 ephemeral spawn markers.
+    if (isEphemeralSpawn(payload, environ))
         return true;
     return false;
 }
@@ -176,34 +176,53 @@ function hasImplementConflictSignal(toolInput, input) {
     return false;
 }
 /**
- * Ephemeral / assist / docs spawns skip active-xBRIEF implementation gates (#3080).
+ * Session assist env tokens that count as structural ephemeral markers for spawn (#3259).
+ * Reuses #1802 ASSIST_POSTURE_MARKERS / DEFT_HOOK_ASSIST — not free-text NLP.
+ */
+function hasSessionAssistEphemeralEnv(environ) {
+    const envPosture = (environ[ASSIST_SESSION_POSTURE_ENV] ?? "").trim();
+    if (envPosture.length > 0 && ASSIST_POSTURE_MARKERS.has(normalizePostureToken(envPosture))) {
+        return true;
+    }
+    return envTruthy(environ, "DEFT_HOOK_ASSIST");
+}
+/**
+ * Ephemeral / assist / docs spawns skip active-xBRIEF implementation gates (#3080 / #3259).
  * True only with an explicit allowlisted marker. Absent marker → false (fail closed).
- * When an ephemeral marker conflicts with implement envelope signals, implement wins.
+ * Markers: structural `worker_role`/`subagent_type` ∈ {ephemeral,docs,assist}, OR
+ * session assist env (`DEFT_SESSION_POSTURE` assist-set / `DEFT_HOOK_ASSIST=1`) for spawn.
+ * Free-text prompt strings are never classified. When a marker conflicts with implement
+ * envelope signals, implement wins.
  */
-export function isEphemeralSpawn(payload) {
+export function isEphemeralSpawn(payload, environ = process.env) {
     const input = record(payload);
-    if (input === null)
-        return false;
-    const toolInput = toolInputRecord(input) ?? input;
-    const subagentType = fieldString(toolInput, "subagent_type") ??
-        fieldString(toolInput, "subagentType") ??
-        fieldString(input, "subagent_type") ??
-        fieldString(input, "subagentType");
-    const workerRole = fieldString(toolInput, "worker_role") ??
-        fieldString(toolInput, "workerRole") ??
-        fieldString(input, "worker_role") ??
-        fieldString(input, "workerRole");
-    const marker = (workerRole !== null && EPHEMERAL_ROLE_MARKERS.has(workerRole.toLowerCase())
-        ? workerRole.toLowerCase()
-        : null) ??
-        (subagentType !== null && EPHEMERAL_ROLE_MARKERS.has(subagentType.toLowerCase())
-            ? subagentType.toLowerCase()
-            : null);
-    if (marker === null)
+    const toolInput = input !== null ? (toolInputRecord(input) ?? input) : null;
+    let hasMarker = false;
+    if (input !== null && toolInput !== null) {
+        const subagentType = fieldString(toolInput, "subagent_type") ??
+            fieldString(toolInput, "subagentType") ??
+            fieldString(input, "subagent_type") ??
+            fieldString(input, "subagentType");
+        const workerRole = fieldString(toolInput, "worker_role") ??
+            fieldString(toolInput, "workerRole") ??
+            fieldString(input, "worker_role") ??
+            fieldString(input, "workerRole");
+        if ((workerRole !== null && EPHEMERAL_ROLE_MARKERS.has(workerRole.toLowerCase())) ||
+            (subagentType !== null && EPHEMERAL_ROLE_MARKERS.has(subagentType.toLowerCase()))) {
+            hasMarker = true;
+        }
+    }
+    // #3259 D1-B: session assist env is a structural ephemeral marker for spawn tools.
+    // Call sites gate "spawn only"; this helper stays pure classification.
+    if (!hasMarker && hasSessionAssistEphemeralEnv(environ)) {
+        hasMarker = true;
+    }
+    if (!hasMarker)
         return false;
-    // Implement signals win over ephemeral markers (fail closed).
-    if (hasImplementConflictSignal(toolInput, input))
+    // Implement signals win over ephemeral markers including session assist env (fail closed).
+    if (input !== null && toolInput !== null && hasImplementConflictSignal(toolInput, input)) {
         return false;
+    }
     return true;
 }
 //# sourceMappingURL=readonly.js.map

package/dist/index.d.ts

@@ -35,6 +35,7 @@ export * as intake from "./intake/index.js";
 export * as layout from "./layout/index.js";
 export * as legacyBridge from "./legacy-bridge/index.js";
 export * as lifecycle from "./lifecycle/index.js";
+export * as literalAcceptance from "./literal-acceptance/index.js";
 export * as metrics from "./metrics/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";

package/dist/index.js

@@ -36,6 +36,7 @@ export * as intake from "./intake/index.js";
 export * as layout from "./layout/index.js";
 export * as legacyBridge from "./legacy-bridge/index.js";
 export * as lifecycle from "./lifecycle/index.js";
+export * as literalAcceptance from "./literal-acceptance/index.js";
 export * as metrics from "./metrics/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";

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

@@ -5,6 +5,26 @@ export { DIRECT_WRITE_HOOK_MATCHER, MCP_HOOK_MATCHER, SHELL_HOOK_MATCHER, SPAWN_
 export declare const DEFT_HOOK_COMMAND_MARKER = "deft-hook";
 export declare const LEGACY_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"];
+/**
+ * Cursor session.start / session.compact deposit timeout (seconds).
+ * Lightweight ceremony paths — keep tight so stalled hooks fail fast.
+ */
+export declare const CURSOR_SESSION_HOOK_TIMEOUT_SECONDS = 5;
+/**
+ * Cursor preToolUse (tool.before) deposit timeout (seconds).
+ *
+ * Mutation tool.before runs `inspectMutationGates` → gated
+ * `verifySessionRitual`, which re-runs non-cacheable agent-hook readiness on
+ * every boundary. Live readiness alone has a multi-host fixture ceiling of
+ * ~12s (`content/contracts/agent-hook-readiness.md`); the historical deposit
+ * default of 5s was below that budget. Under Cursor `failClosed: true`, a
+ * host timeout kill surfaces as opaque exit-1 with no Directive decision
+ * code (#3246 / related #2864). Keep this above the readiness ceiling plus
+ * dispatch overhead so allow/deny can render within the host budget.
+ */
+export declare const CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS = 30;
+/** Nested Claude/Grok/Codex command-hook default timeout (seconds). */
+export declare const NESTED_HOOK_TIMEOUT_SECONDS = 5;
 export type AgentHookPath = (typeof AGENT_HOOK_PATHS)[number];
 export type AgentHookRegistrationStatus = "healthy" | "disabled" | "missing" | "drifted";
 /** Whether the host receives a compact/resume hook deposit (#2113). */

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

@@ -13,6 +13,26 @@ export const AGENT_HOOK_PATHS = [
     ".cursor/hooks.json",
     ".codex/hooks.json",
 ];
+/**
+ * Cursor session.start / session.compact deposit timeout (seconds).
+ * Lightweight ceremony paths — keep tight so stalled hooks fail fast.
+ */
+export const CURSOR_SESSION_HOOK_TIMEOUT_SECONDS = 5;
+/**
+ * Cursor preToolUse (tool.before) deposit timeout (seconds).
+ *
+ * Mutation tool.before runs `inspectMutationGates` → gated
+ * `verifySessionRitual`, which re-runs non-cacheable agent-hook readiness on
+ * every boundary. Live readiness alone has a multi-host fixture ceiling of
+ * ~12s (`content/contracts/agent-hook-readiness.md`); the historical deposit
+ * default of 5s was below that budget. Under Cursor `failClosed: true`, a
+ * host timeout kill surfaces as opaque exit-1 with no Directive decision
+ * code (#3246 / related #2864). Keep this above the readiness ceiling plus
+ * dispatch overhead so allow/deny can render within the host budget.
+ */
+export const CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS = 30;
+/** Nested Claude/Grok/Codex command-hook default timeout (seconds). */
+export const NESTED_HOOK_TIMEOUT_SECONDS = 5;
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -90,7 +110,7 @@ function nestedGroup(host, event, matcher) {
             {
                 type: "command",
                 command: command(host, event),
-                timeout: 5,
+                timeout: NESTED_HOOK_TIMEOUT_SECONDS,
             },
         ],
     };
@@ -154,35 +174,47 @@ function mergeCursorConfig(config, path) {
     const session = eventArray(hooks, "sessionStart", path).filter((entry) => !isManagedCursorEntry(entry));
     const preTool = eventArray(hooks, "preToolUse", path).filter((entry) => !isManagedCursorEntry(entry));
     const preCompact = eventArray(hooks, "preCompact", path).filter((entry) => !isManagedCursorEntry(entry));
-    hooks.sessionStart = [...session, { command: command("cursor", "session.start"), timeout: 5 }];
+    hooks.sessionStart = [
+        ...session,
+        {
+            command: command("cursor", "session.start"),
+            timeout: CURSOR_SESSION_HOOK_TIMEOUT_SECONDS,
+        },
+    ];
     hooks.preToolUse = [
         ...preTool,
         {
             command: command("cursor", "tool.before"),
             matcher: DIRECT_WRITE_HOOK_MATCHER,
             failClosed: true,
-            timeout: 5,
+            timeout: CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS,
         },
         {
             command: command("cursor", "tool.before"),
             matcher: SPAWN_HOOK_MATCHER,
             failClosed: true,
-            timeout: 5,
+            timeout: CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS,
         },
         {
             command: command("cursor", "tool.before"),
             matcher: SHELL_HOOK_MATCHER,
             failClosed: true,
-            timeout: 5,
+            timeout: CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS,
         },
         {
             command: command("cursor", "tool.before"),
             matcher: MCP_HOOK_MATCHER,
             failClosed: true,
-            timeout: 5,
+            timeout: CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS,
+        },
+    ];
+    hooks.preCompact = [
+        ...preCompact,
+        {
+            command: command("cursor", "session.compact"),
+            timeout: CURSOR_SESSION_HOOK_TIMEOUT_SECONDS,
         },
     ];
-    hooks.preCompact = [...preCompact, { command: command("cursor", "session.compact"), timeout: 5 }];
     return { ...config, version: 1, hooks };
 }
 function writeJsonIfChanged(projectRoot, path, payload) {
@@ -341,6 +373,14 @@ function hasNestedRegistration(config, host, options = {}) {
     return (preCompact.some((entry) => nestedCommands(entry).includes(compactCommand)) &&
         postCompact.some((entry) => nestedCommands(entry).includes(compactCommand)));
 }
+function isCursorToolBeforeEntry(value, matcher) {
+    const hook = object(value);
+    return (hook?.command === command("cursor", "tool.before") &&
+        hook.matcher === matcher &&
+        hook.failClosed === true &&
+        // #3246: budget must cover gated ritual + live agent-hook readiness.
+        hook.timeout === CURSOR_TOOL_BEFORE_TIMEOUT_SECONDS);
+}
 function hasCursorRegistration(config) {
     const hooks = object(config.hooks);
     if (hooks === null || config.version !== 1)
@@ -349,30 +389,10 @@ function hasCursorRegistration(config) {
     const preTool = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
     const preCompact = Array.isArray(hooks.preCompact) ? hooks.preCompact : [];
     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.failClosed === true);
-        }) &&
-        preTool.some((entry) => {
-            const hook = object(entry);
-            return (hook?.command === command("cursor", "tool.before") &&
-                hook.matcher === SPAWN_HOOK_MATCHER &&
-                hook.failClosed === true);
-        }) &&
-        preTool.some((entry) => {
-            const hook = object(entry);
-            return (hook?.command === command("cursor", "tool.before") &&
-                hook.matcher === SHELL_HOOK_MATCHER &&
-                hook.failClosed === true);
-        }) &&
-        preTool.some((entry) => {
-            const hook = object(entry);
-            return (hook?.command === command("cursor", "tool.before") &&
-                hook.matcher === MCP_HOOK_MATCHER &&
-                hook.failClosed === true);
-        }) &&
+        preTool.some((entry) => isCursorToolBeforeEntry(entry, DIRECT_WRITE_HOOK_MATCHER)) &&
+        preTool.some((entry) => isCursorToolBeforeEntry(entry, SPAWN_HOOK_MATCHER)) &&
+        preTool.some((entry) => isCursorToolBeforeEntry(entry, SHELL_HOOK_MATCHER)) &&
+        preTool.some((entry) => isCursorToolBeforeEntry(entry, MCP_HOOK_MATCHER)) &&
         preCompact.some((entry) => object(entry)?.command === command("cursor", "session.compact")));
 }
 /** Read-only registration probe shared by verify and doctor. */

package/dist/intake/issue-ingest.js

@@ -4,6 +4,7 @@ import { cacheGet } from "../cache/operations.js";
 import { scan } from "../cache/scanner.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { captureAndAttachLiteralAcceptance } from "../literal-acceptance/index.js";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
@@ -444,6 +445,34 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
         }
         plan.references = references;
     }
+    // #3267: capture exact stated acceptance commands from the issue body at intake
+    // into plan.metadata.literal_acceptance_commands (source=task_statement, capture-only).
+    // Agents MUST promote exact strings into swarm.verify_commands before shell execution
+    // (Greptile P1: raw issue text must not auto-spawn). Not paraphrased.
+    if (bodyStr.length > 0) {
+        const intakeText = [title, bodyStr].filter((s) => s.length > 0).join("\n\n");
+        const attached = captureAndAttachLiteralAcceptance(plan, intakeText);
+        // Re-tag stored capture as task_statement so run refuses until promote.
+        const meta = attached.plan.metadata;
+        if (meta !== undefined && Array.isArray(meta.literal_acceptance_commands)) {
+            meta.literal_acceptance_commands = meta.literal_acceptance_commands.map((row) => ({ ...row, source: "task_statement" }));
+            // Do not copy untrusted issue text into swarm.verify_commands (executable).
+            const swarm = meta.swarm;
+            if (swarm !== undefined && Array.isArray(swarm.verify_commands)) {
+                // Keep only pre-existing verify_commands that were not just attached from capture.
+                // captureAndAttach merges captured into verify_commands — strip those that match
+                // task_statement captures so issue text cannot auto-execute.
+                const capturedSet = new Set(meta.literal_acceptance_commands
+                    .map((r) => (typeof r.command === "string" ? r.command : ""))
+                    .filter((s) => s.length > 0));
+                swarm.verify_commands = swarm.verify_commands.filter((c) => typeof c === "string" && !capturedSet.has(c));
+                if (swarm.verify_commands.length === 0) {
+                    delete swarm.verify_commands;
+                }
+            }
+        }
+        Object.assign(plan, attached.plan);
+    }
     const infoRootKey = options.infoRootKey ?? LEGACY_INFO_ROOT_KEY;
     const infoVersion = options.infoVersion ?? EMITTED_VBRIEF_VERSION;
     const briefLabel = infoRootKey === MIGRATED_INFO_ROOT_KEY ? "xBRIEF" : "vBRIEF";

package/dist/lifecycle/completed-consistency.d.ts

@@ -0,0 +1,60 @@
+/** Item statuses that still represent unfinished checklist work (#2862 / #3240 / #3242). */
+export declare const NON_TERMINAL_ITEM_STATUSES: Set<string>;
+/**
+ * Terminal checklist statuses for completed-folder fail-closed (#3242).
+ * Align with #3240 non-terminal set: any valid item status that is not
+ * pending|proposed|running is terminal; unknown/invalid statuses fail closed.
+ */
+export declare const TERMINAL_ITEM_STATUSES: Set<string>;
+/** Statuses allowed under completed/ (D2/D13). */
+export declare const COMPLETED_FOLDER_PLAN_STATUSES: ReadonlySet<string>;
+export type CompletedConsistencyKind = "status_mismatch" | "open_items" | "unreadable";
+export interface OpenItemHit {
+    readonly path: string;
+    readonly status: string;
+    readonly title: string;
+}
+export interface CompletedConsistencyFinding {
+    /** Lifecycle-relative path, e.g. `completed/foo.xbrief.json`. */
+    readonly relPath: string;
+    readonly planStatus: string;
+    readonly folder: "completed";
+    readonly kind: CompletedConsistencyKind;
+    /** Human detail including exact path + statuses. */
+    readonly detail: string;
+    readonly openItems?: readonly OpenItemHit[];
+}
+export interface CompletedConsistencyResult {
+    readonly ok: boolean;
+    readonly findings: readonly CompletedConsistencyFinding[];
+    readonly message: string;
+}
+/**
+ * Collect non-terminal plan.items / subItems / nested items.
+ * Fail-closed on malformed slots: non-object entries and present non-array
+ * nested collections are reported so completed corpus cannot green-skip them.
+ */
+export declare function collectOpenPlanItems(items: unknown, pathPrefix?: string): OpenItemHit[];
+/**
+ * Evaluate Q4 consistency for a single plan that claims completed lifecycle.
+ *
+ * @param plan - plan object
+ * @param options.relPath - artifact path for messages (default `plan`)
+ * @param options.requireStatus - when set, plan.status must equal this exactly
+ *   (scope:complete uses `completed`). When omitted, any completed-folder
+ *   terminal status (completed|failed) is accepted.
+ */
+export declare function evaluateCompletedPlanConsistency(plan: Record<string, unknown>, options?: {
+    relPath?: string;
+    requireStatus?: string;
+}): CompletedConsistencyResult;
+/** Format fail-closed doctor/complete message with exact paths and statuses. */
+export declare function formatCompletedConsistencyFailure(findings: readonly CompletedConsistencyFinding[]): string;
+/**
+ * Scan `xbrief/completed/` and/or legacy `vbrief/completed/` for Q4 mismatches.
+ * Offline / filesystem only. Missing completed/ is green (nothing to check).
+ * Malformed completed artifacts and unreadable roots fail closed (no silent skip).
+ * Mixed roots scan both.
+ */
+export declare function scanCompletedLifecycleConsistency(projectRoot: string): CompletedConsistencyResult;
+//# sourceMappingURL=completed-consistency.d.ts.map