@deftai/directive-core 0.88.0 → 0.90.0

package/dist/session/verify-session-ritual.js

@@ -4,8 +4,8 @@ import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js
 import { pythonJsonDump } from "./json.js";
 import { ENV_SESSION_POSTURE, readOnlyPostureMessage, resolveSessionPosture, ritualStateIsPostureAuthority, } from "./posture.js";
 import { defaultRitualRunner } from "./ritual-entrypoint.js";
-import { readRitualState, ritualStatePath, ritualStep, writeRitualState, } from "./ritual-sentinel.js";
-import { GATED_STEPS, QUICK_STEPS } from "./session-start.js";
+import { readRitualState, ritualStateMarksRearmNeeded, ritualStatePath, ritualStep, writeRitualState, } from "./ritual-sentinel.js";
+import { formatSessionStartRecoveryCommand, GATED_STEPS, QUICK_STEPS, } from "./session-start.js";
 import { resolveSessionRitualStalenessHours } from "./staleness.js";
 export { formatCacheFetchAllRecoveryCommand, recoveryHintForStaleFailure, } from "./cache-recovery.js";
 export const ENV_SKIP = "DEFT_SESSION_RITUAL_SKIP";
@@ -25,9 +25,10 @@ function stepPasses(step) {
     return step.ok === true;
 }
 function failedStepMessage(tierName, stepName, step) {
+    const coldCmd = formatSessionStartRecoveryCommand("cold");
     if (step === null || step === undefined) {
         return (`session ritual ${tierName} step '${stepName}' is missing. ` +
-            `Run \`${formatFrameworkCommand(["session:start"])}\` before implementation dispatch.`);
+            `Run \`${coldCmd}\` before implementation dispatch.`);
     }
     if (typeof step === "object" &&
         step !== null &&
@@ -38,6 +39,19 @@ function failedStepMessage(tierName, stepName, step) {
     const suffix = typeof message === "string" && message.length > 0 ? `: ${message}` : "";
     return `session ritual ${tierName} step '${stepName}' failed${suffix}`;
 }
+/** Human recovery line after a failed ritual probe (#2992 / #2993). */
+export function formatRitualRecoveryInstruction(tier = "cold") {
+    const ready = formatFrameworkCommand(["session:ready"]);
+    const start = formatSessionStartRecoveryCommand(tier);
+    const verify = formatFrameworkCommand(["verify:session-ritual", "--", "--tier=gated"]);
+    if (tier === "rearm") {
+        return (`Recovery: run ${ready} (one-shot), or ${start} ` +
+            `(or full ${formatSessionStartRecoveryCommand("cold")} if worktree/HEAD changed), ` +
+            `then ${verify}.`);
+    }
+    return (`Recovery: run ${ready} ` +
+        `(one-shot: session:start + gated ritual + cache recovery as needed).`);
+}
 function runGatedStep(projectRoot, payload, stepName, runner, now) {
     const command = [...(GATED_ENTRYPOINT_COMMANDS[stepName] ?? [])];
     const { code, stdout, stderr } = runner(command, projectRoot);
@@ -60,29 +74,42 @@ function runGatedStep(projectRoot, payload, stepName, runner, now) {
     return null;
 }
 function headDriftRecoveryMessage() {
+    const coldCmd = formatSessionStartRecoveryCommand("cold");
     return (`session ritual state is stale because git HEAD changed discontinuously. ` +
-        `Run \`${formatFrameworkCommand(["session:start"])}\` again.`);
+        `Run \`${coldCmd}\` again (full cold ceremony required).`);
 }
 function evaluateLoadedState(projectRoot, state, input) {
     const runGit = input.runGit ?? defaultGitRunner;
+    const coldCmd = formatSessionStartRecoveryCommand("cold");
+    const rearmCmd = formatSessionStartRecoveryCommand("rearm");
     const { head: currentHead, error: headError } = gitHead(projectRoot, runGit);
     if (currentHead === null) {
-        return [2, headError ?? "could not resolve git HEAD"];
+        return {
+            code: 2,
+            message: headError ?? "could not resolve git HEAD",
+            recoveryTier: "cold",
+        };
     }
     const currentWorktree = worktreePath(projectRoot, runGit);
     if (state.worktreePath !== currentWorktree) {
-        return [
-            1,
-            `session ritual state belongs to a different worktree (${state.worktreePath}); run \`${formatFrameworkCommand(["session:start"])}\` here.`,
-        ];
+        return {
+            code: 1,
+            message: `session ritual state belongs to a different worktree (${state.worktreePath}); ` +
+                `run \`${coldCmd}\` here (full cold ceremony required).`,
+            recoveryTier: "cold",
+        };
     }
     if (state.gitHead !== currentHead) {
         const forward = gitIsAncestor(projectRoot, state.gitHead, currentHead, runGit);
         if (forward === null) {
-            return [2, "could not verify git history for session ritual"];
+            return {
+                code: 2,
+                message: "could not verify git history for session ritual",
+                recoveryTier: "cold",
+            };
         }
         if (!forward) {
-            return [1, headDriftRecoveryMessage()];
+            return { code: 1, message: headDriftRecoveryMessage(), recoveryTier: "cold" };
         }
         if (input.rebindForwardHead) {
             const payload = { ...state.raw, git_head: currentHead };
@@ -90,37 +117,63 @@ function evaluateLoadedState(projectRoot, state, input) {
                 writeRitualState(projectRoot, payload);
             }
             catch (exc) {
-                return [2, `could not rebind session ritual git HEAD: ${String(exc)}`];
+                return {
+                    code: 2,
+                    message: `could not rebind session ritual git HEAD: ${String(exc)}`,
+                    recoveryTier: "cold",
+                };
             }
         }
     }
     const staleness = resolveSessionRitualStalenessHours(projectRoot);
     if (staleness.source === "default-on-error") {
-        return [2, staleness.error ?? "session ritual staleness policy is invalid"];
+        return {
+            code: 2,
+            message: staleness.error ?? "session ritual staleness policy is invalid",
+            recoveryTier: "cold",
+        };
     }
     const maxAgeMs = staleness.hours * 60 * 60 * 1000;
     if (input.now.getTime() - state.startedAt.getTime() > maxAgeMs) {
-        const startCommand = formatFrameworkCommand(["session:start"]);
-        return [
-            1,
-            `session ritual state is stale (older than ${staleness.hours}h). Run \`${startCommand}\` again.`,
-        ];
+        // Age / compact stale on same worktree + continuous HEAD → prefer re-arm (#2992).
+        // compact_resume_at / rearm_needed amplify the same recovery path.
+        const compactNote = ritualStateMarksRearmNeeded(state)
+            ? " Compact/resume marked re-arm needed."
+            : "";
+        return {
+            code: 1,
+            message: `session ritual state is stale (older than ${staleness.hours}h).${compactNote} ` +
+                `Run \`${rearmCmd}\` to re-arm (or \`${coldCmd}\` for a full cold ceremony).`,
+            recoveryTier: "rearm",
+        };
     }
     for (const stepName of QUICK_STEPS) {
         const step = state.quickSteps[stepName];
         if (!stepPasses(step)) {
-            return [1, failedStepMessage("quick", stepName, step)];
+            return {
+                code: 1,
+                message: failedStepMessage("quick", stepName, step),
+                recoveryTier: "cold",
+            };
         }
     }
     if (input.tier === "gated") {
         for (const stepName of GATED_STEPS) {
             const step = state.gatedSteps[stepName];
             if (!stepPasses(step)) {
-                return [1, failedStepMessage("gated", stepName, step)];
+                return {
+                    code: 1,
+                    message: failedStepMessage("gated", stepName, step),
+                    recoveryTier: "cold",
+                };
             }
         }
     }
-    return [0, `OK session ritual ${input.tier} tier is fresh.`];
+    return {
+        code: 0,
+        message: `OK session ritual ${input.tier} tier is fresh.`,
+        recoveryTier: null,
+    };
 }
 /**
  * Read-only ritual-state inspection for host hooks.
@@ -155,7 +208,7 @@ export function inspectSessionRitual(projectRoot, options = {}) {
     const [state, err] = readRitualState(projectRoot);
     if (state === null) {
         const code = missingStateFile ? 1 : 2;
-        const startCommand = formatFrameworkCommand(["session:start"]);
+        const startCommand = formatSessionStartRecoveryCommand("cold");
         return {
             code,
             message: code === 1
@@ -167,23 +220,25 @@ export function inspectSessionRitual(projectRoot, options = {}) {
             wouldFailCode: null,
             posture,
             ritualStateRequired,
+            recoveryTier: "cold",
         };
     }
-    const [code, message] = evaluateLoadedState(projectRoot, state, {
+    const evaluated = evaluateLoadedState(projectRoot, state, {
         tier,
         now: options.now ?? new Date(),
         runGit: options.runGit,
         rebindForwardHead: false,
     });
     return {
-        code,
-        message,
+        code: evaluated.code,
+        message: evaluated.message,
         tier,
         statePath,
         bypassed: false,
         wouldFailCode: null,
         posture,
         ritualStateRequired,
+        recoveryTier: evaluated.recoveryTier,
     };
 }
 export function verifySessionRitual(projectRoot, options = {}) {
@@ -231,7 +286,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
     let [state, err] = readRitualState(projectRoot);
     if (state === null) {
         const code = missingStateFile ? 1 : 2;
-        const startCommand = formatFrameworkCommand(["session:start"]);
+        const startCommand = formatSessionStartRecoveryCommand("cold");
         const message = code === 1
             ? `${err}. Run \`${startCommand}\` before implementation dispatch.`
             : (err ?? "ritual state invalid");
@@ -245,6 +300,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
                 wouldFailCode: code,
                 posture,
                 ritualStateRequired,
+                recoveryTier: "cold",
             };
         }
         return {
@@ -256,25 +312,27 @@ export function verifySessionRitual(projectRoot, options = {}) {
             wouldFailCode: null,
             posture,
             ritualStateRequired,
+            recoveryTier: "cold",
         };
     }
     if (tier === "gated" && !isBypassed) {
-        const [precheckCode, precheckMessage] = evaluateLoadedState(projectRoot, state, {
+        const precheck = evaluateLoadedState(projectRoot, state, {
             tier: "quick",
             now: instant,
             runGit: options.runGit,
             rebindForwardHead: true,
         });
-        if (precheckCode !== 0) {
+        if (precheck.code !== 0) {
             return {
-                code: precheckCode,
-                message: precheckMessage,
+                code: precheck.code,
+                message: precheck.message,
                 tier,
                 statePath,
                 bypassed: false,
                 wouldFailCode: null,
                 posture,
                 ritualStateRequired,
+                recoveryTier: precheck.recoveryTier,
             };
         }
         const reloadedAfterPrecheck = readRitualState(projectRoot);
@@ -332,7 +390,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
             };
         }
     }
-    const [code, message] = evaluateLoadedState(projectRoot, state, {
+    const evaluated = evaluateLoadedState(projectRoot, state, {
         tier,
         now: instant,
         runGit: options.runGit,
@@ -341,24 +399,26 @@ export function verifySessionRitual(projectRoot, options = {}) {
     if (isBypassed) {
         return {
             code: 0,
-            message,
+            message: evaluated.message,
             tier,
             statePath,
             bypassed: true,
-            wouldFailCode: code === 0 ? null : code,
+            wouldFailCode: evaluated.code === 0 ? null : evaluated.code,
             posture,
             ritualStateRequired,
+            recoveryTier: evaluated.recoveryTier,
         };
     }
     return {
-        code,
-        message,
+        code: evaluated.code,
+        message: evaluated.message,
         tier,
         statePath,
         bypassed: false,
         wouldFailCode: null,
         posture,
         ritualStateRequired,
+        recoveryTier: evaluated.recoveryTier,
     };
 }
 export function emitVerifyJson(result) {

package/dist/staleness-tickler/state.js

@@ -1,5 +1,6 @@
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdirSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveTriageCachePath } from "../triage/cache-path.js";
 export const STATE_RELATIVE_PATH = join("xbrief", ".triage-cache", "staleness-tickler-state.json");
 const STATE_FILE_NAME = "staleness-tickler-state.json";
@@ -15,10 +16,29 @@ function defaultReadText(path) {
     }
 }
 function defaultWriteText(path, content) {
-    mkdirSync(dirname(path), { recursive: true });
-    const temporary = `${path}.${process.pid}.tmp`;
-    writeFileSync(temporary, content, "utf8");
-    renameSync(temporary, path);
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const tmpBase = `${basename(path)}.${process.pid}.tmp`;
+    const temporary = join(dir, tmpBase);
+    try {
+        // #2980 wave D: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(dir),
+            target: tmpBase,
+            data: content,
+            mode: "create",
+        });
+        renameSync(temporary, path);
+    }
+    catch (err) {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
 }
 export function parseStalenessTicklerState(text) {
     if (text === null) {

package/dist/swarm/launch.js

@@ -1,5 +1,6 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { inferGithubAuthMode } from "../intake/github-auth-modes.js";
 import { getPlatformCapabilities } from "../intake/platform-capabilities.js";
 import { hasArtifactSuffix, resolveLifecycleFolder, stripArtifactSuffix, } from "../layout/resolve.js";
@@ -581,7 +582,16 @@ export function swarmLaunch(args) {
     const rendered = `${JSON.stringify(manifest, null, 2)}\n`;
     if (args.output !== undefined && args.output !== null) {
         try {
-            writeFileSync(args.output, rendered, "utf8");
+            // #2980 wave D: product write sink routes through containedWrite.
+            const abs = resolve(args.output);
+            const dir = dirname(abs);
+            mkdirSync(dir, { recursive: true });
+            containedWrite({
+                root: dir,
+                target: basename(abs),
+                data: rendered,
+                mode: "replace",
+            });
         }
         catch (exc) {
             return {

package/dist/swarm/routing.js

@@ -14,8 +14,9 @@
  * explicit default.
  */
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 /**
  * The fixed worker-role vocabulary (reused from #1531). No separate tier
@@ -234,7 +235,12 @@ export function writeModelDecision(projectRoot, path, provider, role, decision)
         decidedAt: decision.decidedAt ?? new Date().toISOString(),
     };
     file[provider] = block;
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    containedWrite({
+        root: resolve(projectRoot),
+        target: path,
+        data: `${JSON.stringify(file, null, 2)}\n`,
+        mode: "replace",
+    });
 }
 //# sourceMappingURL=routing.js.map

package/dist/task-surface/index.js

@@ -1,8 +1,9 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { LEGACY_VBRIEF_VERSION } from "@deftai/directive-types";
-import { assertProjectionContained, assertWriteTargetSafe, ProjectionContainmentError, } from "../fs/projection-containment.js";
+import { ContainedWriteError, containedWrite } from "../fs/contained-write.js";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 const UNRELEASED_RE = /## \[Unreleased\][ \t]*\n([\s\S]*?)(?=\n## \[|$)/;
 const CHANGE_NAME_RE = /^[\w][\w-]*$/;
 const COMMIT_TYPES = "feat|fix|docs|chore|refactor|test|style|perf|ci|build|revert";
@@ -14,7 +15,7 @@ function projectionTarget(projectDir, ...relSegments) {
     return target;
 }
 function containmentExitCode(io, err) {
-    if (err instanceof ProjectionContainmentError) {
+    if (err instanceof ProjectionContainmentError || err instanceof ContainedWriteError) {
         io.writeErr(`FAIL: ${err.message}\n`);
         return 2;
     }
@@ -93,10 +94,19 @@ export function runChangeInit(projectRoot, name, io) {
         mkdirSync(specsDir, { recursive: true });
         const proposalPath = join(base, "proposal.xbrief.json");
         const tasksPath = join(base, "tasks.xbrief.json");
-        assertWriteTargetSafe(projectAbs, proposalPath);
-        assertWriteTargetSafe(projectAbs, tasksPath);
-        writeFileSync(proposalPath, `${JSON.stringify(proposalTemplate(trimmed), null, 2)}\n`, "utf8");
-        writeFileSync(tasksPath, `${JSON.stringify(tasksTemplate(trimmed), null, 2)}\n`, "utf8");
+        // #2980 wave D: product write sinks route through containedWrite.
+        containedWrite({
+            root: projectAbs,
+            target: proposalPath,
+            data: `${JSON.stringify(proposalTemplate(trimmed), null, 2)}\n`,
+            mode: "create",
+        });
+        containedWrite({
+            root: projectAbs,
+            target: tasksPath,
+            data: `${JSON.stringify(tasksTemplate(trimmed), null, 2)}\n`,
+            mode: "create",
+        });
         io.writeOut(`OK: Created change proposal at ${base}/\n`);
         for (const file of ["proposal.xbrief.json", "tasks.xbrief.json", "specs/"]) {
             io.writeOut(`  - ${file}\n`);
@@ -150,8 +160,13 @@ export function runInstallUninstall(projectRoot, io) {
     const next = filtered.join("");
     if (next !== original) {
         try {
-            assertWriteTargetSafe(resolve(projectRoot), path);
-            writeFileSync(path, next, "utf8");
+            // #2980 wave D: product write sink routes through containedWrite.
+            containedWrite({
+                root: resolve(projectRoot),
+                target: path,
+                data: next,
+                mode: "replace",
+            });
             io.writeOut("Removed deft entry from AGENTS.md\n");
         }
         catch (err) {

package/dist/tool-events/classify.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Deterministic, rule-first tool-event classifier (#2967).
+ *
+ * Pure: no I/O, no LLM. Misclassification policy: prefer `unknown` over a
+ * wrong `verify` (false-positive verify is worse than residual unknown).
+ *
+ * Distinct from packages/core/src/hooks/classify/ (#2950 write-intent/payload).
+ */
+import type { ClassifyToolEventResult, ToolEventInput } from "./types.js";
+/**
+ * Classify one tool event into explore | commit | verify | coordinate | unknown.
+ *
+ * Pure and deterministic. When verify cannot be proven honestly, returns unknown.
+ */
+export declare function classifyToolEvent(event: ToolEventInput): ClassifyToolEventResult;
+/** Classify many events; order preserved. */
+export declare function classifyToolEvents(events: readonly ToolEventInput[]): ClassifyToolEventResult[];
+/** Exported for unit tests of the shell path without wrapping Shell tool names. */
+export declare function classifyShellCommandForTest(command: string): ClassifyToolEventResult;
+//# sourceMappingURL=classify.d.ts.map