@deftai/directive 0.55.0

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

@@ -0,0 +1,111 @@
+/** One-line rationale per in-scope tests/cli file (Bucket C audit). */
+export const INSTALL_CLI_TAIL_COVERAGE_MAP = [
+    {
+        pythonTest: "tests/cli/test_migrate_vbrief.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Exercises scripts/migrate_vbrief.py pre-v0.20 migrator — accepted non-port deleted in #1731.",
+    },
+    {
+        pythonTest: "tests/cli/test_migrate_vbrief_canonical_refs.py",
+        classification: "retire-at-Wave-9",
+        rationale: "End-to-end migrate_vbrief references/narrative clamp regressions — accepted non-port migrator.",
+    },
+    {
+        pythonTest: "tests/cli/test_migrate_vbrief_fixtures.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Fixture-driven migrate() routing matrix — accepted non-port pre-cutover migrator tooling.",
+    },
+    {
+        pythonTest: "tests/cli/test_migrate_vbrief_rc4.py",
+        classification: "retire-at-Wave-9",
+        rationale: "RC4 migrator rollback/reconciliation — accepted non-port migrate_* family (#1731).",
+    },
+    {
+        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.",
+    },
+    {
+        pythonTest: "tests/cli/test_precutover_guard.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Pre-cutover detection and legacy placeholder checks via _precutover — accepted non-port.",
+    },
+    {
+        pythonTest: "tests/cli/test_cmd_agents_refresh.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run cmd_agents_refresh upgrade-gate companion — no deft-ts verb; retires with legacy run.",
+    },
+    {
+        pythonTest: "tests/cli/test_cmd_check_updates.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run cmd_check_updates remote version probe — no TS port; retires with legacy run module.",
+    },
+    {
+        pythonTest: "tests/cli/test_cmd_doctor.py",
+        classification: "retarget",
+        rationale: "cmd_doctor survives as deft-ts doctor verb (packages/cli/src/doctor.ts); exit-code parity via dispatch.",
+        vitestSpec: "packages/cli/src/install-cli/retarget-dispatch.test.ts",
+    },
+    {
+        pythonTest: "tests/cli/test_cmd_gate.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run cmd_gate universal upgrade gate — no deft-ts verb; retires with legacy run module.",
+    },
+    {
+        pythonTest: "tests/cli/test_cmd_spec.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run cmd_spec interactive spec generator — no deft-ts verb; retires with legacy run.",
+    },
+    {
+        pythonTest: "tests/cli/test_upgrade_gate.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run upgrade gate and cmd_project lifecycle scaffolding — legacy run; no TS equivalent.",
+    },
+    {
+        pythonTest: "tests/cli/test_upgrade_gate_remote_drift.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run _check_upgrade_gate remote-drift integration — legacy run upgrade path.",
+    },
+    {
+        pythonTest: "tests/cli/test_run_bat_path.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Windows run.bat packaging shim self-relative resolution — build/packaging accepted non-port.",
+    },
+    {
+        pythonTest: "tests/cli/test_run_version.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run VERSION resolution chain — legacy run entrypoint retires with scripts/*.py in #1731.",
+    },
+    {
+        pythonTest: "tests/cli/test_setup_ghx.py",
+        classification: "retire-at-Wave-9",
+        rationale: "scripts/setup_ghx.py consent-gated installer helper — build/packaging accepted non-port (#1731).",
+    },
+    {
+        pythonTest: "tests/cli/test_safe_subprocess.py",
+        classification: "retire-at-Wave-9",
+        rationale: "scripts/_safe_subprocess.py UTF-8 capture shim — Python runtime accepted non-port (#1731).",
+    },
+    {
+        pythonTest: "tests/cli/test_task_scripts.py",
+        classification: "retarget",
+        rationale: "TestToolchainCheck maps to deft-ts toolchain-check; remainder covers legacy Python task scripts without TS verbs.",
+        vitestSpec: "packages/cli/src/install-cli/retarget-dispatch.test.ts",
+    },
+    {
+        pythonTest: "tests/cli/test_ts_check_lane.py",
+        classification: "retire-at-Wave-9",
+        rationale: "scripts/ts_check_lane.py Python meta-guard for pnpm lane — retires once Python CI lane is removed.",
+    },
+    {
+        pythonTest: "tests/cli/test_vendored_install_metadata.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Vendored Go-install metadata via Python run/doctor/resolve_version — installer deposit accepted non-port.",
+    },
+    {
+        pythonTest: "tests/cli/test_remote_probe_throttle.py",
+        classification: "retire-at-Wave-9",
+        rationale: "Python run remote-probe throttle state for #801 — legacy run module; no deft-ts verb.",
+    },
+];
+//# sourceMappingURL=coverage-map.js.map

package/dist/intake-parity.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { PARITY_SCENARIO_NAMES, type ParityScenarioName } from "@deftai/directive-core/intake/parity-scenarios";
+export interface Capture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: ParityScenarioName;
+    readonly runPython: (deftRoot: string) => Capture;
+    readonly runTs: (deftRoot: string) => Capture;
+}
+export declare const PARITY_CASES: readonly ParityCase[];
+export interface ParityDiff {
+    readonly name: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly diffs: ParityDiff[];
+}
+export declare function diffCase(python: Capture, ts: Capture, name: string): ParityDiff;
+export declare function runParity(deftRoot?: string): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+export { PARITY_SCENARIO_NAMES };
+//# sourceMappingURL=intake-parity.d.ts.map

package/dist/intake-parity.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1784): compares TS intake modules vs Python oracle via python -c.
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildIssueVbrief, CandidatesLogError, extractCrossRefs, IssueState, reconcile, renderIssueBody, resultToDict, validateCandidatesEntry, validateGithubAuth, } from "@deftai/directive-core/intake";
+import { PARITY_SCENARIO_NAMES, SAMPLE_ISSUE, SAMPLE_VBRIEF, } from "@deftai/directive-core/intake/parity-scenarios";
+import { pythonJsonStringify } from "@deftai/directive-core/scm";
+function capture(exitCode, stdout, stderr = "") {
+    return { exitCode, stdout, stderr };
+}
+function sortKeysDeep(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortKeysDeep(item));
+    }
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        const sorted = {};
+        for (const key of Object.keys(obj).sort()) {
+            sorted[key] = sortKeysDeep(obj[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+function stableJson(value) {
+    return `${pythonJsonStringify(sortKeysDeep(value))}\n`;
+}
+function runPythonScript(deftRoot, script) {
+    const code = `import importlib.util, json, sys\nfrom pathlib import Path\nroot = Path(${JSON.stringify(deftRoot)})\nsys.path.insert(0, str(root / "scripts"))\n${script}`;
+    const result = spawnSync("uv", ["run", "python", "-c", code], {
+        cwd: deftRoot,
+        encoding: "utf8",
+        env: { ...process.env, DEFT_CACHE_DISABLE: "1", PYTHONUTF8: "1" },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        exitCode: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function loadModule(name, rel) {
+    return `spec = importlib.util.spec_from_file_location(${JSON.stringify(name)}, root / ${JSON.stringify(rel)})
+mod = importlib.util.module_from_spec(spec)
+sys.modules[${JSON.stringify(name)}] = mod
+spec.loader.exec_module(mod)`;
+}
+export const PARITY_CASES = [
+    {
+        name: "issue-ingest-build-vbrief",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("issue_ingest", "scripts/issue_ingest.py")}
+issue = ${JSON.stringify(SAMPLE_ISSUE)}
+vbrief, folder = mod._build_issue_vbrief(issue, "proposed", "https://github.com/owner/repo")
+print(json.dumps({"folder": folder, "vbrief": vbrief}, ensure_ascii=False, sort_keys=True))
+sys.exit(0)`);
+        },
+        runTs() {
+            const [vbrief, folder] = buildIssueVbrief(SAMPLE_ISSUE, "proposed", "https://github.com/owner/repo");
+            return capture(0, stableJson({ folder, vbrief }));
+        },
+    },
+    {
+        name: "issue-ingest-cross-refs",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("issue_ingest", "scripts/issue_ingest.py")}
+body = "Closes #10\\nRefs #11\\nBlocked by #12"
+refs = mod._extract_cross_refs(body, "https://github.com/o/r", exclude={10})
+print(json.dumps(refs, ensure_ascii=False, sort_keys=True))
+sys.exit(0)`);
+        },
+        runTs() {
+            const refs = extractCrossRefs("Closes #10\nRefs #11\nBlocked by #12", "https://github.com/o/r", new Set([10]));
+            return capture(0, stableJson(refs));
+        },
+    },
+    {
+        name: "issue-emit-render-body",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("issue_emit", "scripts/issue_emit.py")}
+data = ${JSON.stringify(SAMPLE_VBRIEF)}
+print(mod.render_issue_body(data), end="")
+sys.exit(0)`);
+        },
+        runTs() {
+            return capture(0, renderIssueBody(SAMPLE_VBRIEF));
+        },
+    },
+    {
+        name: "reconcile-classify",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("reconcile_issues", "scripts/reconcile_issues.py")}
+report = mod.reconcile({1: ["proposed/a.vbrief.json"]}, {1: mod.IssueState("OPEN")})
+print(json.dumps(report, ensure_ascii=False, sort_keys=True))
+sys.exit(0)`);
+        },
+        runTs() {
+            const report = reconcile(new Map([[1, ["proposed/a.vbrief.json"]]]), new Map([[1, new IssueState("OPEN")]]));
+            return capture(0, stableJson(report));
+        },
+    },
+    {
+        name: "candidates-validate-reject",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("candidates_log", "scripts/candidates_log.py")}
+try:
+    mod._validate_entry({"decision": "accept"})
+except mod.CandidatesLogError as exc:
+    print(str(exc))
+    sys.exit(1)
+sys.exit(0)`);
+        },
+        runTs() {
+            try {
+                validateCandidatesEntry({ decision: "accept" });
+                return capture(0, "");
+            }
+            catch (exc) {
+                if (exc instanceof CandidatesLogError) {
+                    return capture(1, `${exc.message}\n`);
+                }
+                throw exc;
+            }
+        },
+    },
+    {
+        name: "github-auth-invalid-mode",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("github_auth_modes", "scripts/github_auth_modes.py")}
+result = mod.validate_github_auth("bogus", environ={})
+print(json.dumps(result.to_dict(), ensure_ascii=False, sort_keys=True))
+sys.exit(0)`);
+        },
+        runTs() {
+            const result = validateGithubAuth("bogus", { environ: {} });
+            return capture(0, stableJson(resultToDict(result)));
+        },
+    },
+];
+function resolveDeftRoot() {
+    if (process.env.DEFT_ROOT) {
+        return resolve(process.env.DEFT_ROOT);
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+export function diffCase(python, ts, name) {
+    return {
+        name,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: python.stdout !== ts.stdout,
+        stderrMismatch: python.stderr !== ts.stderr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export function runParity(deftRoot = resolveDeftRoot()) {
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        diffs.push(diffCase(testCase.runPython(deftRoot), testCase.runTs(deftRoot), testCase.name));
+    }
+    return {
+        ok: diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch),
+        diffs,
+    };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `intake parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} case(s).`;
+    }
+    const lines = ["intake parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
+            lines.push(`  case: ${d.name}`);
+            if (d.exitMismatch)
+                lines.push(`    exit: python=${d.pythonExit} ts=${d.tsExit}`);
+            if (d.stdoutMismatch)
+                lines.push("    stdout mismatch");
+            if (d.stderrMismatch)
+                lines.push("    stderr mismatch");
+        }
+    }
+    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) {
+        process.stderr.write(`intake parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+export { PARITY_SCENARIO_NAMES };
+//# sourceMappingURL=intake-parity.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * Wave 8.5 Bucket B coverage map: pytest CLI tests → TS vitest / existing-coverage (#1838 s3).
+ * Python tests remain in-tree until Wave 9 (#1731); entries tagged wave9-delete are dedup candidates.
+ */
+export type CoverageDisposition = "existing-coverage" | "lifecycle-cli-dispatch" | "python-oracle";
+export interface CoverageMapEntry {
+    readonly pythonTest: string;
+    readonly tsTarget: string;
+    readonly disposition: CoverageDisposition;
+    readonly wave9Delete: boolean;
+    readonly notes: string;
+}
+/** Canonical mapping for lifecycle CLI pytest files in scope of story 1838-s3. */
+export declare const LIFECYCLE_CLI_COVERAGE_MAP: readonly CoverageMapEntry[];
+export declare const LIFECYCLE_PYTHON_TEST_FILES: string[];
+//# sourceMappingURL=coverage-map.d.ts.map

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

@@ -0,0 +1,254 @@
+/**
+ * Wave 8.5 Bucket B coverage map: pytest CLI tests → TS vitest / existing-coverage (#1838 s3).
+ * Python tests remain in-tree until Wave 9 (#1731); entries tagged wave9-delete are dedup candidates.
+ */
+/** Canonical mapping for lifecycle CLI pytest files in scope of story 1838-s3. */
+export const LIFECYCLE_CLI_COVERAGE_MAP = [
+    {
+        pythonTest: "tests/cli/test_vbrief_activate.py",
+        tsTarget: "packages/core/src/vbrief-activate/{activate,main,coverage-boost}.test.ts + lifecycle-cli/dispatch-vbrief.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Module matrix in core; deft-ts vbrief-activate argv/exit in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_fidelity_legacy.py",
+        tsTarget: "packages/core/src/vbrief-validation/fidelity.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Legacy fidelity normalization covered in TS vbrief-validation module.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_migrate_conformance.py",
+        tsTarget: "packages/core/src/vbrief-validate/main.test.ts (scanVbrief/conformance)",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Conformance scan parity in vbrief-validate TS port.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_preflight_resolver.py",
+        tsTarget: "packages/cli/src/vbrief-preflight.test.ts + lifecycle-cli/dispatch-preflight.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: false,
+        notes: "Install-layout resolver still Python-only; TS preflight gate + dispatcher alias covered.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_reconcile_graph.py",
+        tsTarget: "packages/core/src/vbrief-reconcile/graph.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Dependency-graph promotion logic in TS vbrief-reconcile.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_reconcile_labels.py",
+        tsTarget: "packages/core/src/vbrief-reconcile/labels.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Label/status derivation covered in TS reconcile engine.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_reconcile_umbrellas.py",
+        tsTarget: "packages/core/src/vbrief-reconcile/umbrellas.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Umbrella current-shape render/parse in TS.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_reconciliation.py",
+        tsTarget: "packages/core/src/vbrief-reconcile/reconciliation.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Override reconciliation table covered in TS.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_routing.py",
+        tsTarget: "packages/core/src/vbrief-build/routing.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Status↔folder routing map in TS vbrief-build.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_validate.py",
+        tsTarget: "packages/core/src/vbrief-validate/main.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "validateAll matrix in core; deft-ts vbrief-validate argv in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_validate_direct.py",
+        tsTarget: "packages/core/src/vbrief-validate/branches.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Direct validate orchestration branches in TS.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_validate_direct_orchestration.py",
+        tsTarget: "packages/core/src/vbrief-validate/branches.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Reference/orchestration warnings in TS validate-all.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_validate_issue_536.py",
+        tsTarget: "packages/core/src/vbrief-validate/branches.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "x-vbrief/github-issue reference counting in TS.",
+    },
+    {
+        pythonTest: "tests/cli/test_vbrief_validation.py",
+        tsTarget: "packages/core/src/vbrief-validation/validation.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Slug/title normalization in core; deft-ts vbrief-validation argv in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_scope_decompose.py",
+        tsTarget: "packages/core/src/scope/decomposed-refs.test.ts",
+        disposition: "python-oracle",
+        wave9Delete: false,
+        notes: "scope:decompose CLI still Python; unit helpers partially covered in decomposed-refs TS.",
+    },
+    {
+        pythonTest: "tests/cli/test_scope_decompose_unit.py",
+        tsTarget: "packages/core/src/scope/decomposed-refs.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: false,
+        notes: "Pure decomposition helpers; CLI entry remains Python until Wave 9.",
+    },
+    {
+        pythonTest: "tests/cli/test_scope_demote.py",
+        tsTarget: "packages/core/src/scope/demote.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Demote transitions in core; deft-ts scope-lifecycle argv in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_scope_lifecycle.py",
+        tsTarget: "packages/core/src/scope/{main,transition,scope-exhaustive}.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Promote/activate/complete matrix in core; scope-lifecycle dispatcher in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_scope_undo.py",
+        tsTarget: "packages/core/src/scope/undo.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Undo round-trip covered in TS scope module.",
+    },
+    {
+        pythonTest: "tests/cli/test_issue_emit.py",
+        tsTarget: "packages/core/src/intake/issue-emit.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Emit body/render in core; deft-ts issue-emit argv in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_issue_ingest.py",
+        tsTarget: "packages/core/src/intake/{issue-ingest,intake-cli-and-branches}.test.ts + lifecycle-cli/dispatch-intake.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Ingest happy-path/duplicate in core; dispatcher routing in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_issue_ingest_body_parsing.py",
+        tsTarget: "packages/core/src/intake/markdown-scanners.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Checkbox/AC body scanners in TS intake module.",
+    },
+    {
+        pythonTest: "tests/cli/test_issue_ingest_canonical_refs.py",
+        tsTarget: "packages/core/src/intake/issue-ingest.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "v0.6 canonical reference shape in TS ingest.",
+    },
+    {
+        pythonTest: "tests/cli/test_issue_ingest_direct.py",
+        tsTarget: "packages/core/src/intake/intake-coverage-boost.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Repo URL / gh helper branches in TS intake.",
+    },
+    {
+        pythonTest: "tests/cli/test_issue_ingest_escape_corruption.py",
+        tsTarget: "packages/core/src/intake/intake-cli-and-branches.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Literal escape preservation in TS ingest path.",
+    },
+    {
+        pythonTest: "tests/cli/test_reconcile_issues.py",
+        tsTarget: "packages/core/src/intake/reconcile-issues.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Reconcile classification in core; deft-ts reconcile-issues argv in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_reconcile_issues_754.py",
+        tsTarget: "packages/core/src/intake/reconcile-issues.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Batch gh state fetch (>500) in TS reconcile module.",
+    },
+    {
+        pythonTest: "tests/cli/test_reconcile_issues_apply.py",
+        tsTarget: "packages/core/src/intake/reconcile-issues.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "Apply/move section-C entries in TS reconcile.",
+    },
+    {
+        pythonTest: "tests/cli/test_reconcile_issues_direct.py",
+        tsTarget: "packages/core/src/intake/intake-coverage-boost.test.ts",
+        disposition: "existing-coverage",
+        wave9Delete: true,
+        notes: "gh subprocess error branches in TS reconcile helpers.",
+    },
+    {
+        pythonTest: "tests/cli/test_preflight_architecture_sor.py",
+        tsTarget: "python-oracle (scripts/preflight_architecture_sor.py)",
+        disposition: "python-oracle",
+        wave9Delete: false,
+        notes: "Architecture SOR preflight not yet on deft-ts; stays Python until TS port.",
+    },
+    {
+        pythonTest: "tests/cli/test_preflight_branch.py",
+        tsTarget: "packages/core/src/branch/evaluate.test.ts + packages/cli/src/verify-branch.test.ts + lifecycle-cli/dispatch-preflight.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Branch gate in core/cli; verify-branch + vbrief:preflight alias via dispatcher.",
+    },
+    {
+        pythonTest: "tests/cli/test_preflight_cache.py",
+        tsTarget: "python-oracle (scripts/preflight_cache.py)",
+        disposition: "python-oracle",
+        wave9Delete: false,
+        notes: "verify:cache-fresh still Python-only per Wave 8 notes; TS cache module covers fetch not preflight gate.",
+    },
+    {
+        pythonTest: "tests/cli/test_preflight_gh.py",
+        tsTarget: "python-oracle (scripts/preflight_gh.py)",
+        disposition: "python-oracle",
+        wave9Delete: false,
+        notes: "Destructive gh preflight still Python-only; intake github-auth-modes partially overlaps read paths.",
+    },
+    {
+        pythonTest: "tests/cli/test_preflight_implementation.py",
+        tsTarget: "packages/core/src/preflight/evaluate.test.ts + packages/cli/src/vbrief-preflight.test.ts + lifecycle-cli/dispatch-preflight.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "#810 state matrix in core; vbrief:preflight / vbrief-preflight dispatcher in lifecycle-cli.",
+    },
+    {
+        pythonTest: "tests/cli/test_preflight_story_start.py",
+        tsTarget: "packages/core/src/story-ready/evaluate.test.ts + packages/cli/src/verify-story-ready.test.ts + lifecycle-cli/dispatch-preflight.test.ts",
+        disposition: "lifecycle-cli-dispatch",
+        wave9Delete: true,
+        notes: "Gate 0 matrix in core; verify:story-ready alias via deft-ts dispatcher.",
+    },
+];
+export const LIFECYCLE_PYTHON_TEST_FILES = LIFECYCLE_CLI_COVERAGE_MAP.map((e) => e.pythonTest);
+//# sourceMappingURL=coverage-map.js.map

package/dist/lifecycle-cli/helpers.d.ts

@@ -0,0 +1,8 @@
+export interface CapturedDispatch {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Invoke the unified deft-ts dispatcher with captured stdout/stderr. */
+export declare function runDispatch(argv: readonly string[]): Promise<CapturedDispatch>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lifecycle-cli/helpers.js

@@ -0,0 +1,20 @@
+/**
+ * Shared helpers for lifecycle CLI retarget specs (#1838 s3).
+ */
+import { dispatch } from "../dispatch.js";
+/** Invoke the unified deft-ts dispatcher with captured stdout/stderr. */
+export async function runDispatch(argv) {
+    const out = [];
+    const err = [];
+    const io = {
+        writeOut: (text) => {
+            out.push(text);
+        },
+        writeErr: (text) => {
+            err.push(text);
+        },
+    };
+    const exitCode = await dispatch([...argv], io);
+    return { exitCode, stdout: out.join(""), stderr: err.join("") };
+}
+//# sourceMappingURL=helpers.js.map

package/dist/lifecycle-packs-parity.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly runPython: (deftRoot: string, repo: string) => CommandCapture;
+    readonly runTs: (deftRoot: string, repo: string) => CommandCapture;
+    readonly setup?: (deftRoot: string, repo: string) => void;
+}
+export interface ParityDiff {
+    readonly caseName: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly diffs: ParityDiff[];
+}
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function normalizeOutput(text: string): string;
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=lifecycle-packs-parity.d.ts.map