@openpond/evals 0.11.16 → 0.11.17

package/dist/types/connected-evidence/contracts.d.ts

@@ -0,0 +1,317 @@
+import { z } from "zod";
+export declare const CONNECTED_EVIDENCE_VERSION: "openpond.connectedEvidence.v1";
+export declare const CONNECTED_NORMALIZER_VERSION: "connected-evidence-1";
+export declare const CONNECTED_EVIDENCE_LIMITS: {
+    readonly files: 100;
+    readonly sourceBytes: number;
+    readonly decodedBytes: number;
+    readonly lineBytes: number;
+    readonly events: 100000;
+    readonly sessions: 1000;
+    readonly boundaries: 5000;
+    readonly evaluatorBytes: number;
+};
+export declare const ConnectedSourceKindSchema: z.ZodEnum<{
+    hermes: "hermes";
+    openclaw: "openclaw";
+    native_chat: "native_chat";
+    native_work: "native_work";
+    codex: "codex";
+    claude_code: "claude_code";
+}>;
+export declare const ConnectedUsageSchema: z.ZodObject<{
+    invocationId: z.ZodString;
+    inputTokens: z.ZodNullable<z.ZodNumber>;
+    outputTokens: z.ZodNullable<z.ZodNumber>;
+    cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+    totalTokens: z.ZodNullable<z.ZodNumber>;
+    provenance: z.ZodEnum<{
+        billed_invocation: "billed_invocation";
+        reported_invocation: "reported_invocation";
+        reported_cumulative: "reported_cumulative";
+    }>;
+}, z.core.$strict>;
+export declare const ConnectedEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        message: "message";
+        unknown: "unknown";
+        artifact: "artifact";
+        terminal: "terminal";
+        usage: "usage";
+        tool_call: "tool_call";
+        tool_result: "tool_result";
+        compaction: "compaction";
+    }>;
+    role: z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        tool: "tool";
+        assistant: "assistant";
+        system: "system";
+    }>>;
+    callId: z.ZodNullable<z.ZodString>;
+    parentId: z.ZodNullable<z.ZodString>;
+    content: z.ZodJSONSchema;
+    usage: z.ZodNullable<z.ZodObject<{
+        invocationId: z.ZodString;
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+        totalTokens: z.ZodNullable<z.ZodNumber>;
+        provenance: z.ZodEnum<{
+            billed_invocation: "billed_invocation";
+            reported_invocation: "reported_invocation";
+            reported_cumulative: "reported_cumulative";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ConnectedBoundarySchema: z.ZodObject<{
+    id: z.ZodString;
+    familyKey: z.ZodString;
+    projection: z.ZodEnum<{
+        turn: "turn";
+        conversation: "conversation";
+    }>;
+    requestEventId: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    inputHash: z.ZodString;
+    outputHash: z.ZodNullable<z.ZodString>;
+    revisionHash: z.ZodString;
+    terminal: z.ZodEnum<{
+        unknown: "unknown";
+        cancelled: "cancelled";
+        failed: "failed";
+        completed: "completed";
+    }>;
+    coverage: z.ZodObject<{
+        answer: z.ZodBoolean;
+        context: z.ZodEnum<{
+            unknown: "unknown";
+            retained: "retained";
+            compacted: "compacted";
+        }>;
+        process: z.ZodEnum<{
+            absent: "absent";
+            partial: "partial";
+            retained: "retained";
+        }>;
+        artifacts: z.ZodEnum<{
+            absent: "absent";
+            retained: "retained";
+            references_only: "references_only";
+        }>;
+        replay: z.ZodLiteral<"unavailable">;
+        gaps: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ConnectedSessionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.connectedEvidence.v1">;
+    normalizerVersion: z.ZodLiteral<"connected-evidence-1">;
+    origin: z.ZodEnum<{
+        hermes: "hermes";
+        openclaw: "openclaw";
+        native_chat: "native_chat";
+        native_work: "native_work";
+        codex: "codex";
+        claude_code: "claude_code";
+    }>;
+    sessionId: z.ZodString;
+    branchId: z.ZodNullable<z.ZodString>;
+    parentSessionId: z.ZodNullable<z.ZodString>;
+    exporterVersion: z.ZodNullable<z.ZodString>;
+    sourceFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strict>>;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sequence: z.ZodNumber;
+        occurredAt: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            message: "message";
+            unknown: "unknown";
+            artifact: "artifact";
+            terminal: "terminal";
+            usage: "usage";
+            tool_call: "tool_call";
+            tool_result: "tool_result";
+            compaction: "compaction";
+        }>;
+        role: z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            tool: "tool";
+            assistant: "assistant";
+            system: "system";
+        }>>;
+        callId: z.ZodNullable<z.ZodString>;
+        parentId: z.ZodNullable<z.ZodString>;
+        content: z.ZodJSONSchema;
+        usage: z.ZodNullable<z.ZodObject<{
+            invocationId: z.ZodString;
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            totalTokens: z.ZodNullable<z.ZodNumber>;
+            provenance: z.ZodEnum<{
+                billed_invocation: "billed_invocation";
+                reported_invocation: "reported_invocation";
+                reported_cumulative: "reported_cumulative";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    unmappedEvents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sequence: z.ZodNumber;
+        occurredAt: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            message: "message";
+            unknown: "unknown";
+            artifact: "artifact";
+            terminal: "terminal";
+            usage: "usage";
+            tool_call: "tool_call";
+            tool_result: "tool_result";
+            compaction: "compaction";
+        }>;
+        role: z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            tool: "tool";
+            assistant: "assistant";
+            system: "system";
+        }>>;
+        callId: z.ZodNullable<z.ZodString>;
+        parentId: z.ZodNullable<z.ZodString>;
+        content: z.ZodJSONSchema;
+        usage: z.ZodNullable<z.ZodObject<{
+            invocationId: z.ZodString;
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            totalTokens: z.ZodNullable<z.ZodNumber>;
+            provenance: z.ZodEnum<{
+                billed_invocation: "billed_invocation";
+                reported_invocation: "reported_invocation";
+                reported_cumulative: "reported_cumulative";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    boundaries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        familyKey: z.ZodString;
+        projection: z.ZodEnum<{
+            turn: "turn";
+            conversation: "conversation";
+        }>;
+        requestEventId: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        inputHash: z.ZodString;
+        outputHash: z.ZodNullable<z.ZodString>;
+        revisionHash: z.ZodString;
+        terminal: z.ZodEnum<{
+            unknown: "unknown";
+            cancelled: "cancelled";
+            failed: "failed";
+            completed: "completed";
+        }>;
+        coverage: z.ZodObject<{
+            answer: z.ZodBoolean;
+            context: z.ZodEnum<{
+                unknown: "unknown";
+                retained: "retained";
+                compacted: "compacted";
+            }>;
+            process: z.ZodEnum<{
+                absent: "absent";
+                partial: "partial";
+                retained: "retained";
+            }>;
+            artifacts: z.ZodEnum<{
+                absent: "absent";
+                retained: "retained";
+                references_only: "references_only";
+            }>;
+            replay: z.ZodLiteral<"unavailable">;
+            gaps: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodString>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ConnectedEvent = z.infer<typeof ConnectedEventSchema>;
+export type ConnectedSession = z.infer<typeof ConnectedSessionSchema>;
+export type ConnectedBoundary = z.infer<typeof ConnectedBoundarySchema>;
+export type ConnectedSourceKind = z.infer<typeof ConnectedSourceKindSchema>;
+export type ConnectedUsage = z.infer<typeof ConnectedUsageSchema>;
+export type ConnectedFile = {
+    path: string;
+    text: string;
+};
+export declare function hasRecordedConnectedAnswer(event: ConnectedEvent): boolean;
+/** Bytes stay in one immutable snapshot; cases retain cutoffs, not copied history. */
+export declare function resolveConnectedBoundary(sessionValue: unknown, boundaryId: string): {
+    input: {
+        id: string;
+        sequence: number;
+        occurredAt: string | null;
+        kind: "message" | "unknown" | "artifact" | "terminal" | "usage" | "tool_call" | "tool_result" | "compaction";
+        role: "user" | "tool" | "assistant" | "system" | null;
+        callId: string | null;
+        parentId: string | null;
+        content: z.core.util.JSONType;
+        usage: {
+            invocationId: string;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            totalTokens: number | null;
+            provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+        } | null;
+    }[];
+    observed: {
+        id: string;
+        sequence: number;
+        occurredAt: string | null;
+        kind: "message" | "unknown" | "artifact" | "terminal" | "usage" | "tool_call" | "tool_result" | "compaction";
+        role: "user" | "tool" | "assistant" | "system" | null;
+        callId: string | null;
+        parentId: string | null;
+        content: z.core.util.JSONType;
+        usage: {
+            invocationId: string;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            totalTokens: number | null;
+            provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+        } | null;
+    }[];
+    answer: string | number | boolean | z.core.util.JSONType[] | {
+        [key: string]: z.core.util.JSONType;
+    } | null;
+    boundary: {
+        id: string;
+        familyKey: string;
+        projection: "turn" | "conversation";
+        requestEventId: string;
+        start: number;
+        end: number;
+        inputHash: string;
+        outputHash: string | null;
+        revisionHash: string;
+        terminal: "unknown" | "cancelled" | "failed" | "completed";
+        coverage: {
+            answer: boolean;
+            context: "unknown" | "retained" | "compacted";
+            process: "absent" | "partial" | "retained";
+            artifacts: "absent" | "retained" | "references_only";
+            replay: "unavailable";
+            gaps: string[];
+        };
+    };
+};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/types/connected-evidence/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,0BAA0B,EAAG,+BAAwC,CAAC;AACnF,eAAO,MAAM,4BAA4B,EAAG,sBAA+B,CAAC;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;CACuF,CAAC;AAK9H,eAAO,MAAM,yBAAyB;;;;;;;EAAuF,CAAC;AAC9H,eAAO,MAAM,oBAAoB;;;;;;;;;;;kBAGtB,CAAC;AACZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMtB,CAAC;AACZ,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQzB,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASxB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,WAK/D;AAED,sFAAsF;AACtF,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBjF"}

package/dist/types/connected-evidence/imports.d.ts

@@ -0,0 +1,19 @@
+import { type ConnectedFile, type ConnectedSession, type ConnectedSourceKind } from "./contracts.js";
+export type ExternalAgentSource = Exclude<ConnectedSourceKind, "native_chat" | "native_work">;
+export type AgentImportPreview = {
+    schemaVersion: "openpond.agentImportPreview.v1";
+    source: ExternalAgentSource;
+    sourceHash: string;
+    sessions: ConnectedSession[];
+    issues: {
+        file: string;
+        message: string;
+    }[];
+};
+/** Never admits malformed files partly or executes referenced paths/commands. */
+export declare function previewAgentImport(input: {
+    source: ExternalAgentSource;
+    files: ConnectedFile[];
+    branchLeafId?: string;
+}): AgentImportPreview;
+//# sourceMappingURL=imports.d.ts.map

package/dist/types/connected-evidence/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/imports.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAMhI,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,EAAE,aAAa,GAAG,aAAa,CAAC,CAAC;AAC9F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,aAAa,EAAE,gCAAgC,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IACjG,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3E,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,kBAAkB,CA8C5I"}

package/dist/types/connected-evidence/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./contracts.js";
+export * from "./normalize.js";
+export * from "./imports.js";
+export * from "./usage-summary.js";
+export * from "./python-correctness.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/connected-evidence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC"}

package/dist/types/connected-evidence/normalize.d.ts

@@ -0,0 +1,25 @@
+import { type ConnectedEvent, type ConnectedFile, type ConnectedSession, type ConnectedSourceKind } from "./contracts.js";
+export declare function connectedTimestamp(value: unknown, units?: "seconds" | "milliseconds"): string | null;
+export declare function connectedFileIdentity(file: ConnectedFile): {
+    path: string;
+    contentHash: string;
+    sizeBytes: number;
+};
+export declare function normalizeConnectedSession(input: {
+    origin: ConnectedSourceKind;
+    sessionId: string;
+    branchId?: string | null;
+    parentSessionId?: string | null;
+    exporterVersion?: string | null;
+    files: ConnectedFile[];
+    events: ConnectedEvent[];
+    warnings?: string[];
+    contextComplete?: boolean;
+    includeConversation?: boolean;
+    unmappedEvents?: ConnectedEvent[];
+}): ConnectedSession;
+export declare function connectedJsonLines(file: ConnectedFile): Record<string, unknown>[];
+export declare function object(value: unknown): Record<string, unknown>;
+export declare function event(input: Partial<ConnectedEvent> & Pick<ConnectedEvent, "id" | "kind" | "content">): ConnectedEvent;
+export declare function json(value: unknown): ConnectedEvent["content"];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/types/connected-evidence/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/normalize.ts"],"names":[],"mappings":"AACA,OAAO,EACmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE3I,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,GAAE,SAAS,GAAG,cAA+B,GAAG,MAAM,GAAG,IAAI,CAIpH;AACD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa;;;;EAExD;AACD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,MAAM,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1G,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,MAAM,EAAE,cAAc,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACjK,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;CACnC,GAAG,gBAAgB,CAoDnB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAWjF;AACD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE9D;AACD,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,cAAc,CAEtH;AACD,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,CAAsD"}

package/dist/types/connected-evidence/python-correctness.d.ts

@@ -0,0 +1,196 @@
+import type { RewardAuthoringFields } from "../learning/reward-authoring.js";
+export declare const PYTHON_CORRECTNESS_PRESET_VERSION = "python-stdio-correctness-1";
+export declare const PYTHON_CORRECTNESS_DESCRIPTION = "Check explicitly admitted Python programs against owner-authored private stdin/stdout cases. Requires a pinned Python binary and fresh network, filesystem and process isolation. Missing code, tests or qualified runtime is unscorable; syntax alone is not correctness.";
+/** This module runs only in an owner-admitted sandbox_process grader. Python -I
+ * isolates Python configuration; bubblewrap separately isolates untrusted code.
+ * The candidate receives each test input, never expected outputs or grader files. */
+export declare const PYTHON_CORRECTNESS_VERIFIER_SOURCE: string;
+export declare function pythonCorrectnessAuthoringFields(): Partial<RewardAuthoringFields>;
+/** Explicit owner publication may import these genuine immutable assets like
+ * any other supplied grader. No publication, compute or capture happens here. */
+export declare function createPythonCorrectnessPreset(): {
+    reward: {
+        schemaVersion: "openpond.rewardRelease.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        implementation: {
+            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            config: Record<string, unknown>;
+        } | {
+            kind: "model_judge";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
+        } | {
+            timeoutMs: number;
+            networkPolicy: "none";
+            kind: "custom_verifier";
+            verifierRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            exportName?: string | undefined;
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+        } | {
+            kind: "human";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            reviewerRole: string;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "category";
+                    options: string[];
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "boolean";
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "text";
+                    maximumLength: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    minimumLength?: number | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "preference";
+                    allowTie: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    requireStrength?: boolean | undefined;
+                })[];
+            } | undefined;
+        } | {
+            kind: "learned_model";
+            modelVersion: {
+                id: string;
+                contentHash: string;
+            };
+            inputContract: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+        };
+        rawScore: {
+            minimum: number;
+            maximum: number;
+        };
+        assets: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        }[];
+        contentHash: string;
+        feedbackKey?: string | undefined;
+        fixtureSetRef?: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        } | undefined;
+        calibrationCheckRef?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | undefined;
+    };
+    assets: {
+        schemaVersion: "openpond.learningTextAsset.v1";
+        id: string;
+        revision: 1;
+        asset: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        };
+        text: string;
+        contentHash: string;
+    }[];
+};
+//# sourceMappingURL=python-correctness.d.ts.map

package/dist/types/connected-evidence/python-correctness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-correctness.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/python-correctness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E,eAAO,MAAM,iCAAiC,+BAA+B,CAAC;AAC9E,eAAO,MAAM,8BAA8B,+QAA+Q,CAAC;AAE3T;;qFAEqF;AACrF,eAAO,MAAM,kCAAkC,QAkD9C,CAAC;AAEF,wBAAgB,gCAAgC,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAGjF;AAED;iFACiF;AACjF,wBAAgB,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ5C"}

package/dist/types/connected-evidence/sources/claude-code.d.ts

@@ -0,0 +1,74 @@
+import type { ConnectedFile } from "../contracts.js";
+export declare function parseClaudeSession(file: ConnectedFile, rows: Record<string, unknown>[], leafId?: string): {
+    schemaVersion: "openpond.connectedEvidence.v1";
+    normalizerVersion: "connected-evidence-1";
+    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+    sessionId: string;
+    branchId: string | null;
+    parentSessionId: string | null;
+    exporterVersion: string | null;
+    sourceFiles: {
+        path: string;
+        contentHash: string;
+        sizeBytes: number;
+    }[];
+    events: {
+        id: string;
+        sequence: number;
+        occurredAt: string | null;
+        kind: "message" | "unknown" | "artifact" | "terminal" | "usage" | "tool_call" | "tool_result" | "compaction";
+        role: "user" | "tool" | "assistant" | "system" | null;
+        callId: string | null;
+        parentId: string | null;
+        content: import("zod").JSONType;
+        usage: {
+            invocationId: string;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            totalTokens: number | null;
+            provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+        } | null;
+    }[];
+    unmappedEvents: {
+        id: string;
+        sequence: number;
+        occurredAt: string | null;
+        kind: "message" | "unknown" | "artifact" | "terminal" | "usage" | "tool_call" | "tool_result" | "compaction";
+        role: "user" | "tool" | "assistant" | "system" | null;
+        callId: string | null;
+        parentId: string | null;
+        content: import("zod").JSONType;
+        usage: {
+            invocationId: string;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            totalTokens: number | null;
+            provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+        } | null;
+    }[];
+    boundaries: {
+        id: string;
+        familyKey: string;
+        projection: "turn" | "conversation";
+        requestEventId: string;
+        start: number;
+        end: number;
+        inputHash: string;
+        outputHash: string | null;
+        revisionHash: string;
+        terminal: "unknown" | "cancelled" | "failed" | "completed";
+        coverage: {
+            answer: boolean;
+            context: "unknown" | "retained" | "compacted";
+            process: "absent" | "partial" | "retained";
+            artifacts: "absent" | "retained" | "references_only";
+            replay: "unavailable";
+            gaps: string[];
+        };
+    }[];
+    warnings: string[];
+    contentHash: string;
+};
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/types/connected-evidence/sources/claude-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/claude-code.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkDvG"}