@deftai/directive 0.88.0 → 0.90.0

package/dist/session-ready.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+/**
+ * CLI: deft session:ready — one-shot mutation recovery (#2993).
+ *
+ * Composes session:start (when needed) + verify:session-ritual --tier=gated
+ * + cache fetch-all recovery so PreToolUse gated inspect goes green in one verb.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runSessionReady } from "@deftai/directive-core/session";
+/** Parse session:ready CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        emitJson: false,
+        withNetwork: false,
+        repo: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "--")
+            continue;
+        if (arg === "--json") {
+            parsed.emitJson = true;
+            continue;
+        }
+        if (arg === "--with-network") {
+            parsed.withNetwork = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            return {
+                ...parsed,
+                error: "usage: session:ready [--project-root <path>] [--repo OWNER/NAME] [--with-network] [--json]\n" +
+                    "  One-shot recovery: session:start (if needed) + gated ritual + cache recovery (#2993).",
+            };
+        }
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+            continue;
+        }
+        if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+        return { ...parsed, error: `unexpected argument: ${arg}` };
+    }
+    return parsed;
+}
+/** Native session:ready handler (#2993). */
+export function run(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`session_ready: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = runSessionReady(projectRoot, {
+        repo: args.repo,
+        sessionStartOptions: {
+            allowOptionalNetwork: args.withNetwork ? true : undefined,
+            writeHistory: false,
+        },
+    });
+    if (args.emitJson) {
+        process.stdout.write(`${JSON.stringify({
+            ready: result.code === 0,
+            exit_code: result.code,
+            path: result.path,
+            message: result.message,
+            steps: result.steps,
+            duration_ms: result.duration_ms,
+        })}\n`);
+        return result.code;
+    }
+    const sink = result.code === 0 ? process.stdout : process.stderr;
+    // Prefer the canonical single success/failure line; keep intermediate lines
+    // only when they add recovery context (start output / cache progress).
+    const intermediates = result.lines.filter((line) => line !== result.message);
+    for (const line of intermediates) {
+        sink.write(`${line}\n`);
+    }
+    sink.write(`${result.message}\n`);
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=session-ready.js.map

package/dist/session-start.d.ts

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
+import { type SessionCeremonyTier } from "@deftai/directive-core/session";
 export interface ParsedSessionStartArgs {
     projectRoot: string;
     deferValues: string[];
     emitJson: boolean;
     noHistory: boolean;
     readOnly: boolean;
+    /** #2991: opt into optional network (release probe + triage cache hydrate). */
+    withNetwork: boolean;
+    /** #2992: cold (full) vs rearm (clock/HEAD refresh without fat path). */
+    ceremonyTier: SessionCeremonyTier;
     error?: string;
 }
 /** Parse session:start CLI args, mirroring scripts/session_start.py. */

package/dist/session-start.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseDeferrals, READ_ONLY_POSTURE, ritualStatePath, runSessionStart, } from "@deftai/directive-core/session";
+import { COLD_CEREMONY_TIER, parseDeferrals, READ_ONLY_POSTURE, REARM_CEREMONY_TIER, ritualStatePath, runSessionStart, SESSION_CEREMONY_TIERS, } from "@deftai/directive-core/session";
+function parseCeremonyTier(raw) {
+    const value = raw.trim().toLowerCase();
+    if (SESSION_CEREMONY_TIERS.includes(value)) {
+        return value;
+    }
+    return null;
+}
 /** Parse session:start CLI args, mirroring scripts/session_start.py. */
 export function parseArgs(argv) {
     const parsed = {
@@ -10,6 +17,8 @@ export function parseArgs(argv) {
         emitJson: false,
         noHistory: false,
         readOnly: false,
+        withNetwork: false,
+        ceremonyTier: COLD_CEREMONY_TIER,
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -22,6 +31,39 @@ export function parseArgs(argv) {
         else if (arg === "--read-only") {
             parsed.readOnly = true;
         }
+        else if (arg === "--with-network") {
+            parsed.withNetwork = true;
+        }
+        else if (arg === "--rearm") {
+            // #2992: shortcut for --tier=rearm
+            parsed.ceremonyTier = REARM_CEREMONY_TIER;
+        }
+        else if (arg === "--tier") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --tier: expected one argument (cold|rearm)" };
+            }
+            const tier = parseCeremonyTier(value);
+            if (tier === null) {
+                return {
+                    ...parsed,
+                    error: `argument --tier: expected cold|rearm, got ${JSON.stringify(value)}`,
+                };
+            }
+            parsed.ceremonyTier = tier;
+            i += 1;
+        }
+        else if (arg?.startsWith("--tier=")) {
+            const value = arg.slice("--tier=".length);
+            const tier = parseCeremonyTier(value);
+            if (tier === null) {
+                return {
+                    ...parsed,
+                    error: `argument --tier: expected cold|rearm, got ${JSON.stringify(value)}`,
+                };
+            }
+            parsed.ceremonyTier = tier;
+        }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
             if (value === undefined) {
@@ -81,6 +123,8 @@ export function run(argv) {
             deferrals,
             writeHistory: !args.noHistory,
             posture: args.readOnly ? READ_ONLY_POSTURE : undefined,
+            allowOptionalNetwork: args.withNetwork ? true : undefined,
+            ceremonyTier: args.ceremonyTier,
         });
     }
     finally {

package/dist/verify-source-cli/verify-contained-writes.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    enforce: boolean;
+    help?: boolean;
+    error?: string;
+}
+/** Parse verify-contained-writes CLI args (#2951). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-contained-writes.d.ts.map

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

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * CLI for task verify:contained-writes (#2951 Phase 1).
+ * Fail-open by default; pass --enforce for fail-closed (later phases).
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateContainedWrites } from "@deftai/directive-core/verify-source";
+/** Parse verify-contained-writes CLI args (#2951). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", enforce: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--enforce") {
+            parsed.enforce = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { ...parsed, help: true };
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+const HELP_TEXT = "Usage: verify-contained-writes [--project-root <path>] [--enforce]\n" +
+    "  Inventory raw write sinks outside the allowlist (#2951).\n" +
+    "  Default: fail-open (exit 0 with advisory report).\n" +
+    "  --enforce: fail closed (exit 1) when non-allowlisted sinks remain.\n";
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.help === true) {
+        process.stdout.write(HELP_TEXT);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_contained_writes: ${args.error}\n`);
+        return 2;
+    }
+    const result = evaluateContainedWrites({
+        projectRoot: resolve(args.projectRoot),
+        enforce: args.enforce,
+    });
+    if (result.stream === "stdout") {
+        process.stdout.write(`${result.message}\n`);
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-contained-writes.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.88.0",
+  "version": "0.90.0",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",
@@ -34,8 +34,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.88.0",
-    "@deftai/directive-content": "^0.88.0"
+    "@deftai/directive-core": "^0.90.0",
+    "@deftai/directive-content": "^0.90.0"
   },
   "scripts": {
     "build": "tsc -b"