@deftai/directive-core 0.83.0 → 0.84.0

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

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { formatFrameworkCommand } from "../render/framework-commands.js";
-import { defaultGitRunner, gitHead, worktreePath } from "./git.js";
+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";
@@ -59,6 +59,10 @@ function runGatedStep(projectRoot, payload, stepName, runner, now) {
     }
     return null;
 }
+function headDriftRecoveryMessage() {
+    return (`session ritual state is stale because git HEAD changed discontinuously. ` +
+        `Run \`${formatFrameworkCommand(["session:start"])}\` again.`);
+}
 function evaluateLoadedState(projectRoot, state, input) {
     const runGit = input.runGit ?? defaultGitRunner;
     const { head: currentHead, error: headError } = gitHead(projectRoot, runGit);
@@ -73,10 +77,22 @@ function evaluateLoadedState(projectRoot, state, input) {
         ];
     }
     if (state.gitHead !== currentHead) {
-        return [
-            1,
-            `session ritual state is stale because git HEAD changed. Run \`${formatFrameworkCommand(["session:start"])}\` again.`,
-        ];
+        const forward = gitIsAncestor(projectRoot, state.gitHead, currentHead, runGit);
+        if (forward === null) {
+            return [2, "could not verify git history for session ritual"];
+        }
+        if (!forward) {
+            return [1, headDriftRecoveryMessage()];
+        }
+        if (input.rebindForwardHead) {
+            const payload = { ...state.raw, git_head: currentHead };
+            try {
+                writeRitualState(projectRoot, payload);
+            }
+            catch (exc) {
+                return [2, `could not rebind session ritual git HEAD: ${String(exc)}`];
+            }
+        }
     }
     const staleness = resolveSessionRitualStalenessHours(projectRoot);
     if (staleness.source === "default-on-error") {
@@ -157,6 +173,7 @@ export function inspectSessionRitual(projectRoot, options = {}) {
         tier,
         now: options.now ?? new Date(),
         runGit: options.runGit,
+        rebindForwardHead: false,
     });
     return {
         code,
@@ -246,6 +263,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
             tier: "quick",
             now: instant,
             runGit: options.runGit,
+            rebindForwardHead: true,
         });
         if (precheckCode !== 0) {
             return {
@@ -259,6 +277,21 @@ export function verifySessionRitual(projectRoot, options = {}) {
                 ritualStateRequired,
             };
         }
+        const reloadedAfterPrecheck = readRitualState(projectRoot);
+        state = reloadedAfterPrecheck[0];
+        err = reloadedAfterPrecheck[1];
+        if (state === null) {
+            return {
+                code: 2,
+                message: err ?? "ritual state invalid after precheck",
+                tier,
+                statePath,
+                bypassed: false,
+                wouldFailCode: null,
+                posture,
+                ritualStateRequired,
+            };
+        }
         const payload = { ...state.raw };
         const gated = { ...payload.gated_steps };
         payload.gated_steps = gated;
@@ -303,6 +336,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
         tier,
         now: instant,
         runGit: options.runGit,
+        rebindForwardHead: true,
     });
     if (isBypassed) {
         return {

package/dist/swarm/routing-set-cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { PROJECTION_CONTAINMENT_REFUSED_EXIT_CODE, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { getPlatformCapabilities } from "../intake/platform-capabilities.js";
 import { EXIT_CONFIG_ERROR, EXIT_OK } from "./constants.js";
 import { dispatchProviderFromRuntime, HARNESS_BOUND_PROVIDERS, ROUTING_MODE_HARNESS_DEFAULT, ROUTING_MODE_PINNED, resolveRoutingPath, SWARM_WORKER_ROLES, writeModelDecision, } from "./routing.js";
@@ -66,11 +67,21 @@ export function routingSetMain(argv = process.argv.slice(2)) {
             "so only --harness-default is recordable here.\n");
         return EXIT_CONFIG_ERROR;
     }
-    const path = resolveRoutingPath(resolve(projectRoot));
-    writeModelDecision(path, resolvedProvider, role, {
-        model,
-        mode: harnessDefault ? ROUTING_MODE_HARNESS_DEFAULT : ROUTING_MODE_PINNED,
-    });
+    const root = resolve(projectRoot);
+    const path = resolveRoutingPath(root);
+    try {
+        writeModelDecision(root, path, resolvedProvider, role, {
+            model,
+            mode: harnessDefault ? ROUTING_MODE_HARNESS_DEFAULT : ROUTING_MODE_PINNED,
+        });
+    }
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            process.stderr.write(`ERROR: ${err.message}\n`);
+            return PROJECTION_CONTAINMENT_REFUSED_EXIT_CODE;
+        }
+        throw err;
+    }
     const modelText = model ?? "<harness default>";
     process.stdout.write(`Recorded route: provider '${resolvedProvider}', role '${role}' -> model ${modelText}.\n` +
         `Route file: ${path}\n`);

package/dist/swarm/routing.d.ts

@@ -62,5 +62,5 @@ export declare function resolveDispatchProvider(environ?: NodeJS.ProcessEnv): st
  * `decidedAt` when the caller did not supply one. Used by the interactive
  * resolver path (resolver step 5) and the `swarm:routing-set` task.
  */
-export declare function writeModelDecision(path: string, provider: string, role: string, decision: RouteDecision): void;
+export declare function writeModelDecision(projectRoot: string, path: string, provider: string, role: string, decision: RouteDecision): void;
 //# sourceMappingURL=routing.d.ts.map

package/dist/swarm/routing.js

@@ -16,6 +16,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 /**
  * The fixed worker-role vocabulary (reused from #1531). No separate tier
  * vocabulary to start; decisions are strictly per-role.
@@ -201,9 +202,10 @@ function assertSafeRoutingKey(kind, key) {
  * `decidedAt` when the caller did not supply one. Used by the interactive
  * resolver path (resolver step 5) and the `swarm:routing-set` task.
  */
-export function writeModelDecision(path, provider, role, decision) {
+export function writeModelDecision(projectRoot, path, provider, role, decision) {
     assertSafeRoutingKey("provider", provider);
     assertSafeRoutingKey("role", role);
+    assertWriteTargetSafe(projectRoot, path);
     const { data } = loadRoutingFile(path);
     // Null-prototype write targets so a computed provider/role key can only ever
     // set an own property and can never reach `Object.prototype`, even if the

package/dist/value/readback.js

@@ -2,6 +2,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { runningInsideDeftRepo } from "../doctor/paths.js";
 import { ALL_ATTRIBUTION_EVENT_NAMES } from "../events/attribution-constants.js";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { DEFAULT_EVENT_LOG, readEvents } from "../lifecycle/events.js";
 import { policyColonInvocation } from "../policy/policy-invocation.js";
 import { isValueFeedbackPathAllowed, resolveValueFeedback, } from "../policy/value-feedback.js";
@@ -229,10 +230,14 @@ function appendReadbackHistory(projectRoot, eventId, line, options = {}) {
         line,
     };
     try {
+        assertWriteTargetSafe(projectRoot, path);
         mkdirSync(join(path, ".."), { recursive: true });
         appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
     }
-    catch {
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            throw err;
+        }
         // observability only
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.83.0",
+  "version": "0.84.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -86,6 +86,10 @@
       "types": "./dist/cache/index.d.ts",
       "default": "./dist/cache/index.js"
     },
+    "./cache/task-cache": {
+      "types": "./dist/cache/task-cache/index.d.ts",
+      "default": "./dist/cache/task-cache/index.js"
+    },
     "./doctor": {
       "types": "./dist/doctor/index.d.ts",
       "default": "./dist/doctor/index.js"
@@ -313,8 +317,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.83.0",
-    "@deftai/directive-types": "^0.83.0",
+    "@deftai/directive-content": "^0.84.0",
+    "@deftai/directive-types": "^0.84.0",
     "archiver": "^8.0.0"
   },
   "scripts": {