open-multi-agent-kit 0.78.1 → 0.78.2

package/dist/runtime/public-surface.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Public Surface Compression — Phase 1 of OMK Weakness Remediation.
+ *
+ * Takes a candidate set of runtime surfaces, scores each item,
+ * enforces mandatory anchors, applies budget K, and returns
+ * public surface S and hidden set H.
+ *
+ * Also enforces the 5-step flow invariant:
+ *   goal → dag → route → verify → replay
+ */
+/** A candidate surface item (e.g., a tool, MCP server, skill, or runtime). */
+export interface SurfaceItem {
+    readonly id: string;
+    readonly name: string;
+    readonly category: "tool" | "mcp" | "skill" | "runtime" | "hook";
+    /** How often this surface is invoked per 100 turns. */
+    readonly usage: number;
+    /** Contribution score from verified runs [0, 1]. */
+    readonly verifiedRunContribution: number;
+    /** Contribution score from evidence items [0, 1]. */
+    readonly evidenceContribution: number;
+    /** Onboarding difficulty/cost [0, 1]. */
+    readonly onboardingCost: number;
+    /** Explainability burden [0, 1]. */
+    readonly explainabilityCost: number;
+    /** Risk of lineage drift [0, 1]. */
+    readonly lineageRisk: number;
+}
+/** Scored surface item with computed score. */
+export interface ScoredSurfaceItem extends SurfaceItem {
+    readonly score: number;
+}
+/** Mandatory anchor identifiers. */
+export type MandatoryAnchor = "goal" | "dag" | "route" | "verify" | "replay";
+/** Compression result: public surface S and hidden set H. */
+export interface CompressionResult {
+    readonly publicSurface: readonly ScoredSurfaceItem[];
+    readonly hiddenSet: readonly ScoredSurfaceItem[];
+    readonly mandatoryAnchors: readonly MandatoryAnchor[];
+    readonly budget: number;
+    readonly invariantPassed: boolean;
+    readonly invariantViolations: readonly string[];
+}
+/**
+ * Compute surface score from item metrics.
+ *
+ * Formula:
+ *   0.30 * usage
+ * + 0.30 * verifiedRunContribution
+ * + 0.20 * evidenceContribution
+ * - 0.10 * onboardingCost
+ * - 0.05 * explainabilityCost
+ * - 0.05 * lineageRisk
+ */
+export declare function computeSurfaceScore(item: SurfaceItem): number;
+/**
+ * Validate the 5-step flow invariant against the public surface.
+ *
+ * Invariant: The public surface must contain all mandatory anchors
+ * in order: goal → dag → route → verify → replay.
+ *
+ * Returns violations as human-readable strings.
+ */
+export declare function enforceFlowInvariant(publicSurface: readonly ScoredSurfaceItem[]): {
+    readonly passed: boolean;
+    readonly violations: readonly string[];
+};
+export interface PublicSurfaceCompressorOptions {
+    /** Maximum number of items in the public surface (default 5). */
+    readonly budget?: number;
+    /** Optional custom scoring function. */
+    readonly scoreFn?: (item: SurfaceItem) => number;
+}
+/**
+ * Compresses a candidate surface set into public (S) and hidden (H) subsets.
+ *
+ * Rules:
+ * 1. Mandatory anchors A = {goal, dag, route, verify, replay} are always in S.
+ * 2. Remaining slots are filled by highest score until budget K is reached.
+ * 3. The 5-step flow invariant is enforced and reported.
+ */
+export declare class PublicSurfaceCompressor {
+    private readonly budget;
+    private readonly scoreFn;
+    constructor(options?: PublicSurfaceCompressorOptions);
+    /**
+     * Compress candidates into public surface S and hidden set H.
+     *
+     * @param candidates All candidate surface items.
+     * @returns CompressionResult with S, H, and invariant status.
+     */
+    compress(candidates: readonly SurfaceItem[]): CompressionResult;
+}

package/dist/runtime/public-surface.js

@@ -0,0 +1,146 @@
+/**
+ * Public Surface Compression — Phase 1 of OMK Weakness Remediation.
+ *
+ * Takes a candidate set of runtime surfaces, scores each item,
+ * enforces mandatory anchors, applies budget K, and returns
+ * public surface S and hidden set H.
+ *
+ * Also enforces the 5-step flow invariant:
+ *   goal → dag → route → verify → replay
+ */
+// ── Constants ───────────────────────────────────────────────────
+const MANDATORY_ANCHORS = [
+    "goal",
+    "dag",
+    "route",
+    "verify",
+    "replay",
+];
+const DEFAULT_BUDGET = 5;
+// ── Scoring ─────────────────────────────────────────────────────
+/**
+ * Compute surface score from item metrics.
+ *
+ * Formula:
+ *   0.30 * usage
+ * + 0.30 * verifiedRunContribution
+ * + 0.20 * evidenceContribution
+ * - 0.10 * onboardingCost
+ * - 0.05 * explainabilityCost
+ * - 0.05 * lineageRisk
+ */
+export function computeSurfaceScore(item) {
+    const raw = 0.30 * item.usage +
+        0.30 * item.verifiedRunContribution +
+        0.20 * item.evidenceContribution -
+        0.10 * item.onboardingCost -
+        0.05 * item.explainabilityCost -
+        0.05 * item.lineageRisk;
+    // Clamp to [0, 1]
+    return Math.max(0, Math.min(1, raw));
+}
+// ── Invariant Enforcement ───────────────────────────────────────
+/**
+ * Validate the 5-step flow invariant against the public surface.
+ *
+ * Invariant: The public surface must contain all mandatory anchors
+ * in order: goal → dag → route → verify → replay.
+ *
+ * Returns violations as human-readable strings.
+ */
+export function enforceFlowInvariant(publicSurface) {
+    const violations = [];
+    const ids = publicSurface.map((s) => s.id);
+    for (const anchor of MANDATORY_ANCHORS) {
+        if (!ids.includes(anchor)) {
+            violations.push(`Missing mandatory anchor: ${anchor}`);
+        }
+    }
+    if (violations.length === 0) {
+        const orderIndices = MANDATORY_ANCHORS.map((a) => ids.indexOf(a));
+        for (let i = 1; i < orderIndices.length; i++) {
+            if (orderIndices[i] < orderIndices[i - 1]) {
+                violations.push(`Flow order violation: ${MANDATORY_ANCHORS[i - 1]} must precede ${MANDATORY_ANCHORS[i]}`);
+            }
+        }
+    }
+    return {
+        passed: violations.length === 0,
+        violations: Object.freeze(violations),
+    };
+}
+/**
+ * Compresses a candidate surface set into public (S) and hidden (H) subsets.
+ *
+ * Rules:
+ * 1. Mandatory anchors A = {goal, dag, route, verify, replay} are always in S.
+ * 2. Remaining slots are filled by highest score until budget K is reached.
+ * 3. The 5-step flow invariant is enforced and reported.
+ */
+export class PublicSurfaceCompressor {
+    budget;
+    scoreFn;
+    constructor(options = {}) {
+        this.budget = Math.max(MANDATORY_ANCHORS.length, options.budget ?? DEFAULT_BUDGET);
+        this.scoreFn = options.scoreFn ?? computeSurfaceScore;
+    }
+    /**
+     * Compress candidates into public surface S and hidden set H.
+     *
+     * @param candidates All candidate surface items.
+     * @returns CompressionResult with S, H, and invariant status.
+     */
+    compress(candidates) {
+        const scored = candidates.map((item) => ({
+            ...item,
+            score: this.scoreFn(item),
+        }));
+        // Partition mandatory vs elective
+        const mandatoryItems = [];
+        const electiveItems = [];
+        for (const item of scored) {
+            if (MANDATORY_ANCHORS.includes(item.id)) {
+                mandatoryItems.push(item);
+            }
+            else {
+                electiveItems.push(item);
+            }
+        }
+        // Ensure all mandatory anchors are present; inject placeholders if missing
+        const presentIds = new Set(mandatoryItems.map((m) => m.id));
+        for (const anchor of MANDATORY_ANCHORS) {
+            if (!presentIds.has(anchor)) {
+                mandatoryItems.push({
+                    id: anchor,
+                    name: anchor,
+                    category: "runtime",
+                    usage: 0,
+                    verifiedRunContribution: 0,
+                    evidenceContribution: 0,
+                    onboardingCost: 0,
+                    explainabilityCost: 0,
+                    lineageRisk: 0,
+                    score: 0,
+                });
+            }
+        }
+        // Sort mandatory by canonical order, electives by score desc
+        const orderedMandatory = MANDATORY_ANCHORS.map((anchor) => mandatoryItems.find((m) => m.id === anchor));
+        electiveItems.sort((a, b) => b.score - a.score);
+        const remainingSlots = Math.max(0, this.budget - orderedMandatory.length);
+        const publicSurface = Object.freeze([
+            ...orderedMandatory,
+            ...electiveItems.slice(0, remainingSlots),
+        ]);
+        const hiddenSet = Object.freeze(electiveItems.slice(remainingSlots));
+        const invariant = enforceFlowInvariant(publicSurface);
+        return Object.freeze({
+            publicSurface,
+            hiddenSet,
+            mandatoryAnchors: MANDATORY_ANCHORS,
+            budget: this.budget,
+            invariantPassed: invariant.passed,
+            invariantViolations: invariant.violations,
+        });
+    }
+}

package/dist/runtime/router-v2-scoring.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Router V2 Scoring Engine — Bayesian-smoothed evidence calibration (Algorithm 6).
+ *
+ * Composite formula:
+ *   0.25*E + 0.15*conf + 0.20*cap + 0.15*mat + 0.10*lat + 0.10*cost
+ *   - 0.15*pen - 0.10*blast
+ */
+import type { AgentRuntime } from "./agent-runtime.js";
+import type { EvidenceHistoryEntry, NodeIntent, RuntimeScoreV2, RouterV2Options, RouterV2ScoringEngine, BlastRadiusParams } from "./contracts/router-v2.js";
+export declare function createRouterV2ScoringEngine(options?: RouterV2Options, blastRadiusFn?: (params: BlastRadiusParams) => number): RouterV2ScoringEngine;
+export declare function scoreRuntimes(candidates: AgentRuntime[], intent: NodeIntent, history: EvidenceHistoryEntry[], options?: RouterV2Options): RuntimeScoreV2[];

package/dist/runtime/router-v2-scoring.js

@@ -0,0 +1,151 @@
+/**
+ * Router V2 Scoring Engine — Bayesian-smoothed evidence calibration (Algorithm 6).
+ *
+ * Composite formula:
+ *   0.25*E + 0.15*conf + 0.20*cap + 0.15*mat + 0.10*lat + 0.10*cost
+ *   - 0.15*pen - 0.10*blast
+ */
+import { computeBlastRadiusPenalty } from "./blast-radius.js";
+const ALPHA_0 = 1;
+const BETA_0 = 1;
+const INTENT_CAPABILITY_WEIGHTS = {
+    research: [["read", 0.35], ["review", 0.2], ["toolCalling", 0.15], ["vision", 0.1]],
+    planning: [["read", 0.3], ["review", 0.2], ["toolCalling", 0.15]],
+    coding: [["write", 0.3], ["patch", 0.25], ["shell", 0.15], ["toolCalling", 0.1]],
+    debugging: [["read", 0.2], ["write", 0.2], ["patch", 0.2], ["shell", 0.15], ["toolCalling", 0.1]],
+    refactor: [["write", 0.25], ["patch", 0.25], ["review", 0.15], ["toolCalling", 0.1]],
+    review: [["review", 0.35], ["read", 0.25], ["toolCalling", 0.1]],
+    "test-generation": [["write", 0.25], ["patch", 0.2], ["review", 0.15], ["toolCalling", 0.1]],
+    documentation: [["read", 0.25], ["write", 0.15], ["review", 0.15], ["toolCalling", 0.1]],
+    "shell-operation": [["shell", 0.4], ["read", 0.15], ["write", 0.1]],
+};
+function runtimeCapabilityEnabled(capabilities, capability) {
+    if (capability === "toolCalling") {
+        return capabilities.toolCalling === true || capabilities.supportsToolCalling === true;
+    }
+    if (capability === "streaming") {
+        return capabilities.streaming === true || capabilities.supportsStreaming === true;
+    }
+    return capabilities[capability] === true;
+}
+function computeCapabilityFit(runtime, intent) {
+    const caps = runtime.capabilities;
+    if (!caps)
+        return 0;
+    let score = 0;
+    for (const [capability, weight] of INTENT_CAPABILITY_WEIGHTS[intent]) {
+        if (runtimeCapabilityEnabled(caps, capability))
+            score += weight;
+    }
+    if (caps.maxTokens != null && caps.maxTokens > 0) {
+        score += Math.min(0.1, caps.maxTokens / 1_000_000);
+    }
+    if (caps.maxContextTokens != null && caps.maxContextTokens > 0) {
+        score += Math.min(0.1, caps.maxContextTokens / 1_000_000);
+    }
+    return score;
+}
+function computeMaturityScore(runtime) {
+    const caps = runtime.capabilities;
+    if (!caps)
+        return 0.5;
+    const capabilityCount = [
+        caps.read,
+        caps.write,
+        caps.shell,
+        caps.patch,
+        caps.review,
+        caps.merge,
+        caps.vision,
+        caps.mcp,
+        caps.toolCalling,
+        caps.supportsToolCalling,
+    ].filter(Boolean).length;
+    const breadthScore = Math.min(1, capabilityCount / 8);
+    const priorityScore = Math.max(0, Math.min(1, runtime.priority / 100));
+    return 0.6 * breadthScore + 0.4 * priorityScore;
+}
+function computeLatencyScore(runtime) {
+    return runtime.capabilities?.supportsStreaming === true || runtime.capabilities?.streaming === true
+        ? 0.85
+        : 0.70;
+}
+function computeCostScore(runtime) {
+    return runtime.priority > 50 ? 0.75 : 0.90;
+}
+export function createRouterV2ScoringEngine(options = {}, blastRadiusFn = computeBlastRadiusPenalty) {
+    const { enableBlastRadius = false, blastRadiusParams = { downstreamNodeCount: 0, affectedFileCount: 0, hasGlobalSideEffects: false }, } = options;
+    function score(runtime, intent, history) {
+        const runtimeHistory = history.filter((e) => e.runtime === runtime.id);
+        const totalAttempts = runtimeHistory.length;
+        const passedAttempts = runtimeHistory.filter((e) => e.passed).length;
+        // Bayesian smoothing with α₀=1, β₀=1
+        const bayesianEvidenceScore = (ALPHA_0 + passedAttempts) / (ALPHA_0 + BETA_0 + totalAttempts);
+        // Confidence increases with sample size (asymptotic toward 1)
+        const confidence = Math.min(1, totalAttempts / 10 + 0.1);
+        const recentFailures = runtimeHistory
+            .filter((e) => !e.passed)
+            .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+            .slice(0, 5);
+        const recentFailurePenalty = Math.min(0.3, recentFailures.length * 0.06);
+        const capabilityFit = computeCapabilityFit(runtime, intent);
+        const maturityScore = computeMaturityScore(runtime);
+        const latencyScore = computeLatencyScore(runtime);
+        const costScore = computeCostScore(runtime);
+        const blastRadiusPenalty = enableBlastRadius ? blastRadiusFn(blastRadiusParams) : 0;
+        const composite = 0.25 * bayesianEvidenceScore +
+            0.15 * confidence +
+            0.20 * capabilityFit +
+            0.15 * maturityScore +
+            0.10 * latencyScore +
+            0.10 * costScore -
+            0.15 * recentFailurePenalty -
+            0.10 * blastRadiusPenalty;
+        return {
+            runtimeId: runtime.id,
+            bayesianEvidenceScore,
+            confidence,
+            capabilityFit,
+            maturityScore,
+            latencyScore,
+            costScore,
+            recentFailurePenalty,
+            blastRadiusPenalty,
+            composite,
+        };
+    }
+    function select(candidates, intent, history) {
+        const scored = candidates.map((runtime) => ({
+            runtime,
+            score: score(runtime, intent, history),
+        }));
+        scored.sort((a, b) => b.score.composite - a.score.composite);
+        const primary = scored[0].runtime;
+        const fallbacks = scored.slice(1).map((s) => s.runtime);
+        const bestScore = scored[0].score;
+        const reason = [
+            `intent=${intent}`,
+            `bayesianE=${bestScore.bayesianEvidenceScore.toFixed(2)}`,
+            `confidence=${bestScore.confidence.toFixed(2)}`,
+            `capability=${bestScore.capabilityFit.toFixed(2)}`,
+            `maturity=${bestScore.maturityScore.toFixed(2)}`,
+            `latency=${bestScore.latencyScore.toFixed(2)}`,
+            `cost=${bestScore.costScore.toFixed(2)}`,
+            `penalty=${bestScore.recentFailurePenalty.toFixed(2)}`,
+            `blast=${bestScore.blastRadiusPenalty.toFixed(2)}`,
+            `composite=${bestScore.composite.toFixed(3)}`,
+        ].join("; ");
+        return {
+            runtime: primary,
+            reason,
+            fallbacks,
+            intent,
+            scores: scored.map((s) => s.score),
+        };
+    }
+    return { score, select };
+}
+export function scoreRuntimes(candidates, intent, history, options = {}) {
+    const engine = createRouterV2ScoringEngine(options);
+    return candidates.map((runtime) => engine.score(runtime, intent, history));
+}

package/dist/runtime/weakness-remediation-index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Weakness Remediation Index — Public factory that instantiates all
+ * Phase 1–6 engines with sensible defaults.
+ */
+export { type IntegrationResultKind, type WeaknessRemediationState, type AdvancedControlLoopInput, type AdvancedControlLoopResult, type AdvancedControlLoop, type AdvancedControlLoopOptions, createAdvancedControlLoop, } from "./advanced-control-loop.js";
+export { type SurfaceItem, type ScoredSurfaceItem, type MandatoryAnchor, type CompressionResult, type PublicSurfaceCompressorOptions, computeSurfaceScore, enforceFlowInvariant, PublicSurfaceCompressor, } from "./public-surface.js";
+export { type ProofBundleScores, type TrustScoreResult, type ProofBundleTrustEngine, type DeriveScoresOptions, createProofBundleTrustEngine, } from "./proof-bundle-trust.js";
+export { type MaturityResult, type ProviderMaturityGate, createProviderMaturityGate, } from "./provider-maturity-gate.js";
+export { type RuntimeScoreV2, type RuntimeRouterDecisionV2, type RouterV2Options, type RouterV2ScoringEngine, type BlastRadiusParams, type EvidenceHistoryEntry, type NodeIntent, } from "./contracts/router-v2.js";
+export { createRouterV2ScoringEngine, } from "./router-v2-scoring.js";
+export { type ReleasePromotionInputs, type ReleasePromotionResult, type ReleaseVerdict, RELEASE_GATE_WEIGHTS, TAU_EVIDENCE, TAU_EVIDENCE_HIGH, TAU_PROOF, TAU_STABLE, BETA_PRIOR_ALPHA0, BETA_PRIOR_BETA0, SURFACE_BUDGET_K, } from "./contracts/weakness-remediation.js";
+export { createReleasePromotionGate, type ReleasePromotionGate, } from "../cli/release-promotion-gate.js";
+import { PublicSurfaceCompressor } from "./public-surface.js";
+import { createProofBundleTrustEngine } from "./proof-bundle-trust.js";
+import { createProviderMaturityGate } from "./provider-maturity-gate.js";
+import { createRouterV2ScoringEngine } from "./router-v2-scoring.js";
+import { createReleasePromotionGate } from "../cli/release-promotion-gate.js";
+import { createAdvancedControlLoop } from "./advanced-control-loop.js";
+export interface WeaknessRemediationIndex {
+    readonly publicSurfaceCompressor: PublicSurfaceCompressor;
+    readonly proofBundleTrustEngine: ReturnType<typeof createProofBundleTrustEngine>;
+    readonly providerMaturityGate: ReturnType<typeof createProviderMaturityGate>;
+    readonly routerV2ScoringEngine: ReturnType<typeof createRouterV2ScoringEngine>;
+    readonly releasePromotionGate: ReturnType<typeof createReleasePromotionGate>;
+    readonly advancedControlLoop: ReturnType<typeof createAdvancedControlLoop>;
+}
+export declare function createWeaknessRemediationIndex(): WeaknessRemediationIndex;

package/dist/runtime/weakness-remediation-index.js

@@ -0,0 +1,37 @@
+/**
+ * Weakness Remediation Index — Public factory that instantiates all
+ * Phase 1–6 engines with sensible defaults.
+ */
+export { createAdvancedControlLoop, } from "./advanced-control-loop.js";
+export { computeSurfaceScore, enforceFlowInvariant, PublicSurfaceCompressor, } from "./public-surface.js";
+export { createProofBundleTrustEngine, } from "./proof-bundle-trust.js";
+export { createProviderMaturityGate, } from "./provider-maturity-gate.js";
+export { createRouterV2ScoringEngine, } from "./router-v2-scoring.js";
+export { RELEASE_GATE_WEIGHTS, TAU_EVIDENCE, TAU_EVIDENCE_HIGH, TAU_PROOF, TAU_STABLE, BETA_PRIOR_ALPHA0, BETA_PRIOR_BETA0, SURFACE_BUDGET_K, } from "./contracts/weakness-remediation.js";
+export { createReleasePromotionGate, } from "../cli/release-promotion-gate.js";
+// ─── Convenience factory ─────────────────────────────────────────────────────
+import { PublicSurfaceCompressor } from "./public-surface.js";
+import { createProofBundleTrustEngine } from "./proof-bundle-trust.js";
+import { createProviderMaturityGate } from "./provider-maturity-gate.js";
+import { createRouterV2ScoringEngine } from "./router-v2-scoring.js";
+import { createReleasePromotionGate } from "../cli/release-promotion-gate.js";
+import { createAdvancedControlLoop } from "./advanced-control-loop.js";
+export function createWeaknessRemediationIndex() {
+    const publicSurfaceCompressor = new PublicSurfaceCompressor();
+    const proofBundleTrustEngine = createProofBundleTrustEngine();
+    const providerMaturityGate = createProviderMaturityGate();
+    const routerV2ScoringEngine = createRouterV2ScoringEngine();
+    const releasePromotionGate = createReleasePromotionGate();
+    const advancedControlLoop = createAdvancedControlLoop({
+        releaseGate: releasePromotionGate,
+        releaseGateEnabled: true,
+    });
+    return {
+        publicSurfaceCompressor,
+        proofBundleTrustEngine,
+        providerMaturityGate,
+        routerV2ScoringEngine,
+        releasePromotionGate,
+        advancedControlLoop,
+    };
+}

package/dist/schema/proof-bundle.schema.d.ts

@@ -16,29 +16,29 @@ export declare const ProofBundleFilesSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     commands: string;
     rawPrompt: string;
-    verifyJson: string;
+    limitations: string;
     decisionsJsonl: string;
-    runManifest: string;
     evidenceJsonl: string;
-    limitations: string;
+    verifyJson: string;
+    runManifest: string;
     stdout?: string | undefined;
     stderr?: string | undefined;
     replay?: string | undefined;
-    diffPatch?: string | undefined;
     inspectJson?: string | undefined;
+    diffPatch?: string | undefined;
 }, {
     commands: string;
     rawPrompt: string;
-    verifyJson: string;
+    limitations: string;
     decisionsJsonl: string;
-    runManifest: string;
     evidenceJsonl: string;
-    limitations: string;
+    verifyJson: string;
+    runManifest: string;
     stdout?: string | undefined;
     stderr?: string | undefined;
     replay?: string | undefined;
-    diffPatch?: string | undefined;
     inspectJson?: string | undefined;
+    diffPatch?: string | undefined;
 }>;
 export declare const ProofBundleSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"omk.proof-bundle.v1">;
@@ -66,29 +66,29 @@ export declare const ProofBundleSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         commands: string;
         rawPrompt: string;
-        verifyJson: string;
+        limitations: string;
         decisionsJsonl: string;
-        runManifest: string;
         evidenceJsonl: string;
-        limitations: string;
+        verifyJson: string;
+        runManifest: string;
         stdout?: string | undefined;
         stderr?: string | undefined;
         replay?: string | undefined;
-        diffPatch?: string | undefined;
         inspectJson?: string | undefined;
+        diffPatch?: string | undefined;
     }, {
         commands: string;
         rawPrompt: string;
-        verifyJson: string;
+        limitations: string;
         decisionsJsonl: string;
-        runManifest: string;
         evidenceJsonl: string;
-        limitations: string;
+        verifyJson: string;
+        runManifest: string;
         stdout?: string | undefined;
         stderr?: string | undefined;
         replay?: string | undefined;
-        diffPatch?: string | undefined;
         inspectJson?: string | undefined;
+        diffPatch?: string | undefined;
     }>;
     verdict: z.ZodEnum<["passed", "failed", "partial"]>;
     knownLimitations: z.ZodArray<z.ZodString, "many">;
@@ -101,21 +101,21 @@ export declare const ProofBundleSchema: z.ZodObject<{
     files: {
         commands: string;
         rawPrompt: string;
-        verifyJson: string;
+        limitations: string;
         decisionsJsonl: string;
-        runManifest: string;
         evidenceJsonl: string;
-        limitations: string;
+        verifyJson: string;
+        runManifest: string;
         stdout?: string | undefined;
         stderr?: string | undefined;
         replay?: string | undefined;
-        diffPatch?: string | undefined;
         inspectJson?: string | undefined;
+        diffPatch?: string | undefined;
     };
     providerPolicy: string;
     omkVersion: string;
-    runtimeVersion: "v1.2";
     proofId: string;
+    runtimeVersion: "v1.2";
     scenario: "no-kimi-smoke" | "evidence-block" | "fallback-route" | "dag-dependent-block" | "replay-inspect" | "example-generation" | "doctor-provider" | "native-safety" | "contract-version-smoke";
     verdict: "failed" | "partial" | "passed";
     knownLimitations: string[];
@@ -128,21 +128,21 @@ export declare const ProofBundleSchema: z.ZodObject<{
     files: {
         commands: string;
         rawPrompt: string;
-        verifyJson: string;
+        limitations: string;
         decisionsJsonl: string;
-        runManifest: string;
         evidenceJsonl: string;
-        limitations: string;
+        verifyJson: string;
+        runManifest: string;
         stdout?: string | undefined;
         stderr?: string | undefined;
         replay?: string | undefined;
-        diffPatch?: string | undefined;
         inspectJson?: string | undefined;
+        diffPatch?: string | undefined;
     };
     providerPolicy: string;
     omkVersion: string;
-    runtimeVersion: "v1.2";
     proofId: string;
+    runtimeVersion: "v1.2";
     scenario: "no-kimi-smoke" | "evidence-block" | "fallback-route" | "dag-dependent-block" | "replay-inspect" | "example-generation" | "doctor-provider" | "native-safety" | "contract-version-smoke";
     verdict: "failed" | "partial" | "passed";
     knownLimitations: string[];

package/dist/util/clipboard-image.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cross-platform clipboard image reader.
+ *
+ * Wraps the platform-specific clipboard reading from screenshot-store patterns
+ * into a reusable utility for the chat REPL, goal commands, and any input
+ * surface that needs Ctrl+V / paste image support.
+ *
+ * Platforms:
+ * - macOS: `pngpaste -` (brew) or `osascript` with TIFF→PNG conversion
+ * - Linux: `xclip -selection clipboard -target image/png`
+ * - Windows: PowerShell System.Windows.Forms.Clipboard
+ *
+ * Output: PNG Buffer + saved file path under .omk/screenshots/
+ */
+export declare const SCREENSHOT_DIR = ".omk/screenshots";
+export declare const MAX_IMAGE_BYTES: number;
+export interface ClipboardImage {
+    ok: boolean;
+    /** Absolute path to the saved PNG/JPG/WebP/GIF file. */
+    path?: string;
+    /** Project-relative path (e.g. .omk/screenshots/2026-06-08/screenshot-....png). */
+    relativePath?: string;
+    /** Base64 data URI suitable for wire protocol image_url. */
+    dataUri?: string;
+    /** Base64 raw (no prefix). */
+    base64?: string;
+    /** Detected extension: png, jpg, webp, gif. */
+    ext?: string;
+    /** Error message when ok=false. */
+    error?: string;
+}
+export declare function detectImageExt(buf: Buffer): string | null;
+export declare function toDataUri(base64: string, ext: string): string;
+/**
+ * Read an image from the system clipboard. Returns null if clipboard is empty
+ * or contains no image. Platform-specific: macOS (pngpaste/osascript), Linux
+ * (xclip/wl-paste), Windows (PowerShell).
+ */
+export declare function readClipboardImage(platform?: NodeJS.Platform): Buffer | null;
+/**
+ * Read clipboard image, validate, save to .omk/screenshots/, and return
+ * both the file path and base64 data URI for wire protocol use.
+ */
+export declare function pasteClipboardImage(projectRoot: string): ClipboardImage;
+/**
+ * Read an image file from disk, validate, and return base64 data URI.
+ * Used for --image <file> flag support.
+ */
+export declare function readImageFile(filePath: string): ClipboardImage;