@deftai/directive 0.55.0

package/dist/vbrief-activate-parity.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1782 s5): runs BOTH the Python oracle
+ * (`scripts/vbrief_activate.py`) and the ported TS vbrief-activate CLI over
+ * temp fixture vBRIEF trees, then diffs exit codes and byte-identical
+ * stdout/stderr (cache-off). Mutating scenarios also compare destination
+ * JSON with the volatile ``vBRIEFInfo.updated`` field stripped.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const FIXTURE_NAME = "2026-05-01-test.vbrief.json";
+export const PARITY_CASES = [
+    { name: "pending-to-active", folder: "pending", status: "pending", mutates: true },
+    { name: "approved-to-active", folder: "pending", status: "approved", mutates: true },
+    { name: "already-active-noop", folder: "active", status: "running" },
+    { name: "proposed-reject", folder: "proposed", status: "proposed" },
+    { name: "completed-reject", folder: "completed", status: "completed" },
+    { name: "active-blocked-reject", folder: "active", status: "blocked" },
+    { name: "pending-draft-reject", folder: "pending", status: "draft" },
+    { name: "nonexistent-reject", folder: "pending", status: "pending", missingPath: true },
+    { name: "malformed-json", folder: "pending", status: "pending", rawOverride: "{ not json" },
+    {
+        name: "missing-plan",
+        folder: "pending",
+        status: "pending",
+        payloadOverride: { vBRIEFInfo: { version: "0.6" } },
+    },
+    {
+        name: "missing-plan-status",
+        folder: "pending",
+        status: "pending",
+        payloadOverride: { vBRIEFInfo: { version: "0.6" }, plan: { title: "T" } },
+    },
+    {
+        name: "destination-collision",
+        folder: "pending",
+        status: "pending",
+        preSeedActive: true,
+    },
+];
+function runCapture(cmd, args, cwd) {
+    try {
+        const stdout = execFileSync(cmd, args, {
+            cwd,
+            encoding: "utf8",
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { exitCode: 0, stdout, stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            exitCode: typeof e.status === "number" ? e.status : 2,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.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)), "..", "..", "..");
+}
+function writeFixture(repo, testCase) {
+    const full = join(repo, "vbrief", testCase.folder, FIXTURE_NAME);
+    mkdirSync(dirname(full), { recursive: true });
+    if (testCase.rawOverride !== undefined) {
+        writeFileSync(full, testCase.rawOverride, "utf8");
+        return full;
+    }
+    if (testCase.payloadOverride !== undefined) {
+        writeFileSync(full, JSON.stringify(testCase.payloadOverride), "utf8");
+        return full;
+    }
+    writeFileSync(full, JSON.stringify({
+        vBRIEFInfo: { version: "0.6", updated: "2026-04-30T00:00:00Z" },
+        plan: { title: "T", status: testCase.status, items: [] },
+    }), "utf8");
+    return full;
+}
+function setupRepo(testCase) {
+    const repo = mkdtempSync(join(tmpdir(), "deft-vbrief-activate-parity-"));
+    mkdirSync(join(repo, "vbrief"), { recursive: true });
+    if (testCase.missingPath === true) {
+        return { repo, vbriefPath: join(repo, "vbrief", "pending", "missing.vbrief.json") };
+    }
+    const vbriefPath = writeFixture(repo, testCase);
+    if (testCase.preSeedActive === true) {
+        const activePath = join(repo, "vbrief", "active", FIXTURE_NAME);
+        mkdirSync(dirname(activePath), { recursive: true });
+        writeFileSync(activePath, "{}", "utf8");
+    }
+    return { repo, vbriefPath };
+}
+function stripUpdatedField(repo) {
+    const dest = join(repo, "vbrief", "active", FIXTURE_NAME);
+    if (!existsSync(dest)) {
+        return null;
+    }
+    const payload = JSON.parse(readFileSync(dest, "utf8"));
+    const info = payload.vBRIEFInfo;
+    if (info !== null && typeof info === "object" && !Array.isArray(info)) {
+        delete info.updated;
+    }
+    return JSON.stringify(payload);
+}
+function runPython(deftRoot, vbriefPath) {
+    return runCapture("uv", ["run", "python", join(deftRoot, "scripts", "vbrief_activate.py"), vbriefPath], deftRoot);
+}
+function runTs(deftRoot, vbriefPath) {
+    return runCapture("node", [join(deftRoot, "packages", "cli", "dist", "vbrief-activate.js"), vbriefPath], deftRoot);
+}
+export function diffCase(python, ts, caseName, sideEffectMismatch) {
+    return {
+        caseName,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: python.stdout !== ts.stdout,
+        stderrMismatch: python.stderr !== ts.stderr,
+        sideEffectMismatch,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+        pythonStdout: python.stdout,
+        pythonStderr: python.stderr,
+        tsStdout: ts.stdout,
+        tsStderr: ts.stderr,
+    };
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const pySetup = setupRepo(testCase);
+        const tsSetup = testCase.mutates === true ? setupRepo(testCase) : pySetup;
+        try {
+            const py = runPython(deftRoot, pySetup.vbriefPath);
+            const ts = runTs(deftRoot, tsSetup.vbriefPath);
+            let sideEffectMismatch = false;
+            if (testCase.mutates === true && py.exitCode === 0 && ts.exitCode === 0) {
+                const pyBody = stripUpdatedField(pySetup.repo);
+                const tsBody = stripUpdatedField(tsSetup.repo);
+                sideEffectMismatch = pyBody !== tsBody;
+                if (pyBody !== null && tsBody !== null) {
+                    const pyPendingGone = !existsSync(pySetup.vbriefPath);
+                    const tsPendingGone = !existsSync(tsSetup.vbriefPath);
+                    sideEffectMismatch =
+                        sideEffectMismatch ||
+                            pyPendingGone !== tsPendingGone ||
+                            !pyPendingGone ||
+                            !tsPendingGone;
+                }
+            }
+            diffs.push(diffCase(py, ts, testCase.name, sideEffectMismatch));
+        }
+        finally {
+            rmSync(pySetup.repo, { recursive: true, force: true });
+            if (tsSetup.repo !== pySetup.repo) {
+                rmSync(tsSetup.repo, { recursive: true, force: true });
+            }
+        }
+    }
+    const ok = diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch && !d.sideEffectMismatch);
+    return { ok, diffs };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `vbrief-activate parity: CLEAN -- Python and TS agree on ${result.diffs.length} scenario(s).`;
+    }
+    const lines = ["vbrief-activate parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch || d.sideEffectMismatch) {
+            lines.push(`  scenario: ${d.caseName}`);
+            if (d.exitMismatch) {
+                lines.push(`    exit mismatch: python=${d.pythonExit} ts=${d.tsExit}`);
+            }
+            if (d.stdoutMismatch) {
+                lines.push(`    python stdout: ${JSON.stringify(d.pythonStdout)}`);
+                lines.push(`    ts stdout:     ${JSON.stringify(d.tsStdout)}`);
+            }
+            if (d.stderrMismatch) {
+                lines.push(`    python stderr: ${JSON.stringify(d.pythonStderr)}`);
+                lines.push(`    ts stderr:     ${JSON.stringify(d.tsStderr)}`);
+            }
+            if (d.sideEffectMismatch) {
+                lines.push("    side-effect mismatch (active/ payload or source removal)");
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export function runParityCli() {
+    try {
+        const result = runParity();
+        if (result.ok) {
+            process.stdout.write(`${renderReport(result)}\n`);
+            return 0;
+        }
+        process.stderr.write(`${renderReport(result)}\n`);
+        return 1;
+    }
+    catch (err) {
+        const msg = String(err).replace(/\r?\n/g, " ");
+        process.stderr.write(`vbrief-activate parity: harness error -- ${msg}\n`);
+        return 2;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(runParityCli());
+}
+//# sourceMappingURL=vbrief-activate-parity.js.map

package/dist/vbrief-activate.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-activate.d.ts.map

package/dist/vbrief-activate.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { run } from "@deftai/directive-core/vbrief-activate";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-activate.js.map

package/dist/vbrief-build-parity.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+export interface ScenarioResult {
+    readonly name: string;
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly scenarios: Array<{
+        readonly name: string;
+        readonly exitMismatch: boolean;
+        readonly pythonExit: number;
+        readonly tsExit: number;
+        readonly outputMismatch: boolean;
+        readonly pythonOutput: string;
+        readonly tsOutput: string;
+    }>;
+}
+export declare function diffParity(python: ScenarioResult, ts: ScenarioResult): {
+    exitMismatch: boolean;
+    outputMismatch: boolean;
+    pythonOutput: string;
+    tsOutput: string;
+};
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=vbrief-build-parity.d.ts.map

package/dist/vbrief-build-parity.js

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1782 s1): runs BOTH the Python oracle
+ * (frozen ``scripts/_vbrief_*.py`` helpers via an inline driver) and the
+ * ported TS vbrief-build CLI over shared fixtures, then diffs exit codes and
+ * byte-identical stdout/stderr (cache-off).
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { spawnSync } from "node:child_process";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PARITY_SCENARIO_NAMES } from "@deftai/directive-core/vbrief-build";
+const PYTHON_DRIVER = String.raw `import json, os, sys
+from pathlib import Path
+
+ROOT = Path(os.environ["DEFT_ROOT"])
+sys.path.insert(0, str(ROOT / "scripts"))
+
+from _vbrief_build import create_scope_vbrief, reference_with_default_trust, slugify
+from _vbrief_sources import (
+    derive_overview_narrative,
+    extract_tech_stack,
+    first_prose_paragraph,
+    parse_roadmap_items,
+    resolve_repo_url,
+)
+from _vbrief_routing import build_scope_vbrief_from_reconciled, folder_for_status, plan_status_matches_folder
+from _vbrief_speckit import (
+    create_speckit_scope_vbrief,
+    dependencies_for_item,
+    edge_nodes,
+    migrate_speckit_plan,
+    speckit_ip_index,
+    speckit_ip_slug,
+)
+from _project_definition_io import (
+    atomic_write_project_definition,
+    load_project_definition_for_mutation,
+    project_definition_mutation_lock,
+)
+
+SAMPLE_ROADMAP_MD = """# Roadmap
+
+## Phase 1 -- Foundation
+
+- **#100** -- Add widget support
+- **#101** -- Fix login bug
+
+## Phase 2 -- Features
+
+- **#200** -- Dashboard redesign
+
+## Completed
+
+- ~~#50 -- Initial setup~~
+"""
+
+SAMPLE_SPEC_VBRIEF = {
+    "vBRIEFInfo": {"version": "0.5", "description": "Test spec"},
+    "plan": {
+        "title": "Test Specification",
+        "status": "approved",
+        "narratives": {
+            "Overview": "A test project for migration.",
+            "Architecture": "Simple architecture.",
+        },
+        "items": [{"id": "t1.1", "title": "Task one", "status": "completed"}],
+    },
+}
+
+SAMPLE_PROJECT_MD = (
+    "# Test Project\n\n"
+    "## Project Configuration\n\n"
+    "**Tech Stack**: Python\n\n"
+    "**Generated by**: deft-setup skill\n"
+    "**Date**: 2026-04-01\n"
+)
+
+SAMPLE_SPEC_MD = (
+    "# Test Specification\n\n"
+    "A test specification.\n\n"
+    "**Generated by**: spec_render.py\n"
+)
+
+def reconciled_base(**overrides):
+    base = {
+        "task_id": "#99",
+        "number": "99",
+        "title": "Widget feature",
+        "description": "Add a widget.",
+        "description_source": "SPECIFICATION.md",
+        "status": "pending",
+        "status_source": "default",
+        "folder": "pending",
+        "phase": "Phase 1",
+        "phase_description": "",
+        "tier": "",
+        "spec_phase": "",
+        "roadmap_summary": "",
+        "source_conflict": "",
+        "title_source": "",
+        "override_applied": False,
+        "synthetic_id": "",
+        "original_task_id": "",
+    }
+    base.update(overrides)
+    return base
+
+def dump(obj):
+    payload = json.dumps(obj, indent=2, ensure_ascii=False, sort_keys=False)
+    if not payload.endswith("\n"):
+        payload += "\n"
+    sys.stdout.write(payload)
+
+def run_scenario(name, fixture_root):
+    fixture = Path(fixture_root)
+    if name == "slugify-basic":
+        return {"scenario": name, "ok": True, "payload": {
+            "hello": slugify("Hello World"),
+            "special": slugify("Add widget (v2)!"),
+            "underscores": slugify("task_id_foo"),
+        }}
+    if name == "create-scope-vbrief":
+        return {"scenario": name, "ok": True, "payload": create_scope_vbrief(
+            {"number": "99", "title": "Test feature", "phase": "Phase 1", "tier": "Tier 1"},
+            repo_url="https://github.com/owner/repo",
+        )}
+    if name == "reference-trust-levels":
+        return {"scenario": name, "ok": True, "payload": {
+            "internal": reference_with_default_trust({"type": "x-vbrief/plan", "uri": "specification.vbrief.json"}),
+            "external": reference_with_default_trust({"type": "x-vbrief/github-issue", "uri": "https://github.com/o/r/issues/1", "title": "Issue #1"}),
+            "preset": reference_with_default_trust({"type": "x-vbrief/github-issue", "uri": "https://github.com/o/r/issues/1", "title": "Issue #1", "TrustLevel": "internal"}),
+        }}
+    if name == "parse-roadmap":
+        roadmap = fixture / "ROADMAP.md"
+        roadmap.write_text(SAMPLE_ROADMAP_MD, encoding="utf-8")
+        items, phase_descs, completed = parse_roadmap_items(roadmap)
+        return {"scenario": name, "ok": True, "payload": {"items": items, "phaseDescriptions": phase_descs, "completedItems": completed}}
+    if name == "resolve-repo-url":
+        return {"scenario": name, "ok": True, "payload": {
+            "fromRepository": resolve_repo_url({"vBRIEFInfo": {"repository": "owner/repo"}}),
+            "fromRef": resolve_repo_url({"plan": {"references": [{"uri": "https://github.com/acme/widget/issues/1"}]}}),
+            "empty": resolve_repo_url(None),
+        }}
+    if name == "extract-tech-stack":
+        return {"scenario": name, "ok": True, "payload": extract_tech_stack(SAMPLE_PROJECT_MD)}
+    if name == "first-prose-paragraph":
+        return {"scenario": name, "ok": True, "payload": first_prose_paragraph(SAMPLE_SPEC_MD)}
+    if name == "derive-overview":
+        return {"scenario": name, "ok": True, "payload": {
+            "fromSpec": derive_overview_narrative(SAMPLE_SPEC_VBRIEF, None, None, 0),
+            "fromSpecMd": derive_overview_narrative(None, SAMPLE_SPEC_MD, None, 0),
+            "placeholder": derive_overview_narrative(None, None, None, 3),
+        }}
+    if name == "routing-map":
+        return {"scenario": name, "ok": True, "payload": {
+            "running": folder_for_status("running"),
+            "matches": plan_status_matches_folder("running", "active"),
+        }}
+    if name == "build-reconciled":
+        return {"scenario": name, "ok": True, "payload": build_scope_vbrief_from_reconciled(
+            reconciled_base(status="completed", folder="completed", source_section="ROADMAP Completed section"),
+            repo_url="https://github.com/acme/widget",
+            migration_timestamp="2026-04-23T00:00:00Z",
+        )}
+    if name == "speckit-edge-deps":
+        return {"scenario": name, "ok": True, "payload": {
+            "nodes": list(edge_nodes({"from": "a", "to": "b"})),
+            "legacy": list(edge_nodes({"source": "x", "target": "y"})),
+            "deps": dependencies_for_item("ip-2", [
+                {"type": "blocks", "from": "ip-1", "to": "ip-2"},
+                {"type": "blocks", "source": "ip-0", "target": "ip-2"},
+            ]),
+            "slug": speckit_ip_slug("IP-1: Widget phase", "ip-1"),
+            "index": speckit_ip_index({"id": "phase-ip-3", "title": "IP 3: Build"}, 9),
+        }}
+    if name == "create-speckit-scope":
+        return {"scenario": name, "ok": True, "payload": create_speckit_scope_vbrief(
+            {"title": "IP-1: Foundation", "narrative": {"Description": "Build the foundation.", "Acceptance": "Tests pass.", "Traces": "REQ-1"}},
+            ip_index=1,
+            dependencies=["ip-0"],
+            spec_ref="../specification.vbrief.json",
+        )}
+    if name == "project-definition-roundtrip":
+        vbrief = fixture / "vbrief"
+        vbrief.mkdir(parents=True, exist_ok=True)
+        seed = {
+            "vBRIEFInfo": {"version": "0.6"},
+            "plan": {"title": "Parity project", "status": "running", "policy": {"wipCap": 10}, "items": []},
+        }
+        pd = vbrief / "PROJECT-DEFINITION.vbrief.json"
+        pd.write_text(json.dumps(seed, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        roundtrip = {}
+        with project_definition_mutation_lock(fixture):
+            data, path = load_project_definition_for_mutation(fixture)
+            data["plan"]["policy"] = {"wipCap": 12}
+            atomic_write_project_definition(path, data)
+            roundtrip = json.loads(path.read_text(encoding="utf-8"))
+        return {"scenario": name, "ok": True, "payload": roundtrip}
+    if name == "migrate-speckit-plan":
+        vbrief = fixture / "vbrief"
+        vbrief.mkdir(parents=True, exist_ok=True)
+        plan_path = vbrief / "plan.vbrief.json"
+        plan_fixture = {
+            "vBRIEFInfo": {"version": "0.5", "description": "Speckit plan"},
+            "plan": {
+                "title": "Session",
+                "items": [{"id": "ip-1", "title": "IP-1: Foundation", "narrative": {"Description": "Build it."}}],
+                "edges": [],
+            },
+        }
+        plan_path.write_text(json.dumps(plan_fixture, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        ok, actions = migrate_speckit_plan(plan_path, pending_dir=vbrief / "pending", today="2026-04-23")
+        pending_content = None
+        pending_path = vbrief / "pending" / "2026-04-23-ip001-foundation.vbrief.json"
+        if pending_path.is_file():
+            pending_content = json.loads(pending_path.read_text(encoding="utf-8"))
+        rewritten = json.loads(plan_path.read_text(encoding="utf-8"))
+        return {"scenario": name, "ok": ok, "payload": {"actions": actions, "pendingContent": pending_content, "rewrittenPlan": rewritten, "pendingFiles": ["pending"]}}
+    if name == "extract-tech-stack-eos":
+        return {"scenario": name, "ok": True, "payload": {
+            "endOfString": extract_tech_stack("## Tech Stack\nRust + TypeScript"),
+            "trailingNewline": extract_tech_stack("## Tech Stack\nRust + TypeScript\n"),
+            "followedByHeading": extract_tech_stack("## Tech Stack\nRust\n## Next\nmore"),
+            "multiLine": extract_tech_stack("## Tech Stack\nRust\nVitest\n"),
+        }}
+    if name == "speckit-ip-index-edge":
+        return {"scenario": name, "ok": True, "payload": {
+            "longDigits": speckit_ip_index({"id": "12345678901234"}, 1),
+            "trailingWhitespace": speckit_ip_index({"id": "ip-7   "}, 1),
+            "trailingNewline": speckit_ip_index({"id": "ip-8\n"}, 1),
+            "titleFallback": speckit_ip_index({"id": "phase", "title": "IP-3: Build"}, 9),
+            "noDigits": speckit_ip_index({"id": "phase-x", "title": "no ip"}, 5),
+        }}
+    if name == "repo-url-trailing-slashes":
+        return {"scenario": name, "ok": True, "payload": {
+            "single": create_scope_vbrief({"number": "5", "title": "T"}, repo_url="https://github.com/o/r/"),
+            "multiple": create_scope_vbrief({"number": "6", "title": "U"}, repo_url="https://github.com/o/r///"),
+            "spaced": create_scope_vbrief({"number": "7", "title": "V"}, repo_url="  https://github.com/o/r//  "),
+        }}
+    return {"scenario": name, "ok": False, "payload": {"error": f"unknown scenario: {name}"}}
+
+def main():
+    mode = sys.argv[1] if len(sys.argv) > 1 else ""
+    fixture_root = os.environ.get("DEFT_VBRIEF_BUILD_FIXTURE", "")
+    if mode == "--all":
+        results = [run_scenario(name, fixture_root) for name in json.loads(os.environ["DEFT_VBRIEF_BUILD_SCENARIOS"])]
+        dump(results)
+        return 0
+    if mode == "--scenario":
+        name = sys.argv[2]
+        dump(run_scenario(name, fixture_root))
+        return 0
+    sys.stderr.write("usage: driver --all | --scenario NAME\n")
+    return 2
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+`;
+function runCapture(cmd, args, cwd, env) {
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: { ...process.env, ...env },
+        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)), "..", "..", "..");
+}
+function normaliseHarnessNoise(text) {
+    return text
+        .split("\n")
+        .filter((line) => !line.startsWith("Using CPython") &&
+        !line.startsWith("Creating virtual environment") &&
+        !line.startsWith("Installed "))
+        .join("\n");
+}
+export function diffParity(python, ts) {
+    const pythonOutput = normaliseHarnessNoise(python.stdout);
+    const tsOutput = normaliseHarnessNoise(ts.stdout);
+    return {
+        exitMismatch: python.exitCode !== ts.exitCode,
+        outputMismatch: pythonOutput !== tsOutput,
+        pythonOutput,
+        tsOutput,
+    };
+}
+function installPythonDriver(_deftRoot) {
+    const dir = mkdtempSync(join(tmpdir(), "deft-vbrief-build-py-driver-"));
+    const driverPath = join(dir, "vbrief_build_parity_driver.py");
+    writeFileSync(driverPath, PYTHON_DRIVER, "utf8");
+    chmodSync(driverPath, 0o755);
+    return {
+        driverPath,
+        cleanup: () => rmSync(dir, { recursive: true, force: true }),
+    };
+}
+function runScenario(deftRoot, driverPath, name) {
+    const pyFixture = mkdtempSync(join(tmpdir(), "deft-vbrief-build-parity-py-"));
+    const tsFixture = mkdtempSync(join(tmpdir(), "deft-vbrief-build-parity-ts-"));
+    const envBase = {
+        DEFT_CACHE_DISABLE: "1",
+        PYTHONUTF8: "1",
+        DEFT_ROOT: deftRoot,
+        DEFT_VBRIEF_BUILD_SCENARIOS: JSON.stringify(PARITY_SCENARIO_NAMES),
+    };
+    try {
+        const py = runCapture("uv", ["run", "python", driverPath, "--scenario", name], deftRoot, {
+            ...envBase,
+            DEFT_VBRIEF_BUILD_FIXTURE: pyFixture,
+        });
+        const ts = runCapture("node", [
+            join(deftRoot, "packages", "cli", "dist", "vbrief-build.js"),
+            "--scenario",
+            name,
+            "--fixture-root",
+            tsFixture,
+        ], deftRoot, envBase);
+        return {
+            python: { name, exitCode: py.status, stdout: py.stdout, stderr: py.stderr },
+            ts: { name, exitCode: ts.status, stdout: ts.stdout, stderr: ts.stderr },
+        };
+    }
+    finally {
+        rmSync(pyFixture, { recursive: true, force: true });
+        rmSync(tsFixture, { recursive: true, force: true });
+    }
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const driver = installPythonDriver(deftRoot);
+    const scenarios = [];
+    try {
+        for (const name of PARITY_SCENARIO_NAMES) {
+            const ran = runScenario(deftRoot, driver.driverPath, name);
+            scenarios.push({
+                name,
+                pythonExit: ran.python.exitCode,
+                tsExit: ran.ts.exitCode,
+                ...diffParity(ran.python, ran.ts),
+            });
+        }
+    }
+    finally {
+        driver.cleanup();
+    }
+    const ok = scenarios.every((s) => !s.exitMismatch && !s.outputMismatch);
+    return { ok, scenarios };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `vbrief_build parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
+    }
+    const lines = ["vbrief_build parity: DIVERGENCE"];
+    for (const s of result.scenarios) {
+        if (s.exitMismatch || s.outputMismatch) {
+            lines.push(`  scenario: ${s.name}`);
+            if (s.exitMismatch) {
+                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
+            }
+            if (s.outputMismatch) {
+                lines.push(`    python (${s.pythonOutput.length} bytes):`);
+                lines.push(s.pythonOutput.slice(0, 500));
+                lines.push(`    ts (${s.tsOutput.length} bytes):`);
+                lines.push(s.tsOutput.slice(0, 500));
+            }
+        }
+    }
+    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(`vbrief_build parity: harness error -- ${msg}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=vbrief-build-parity.js.map

package/dist/vbrief-build.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-build.d.ts.map

package/dist/vbrief-build.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/** Thin CLI seam for vbrief-build parity scenarios (#1782 s1). */
+import { fileURLToPath } from "node:url";
+import { cmdVbriefBuild } from "@deftai/directive-core/vbrief-build";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(cmdVbriefBuild(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-build.js.map