@deftai/directive-core 0.85.0 → 0.86.0

package/dist/doctor/constants.d.ts

@@ -14,9 +14,9 @@ export declare const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org/";
 export declare const NPM_REGISTRY_MIRROR_DOC_URL = "https://github.com/deftai/directive/blob/master/content/UPGRADING.md#corporate-or-mirrored-npm-registry";
 export declare const NETWORK_DISCLOSURE_LINE: string;
 export declare const PAYLOAD_STALENESS_OFFLINE_SKIP_MESSAGE: string;
-export declare const EXPECTED_FRAMEWORK_DIRS: readonly ["tasks", "scripts", "vbrief"];
+export declare const EXPECTED_FRAMEWORK_DIRS: readonly ["tasks", "scripts", "xbrief"];
 /** npm consumer deposit after #2022 Phase 3 -- Python scripts/ tree is intentionally absent. */
-export declare const CONSUMER_FRAMEWORK_DIRS: readonly ["tasks", "vbrief"];
+export declare const CONSUMER_FRAMEWORK_DIRS: readonly ["tasks", "xbrief"];
 export declare const DEFT_REPO_POSITIVE_MARKERS: readonly ["content/templates/agents-entry.md", "content/skills/deft-directive-build/SKILL.md"];
 export declare const EXPECTED_CONTENT_DIRS: readonly ["languages", "strategies", "skills", "templates"];
 /** Post-freeze canonical upgrade path (#1997 / #2003 / #1912). */

package/dist/doctor/constants.js

@@ -46,9 +46,9 @@ export const PAYLOAD_STALENESS_OFFLINE_SKIP_MESSAGE = "skip -- offline tier (def
     "(discloses tool + registry before contacting either).";
 // Engine / lifecycle dirs that stay at the framework root (NOT relocated by
 // #1875). Shippable-content dirs moved under content/ -- see EXPECTED_CONTENT_DIRS.
-export const EXPECTED_FRAMEWORK_DIRS = ["tasks", "scripts", "vbrief"];
+export const EXPECTED_FRAMEWORK_DIRS = ["tasks", "scripts", "xbrief"];
 /** npm consumer deposit after #2022 Phase 3 -- Python scripts/ tree is intentionally absent. */
-export const CONSUMER_FRAMEWORK_DIRS = ["tasks", "vbrief"];
+export const CONSUMER_FRAMEWORK_DIRS = ["tasks", "xbrief"];
 // Post-#1875 content/ move: these framework-internal markers now live under
 // content/ in the SOURCE repo. They identify a deft source checkout (a consumer
 // would never reproduce them); the C1 flatten means a consumer deposit has no

package/dist/doctor/main.d.ts

@@ -2,7 +2,8 @@ import { type ResolutionFacts } from "../resolution/index.js";
 import { createPlainSink } from "./output.js";
 import type { DoctorSeams, Finding, ResolutionSummary } from "./types.js";
 export declare function cmdDoctor(args: readonly string[], seams?: DoctorSeams): number;
-export declare function runAgentHooksHealthCheck(projectRoot: string, consumerContext: boolean, sink: ReturnType<typeof createPlainSink>, addFinding: (finding: Finding) => void, seams: DoctorSeams): void;
+export declare function runAgentHooksHealthCheck(projectRoot: string, consumerContext: boolean, sink: ReturnType<typeof createPlainSink>, addFinding: (finding: Finding) => void, seams: DoctorSeams): boolean;
+export declare function runAgentHooksLiveProbeCheck(projectRoot: string, sink: ReturnType<typeof createPlainSink>, addFinding: (finding: Finding) => void, seams: DoctorSeams): void;
 /**
  * Never emit a bare `task ...` remediation in a project without Taskfile wiring
  * (#2267). The `directive` surface always works; `task deft:X` is optional and

package/dist/doctor/main.js

@@ -7,6 +7,7 @@ import { loadProjectDefinition } from "../policy/resolve.js";
 import { checkLocalEngineIntegrity, classify, detectPackageManager, evaluateSkew, reconcileVersions, plan as resolvePlan, } from "../resolution/index.js";
 import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
 import { evaluateAgentHooks } from "../verify-env/agent-hooks.js";
+import { probeAgentHooksLive } from "../verify-env/agent-hooks-live-probe.js";
 import { agentsRefreshPlan, hasV3ManagedMarker } from "./agents-md.js";
 import { runChecks } from "./checks.js";
 import { CONSUMER_FRAMEWORK_DIRS, EXPECTED_CONTENT_DIRS, EXPECTED_FRAMEWORK_DIRS, NETWORK_DISCLOSURE_LINE, PAYLOAD_STALENESS_OFFLINE_SKIP_MESSAGE, TASKFILE_INCLUDE_SNIPPET, UV_INSTALL_URL, } from "./constants.js";
@@ -16,7 +17,7 @@ import { pythonJsonDump } from "./json.js";
 import { parseInstallRootFromAgentsMd } from "./manifest.js";
 import { runNpmRegistryMirrorCheck } from "./npm-registry.js";
 import { createPlainSink } from "./output.js";
-import { readTextSafe, resolveDefaultFrameworkRoot, resolvePath, resolveVersion, runningInsideDeftRepo, } from "./paths.js";
+import { readTextSafe, resolveFrameworkRootForProject, resolvePath, resolveVersion, runningInsideDeftRepo, } from "./paths.js";
 import { runPayloadStalenessCheck } from "./payload-staleness.js";
 import { runLocalSignpostChecks } from "./signpost-checks.js";
 import { classifyTaskfileInclude, formatMissingIncludeSnippet, includesBlockHasDeftTaskfile, resolveConsumerTaskfile, } from "./taskfile.js";
@@ -57,7 +58,7 @@ export function cmdDoctor(args, seams = {}) {
     const quietMode = flags.quiet;
     const fullMode = flags.full;
     const projectRoot = resolvePath(flags.projectRoot ?? process.cwd());
-    const frameworkRoot = seams.frameworkRoot ?? resolveDefaultFrameworkRoot();
+    const frameworkRoot = seams.frameworkRoot ?? resolveFrameworkRootForProject(projectRoot);
     const consumerContext = resolve(projectRoot) !== resolve(frameworkRoot);
     const whichFn = seams.whichFn ?? defaultWhich;
     const nowFn = seams.now ?? (() => new Date());
@@ -165,7 +166,17 @@ export function cmdDoctor(args, seams = {}) {
         sink.blank();
     }
     sink.info("Checking agent-host hook registration...");
-    runAgentHooksHealthCheck(projectRoot, consumerContext, sink, addFinding, seams);
+    const findingCountBeforeHooks = findings.length;
+    const hooksHealthy = runAgentHooksHealthCheck(projectRoot, consumerContext, sink, addFinding, seams);
+    if (fullMode && hooksHealthy) {
+        const lastFinding = findings[findings.length - 1];
+        if (findings.length > findingCountBeforeHooks &&
+            lastFinding?.check === "agent-hooks-registration" &&
+            lastFinding?.status === "registered") {
+            findings.pop();
+        }
+        runAgentHooksLiveProbeCheck(projectRoot, sink, addFinding, seams);
+    }
     if (consumerContext) {
         if (!jsonMode) {
             sink.blank();
@@ -353,40 +364,81 @@ export function runAgentHooksHealthCheck(projectRoot, consumerContext, sink, add
         const reason = "maintainer source checkout; project hook deposit is consumer-only";
         sink.info(`${checkName}: skip -- ${reason}`);
         addFinding({ severity: "skip", message: reason, check: checkName, status: "skip" });
-        return;
+        return false;
     }
     try {
         const result = (seams.evaluateAgentHooks ?? evaluateAgentHooks)(projectRoot);
-        if (result.code === 0) {
-            const message = `${checkName}: registered and structurally valid; ` +
-                "Codex runtime trust is user-controlled and must be reviewed with `/hooks`";
-            sink.success(message);
+        if (result.code !== 0) {
+            const message = `${checkName}: ${result.message.replace(/\s+/g, " ").trim()}`;
+            sink.warn(message);
             addFinding({
-                severity: "skip",
+                severity: "warning",
                 message,
                 check: checkName,
-                status: "registered",
+                status: result.code === 2 ? "unavailable" : "incomplete",
                 registrations: result.registrations,
-                trust_status: "not-verifiable",
-                trust_review: "Open `/hooks` in Codex and review the project hook commands.",
+                suggestion: "deft update",
             });
-            return;
+            return false;
         }
-        const message = `${checkName}: ${result.message.replace(/\s+/g, " ").trim()}`;
-        sink.warn(message);
+        const message = `${checkName}: registered and structurally valid; ` +
+            "Codex runtime trust is user-controlled and must be reviewed with `/hooks`";
+        sink.success(message);
         addFinding({
-            severity: "warning",
+            severity: "skip",
             message,
             check: checkName,
-            status: result.code === 2 ? "unavailable" : "incomplete",
+            status: "registered",
             registrations: result.registrations,
-            suggestion: "deft update",
+            trust_status: "not-verifiable",
+            trust_review: "Open `/hooks` in Codex and review the project hook commands.",
         });
+        return true;
     }
     catch (cause) {
         const message = `${checkName}: probe failed -- ${String(cause)}`;
         sink.warn(message);
         addFinding({ severity: "warning", message, check: checkName, suggestion: "deft update" });
+        return false;
+    }
+}
+export function runAgentHooksLiveProbeCheck(projectRoot, sink, addFinding, seams) {
+    const checkName = "agent-hooks-registration";
+    const liveCheckName = "agent-hooks-live-probe";
+    try {
+        const result = (seams.evaluateAgentHooks ?? evaluateAgentHooks)(projectRoot);
+        const liveResult = (seams.probeAgentHooksLive ?? probeAgentHooksLive)(projectRoot);
+        if (liveResult.code !== 0) {
+            const message = `${liveCheckName}: ${liveResult.message.replace(/\s+/g, " ").trim()}`;
+            sink.warn(message);
+            addFinding({
+                severity: "warning",
+                message,
+                check: liveCheckName,
+                status: liveResult.code === 2 ? "unavailable" : "non-functional",
+                cases: liveResult.cases,
+                suggestion: "npm i -g @deftai/directive@latest && deft update",
+            });
+            return;
+        }
+        const message = `${checkName}: registered, structurally valid, and live probe passed; ` +
+            "Codex runtime trust is user-controlled and must be reviewed with `/hooks`";
+        sink.success(message);
+        addFinding({
+            severity: "skip",
+            message,
+            check: liveCheckName,
+            status: "registered-and-functional",
+            registrations: result.registrations,
+            trust_status: "not-verifiable",
+            trust_review: "Open `/hooks` in Codex and review the project hook commands.",
+            live_probe: "passed",
+        });
+    }
+    catch (cause) {
+        const message = `${liveCheckName}: probe failed -- ${String(cause)}`;
+        sink.warn(message);
+        addFinding({ severity: "warning", message, check: liveCheckName, suggestion: "deft update" });
     }
 }
 function runInstallIntegrityChecks(projectRoot, sink, addFinding, seams) {

package/dist/doctor/types.d.ts

@@ -4,6 +4,7 @@ import type { EngineProbeResult } from "../resolution/classify.js";
 import type { ResolutionMode } from "../resolution/index.js";
 import type { ResolveUserMdResult } from "../user-config/resolve-user-md.js";
 import type { AgentHookHealthResult } from "../verify-env/agent-hooks.js";
+import type { AgentHookLiveProbeResult } from "../verify-env/agent-hooks-live-probe.js";
 export declare const EXIT_CLEAN = 0;
 export declare const EXIT_DRIFT = 1;
 export declare const EXIT_CONFIG_ERROR = 2;
@@ -147,5 +148,7 @@ export interface DoctorSeams {
     readonly detectPlanExtensionShadows?: (projectRoot: string) => readonly ShadowedPlanExtension[];
     /** Read-only agent-host hook registration probe (#2438). */
     readonly evaluateAgentHooks?: (projectRoot: string) => AgentHookHealthResult;
+    /** Live hook spawn probe for doctor --full (#2852). */
+    readonly probeAgentHooksLive?: (projectRoot: string) => AgentHookLiveProbeResult;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -238,14 +238,22 @@ export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefine
                 changedPaths.push(item.path);
         }
     }
-    const adapterAbsolute = join(projectRoot, ".cursor/hooks/deft-cursor-hook-adapter.mjs");
-    assertDepositContained(projectRoot, adapterAbsolute);
-    if (existsSync(adapterAbsolute)) {
-        rmSync(adapterAbsolute, { force: true });
-        if (!changedPaths.includes(AGENT_HOOK_PATHS[2])) {
-            changedPaths.push(AGENT_HOOK_PATHS[2]);
+    const legacyAdapterPaths = [
+        ".cursor/hooks/deft-cursor-hook-adapter.mjs",
+        ".cursor/hooks/deft-cursor-hook-adapter.test.mjs",
+    ];
+    let removedLegacyAdapter = false;
+    for (const relative of legacyAdapterPaths) {
+        const absolute = join(projectRoot, relative);
+        assertDepositContained(projectRoot, absolute);
+        if (existsSync(absolute)) {
+            rmSync(absolute, { force: true });
+            removedLegacyAdapter = true;
         }
     }
+    if (removedLegacyAdapter && !changedPaths.includes(AGENT_HOOK_PATHS[2])) {
+        changedPaths.push(AGENT_HOOK_PATHS[2]);
+    }
     if (changedPaths.length > 0) {
         io.printf(`Installed Directive agent hooks: ${changedPaths.join(", ")}\n`);
     }

package/dist/init-deposit/gitignore.js

@@ -11,6 +11,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { FORBIDDEN_BLANKET_EVAL_LINES, stripGitignoreInlineComment, } from "../triage/bootstrap/gitignore.js";
 /** Directory ignore entry for the hybrid deposit (greenfield only). */
 export const GITIGNORE_DEFT_CORE_LINE = ".deft/core/";
@@ -195,9 +196,13 @@ function reconcileGitignoreFile(projectDir, targetLines, includeDeftCoreRational
         }
     }
     try {
+        assertWriteTargetSafe(projectDir, path);
         writeFileSync(path, body, { encoding: "utf8", mode: 0o644 });
     }
     catch (cause) {
+        if (cause instanceof ProjectionContainmentError) {
+            throw cause;
+        }
         throw new Error(`could not write .gitignore: ${String(cause)}`);
     }
     const finalPresent = collectPresentGitignoreLines(body);

package/dist/policy/org-force-on-migration.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
 import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
@@ -56,6 +57,7 @@ export function readOrgForceOnMarker(projectRoot) {
 }
 function writeOrgForceOnMarker(projectRoot, marker) {
     const path = markerPath(projectRoot);
+    assertWriteTargetSafe(projectRoot, path);
     mkdirSync(join(path, ".."), { recursive: true });
     writeFileSync(path, `${JSON.stringify(marker, null, 2)}\n`, "utf8");
 }

package/dist/render/framework-commands.d.ts

@@ -25,7 +25,7 @@ export declare function formatFrameworkCommand(args: readonly string[], options?
     surface?: string;
     taskPrefix?: string | null;
 }): string;
-export declare function cmdCoreValidate(argv: readonly string[]): number;
+export declare function cmdCoreValidate(argv: readonly string[], root?: string): number;
 export declare function cmdCoreLint(_argv: readonly string[]): number;
 export declare function cmdCoreTest(_argv: readonly string[]): number;
 export declare function resolveFrameworkRoot(): string;

package/dist/render/framework-commands.js

@@ -154,7 +154,7 @@ export function formatFrameworkCommand(args, options = {}) {
     }
     return [surface, ...parts].join(" ");
 }
-const EXCLUDE_PARTS = new Set([".git", "backup"]);
+const EXCLUDE_PARTS = new Set([".git", "backup", "node_modules", ".deft-scratch"]);
 function collectMarkdownFiles(root) {
     const out = [];
     const walk = (dir, parts) => {
@@ -189,12 +189,12 @@ function collectMarkdownFiles(root) {
     walk(root, []);
     return out.sort();
 }
-export function cmdCoreValidate(argv) {
+export function cmdCoreValidate(argv, root = ".") {
     if (argv.length > 0) {
         process.stderr.write(`error: core:validate does not accept arguments: ${argv.join(" ")}\n`);
         return 2;
     }
-    const files = collectMarkdownFiles(".");
+    const files = collectMarkdownFiles(root);
     for (const path of files)
         process.stdout.write(`✓ ${path}\n`);
     process.stdout.write(`✓ All ${files.length} markdown files validated\n`);
@@ -271,7 +271,7 @@ function runBuildDistArgv(argv) {
     return result.status ?? 1;
 }
 const TS_INLINE = {
-    "framework_commands:_cmd_core_validate": (argv) => cmdCoreValidate(argv),
+    "framework_commands:_cmd_core_validate": (argv, cwd) => cmdCoreValidate(argv, cwd),
     "doctor:cmd_doctor": (argv) => cmdDoctor(argv),
     "build_dist:main": (argv) => runBuildDistArgv(argv),
 };
@@ -349,7 +349,7 @@ function invokeEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv, capture)
             };
             let code;
             try {
-                code = inline(argv);
+                code = inline(argv, cwd);
             }
             finally {
                 process.stdout.write = prevOut;
@@ -357,7 +357,7 @@ function invokeEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv, capture)
             }
             return { code, stdout: chunks.out, stderr: chunks.err };
         }
-        return { code: inline(argv), stdout: "", stderr: "" };
+        return { code: inline(argv, cwd), stdout: "", stderr: "" };
     }
     const verb = ENTRYPOINT_VERB[entrypoint];
     if (verb) {

package/dist/render/roadmap-render.d.ts

@@ -3,7 +3,11 @@ export declare function renderRoadmapToBuffer(pendingDir: string, completedDir?:
 /** @deprecated Prefer ``renderRoadmapToBuffer`` — kept for existing imports and parity harnesses. */
 export declare function generateRoadmapContent(pendingDir: string, completedDir?: string): string;
 export type RenderRoadmapResult = readonly [boolean, string];
-export declare function renderRoadmap(pendingDir: string, outPath: string, completedDir?: string): RenderRoadmapResult;
+export type RenderRoadmapOptions = {
+    completedDir?: string;
+    projectRoot?: string;
+};
+export declare function renderRoadmap(pendingDir: string, outPath: string, completedDirOrOptions?: string | RenderRoadmapOptions): RenderRoadmapResult;
 export declare function checkDrift(pendingDir: string, roadmapPath: string, completedDir?: string): RenderRoadmapResult;
 /** CLI entry (mirrors ``scripts/roadmap_render.main``). */
 export declare function main(argv: readonly string[]): number;

package/dist/render/roadmap-render.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { MIGRATOR_METADATA_KEY, ROADMAP_BANNER } from "./constants.js";
 import { phaseSortKey } from "./text-utils.js";
@@ -351,9 +352,22 @@ export function renderRoadmapToBuffer(pendingDir, completedDir) {
 export function generateRoadmapContent(pendingDir, completedDir) {
     return renderRoadmapToBuffer(pendingDir, completedDir);
 }
-export function renderRoadmap(pendingDir, outPath, completedDir) {
+export function renderRoadmap(pendingDir, outPath, completedDirOrOptions) {
+    let completedDir;
+    let projectRoot;
+    if (typeof completedDirOrOptions === "string") {
+        completedDir = completedDirOrOptions;
+    }
+    else if (completedDirOrOptions !== undefined) {
+        completedDir = completedDirOrOptions.completedDir;
+        projectRoot = completedDirOrOptions.projectRoot;
+    }
     try {
         const content = renderRoadmapToBuffer(pendingDir, completedDir);
+        // Trust boundary is the project root — never dirname(outPath), which follows a
+        // diverted parent symlink and would make containment pass outside the checkout.
+        const projectDir = projectRoot !== undefined ? resolve(projectRoot) : resolve(pendingDir, "..", "..");
+        assertWriteTargetSafe(projectDir, resolve(outPath));
         writeFileSync(outPath, content, "utf8");
         return [true, `✓ Rendered ROADMAP.md to ${outPath}`];
     }
@@ -415,7 +429,11 @@ export function main(argv) {
         process.stdout.write(`${msg}\n`);
         return ok ? 0 : 1;
     }
-    const [ok, msg] = renderRoadmap(pendingDir, outPath);
+    // When --project-root is set, use it; otherwise renderRoadmap derives from pendingDir
+    // (…/xbrief|vbrief/pending → project root). Never use dirname(outPath).
+    const [ok, msg] = renderRoadmap(pendingDir, outPath, {
+        projectRoot: projectRoot !== undefined ? resolve(projectRoot) : undefined,
+    });
     process.stdout.write(`${msg}\n`);
     return ok ? 0 : 1;
 }

package/dist/render/rule-map.js

@@ -13,6 +13,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 import { TEMPLATE } from "./rule-map-template.js";
 const MARKER_RE = /^\s*[-*]\s*([!~⊗≉?])\s/;
 const MARKER_LABEL = {
@@ -684,6 +685,10 @@ export function main(argv) {
         process.stdout.write("ok: docs/RULE-MAP.md is up to date\n");
         return 0;
     }
+    // Preflight both destinations before either write so a later HTML refusal
+    // cannot leave RULE-MAP.md updated while docs/rule-map/index.html stays stale.
+    assertWriteTargetSafe(repo, mdPath);
+    assertWriteTargetSafe(repo, htmlPath);
     mkdirSync(dirname(mdPath), { recursive: true });
     writeFileSync(mdPath, md, "utf8");
     mkdirSync(htmlDir, { recursive: true });

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

@@ -0,0 +1,32 @@
+import type { HookEvent, HookHost } from "../hooks/dispatcher.js";
+export type AgentHookLiveProbeIssue = "hook-command-missing" | "spawn-failed" | "empty-stdout" | "unparseable-json" | "missing-allow" | "missing-deny";
+export interface AgentHookLiveProbeCase {
+    readonly host: HookHost;
+    readonly event: HookEvent;
+    readonly fixture: "allow" | "deny";
+    readonly issue: AgentHookLiveProbeIssue;
+    readonly detail: string;
+}
+export interface AgentHookLiveProbeResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly cases: readonly AgentHookLiveProbeCase[];
+}
+export interface AgentHookLiveProbeSeams {
+    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 status: number;
+        readonly stdout: string;
+        readonly stderr: string;
+    };
+}
+export declare function quoteWindowsCmdArg(value: string): string;
+/** Spawn the configured hook command and assert Cursor tool.before allow/deny behavior. */
+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

@@ -0,0 +1,216 @@
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+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";
+const LIVE_PROBE_EVENT = "tool.before";
+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;
+}
+export function quoteWindowsCmdArg(value) {
+    const escaped = value.replace(/%/g, "%%");
+    if (!/[\s"&|<>^()]/.test(escaped)) {
+        return escaped;
+    }
+    return `"${escaped.replace(/"/g, '""')}"`;
+}
+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], {
+        input: stdin,
+        cwd,
+        env,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        shell,
+        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 : "",
+    };
+}
+function allowFixture(projectRoot) {
+    return JSON.stringify({
+        tool_name: "Read",
+        cwd: projectRoot,
+        workspace_roots: [projectRoot],
+    });
+}
+function denyFixture(projectRoot) {
+    return JSON.stringify({
+        tool_name: "Task",
+        cwd: projectRoot,
+        workspace_roots: [projectRoot],
+        tool_input: { subagent_type: "generalPurpose", prompt: "implement" },
+    });
+}
+function denyProbeEnv() {
+    return { ...process.env, [READ_ONLY_HOOK_ENV]: "1" };
+}
+function parseCursorDecision(stdout) {
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, 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" };
+        }
+        return { ok: false, detail: "stdout JSON missing permission allow/deny" };
+    }
+    catch {
+        return { ok: false, 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) {
+        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()}` : ""}`,
+        };
+    }
+    const decision = parseCursorDecision(spawned.stdout);
+    if (!decision.ok) {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: decision.detail.includes("JSON") ? "unparseable-json" : "empty-stdout",
+            detail: decision.detail,
+        };
+    }
+    if (fixture === "allow" && decision.permission !== "allow") {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: "missing-allow",
+            detail: `expected permission allow, got ${decision.permission ?? "none"}`,
+        };
+    }
+    if (fixture === "deny" && decision.permission !== "deny") {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: "missing-deny",
+            detail: `expected permission deny, got ${decision.permission ?? "none"}`,
+        };
+    }
+    return null;
+}
+/** Spawn the configured hook command and assert Cursor tool.before allow/deny behavior. */
+export function probeAgentHooksLive(projectRoot, seams = {}) {
+    const root = resolve(projectRoot);
+    const resolved = resolveHookCommand(seams);
+    if (resolved === null) {
+        return {
+            code: 2,
+            message: "deft agent hooks live probe unavailable: neither deft-hook nor deft/directive hook:dispatch is on PATH.",
+            cases: [
+                {
+                    host: LIVE_PROBE_HOST,
+                    event: LIVE_PROBE_EVENT,
+                    fixture: "allow",
+                    issue: "hook-command-missing",
+                    detail: `${DEFT_HOOK_COMMAND_MARKER} not found on PATH`,
+                },
+            ],
+        };
+    }
+    const spawnHook = seams.spawnHook ??
+        ((input) => spawnHookWithStdin(input.command, input.args, input.stdin, input.cwd, input.env ?? process.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);
+    }
+    if (failures.length === 0) {
+        return {
+            code: 0,
+            message: "deft agent hooks live probe passed for Cursor tool.before allow and deny fixtures.",
+            cases: [],
+        };
+    }
+    const summary = failures
+        .map((entry) => `${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,
+    };
+}
+//# sourceMappingURL=agent-hooks-live-probe.js.map

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

@@ -1,4 +1,5 @@
 export * from "./agent-hooks.js";
+export * from "./agent-hooks-live-probe.js";
 export * from "./command-spawn.js";
 export * from "./node-runtime.js";
 export * from "./toolchain-check.js";

package/dist/verify-env/index.js

@@ -1,4 +1,5 @@
 export * from "./agent-hooks.js";
+export * from "./agent-hooks-live-probe.js";
 export * from "./command-spawn.js";
 export * from "./node-runtime.js";
 export * from "./toolchain-check.js";

package/dist/xbrief-migrate/migrate-project.js

@@ -1,7 +1,8 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { checkGitClean } from "../migrate-preflight/index.js";
-import { agentsRefreshPlan } from "../platform/agents-md.js";
+import { applyAgentsRefresh } from "../platform/agents-md.js";
 import { patchAgentsMdHeader, renderHeaderPatchSummary } from "./agents-header.js";
 import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, OBSOLETE_FRAMEWORK_NARRATIVE_FILENAME, VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, } from "./constants.js";
 import { detectLegacyVbriefLayout, detectXbriefConvergence } from "./detect.js";
@@ -157,25 +158,33 @@ function renameOrReplace(src, dest) {
     rmSync(src, { recursive: true, force: true });
 }
 function runAgentsRefresh(projectRoot, frameworkRoot, io) {
-    const plan = agentsRefreshPlan(projectRoot, { frameworkRoot });
-    const state = String(plan.state ?? "unknown");
-    if (state === "current") {
-        io.writeOut("AGENTS.md managed section is current — no changes.\n");
+    try {
+        assertWriteTargetSafe(projectRoot, join(projectRoot, "AGENTS.md"));
+        const { state, wrote, writable } = applyAgentsRefresh(projectRoot, {}, { frameworkRoot });
+        if (state === "current") {
+            io.writeOut("AGENTS.md managed section is current — no changes.\n");
+            return 0;
+        }
+        if (state === "template-missing" || state === "template-malformed" || state === "unreadable") {
+            io.writeErr(`agents:refresh failed: ${state}\n`);
+            return 2;
+        }
+        if (!writable) {
+            io.writeErr("agents:refresh failed: plan produced no new_content\n");
+            return 2;
+        }
+        if (wrote) {
+            io.writeOut(`AGENTS.md updated (state=${state}).\n`);
+        }
         return 0;
     }
-    if (state === "template-missing" || state === "template-malformed" || state === "unreadable") {
-        io.writeErr(`agents:refresh failed: ${state}\n`);
-        return 2;
-    }
-    const newContent = plan.new_content;
-    if (typeof newContent !== "string") {
-        io.writeErr("agents:refresh failed: plan produced no new_content\n");
-        return 2;
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            io.writeErr(`agents:refresh failed: ${err.message}\n`);
+            return 2;
+        }
+        throw err;
     }
-    const path = String(plan.path ?? join(projectRoot, "AGENTS.md"));
-    writeFileSync(path, newContent, "utf8");
-    io.writeOut(`AGENTS.md updated (state=${state}).\n`);
-    return 0;
 }
 /** Core orchestrator for the consumer xbrief rename (#2110) + convergence (#2270). */
 export function runXbriefMigration(args, _io) {

package/package.json

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