open-multi-agent-kit 0.78.0 → 0.78.2

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;

package/dist/commands/team.js

@@ -8,7 +8,45 @@ 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);

package/dist/contracts/interview.d.ts

@@ -0,0 +1,106 @@
+import type { GoalSpec, RiskLevel } from "./goal.js";
+export declare const INTERVIEW_SCHEMA_VERSION: "omk.interview.v1";
+export declare const INTERVIEW_DELTA_SCHEMA_VERSION: "omk.interview-delta.v1";
+export type InterviewDepth = "light" | "standard" | "deep";
+export type InterviewMode = "create" | "refine";
+export type InterviewQuestionKind = "objective" | "success-criteria" | "artifact" | "constraint" | "non-goal" | "risk" | "authority" | "evidence" | "dependency" | "rollback";
+/**
+ * Field on GoalSpec (or a derived structure) that an answer is meant to fill.
+ * A question without a targetField is low quality and must be dropped.
+ */
+export type InterviewTargetField = "objective" | "successCriteria" | "expectedArtifacts" | "constraints" | "nonGoals" | "risks" | "riskLevel" | "intentFrame" | "actionAtoms";
+export interface InterviewQuestion {
+    id: string;
+    kind: InterviewQuestionKind;
+    prompt: string;
+    required: boolean;
+    targetField: InterviewTargetField;
+    /** 0..1 — how much answering reduces uncertainty about the goal. */
+    informationGain: number;
+    /** 0..1 — how much answering reduces execution risk. */
+    riskReduction: number;
+    /** 0..1 — how strongly the answer reshapes the execution DAG. */
+    dagImpact: number;
+    /** 0..1 — how strongly the answer strengthens evidence gates. */
+    evidenceImpact: number;
+    /** 0..1 — burden on the user (penalty). */
+    userCost: number;
+    /** Derived ranking score, 0..1, rounded to 2 decimals. */
+    score: number;
+}
+export interface InterviewAnswer {
+    questionId: string;
+    answer: string;
+    answeredAt: string;
+    skipped?: boolean;
+}
+export interface InterviewFinding {
+    field: InterviewTargetField | string;
+    value: unknown;
+    sourceQuestionId: string;
+    /** 0..1 confidence that this finding is correct and explicit. */
+    confidence: number;
+    /** True when this finding contradicts an existing explicit value. */
+    conflict?: boolean;
+}
+export interface InterviewCompleteness {
+    /** Weighted overall completeness, 0..1. */
+    overall: number;
+    objective: number;
+    successCriteria: number;
+    evidence: number;
+    artifacts: number;
+    constraints: number;
+    risks: number;
+    authority: number;
+    /** Required fields with no usable value yet. */
+    criticalMissing: string[];
+    /** Unresolved contradictions between answers and existing values. */
+    contradictions: string[];
+}
+export type InterviewDeltaField = keyof GoalSpec | "successCriteria" | "expectedArtifacts" | "riskLevel";
+export interface InterviewSpecChange {
+    field: InterviewDeltaField;
+    op: "add" | "replace" | "remove";
+    value: unknown;
+    sourceQuestionId: string;
+    /** 0..1 confidence used by the conflict resolver. */
+    confidence: number;
+}
+export interface InterviewSpecDelta {
+    schemaVersion: typeof INTERVIEW_DELTA_SCHEMA_VERSION;
+    goalId?: string;
+    changes: InterviewSpecChange[];
+}
+export type InterviewStatus = "open" | "complete" | "blocked";
+export interface InterviewSession {
+    schemaVersion: typeof INTERVIEW_SCHEMA_VERSION;
+    sessionId: string;
+    goalId?: string;
+    mode: InterviewMode;
+    depth: InterviewDepth;
+    createdAt: string;
+    updatedAt: string;
+    rawPrompt?: string;
+    /** Ambiguity score 0..1; higher means more interview is needed. */
+    ambiguity: number;
+    questions: InterviewQuestion[];
+    answers: InterviewAnswer[];
+    findings: InterviewFinding[];
+    completeness: InterviewCompleteness;
+    specDelta: InterviewSpecDelta;
+    status: InterviewStatus;
+}
+/** Inputs the question bank needs to derive candidate questions. */
+export interface InterviewSeed {
+    rawPrompt: string;
+    riskLevel?: RiskLevel;
+    goal?: GoalSpec;
+}
+/** Result of applying a spec delta to a GoalSpec. */
+export interface InterviewApplyResult {
+    goal: GoalSpec;
+    appliedChanges: InterviewSpecChange[];
+    skippedChanges: InterviewSpecChange[];
+    contradictions: string[];
+}

package/dist/contracts/interview.js

@@ -0,0 +1,9 @@
+// Contract: src/contracts/interview.ts
+// Owner: Contract Worker (Deep Interview phase 0)
+// OMK Deep Interview — uncertainty reducer for goal-driven agent runs.
+//
+// Read-only for downstream interview modules. These types are the shared
+// language for question banking, scoring, assimilation, session building,
+// and the `omk goal interview` / `omk goal refine` CLI commands.
+export const INTERVIEW_SCHEMA_VERSION = "omk.interview.v1";
+export const INTERVIEW_DELTA_SCHEMA_VERSION = "omk.interview-delta.v1";

package/dist/contracts/provider-health.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared, provider-neutral health shape.
+ *
+ * This contract is intentionally additive: it is embedded alongside the
+ * existing `omk provider doctor <x> --json` payloads without removing or
+ * renaming any pre-existing keys. It never carries secret values — only
+ * boolean signals (e.g. `authOk`) and non-sensitive remediation hints.
+ */
+/** Classified failure category for a provider health check. */
+export type ProviderFailureKind = "none" | "runtime" | "auth" | "model" | "quota" | "policy" | "transient" | "unknown";
+/** Authority level a provider holds for a given capability lane. */
+export type ProviderAuthorityLevel = "none" | "advisory" | "direct" | "full";
+/**
+ * Normalized provider health snapshot.
+ *
+ * All fields are required so consumers can rely on a stable shape regardless
+ * of which provider produced it.
+ */
+export interface ProviderHealth {
+    /** Provider id (e.g. "kimi", "deepseek", "codex"). */
+    provider: string;
+    /** ISO-8601 timestamp of when the health snapshot was produced. */
+    checkedAt: string;
+    /** Runtime/transport reachable and enabled. */
+    runtimeOk: boolean;
+    /** Authentication satisfied (API key present or externally managed auth). */
+    authOk: boolean;
+    /** A resolvable default model is configured. */
+    modelOk: boolean;
+    /** No known quota/balance/rate-limit blocker. */
+    quotaOk: boolean;
+    /** Authority to perform write/merge work. */
+    writeAuthority: ProviderAuthorityLevel;
+    /** Authority to run shell/CLI work. */
+    shellAuthority: ProviderAuthorityLevel;
+    /** Authority to drive MCP tools. */
+    mcpAuthority: ProviderAuthorityLevel;
+    /** Classified failure category ("none" when healthy). */
+    failureKind: ProviderFailureKind;
+    /** Non-sensitive remediation hints (never includes secret values). */
+    remediation: string[];
+}

package/dist/contracts/provider-health.js

@@ -0,0 +1,9 @@
+/**
+ * Shared, provider-neutral health shape.
+ *
+ * This contract is intentionally additive: it is embedded alongside the
+ * existing `omk provider doctor <x> --json` payloads without removing or
+ * renaming any pre-existing keys. It never carries secret values — only
+ * boolean signals (e.g. `authOk`) and non-sensitive remediation hints.
+ */
+export {};

package/dist/evidence/index.d.ts

@@ -13,3 +13,7 @@ export { decideRepair } from "../orchestration/repair-policy.js";
 export type { RepairContext } from "../orchestration/repair-policy.js";
 export type { DecisionTraceStore } from "./decision-trace.js";
 export { createDecisionTraceStore } from "./decision-trace.js";
+export type { ProofTrustMvpEngine, ProofTrustResult } from "./proof-trust.js";
+export { createProofTrustMvpEngine } from "./proof-trust.js";
+export type { AlgorithmSpec, ReleaseCandidate, RegressionProofMatrixResult, RegressionProofMatrixEngine, RegressionProofMatrixOptions, } from "./regression-proof-matrix.js";
+export { createRegressionProofMatrixEngine } from "./regression-proof-matrix.js";

package/dist/evidence/index.js

@@ -5,3 +5,5 @@ export { createDiagnosisEngine } from "./diagnosis.js";
 export { createRunTraceStore } from "./run-trace.js";
 export { decideRepair } from "../orchestration/repair-policy.js";
 export { createDecisionTraceStore } from "./decision-trace.js";
+export { createProofTrustMvpEngine } from "./proof-trust.js";
+export { createRegressionProofMatrixEngine } from "./regression-proof-matrix.js";

package/dist/evidence/proof-trust-cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Proof Trust CLI — thin wrapper around ProofTrustMvpEngine.
+ *
+ * Usage:
+ *   node dist/evidence/proof-trust-cli.js <runDir> <bundlePath>
+ */
+export {};

package/dist/evidence/proof-trust-cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Proof Trust CLI — thin wrapper around ProofTrustMvpEngine.
+ *
+ * Usage:
+ *   node dist/evidence/proof-trust-cli.js <runDir> <bundlePath>
+ */
+import { readFile } from "node:fs/promises";
+import { createProofTrustMvpEngine } from "./proof-trust.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const runDir = args[0] ?? ".omk/runs";
+    const bundlePath = args[1];
+    if (!bundlePath) {
+        console.error("Usage: proof-trust-cli <runDir> <bundlePath>");
+        process.exit(1);
+    }
+    const bundle = JSON.parse(await readFile(bundlePath, "utf8"));
+    const engine = createProofTrustMvpEngine();
+    const result = await engine.evaluate(runDir, bundle);
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.missingFields.length > 0 ? 1 : 0);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/evidence/proof-trust.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Proof Trust MVP — Algorithm 3
+ *
+ * Evaluates a proof bundle against a run directory, computing a trust score
+ * based on weighted field presence and validity.
+ */
+export interface ProofTrustMvpEngine {
+    evaluate(runDir: string, bundle: unknown): Promise<ProofTrustResult>;
+}
+export interface ProofTrustResult {
+    readonly trustScore: number;
+    readonly missingFields: readonly string[];
+}
+export declare function createProofTrustMvpEngine(schemas?: Readonly<Record<string, unknown>>): ProofTrustMvpEngine;