open-multi-agent-kit 0.78.0

package/dist/contracts/replay.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Replay contracts — deterministic execution reproducibility.
+ *
+ * A ReplayManifest captures every decision, context capsule, and evidence
+ * sequence so that a run can be audited, replayed, or diffed.
+ */
+import type { AttemptStatus, RuntimeId } from "../evidence/attempt-record.js";
+export type DecisionComponent = "runtime-router" | "context-broker" | "repair-policy" | "evidence-gate" | "scheduler" | "provider-router" | "ensemble-decision" | "skill-assigner";
+export interface DecisionTraceEntry {
+    readonly at: string;
+    readonly component: DecisionComponent;
+    readonly inputSummary: string;
+    readonly outputDecision: string;
+    readonly reason: string;
+    readonly scores?: Record<string, number>;
+    readonly nodeId?: string;
+    readonly attemptId?: string;
+}
+export interface ReplayAttemptRecord {
+    readonly attemptId: string;
+    readonly runtime: RuntimeId;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly contextCapsulePath: string;
+    readonly promptSnapshotPath: string;
+    readonly toolEventsPath: string;
+    readonly evidencePath: string;
+    readonly diffPatchPath?: string;
+    readonly decisionTracePath: string;
+    readonly startedAt: string;
+    readonly endedAt?: string;
+    readonly latencyMs?: number;
+    readonly status: AttemptStatus;
+    readonly error?: string;
+    readonly inputTokensEstimated: number;
+    readonly outputTokensEstimated: number;
+    readonly toolResultTokensEstimated: number;
+    readonly costUsdEstimated?: number;
+    readonly decisionTrace: readonly DecisionTraceEntry[];
+}
+export interface ReplayNodeRecord {
+    readonly nodeId: string;
+    readonly nodeName?: string;
+    readonly role?: string;
+    readonly attempts: readonly ReplayAttemptRecord[];
+    readonly finalStatus: "success" | "failed" | "skipped" | "cancelled";
+    readonly totalLatencyMs: number;
+    readonly totalCostUsd: number;
+}
+export interface ReplayManifest {
+    readonly runId: string;
+    readonly omkVersion: string;
+    readonly dagHash: string;
+    readonly policyHash: string;
+    readonly routerPolicyHash: string;
+    readonly repairPolicyHash: string;
+    readonly contextPolicyHash: string;
+    readonly startedAt: string;
+    readonly completedAt?: string;
+    readonly nodes: readonly ReplayNodeRecord[];
+    readonly summary: {
+        readonly totalNodes: number;
+        readonly totalAttempts: number;
+        readonly successCount: number;
+        readonly failureCount: number;
+        readonly skippedCount: number;
+        readonly totalLatencyMs: number;
+        readonly totalCostUsd: number;
+        readonly totalInputTokens: number;
+        readonly totalOutputTokens: number;
+    };
+}
+export interface ReplayDiffEntry {
+    readonly kind: "node-added" | "node-removed" | "attempt-count" | "status-changed" | "decision-changed" | "latency" | "cost" | "token-delta" | "context-changed" | "evidence-changed" | "repair-changed";
+    readonly nodeId: string;
+    readonly runA: string;
+    readonly runB: string;
+    readonly detail: string;
+    readonly values?: {
+        a?: string | number;
+        b?: string | number;
+    };
+}
+export interface ReplayDiffReport {
+    readonly runA: string;
+    readonly runB: string;
+    readonly dagHashMatch: boolean;
+    readonly policyHashMatch: boolean;
+    readonly entries: readonly ReplayDiffEntry[];
+}
+export interface ReplayValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+}

package/dist/contracts/replay.js

@@ -0,0 +1,7 @@
+/**
+ * Replay contracts — deterministic execution reproducibility.
+ *
+ * A ReplayManifest captures every decision, context capsule, and evidence
+ * sequence so that a run can be audited, replayed, or diffed.
+ */
+export {};

package/dist/contracts/run.d.ts

@@ -0,0 +1,34 @@
+import type { OMK_RUN_MANIFEST_SCHEMA_VERSION } from "../version.js";
+import type { ProviderPolicy } from "./provider.js";
+export type RunStatus = "running" | "passed" | "failed" | "blocked" | "partial";
+export type RunNodeSummary = {
+    nodeId: string;
+    label?: string;
+    status: RunStatus;
+    provider?: string;
+    startedAt?: string;
+    completedAt?: string;
+};
+export type RunArtifactRef = {
+    kind: string;
+    path: string;
+    sha256?: string;
+};
+export type RunManifest = {
+    schemaVersion: typeof OMK_RUN_MANIFEST_SCHEMA_VERSION;
+    runId: string;
+    createdAt: string;
+    completedAt?: string;
+    status: RunStatus;
+    promptHash?: string;
+    providerPolicy: ProviderPolicy;
+    nodes: RunNodeSummary[];
+    artifacts: RunArtifactRef[];
+    evidenceSummary: {
+        required: number;
+        passed: number;
+        failed: number;
+        missing: number;
+    };
+    decisionTracePath?: string;
+};

package/dist/contracts/run.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/safety.d.ts

@@ -0,0 +1,10 @@
+export interface ApprovalContext {
+    tool: string;
+    input: unknown;
+    workerId?: string;
+    runId?: string;
+}
+export type ApprovalDecision = "allow" | "block" | "ask";
+export interface PolicyEngine {
+    decide(ctx: ApprovalContext): Promise<ApprovalDecision>;
+}

package/dist/contracts/safety.js

@@ -0,0 +1,4 @@
+// Contract: src/contracts/safety.ts
+// Owner: Contract Worker (Phase 0)
+// Read-only for all other workers. Version-bump only via Integration Worker.
+export {};

package/dist/contracts/version.d.ts

@@ -0,0 +1,21 @@
+import type { OMK_RUNTIME_VERSION, OMK_VERSION_SCHEMA_VERSION } from "../version.js";
+export type VersionMismatch = {
+    file: string;
+    expected: string;
+    actual: string;
+};
+export type VersionReport = {
+    schemaVersion: typeof OMK_VERSION_SCHEMA_VERSION;
+    packageName: string;
+    packageVersion: string;
+    runtimeVersion: typeof OMK_RUNTIME_VERSION;
+    schemaVersions: string[];
+    gitCommit?: string;
+    gitBranch?: string;
+    npmPublishedVersion?: string;
+    sourceTarget?: string;
+    releaseCandidate?: string;
+    dirty: boolean;
+    consistent: boolean;
+    mismatches: VersionMismatch[];
+};

package/dist/contracts/version.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/web-bridge.d.ts

@@ -0,0 +1,95 @@
+export declare const WEB_BRIDGE_SCHEMA_VERSION: 1;
+export declare const WEB_BRIDGE_NATIVE_HOST_NAME = "io.ohmykimi.web_bridge";
+export declare const WEB_BRIDGE_MCP_SERVER_NAME = "omk-web-bridge";
+export declare const WEB_BRIDGE_MAX_TEXT_CHARS = 120000;
+export declare const WEB_BRIDGE_MAX_PAYLOAD_BYTES = 1000000;
+export type WebBridgeReadMethod = "bridge.ping" | "bridge.status" | "bridge.capabilities" | "browser.tabs.list" | "browser.page.read" | "browser.selection.read" | "browser.dom.query" | "browser.screenshot.capture" | "orchestration.context.write";
+export type WebBridgeMutationMethod = "browser.action.request";
+export type WebBridgeMethod = WebBridgeReadMethod | WebBridgeMutationMethod;
+export type WebBridgeActionKind = "click" | "formFill" | "download" | "upload" | "post" | "clipboardWrite" | "navigate";
+export interface WebBridgeApproval {
+    token: string;
+    expiresAt: string;
+    method: WebBridgeMutationMethod;
+    target: string;
+    argsDigest: string;
+}
+export interface WebBridgeRequestEnvelope<TParams = unknown> {
+    schemaVersion: typeof WEB_BRIDGE_SCHEMA_VERSION;
+    requestId: string;
+    method: WebBridgeMethod;
+    params?: TParams;
+    origin?: string;
+    nonce?: string;
+    approval?: WebBridgeApproval;
+}
+export interface WebBridgeError {
+    code: "invalid_schema" | "unknown_method" | "payload_too_large" | "unsafe_mutation" | "approval_required" | "not_connected" | "internal_error";
+    message: string;
+    retryable?: boolean;
+}
+export interface WebBridgeResponseEnvelope<TResult = unknown> {
+    schemaVersion: typeof WEB_BRIDGE_SCHEMA_VERSION;
+    requestId: string;
+    ok: boolean;
+    result?: TResult;
+    error?: WebBridgeError;
+}
+export interface WebBridgeTabInfo {
+    id: string | number;
+    url?: string;
+    title?: string;
+    active?: boolean;
+    windowId?: string | number;
+}
+export interface WebBridgePageMetadata {
+    url?: string;
+    title?: string;
+    description?: string;
+    language?: string;
+    contentType?: string;
+    capturedAt?: string;
+    source?: "chrome-extension" | "native-host" | "mock" | "artifact";
+    [key: string]: unknown;
+}
+export interface WebBridgeScreenshotRef {
+    mimeType: "image/png" | "image/jpeg";
+    bytes?: string;
+    artifactPath?: string;
+    redacted?: boolean;
+}
+export interface WebBridgePageSnapshot {
+    tab?: WebBridgeTabInfo;
+    tabs?: WebBridgeTabInfo[];
+    metadata?: WebBridgePageMetadata;
+    text?: string;
+    selectedText?: string;
+    dom?: string;
+    screenshot?: WebBridgeScreenshotRef;
+    warnings?: string[];
+}
+export interface WebBridgeCapabilities {
+    schemaVersion: typeof WEB_BRIDGE_SCHEMA_VERSION;
+    readOnlyDefault: true;
+    supportsTabs: boolean;
+    supportsPageText: boolean;
+    supportsSelection: boolean;
+    supportsDom: boolean;
+    supportsScreenshot: boolean;
+    supportsMutations: false;
+    mutationsRequireApproval: true;
+    forbiddenData: string[];
+    methods: WebBridgeMethod[];
+}
+export declare function getDefaultWebBridgeCapabilities(): WebBridgeCapabilities;
+export declare function isWebBridgeMethod(value: string): value is WebBridgeMethod;
+export declare function isWebBridgeMutation(method: WebBridgeMethod): method is WebBridgeMutationMethod;
+export declare function createWebBridgeErrorResponse(requestId: string, code: WebBridgeError["code"], message: string, options?: {
+    retryable?: boolean;
+}): WebBridgeResponseEnvelope;
+export declare function createWebBridgeOkResponse<TResult>(requestId: string, result: TResult): WebBridgeResponseEnvelope<TResult>;
+export declare function validateWebBridgeRequest(input: unknown): WebBridgeRequestEnvelope;
+export declare function assertReadOnlyWebBridgeRequest(request: WebBridgeRequestEnvelope): void;
+export declare function sanitizeWebBridgePageSnapshot(snapshot: WebBridgePageSnapshot): WebBridgePageSnapshot;
+export declare function redactWebBridgeValue<T>(value: T): T;
+export declare function truncateBridgeText(value: string | undefined, maxChars?: number): string | undefined;

package/dist/contracts/web-bridge.js

@@ -0,0 +1,168 @@
+import { maskSensitiveText } from "../util/secret-mask.js";
+export const WEB_BRIDGE_SCHEMA_VERSION = 1;
+export const WEB_BRIDGE_NATIVE_HOST_NAME = "io.ohmykimi.web_bridge";
+export const WEB_BRIDGE_MCP_SERVER_NAME = "omk-web-bridge";
+export const WEB_BRIDGE_MAX_TEXT_CHARS = 120_000;
+export const WEB_BRIDGE_MAX_PAYLOAD_BYTES = 1_000_000;
+const READ_METHODS = [
+    "bridge.ping",
+    "bridge.status",
+    "bridge.capabilities",
+    "browser.tabs.list",
+    "browser.page.read",
+    "browser.selection.read",
+    "browser.dom.query",
+    "browser.screenshot.capture",
+    "orchestration.context.write",
+];
+const MUTATION_METHODS = ["browser.action.request"];
+const METHODS = new Set([...READ_METHODS, ...MUTATION_METHODS]);
+const SENSITIVE_KEY_RE = /(?:cookie|set-cookie|authorization|proxy-authorization|password|passwd|token|secret|credential|localstorage|sessionstorage|indexeddb|auth|privatekey|api[-_]?key)/iu;
+export function getDefaultWebBridgeCapabilities() {
+    return {
+        schemaVersion: WEB_BRIDGE_SCHEMA_VERSION,
+        readOnlyDefault: true,
+        supportsTabs: true,
+        supportsPageText: true,
+        supportsSelection: true,
+        supportsDom: true,
+        supportsScreenshot: true,
+        supportsMutations: false,
+        mutationsRequireApproval: true,
+        forbiddenData: [
+            "cookies",
+            "passwords",
+            "localStorage",
+            "sessionStorage",
+            "indexedDB",
+            "authorization headers",
+            "raw secrets",
+        ],
+        methods: [...READ_METHODS, ...MUTATION_METHODS],
+    };
+}
+export function isWebBridgeMethod(value) {
+    return METHODS.has(value);
+}
+export function isWebBridgeMutation(method) {
+    return MUTATION_METHODS.includes(method);
+}
+export function createWebBridgeErrorResponse(requestId, code, message, options = {}) {
+    return {
+        schemaVersion: WEB_BRIDGE_SCHEMA_VERSION,
+        requestId,
+        ok: false,
+        error: {
+            code,
+            message: maskSensitiveText(message),
+            ...(options.retryable === undefined ? {} : { retryable: options.retryable }),
+        },
+    };
+}
+export function createWebBridgeOkResponse(requestId, result) {
+    return {
+        schemaVersion: WEB_BRIDGE_SCHEMA_VERSION,
+        requestId,
+        ok: true,
+        result: redactWebBridgeValue(result),
+    };
+}
+export function validateWebBridgeRequest(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("Web bridge request must be an object");
+    }
+    const value = input;
+    if (value.schemaVersion !== WEB_BRIDGE_SCHEMA_VERSION) {
+        throw new Error(`Unsupported web bridge schemaVersion: ${String(value.schemaVersion)}`);
+    }
+    if (typeof value.requestId !== "string" || value.requestId.trim() === "") {
+        throw new Error("Web bridge requestId must be a non-empty string");
+    }
+    if (typeof value.method !== "string" || !isWebBridgeMethod(value.method)) {
+        throw new Error(`Unknown web bridge method: ${String(value.method)}`);
+    }
+    const origin = typeof value.origin === "string" ? maskSensitiveText(value.origin) : undefined;
+    const nonce = typeof value.nonce === "string" ? value.nonce : undefined;
+    const approval = parseApproval(value.approval);
+    return {
+        schemaVersion: WEB_BRIDGE_SCHEMA_VERSION,
+        requestId: value.requestId,
+        method: value.method,
+        ...(value.params === undefined ? {} : { params: redactWebBridgeValue(value.params) }),
+        ...(origin === undefined ? {} : { origin }),
+        ...(nonce === undefined ? {} : { nonce }),
+        ...(approval === undefined ? {} : { approval }),
+    };
+}
+export function assertReadOnlyWebBridgeRequest(request) {
+    if (!isWebBridgeMutation(request.method))
+        return;
+    throw new Error("Mutating browser actions require explicit approval and are disabled by default");
+}
+export function sanitizeWebBridgePageSnapshot(snapshot) {
+    const sanitized = redactWebBridgeValue(snapshot);
+    return {
+        ...sanitized,
+        text: truncateBridgeText(sanitized.text),
+        selectedText: truncateBridgeText(sanitized.selectedText),
+        dom: truncateBridgeText(sanitized.dom),
+        warnings: normalizeWarnings(sanitized.warnings),
+    };
+}
+export function redactWebBridgeValue(value) {
+    return redactUnknown(value);
+}
+export function truncateBridgeText(value, maxChars = WEB_BRIDGE_MAX_TEXT_CHARS) {
+    if (typeof value !== "string")
+        return undefined;
+    const masked = maskSensitiveText(value)
+        .replace(/\b(localStorage|sessionStorage|indexedDB)\s*[:=]\s*[^\n\r;]+/giu, "$1: [redacted]")
+        .replace(/(<input\b[^>]*type=["']?password["']?[^>]*)(value=["'][^"']*["'])/giu, "$1value=" + JSON.stringify("[redacted]"));
+    if (masked.length <= maxChars)
+        return masked;
+    return `${masked.slice(0, maxChars)}\n[truncated:${masked.length - maxChars}]`;
+}
+function redactUnknown(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string")
+        return truncateBridgeText(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => redactUnknown(item));
+    if (typeof value !== "object")
+        return String(value);
+    const output = {};
+    for (const [key, nested] of Object.entries(value)) {
+        if (SENSITIVE_KEY_RE.test(key)) {
+            output[key] = "[redacted]";
+            continue;
+        }
+        output[key] = redactUnknown(nested);
+    }
+    return output;
+}
+function parseApproval(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    if (typeof raw.token !== "string" ||
+        typeof raw.expiresAt !== "string" ||
+        raw.method !== "browser.action.request" ||
+        typeof raw.target !== "string" ||
+        typeof raw.argsDigest !== "string") {
+        return undefined;
+    }
+    return {
+        token: "[redacted]",
+        expiresAt: raw.expiresAt,
+        method: "browser.action.request",
+        target: maskSensitiveText(raw.target),
+        argsDigest: raw.argsDigest,
+    };
+}
+function normalizeWarnings(value) {
+    const warnings = Array.isArray(value) ? value : [];
+    return [...new Set(warnings.map((item) => maskSensitiveText(String(item))).filter(Boolean))].slice(0, 20);
+}

package/dist/contracts/worker-context.d.ts

@@ -0,0 +1,70 @@
+export type OmkRuntimeScope = "all" | "project" | "none";
+export interface GoalExecutionContext {
+    readonly runId: string;
+    readonly goalId?: string;
+    readonly objective?: string;
+    readonly root: string;
+    readonly mcpScope: OmkRuntimeScope;
+    readonly skillsScope: OmkRuntimeScope;
+    readonly hooksScope: OmkRuntimeScope;
+}
+export interface WorkerProviderManifest {
+    readonly preferred: readonly string[];
+    readonly fallbackChain: readonly string[];
+    readonly selectedRuntimeId?: string;
+    readonly model?: string;
+}
+export interface WorkerToolPlaneManifest {
+    readonly mcpServers: readonly string[];
+    readonly mcpConfigFile?: string;
+    readonly skills: readonly string[];
+    readonly hooks: readonly string[];
+    readonly tools: readonly string[];
+    readonly requiresRuntimeMcp: boolean;
+}
+export interface WorkerCapabilityManifest {
+    readonly read: boolean;
+    readonly write: boolean;
+    readonly shell: boolean;
+    readonly mcp: boolean;
+    readonly patch: boolean;
+    readonly review: boolean;
+    readonly merge: boolean;
+    readonly vision: boolean;
+    readonly toolCalling?: boolean;
+    readonly maxTokens?: number;
+}
+export interface WorkerManifestArtifacts {
+    readonly harnessPath?: string;
+    readonly agentYamlPath?: string;
+    readonly logPath?: string;
+}
+export interface WorkerManifest {
+    readonly schemaVersion: 1;
+    readonly owner: "omk";
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly role?: string;
+    readonly provider: WorkerProviderManifest;
+    readonly toolPlane: WorkerToolPlaneManifest;
+    readonly capabilities: WorkerCapabilityManifest;
+    readonly artifacts: WorkerManifestArtifacts;
+    readonly createdAt: string;
+}
+export type EnvMergeTraceSource = "base" | "node" | "worker-manifest";
+export type EnvMergeTraceAction = "set" | "overwrite" | "preserve-non-empty" | "drop-empty";
+export interface EnvMergeTraceEntry {
+    readonly key: string;
+    readonly previous?: string;
+    readonly next: string;
+    readonly source: EnvMergeTraceSource;
+    readonly action: EnvMergeTraceAction;
+}
+export interface TaskRunDiagnostics {
+    readonly envMergeTrace?: readonly EnvMergeTraceEntry[];
+}
+export interface TaskRunContext {
+    readonly goal: GoalExecutionContext;
+    readonly worker: WorkerManifest;
+    readonly diagnostics?: TaskRunDiagnostics;
+}

package/dist/contracts/worker-context.js

@@ -0,0 +1 @@
+export {};

package/dist/evidence/attempt-record.d.ts

@@ -0,0 +1,78 @@
+/**
+ * AttemptRecord — evidence-driven attempt tracking.
+ *
+ * Each attempt captures full context: runtime, tokens, evidence results,
+ * changed files, and failure diagnosis for retry strategy selection.
+ */
+export type AttemptStatus = "success" | "runtime_failed" | "tool_failed" | "evidence_failed" | "context_overflow" | "cancelled" | "timeout";
+export type RuntimeId = "kimi-wire" | "kimi-print" | "openai-compatible" | "deepseek" | "local";
+export interface EvidenceResult {
+    readonly gate: string;
+    readonly passed: boolean;
+    readonly ref?: string;
+    readonly message?: string;
+}
+export interface AttemptRecord {
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly attemptId: string;
+    readonly runtime: RuntimeId;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly startedAt: string;
+    readonly endedAt?: string;
+    readonly latencyMs?: number;
+    readonly inputTokensEstimated: number;
+    readonly outputTokensEstimated: number;
+    readonly toolResultTokensEstimated: number;
+    readonly costUsdEstimated?: number;
+    readonly contextHash: string;
+    readonly promptHash: string;
+    readonly status: AttemptStatus;
+    readonly error?: string;
+    readonly evidenceResults: readonly EvidenceResult[];
+    readonly changedFiles: readonly string[];
+    readonly summary: string;
+    readonly totalTokensEstimated: number;
+    readonly evidencePassCount: number;
+    readonly evidenceFailCount: number;
+    readonly evidencePassRate: number;
+    readonly evidencePassRatePerToken: number;
+    readonly worktreePath?: string;
+}
+export interface DiagnosisResult {
+    readonly category: AttemptStatus;
+    readonly rootCause: string;
+    readonly retryStrategy: RetryStrategy;
+    readonly suggestedContextAdjustment?: ContextAdjustment;
+    readonly suggestedProviderSwitch?: string;
+    readonly confidence: number;
+}
+export interface RetryStrategy {
+    readonly action: "retry-same" | "retry-with-context" | "fallback-provider" | "skip" | "abort";
+    readonly delayMs?: number;
+    readonly maxRetries?: number;
+    readonly reason: string;
+}
+export interface ContextAdjustment {
+    readonly addFiles?: readonly string[];
+    readonly removeFiles?: readonly string[];
+    readonly addMemory?: readonly string[];
+    readonly budgetChange?: Partial<{
+        maxInputTokens: number;
+        maxToolResultTokens: number;
+        compression: "none" | "lossless-ish" | "summary" | "aggressive";
+    }>;
+    readonly promptPatch?: string;
+}
+export type RepairAction = "retry-same" | "retry-with-context" | "fallback-provider" | "split-node" | "escalate" | "skip" | "abort";
+export interface RepairDecision {
+    readonly action: RepairAction;
+    readonly reason: string;
+    readonly adjustment?: ContextAdjustment;
+    readonly fallbackProvider?: string;
+    readonly splitParts?: number;
+    readonly escalateMessage?: string;
+}
+export declare function createAttemptId(nodeId: string, attempt: number): string;
+export declare function hashContent(content: string): string;

package/dist/evidence/attempt-record.js

@@ -0,0 +1,16 @@
+/**
+ * AttemptRecord — evidence-driven attempt tracking.
+ *
+ * Each attempt captures full context: runtime, tokens, evidence results,
+ * changed files, and failure diagnosis for retry strategy selection.
+ */
+export function createAttemptId(nodeId, attempt) {
+    return `${nodeId}__${attempt}`;
+}
+export function hashContent(content) {
+    let h = 0;
+    for (let i = 0; i < content.length; i++) {
+        h = ((h << 5) - h + content.charCodeAt(i)) | 0;
+    }
+    return Math.abs(h).toString(36);
+}

package/dist/evidence/context-snapshot.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ContextSnapshot — persisted snapshot of ContextCapsule per attempt.
+ *
+ * Enables post-hoc analysis of what context was provided to each runtime,
+ * supporting diagnosis of context_overflow and evidence_failed attempts.
+ */
+import type { ContextCapsule } from "../runtime/context-capsule.js";
+export interface ContextSnapshotMeta {
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly attemptId: string;
+    readonly capturedAt: string;
+    readonly estimatedTokens: number;
+}
+export interface ContextSnapshotStore {
+    save(capsule: ContextCapsule, attemptId: string): Promise<void>;
+    load(runId: string, nodeId: string, attemptId: string): Promise<ContextCapsule | null>;
+    list(runId: string): Promise<ContextSnapshotMeta[]>;
+}
+export declare function createContextSnapshotStore(runsDir?: string): ContextSnapshotStore;