open-multi-agent-kit 0.78.7 → 0.79.1

package/dist/commands/team.js

@@ -1,302 +0,0 @@
-import { runShell, checkCommand } from "../util/shell.js";
-import { getProjectRoot, getRunPath } from "../util/fs.js";
-import { style, header, status, bullet, label } from "../util/theme.js";
-import { getOmkResourceSettings } from "../util/resource-profile.js";
-import { t } from "../util/i18n.js";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { join } from "path";
-import { refreshRunStateEstimate } from "../orchestration/run-state.js";
-import { createInteractiveRunState as createParallelRunState } from "./parallel/orchestrator.js";
-import { ensureCompletionArtifactContract } from "../orchestration/completion-artifacts.js";
-import { createOmkJsonEnvelope } from "../util/json-envelope.js";
-import { emitJson } from "../util/cli-contract.js";
-/**
- * JSON path for `omk team --json`.
- * Read-only describe: reports the expected team layout for the resolved run
- * WITHOUT spawning or attaching tmux, so stdout stays exactly one
- * omk.contract.v1 envelope (no banner, no ANSI) and never blocks/exits.
- */
-async function emitTeamJson(options) {
-    const started = Date.now();
-    const root = getProjectRoot();
-    const resources = await getOmkResourceSettings();
-    const workerCount = normalizeWorkerCount(options.workers, resources.maxWorkers);
-    const runId = options.runId ?? `team-${new Date().toISOString().replace(/[:.]/g, "-")}`;
-    const statePath = getRunPath(runId, "state.json", root);
-    const expected = buildExpectedTeamRuntimeStatus("omk-team", statePath, workerCount, "starting");
-    const data = {
-        teamId: runId,
-        members: expected.windows.map((window) => ({
-            name: window.name,
-            role: window.role,
-            nodeId: window.nodeId,
-        })),
-        statePath,
-    };
-    emitJson(createOmkJsonEnvelope({
-        command: "team",
-        status: "passed",
-        ok: true,
-        runId,
-        data,
-        durationMs: Date.now() - started,
-    }));
-}
-export async function teamCommand(options = {}) {
-    if (options.json === true || process.argv.includes("--json")) {
-        await emitTeamJson(options);
-        return;
-    }
-    const root = getProjectRoot();
-    const resources = await getOmkResourceSettings();
-    const workerCount = normalizeWorkerCount(options.workers, resources.maxWorkers);
-    const runId = options.runId ?? `team-${new Date().toISOString().replace(/[:.]/g, "-")}`;
-    const tmuxExists = await checkCommand("tmux");
-    if (!tmuxExists) {
-        console.error(status.error(t("team.tmuxNotInstalled")));
-        console.error(style.gray(t("team.tmuxInstallHint")));
-        process.exit(1);
-    }
-    const session = "omk-team";
-    // Check if session already exists
-    const lsResult = await runShell("tmux", ["ls"], { timeout: 5000 });
-    const sessionExists = !lsResult.failed && lsResult.stdout.includes(session);
-    if (sessionExists) {
-        console.log(style.purpleBold(t("team.attachSession", session)));
-        const existingRunId = await getTeamRunId(session);
-        const existingWorkerCount = await getTeamWorkerCount(session) ?? workerCount;
-        await ensureCoordinatorHudPane(session, root, existingRunId ?? options.runId);
-        if (existingRunId) {
-            const existingStatePath = getRunPath(existingRunId, "state.json", root);
-            const runtime = await collectTeamRuntimeStatus(session, existingStatePath, existingWorkerCount, "attached");
-            await persistTeamRuntimeState(existingStatePath, runtime);
-            console.log(label("Runtime", formatTeamRuntimeSummary(runtime)));
-            console.log(label("State", existingStatePath));
-        }
-        console.log(style.gray(t("team.detachHint")));
-        await runShell("tmux", ["attach", "-t", session], { timeout: 0, stdio: "inherit" });
-        return;
-    }
-    console.log(header(t("team.createSession")));
-    console.log(label("Resource profile", `${resources.profile} (${resources.reason})`));
-    console.log(label("Worker windows", String(workerCount)) + "\n");
-    const statePath = await writeTeamRunState(root, runId, workerCount, "omk-team", resources.profile);
-    const teamEnv = {
-        OMK_RUN_ID: runId,
-        OMK_WORKERS: String(workerCount),
-        OMK_DAG_ROUTING: "1",
-        OMK_DAG_STATE_PATH: statePath,
-    };
-    // Create new session with a main window
-    const createResult = await runShell("tmux", ["new-session", "-d", "-s", session, "-n", "coordinator"], {
-        cwd: root,
-        env: teamEnv,
-        timeout: 10000,
-    });
-    if (createResult.failed) {
-        console.error(status.error(t("team.sessionCreateFailed")), createResult.stderr);
-        process.exit(1);
-    }
-    await setTeamEnvironment(session, teamEnv);
-    // Create additional windows for workers sequentially to avoid tmux session modification race conditions
-    for (let i = 1; i <= workerCount; i += 1) {
-        await runShell("tmux", ["new-window", "-t", `${session}:${i}`, "-n", `worker-${i}`], { env: teamEnv, timeout: 5000 });
-    }
-    await runShell("tmux", ["new-window", "-t", `${session}:${workerCount + 1}`, "-n", "reviewer"], { env: teamEnv, timeout: 5000 });
-    // Split coordinator window vertically and keep a live HUD visible on the right.
-    await ensureCoordinatorHudPane(session, root, runId);
-    const runtime = await collectTeamRuntimeStatus(session, statePath, workerCount, "ready");
-    await persistTeamRuntimeState(statePath, runtime);
-    console.log(status.ok(t("team.sessionReady")));
-    console.log(label("Runtime", formatTeamRuntimeSummary(runtime)));
-    console.log(label("State", statePath));
-    console.log(bullet(t("team.coordinator"), "purple"));
-    console.log(bullet(t("team.hudPane"), "blue"));
-    console.log(bullet(workerCount === 1 ? t("team.workerSingular") : t("team.workerPlural", workerCount), "mint"));
-    console.log(bullet(t("team.reviewer"), "pink"));
-    console.log("");
-    console.log(style.pinkBold(t("team.shortcuts")));
-    console.log(style.gray(t("team.switchWindows", workerCount + 1)));
-    console.log(style.gray(t("team.detachSession")));
-    console.log(style.gray(t("team.reconnect")));
-    console.log("");
-    console.log(style.purple(t("team.connecting")));
-    await runShell("tmux", ["attach", "-t", session], { timeout: 0, stdio: "inherit" });
-}
-function normalizeWorkerCount(value, fallback) {
-    if (!value || value === "auto")
-        return fallback;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed < 1)
-        return fallback;
-    return Math.min(parsed, 6);
-}
-async function setTeamEnvironment(session, env) {
-    for (const [key, value] of Object.entries(env)) {
-        await runShell("tmux", ["set-environment", "-t", session, key, value], { timeout: 5000 });
-    }
-}
-async function getTeamRunId(session) {
-    const result = await runShell("tmux", ["show-environment", "-t", session, "OMK_RUN_ID"], { timeout: 5000 });
-    if (result.failed)
-        return null;
-    const match = result.stdout.trim().match(/^OMK_RUN_ID=(.+)$/);
-    return match?.[1] ?? null;
-}
-async function getTeamWorkerCount(session) {
-    const result = await runShell("tmux", ["show-environment", "-t", session, "OMK_WORKERS"], { timeout: 5000 });
-    if (result.failed)
-        return null;
-    const match = result.stdout.trim().match(/^OMK_WORKERS=(\d+)$/);
-    if (!match)
-        return null;
-    const parsed = Number.parseInt(match[1], 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
-}
-async function ensureCoordinatorHudPane(session, root, runId) {
-    const windowTarget = `${session}:coordinator`;
-    const panes = await runShell("tmux", ["list-panes", "-t", windowTarget, "-F", "#{pane_title}"], { timeout: 5000 });
-    if (!panes.failed && panes.stdout.split(/\r?\n/).some((title) => title.trim() === "omk-hud")) {
-        return;
-    }
-    const split = await runShell("tmux", ["split-window", "-h", "-P", "-F", "#{pane_id}", "-c", root, "-t", windowTarget], { timeout: 5000 });
-    if (split.failed) {
-        console.error(status.warn(t("team.hudPanelFailed")), split.stderr);
-        return;
-    }
-    const paneId = split.stdout.trim();
-    if (!paneId)
-        return;
-    await runShell("tmux", ["select-pane", "-t", paneId, "-T", "omk-hud"], { timeout: 5000 });
-    await runShell("tmux", ["send-keys", "-t", paneId, buildHudPaneCommand(runId), "C-m"], { timeout: 5000 });
-    await runShell("tmux", ["select-layout", "-t", windowTarget, "main-vertical"], { timeout: 5000 });
-    await runShell("tmux", ["select-pane", "-t", `${windowTarget}.0`], { timeout: 5000 });
-}
-function buildHudPaneCommand(runId) {
-    const cli = currentCliInvocation();
-    const runArg = runId ? `--run-id ${shellQuote(runId)} ` : "";
-    return [
-        "printf '\\033]2;omk HUD\\007'",
-        `${cli} ${runArg}hud --watch --refresh 2000`,
-    ].join("; ");
-}
-function currentCliInvocation() {
-    const entry = process.argv[1];
-    if (!entry)
-        return "omk";
-    if (entry.endsWith(".ts")) {
-        return `npx tsx ${shellQuote(entry)}`;
-    }
-    return `${shellQuote(process.execPath)} ${shellQuote(entry)}`;
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
-export async function writeTeamRunState(root, runId, workerCount, session = "omk-team", profile = "standard") {
-    const startedAt = new Date().toISOString();
-    const runDir = join(root, ".omk", "runs", runId);
-    const statePath = join(runDir, "state.json");
-    const state = createParallelRunState({
-        runId,
-        flow: "team",
-        goal: "Coordinate tmux team run and manage parallel worker lanes toward the active goal",
-        workerCount,
-        startedAt,
-        approvalPolicy: "ask",
-        profile,
-        executionStrategy: "parallel",
-    });
-    state.teamRuntime = buildExpectedTeamRuntimeStatus(session, statePath, workerCount, "starting");
-    state.updatedAt = startedAt;
-    state.lastActivityAt = startedAt;
-    refreshRunStateEstimate(state, workerCount);
-    await ensureCompletionArtifactContract(root, runId);
-    await mkdir(runDir, { recursive: true });
-    await writeFile(join(runDir, "goal.md"), "# Goal\n\nCoordinate tmux team run and manage parallel worker lanes toward the active goal.\n", "utf-8");
-    await writeFile(join(runDir, "plan.md"), `# Plan\n\nFlow: team\nWorkers: ${workerCount}\nResource profile: ${profile}\nCapability assignment: goal-scoped MCP/skills/hooks per worker lane\nExecution strategy: parallel\n`, "utf-8");
-    await writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
-    return statePath;
-}
-export function buildExpectedTeamRuntimeStatus(session, statePath, workerCount, runtimeStatus, presentWindows = new Map()) {
-    const windows = [
-        {
-            index: 0,
-            name: "coordinator",
-            role: "coordinator",
-            nodeId: "root-coordinator",
-            status: presentWindows.has("coordinator") ? "present" : "expected",
-            paneCount: presentWindows.get("coordinator"),
-        },
-        ...Array.from({ length: workerCount }, (_, index) => {
-            const name = `worker-${index + 1}`;
-            return {
-                index: index + 1,
-                name,
-                role: "worker",
-                nodeId: name,
-                status: presentWindows.has(name) ? "present" : "expected",
-                paneCount: presentWindows.get(name),
-            };
-        }),
-        {
-            index: workerCount + 1,
-            name: "reviewer",
-            role: "reviewer",
-            nodeId: "review-merge",
-            status: presentWindows.has("reviewer") ? "present" : "expected",
-            paneCount: presentWindows.get("reviewer"),
-        },
-    ];
-    return {
-        session,
-        status: runtimeStatus,
-        workerCount,
-        reviewerCount: 1,
-        coordinatorPanes: presentWindows.get("coordinator") ?? 0,
-        statePath,
-        windows,
-        updatedAt: new Date().toISOString(),
-    };
-}
-async function collectTeamRuntimeStatus(session, statePath, workerCount, runtimeStatus) {
-    const windows = await runShell("tmux", ["list-windows", "-t", session, "-F", "#{window_index}\t#{window_name}\t#{window_panes}"], { timeout: 5000 });
-    if (windows.failed) {
-        const missing = buildExpectedTeamRuntimeStatus(session, statePath, workerCount, "missing");
-        missing.windows = missing.windows.map((window) => ({ ...window, status: "missing" }));
-        return missing;
-    }
-    const present = new Map();
-    for (const line of windows.stdout.split(/\r?\n/)) {
-        const [indexRaw, name, panesRaw] = line.split("\t");
-        if (!name)
-            continue;
-        const paneCount = Number.parseInt(panesRaw ?? "", 10);
-        present.set(name.trim(), Number.isFinite(paneCount) ? paneCount : Number.parseInt(indexRaw ?? "", 10));
-    }
-    const runtime = buildExpectedTeamRuntimeStatus(session, statePath, workerCount, runtimeStatus, present);
-    runtime.windows = runtime.windows.map((window) => ({
-        ...window,
-        status: present.has(window.name) ? "present" : "missing",
-    }));
-    runtime.coordinatorPanes = present.get("coordinator") ?? 0;
-    runtime.status = runtime.windows.some((window) => window.status === "missing") ? "missing" : runtimeStatus;
-    runtime.updatedAt = new Date().toISOString();
-    return runtime;
-}
-async function persistTeamRuntimeState(statePath, runtime) {
-    try {
-        const state = JSON.parse(await readFile(statePath, "utf-8"));
-        state.teamRuntime = runtime;
-        state.updatedAt = runtime.updatedAt;
-        await writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
-    }
-    catch {
-        // Team/HUD startup should not fail solely because a legacy state file is absent or corrupt.
-    }
-}
-function formatTeamRuntimeSummary(runtime) {
-    const present = runtime.windows.filter((window) => window.status === "present").length;
-    const missing = runtime.windows.filter((window) => window.status === "missing").length;
-    const suffix = missing > 0 ? `, ${missing} missing` : "";
-    return `${runtime.status}: ${present}/${runtime.windows.length} windows, ${runtime.coordinatorPanes} coordinator pane(s)${suffix}`;
-}

package/dist/commands/verify.d.ts

@@ -1,4 +0,0 @@
-export declare function verifyCommand(options?: {
-    run?: string;
-    json?: boolean;
-}): Promise<void>;

package/dist/commands/verify.js

@@ -1,320 +0,0 @@
-import { join } from "path";
-import { style, status } from "../util/theme.js";
-import { NotFoundError, emitError, VerificationError } from "../util/cli-contract.js";
-import { getProjectRoot, pathExists, getRunsDir, getRunPath } from "../util/fs.js";
-import { readFile, writeFile } from "fs/promises";
-import { createStatePersister } from "../orchestration/state-persister.js";
-import { checkEvidenceGates } from "../orchestration/evidence-gate.js";
-import { captureGitDiffArtifacts, ensureCompletionArtifactContract, getCompletionArtifactStatus, writeTestEvidenceLog, } from "../orchestration/completion-artifacts.js";
-const SCHEMA_VERSION = 1;
-export async function verifyCommand(options = {}) {
-    const root = getProjectRoot();
-    const runId = options.run ?? process.env.OMK_RUN_ID;
-    if (!runId) {
-        const msg = "No run ID specified. Use --run <id> or set OMK_RUN_ID.";
-        emitError(msg, Boolean(options.json));
-        throw new NotFoundError(msg);
-    }
-    const persister = createStatePersister(getRunsDir(root));
-    const state = await persister.load(runId);
-    if (!state) {
-        const msg = `Run not found: ${runId}`;
-        emitError(msg, Boolean(options.json));
-        throw new NotFoundError(msg);
-    }
-    await ensureCompletionArtifactContract(root, runId);
-    if (!options.json && state.schemaVersion !== 1) {
-        console.warn(status.warn(`Run state schemaVersion is missing or outdated for ${runId}. Continuing with verification.`));
-    }
-    const gates = [];
-    const evidence = [];
-    const passed = [];
-    const failed = [];
-    const missing = [];
-    for (const node of state.nodes) {
-        if (node.status !== "done") {
-            missing.push({
-                nodeId: node.id,
-                message: `Node "${node.id}" is not done (status: ${node.status})`,
-            });
-            continue;
-        }
-        if (!node.outputs || node.outputs.length === 0) {
-            missing.push({
-                nodeId: node.id,
-                message: `Node "${node.id}" has no declared outputs`,
-            });
-            continue;
-        }
-        const nodeGates = [];
-        for (const output of node.outputs) {
-            switch (output.gate) {
-                case "file-exists": {
-                    if (!output.ref) {
-                        missing.push({
-                            nodeId: node.id,
-                            gate: output.gate,
-                            message: `Node "${node.id}" file-exists gate is missing a ref/path`,
-                        });
-                    }
-                    else {
-                        nodeGates.push({ type: "file-exists", path: output.ref });
-                        gates.push({ nodeId: node.id, type: "file-exists", ref: output.ref });
-                    }
-                    break;
-                }
-                case "test-pass": {
-                    const command = output.ref ?? "npm test";
-                    nodeGates.push({ type: "command-pass", command });
-                    gates.push({ nodeId: node.id, type: "command-pass", ref: command });
-                    break;
-                }
-                case "review-pass":
-                case "summary": {
-                    const marker = output.ref ?? "## Summary";
-                    nodeGates.push({ type: "summary-present", summaryMarker: marker });
-                    gates.push({ nodeId: node.id, type: "summary-present", ref: marker });
-                    break;
-                }
-                default:
-                    missing.push({
-                        nodeId: node.id,
-                        gate: output.gate,
-                        message: `Node "${node.id}" has unrecognized gate type: ${output.gate}`,
-                    });
-            }
-        }
-        if (nodeGates.length === 0) {
-            continue;
-        }
-        const result = await checkEvidenceGates(nodeGates, {
-            cwd: root,
-            stdout: await loadNodeStdout(root, runId, node.id),
-            nodeId: node.id,
-        });
-        for (const ev of result.evidence) {
-            const item = {
-                nodeId: node.id,
-                gate: ev.gate,
-                ref: ev.ref,
-                passed: ev.passed,
-                message: ev.message ?? "",
-            };
-            evidence.push(item);
-            if (ev.passed) {
-                passed.push(item);
-            }
-            else {
-                failed.push(item);
-            }
-        }
-    }
-    // Emit human-readable messages for missing / corrupt evidence to stderr
-    for (const m of missing) {
-        const humanMsg = `Missing evidence: ${m.message}`;
-        if (options.json) {
-            console.error(humanMsg);
-        }
-        else {
-            console.error(status.error(humanMsg));
-        }
-    }
-    for (const f of failed) {
-        if (f.message.includes("does not exist") ||
-            f.message.includes("missing") ||
-            f.message.includes("execution failed") ||
-            f.message.includes("failed with exit code")) {
-            const humanMsg = `Corrupt evidence: ${f.nodeId}: ${f.gate}${f.ref ? ` (${f.ref})` : ""} — ${f.message}`;
-            if (options.json) {
-                console.error(humanMsg);
-            }
-            else {
-                console.error(status.error(humanMsg));
-            }
-        }
-    }
-    // Goal-level evidence
-    let goalEvidence = [];
-    let goalScore;
-    if (state.goalId) {
-        try {
-            const { createGoalPersister } = await import("../goal/persistence.js");
-            const goalPersister = createGoalPersister(join(root, ".omk", "goals"));
-            const goalSpec = await goalPersister.load(state.goalId);
-            if (goalSpec) {
-                const { checkGoalEvidence } = await import("../goal/evidence.js");
-                const { scoreGoal } = await import("../goal/scoring.js");
-                const ge = await checkGoalEvidence(goalSpec, { root, runState: state });
-                goalEvidence = ge.map((e) => ({
-                    criterionId: e.criterionId,
-                    passed: e.passed,
-                    message: e.message,
-                    ref: e.ref,
-                }));
-                goalScore = scoreGoal(goalSpec, ge);
-            }
-        }
-        catch {
-            // ignore goal verification errors
-        }
-    }
-    await captureGitDiffArtifacts(root, runId);
-    const commandEvidence = evidence.filter((item) => item.gate === "command-pass");
-    await writeTestEvidenceLog(root, runId, commandEvidence.length > 0
-        ? commandEvidence.map((item) => `${item.nodeId}: ${item.ref ?? item.gate} => ${item.passed ? "pass" : "fail"} :: ${item.message}`)
-        : ["No command-pass evidence captured for this run."]);
-    const provisionalArtifactStatus = await getCompletionArtifactStatus(root, runId);
-    const artifactMissingMessages = [
-        ...provisionalArtifactStatus.missing.filter((entry) => entry !== "result json missing"),
-        ...(commandEvidence.length === 0 ? ["test evidence missing: no command-pass gate was captured"] : []),
-    ];
-    const artifactMissing = artifactMissingMessages.map((message) => ({
-        nodeId: "run-artifacts",
-        message,
-    }));
-    const errors = [
-        ...failed.map((f) => `${f.nodeId}: ${f.gate}${f.ref ? ` (${f.ref})` : ""} — ${f.message}`),
-        ...missing.map((m) => m.message),
-        ...artifactMissing.map((m) => m.message),
-    ];
-    const output = {
-        ok: errors.length === 0,
-        command: "verify",
-        checkedAt: new Date().toISOString(),
-        errors,
-        warnings: [],
-        runId,
-        schemaVersion: SCHEMA_VERSION,
-        gates,
-        evidence,
-        passed,
-        failed,
-        missing: [...missing, ...artifactMissing],
-        data: {
-            runId,
-            gates: gates.length,
-            passed: passed.length,
-            failed: failed.length,
-            missing: missing.length + artifactMissing.length,
-        },
-        artifacts: {
-            ...provisionalArtifactStatus.paths,
-        },
-    };
-    if (goalEvidence.length > 0) {
-        output.goalEvidence = goalEvidence;
-        output.goalScore = goalScore;
-    }
-    await writeFile(output.artifacts.verifyJson, `${JSON.stringify(output, null, 2)}\n`, "utf-8");
-    await writeFile(output.artifacts.resultJson, `${JSON.stringify({
-        ok: output.ok,
-        runId,
-        checkedAt: output.checkedAt,
-        artifacts: {
-            diffPatch: output.artifacts.diffPatch,
-            diffStat: output.artifacts.diffStat,
-            testLog: output.artifacts.testLog,
-            runLog: output.artifacts.runLog,
-            verifyJson: output.artifacts.verifyJson,
-            evidenceJson: output.artifacts.evidenceJson,
-        },
-        errors,
-    }, null, 2)}\n`, "utf-8");
-    const artifactStatus = await getCompletionArtifactStatus(root, runId);
-    const artifactErrors = artifactStatus.missing.filter((entry) => !errors.includes(entry));
-    const finalOutput = {
-        ...output,
-        ok: output.ok && artifactStatus.ok,
-        errors: [...errors, ...artifactErrors],
-    };
-    if (options.json) {
-        console.log(JSON.stringify(finalOutput, null, 2));
-    }
-    else {
-        console.log("");
-        for (const ev of evidence) {
-            const icon = ev.passed ? "✓" : "✗";
-            const color = ev.passed ? style.mint : style.pink;
-            console.log(color(`  ${icon} ${ev.nodeId}: ${ev.gate}${ev.ref ? ` (${ev.ref})` : ""} — ${ev.message}`));
-        }
-        if (artifactMissing.length > 0) {
-            console.log("");
-            for (const item of artifactMissing) {
-                console.log(style.pink(`  ✗ ${item.nodeId}: ${item.message}`));
-            }
-        }
-        console.log("");
-        console.log(style.mint(`Passed: ${passed.length}`));
-        if (failed.length > 0)
-            console.log(style.pink(`Failed: ${failed.length}`));
-        if (finalOutput.missing.length > 0)
-            console.log(style.pink(`Missing: ${finalOutput.missing.length}`));
-        if (goalScore) {
-            console.log("");
-            console.log(style.purpleBold("Goal Score"));
-            console.log(`  ${style.gray("Overall:")} ${goalScore.overall === "pass" ? style.mint("pass") : style.pink(goalScore.overall)}`);
-            console.log(`  ${style.gray("Required:")} ${goalScore.requiredPassed}/${goalScore.requiredTotal}`);
-            if (goalScore.optionalScore > 0) {
-                console.log(`  ${style.gray("Optional:")} ${goalScore.optionalScore}`);
-            }
-            if (goalEvidence.length > 0) {
-                console.log("");
-                console.log(style.purpleBold("Goal Evidence"));
-                for (const ev of goalEvidence) {
-                    const icon = ev.passed ? style.mint("✓") : style.pink("✗");
-                    console.log(`  ${icon} ${ev.criterionId}: ${ev.message ?? ""}`);
-                }
-            }
-        }
-    }
-    const nodeFailed = failed.length > 0 || missing.length > 0;
-    const artifactFailed = finalOutput.errors.length > 0;
-    const goalFailed = goalScore ? goalScore.overall === "fail" : false;
-    if (nodeFailed || artifactFailed || goalFailed) {
-        throw new VerificationError("Verification failed", [
-            ...(nodeFailed ? [`${failed.length} failed gates, ${missing.length} missing`] : []),
-            ...(artifactFailed ? ["required diff/test/log/result artifacts missing or incomplete"] : []),
-            ...(goalFailed ? ["goal score: fail"] : []),
-        ]);
-    }
-    await saveEvidenceJson(root, runId, {
-        gates,
-        evidence,
-        passed,
-        failed,
-        missing: [...missing, ...artifactMissing],
-        goalEvidence: goalEvidence.map((e) => ({ ...e, message: e.message ?? "" })),
-        goalScore: goalScore ?? null,
-    });
-}
-async function loadNodeStdout(root, runId, nodeId) {
-    const logPath = getRunPath(runId, `${nodeId}.log`, root);
-    if (await pathExists(logPath)) {
-        return await readFile(logPath, "utf-8");
-    }
-    const summaryPath = getRunPath(runId, "summary.md", root);
-    if (await pathExists(summaryPath)) {
-        return await readFile(summaryPath, "utf-8");
-    }
-    return "";
-}
-async function saveEvidenceJson(root, runId, data) {
-    try {
-        const evidencePath = getRunPath(runId, "evidence.json", root);
-        await writeFile(evidencePath, JSON.stringify({
-            schemaVersion: SCHEMA_VERSION,
-            runId,
-            checkedAt: new Date().toISOString(),
-            gates: data.gates,
-            evidence: data.evidence,
-            passed: data.passed.length,
-            failed: data.failed.length,
-            missing: data.missing.length,
-            goalEvidence: data.goalEvidence,
-            goalScore: data.goalScore,
-        }, null, 2));
-    }
-    catch {
-        // non-fatal
-    }
-}

package/dist/commands/version.d.ts

@@ -1,6 +0,0 @@
-import type { VersionReport } from "../contracts/index.js";
-export type VersionCommandOptions = {
-    json?: boolean;
-};
-export declare function buildVersionReport(): VersionReport;
-export declare function versionCommand(options?: VersionCommandOptions): Promise<void>;