@deftai/directive 0.89.0 → 0.90.0

package/dist/dispatch.d.ts

@@ -10,7 +10,7 @@ export interface DispatchIo {
     writeErr: (text: string) => void;
 }
 /** CLI modules in packages/cli/src (excluding parity harnesses and bin/index). */
-export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "lifecycle-event", "session-start", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-content-manifest", "verify-skill-external-fetch-gate", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-subagent-alive", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-agents-md-budget", "verify-agents-md-advisory", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "eval-health", "eval-run", "eval-report", "eval-triggers"];
+export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "lifecycle-event", "lifecycle-stats", "session-start", "session-ready", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-content-manifest", "verify-skill-external-fetch-gate", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-subagent-alive", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-agents-md-budget", "verify-agents-md-advisory", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "eval-health", "eval-run", "eval-report", "eval-triggers"];
 /** Core-only CLI entrypoints without a packages/cli wrapper. */
 export declare const CORE_MODULE_VERBS: readonly ["scm", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "issue-sync-from-xbrief", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-finalize-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "export-spec", "project-render", "roadmap-render", "rule-map", "spec-render", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "setup-ghx", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor", "feedback-file", "value-readback", "product-signal"];
 /** Colon aliases for triage-actions (mirrors cli-router SUBCOMMAND_ROUTES). */

package/dist/dispatch.js

@@ -69,7 +69,9 @@ export const CLI_MODULE_VERBS = [
     "release-rollback",
     "scope-lifecycle",
     "lifecycle-event",
+    "lifecycle-stats",
     "session-start",
+    "session-ready",
     "plan-sequence",
     "slice",
     "subagent-monitor",
@@ -311,7 +313,9 @@ export const VERB_ALIASES = {
     "issue:sync-from-xbrief": "issue-sync-from-xbrief",
     upgrade: "install-upgrade",
     "session:start": "session-start",
+    "session:ready": "session-ready",
     "lifecycle:event": "lifecycle-event",
+    "lifecycle:stats": "lifecycle-stats",
     "toolchain:check": "toolchain-check",
     "ts:check-lane": "ts-check-lane",
     "spec:validate": "spec-validate",
@@ -2516,10 +2520,18 @@ const CURATED_HELP_GROUPS = [
         title: "Session & ritual",
         commands: [
             { name: "session:start", summary: "Record session-start ritual state" },
+            {
+                name: "session:ready",
+                summary: "One-shot recovery to gated write-ready (session + ritual + cache)",
+            },
             {
                 name: "lifecycle:event",
                 summary: "Record review-cycle plan:approved approval events",
             },
+            {
+                name: "lifecycle:stats",
+                summary: "Local xBRIEF lifecycle folder counts for process rollups",
+            },
         ],
     },
     {

package/dist/lifecycle-stats.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export interface ParsedLifecycleStatsArgs {
+    projectRoot: string;
+    since: string;
+    json: boolean;
+    error?: string;
+}
+/** Parse lifecycle:stats CLI args. */
+export declare function parseArgs(argv: readonly string[]): ParsedLifecycleStatsArgs;
+/** Native lifecycle:stats handler (#2995). */
+export declare function run(argv?: readonly string[]): number;
+//# sourceMappingURL=lifecycle-stats.d.ts.map

package/dist/lifecycle-stats.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * CLI: deft lifecycle:stats — local xBRIEF folder counts for process rollups (#2995).
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectLifecycleStats, formatLifecycleStatsText, parseDurationMs, } from "@deftai/directive-core/lifecycle";
+/** Parse lifecycle:stats CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        since: "7d",
+        json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "--json") {
+            parsed.json = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            return {
+                ...parsed,
+                error: "usage: lifecycle:stats [--since=7d] [--json] [--project-root <path>]\n" +
+                    "  Counts xbrief lifecycle folders (filesystem only). See commands.md § lifecycle:stats.",
+            };
+        }
+        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 === "--since") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --since: expected one argument" };
+            }
+            parsed.since = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--since=")) {
+            parsed.since = arg.slice("--since=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { ...parsed, error: `unknown flag: ${arg}` };
+        }
+        return { ...parsed, error: `unexpected argument: ${arg}` };
+    }
+    return parsed;
+}
+/** Native lifecycle:stats handler (#2995). */
+export function run(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`lifecycle_stats: ${args.error}\n`);
+        return 2;
+    }
+    try {
+        parseDurationMs(args.since);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`lifecycle_stats: ${msg}\n`);
+        return 2;
+    }
+    try {
+        const stats = collectLifecycleStats({
+            projectRoot: resolve(args.projectRoot),
+            since: args.since,
+        });
+        if (args.json) {
+            process.stdout.write(`${JSON.stringify(stats, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatLifecycleStatsText(stats));
+        }
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`lifecycle_stats: ${msg}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=lifecycle-stats.js.map

package/dist/session-ready.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+export interface ParsedSessionReadyArgs {
+    projectRoot: string;
+    emitJson: boolean;
+    withNetwork: boolean;
+    repo: string | null;
+    error?: string;
+}
+/** Parse session:ready CLI args. */
+export declare function parseArgs(argv: readonly string[]): ParsedSessionReadyArgs;
+/** Native session:ready handler (#2993). */
+export declare function run(argv?: readonly string[]): number;
+//# sourceMappingURL=session-ready.d.ts.map

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.89.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.89.0",
-    "@deftai/directive-content": "^0.89.0"
+    "@deftai/directive-core": "^0.90.0",
+    "@deftai/directive-content": "^0.90.0"
   },
   "scripts": {
     "build": "tsc -b"