@deftai/directive 0.59.0 → 0.60.0

package/dist/change-init.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=change-init.d.ts.map

package/dist/change-init.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runChangeInit } from "@deftai/directive-core/task-surface";
+function parseArgs(argv) {
+    let projectRoot = ".";
+    let name = "";
+    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 { projectRoot, name, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--name") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { projectRoot, name, error: "argument --name: expected one argument" };
+            }
+            name = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--name=")) {
+            name = arg.slice("--name=".length);
+        }
+        else if (!arg.startsWith("-") && name.length === 0) {
+            name = arg;
+        }
+        else {
+            return { projectRoot, name, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot, name };
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`change-init: ${args.error}\n`);
+        return 2;
+    }
+    return runChangeInit(resolve(args.projectRoot), args.name, {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=change-init.js.map

package/dist/changelog-check.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=changelog-check.d.ts.map

package/dist/changelog-check.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runChangelogCheck } from "@deftai/directive-core/task-surface";
+function parseProjectRoot(argv) {
+    let projectRoot = ".";
+    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 { projectRoot, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { projectRoot, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot };
+}
+export function run(argv) {
+    const args = parseProjectRoot(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`changelog-check: ${args.error}\n`);
+        return 2;
+    }
+    return runChangelogCheck(resolve(args.projectRoot), {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=changelog-check.js.map

package/dist/cli-router/index.js

@@ -1,7 +1,7 @@
 /**
  * CLI router entry: `directive <namespace> <verb>` → flat dispatcher (#1670 / #11 S3).
  */
-import { dispatch } from "../dispatch.js";
+import { dispatch, runDirectiveBootstrap } from "../dispatch.js";
 import { runInit } from "../init-cli/init.js";
 import { runMigrate } from "../init-cli/migrate.js";
 import { runUpdate } from "../init-cli/update.js";
@@ -36,6 +36,9 @@ export async function routeAndDispatch(argv, io) {
     if (first === "migrate") {
         return runMigrate(rest, io ?? defaultIo());
     }
+    if (first === "bootstrap") {
+        return runDirectiveBootstrap(rest, io ?? defaultIo());
+    }
     return dispatch(routed.argv, io);
 }
 //# sourceMappingURL=index.js.map

package/dist/cli-router/route-argv.js

@@ -17,7 +17,7 @@ export const TOP_LEVEL_UX_VERBS = [
 /** Stubbed until a later story lands the handler (#1670 / #11). */
 export const STUBBED_TOP_LEVEL_VERBS = new Set([]);
 /** Registered but not yet implemented as TS handlers. */
-export const DEFERRED_TOP_LEVEL_VERBS = new Set(["bootstrap", "feature"]);
+export const DEFERRED_TOP_LEVEL_VERBS = new Set(["feature"]);
 /** scope:* lifecycle verbs routed through scope-lifecycle handler. */
 export const SCOPE_LIFECYCLE_VERBS = new Set([
     "promote",
@@ -91,7 +91,7 @@ function routeTopLevel(first, rest) {
     if (first === "check" || first === "doctor") {
         return { kind: "dispatch", argv: [first, ...rest] };
     }
-    if (first === "init" || first === "update" || first === "migrate") {
+    if (first === "init" || first === "update" || first === "migrate" || first === "bootstrap") {
         return { kind: "dispatch", argv: [first, ...rest] };
     }
     if (STUBBED_TOP_LEVEL_VERBS.has(first)) {

package/dist/commit-lint.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=commit-lint.d.ts.map

package/dist/commit-lint.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runCommitLint } from "@deftai/directive-core/task-surface";
+function parseProjectRoot(argv) {
+    let projectRoot = ".";
+    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 { projectRoot, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { projectRoot, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot };
+}
+export function run(argv) {
+    const args = parseProjectRoot(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`commit-lint: ${args.error}\n`);
+        return 2;
+    }
+    return runCommitLint(resolve(args.projectRoot), {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=commit-lint.js.map

package/dist/dispatch.d.ts

@@ -2,17 +2,76 @@
  * Unified `directive <verb> [args]` dispatcher (#1828 s0).
  * Routes to ported command modules in packages/cli and packages/core.
  */
+import { spawnSync } from "node:child_process";
+import { type WhichFn } from "@deftai/directive-core/scm";
 export type CommandHandler = (argv: string[]) => number | Promise<number>;
 export interface DispatchIo {
     writeOut: (text: string) => void;
     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", "parity", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "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-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-bridge-drift", "verify-capacity", "verify-content-manifest", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-stubs", "rule-ownership-lint", "verify-story-ready", "verify-tools", "verify-wip-cap"];
+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", "changelog-check", "change-init", "commit-lint", "parity", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "session-start", "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-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-bridge-drift", "verify-capacity", "verify-content-manifest", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-stubs", "rule-ownership-lint", "verify-story-ready", "verify-tools", "verify-wip-cap"];
 /** 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", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "project-render", "roadmap-render", "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", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor"];
+export declare const CORE_MODULE_VERBS: readonly ["scm", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "project-render", "roadmap-render", "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"];
 /** Task-style aliases (framework_commands / Taskfile names). */
 export declare const VERB_ALIASES: Readonly<Record<string, string>>;
+/** Pinned ghx version — keep in lockstep with .github/workflows/ci.yml env.GHX_VERSION. */
+export declare const GHX_VERSION = "v1.5.1";
+export declare const INSTALL_PS1_URL = "https://raw.githubusercontent.com/brunoborges/ghx/v1.5.1/install.ps1";
+export declare const INSTALL_SH_URL = "https://raw.githubusercontent.com/brunoborges/ghx/v1.5.1/install.sh";
+export type SetupGhxHost = "windows" | "darwin" | "linux" | string;
+export interface SetupGhxDeps {
+    whichFn?: WhichFn;
+    readConsentLine?: () => string;
+    runInstall?: (host: SetupGhxHost) => number;
+}
+export declare function ghxPresent(whichFn?: WhichFn): boolean;
+export declare function detectSetupGhxHost(): SetupGhxHost;
+export declare function promptSetupGhxConsent(io: DispatchIo, readLine?: () => string): boolean;
+export declare function buildSetupGhxInstallCommand(host: SetupGhxHost, whichFn?: WhichFn): string[];
+export declare function installSetupGhx(host: SetupGhxHost, whichFn?: WhichFn, runner?: typeof spawnSync): number;
+/** Native `setup:ghx` handler (replaces scripts/setup_ghx.py shell-out, #2022 Phase 1). */
+export declare function runSetupGhx(argv: string[], io: DispatchIo, deps?: SetupGhxDeps): number;
+export declare const SETUP_SKILL_REL_PATH = ".deft/core/skills/deft-directive-setup/SKILL.md";
+export type BootstrapPhaseLabel = "user" | "project" | "spec";
+export type BootstrapReEntry = "none" | "prompt" | "reconfigure" | "force";
+export interface DirectiveBootstrapArgs {
+    projectRoot: string;
+    jumpProject: boolean;
+    strategy: string | null;
+    reconfigure: boolean;
+    force: boolean;
+    json: boolean;
+    error?: string;
+}
+export interface DirectiveBootstrapPlan {
+    phase: 1 | 2 | 3;
+    phaseLabel: BootstrapPhaseLabel;
+    reEntry: BootstrapReEntry;
+    strategy: string | null;
+}
+export interface DirectiveBootstrapHandoff {
+    handoff: "deft-directive-setup";
+    skill_path: string;
+    project_root: string;
+    deposited: boolean;
+    phase: 1 | 2 | 3;
+    phase_label: BootstrapPhaseLabel;
+    re_entry: BootstrapReEntry;
+    strategy: string | null;
+}
+export interface DirectiveBootstrapDeps {
+    deftCorePresent?: (projectRoot: string) => boolean;
+    userMdPresent?: (projectRoot: string) => boolean;
+    projectDefPresent?: (projectRoot: string) => boolean;
+    runInitDeposit?: (projectRoot: string, io: DispatchIo) => Promise<number>;
+}
+/** Parse `directive bootstrap` argv (#2022 Phase 4). */
+export declare function parseDirectiveBootstrapArgs(argv: readonly string[]): DirectiveBootstrapArgs;
+/** Resolve phase intent and deliberate re-entry signal from parsed args + on-disk state. */
+export declare function resolveDirectiveBootstrapPlan(args: DirectiveBootstrapArgs, deps: Required<DirectiveBootstrapDeps>): DirectiveBootstrapPlan;
+/** Native `directive bootstrap` handler (#2022 Phase 4). */
+export declare function runDirectiveBootstrap(argv: string[], io: DispatchIo, deps?: DirectiveBootstrapDeps): Promise<number>;
 /** Native `policy-set` dispatcher (replaces the policy_set.py shell-out, #2022 Phase 1). */
 export declare function runPolicySet(argv: string[], io: DispatchIo): number;
 /** Resolve a user-facing verb to its canonical handler key. */

package/dist/dispatch.js

@@ -2,11 +2,14 @@
  * Unified `directive <verb> [args]` dispatcher (#1828 s0).
  * Routes to ported command modules in packages/cli and packages/core.
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { engineInfo } from "@deftai/directive-core";
+import { parseInitArgv, runInitDepositCli, userConfigDir, } from "@deftai/directive-core/init-deposit";
 import { appendAuditLog, disclosureLine, projectDefinitionPath, resolvePolicy, resolveWipCap, setPolicy, } from "@deftai/directive-core/policy";
+import { defaultWhich } from "@deftai/directive-core/scm";
 import { KNOWN_SUBAGENT_BACKEND_IDS, probeSubagentBackends, resolveSwarmSubagentBackend, } from "@deftai/directive-core/swarm";
 const HANDLER_KEYS = [
     "run",
@@ -31,6 +34,12 @@ export const CLI_MODULE_VERBS = [
     "codebase-projection-registry",
     "codebase-provider",
     "doctor",
+    "install-upgrade",
+    "install-uninstall",
+    "migrate-preflight",
+    "changelog-check",
+    "change-init",
+    "commit-lint",
     "parity",
     "policy",
     "pr-closing-keywords",
@@ -46,6 +55,7 @@ export const CLI_MODULE_VERBS = [
     "release-publish",
     "release-rollback",
     "scope-lifecycle",
+    "session-start",
     "slice",
     "subagent-monitor",
     "toolchain-check",
@@ -120,6 +130,7 @@ export const CORE_MODULE_VERBS = [
     "pack-migrate-patterns",
     "pack-migrate-swarm-spec",
     "policy-set",
+    "setup-ghx",
     "scope-undo",
     "scope-demote",
     "scope-decompose",
@@ -163,7 +174,9 @@ export const VERB_ALIASES = {
     "triage:accept": "triage-actions",
     "triage:status": "triage-actions",
     "agents:refresh": "agents-refresh",
-    "session:start": "framework-commands",
+    "migrate:preflight": "migrate-preflight",
+    upgrade: "install-upgrade",
+    "session:start": "session-start",
     "toolchain:check": "toolchain-check",
     "ts:check-lane": "ts-check-lane",
     "spec:validate": "spec-validate",
@@ -172,6 +185,7 @@ export const VERB_ALIASES = {
     "project:render": "project-render",
     doctor: "doctor",
     build: "framework-commands",
+    "setup:ghx": "setup-ghx",
 };
 /** CLI modules living under verify-source-cli/ or content-validate-cli/ subdirs. */
 const SUBDIR_CLI_STEMS = {
@@ -1072,6 +1086,384 @@ function runPackMigrateSwarmSpec(argv, io) {
     return 0;
 }
 // ===========================================================================
+// Native setup:ghx handler (#2022 Phase 1).
+//
+// Port of scripts/setup_ghx.py to native TypeScript: consent-gated ghx proxy
+// installer with three-state exit (0 ok / 1 install failure / 2 config error).
+// ===========================================================================
+/** Pinned ghx version — keep in lockstep with .github/workflows/ci.yml env.GHX_VERSION. */
+export const GHX_VERSION = "v1.5.1";
+export const INSTALL_PS1_URL = `https://raw.githubusercontent.com/brunoborges/ghx/${GHX_VERSION}/install.ps1`;
+export const INSTALL_SH_URL = `https://raw.githubusercontent.com/brunoborges/ghx/${GHX_VERSION}/install.sh`;
+function parseSetupGhxArgs(argv) {
+    let yes = false;
+    let check = false;
+    for (const arg of argv) {
+        if (arg === "--yes") {
+            yes = true;
+        }
+        else if (arg === "--check") {
+            check = true;
+        }
+        else {
+            return { yes, check, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { yes, check };
+}
+export function ghxPresent(whichFn = defaultWhich) {
+    return whichFn("ghx") !== null;
+}
+export function detectSetupGhxHost() {
+    if (process.platform === "win32")
+        return "windows";
+    if (process.platform === "darwin")
+        return "darwin";
+    if (process.platform === "linux")
+        return "linux";
+    return process.platform;
+}
+function readConsentLineFromStdin() {
+    const buf = Buffer.alloc(256);
+    try {
+        const n = readSync(0, buf, 0, 256, null);
+        if (n === null || n <= 0)
+            return "";
+        return buf.toString("utf8", 0, n);
+    }
+    catch {
+        return "";
+    }
+}
+export function promptSetupGhxConsent(io, readLine = readConsentLineFromStdin) {
+    io.writeOut("\n[setup_ghx] ghx is the recommended GitHub CLI cache proxy for deft " +
+        "maintainers (prevents rate-limiting in multi-agent swarms; speeds up " +
+        "scm:* calls). Consumer projects only require gh.\n");
+    io.writeOut(`[setup_ghx] Upstream: https://github.com/brunoborges/ghx (${GHX_VERSION})\n`);
+    io.writeOut("[setup_ghx] Install ghx via the upstream installer? [y/N]: ");
+    const answer = readLine().trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+}
+export function buildSetupGhxInstallCommand(host, whichFn = defaultWhich) {
+    if (host === "windows") {
+        const psBin = whichFn("pwsh") ?? whichFn("powershell") ?? "powershell";
+        return [
+            psBin,
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            `irm ${INSTALL_PS1_URL} | iex`,
+        ];
+    }
+    if (host === "darwin" || host === "linux") {
+        return ["bash", "-c", `curl -fsSL ${INSTALL_SH_URL} | bash`];
+    }
+    throw new Error(`no upstream ghx installer available for host '${host}'; ` +
+        "see https://github.com/brunoborges/ghx#install for manual options");
+}
+export function installSetupGhx(host, whichFn = defaultWhich, runner = spawnSync) {
+    const cmd = buildSetupGhxInstallCommand(host, whichFn);
+    const proc = runner(cmd[0] ?? "", cmd.slice(1), {
+        env: { ...process.env, GHX_VERSION },
+        stdio: "inherit",
+    });
+    return proc.status ?? 1;
+}
+/** Native `setup:ghx` handler (replaces scripts/setup_ghx.py shell-out, #2022 Phase 1). */
+export function runSetupGhx(argv, io, deps = {}) {
+    const args = parseSetupGhxArgs(argv);
+    if (args.error !== undefined) {
+        io.writeErr(`setup-ghx: ${args.error}\n`);
+        return 2;
+    }
+    if (args.yes && args.check) {
+        io.writeErr("[setup_ghx] error: --yes and --check are mutually exclusive.\n");
+        return 2;
+    }
+    const whichFn = deps.whichFn ?? defaultWhich;
+    if (ghxPresent(whichFn)) {
+        io.writeOut("[setup_ghx] ghx already on PATH -- skipping install.\n");
+        return 0;
+    }
+    if (args.check) {
+        if (whichFn("gh") !== null) {
+            io.writeOut("[setup_ghx] gh is on PATH but ghx is not; ghx is the recommended GitHub CLI " +
+                "cache proxy. Install with `directive setup:ghx` (or `task setup:ghx`). Refs #884.\n");
+        }
+        else {
+            io.writeOut("[setup_ghx] ghx not on PATH; recommended for speed -- run `directive setup:ghx` " +
+                "to opt in. Consumer projects only require gh. Refs #884.\n");
+        }
+        return 0;
+    }
+    let consent;
+    if (args.yes) {
+        consent = true;
+        io.writeOut("[setup_ghx] --yes provided; skipping interactive consent prompt.\n");
+    }
+    else {
+        const skip = (process.env.DEFT_SETUP_GHX_SKIP ?? "").trim();
+        if (skip === "1" || skip.toLowerCase() === "true" || skip.toLowerCase() === "yes") {
+            io.writeOut("[setup_ghx] DEFT_SETUP_GHX_SKIP set; skipping ghx install. Refs #884.\n");
+            return 0;
+        }
+        const readLine = deps.readConsentLine ?? readConsentLineFromStdin;
+        consent = promptSetupGhxConsent(io, readLine);
+    }
+    if (!consent) {
+        io.writeOut("[setup_ghx] Skipping ghx install. ghx is recommended for speed for maintainers and " +
+            "swarm runs; consumer projects only require gh " +
+            "(see https://github.com/brunoborges/ghx, #884).\n");
+        return 0;
+    }
+    const host = detectSetupGhxHost();
+    const runInstall = deps.runInstall ?? ((h) => installSetupGhx(h, whichFn));
+    try {
+        const rc = runInstall(host);
+        if (rc !== 0) {
+            io.writeErr(`[setup_ghx] error: upstream installer exited ${rc}. ` +
+                "See https://github.com/brunoborges/ghx#install for manual options.\n");
+            return 1;
+        }
+        io.writeOut("[setup_ghx] ghx installed. Open a fresh shell so the updated PATH takes effect, " +
+            "then re-run `task setup` to verify.\n");
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        io.writeErr(`[setup_ghx] error: ${message}\n`);
+        return 1;
+    }
+}
+// ===========================================================================
+// Native directive bootstrap launcher (#2022 Phase 4).
+//
+// Thin operator entry: deposit-if-absent, carry phase intent + deliberate
+// re-entry signal, then hand off to deft-directive-setup (agent-driven).
+// ===========================================================================
+export const SETUP_SKILL_REL_PATH = ".deft/core/skills/deft-directive-setup/SKILL.md";
+function bootstrapPhaseLabel(phase) {
+    if (phase === 1)
+        return "user";
+    if (phase === 2)
+        return "project";
+    return "spec";
+}
+function resolveBootstrapUserMdPath() {
+    const override = process.env.DEFT_USER_PATH?.trim();
+    if (override)
+        return resolve(override);
+    return join(userConfigDir(), "USER.md");
+}
+function defaultBootstrapDeps() {
+    return {
+        deftCorePresent: (projectRoot) => isDirSafe(join(resolve(projectRoot), ".deft", "core")),
+        userMdPresent: () => isFileSafe(resolveBootstrapUserMdPath()),
+        projectDefPresent: (projectRoot) => isFileSafe(projectDefinitionPath(projectRoot)),
+        runInitDeposit: async (projectRoot, io) => {
+            const initArgs = parseInitArgv(["--yes", "--repo-root", projectRoot, "--json"], []);
+            return runInitDepositCli({
+                ...initArgs,
+                writeOut: io.writeOut,
+                writeErr: io.writeErr,
+            });
+        },
+    };
+}
+/** Parse `directive bootstrap` argv (#2022 Phase 4). */
+export function parseDirectiveBootstrapArgs(argv) {
+    let projectRoot = ".";
+    let jumpProject = false;
+    let strategy = null;
+    let reconfigure = false;
+    let force = false;
+    let json = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project") {
+            jumpProject = true;
+        }
+        else if (arg === "--reconfigure") {
+            reconfigure = true;
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    projectRoot,
+                    jumpProject,
+                    strategy,
+                    reconfigure,
+                    force,
+                    json,
+                    error: "argument --project-root: expected one argument",
+                };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--strategy") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    projectRoot,
+                    jumpProject,
+                    strategy,
+                    reconfigure,
+                    force,
+                    json,
+                    error: "argument --strategy: expected one argument",
+                };
+            }
+            strategy = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--strategy=")) {
+            strategy = arg.slice("--strategy=".length);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return {
+                projectRoot,
+                jumpProject,
+                strategy,
+                reconfigure,
+                force,
+                json,
+                error: "__help__",
+            };
+        }
+        else {
+            return {
+                projectRoot,
+                jumpProject,
+                strategy,
+                reconfigure,
+                force,
+                json,
+                error: `unrecognized argument: ${arg}`,
+            };
+        }
+    }
+    return {
+        projectRoot: resolve(projectRoot),
+        jumpProject,
+        strategy,
+        reconfigure,
+        force,
+        json,
+    };
+}
+/** Resolve phase intent and deliberate re-entry signal from parsed args + on-disk state. */
+export function resolveDirectiveBootstrapPlan(args, deps) {
+    let phase;
+    if (args.jumpProject) {
+        phase = 2;
+    }
+    else if (args.strategy !== null) {
+        phase = 3;
+    }
+    else if (!deps.userMdPresent(args.projectRoot)) {
+        phase = 1;
+    }
+    else if (!deps.projectDefPresent(args.projectRoot)) {
+        phase = 2;
+    }
+    else {
+        phase = 3;
+    }
+    let reEntry = "none";
+    if (args.force) {
+        reEntry = "force";
+    }
+    else if (args.reconfigure) {
+        reEntry = "reconfigure";
+    }
+    else {
+        const artifactExists = phase === 1
+            ? deps.userMdPresent(args.projectRoot)
+            : phase === 2
+                ? deps.projectDefPresent(args.projectRoot)
+                : deps.projectDefPresent(args.projectRoot);
+        if (artifactExists) {
+            reEntry = "prompt";
+        }
+    }
+    return {
+        phase,
+        phaseLabel: bootstrapPhaseLabel(phase),
+        reEntry,
+        strategy: args.strategy,
+    };
+}
+function printDirectiveBootstrapHelp(io) {
+    io.writeOut("Usage: directive bootstrap [--project-root <path>] [--project] [--strategy <name>] [--reconfigure] [--force] [--json]\n\n" +
+        "Deposit the framework when absent, then hand off to deft-directive-setup.\n\n" +
+        "  --project       Jump to Phase 2 (project configuration)\n" +
+        "  --strategy      Jump to Phase 3 (scope vBRIEF / spec interview)\n" +
+        "  --reconfigure   Deliberate re-entry — agent should reconfigure existing artifacts\n" +
+        "  --force         Skip reconfigure-or-keep prompt; overwrite allowed\n" +
+        "  --json          Emit structured handoff JSON on stdout\n");
+}
+function emitBootstrapHandoff(handoff, io, json) {
+    if (json) {
+        io.writeOut(`${JSON.stringify(handoff, null, 2)}\n`);
+        return;
+    }
+    io.writeOut("[directive bootstrap] Setup launcher — hand off to deft-directive-setup\n\n");
+    io.writeOut(`project_root: ${handoff.project_root}\n`);
+    io.writeOut(`deposited: ${handoff.deposited}\n`);
+    io.writeOut(`phase: ${handoff.phase} (${handoff.phase_label})\n`);
+    io.writeOut(`re_entry: ${handoff.re_entry}\n`);
+    if (handoff.strategy !== null) {
+        io.writeOut(`strategy: ${handoff.strategy}\n`);
+    }
+    io.writeOut(`\nNext: Read and follow ${handoff.skill_path}\n`);
+}
+/** Native `directive bootstrap` handler (#2022 Phase 4). */
+export async function runDirectiveBootstrap(argv, io, deps = {}) {
+    const merged = { ...defaultBootstrapDeps(), ...deps };
+    const args = parseDirectiveBootstrapArgs(argv);
+    if (args.error === "__help__") {
+        printDirectiveBootstrapHelp(io);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        io.writeErr(`directive bootstrap: ${args.error}\n`);
+        return 2;
+    }
+    const plan = resolveDirectiveBootstrapPlan(args, merged);
+    let deposited = false;
+    if (!merged.deftCorePresent(args.projectRoot)) {
+        const initCode = await merged.runInitDeposit(args.projectRoot, io);
+        if (initCode !== 0) {
+            return initCode;
+        }
+        deposited = true;
+    }
+    const handoff = {
+        handoff: "deft-directive-setup",
+        skill_path: SETUP_SKILL_REL_PATH,
+        project_root: args.projectRoot,
+        deposited,
+        phase: plan.phase,
+        phase_label: plan.phaseLabel,
+        re_entry: plan.reEntry,
+        strategy: plan.strategy,
+    };
+    emitBootstrapHandoff(handoff, io, args.json);
+    return 0;
+}
+// ===========================================================================
 // Native policy-set handler (#2022 Phase 1).
 //
 // Port of scripts/policy_set.py to native TypeScript so the typed-policy write
@@ -1604,6 +1996,8 @@ async function loadCoreModuleHandler(verb, io) {
             return (argv) => runPackMigrateSwarmSpec(argv, io);
         case "policy-set":
             return (argv) => runPolicySet(argv, io);
+        case "setup-ghx":
+            return (argv) => runSetupGhx(argv, io);
         case "scope-undo": {
             const { undoMain } = await import("@deftai/directive-core/dist/scope/main.js");
             return undoMain;

package/dist/doc-cli-parity.js

@@ -15,7 +15,7 @@ import { registeredVerbs, resolveCanonicalVerb, VERB_ALIASES } from "./dispatch.
 export const LEGACY_DOC_VERB_KEYS = new Set(["setup", "upgrade", "relocate"]);
 const CLI_PREFIX_RE = /^(?:directive|deft|npx @deftai\/directive)\s+/;
 const BACKTICK_COMMAND_RE = /`((?:directive|deft|npx @deftai\/directive)\s+[^`]+)`/g;
-const TOP_LEVEL_UX = new Set(["init", "update", "migrate"]);
+const TOP_LEVEL_UX = new Set(["init", "update", "migrate", "bootstrap"]);
 function repoRootFromModule() {
     return resolve(import.meta.dirname, "..", "..", "..");
 }

package/dist/doctor-parity.d.ts

@@ -11,6 +11,8 @@ export interface ParityScenario {
     readonly cwd?: string;
     readonly env?: Record<string, string | undefined>;
     readonly setup?: (root: string) => void;
+    /** When true, stdout may diverge (TS-only consumer probes post #2022 Phase 3). */
+    readonly exitCodeOnly?: boolean;
 }
 export interface ParityResult {
     readonly ok: boolean;
@@ -27,7 +29,9 @@ export interface ParityResult {
 export declare const PARITY_SCENARIOS: readonly ParityScenario[];
 /** Normalise volatile lines while preserving doctor semantics. */
 export declare function normaliseStdout(text: string): string;
-export declare function diffParity(python: ScenarioResult, ts: ScenarioResult): {
+export declare function diffParity(python: ScenarioResult, ts: ScenarioResult, options?: {
+    exitCodeOnly?: boolean;
+}): {
     exitMismatch: boolean;
     stdoutMismatch: boolean;
     pythonStdout: string;

package/dist/doctor-parity.js

@@ -18,6 +18,7 @@ export const PARITY_SCENARIOS = [
     {
         name: "full-json-consumer-fixture",
         argv: ["--full", "--json"],
+        exitCodeOnly: true,
         setup(root) {
             writeFileSync(join(root, "AGENTS.md"), "<!-- deft:managed-section v3 -->\nbody\n<!-- /deft:managed-section -->\n", "utf8");
             mkdirSync(join(root, ".deft", "core"), { recursive: true });
@@ -93,12 +94,12 @@ function runScenario(deftRoot, scenario) {
         }
     }
 }
-export function diffParity(python, ts) {
+export function diffParity(python, ts, options = {}) {
     const pythonStdout = normaliseStdout(python.stdout);
     const tsStdout = normaliseStdout(ts.stdout);
     return {
         exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: pythonStdout !== tsStdout,
+        stdoutMismatch: options.exitCodeOnly ? false : pythonStdout !== tsStdout,
         pythonStdout,
         tsStdout,
     };
@@ -112,7 +113,7 @@ export function runParity() {
             name: scenario.name,
             pythonExit: ran.python.exitCode,
             tsExit: ran.ts.exitCode,
-            ...diffParity(ran.python, ran.ts),
+            ...diffParity(ran.python, ran.ts, { exitCodeOnly: scenario.exitCodeOnly }),
         });
     }
     const ok = scenarios.every((s) => !s.exitMismatch && !s.stdoutMismatch);

package/dist/install-cli/coverage-map.js

@@ -22,8 +22,9 @@ export const INSTALL_CLI_TAIL_COVERAGE_MAP = [
     },
     {
         pythonTest: "tests/cli/test_migrate_preflight.py",
-        classification: "retire-at-Wave-9",
-        rationale: "scripts/migrate_preflight.py agent-side migrate:vbrief gate — accepted non-port migration tooling.",
+        classification: "retarget",
+        rationale: "scripts/migrate_preflight.py agent-side migrate:vbrief gate — retargeted to deft-ts migrate-preflight on consumer task path (#2022 Phase 2).",
+        vitestSpec: "packages/cli/src/migrate-task-surface.test.ts",
     },
     {
         pythonTest: "tests/cli/test_precutover_guard.py",

package/dist/install-uninstall.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=install-uninstall.d.ts.map

package/dist/install-uninstall.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runInstallUninstall } from "@deftai/directive-core/task-surface";
+function parseProjectRoot(argv) {
+    let projectRoot = ".";
+    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 { projectRoot, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { projectRoot, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot };
+}
+export function run(argv) {
+    const args = parseProjectRoot(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`install-uninstall: ${args.error}\n`);
+        return 2;
+    }
+    return runInstallUninstall(resolve(args.projectRoot), {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=install-uninstall.js.map

package/dist/install-upgrade.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export interface ParsedInstallUpgradeArgs {
+    projectRoot: string;
+    frameworkRoot: string;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedInstallUpgradeArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=install-upgrade.d.ts.map

package/dist/install-upgrade.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runInstallUpgrade } from "@deftai/directive-core/install-upgrade";
+export function parseArgs(argv) {
+    let projectRoot = ".";
+    let frameworkRoot = resolve(import.meta.dirname, "..", "..", "..");
+    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 {
+                    projectRoot,
+                    frameworkRoot,
+                    error: "argument --project-root: expected one argument",
+                };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--framework-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    projectRoot,
+                    frameworkRoot,
+                    error: "argument --framework-root: expected one argument",
+                };
+            }
+            frameworkRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--framework-root=")) {
+            frameworkRoot = arg.slice("--framework-root=".length);
+        }
+        else {
+            return { projectRoot, frameworkRoot, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    if (process.env.DEFT_ROOT && process.env.DEFT_ROOT.length > 0) {
+        frameworkRoot = process.env.DEFT_ROOT;
+    }
+    return { projectRoot, frameworkRoot };
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`install-upgrade: ${args.error}\n`);
+        return 2;
+    }
+    return runInstallUpgrade({ projectRoot: args.projectRoot, frameworkRoot: args.frameworkRoot }, {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=install-upgrade.js.map

package/dist/migrate-preflight.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export interface ParsedMigratePreflightArgs {
+    projectRoot: string;
+    deftRoot: string;
+    quiet: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedMigratePreflightArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=migrate-preflight.d.ts.map

package/dist/migrate-preflight.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { emitMigratePreflight, runMigratePreflight, } from "@deftai/directive-core/migrate-preflight";
+export function parseArgs(argv) {
+    let projectRoot = ".";
+    let deftRoot = resolve(import.meta.dirname, "..", "..", "..");
+    let quiet = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? "";
+        if (arg === "--quiet") {
+            quiet = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    projectRoot,
+                    deftRoot,
+                    quiet,
+                    error: "argument --project-root: expected one argument",
+                };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--deft-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    projectRoot,
+                    deftRoot,
+                    quiet,
+                    error: "argument --deft-root: expected one argument",
+                };
+            }
+            deftRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--deft-root=")) {
+            deftRoot = arg.slice("--deft-root=".length);
+        }
+        else {
+            return { projectRoot, deftRoot, quiet, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    if (process.env.DEFT_ROOT &&
+        process.env.DEFT_ROOT.length > 0 &&
+        !argv.some((a) => a.startsWith("--deft-root"))) {
+        deftRoot = process.env.DEFT_ROOT;
+    }
+    return { projectRoot, deftRoot, quiet };
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`migrate-preflight: ${args.error}\n`);
+        return 2;
+    }
+    const outcome = runMigratePreflight({
+        projectRoot: args.projectRoot,
+        deftRoot: args.deftRoot,
+        quiet: args.quiet,
+    });
+    if (outcome.kind === "config") {
+        process.stderr.write(`migrate-preflight: ${outcome.message}\n`);
+        return 2;
+    }
+    return emitMigratePreflight(outcome, {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    }, args.quiet);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=migrate-preflight.js.map

package/dist/session-start.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+export interface ParsedSessionStartArgs {
+    projectRoot: string;
+    deferValues: string[];
+    emitJson: boolean;
+    noHistory: boolean;
+    error?: string;
+}
+/** Parse session:start CLI args, mirroring scripts/session_start.py. */
+export declare function parseArgs(argv: readonly string[]): ParsedSessionStartArgs;
+/** Native session:start handler (#2032 — replaces framework-commands Python bridge). */
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=session-start.d.ts.map

package/dist/session-start.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDeferrals, ritualStatePath, runSessionStart } from "@deftai/directive-core/session";
+/** Parse session:start CLI args, mirroring scripts/session_start.py. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        deferValues: [],
+        emitJson: false,
+        noHistory: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            parsed.emitJson = true;
+        }
+        else if (arg === "--no-history") {
+            parsed.noHistory = true;
+        }
+        else 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 === "--defer") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --defer: expected one argument" };
+            }
+            parsed.deferValues.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--defer=")) {
+            parsed.deferValues.push(arg.slice("--defer=".length));
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Native session:start handler (#2032 — replaces framework-commands Python bridge). */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`session_start: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const { deferrals, errors } = parseDeferrals(args.deferValues);
+    if (errors.length > 0) {
+        for (const error of errors) {
+            process.stderr.write(`${error}\n`);
+        }
+        return 2;
+    }
+    const capturedStdout = [];
+    const prevWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((chunk, encoding, callback) => {
+        capturedStdout.push(String(chunk));
+        const cb = typeof encoding === "function" ? encoding : callback;
+        if (typeof cb === "function") {
+            cb();
+        }
+        return true;
+    });
+    let result;
+    try {
+        result = runSessionStart(projectRoot, {
+            deferrals,
+            writeHistory: !args.noHistory,
+        });
+    }
+    finally {
+        process.stdout.write = prevWrite;
+    }
+    const lines = [...result.lines];
+    const stray = capturedStdout.join("").trim();
+    if (stray) {
+        lines.push(stray);
+    }
+    if (args.emitJson) {
+        const sorted = Object.keys(result.payload)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = result.payload[key];
+            return acc;
+        }, {});
+        process.stdout.write(`${JSON.stringify(sorted)}\n`);
+        return result.code;
+    }
+    const sink = result.code === 0 ? process.stdout : process.stderr;
+    for (const line of lines) {
+        sink.write(`${line}\n`);
+    }
+    if (result.code === 0) {
+        process.stdout.write(`[deft] session ritual recorded at ${ritualStatePath(projectRoot)}\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-start.js.map

package/dist/toolchain-check.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-export declare function run(): number;
+export declare function run(argv?: readonly string[]): number;
 //# sourceMappingURL=toolchain-check.d.ts.map

package/dist/toolchain-check.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
 import { runToolchainCheck } from "@deftai/directive-core/verify-env";
-export function run() {
-    const result = runToolchainCheck();
+export function run(argv = process.argv.slice(2)) {
+    const consumer = argv.includes("--consumer");
+    const result = runToolchainCheck(undefined, { consumer });
     for (const line of result.lines) {
         process.stdout.write(`${line}\n`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,8 +42,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.59.0",
-    "@deftai/directive-content": "^0.59.0"
+    "@deftai/directive-core": "^0.60.0",
+    "@deftai/directive-content": "^0.60.0"
   },
   "scripts": {
     "build": "tsc -b"