open-multi-agent-kit 0.78.0 → 0.78.2

package/dist/commands/goal-interview.js

@@ -0,0 +1,396 @@
+import { mkdir, writeFile, readFile, readdir } from "fs/promises";
+import { basename, join } from "path";
+import { getProjectRoot } from "../util/fs.js";
+import { style, header, status, label } from "../util/theme.js";
+import { NotFoundError, UsageError, emitError } from "../util/cli-contract.js";
+import { createGoalPersister } from "../goal/persistence.js";
+import { createGoalSpec, updateGoalStatus } from "../goal/intake.js";
+import { buildInterviewSession, ingestAnswers } from "../goal/interview-session.js";
+import { applyInterviewDelta } from "../goal/interview-assimilation.js";
+import { redactSecretText } from "../goal/intent-frame.js";
+import { readImageFile } from "../util/clipboard-image.js";
+const IMAGE_ATTACHMENT_QUESTION_ID = "q-image-attachment";
+function getGoalBasePath() {
+    return join(getProjectRoot(), ".omk", "goals");
+}
+function printAlphaWarning(json) {
+    if (json)
+        return;
+    if (!process.env.OMK_GOAL_ALPHA) {
+        console.log(style.orange("⚠️  Goal interview is alpha. Set OMK_GOAL_ALPHA=1 to suppress this warning."));
+    }
+}
+function parseDepth(value) {
+    if (!value)
+        return undefined;
+    if (value === "light" || value === "standard" || value === "deep")
+        return value;
+    throw new UsageError(`Invalid depth: ${value} (expected light | standard | deep)`);
+}
+function parseMode(value) {
+    if (!value || value === "create")
+        return "create";
+    if (value === "refine")
+        return "refine";
+    throw new UsageError(`Invalid mode: ${value} (expected create | refine)`);
+}
+async function loadAnswersFile(root, filePath) {
+    const abs = join(root, filePath);
+    let content;
+    try {
+        content = await readFile(abs, "utf-8");
+    }
+    catch {
+        throw new NotFoundError(`Answers file not found: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new UsageError(`Answers file is not valid JSON: ${filePath}`);
+    }
+    const rows = Array.isArray(parsed)
+        ? parsed
+        : (parsed && typeof parsed === "object" && Array.isArray(parsed.answers)
+            ? parsed.answers
+            : null);
+    if (!rows) {
+        throw new UsageError(`Answers file must be an array or { "answers": [...] }: ${filePath}`);
+    }
+    const now = new Date().toISOString();
+    const answers = [];
+    for (const row of rows) {
+        if (!row || typeof row !== "object")
+            continue;
+        const r = row;
+        if (typeof r.questionId !== "string")
+            continue;
+        answers.push({
+            questionId: r.questionId,
+            answer: typeof r.answer === "string" ? r.answer : "",
+            answeredAt: typeof r.answeredAt === "string" ? r.answeredAt : now,
+            skipped: r.skipped === true ? true : undefined,
+        });
+    }
+    return answers;
+}
+function buildImageAttachment(imagePath) {
+    const img = readImageFile(imagePath);
+    if (!img.ok) {
+        throw new UsageError(img.error ?? `Unable to read image file: ${imagePath}`);
+    }
+    if (typeof img.dataUri !== "string" || typeof img.ext !== "string") {
+        throw new UsageError(`Image file could not be converted to a data URI: ${imagePath}`);
+    }
+    return {
+        name: basename(imagePath),
+        path: imagePath,
+        mimeType: `image/${img.ext}`,
+        dataUri: img.dataUri,
+        ext: img.ext,
+        source: "file",
+    };
+}
+function attachImageToSession(session, imagePath) {
+    const attachment = buildImageAttachment(imagePath);
+    const answeredAt = new Date().toISOString();
+    return {
+        ...session,
+        updatedAt: answeredAt,
+        answers: [
+            ...session.answers.filter((answer) => answer.questionId !== IMAGE_ATTACHMENT_QUESTION_ID),
+            {
+                questionId: IMAGE_ATTACHMENT_QUESTION_ID,
+                answer: `Image file: ${imagePath}`,
+                answeredAt,
+                skipped: false,
+            },
+        ],
+        findings: [
+            ...session.findings.filter((finding) => finding.sourceQuestionId !== IMAGE_ATTACHMENT_QUESTION_ID),
+            {
+                field: "attachments",
+                value: attachment,
+                sourceQuestionId: IMAGE_ATTACHMENT_QUESTION_ID,
+                confidence: 1,
+            },
+        ],
+    };
+}
+function renderQuestionsMarkdown(session) {
+    const lines = [
+        `# Interview Questions — ${session.sessionId}`,
+        "",
+        `**Mode:** ${session.mode}  |  **Depth:** ${session.depth}  |  **Ambiguity:** ${session.ambiguity}`,
+        "",
+        "| # | Score | Req | Target | Kind | Prompt |",
+        "|---|-------|-----|--------|------|--------|",
+    ];
+    session.questions.forEach((q, i) => {
+        const req = q.required ? "✓" : "";
+        lines.push(`| ${i + 1} | ${q.score} | ${req} | ${q.targetField} | ${q.kind} | ${q.prompt.replace(/\|/g, "\\|")} |`);
+    });
+    lines.push("");
+    return lines.join("\n");
+}
+function renderReportMarkdown(session) {
+    const c = session.completeness;
+    const lines = [
+        `# Interview Report — ${session.sessionId}`,
+        "",
+        `**Status:** ${session.status}  |  **Mode:** ${session.mode}  |  **Depth:** ${session.depth}`,
+        `**Ambiguity:** ${session.ambiguity}  |  **Completeness:** ${c.overall}`,
+        "",
+        "## Completeness by axis",
+        "",
+        `- objective: ${c.objective}`,
+        `- successCriteria: ${c.successCriteria}`,
+        `- evidence: ${c.evidence}`,
+        `- artifacts: ${c.artifacts}`,
+        `- constraints: ${c.constraints}`,
+        `- risks: ${c.risks}`,
+        `- authority: ${c.authority}`,
+        "",
+    ];
+    if (c.criticalMissing.length > 0) {
+        lines.push("## Critical missing fields", "", ...c.criticalMissing.map((m) => `- ${m}`), "");
+    }
+    if (c.contradictions.length > 0) {
+        lines.push("## Unresolved contradictions", "", ...c.contradictions.map((m) => `- ${m}`), "");
+    }
+    lines.push("## Answers", "");
+    if (session.answers.length === 0) {
+        lines.push("_No answers recorded yet._", "");
+    }
+    else {
+        for (const a of session.answers) {
+            if (a.skipped) {
+                lines.push(`- **${a.questionId}**: _(skipped)_`);
+            }
+            else {
+                lines.push(`- **${a.questionId}**: ${a.answer}`);
+            }
+        }
+        lines.push("");
+    }
+    lines.push("## Spec delta", "");
+    if (session.specDelta.changes.length === 0) {
+        lines.push("_No structured changes derived._", "");
+    }
+    else {
+        for (const ch of session.specDelta.changes) {
+            lines.push(`- \`${ch.op}\` **${String(ch.field)}** (conf ${ch.confidence}): ${JSON.stringify(ch.value)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+async function writeSessionArtifacts(dir, session) {
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, "interview.json"), `${JSON.stringify(session, null, 2)}\n`);
+    await writeFile(join(dir, "spec-delta.json"), `${JSON.stringify(session.specDelta, null, 2)}\n`);
+    await writeFile(join(dir, "questions.md"), renderQuestionsMarkdown(session));
+    await writeFile(join(dir, "interview-report.md"), renderReportMarkdown(session));
+    const answersJsonl = session.answers.map((a) => JSON.stringify(a)).join("\n");
+    await writeFile(join(dir, "answers.jsonl"), answersJsonl.length > 0 ? `${answersJsonl}\n` : "");
+}
+function printSessionSummary(session, sessionDir) {
+    console.log(header("Goal Interview"));
+    console.log(label("Session", session.sessionId));
+    console.log(label("Mode", session.mode));
+    console.log(label("Depth", session.depth));
+    console.log(label("Ambiguity", String(session.ambiguity)));
+    console.log(label("Completeness", String(session.completeness.overall)));
+    console.log(label("Status", session.status));
+    console.log(label("Questions", String(session.questions.length)));
+    console.log(label("Answers", String(session.answers.length)));
+    if (session.completeness.criticalMissing.length > 0) {
+        console.log(label("Missing", session.completeness.criticalMissing.join(", ")));
+    }
+    if (session.completeness.contradictions.length > 0) {
+        console.log(style.pink(`Contradictions: ${session.completeness.contradictions.join("; ")}`));
+    }
+    console.log("");
+    if (session.answers.length === 0) {
+        console.log(style.purpleBold("Top questions"));
+        for (const q of session.questions.slice(0, 6)) {
+            const req = q.required ? style.pink("[required]") : style.gray("[optional]");
+            console.log(`  ${req} (${q.score}) ${q.prompt}`);
+        }
+        console.log("");
+        console.log(style.gray("Answer via: omk goal interview \"<prompt>\" --answers answers.json --write-spec"));
+    }
+    console.log(status.success(`interview.json → ${join(sessionDir, "interview.json")}`));
+}
+export async function goalInterviewCommand(input, options) {
+    printAlphaWarning(options.json);
+    const root = getProjectRoot();
+    const persister = createGoalPersister(getGoalBasePath());
+    const mode = parseMode(options.mode);
+    const depth = parseDepth(options.depth);
+    const maxQuestions = options.maxQuestions ? Number.parseInt(options.maxQuestions, 10) : undefined;
+    if (maxQuestions !== undefined && (!Number.isFinite(maxQuestions) || maxQuestions <= 0)) {
+        throw new UsageError(`Invalid --max-questions: ${options.maxQuestions}`);
+    }
+    // Resolve existing goal for refine mode or when --goal-id / id positional is given.
+    const goalIdHint = options.goalId ?? (mode === "refine" ? input : undefined);
+    let existingGoal = null;
+    if (goalIdHint) {
+        existingGoal = await persister.load(goalIdHint);
+        if (!existingGoal) {
+            const msg = `Goal not found: ${goalIdHint}`;
+            emitError(msg, Boolean(options.json));
+            throw new NotFoundError(msg);
+        }
+    }
+    const rawPrompt = existingGoal
+        ? (existingGoal.rawPrompt || existingGoal.objective || existingGoal.title)
+        : (input ?? "");
+    if (!rawPrompt.trim()) {
+        throw new UsageError("A raw goal prompt or an existing --goal-id is required.");
+    }
+    // Redact secrets from the prompt before it reaches the session, the GoalSpec,
+    // persisted artifacts, or --json output.
+    const safePrompt = redactSecretText(rawPrompt);
+    const seed = {
+        rawPrompt: safePrompt,
+        riskLevel: existingGoal?.riskLevel,
+        goal: existingGoal ?? undefined,
+    };
+    let session = buildInterviewSession({
+        seed,
+        mode: existingGoal ? "refine" : mode,
+        depth,
+        maxQuestions,
+        goalId: existingGoal?.goalId,
+    });
+    if (options.answers) {
+        const answers = await loadAnswersFile(root, options.answers);
+        session = ingestAnswers(session, seed, answers);
+    }
+    if (options.image) {
+        session = attachImageToSession(session, options.image);
+    }
+    // Optionally apply the delta to a GoalSpec.
+    let savedGoalId = existingGoal?.goalId;
+    if (options.writeSpec) {
+        let goal;
+        if (existingGoal) {
+            const result = applyInterviewDelta(existingGoal, session.specDelta);
+            goal = updateGoalStatus(result.goal, result.goal.status, { planRevision: result.goal.planRevision + 1 });
+        }
+        else {
+            const base = createGoalSpec(safePrompt);
+            goal = applyInterviewDelta(base, session.specDelta).goal;
+        }
+        await persister.save(goal);
+        await persister.appendHistory(goal.goalId, {
+            at: new Date().toISOString(),
+            action: existingGoal ? "interview-refine" : "interview-create",
+            detail: {
+                sessionId: session.sessionId,
+                ambiguity: session.ambiguity,
+                completeness: session.completeness.overall,
+                changes: session.specDelta.changes.length,
+            },
+        });
+        savedGoalId = goal.goalId;
+        session.goalId = goal.goalId;
+        session.specDelta.goalId = goal.goalId;
+    }
+    // Persist interview artifacts. With a goal id, store under the goal dir.
+    const sessionDir = savedGoalId
+        ? join(getGoalBasePath(), savedGoalId, "interviews", session.sessionId)
+        : join(root, ".omk", "interviews", session.sessionId);
+    await writeSessionArtifacts(sessionDir, session);
+    if (options.json) {
+        console.log(JSON.stringify(session, null, 2));
+        return;
+    }
+    printSessionSummary(session, sessionDir);
+    if (savedGoalId) {
+        console.log(status.success(`goal spec written → ${savedGoalId}`));
+        console.log(style.gray(`Next: omk goal plan ${savedGoalId}`));
+    }
+}
+async function findLatestInterviewSessionId(goalDir) {
+    const interviewsDir = join(goalDir, "interviews");
+    try {
+        const entries = await readdir(interviewsDir, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+        return dirs.length > 0 ? dirs[dirs.length - 1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function goalRefineCommand(goalId, options) {
+    printAlphaWarning(options.json);
+    const persister = createGoalPersister(getGoalBasePath());
+    const goal = await persister.load(goalId);
+    if (!goal) {
+        const msg = `Goal not found: ${goalId}`;
+        emitError(msg, Boolean(options.json));
+        throw new NotFoundError(msg);
+    }
+    const goalDir = join(getGoalBasePath(), goalId);
+    const from = options.fromInterview ?? "latest";
+    const sessionId = from === "latest" ? await findLatestInterviewSessionId(goalDir) : from;
+    if (!sessionId) {
+        const msg = `No interview session found for goal: ${goalId}. Run: omk goal interview ${goalId} --mode refine --answers answers.json`;
+        emitError(msg, Boolean(options.json));
+        throw new NotFoundError(msg);
+    }
+    const deltaPath = join(goalDir, "interviews", sessionId, "spec-delta.json");
+    let delta;
+    try {
+        delta = JSON.parse(await readFile(deltaPath, "utf-8"));
+    }
+    catch {
+        const msg = `Interview spec-delta not found: ${deltaPath}`;
+        emitError(msg, Boolean(options.json));
+        throw new NotFoundError(msg);
+    }
+    const result = applyInterviewDelta(goal, delta);
+    const refined = updateGoalStatus(result.goal, result.goal.status, { planRevision: result.goal.planRevision + 1 });
+    await persister.save(refined);
+    await persister.appendHistory(goalId, {
+        at: new Date().toISOString(),
+        action: "refine",
+        detail: {
+            sessionId,
+            applied: result.appliedChanges.length,
+            skipped: result.skippedChanges.length,
+            contradictions: result.contradictions.length,
+            planRevision: refined.planRevision,
+        },
+    });
+    if (options.plan) {
+        const { goalPlanCommand } = await import("./goal.js");
+        await goalPlanCommand(goalId, { json: options.json });
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            goalId,
+            sessionId,
+            applied: result.appliedChanges.length,
+            skipped: result.skippedChanges.length,
+            contradictions: result.contradictions,
+            planRevision: refined.planRevision,
+            status: refined.status,
+        }, null, 2));
+        return;
+    }
+    console.log(header("Goal Refined"));
+    console.log(label("ID", goalId));
+    console.log(label("From interview", sessionId));
+    console.log(label("Applied changes", String(result.appliedChanges.length)));
+    console.log(label("Skipped changes", String(result.skippedChanges.length)));
+    console.log(label("Plan revision", String(refined.planRevision)));
+    if (result.contradictions.length > 0) {
+        console.log(style.pink(`Contradictions: ${result.contradictions.join("; ")}`));
+    }
+    console.log(style.gray(`Next: omk goal plan ${goalId}`));
+}

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 {};