@deftai/directive 0.58.0 → 0.60.0

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 });
@@ -59,7 +60,12 @@ export function normaliseStdout(text) {
         .split("\n")
         .filter((line) => !line.startsWith("Using CPython") &&
         !line.startsWith("Creating virtual environment") &&
-        !line.startsWith("Installed "))
+        !line.startsWith("Installed ") &&
+        // #2022: the TS doctor emits a pre-cutover status line that the Python
+        // oracle (scripts/doctor.py) never had ("without a Python port"). Filter
+        // it so this intentional TS-only addition does not register as parity
+        // divergence. Removed when scripts/doctor.py is purged with the gate.
+        !line.startsWith("Pre-cutover:"))
         .join("\n");
 }
 function runScenario(deftRoot, scenario) {
@@ -88,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,
     };
@@ -107,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/doctor.js

@@ -1,7 +1,18 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
+import { parseDoctorFlags } from "@deftai/directive-core/dist/doctor/flags.js";
 import { cmdDoctor } from "@deftai/directive-core/dist/doctor/main.js";
+import { renderPrecutoverLine } from "@deftai/directive-core/dist/vbrief-validate/precutover.js";
 export function run(argv) {
+    // #2022: surface pre-cutover (pre-v0.20 document model) migration state alongside the
+    // core doctor report. Only emit on a valid, human-readable invocation: suppressed under
+    // --json (so the machine-readable report stays valid), on --help, and when unknown flags
+    // are present (so an invalid invocation still mirrors the core error path exactly).
+    const flags = parseDoctorFlags(argv);
+    if (!flags.json && !flags.help && flags.unknown.length === 0) {
+        const projectRoot = flags.projectRoot ?? process.cwd();
+        process.stdout.write(`${renderPrecutoverLine(projectRoot)}\n`);
+    }
     return cmdDoctor(argv);
 }
 if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {

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/orchestration-cli/coverage-map.js

@@ -118,7 +118,7 @@ export const ORCHESTRATION_CLI_COVERAGE_MAP = [
     {
         pythonTest: "test_release_subprocess_path.py",
         kind: "existing-coverage",
-        tsTarget: "packages/core/src/release/python-bridge.test.ts",
+        tsTarget: "packages/core/src/release/python-steps.test.ts",
     },
     {
         pythonTest: "test_release_summary.py",

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.58.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.58.0",
-    "@deftai/directive-content": "^0.58.0"
+    "@deftai/directive-core": "^0.60.0",
+    "@deftai/directive-content": "^0.60.0"
   },
   "scripts": {
     "build": "tsc -b"