@deftai/directive 0.55.0

package/dist/story-ready-parity.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1720): builds throwaway git fixture repos for
+ * story-start Gate 0 scenarios, runs BOTH the Python oracle
+ * (`scripts/preflight_story_start.py`) and the ported TS gate, and diffs exit
+ * codes + normalised messages. Exit 0 only on identical results.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { execFileSync } 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";
+function writeVbrief(root, rel, status = "running", folder = "active") {
+    const full = join(root, "vbrief", folder, rel);
+    mkdirSync(dirname(full), { recursive: true });
+    const payload = {
+        plan: { status, title: "T", items: [] },
+        vBRIEFInfo: { version: "0.6" },
+    };
+    writeFileSync(full, `${JSON.stringify(payload)}\n`, "utf8");
+}
+function renderAllocation(fields) {
+    const lines = ["Dispatch envelope.", "", "## Allocation context", ""];
+    for (const [key, value] of Object.entries(fields)) {
+        lines.push(`- ${key}: ${value === null ? "null" : value}`);
+    }
+    lines.push("", "## Next section", "- trailing: ignored");
+    return lines.join("\n");
+}
+const VALID_COHORT = {
+    allocation_plan_id: "orchestrator-run-019e80bd",
+    batching_rationale: "Three disjoint-file-scope stories from #1378.",
+    cohort_vbriefs: "[vbrief/active/a.json, vbrief/active/b.json]",
+    dispatch_kind: "swarm-cohort",
+    operator_approval_evidence: "user directive 2026-06-01T02:26Z",
+};
+/** Scenarios exercised by the parity harness (mirrors Python contract cases). */
+export const PARITY_SCENARIOS = [
+    {
+        name: "clean-active-running-solo",
+        vbriefRel: "2026-06-01-story.vbrief.json",
+        envelopeRel: null,
+    },
+    {
+        name: "dirty-tree",
+        vbriefRel: "2026-06-01-story.vbrief.json",
+        envelopeRel: null,
+        dirty: true,
+    },
+    {
+        name: "non-running-vbrief",
+        vbriefRel: "2026-06-01-pending.vbrief.json",
+        vbriefStatus: "approved",
+        envelopeRel: null,
+    },
+    {
+        name: "satisfied-swarm-cohort",
+        vbriefRel: "2026-06-01-story.vbrief.json",
+        envelopeRel: "envelope-cohort.md",
+    },
+    {
+        name: "malformed-allocation",
+        vbriefRel: "2026-06-01-story.vbrief.json",
+        envelopeRel: "envelope-bad.md",
+    },
+];
+function gitCommit(cwd, message) {
+    execFileSync("git", ["commit", "-q", "-m", message], {
+        cwd,
+        env: {
+            ...process.env,
+            GIT_AUTHOR_NAME: "deft-parity",
+            GIT_AUTHOR_EMAIL: "parity@test.local",
+            GIT_COMMITTER_NAME: "deft-parity",
+            GIT_COMMITTER_EMAIL: "parity@test.local",
+        },
+    });
+}
+function runCapture(cmd, args, cwd) {
+    try {
+        const stdout = execFileSync(cmd, args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { status: 0, stdout, stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            status: typeof e.status === "number" ? e.status : 2,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.stderr : "",
+        };
+    }
+}
+/** Normalise gate message for comparison (trim, collapse whitespace). */
+export function normaliseMessage(stdout, stderr, exitCode) {
+    const raw = exitCode === 0 ? stdout : stderr;
+    return raw.trim().replace(/\s+/g, " ");
+}
+/** Build a fixture repo for one scenario; return repo root + vbrief absolute path. */
+export function buildScenarioRepo(scenario) {
+    const root = mkdtempSync(join(tmpdir(), "deft-story-ready-parity-"));
+    const vbriefName = scenario.vbriefRel;
+    const status = scenario.vbriefStatus ?? "running";
+    writeVbrief(root, vbriefName, status);
+    if (scenario.dirty) {
+        writeFileSync(join(root, "scratch.txt"), "dirty\n", "utf8");
+    }
+    let envelopePath = null;
+    if (scenario.envelopeRel === "envelope-cohort.md") {
+        envelopePath = join(root, scenario.envelopeRel);
+        writeFileSync(envelopePath, renderAllocation(VALID_COHORT), "utf8");
+    }
+    else if (scenario.envelopeRel === "envelope-bad.md") {
+        envelopePath = join(root, scenario.envelopeRel);
+        const bad = { ...VALID_COHORT };
+        delete bad.dispatch_kind;
+        writeFileSync(envelopePath, renderAllocation(bad), "utf8");
+    }
+    execFileSync("git", ["init", "-q"], { cwd: root });
+    execFileSync("git", ["add", "-A"], { cwd: root });
+    if (!scenario.dirty) {
+        gitCommit(root, "init");
+    }
+    const vbriefPath = join(root, "vbrief", "active", vbriefName);
+    return { root, vbriefPath, envelopePath };
+}
+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 runScenario(deftRoot, scenario) {
+    const { root, vbriefPath, envelopePath } = buildScenarioRepo(scenario);
+    const pyArgs = [
+        "run",
+        "python",
+        join(deftRoot, "scripts", "preflight_story_start.py"),
+        "--vbrief-path",
+        vbriefPath,
+        "--project-root",
+        root,
+    ];
+    if (envelopePath !== null) {
+        pyArgs.push("--allocation-context", envelopePath);
+    }
+    if (scenario.allowDirty) {
+        pyArgs.push("--allow-dirty");
+    }
+    const tsArgs = [
+        join(deftRoot, "packages", "cli", "dist", "verify-story-ready.js"),
+        "--vbrief-path",
+        vbriefPath,
+        "--project-root",
+        root,
+    ];
+    if (envelopePath !== null) {
+        tsArgs.push("--allocation-context", envelopePath);
+    }
+    if (scenario.allowDirty) {
+        tsArgs.push("--allow-dirty");
+    }
+    const py = runCapture("uv", pyArgs, deftRoot);
+    const ts = runCapture("node", tsArgs, deftRoot);
+    return {
+        root,
+        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,
+        },
+    };
+}
+/** Diff python vs TS gate outputs across all parity scenarios. */
+export function diffParity(python, ts) {
+    const pythonMessage = normaliseMessage(python.stdout, python.stderr, python.exitCode);
+    const tsMessage = normaliseMessage(ts.stdout, ts.stderr, ts.exitCode);
+    return {
+        exitMismatch: python.exitCode !== ts.exitCode,
+        messageMismatch: pythonMessage !== tsMessage,
+        pythonMessage,
+        tsMessage,
+    };
+}
+/** Run all parity scenarios and return a structured result. */
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const scenarios = [];
+    for (const scenario of PARITY_SCENARIOS) {
+        const { root, python, ts } = runScenario(deftRoot, scenario);
+        try {
+            const diff = diffParity(python, ts);
+            scenarios.push({
+                name: scenario.name,
+                pythonExit: python.exitCode,
+                tsExit: ts.exitCode,
+                ...diff,
+            });
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }
+    const ok = scenarios.every((s) => !s.exitMismatch && !s.messageMismatch);
+    return { ok, scenarios };
+}
+/** Render a human-readable parity report (exported for unit tests). */
+export function renderReport(result) {
+    if (result.ok) {
+        return `verify_story_ready parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
+    }
+    const lines = ["verify_story_ready parity: DIVERGENCE"];
+    for (const s of result.scenarios) {
+        if (s.exitMismatch || s.messageMismatch) {
+            lines.push(`  scenario: ${s.name}`);
+            if (s.exitMismatch) {
+                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
+            }
+            if (s.messageMismatch) {
+                lines.push(`    python: ${s.pythonMessage}`);
+                lines.push(`    ts:     ${s.tsMessage}`);
+            }
+        }
+    }
+    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(`verify_story_ready parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=story-ready-parity.js.map

package/dist/subagent-monitor.d.ts

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

package/dist/subagent-monitor.js

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

package/dist/swarm-parity.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+export interface Capture {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface ParityCase {
+    name: string;
+    run: (deftRoot: string) => {
+        python: Capture;
+        ts: Capture;
+    };
+}
+export declare function normalizeOutput(text: string): string;
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function diffCase(name: string, python: Capture, ts: Capture): {
+    name: string;
+    ok: boolean;
+    exitMismatch: boolean;
+    stdoutMismatch: boolean;
+    stderrMismatch: boolean;
+};
+export declare function runParity(): {
+    ok: boolean;
+    cases: ReturnType<typeof diffCase>[];
+};
+export declare function runParityCli(): number;
+//# sourceMappingURL=swarm-parity.d.ts.map

package/dist/swarm-parity.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+/**
+ * Golden-diff parity harness (#1788): runs TS swarm cohort verbs vs the FROZEN
+ * Python oracle (cache-off) across launch-manifest, worktree-map collision,
+ * readiness three-state, and review-clean fixtures.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const HEAD_SHA = "abc1234567890def1234567890abcdef12345678";
+const FAKE_GH_PY = `import json, os, sys
+responses = json.loads(os.environ.get("DEFT_FAKE_GH_RESPONSES", "{}"))
+cmd = " ".join(sys.argv[1:])
+label = "unknown"
+if "headRefOid" in cmd: label = "head-sha"
+elif "/issues/" in cmd and "/comments" in cmd and "--jq" in cmd: label = "comments-jq"
+resp = responses.get(label, {"returncode": 1, "stderr": f"unexpected: {label}", "stdout": ""})
+if resp.get("stdout"): sys.stdout.write(resp["stdout"])
+if resp.get("stderr"): sys.stderr.write(resp["stderr"])
+sys.exit(int(resp.get("returncode", 0)))
+`;
+function runCapture(cmd, args, cwd, env) {
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: env ?? process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        exitCode: 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)), "..", "..", "..");
+}
+export function normalizeOutput(text) {
+    return text
+        .replace(/--project-root [^\s]+/g, "--project-root <ROOT>")
+        .replace(/--repo-root [^\s]+/g, "--repo-root <ROOT>")
+        .replace(/\/tmp\/[^\s]+/g, "<TMP>")
+        .replace(/\/home\/[^\s]+/g, "<PATH>")
+        .trim()
+        .replace(/\s+/g, " ");
+}
+function gitInit(repo) {
+    execFileSync("git", ["init", "-q", "-b", "master", repo], { encoding: "utf8" });
+    execFileSync("git", ["config", "user.email", "parity@test.local"], {
+        cwd: repo,
+        encoding: "utf8",
+    });
+    execFileSync("git", ["config", "user.name", "deft-parity"], { cwd: repo, encoding: "utf8" });
+    writeFileSync(join(repo, "f.txt"), "x\n", "utf8");
+    execFileSync("git", ["add", "-A"], { cwd: repo, encoding: "utf8" });
+    execFileSync("git", ["commit", "-q", "-m", "init"], { cwd: repo, encoding: "utf8" });
+}
+function writeReadyStory(project, filename, storyId, issue) {
+    const full = join(project, "vbrief", "active", filename);
+    mkdirSync(dirname(full), { recursive: true });
+    const acceptanceValues = [
+        `Given ${storyId} input, when the story runs, then it returns a scoped result.`,
+        `Given ${storyId} failure input, when the story runs, then it rejects the request.`,
+    ];
+    const payload = {
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            id: storyId,
+            title: storyId,
+            status: "running",
+            references: [
+                {
+                    uri: `https://github.com/deftai/directive/issues/${issue}`,
+                    type: "x-vbrief/github-issue",
+                },
+            ],
+            narratives: {
+                Description: `${storyId} implements a focused product behavior for the active workflow. The story stays within a narrow code path and includes targeted tests for success and failure behavior.`,
+                ImplementationPlan: `1. Update the ${storyId} source path to implement the focused workflow behavior.\n2. Add targeted tests for ${storyId} success and failure outcomes.`,
+                Traces: "FR-1",
+                UserStory: `As a product user, I want ${storyId} behavior, so that I can complete the workflow.`,
+            },
+            items: acceptanceValues.map((criterion, index) => ({
+                id: `${storyId}-a${index + 1}`,
+                title: `Acceptance item ${index + 1}`,
+                status: "pending",
+                narrative: { Acceptance: criterion, Traces: "FR-1" },
+            })),
+            metadata: {
+                kind: "story",
+                swarm: {
+                    readiness: "ready",
+                    parallel_safe: true,
+                    file_scope: [`src/${storyId}.ts`],
+                    verify_commands: [`npm test -- ${storyId}`],
+                    expected_outputs: ["focused tests pass"],
+                    depends_on: [],
+                    conflict_group: "auth",
+                    size: "small",
+                    file_scope_confidence: "high",
+                    model_tier: "medium",
+                },
+            },
+        },
+    };
+    writeFileSync(full, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+function writeProjectDef(project) {
+    const full = join(project, "vbrief", "PROJECT-DEFINITION.vbrief.json");
+    mkdirSync(dirname(full), { recursive: true });
+    writeFileSync(full, `${JSON.stringify({ vBRIEFInfo: { version: "0.6" }, plan: { policy: { swarmSubagentBackend: "grok-build" } } }, null, 2)}\n`, "utf8");
+}
+function writeBlockedStory(project) {
+    const full = join(project, "vbrief", "active", "blocked.vbrief.json");
+    mkdirSync(dirname(full), { recursive: true });
+    writeFileSync(full, `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            id: "blocked-story",
+            title: "blocked",
+            status: "running",
+            metadata: { kind: "story", swarm: { readiness: "not-ready" } },
+        },
+    }, null, 2)}\n`, "utf8");
+}
+function setupFakeGh(tmp) {
+    const fakeGh = join(tmp, "fake-gh");
+    writeFileSync(fakeGh, FAKE_GH_PY, "utf8");
+    chmodSync(fakeGh, 0o755);
+    return fakeGh;
+}
+function cleanGreptileBody(sha = HEAD_SHA, confidence = 5) {
+    return ("## Greptile Summary\n\nNo P0 or P1 issues.\n\n" +
+        `**Confidence Score: ${confidence}/5**\n\n` +
+        `Last reviewed commit: [fix](https://github.com/deftai/directive/commit/${sha})\n`);
+}
+export const PARITY_CASES = [
+    {
+        name: "worktree-map-collision-reject",
+        run: (deftRoot) => {
+            const repo = mkdtempSync(join(tmpdir(), "swarm-wt-"));
+            gitInit(repo);
+            const mapPath = join(repo, "map.json");
+            const wt = join(repo, "wt-shared");
+            writeFileSync(mapPath, JSON.stringify([
+                { story_id: "alpha", worktree_path: wt },
+                { story_id: "beta", worktree_path: wt },
+            ]), "utf8");
+            const pyArgs = [
+                "run",
+                "python",
+                join(deftRoot, "scripts", "swarm_worktrees.py"),
+                "--map",
+                mapPath,
+                "--base-branch",
+                "master",
+                "--repo-root",
+                repo,
+                "--no-create-missing",
+            ];
+            const tsArgs = [
+                join(deftRoot, "packages", "core", "dist", "swarm", "worktrees-cli.js"),
+                "--map",
+                mapPath,
+                "--base-branch",
+                "master",
+                "--repo-root",
+                repo,
+                "--no-create-missing",
+            ];
+            const python = runCapture("uv", pyArgs, deftRoot);
+            const ts = runCapture("node", tsArgs, deftRoot);
+            rmSync(repo, { recursive: true, force: true });
+            return { python, ts };
+        },
+    },
+    {
+        name: "readiness-ready-story",
+        run: (deftRoot) => {
+            const project = mkdtempSync(join(tmpdir(), "swarm-ready-"));
+            mkdirSync(join(project, "vbrief", "active"), { recursive: true });
+            writeReadyStory(project, "ready.vbrief.json", "ready-a", 9001);
+            const storyPath = join(project, "vbrief", "active", "ready.vbrief.json");
+            const py = runCapture("uv", [
+                "run",
+                "python",
+                join(deftRoot, "scripts", "swarm_readiness.py"),
+                storyPath,
+                "--project-root",
+                project,
+            ], deftRoot);
+            const ts = runCapture("node", [
+                join(deftRoot, "packages", "core", "dist", "swarm", "readiness-cli.js"),
+                storyPath,
+                "--project-root",
+                project,
+            ], deftRoot);
+            rmSync(project, { recursive: true, force: true });
+            return { python: py, ts };
+        },
+    },
+    {
+        name: "readiness-blocked-story",
+        run: (deftRoot) => {
+            const project = mkdtempSync(join(tmpdir(), "swarm-block-"));
+            writeBlockedStory(project);
+            const storyPath = join(project, "vbrief", "active", "blocked.vbrief.json");
+            const py = runCapture("uv", [
+                "run",
+                "python",
+                join(deftRoot, "scripts", "swarm_readiness.py"),
+                storyPath,
+                "--project-root",
+                project,
+            ], deftRoot);
+            const ts = runCapture("node", [
+                join(deftRoot, "packages", "core", "dist", "swarm", "readiness-cli.js"),
+                storyPath,
+                "--project-root",
+                project,
+            ], deftRoot);
+            rmSync(project, { recursive: true, force: true });
+            return { python: py, ts };
+        },
+    },
+    {
+        name: "review-clean-cohort-clean",
+        run: (deftRoot) => {
+            const tmp = mkdtempSync(join(tmpdir(), "swarm-rc-"));
+            const fakeGh = setupFakeGh(tmp);
+            const env = {
+                ...process.env,
+                PATH: `${dirname(fakeGh)}:${process.env.PATH ?? ""}`,
+                DEFT_FAKE_GH_RESPONSES: JSON.stringify({
+                    "head-sha": { returncode: 0, stdout: `${HEAD_SHA}\n` },
+                    "comments-jq": { returncode: 0, stdout: cleanGreptileBody() },
+                }),
+            };
+            const argv = ["1370", "--repo", "deftai/directive"];
+            const py = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "swarm_verify_review_clean.py"), ...argv], deftRoot, env);
+            const ts = runCapture("node", [
+                join(deftRoot, "packages", "core", "dist", "swarm", "verify-review-clean-cli.js"),
+                ...argv,
+            ], deftRoot, env);
+            rmSync(tmp, { recursive: true, force: true });
+            return { python: py, ts };
+        },
+    },
+    {
+        name: "launch-manifest-solo",
+        run: (deftRoot) => {
+            const project = mkdtempSync(join(tmpdir(), "swarm-launch-"));
+            mkdirSync(join(project, "vbrief", "active"), { recursive: true });
+            writeReadyStory(project, "solo.vbrief.json", "solo-a", 8801);
+            writeProjectDef(project);
+            const env = { ...process.env, DEFT_PROBE_GROK_BUILD: "yes" };
+            const argv = ["--stories", "8801", "--project-root", project, "--autonomous"];
+            const py = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "swarm_launch.py"), ...argv], deftRoot, env);
+            const ts = runCapture("node", [join(deftRoot, "packages", "core", "dist", "swarm", "launch-cli.js"), ...argv], deftRoot, env);
+            rmSync(project, { recursive: true, force: true });
+            return { python: py, ts };
+        },
+    },
+];
+export function diffCase(name, python, ts) {
+    const pyStdout = normalizeOutput(python.stdout);
+    const tsStdout = normalizeOutput(ts.stdout);
+    const pyStderr = normalizeOutput(python.stderr);
+    const tsStderr = normalizeOutput(ts.stderr);
+    const exitMismatch = python.exitCode !== ts.exitCode;
+    const stdoutMismatch = pyStdout !== tsStdout;
+    const stderrMismatch = pyStderr !== tsStderr;
+    return {
+        name,
+        ok: !exitMismatch && !stdoutMismatch && !stderrMismatch,
+        exitMismatch,
+        stdoutMismatch,
+        stderrMismatch,
+    };
+}
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const cases = PARITY_CASES.map((c) => {
+        const { python, ts } = c.run(deftRoot);
+        return diffCase(c.name, python, ts);
+    });
+    return { ok: cases.every((c) => c.ok), cases };
+}
+export function runParityCli() {
+    try {
+        const result = runParity();
+        if (result.ok) {
+            process.stdout.write(`swarm parity: CLEAN -- Python and TS agree on ${result.cases.length} case(s).\n`);
+            return 0;
+        }
+        process.stderr.write("swarm parity: DIVERGENCE\n");
+        for (const c of result.cases) {
+            if (!c.ok) {
+                process.stderr.write(`  case: ${c.name}\n`);
+                if (c.exitMismatch) {
+                    process.stderr.write("    exit code mismatch\n");
+                }
+                if (c.stdoutMismatch) {
+                    process.stderr.write("    stdout mismatch\n");
+                }
+                if (c.stderrMismatch) {
+                    process.stderr.write("    stderr mismatch\n");
+                }
+            }
+        }
+        return 1;
+    }
+    catch (err) {
+        process.stderr.write(`swarm parity: harness error -- ${String(err)}\n`);
+        return 2;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(runParityCli());
+}
+//# sourceMappingURL=swarm-parity.js.map

package/dist/toolchain-check.d.ts

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

package/dist/toolchain-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { runToolchainCheck } from "@deftai/directive-core/verify-env";
+export function run() {
+    const result = runToolchainCheck();
+    for (const line of result.lines) {
+        process.stdout.write(`${line}\n`);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run());
+}
+//# sourceMappingURL=toolchain-check.js.map

package/dist/triage-actions-parity.d.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: readonly string[];
+}
+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[];
+}
+/** Strip volatile UUIDs and timestamps before compare. */
+export declare function normalizeOutput(text: string): string;
+/** Build a throwaway project root with an empty audit-log parent directory. */
+export declare function buildFixtureRepo(): string;
+/** Diff one parity case between Python oracle and TS CLI. */
+export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
+export declare const PARITY_CASES: readonly ParityCase[];
+/** Run all parity cases; returns aggregate result. */
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=triage-actions-parity.d.ts.map