@deftai/directive 0.55.0

package/dist/doctor-parity.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1728): runs BOTH the Python oracle
+ * (`scripts/doctor.py`) and the ported TS doctor CLI with identical argv,
+ * then diffs exit codes and stdout. Exit 0 only on byte-identical results.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const PARITY_SCENARIOS = [
+    { name: "full-json-deft-root", argv: ["--full", "--json"] },
+    { name: "full-quiet-deft-root", argv: ["--full", "--quiet"] },
+    { name: "unknown-flag", argv: ["--not-a-real-flag"] },
+    {
+        name: "full-json-consumer-fixture",
+        argv: ["--full", "--json"],
+        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 });
+            writeFileSync(join(root, ".deft", "core", "VERSION"), "tag: v0.1.0\nsha: abcdef0123456789abcdef0123456789abcdef01\nref: v0.1.0\n", "utf8");
+        },
+    },
+];
+function runCapture(cmd, args, cwd, env = {}) {
+    const merged = {
+        ...process.env,
+        ...env,
+        DEFT_CACHE_DISABLE: "1",
+    };
+    for (const key of Object.keys(merged)) {
+        if (merged[key] === undefined)
+            delete merged[key];
+    }
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: merged,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        status: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function resolveDeftRoot() {
+    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
+        return resolve(process.env.DEFT_ROOT);
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+/** Normalise volatile lines while preserving doctor semantics. */
+export function normaliseStdout(text) {
+    return text
+        .split("\n")
+        .filter((line) => !line.startsWith("Using CPython") &&
+        !line.startsWith("Creating virtual environment") &&
+        !line.startsWith("Installed "))
+        .join("\n");
+}
+function runScenario(deftRoot, scenario) {
+    let cwd = scenario.cwd ?? deftRoot;
+    let tempRoot;
+    const argv = [...scenario.argv];
+    if (scenario.setup) {
+        tempRoot = mkdtempSync(join(tmpdir(), "deft-doctor-parity-"));
+        scenario.setup(tempRoot);
+        cwd = tempRoot;
+    }
+    try {
+        const pyArgs = ["run", "python", join(deftRoot, "scripts", "doctor.py"), ...argv];
+        const tsArgs = [join(deftRoot, "packages", "cli", "dist", "doctor.js"), ...argv];
+        const env = { ...scenario.env, PYTHONUTF8: "1" };
+        const py = runCapture("uv", pyArgs, cwd, env);
+        const ts = runCapture("node", tsArgs, cwd, env);
+        return {
+            python: { name: scenario.name, exitCode: py.status, stdout: py.stdout, stderr: py.stderr },
+            ts: { name: scenario.name, exitCode: ts.status, stdout: ts.stdout, stderr: ts.stderr },
+        };
+    }
+    finally {
+        if (tempRoot) {
+            rmSync(tempRoot, { recursive: true, force: true });
+        }
+    }
+}
+export function diffParity(python, ts) {
+    const pythonStdout = normaliseStdout(python.stdout);
+    const tsStdout = normaliseStdout(ts.stdout);
+    return {
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: pythonStdout !== tsStdout,
+        pythonStdout,
+        tsStdout,
+    };
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const scenarios = [];
+    for (const scenario of PARITY_SCENARIOS) {
+        const ran = runScenario(deftRoot, scenario);
+        scenarios.push({
+            name: scenario.name,
+            pythonExit: ran.python.exitCode,
+            tsExit: ran.ts.exitCode,
+            ...diffParity(ran.python, ran.ts),
+        });
+    }
+    const ok = scenarios.every((s) => !s.exitMismatch && !s.stdoutMismatch);
+    return { ok, scenarios };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `doctor parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
+    }
+    const lines = ["doctor parity: DIVERGENCE"];
+    for (const s of result.scenarios) {
+        if (s.exitMismatch || s.stdoutMismatch) {
+            lines.push(`  scenario: ${s.name}`);
+            if (s.exitMismatch) {
+                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
+            }
+            if (s.stdoutMismatch) {
+                lines.push(`    python stdout (${s.pythonStdout.length} bytes)`);
+                lines.push(`    ts stdout (${s.tsStdout.length} bytes)`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    try {
+        const result = runParity();
+        if (result.ok) {
+            process.stdout.write(`${renderReport(result)}\n`);
+            process.exit(0);
+        }
+        process.stderr.write(`${renderReport(result)}\n`);
+        process.exit(1);
+    }
+    catch (err) {
+        const msg = String(err).replace(/\r?\n/g, " ");
+        process.stderr.write(`doctor parity: harness error -- ${msg}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=doctor-parity.js.map

package/dist/doctor.d.ts

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

package/dist/doctor.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { cmdDoctor } from "../../core/dist/doctor/main.js";
+export function run(argv) {
+    return cmdDoctor(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=doctor.js.map

package/dist/gates-cli/_helpers.d.ts

@@ -0,0 +1,18 @@
+export interface DeftTsResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Repo root (deft framework checkout). */
+export declare function repoRoot(): string;
+/** Built `deft-ts` dispatcher binary. */
+export declare function binPath(): string;
+/** Invoke `node packages/cli/dist/bin.js <verb> [...args]`. Pass an empty verb for `--help`. */
+export declare function runDeftTs(verb: string, args?: readonly string[], opts?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): DeftTsResult;
+export declare function initGitRepo(root: string): string;
+export declare function writeProjectDef(root: string, policy?: Record<string, unknown>): void;
+export declare function seedProject(policy?: Record<string, unknown>): string;
+//# sourceMappingURL=_helpers.d.ts.map

package/dist/gates-cli/_helpers.js

@@ -0,0 +1,71 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const gatesDir = dirname(fileURLToPath(import.meta.url));
+/** Repo root (deft framework checkout). */
+export function repoRoot() {
+    return resolve(gatesDir, "..", "..", "..", "..");
+}
+/** Built `deft-ts` dispatcher binary. */
+export function binPath() {
+    return join(repoRoot(), "packages/cli/dist/bin.js");
+}
+/** Invoke `node packages/cli/dist/bin.js <verb> [...args]`. Pass an empty verb for `--help`. */
+export function runDeftTs(verb, args = [], opts = {}) {
+    const root = repoRoot();
+    const argv = verb.length > 0 ? [binPath(), verb, ...args] : [binPath(), ...args];
+    const res = spawnSync(process.execPath, argv, {
+        cwd: opts.cwd ?? root,
+        env: {
+            ...process.env,
+            DEFT_ROOT: root,
+            DEFT_CACHE_DISABLE: "1",
+            PYTHONUTF8: "1",
+            ...opts.env,
+        },
+        encoding: "utf8",
+    });
+    return {
+        exitCode: res.status ?? 1,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? "",
+    };
+}
+export function initGitRepo(root) {
+    writeFileSync(join(root, "README.md"), "fixture\n", "utf8");
+    execFileSync("git", ["init", "-q"], { cwd: root, encoding: "utf8" });
+    execFileSync("git", ["config", "user.email", "gates-cli@test.local"], {
+        cwd: root,
+        encoding: "utf8",
+    });
+    execFileSync("git", ["config", "user.name", "gates-cli"], { cwd: root, encoding: "utf8" });
+    execFileSync("git", ["add", "-A"], { cwd: root, encoding: "utf8" });
+    execFileSync("git", ["commit", "-q", "-m", "init"], {
+        cwd: root,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            GIT_AUTHOR_NAME: "gates-cli",
+            GIT_AUTHOR_EMAIL: "gates-cli@test.local",
+            GIT_COMMITTER_NAME: "gates-cli",
+            GIT_COMMITTER_EMAIL: "gates-cli@test.local",
+        },
+    });
+    return execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim();
+}
+export function writeProjectDef(root, policy = {}) {
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    writeFileSync(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: { title: "T", status: "running", items: [], policy },
+    }), "utf8");
+}
+export function seedProject(policy = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-gates-cli-"));
+    writeProjectDef(root, policy);
+    initGitRepo(root);
+    return root;
+}
+//# sourceMappingURL=_helpers.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@deftai/directive` — entrypoint for the deft directive TypeScript engine.
+ *
+ * Wave-1 skeleton (#1717): `banner()` spans the full dependency chain
+ * (cli → core → types), proving the project-reference graph builds and
+ * resolves end-to-end. Real commands land in later migration waves.
+ */
+export declare const CLI_PACKAGE: "@deftai/directive";
+/** Renders the engine banner string, sourcing core engine metadata. */
+export declare function banner(): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,15 @@
+import { engineInfo } from "@deftai/directive-core";
+/**
+ * `@deftai/directive` — entrypoint for the deft directive TypeScript engine.
+ *
+ * Wave-1 skeleton (#1717): `banner()` spans the full dependency chain
+ * (cli → core → types), proving the project-reference graph builds and
+ * resolves end-to-end. Real commands land in later migration waves.
+ */
+export const CLI_PACKAGE = "@deftai/directive";
+/** Renders the engine banner string, sourcing core engine metadata. */
+export function banner() {
+    const info = engineInfo();
+    return `${CLI_PACKAGE} (engine: ${info.name}@${info.version})`;
+}
+//# sourceMappingURL=index.js.map

package/dist/init-cli/constants.d.ts

@@ -0,0 +1,5 @@
+/** Canonical headless install argv (#1339 / #1409 / getting-started.md). */
+export declare const CANONICAL_INIT_ARGV: readonly ["--yes", "--repo-root", ".", "--json"];
+/** Canonical headless upgrade argv (#1339 / #1409). */
+export declare const CANONICAL_UPDATE_ARGV: readonly ["--yes", "--upgrade", "--repo-root", ".", "--json"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/init-cli/constants.js

@@ -0,0 +1,5 @@
+/** Canonical headless install argv (#1339 / #1409 / getting-started.md). */
+export const CANONICAL_INIT_ARGV = ["--yes", "--repo-root", ".", "--json"];
+/** Canonical headless upgrade argv (#1339 / #1409). */
+export const CANONICAL_UPDATE_ARGV = ["--yes", "--upgrade", "--repo-root", ".", "--json"];
+//# sourceMappingURL=constants.js.map

package/dist/init-cli/init.d.ts

@@ -0,0 +1,3 @@
+import type { DispatchIo } from "../dispatch.js";
+export declare function runInit(argv: readonly string[], io: DispatchIo): number;
+//# sourceMappingURL=init.d.ts.map

package/dist/init-cli/init.js

@@ -0,0 +1,11 @@
+import { CANONICAL_INIT_ARGV } from "./constants.js";
+import { runDeftInstall } from "./run-deft-install.js";
+export function runInit(argv, io) {
+    return runDeftInstall({
+        verb: "init",
+        canonicalArgv: CANONICAL_INIT_ARGV,
+        userArgv: argv,
+        io,
+    });
+}
+//# sourceMappingURL=init.js.map

package/dist/init-cli/resolve-binary.d.ts

@@ -0,0 +1,34 @@
+/** Resolve @deftai/directive package root from a compiled init-cli module URL. */
+export declare function cliPackageRoot(fromModuleUrl?: string): string;
+/** Release artifact basename for the current platform (#11 bundled layout). */
+export declare function releaseArtifactName(platform: NodeJS.Platform, arch: string): string;
+/** Ordered search paths for the bundled deft-install binary. */
+export declare function bundledBinaryCandidates(packageRoot: string, platform: NodeJS.Platform, arch: string): readonly string[];
+export interface ResolveBinaryOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    arch?: string;
+    packageRoot?: string;
+    moduleUrl?: string;
+}
+export type ResolveBinaryResult = {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    reason: "not-found";
+    packageRoot: string;
+    platform: NodeJS.Platform;
+    arch: string;
+} | {
+    ok: false;
+    reason: "override-unreadable";
+    path: string;
+};
+/** Locate the bundled deft-install binary or an explicit DEFT_INSTALL_BINARY override. */
+export declare function resolveBundledDeftInstallBinaryDetailed(options?: ResolveBinaryOptions): ResolveBinaryResult;
+/** Back-compat helper returning only the resolved path. */
+export declare function resolveBundledDeftInstallBinary(options?: ResolveBinaryOptions): string | null;
+export declare function missingBinaryMessage(verb: "init" | "update", packageRoot: string, platform: NodeJS.Platform, arch: string): string;
+export declare function overrideUnreadableMessage(verb: "init" | "update", path: string): string;
+//# sourceMappingURL=resolve-binary.d.ts.map

package/dist/init-cli/resolve-binary.js

@@ -0,0 +1,78 @@
+import { accessSync, constants as fsConstants } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Resolve @deftai/directive package root from a compiled init-cli module URL. */
+export function cliPackageRoot(fromModuleUrl = import.meta.url) {
+    return join(dirname(fileURLToPath(fromModuleUrl)), "..", "..");
+}
+/** Release artifact basename for the current platform (#11 bundled layout). */
+export function releaseArtifactName(platform, arch) {
+    const normalizedArch = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : arch;
+    switch (platform) {
+        case "win32":
+            return `install-windows-${normalizedArch}.exe`;
+        case "darwin":
+            return `install-macos-${normalizedArch}`;
+        case "linux":
+            return `install-linux-${normalizedArch}`;
+        default:
+            return `install-${platform}-${normalizedArch}`;
+    }
+}
+/** Ordered search paths for the bundled deft-install binary. */
+export function bundledBinaryCandidates(packageRoot, platform, arch) {
+    const artifact = releaseArtifactName(platform, arch);
+    const genericName = platform === "win32" ? "deft-install.exe" : "deft-install";
+    return [
+        join(packageRoot, "vendor", "deft-install", artifact),
+        join(packageRoot, "vendor", "deft-install", genericName),
+    ];
+}
+function accessMode(platform) {
+    return platform === "win32" ? fsConstants.R_OK : fsConstants.R_OK | fsConstants.X_OK;
+}
+function isRunnableBinary(path, platform) {
+    try {
+        accessSync(path, accessMode(platform));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Locate the bundled deft-install binary or an explicit DEFT_INSTALL_BINARY override. */
+export function resolveBundledDeftInstallBinaryDetailed(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const packageRoot = options.packageRoot ?? cliPackageRoot(options.moduleUrl ?? import.meta.url);
+    const override = env.DEFT_INSTALL_BINARY?.trim();
+    if (override !== undefined && override.length > 0) {
+        if (isRunnableBinary(override, platform)) {
+            return { ok: true, path: override };
+        }
+        return { ok: false, reason: "override-unreadable", path: override };
+    }
+    for (const candidate of bundledBinaryCandidates(packageRoot, platform, arch)) {
+        if (isRunnableBinary(candidate, platform)) {
+            return { ok: true, path: candidate };
+        }
+    }
+    return { ok: false, reason: "not-found", packageRoot, platform, arch };
+}
+/** Back-compat helper returning only the resolved path. */
+export function resolveBundledDeftInstallBinary(options = {}) {
+    const resolved = resolveBundledDeftInstallBinaryDetailed(options);
+    return resolved.ok ? resolved.path : null;
+}
+export function missingBinaryMessage(verb, packageRoot, platform, arch) {
+    const expected = bundledBinaryCandidates(packageRoot, platform, arch)[0];
+    return (`directive ${verb}: bundled deft-install binary not found (expected ${expected}).\n` +
+        "Download a platform installer from https://github.com/deftai/directive/releases " +
+        "or set DEFT_INSTALL_BINARY to the absolute path of deft-install.");
+}
+export function overrideUnreadableMessage(verb, path) {
+    return (`directive ${verb}: DEFT_INSTALL_BINARY is set to ${path} but the path is missing or not executable.\n` +
+        "Fix the path or download a platform installer from https://github.com/deftai/directive/releases.");
+}
+//# sourceMappingURL=resolve-binary.js.map

package/dist/init-cli/run-deft-install.d.ts

@@ -0,0 +1,23 @@
+import type { DispatchIo } from "../dispatch.js";
+import { type ResolveBinaryOptions, resolveBundledDeftInstallBinaryDetailed } from "./resolve-binary.js";
+export interface BinaryRunResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+}
+export type RunBinaryFn = (binary: string, args: readonly string[], cwd: string) => BinaryRunResult;
+/** Safe subprocess capture (#1366): utf-8 text mode with replace semantics. */
+export declare function defaultRunBinary(binary: string, args: readonly string[], cwd: string): BinaryRunResult;
+export interface RunDeftInstallOptions {
+    verb: "init" | "update";
+    canonicalArgv: readonly string[];
+    userArgv?: readonly string[];
+    io: DispatchIo;
+    cwd?: string;
+    resolveBinaryDetailed?: (options?: ResolveBinaryOptions) => ReturnType<typeof resolveBundledDeftInstallBinaryDetailed>;
+    resolveBinaryOptions?: ResolveBinaryOptions;
+    runBinary?: RunBinaryFn;
+}
+/** Shell out to bundled deft-install with canonical argv and map exit codes. */
+export declare function runDeftInstall(options: RunDeftInstallOptions): number;
+//# sourceMappingURL=run-deft-install.d.ts.map

package/dist/init-cli/run-deft-install.js

@@ -0,0 +1,71 @@
+import { spawnSync } from "node:child_process";
+import { constants as osConstants } from "node:os";
+import { cliPackageRoot, missingBinaryMessage, overrideUnreadableMessage, resolveBundledDeftInstallBinaryDetailed, } from "./resolve-binary.js";
+const SUBPROCESS_MAX_BUFFER = 64 * 1024 * 1024;
+function signalExitCode(signal) {
+    const signum = osConstants.signals[signal];
+    return 128 + (typeof signum === "number" ? signum : 0);
+}
+/** Safe subprocess capture (#1366): utf-8 text mode with replace semantics. */
+export function defaultRunBinary(binary, args, cwd) {
+    const result = spawnSync(binary, [...args], {
+        cwd,
+        env: process.env,
+        encoding: "utf8",
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let status = result.status;
+    let stderr = typeof result.stderr === "string" ? result.stderr : "";
+    if (status === null) {
+        if (result.signal !== null && result.signal !== undefined) {
+            status = signalExitCode(result.signal);
+        }
+        else if (result.error) {
+            status = 2;
+            if (stderr.trim().length === 0) {
+                stderr = result.error.message;
+            }
+        }
+        else {
+            status = 0;
+        }
+    }
+    return {
+        status,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr,
+    };
+}
+function writeCaptured(text, write) {
+    if (text.length === 0)
+        return;
+    write(text.endsWith("\n") ? text : `${text}\n`);
+}
+/** Shell out to bundled deft-install with canonical argv and map exit codes. */
+export function runDeftInstall(options) {
+    const resolveDetailed = options.resolveBinaryDetailed ?? resolveBundledDeftInstallBinaryDetailed;
+    const resolveOptions = options.resolveBinaryOptions ?? {};
+    const resolved = resolveDetailed(resolveOptions);
+    if (!resolved.ok) {
+        if (resolved.reason === "override-unreadable") {
+            options.io.writeErr(`${overrideUnreadableMessage(options.verb, resolved.path)}\n`);
+            return 2;
+        }
+        const packageRoot = resolved.packageRoot ??
+            resolveOptions.packageRoot ??
+            cliPackageRoot(resolveOptions.moduleUrl ?? import.meta.url);
+        const platform = resolved.platform ?? resolveOptions.platform ?? process.platform;
+        const arch = resolved.arch ?? resolveOptions.arch ?? process.arch;
+        options.io.writeErr(`${missingBinaryMessage(options.verb, packageRoot, platform, arch)}\n`);
+        return 2;
+    }
+    const args = [...options.canonicalArgv, ...(options.userArgv ?? [])];
+    const cwd = options.cwd ?? process.cwd();
+    const runBinary = options.runBinary ?? defaultRunBinary;
+    const result = runBinary(resolved.path, args, cwd);
+    writeCaptured(result.stdout, options.io.writeOut);
+    writeCaptured(result.stderr, options.io.writeErr);
+    return result.status === 0 ? 0 : result.status;
+}
+//# sourceMappingURL=run-deft-install.js.map

package/dist/init-cli/update.d.ts

@@ -0,0 +1,3 @@
+import type { DispatchIo } from "../dispatch.js";
+export declare function runUpdate(argv: readonly string[], io: DispatchIo): number;
+//# sourceMappingURL=update.d.ts.map

package/dist/init-cli/update.js

@@ -0,0 +1,11 @@
+import { CANONICAL_UPDATE_ARGV } from "./constants.js";
+import { runDeftInstall } from "./run-deft-install.js";
+export function runUpdate(argv, io) {
+    return runDeftInstall({
+        verb: "update",
+        canonicalArgv: CANONICAL_UPDATE_ARGV,
+        userArgv: argv,
+        io,
+    });
+}
+//# sourceMappingURL=update.js.map

package/dist/install-cli/coverage-map.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Wave 8.5 s7 install/migrate CLI tail — retire-vs-retarget coverage map (#1838).
+ * Primary deliverable is duplicated in the PR body for Wave 9 mechanical teardown.
+ */
+export type InstallCliTailClassification = "retire-at-Wave-9" | "retarget";
+export interface InstallCliTailEntry {
+    readonly pythonTest: string;
+    readonly classification: InstallCliTailClassification;
+    readonly rationale: string;
+    readonly vitestSpec?: string;
+}
+/** One-line rationale per in-scope tests/cli file (Bucket C audit). */
+export declare const INSTALL_CLI_TAIL_COVERAGE_MAP: readonly InstallCliTailEntry[];
+//# sourceMappingURL=coverage-map.d.ts.map