open-multi-agent-kit 0.78.0 → 0.78.1

package/dist/commands/dag-from-spec.js

@@ -3,7 +3,9 @@ import { join } from "path";
 import { writeFile, mkdir } from "fs/promises";
 import { getProjectRoot, pathExists, getRunPath, getRunsDir } from "../util/fs.js";
 import { header, label } from "../util/theme.js";
-import { createDag } from "../orchestration/dag.js";
+import { createDag, getExecutionWaves } from "../orchestration/dag.js";
+import { createOmkJsonEnvelope } from "../util/json-envelope.js";
+import { emitJson } from "../util/cli-contract.js";
 function inferRole(description, explicitRole) {
     if (explicitRole)
         return explicitRole;
@@ -243,6 +245,61 @@ export async function loadSpecDag(specDir, options = {}) {
     }
     return tasksToDag(tasks, { parallel: options.parallel });
 }
+/**
+ * Project the in-memory DAG artifact into the envelope `data` shape. The inner
+ * dag artifact (nodes) is preserved verbatim; edges/batches/stats are derived
+ * from the existing dependsOn graph (no new data sources).
+ */
+function buildDagJsonData(inputId, dag) {
+    const edges = dag.nodes.flatMap((node) => node.dependsOn.map((from) => ({ from, to: node.id })));
+    const batches = getExecutionWaves(dag).map((wave) => wave.map((node) => node.id));
+    return {
+        inputId,
+        nodes: dag.nodes,
+        edges,
+        batches,
+        stats: { nodes: dag.nodes.length, edges: edges.length, batches: batches.length },
+    };
+}
+/**
+ * JSON path for `omk dag from-spec --json`.
+ * Emits EXACTLY ONE omk.contract.v1 envelope to stdout (no banner, no ANSI) and
+ * never throws on a missing/empty tasks.md, so JSON stdout stays one envelope.
+ */
+async function emitDagFromSpecJson(targetDir, options) {
+    const started = Date.now();
+    let dag;
+    try {
+        dag = await loadSpecDag(targetDir, { parallel: options.parallel });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const empty = { nodes: [] };
+        emitJson(createOmkJsonEnvelope({
+            command: "dag",
+            status: "not-applicable",
+            ok: false,
+            data: buildDagJsonData(targetDir, empty),
+            warnings: [
+                { code: "RUN_ARTIFACT_MISSING", message, recoverable: true, severity: "warning" },
+            ],
+            durationMs: Date.now() - started,
+        }));
+        return empty;
+    }
+    if (options.output) {
+        await mkdir(getRunsDir(getProjectRoot()), { recursive: true });
+        await writeFile(options.output, JSON.stringify(dag, null, 2));
+    }
+    emitJson(createOmkJsonEnvelope({
+        command: "dag",
+        status: "passed",
+        ok: true,
+        data: buildDagJsonData(targetDir, dag),
+        durationMs: Date.now() - started,
+    }));
+    return dag;
+}
 export async function dagFromSpecCommand(specDir, options = {}) {
     const root = getProjectRoot();
     let targetDir = specDir;
@@ -266,6 +323,9 @@ export async function dagFromSpecCommand(specDir, options = {}) {
             targetDir = getRunPath(options.run, undefined, root);
         }
     }
+    if (options.json === true || process.argv.includes("--json")) {
+        return emitDagFromSpecJson(targetDir, { output: options.output, parallel: options.parallel });
+    }
     const dag = await loadSpecDag(targetDir, { parallel: options.parallel });
     const dagJson = JSON.stringify(dag, null, 2);
     if (options.output) {

package/dist/commands/graph.d.ts

@@ -1,3 +1,5 @@
+import type { RunManifest } from "../contracts/run.js";
+import type { GraphState } from "../memory/local-graph-memory-store.js";
 export interface GraphViewCommandOptions {
     input?: string;
     output?: string;
@@ -7,3 +9,63 @@ export interface GraphViewCommandOptions {
     open?: boolean;
 }
 export declare function graphViewCommand(options?: GraphViewCommandOptions): Promise<void>;
+export type GraphAuditVerdict = "passed" | "partial" | "failed";
+export interface GraphAuditCounts {
+    providerRoute: number;
+    provider: number;
+    evidence: number;
+    decision: number;
+    artifact: number;
+}
+export interface GraphAuditMismatch {
+    field: string;
+    graph: number | string | null;
+    manifest: number | string | null;
+}
+export interface GraphAuditDangler {
+    edgeId: string;
+    type: string;
+    from: string;
+    to: string;
+    missing: "from" | "to";
+}
+export interface GraphAuditRunResult {
+    runId: string;
+    runNodeFound: boolean;
+    orphan: boolean;
+    manifestPresent: boolean;
+    counts: GraphAuditCounts;
+    mismatches: GraphAuditMismatch[];
+    danglers: GraphAuditDangler[];
+    verdict: GraphAuditVerdict;
+    notes: string[];
+}
+export interface GraphAuditReport {
+    schemaVersion: "omk.graph-audit.v1";
+    verdict: GraphAuditVerdict;
+    statePath?: string;
+    generatedAt: string;
+    summary: {
+        total: number;
+        passed: number;
+        partial: number;
+        failed: number;
+    };
+    runs: GraphAuditRunResult[];
+}
+export interface GraphAuditCommandOptions {
+    run?: string;
+    input?: string;
+    json?: boolean;
+}
+/**
+ * Pure auditor: cross-checks linked run subgraphs against their manifests.
+ * For each run it asserts the Run node exists with >=1 provider-route, provider,
+ * evidence, decision, and artifact edge, cross-checks evidence counts/artifact
+ * counts/status against the manifest, and flags orphan runs and dangling edges.
+ */
+export declare function auditGraphRuns(state: GraphState, entries: ReadonlyArray<{
+    runId: string;
+    manifest?: RunManifest | null;
+}>, statePath?: string): GraphAuditReport;
+export declare function graphAuditCommand(options?: GraphAuditCommandOptions): Promise<void>;

package/dist/commands/graph.js

@@ -1,7 +1,11 @@
+import { readFile } from "fs/promises";
 import { join, resolve } from "path";
 import { getProjectRoot } from "../util/fs.js";
 import { createGraphView } from "../memory/graph-viewer.js";
 import { header, label, status } from "../util/theme.js";
+import { createOmkJsonEnvelope } from "../util/json-envelope.js";
+import { getRunArtifactPath, listValidRunIds, validateRunId } from "../util/run-store.js";
+import { RunManifestSchema } from "../schema/run-manifest.schema.js";
 export async function graphViewCommand(options = {}) {
     const root = getProjectRoot();
     const inputPath = options.input ? resolve(root, options.input) : join(root, ".omk", "memory", "graph-state.json");
@@ -24,3 +28,181 @@ export async function graphViewCommand(options = {}) {
     console.log(label("Edges", String(result.edgeCount)));
     console.log(status.ok("Graph HTML generated"));
 }
+const EVIDENCE_SUMMARY_FIELDS = ["required", "passed", "failed", "missing"];
+/**
+ * Pure auditor: cross-checks linked run subgraphs against their manifests.
+ * For each run it asserts the Run node exists with >=1 provider-route, provider,
+ * evidence, decision, and artifact edge, cross-checks evidence counts/artifact
+ * counts/status against the manifest, and flags orphan runs and dangling edges.
+ */
+export function auditGraphRuns(state, entries, statePath) {
+    const nodeIds = new Set(state.nodes.map((node) => node.id));
+    const runs = entries.map((entry) => auditSingleRun(state, nodeIds, entry.runId, entry.manifest ?? null));
+    const summary = { total: runs.length, passed: 0, partial: 0, failed: 0 };
+    for (const run of runs)
+        summary[run.verdict] += 1;
+    const verdict = summary.failed > 0 ? "failed" : summary.partial > 0 ? "partial" : "passed";
+    return {
+        schemaVersion: "omk.graph-audit.v1",
+        verdict,
+        statePath,
+        generatedAt: new Date().toISOString(),
+        summary,
+        runs,
+    };
+}
+function auditSingleRun(state, nodeIds, runId, manifest) {
+    const notes = [];
+    const mismatches = [];
+    const danglers = [];
+    const counts = { providerRoute: 0, provider: 0, evidence: 0, decision: 0, artifact: 0 };
+    const manifestPresent = manifest !== null;
+    const runNode = state.nodes.find((node) => node.type === "Run" && node.properties.runId === runId);
+    if (!runNode) {
+        notes.push("run node not found in graph");
+        if (!manifestPresent)
+            notes.push("run-manifest.json not found");
+        return { runId, runNodeFound: false, orphan: false, manifestPresent, counts, mismatches, danglers, verdict: "failed", notes };
+    }
+    const outgoing = state.edges.filter((edge) => edge.from === runNode.id);
+    const routeEdges = outgoing.filter((edge) => edge.type === "HAS_PROVIDER_ROUTE");
+    counts.providerRoute = routeEdges.length;
+    counts.evidence = outgoing.filter((edge) => edge.type === "HAS_EVIDENCE").length;
+    counts.decision = outgoing.filter((edge) => edge.type === "HAS_DECISION").length;
+    counts.artifact = outgoing.filter((edge) => edge.type === "TOUCHES_FILE").length;
+    const routeToEdges = routeEdges.flatMap((routeEdge) => state.edges.filter((edge) => edge.from === routeEdge.to && edge.type === "ROUTES_TO"));
+    counts.provider = routeToEdges.length;
+    const orphan = outgoing.length === 0;
+    // Dangler detection across the run subgraph (run edges + route ROUTES_TO).
+    for (const edge of [...outgoing, ...routeToEdges]) {
+        if (!nodeIds.has(edge.from))
+            danglers.push({ edgeId: edge.id, type: edge.type, from: edge.from, to: edge.to, missing: "from" });
+        if (!nodeIds.has(edge.to))
+            danglers.push({ edgeId: edge.id, type: edge.type, from: edge.from, to: edge.to, missing: "to" });
+    }
+    if (manifest) {
+        const evidenceNode = outgoing
+            .filter((edge) => edge.type === "HAS_EVIDENCE")
+            .map((edge) => state.nodes.find((node) => node.id === edge.to))
+            .find((node) => node !== undefined);
+        if (evidenceNode) {
+            for (const field of EVIDENCE_SUMMARY_FIELDS) {
+                const graphValue = Number(evidenceNode.properties[field] ?? Number.NaN);
+                const manifestValue = manifest.evidenceSummary[field];
+                if (graphValue !== manifestValue) {
+                    mismatches.push({ field: `evidence.${field}`, graph: Number.isNaN(graphValue) ? null : graphValue, manifest: manifestValue });
+                }
+            }
+        }
+        else {
+            notes.push("evidence node missing for cross-check");
+        }
+        if (counts.artifact !== manifest.artifacts.length) {
+            mismatches.push({ field: "artifact.count", graph: counts.artifact, manifest: manifest.artifacts.length });
+        }
+        const graphStatus = String(runNode.properties.status ?? "");
+        if (graphStatus !== manifest.status) {
+            mismatches.push({ field: "run.status", graph: graphStatus, manifest: manifest.status });
+        }
+    }
+    else {
+        notes.push("run-manifest.json not found; structural audit only");
+    }
+    const hasAllEdges = counts.providerRoute >= 1 &&
+        counts.provider >= 1 &&
+        counts.evidence >= 1 &&
+        counts.decision >= 1 &&
+        counts.artifact >= 1;
+    let verdict;
+    if (orphan || !hasAllEdges)
+        verdict = "failed";
+    else if (danglers.length > 0 || mismatches.length > 0 || !manifestPresent)
+        verdict = "partial";
+    else
+        verdict = "passed";
+    return { runId, runNodeFound: true, orphan, manifestPresent, counts, mismatches, danglers, verdict, notes };
+}
+async function loadGraphStateForAudit(statePath) {
+    try {
+        const raw = await readFile(statePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed.nodes) && Array.isArray(parsed.edges)) {
+            return { ...parsed, nodes: parsed.nodes, edges: parsed.edges };
+        }
+    }
+    catch {
+        // fall through to an empty state
+    }
+    return {
+        version: 1,
+        ontology: { version: "", classes: [], relationTypes: [], description: "" },
+        project: { key: "", name: "", root: "" },
+        updatedAt: new Date().toISOString(),
+        nodes: [],
+        edges: [],
+    };
+}
+async function loadRunManifestForAudit(runId, root) {
+    try {
+        const raw = await readFile(getRunArtifactPath(runId, "run-manifest.json", root), "utf-8");
+        const parsed = RunManifestSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function graphAuditCommand(options = {}) {
+    const startedAt = Date.now();
+    const root = getProjectRoot();
+    const statePath = options.input ? resolve(root, options.input) : join(root, ".omk", "memory", "graph-state.json");
+    const state = await loadGraphStateForAudit(statePath);
+    const runIds = options.run ? [validateRunId(options.run)] : await listValidRunIds(root);
+    const entries = [];
+    for (const runId of runIds) {
+        entries.push({ runId, manifest: await loadRunManifestForAudit(runId, root) });
+    }
+    const report = auditGraphRuns(state, entries, statePath);
+    if (options.json) {
+        console.log(JSON.stringify(createOmkJsonEnvelope({
+            command: "graph",
+            status: report.verdict,
+            data: report,
+            durationMs: Date.now() - startedAt,
+        })));
+        return;
+    }
+    printGraphAuditReport(report);
+    if (report.verdict === "failed")
+        process.exitCode = 1;
+}
+function printGraphAuditReport(report) {
+    console.log(header("OMK Graph Audit"));
+    if (report.statePath)
+        console.log(label("State", report.statePath));
+    console.log(label("Runs", `${report.summary.total} (passed ${report.summary.passed}, partial ${report.summary.partial}, failed ${report.summary.failed})`));
+    for (const run of report.runs) {
+        const line = `${run.runId} — routes ${run.counts.providerRoute}/providers ${run.counts.provider}/evidence ${run.counts.evidence}/decisions ${run.counts.decision}/artifacts ${run.counts.artifact}`;
+        if (run.verdict === "passed")
+            console.log(status.ok(line));
+        else if (run.verdict === "partial")
+            console.log(status.warn(line));
+        else
+            console.log(status.fail(line));
+        for (const mismatch of run.mismatches) {
+            console.log(label("  mismatch", `${mismatch.field}: graph=${String(mismatch.graph)} manifest=${String(mismatch.manifest)}`));
+        }
+        for (const dangler of run.danglers) {
+            console.log(label("  dangler", `${dangler.type} missing ${dangler.missing} (${dangler.from} -> ${dangler.to})`));
+        }
+        for (const note of run.notes)
+            console.log(label("  note", note));
+    }
+    const verdictLine = `Verdict: ${report.verdict}`;
+    if (report.verdict === "passed")
+        console.log(status.ok(verdictLine));
+    else if (report.verdict === "partial")
+        console.log(status.warn(verdictLine));
+    else
+        console.log(status.fail(verdictLine));
+}

package/dist/commands/merge.d.ts

@@ -3,6 +3,7 @@ interface MergeOptions {
     runId?: string;
     strategy?: string;
     dryRun?: boolean;
+    json?: boolean;
 }
 export declare function mergeCommand(options: MergeOptions): Promise<void>;
 export {};

package/dist/commands/merge.js

@@ -9,7 +9,95 @@ import { runQualityGate } from "../mcp/quality-gate.js";
 import { readTextFile } from "../util/fs.js";
 import { getOmkResourceSettings } from "../util/resource-profile.js";
 import { defaultScopedRoleAgentFile, writeScopedAgentFile } from "../util/scoped-agent-file.js";
+import { createOmkJsonEnvelope } from "../util/json-envelope.js";
+import { emitJson } from "../util/cli-contract.js";
+/**
+ * JSON path for `omk merge --json`.
+ * Read-only preview: resolves the run, collects worktree diffs (git diff +
+ * `git apply --check`) and selects a winner by strategy, but does NOT run the
+ * reviewer, tests, patch apply, or quality gate. Emits exactly one
+ * omk.contract.v1 envelope (no banner, no ANSI) and never calls process.exit.
+ */
+async function emitMergeJson(options) {
+    const started = Date.now();
+    const root = getProjectRoot();
+    const strategy = (options.strategy ?? "first").trim().toLowerCase();
+    const dryRun = Boolean(options.dryRun);
+    const emitNotApplicable = (runId, code, message) => {
+        emitJson(createOmkJsonEnvelope({
+            command: "merge",
+            status: "not-applicable",
+            ok: false,
+            ...(runId ? { runId } : {}),
+            data: { runId, strategy, dryRun, merged: null, conflicts: [], applied: 0 },
+            warnings: [{ code, message, recoverable: true, severity: "warning" }],
+            durationMs: Date.now() - started,
+        }));
+    };
+    if (!(await isGitRepo())) {
+        emitNotApplicable(null, "INTERNAL_ERROR", "Not a git repository.");
+        return;
+    }
+    const runsDir = getOmkPath("runs");
+    if (!(await pathExists(runsDir))) {
+        emitNotApplicable(null, "RUN_ARTIFACT_MISSING", "No runs found.");
+        return;
+    }
+    let runId = options.run ?? options.runId ?? "latest";
+    if (runId === "latest") {
+        const entries = await readdir(runsDir, { withFileTypes: true });
+        const runs = entries.filter((e) => e.isDirectory()).sort().reverse();
+        if (runs.length === 0) {
+            emitNotApplicable(null, "RUN_ARTIFACT_MISSING", "No runs found.");
+            return;
+        }
+        runId = runs[0].name;
+    }
+    const worktreesDir = getOmkPath(`worktrees/${runId}`);
+    if (!(await pathExists(worktreesDir))) {
+        emitNotApplicable(runId, "RUN_ARTIFACT_MISSING", "No worktrees found for run.");
+        return;
+    }
+    const workerNames = await readdir(worktreesDir, { withFileTypes: true }).then((e) => e.filter((d) => d.isDirectory()).map((d) => d.name));
+    const currentBranch = await getCurrentBranch();
+    if (!currentBranch) {
+        emitNotApplicable(runId, "INTERNAL_ERROR", "Could not determine current branch.");
+        return;
+    }
+    const workers = [];
+    for (const name of workerNames) {
+        const wtPath = join(worktreesDir, name);
+        const diffResult = await runShell("git", ["-C", wtPath, "diff", currentBranch], { timeout: 15000 });
+        if (diffResult.failed || !diffResult.stdout.trim())
+            continue;
+        const diff = diffResult.stdout;
+        const diffLines = diff.split("\n").length;
+        const applyCheck = await runShell("git", ["apply", "--check"], { cwd: root, input: diff, timeout: 15000 });
+        workers.push({ name, path: wtPath, diff, diffLines, canApply: !applyCheck.failed });
+    }
+    const winner = selectWinner(workers, strategy);
+    const data = {
+        runId,
+        strategy,
+        dryRun,
+        merged: winner?.name ?? null,
+        conflicts: workers.filter((w) => !w.canApply).map((w) => w.name),
+        applied: 0,
+    };
+    emitJson(createOmkJsonEnvelope({
+        command: "merge",
+        status: workers.length === 0 ? "not-applicable" : "dry-run",
+        ok: workers.length > 0,
+        runId,
+        data,
+        durationMs: Date.now() - started,
+    }));
+}
 export async function mergeCommand(options) {
+    if (options.json === true || process.argv.includes("--json")) {
+        await emitMergeJson(options);
+        return;
+    }
     const root = getProjectRoot();
     const strategy = (options.strategy ?? "first").trim().toLowerCase();
     const dryRun = Boolean(options.dryRun);

package/dist/commands/parallel/core.js

@@ -11,7 +11,7 @@ import { writeMemoryRecallSummary } from "../../util/chat-startup.js";
 import { normalizeProviderPolicy, parseProviderModelArg } from "../../providers/model-registry.js";
 import { parseExecutionPromptPolicy } from "../../util/execution-selection.js";
 import { analyzeUserIntent } from "../../goal/intake.js";
-import { buildIntentFrame } from "../../goal/intent-frame.js";
+import { buildIntentFrame, buildIntentFrameWithOuroboros } from "../../goal/intent-frame.js";
 import { renderCapabilityRoutingArtifact } from "../../orchestration/capability-routing.js";
 import { ensureCompletionArtifactContract } from "../../orchestration/completion-artifacts.js";
 import { buildParallelRouteDecision, resolveParallelCommandExecutionDecision, createInteractiveRunState, createExecutableDagFromState } from "./orchestrator.js";
@@ -70,7 +70,7 @@ export async function parallelCommand(goal, options = {}) {
         const { loadSpecDag } = await import("../dag-from-spec.js");
         const specDag = await loadSpecDag(options.fromSpec, { parallel: true });
         effectiveGoal = goal ?? `spec: ${specDag.nodes[0]?.name ?? options.fromSpec}`;
-        intentFrame = buildIntentFrame(effectiveGoal);
+        intentFrame = await buildIntentFrameWithOuroboros(effectiveGoal);
         specNodes = specDag.nodes.map((node) => {
             const { status: _status, retries: _retries, ...def } = node;
             void _status;
@@ -79,7 +79,7 @@ export async function parallelCommand(goal, options = {}) {
         });
     }
     else {
-        intentFrame = intentFrame ?? buildIntentFrame(effectiveGoal);
+        intentFrame = intentFrame ?? (await buildIntentFrameWithOuroboros(effectiveGoal));
     }
     const resolvedIntent = options.intent ?? analyzeUserIntent(effectiveGoal);
     const executionDecision = options.executionDecision ?? await resolveParallelCommandExecutionDecision({

package/dist/commands/provider.js

@@ -1,6 +1,7 @@
 import { checkDeepSeekBalance } from "../providers/deepseek/deepseek-balance.js";
 import { forceDisableDeepSeek, getDeepSeekProviderStatus, resolveDeepSeekApiKey, setDeepSeekApiKey, setDeepSeekEnabled, } from "../providers/deepseek/deepseek-config.js";
 import { normalizeProviderId, providerDoctorStatus, readProviderRegistry, setProviderDefaults, setProviderConfig, setProviderEnabled, } from "../providers/model-registry.js";
+import { toProviderHealth } from "../providers/provider-health.js";
 import { maskSensitiveText } from "../util/secret-mask.js";
 import { status, label, header, style } from "../util/theme.js";
 const PROVIDER_PROFILES = [
@@ -95,7 +96,7 @@ export async function providerDoctorCommand(provider, options = {}) {
         const normalized = normalizeProviderId(target);
         const payload = await providerDoctorStatus(normalized === "auto" ? "kimi" : normalized);
         if (options.json) {
-            console.log(JSON.stringify(payload, null, 2));
+            console.log(JSON.stringify({ ...payload, health: toProviderHealth(payload) }, null, 2));
         }
         else {
             console.log(header("Provider doctor"));
@@ -125,13 +126,14 @@ export async function providerDoctorCommand(provider, options = {}) {
             disableForRun: true,
         };
     if (options.json) {
-        console.log(JSON.stringify({
+        const deepseekDoctor = {
             ...result,
             enabled: providerStatus.enabled,
             disabledBy: providerStatus.disabledBy,
             apiKeySet: providerStatus.apiKeySet,
             apiKeySource: providerStatus.apiKeySource,
-        }, null, 2));
+        };
+        console.log(JSON.stringify({ ...deepseekDoctor, health: toProviderHealth(deepseekDoctor) }, null, 2));
     }
     else {
         console.log(header("Provider doctor"));

package/dist/commands/star.js

@@ -1,5 +1,6 @@
-import { starGitHubRepo, getStarPromptSummary } from "../util/first-run-star.js";
+import { starGitHubRepo, getStarPromptSummary, openRepoInBrowser, parseGitHubRepoSlug } from "../util/first-run-star.js";
 import { OMK_REPO_URL } from "../util/version.js";
+import { style } from "../util/theme.js";
 export async function starCommand(options = {}) {
     if (options.status) {
         const summary = await getStarPromptSummary();
@@ -25,6 +26,10 @@ export async function starCommand(options = {}) {
     }
     catch (e) {
         console.error("Failed to star:", e instanceof Error ? e.message : String(e));
+        const slug = parseGitHubRepoSlug(OMK_REPO_URL);
+        if (slug)
+            console.error(style.gray(`Visit ${style.cream(`https://github.com/${slug}`)} to star manually.`));
+        await openRepoInBrowser(OMK_REPO_URL);
         process.exit(1);
     }
 }

package/dist/commands/summary.d.ts

@@ -1,2 +1,5 @@
-export declare function summaryLatestCommand(): Promise<void>;
+export interface SummaryLatestCommandOptions {
+    json?: boolean;
+}
+export declare function summaryLatestCommand(options?: SummaryLatestCommandOptions): Promise<void>;
 export declare function summaryShowCommand(runId?: string): Promise<void>;

package/dist/commands/summary.js

@@ -2,6 +2,8 @@ import { readFile, writeFile, readdir, stat } from "fs/promises";
 import { join } from "path";
 import { getProjectRoot, pathExists, getRunsDir, getRunPath } from "../util/fs.js";
 import { style, header, status, label } from "../util/theme.js";
+import { createOmkJsonEnvelope } from "../util/json-envelope.js";
+import { emitJson } from "../util/cli-contract.js";
 function computeProviderRouting(nodes) {
     const byProvider = {};
     const fallbacks = [];
@@ -257,7 +259,107 @@ function generateReportMd(s) {
     lines.push("");
     return lines.join("\n");
 }
-export async function summaryLatestCommand() {
+function deriveRunRollupStatus(s) {
+    if (s.failed > 0)
+        return "failed";
+    if (s.blocked > 0)
+        return "blocked";
+    if (s.running > 0 || s.pending > 0)
+        return "running";
+    if (s.totalNodes > 0 && s.done === s.totalNodes)
+        return "passed";
+    return "partial";
+}
+function buildSummaryJsonData(summary) {
+    const data = {
+        runId: summary.runId,
+        status: deriveRunRollupStatus(summary),
+        nodes: { total: summary.totalNodes, passed: summary.done, failed: summary.failed },
+        successRate: summary.successRate,
+        durationMs: summary.durationMs,
+        startedAt: summary.startedAt,
+    };
+    if (summary.completedAt)
+        data.completedAt = summary.completedAt;
+    if (summary.providerRouting.attempts > 0) {
+        data.providerRoute = {
+            attempts: summary.providerRouting.attempts,
+            byProvider: summary.providerRouting.byProvider,
+            fallbacks: summary.providerRouting.fallbacks.length,
+        };
+    }
+    const evidenceRefs = summary.nodes.flatMap((node) => (node.evidence ?? []).map((e) => ({ nodeId: node.id, gate: e.gate, passed: e.passed })));
+    if (evidenceRefs.length > 0)
+        data.evidenceRefs = evidenceRefs;
+    return data;
+}
+function emptySummaryJsonData(runId) {
+    return {
+        runId,
+        status: "no-runs",
+        nodes: { total: 0, passed: 0, failed: 0 },
+        successRate: 0,
+        durationMs: 0,
+    };
+}
+/**
+ * Read-only JSON path for `omk summary --json`.
+ * Emits EXACTLY ONE omk.contract.v1 envelope to stdout (no banner, no ANSI),
+ * never calls process.exit, and never writes summary.md/report.md side effects.
+ */
+async function emitSummaryJson() {
+    const started = Date.now();
+    const root = getProjectRoot();
+    const latestId = await findLatestRunId(root);
+    if (!latestId) {
+        emitJson(createOmkJsonEnvelope({
+            command: "summary",
+            status: "not-applicable",
+            ok: false,
+            data: emptySummaryJsonData(null),
+            warnings: [
+                { code: "RUN_ARTIFACT_MISSING", message: "No runs found.", recoverable: true, severity: "warning" },
+            ],
+            durationMs: Date.now() - started,
+        }));
+        return;
+    }
+    const state = await loadRunState(root, latestId);
+    if (!state) {
+        emitJson(createOmkJsonEnvelope({
+            command: "summary",
+            status: "not-applicable",
+            ok: false,
+            runId: latestId,
+            data: emptySummaryJsonData(latestId),
+            warnings: [
+                {
+                    code: "RUN_ARTIFACT_MISSING",
+                    message: `Run state not found for ${latestId}`,
+                    recoverable: true,
+                    severity: "warning",
+                },
+            ],
+            durationMs: Date.now() - started,
+        }));
+        return;
+    }
+    const summary = computeSummary(state);
+    emitJson(createOmkJsonEnvelope({
+        command: "summary",
+        status: "passed",
+        ok: true,
+        runId: summary.runId,
+        data: buildSummaryJsonData(summary),
+        durationMs: Date.now() - started,
+    }));
+}
+export async function summaryLatestCommand(options = {}) {
+    const jsonMode = options.json === true || process.argv.includes("--json");
+    if (jsonMode) {
+        await emitSummaryJson();
+        return;
+    }
     const root = await getProjectRoot();
     const latestId = await findLatestRunId(root);
     if (!latestId) {

package/dist/commands/team.d.ts

@@ -2,6 +2,7 @@ import type { TeamRuntimeStatus } from "../contracts/orchestration.js";
 export declare function teamCommand(options?: {
     workers?: string;
     runId?: string;
+    json?: boolean;
 }): Promise<void>;
 export declare function writeTeamRunState(root: string, runId: string, workerCount: number, session?: string, profile?: string): Promise<string>;
 export declare function buildExpectedTeamRuntimeStatus(session: string, statePath: string, workerCount: number, runtimeStatus: TeamRuntimeStatus["status"], presentWindows?: Map<string, number>): TeamRuntimeStatus;