@deftai/directive-core 0.104.0 → 0.106.0

package/dist/verify-ac/evaluate.js

@@ -7,14 +7,25 @@
  * attempts just emitted by this verify:ac — it does not treat non-file
  * dest as no evidence.
  */
-import { randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseRunSummaryJsonl, RunSummaryEmitter, resolveRunSummaryDestination, } from "../run-summary/index.js";
 import { flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
 function formatUnresolved(flag) {
+    const delta = typeof flag.resolved_command_count_delta === "number"
+        ? ` command_count_delta=${flag.resolved_command_count_delta}`
+        : "";
     return (`check_id=${flag.check_id} fail method=${flag.failed_method} ` +
-        `then pass method=${flag.passed_method} without independent re-derivation`);
+        `then pass method=${flag.passed_method} without independent re-derivation${delta}`);
+}
+/**
+ * Walk-level method fingerprint: command list + cwd hash (#3397 / #3322).
+ * Same shape for fail and pass so an honest product fix does not flag.
+ */
+export function methodFingerprintForWalk(commands, cwd) {
+    const cwdHash = createHash("sha256").update(cwd, "utf8").digest("hex");
+    return `${commands.join("\0")}\0${cwdHash}`;
 }
 /** Stable prefix for product-oracle check ids emitted by verify:ac (#3322 / #3337). */
 export const VERIFY_AC_CHECK_ID_PREFIX = "verify:ac";
@@ -36,11 +47,9 @@ export function verifyAcCheckId(scopeKey) {
 }
 /** Same-process verification JSONL when dest is stdout (`-`). */
 const inProcessVerificationLines = [];
-let inProcessStdoutSessionId;
 /** Test seam: isolate stdout-dest buffer across cases. */
 export function resetInProcessVerificationBuffer() {
     inProcessVerificationLines.length = 0;
-    inProcessStdoutSessionId = undefined;
 }
 function inProcessVerificationText() {
     if (inProcessVerificationLines.length === 0) {
@@ -49,7 +58,8 @@ function inProcessVerificationText() {
     return inProcessVerificationLines.join("\n");
 }
 /**
- * Record each executed acceptance command as a verification event (#3322).
+ * Record one walk-level verification event for the executed command set (#3322 / #3397).
+ * Fail and pass use the same method_fingerprint shape (command list + cwd hash).
  * Fail-open: missing dest / write errors never change the AC result.
  * Stdout dest also appends to the same-process buffer so evaluate can
  * inspect this invocation without re-reading a file.
@@ -63,18 +73,7 @@ export function emitVerifyAcAttempts(options) {
         const env = options.env ?? process.env;
         const projectRoot = resolve(options.projectRoot);
         const dest = resolveRunSummaryDestination(projectRoot, { env });
-        const explicitSession = options.sessionId?.trim() ||
-            (typeof env.DEFT_SESSION_ID === "string" ? env.DEFT_SESSION_ID.trim() : "");
-        let sessionId = explicitSession;
-        if (!sessionId) {
-            if (dest.kind === "stdout") {
-                inProcessStdoutSessionId ??= randomUUID();
-                sessionId = inProcessStdoutSessionId;
-            }
-            else {
-                sessionId = randomUUID();
-            }
-        }
+        const sessionId = options.sessionId;
         const explicitCheck = typeof options.checkId === "string" && options.checkId.trim().length > 0
             ? options.checkId.trim()
             : null;
@@ -83,17 +82,26 @@ export function emitVerifyAcAttempts(options) {
             projectRoot,
             sessionId,
             env,
+            component: "verify-ac",
             writeStdout: options.writeStdout,
         });
-        for (const run of options.runs) {
-            const emitted = emitter.emitVerification({
-                check_id: checkId,
-                method_fingerprint: `${run.command}\0${run.cwd}`,
-                outcome: run.ok ? "pass" : "fail",
-            });
-            if (dest.kind === "stdout" && emitted.line !== null) {
-                inProcessVerificationLines.push(JSON.stringify(emitted.line));
-            }
+        // One walk-level event: the method is the command set, not each command.
+        // Per-command emit was blind to a shrinking list that kept the first command (#3397).
+        const commands = options.runs.map((run) => run.command);
+        const firstCwd = options.runs[0]?.cwd ?? "";
+        // Hash the cwd key (joined only when cwds differ) so cwd paths never enter
+        // the fingerprint; commandCountFromFingerprint can still count commands.
+        const cwdKey = options.runs.every((run) => run.cwd === firstCwd)
+            ? firstCwd
+            : options.runs.map((run) => run.cwd).join("\0");
+        const outcome = options.runs.every((run) => run.ok) ? "pass" : "fail";
+        const emitted = emitter.emitVerification({
+            check_id: checkId,
+            method_fingerprint: methodFingerprintForWalk(commands, cwdKey),
+            outcome,
+        });
+        if (dest.kind === "stdout" && emitted.line !== null) {
+            inProcessVerificationLines.push(JSON.stringify(emitted.line));
         }
     }
     catch {

package/dist/verify-ac/flag.d.ts

@@ -20,7 +20,11 @@ export interface FlaggedMethodChangePass {
     readonly failed_method: string;
     readonly passed_method: string;
     readonly independent_rederivation: boolean;
+    /** Pass count minus fail count when both fingerprints carry a command list (#3397). */
+    readonly resolved_command_count_delta?: number;
 }
+/** Command count encoded in a walk fingerprint (`cmd\0cmd\0cwd-or-hash`). */
+export declare function commandCountFromFingerprint(fingerprint: string): number;
 /** Extract well-formed verification attempts in stream order. */
 export declare function readVerificationAttempts(lines: readonly RunSummaryLine[]): VerificationAttempt[];
 /**

package/dist/verify-ac/flag.js

@@ -6,6 +6,19 @@
  * In-place comparison repair then pass is unresolved.
  */
 import { parseRunSummaryJsonl } from "../run-summary/index.js";
+/** Command count encoded in a walk fingerprint (`cmd\0cmd\0cwd-or-hash`). */
+export function commandCountFromFingerprint(fingerprint) {
+    const parts = fingerprint.split("\0");
+    if (parts.length <= 1) {
+        return 1;
+    }
+    const last = parts[parts.length - 1] ?? "";
+    const lastIsCwdOrHash = /^[0-9a-f]{8,64}$/i.test(last) ||
+        last.includes("/") ||
+        last.includes("\\") ||
+        last.includes(":");
+    return lastIsCwdOrHash ? Math.max(1, parts.length - 1) : parts.length;
+}
 function asRecord(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -74,11 +87,14 @@ export function flagPassAfterFailWithMethodChange(attempts) {
         }
         const other = [...prior].find((method) => method !== attempt.method_fingerprint);
         if (other !== undefined) {
+            const delta = commandCountFromFingerprint(attempt.method_fingerprint) -
+                commandCountFromFingerprint(other);
             flagged.push({
                 check_id: attempt.check_id,
                 failed_method: other,
                 passed_method: attempt.method_fingerprint,
                 independent_rederivation: attempt.independent_rederivation,
+                ...(delta !== 0 ? { resolved_command_count_delta: delta } : {}),
             });
         }
         if (attempt.independent_rederivation || other === undefined) {

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

@@ -5,6 +5,6 @@
  * by editing the comparison. Deterministic surface is the flagged event.
  */
 export { type AcceptanceClause, type AcceptanceClauseReading, type ClauseOutcome, type ClauseWalkReport, type ClauseWalkResult, deriveAcceptanceClauses, formatClauseWalkMessage, isScratchArtifactPath, readAcceptanceClauses, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
-export { type EvaluateProductOracleIntegrityOptions, emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, type OracleIntegrityResultFields, type ProductOracleIntegrityVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
-export { type FlaggedMethodChangePass, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, type VerificationAttempt, } from "./flag.js";
+export { type EvaluateProductOracleIntegrityOptions, emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, methodFingerprintForWalk, type OracleIntegrityResultFields, type ProductOracleIntegrityVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
+export { commandCountFromFingerprint, type FlaggedMethodChangePass, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, type VerificationAttempt, } from "./flag.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/verify-ac/index.js

@@ -5,6 +5,6 @@
  * by editing the comparison. Deterministic surface is the flagged event.
  */
 export { deriveAcceptanceClauses, formatClauseWalkMessage, isScratchArtifactPath, readAcceptanceClauses, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
-export { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
-export { flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
+export { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, methodFingerprintForWalk, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
+export { commandCountFromFingerprint, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
 //# sourceMappingURL=index.js.map

package/dist/verify-env/agent-hook-readiness.d.ts

@@ -5,10 +5,10 @@ import { type AgentHookHealthResult } from "./agent-hooks.js";
 import { type AgentHookLiveProbeResult, type AgentHookLiveProbeSeams } from "./agent-hooks-live-probe.js";
 import type { OutputStream } from "./verify-hooks-installed.js";
 export type AgentHookReadinessRegistration = "registered" | "disabled" | "missing" | "drifted" | "not-applicable";
-export type AgentHookReadinessFunctionality = "functional" | "non-functional" | "unavailable" | "not-run" | "disabled" | "not-applicable";
+export type AgentHookReadinessFunctionality = "functional" | "non-functional" | "unavailable" | "timed-out" | "not-run" | "disabled" | "not-applicable";
 export type AgentHookReadinessTrust = "manual-review-required" | "not-applicable" | "disabled";
 export type AgentHookReadinessInterception = "not-directly-verified" | "not-applicable" | "disabled";
-export type AgentHookReadinessLiveStatus = "functional" | "non-functional" | "unavailable" | "not-run" | "disabled" | "skipped";
+export type AgentHookReadinessLiveStatus = "functional" | "non-functional" | "unavailable" | "timed-out" | "not-run" | "disabled" | "skipped";
 export interface AgentHookReadinessHostResult {
     readonly host: HookHost;
     readonly registration: AgentHookReadinessRegistration;

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

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { resolveFrameworkRootForProject } from "../doctor/paths.js";
-import { loadHostHooksPolicyFromProject } from "../policy/host-hooks.js";
+import { loadHostHooksPolicyFromProject, UNUSED_HOST_HOOKS_RECOVERY, } 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. */
@@ -114,31 +114,35 @@ export function evaluateAgentHookReadiness(projectRoot, options = {}) {
                 ? "functional"
                 : liveStatus === "unavailable"
                     ? "unavailable"
-                    : liveStatus === "non-functional"
-                        ? "non-functional"
-                        : "not-run",
+                    : liveStatus === "timed-out"
+                        ? "timed-out"
+                        : liveStatus === "non-functional"
+                            ? "non-functional"
+                            : "not-run",
         };
     });
     const allDisabled = enabledHosts.length === 0;
+    const timeoutOnly = liveProbe.cases.length > 0 && liveProbe.cases.every((entry) => entry.issue === "timed-out");
     const liveStatus = allDisabled
         ? "disabled"
         : liveProbe.code === 0
             ? "functional"
             : liveProbe.code === 2
                 ? "unavailable"
-                : "non-functional";
+                : timeoutOnly
+                    ? "timed-out"
+                    : "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."
         : "";
+    const unusedHostRecovery = liveProbe.code === 0 || timeoutOnly ? "" : `\n  ${UNUSED_HOST_HOOKS_RECOVERY}`;
     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`."),
+            unusedHostRecovery,
         stream: liveProbe.code === 0 ? "stdout" : "stderr",
         skipped: false,
         liveStatus,

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

@@ -1,5 +1,9 @@
 import { type HookEvent, type HookHost } from "../hooks/dispatcher.js";
 export declare const LIVE_PROBE_CASE_TIMEOUT_MS = 1500;
+/** Extra attempts after a timeout. One retry keeps 4×2×1.5s×2 = 24s under Cursor 30s (#3570). */
+export declare const LIVE_PROBE_CASE_RETRY_COUNT = 1;
+export declare const LIVE_PROBE_TIMEOUT_RECOVERY = "Recovery: retry the gated ritual when load is lower. Do not reinstall @deftai/directive or disable hostHooks for a timeout.";
+export declare const LIVE_PROBE_BROKEN_RECOVERY = "Recovery: reinstall @deftai/directive and run `deft update`.";
 export type AgentHookLiveProbeIssue = "hook-command-missing" | "spawn-failed" | "timed-out" | "empty-stdout" | "unparseable-json" | "missing-allow" | "missing-deny";
 export interface AgentHookLiveProbeCase {
     readonly host: HookHost;
@@ -8,7 +12,7 @@ export interface AgentHookLiveProbeCase {
     readonly issue: AgentHookLiveProbeIssue;
     readonly detail: string;
 }
-export type AgentHookLiveProbeHostStatus = "functional" | "non-functional" | "unavailable";
+export type AgentHookLiveProbeHostStatus = "functional" | "non-functional" | "unavailable" | "timed-out";
 export interface AgentHookLiveProbeHostResult {
     readonly host: HookHost;
     readonly status: AgentHookLiveProbeHostStatus;

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

@@ -6,6 +6,10 @@ 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";
 export const LIVE_PROBE_CASE_TIMEOUT_MS = 1_500;
+/** Extra attempts after a timeout. One retry keeps 4×2×1.5s×2 = 24s under Cursor 30s (#3570). */
+export const LIVE_PROBE_CASE_RETRY_COUNT = 1;
+export const LIVE_PROBE_TIMEOUT_RECOVERY = "Recovery: retry the gated ritual when load is lower. Do not reinstall @deftai/directive or disable hostHooks for a timeout.";
+export const LIVE_PROBE_BROKEN_RECOVERY = "Recovery: reinstall @deftai/directive and run `deft update`.";
 const LIVE_PROBE_EVENT = "tool.before";
 function elapsedMs(started) {
     return Math.max(0, Math.round(performance.now() - started));
@@ -122,21 +126,38 @@ function validateFixtureOutput(host, fixture, stdout) {
         ? { ok: true }
         : { ok: false, issue: "missing-deny", detail: `expected ${host} deny envelope` };
 }
+function liveProbeRecovery(cases) {
+    if (cases.length > 0 && cases.every((entry) => entry.issue === "timed-out")) {
+        return LIVE_PROBE_TIMEOUT_RECOVERY;
+    }
+    return LIVE_PROBE_BROKEN_RECOVERY;
+}
+function hostStatusFromFailure(hostFailure) {
+    if (hostFailure === null)
+        return "functional";
+    if (hostFailure.issue === "timed-out")
+        return "timed-out";
+    return "non-functional";
+}
 function runFixtureProbe(command, host, projectRoot, fixture, spawnHook) {
-    const spawned = spawnHook({
+    const input = {
         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(),
-    });
+    };
+    let spawned = spawnHook(input);
+    for (let retry = 0; retry < LIVE_PROBE_CASE_RETRY_COUNT && spawned.timedOut === true; retry += 1) {
+        spawned = spawnHook(input);
+    }
     if (spawned.timedOut === true) {
         return {
             host,
             event: LIVE_PROBE_EVENT,
             fixture,
             issue: "timed-out",
-            detail: `hook command exceeded ${LIVE_PROBE_CASE_TIMEOUT_MS}ms`,
+            detail: `hook command exceeded ${LIVE_PROBE_CASE_TIMEOUT_MS}ms after ${LIVE_PROBE_CASE_RETRY_COUNT + 1} attempts`,
         };
     }
     if (spawned.status !== 0) {
@@ -204,7 +225,7 @@ export function probeAgentHooksLive(projectRoot, seams = {}) {
                 break;
             }
         }
-        hostResults.push({ host, status: hostFailure === null ? "functional" : "non-functional" });
+        hostResults.push({ host, status: hostStatusFromFailure(hostFailure) });
     }
     if (failures.length === 0) {
         return {
@@ -220,7 +241,7 @@ export function probeAgentHooksLive(projectRoot, seams = {}) {
         .join("; ");
     return {
         code: 1,
-        message: `deft agent hooks live probe FAILED: ${summary}. Recovery: reinstall @deftai/directive and run \`deft update\`.`,
+        message: `deft agent hooks live probe FAILED: ${summary}. ${liveProbeRecovery(failures)}`,
         cases: failures,
         hosts: hostResults,
         durationMs: elapsedMs(started),

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

@@ -1,7 +1,7 @@
 import { statSync } from "node:fs";
 import { resolve } from "node:path";
 import { inspectAgentHookDeposit } from "../init-deposit/agent-hooks.js";
-import { loadHostHooksPolicyFromProject } from "../policy/host-hooks.js";
+import { loadHostHooksPolicyFromProject, UNUSED_HOST_HOOKS_RECOVERY, } from "../policy/host-hooks.js";
 function isDirectory(path) {
     try {
         return statSync(path).isDirectory();
@@ -30,9 +30,8 @@ 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." +
-                " If a failed host is intentionally unused, inspect `deft policy:show --field=hostHooks`, " +
-                "set `plan.policy.hostHooks.<host> = false`, and run `deft update` again.",
+                "\n  Recovery: run `deft update` (or `directive init`) to refresh project hooks. " +
+                UNUSED_HOST_HOOKS_RECOVERY,
             stream: "stderr",
             registrations,
         };

package/dist/verify-source/contained-writes.js

@@ -46,6 +46,8 @@ export const CONTAINED_WRITES_ALLOWLIST = [
     // Implementation modules for containment + contained write.
     "packages/core/src/fs/contained-write.ts",
     "packages/core/src/fs/projection-containment.ts",
+    // #3424: read-only O_NOFOLLOW fd pin in intended-placement inspect (not a write sink).
+    "packages/core/src/preflight/intended-placement.ts",
     // Deposit tree copy / contain primitives (low-level install sinks).
     "packages/core/src/deposit/copy-tree.ts",
     "packages/core/src/deposit/contain.ts",

package/dist/verify-source/verify-stubs.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Shared "not product source" core (#3487) plus the directories only the stub
+ * scan treats as non-product: fixtures/tests, vendored trees, the history
+ * archive, and operator scripts.
+ */
 export declare const EXCLUDE_DIRS: Set<string>;
 export declare const EXTENSIONS: Set<string>;
 export interface StubFinding {
@@ -6,7 +11,16 @@ export interface StubFinding {
     readonly label: string;
     readonly text: string;
 }
-/** Recursive sorted rglob mirroring `sorted(Path(".").rglob("*"))`. */
+/**
+ * Recursive sorted rglob mirroring `sorted(Path(".").rglob("*"))`, pruning
+ * `EXCLUDE_DIRS` before recursing.
+ *
+ * Pruning is load-bearing, not an optimisation of a filter applied later: on a
+ * host with a populated `.deft-scratch/` the unpruned walk enumerates every
+ * swarm worktree (millions of entries) only to discard them per-file. #2953
+ * added `.deft-scratch` / `swarm-worktrees` to `EXCLUDE_DIRS` for exactly this
+ * reason but left the walk descending into them (#3481).
+ */
 export declare function sortedRglob(root: string): string[];
 export declare function scanFileForStubs(relPath: string, fullPath: string): StubFinding[];
 export interface VerifyStubsResult {

package/dist/verify-source/verify-stubs.js

@@ -1,20 +1,12 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-export const EXCLUDE_DIRS = new Set([
-    "tests",
-    "vendor",
-    ".git",
-    "backup",
-    "history",
-    "node_modules",
-    ".venv",
-    "__pycache__",
-    "dist",
-    "scripts",
-    // Swarm / agent worktrees are not product source (#2953, #1656).
-    ".deft-scratch",
-    "swarm-worktrees",
-]);
+import { NON_PRODUCT_DIRS } from "../fs/non-product-dirs.js";
+/**
+ * Shared "not product source" core (#3487) plus the directories only the stub
+ * scan treats as non-product: fixtures/tests, vendored trees, the history
+ * archive, and operator scripts.
+ */
+export const EXCLUDE_DIRS = new Set([...NON_PRODUCT_DIRS, "tests", "vendor", "history", "scripts"]);
 export const EXTENSIONS = new Set([".py", ".go", ".sh"]);
 function isWordChar(ch) {
     if (ch.length === 0) {
@@ -73,7 +65,16 @@ function hasReturnNull(text) {
     }
     return false;
 }
-/** Recursive sorted rglob mirroring `sorted(Path(".").rglob("*"))`. */
+/**
+ * Recursive sorted rglob mirroring `sorted(Path(".").rglob("*"))`, pruning
+ * `EXCLUDE_DIRS` before recursing.
+ *
+ * Pruning is load-bearing, not an optimisation of a filter applied later: on a
+ * host with a populated `.deft-scratch/` the unpruned walk enumerates every
+ * swarm worktree (millions of entries) only to discard them per-file. #2953
+ * added `.deft-scratch` / `swarm-worktrees` to `EXCLUDE_DIRS` for exactly this
+ * reason but left the walk descending into them (#3481).
+ */
 export function sortedRglob(root) {
     const out = [];
     function walk(dir, relPrefix) {
@@ -95,6 +96,9 @@ export function sortedRglob(root) {
                 continue;
             }
             if (st.isDirectory()) {
+                if (EXCLUDE_DIRS.has(name)) {
+                    continue;
+                }
                 walk(full, rel);
             }
             else {

package/dist/vitest-runner/win32-coverage-tmp-setup.d.ts

@@ -3,18 +3,17 @@ export declare const COVERAGE_TMP_CHUNK_RE: RegExp;
 export declare function isCoverageTmpChunkPath(filePath: string): boolean;
 export declare function ensureCoverageTmpDir(coverageTmpDir?: string): void;
 /**
- * Vitest 3.2.x writes coverage chunks without mkdir'ing the parent directory
- * (fixed upstream in vitest 4.x — vitest-dev/vitest#10117). On Windows the
- * directory can disappear between clean() and writeFile under release-scale
+ * Vitest 4.x includes the upstream mkdir (vitest-dev/vitest#10117). On Windows the
+ * directory can still disappear between clean() and writeFile under release-scale
  * load; mkdir immediately before chunk writes closes that race without
- * soft-failing real threshold failures (#2634).
+ * soft-failing real threshold failures (#2634 / #3480).
  */
 export declare function installCoverageTmpWriteGuard(): () => void;
 /**
  * Win32 globalSetup for coverage runs (#2580, hardened #2634).
  *
- * Keepalive mkdir plus a writeFile guard mirror vitest 4's defensive mkdir until
- * directive upgrades past vitest@3 (see vitest.config.ts #2634 upgrade note).
+ * Keepalive mkdir plus a writeFile guard remain until a full win32 coverage
+ * run proves vitest 4's #10117 mkdir is enough on its own (#3480).
  */
 export default function setup(): () => void;
 //# sourceMappingURL=win32-coverage-tmp-setup.d.ts.map

package/dist/vitest-runner/win32-coverage-tmp-setup.js

@@ -10,11 +10,10 @@ export function ensureCoverageTmpDir(coverageTmpDir = defaultCoverageTmp) {
     mkdirSync(coverageTmpDir, { recursive: true });
 }
 /**
- * Vitest 3.2.x writes coverage chunks without mkdir'ing the parent directory
- * (fixed upstream in vitest 4.x — vitest-dev/vitest#10117). On Windows the
- * directory can disappear between clean() and writeFile under release-scale
+ * Vitest 4.x includes the upstream mkdir (vitest-dev/vitest#10117). On Windows the
+ * directory can still disappear between clean() and writeFile under release-scale
  * load; mkdir immediately before chunk writes closes that race without
- * soft-failing real threshold failures (#2634).
+ * soft-failing real threshold failures (#2634 / #3480).
  */
 export function installCoverageTmpWriteGuard() {
     const originalWriteFile = fsPromises.writeFile.bind(fsPromises);
@@ -33,8 +32,8 @@ export function installCoverageTmpWriteGuard() {
 /**
  * Win32 globalSetup for coverage runs (#2580, hardened #2634).
  *
- * Keepalive mkdir plus a writeFile guard mirror vitest 4's defensive mkdir until
- * directive upgrades past vitest@3 (see vitest.config.ts #2634 upgrade note).
+ * Keepalive mkdir plus a writeFile guard remain until a full win32 coverage
+ * run proves vitest 4's #10117 mkdir is enough on its own (#3480).
  */
 export default function setup() {
     if (process.platform !== "win32")

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

@@ -1,6 +1,6 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
-import { containedWrite } from "../fs/contained-write.js";
+import { containedRemove, containedWrite } from "../fs/contained-write.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { checkGitClean } from "../migrate-preflight/index.js";
 import { applyAgentsRefresh } from "../platform/agents-md.js";
@@ -36,10 +36,7 @@ export function shouldOmitLegacyMigrationFile(relativePath) {
  */
 export function removeStaleMigratedFrameworkNarrative(projectRoot) {
     const stale = join(projectRoot, MIGRATED_ARTIFACT_DIR, OBSOLETE_FRAMEWORK_NARRATIVE_FILENAME);
-    if (!existsSync(stale))
-        return false;
-    rmSync(stale, { force: true });
-    return true;
+    return containedRemove({ root: projectRoot, target: stale }).removed;
 }
 function mapRelativePath(relativePath) {
     return relativePath

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.104.0",
+  "version": "0.106.0",
   "description": "TypeScript engine core for the Directive framework.",
   "license": "MIT",
   "type": "module",
@@ -283,6 +283,10 @@
       "types": "./dist/lifecycle/index.d.ts",
       "default": "./dist/lifecycle/index.js"
     },
+    "./lifecycle-visible": {
+      "types": "./dist/lifecycle-visible/index.d.ts",
+      "default": "./dist/lifecycle-visible/index.js"
+    },
     "./literal-acceptance": {
       "types": "./dist/literal-acceptance/index.d.ts",
       "default": "./dist/literal-acceptance/index.js"
@@ -382,8 +386,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.104.0",
-    "@deftai/directive-types": "^0.104.0",
+    "@deftai/directive-content": "^0.106.0",
+    "@deftai/directive-types": "^0.106.0",
     "archiver": "^8.0.0"
   },
   "scripts": {