@openpond/evals 0.11.16 → 0.11.17

package/dist/connected-evidence/contracts.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+export const CONNECTED_EVIDENCE_VERSION = "openpond.connectedEvidence.v1";
+export const CONNECTED_NORMALIZER_VERSION = "connected-evidence-1";
+export const CONNECTED_EVIDENCE_LIMITS = { files: 100, sourceBytes: 32 * 1024 * 1024, decodedBytes: 64 * 1024 * 1024,
+    lineBytes: 2 * 1024 * 1024, events: 100_000, sessions: 1_000, boundaries: 5_000, evaluatorBytes: 2 * 1024 * 1024 };
+const Id = z.string().min(1).max(500);
+const Hash = z.string().regex(/^[a-f0-9]{64}$/);
+const Time = z.string().datetime().nullable();
+const Tokens = z.number().int().nonnegative().nullable();
+export const ConnectedSourceKindSchema = z.enum(["native_chat", "native_work", "codex", "claude_code", "hermes", "openclaw"]);
+export const ConnectedUsageSchema = z.object({
+    invocationId: Id, inputTokens: Tokens, outputTokens: Tokens, cachedInputTokens: Tokens,
+    totalTokens: Tokens, provenance: z.enum(["billed_invocation", "reported_invocation", "reported_cumulative"]),
+}).strict();
+export const ConnectedEventSchema = z.object({
+    id: Id, sequence: z.number().int().nonnegative(), occurredAt: Time,
+    kind: z.enum(["message", "tool_call", "tool_result", "compaction", "artifact", "terminal", "usage", "unknown"]),
+    role: z.enum(["user", "assistant", "system", "tool"]).nullable(),
+    callId: Id.nullable(), parentId: Id.nullable(), content: z.json(),
+    usage: ConnectedUsageSchema.nullable(),
+}).strict();
+export const ConnectedBoundarySchema = z.object({
+    id: Id, familyKey: Id, projection: z.enum(["turn", "conversation"]),
+    requestEventId: Id, start: z.number().int().nonnegative(), end: z.number().int().positive(),
+    inputHash: Hash, outputHash: Hash.nullable(), revisionHash: Hash,
+    terminal: z.enum(["completed", "failed", "cancelled", "unknown"]),
+    coverage: z.object({ answer: z.boolean(), context: z.enum(["retained", "compacted", "unknown"]),
+        process: z.enum(["retained", "partial", "absent"]), artifacts: z.enum(["retained", "references_only", "absent"]),
+        replay: z.literal("unavailable"), gaps: z.array(z.string().max(500)).max(100) }).strict(),
+}).strict();
+export const ConnectedSessionSchema = z.object({
+    schemaVersion: z.literal(CONNECTED_EVIDENCE_VERSION), normalizerVersion: z.literal(CONNECTED_NORMALIZER_VERSION),
+    origin: ConnectedSourceKindSchema, sessionId: Id, branchId: Id.nullable(), parentSessionId: Id.nullable(),
+    exporterVersion: z.string().max(200).nullable(),
+    sourceFiles: z.array(z.object({ path: Id, contentHash: Hash, sizeBytes: z.number().int().nonnegative() }).strict()).max(CONNECTED_EVIDENCE_LIMITS.files),
+    events: z.array(ConnectedEventSchema).max(CONNECTED_EVIDENCE_LIMITS.events),
+    unmappedEvents: z.array(ConnectedEventSchema).max(CONNECTED_EVIDENCE_LIMITS.events),
+    boundaries: z.array(ConnectedBoundarySchema).max(CONNECTED_EVIDENCE_LIMITS.boundaries),
+    warnings: z.array(z.string().max(500)).max(100), contentHash: Hash,
+}).strict();
+export function hasRecordedConnectedAnswer(event) {
+    if (event.kind !== "message" || event.role !== "assistant" || event.content === null)
+        return false;
+    if (typeof event.content === "string")
+        return event.content.trim().length > 0;
+    if (Array.isArray(event.content))
+        return event.content.length > 0;
+    return typeof event.content !== "object" || !("text" in event.content) || typeof event.content.text === "string" && event.content.text.trim().length > 0;
+}
+/** Bytes stay in one immutable snapshot; cases retain cutoffs, not copied history. */
+export function resolveConnectedBoundary(sessionValue, boundaryId) {
+    const session = ConnectedSessionSchema.parse(sessionValue);
+    const { contentHash: actual, ...body } = session;
+    if (contentHash(body) !== actual)
+        throw new Error("connected_evidence_hash_mismatch");
+    const boundary = session.boundaries.find(item => item.id === boundaryId);
+    if (!boundary)
+        throw new Error("connected_boundary_missing");
+    const input = session.events.slice(0, boundary.start + 1);
+    const observed = session.events.slice(boundary.start + 1, boundary.end);
+    if (contentHash(input) !== boundary.inputHash || contentHash(observed) !== boundary.revisionHash)
+        throw new Error("connected_boundary_hash_mismatch");
+    const answers = observed.filter(hasRecordedConnectedAnswer);
+    const answer = boundary.projection === "conversation" ? answers.map(event => event.content) : answers.at(-1)?.content ?? null;
+    if ((answers.length ? contentHash(answer) : null) !== boundary.outputHash)
+        throw new Error("connected_output_hash_mismatch");
+    const value = { input, observed, answer, boundary };
+    if (new TextEncoder().encode(JSON.stringify(value)).length > CONNECTED_EVIDENCE_LIMITS.evaluatorBytes)
+        throw new Error("connected_evaluator_context_too_large");
+    return value;
+}

package/dist/connected-evidence/imports.js

@@ -0,0 +1,71 @@
+import { contentHash } from "@openpond/harness";
+import { CONNECTED_EVIDENCE_LIMITS } from "./contracts.js";
+import { connectedJsonLines } from "./normalize.js";
+import { parseCodexSession } from "./sources/codex.js";
+import { parseClaudeSession } from "./sources/claude-code.js";
+import { parseHermesEvidence, parseOpenClawEvidence } from "./sources/history.js";
+/** Never admits malformed files partly or executes referenced paths/commands. */
+export function previewAgentImport(input) {
+    if (!input.files.length || input.files.length > CONNECTED_EVIDENCE_LIMITS.files)
+        throw new Error("Choose between 1 and 100 source files.");
+    const paths = new Set();
+    let bytes = 0;
+    for (const file of input.files) {
+        if (file.path.length > 500 || file.path.startsWith("/") || file.path.includes("\\") || file.path.split("/").some(part => !part || part === "." || part === "..") || paths.has(file.path))
+            throw new Error("Unsafe or duplicate source file path.");
+        paths.add(file.path);
+        bytes += new TextEncoder().encode(file.text).length;
+    }
+    if (bytes > CONNECTED_EVIDENCE_LIMITS.decodedBytes)
+        throw new Error("Decoded source files exceed 64 MiB.");
+    const sessions = [], issues = [];
+    const attempt = (file, parse) => {
+        try {
+            sessions.push(...parse());
+        }
+        catch (error) {
+            issues.push({ file, message: error instanceof Error ? error.message : "Unsupported session." });
+        }
+    };
+    if (input.source === "openclaw")
+        attempt("manifest.json", () => {
+            const root = input.files[0].path.split("/")[0];
+            const files = !input.files.some(file => file.path === "manifest.json") && input.files.every(file => file.path.startsWith(`${root}/`))
+                ? input.files.map(file => ({ ...file, path: file.path.slice(root.length + 1) })) : input.files;
+            return [parseOpenClawEvidence(files)];
+        });
+    else
+        for (const file of input.files)
+            attempt(file.path, () => {
+                let rows;
+                if (input.source === "hermes" && file.path.endsWith(".json")) {
+                    const value = JSON.parse(file.text.replace(/^\uFEFF/u, ""));
+                    if (!value || typeof value !== "object" || Array.isArray(value))
+                        throw new Error("Hermes session backup must be one JSON object.");
+                    rows = [value];
+                }
+                else
+                    rows = connectedJsonLines(file);
+                if (input.source === "codex")
+                    return [parseCodexSession(file, rows)];
+                if (input.source === "claude_code")
+                    return [parseClaudeSession(file, rows, input.branchLeafId)];
+                if (input.source === "hermes")
+                    return rows.map(row => parseHermesEvidence(file, row));
+                throw new Error("Unsupported source adapter.");
+            });
+    if (sessions.length > CONNECTED_EVIDENCE_LIMITS.sessions || sessions.reduce((total, session) => total + session.events.length + session.unmappedEvents.length, 0) > CONNECTED_EVIDENCE_LIMITS.events
+        || sessions.reduce((total, session) => total + session.boundaries.length, 0) > CONNECTED_EVIDENCE_LIMITS.boundaries)
+        throw new Error("Import exceeds the session/event/boundary limit.");
+    const identities = new Map();
+    for (const session of sessions) {
+        const key = JSON.stringify([session.origin, session.sessionId, session.branchId]);
+        const prior = identities.get(key);
+        if (prior && prior !== session.contentHash)
+            throw new Error("The same session has different contents in this selection. Choose one export.");
+        identities.set(key, session.contentHash);
+    }
+    return { schemaVersion: "openpond.agentImportPreview.v1", source: input.source,
+        sourceHash: contentHash({ source: input.source, files: [...input.files].sort((a, b) => a.path.localeCompare(b.path)), branchLeafId: input.branchLeafId ?? null }),
+        sessions: sessions.filter((session, index) => sessions.findIndex(other => other.contentHash === session.contentHash) === index), issues };
+}

package/dist/connected-evidence/index.js

@@ -0,0 +1,5 @@
+export * from "./contracts.js";
+export * from "./normalize.js";
+export * from "./imports.js";
+export * from "./usage-summary.js";
+export * from "./python-correctness.js";

package/dist/connected-evidence/normalize.js

@@ -0,0 +1,97 @@
+import { contentHash } from "@openpond/harness";
+import { CONNECTED_EVIDENCE_LIMITS, CONNECTED_EVIDENCE_VERSION, CONNECTED_NORMALIZER_VERSION, ConnectedSessionSchema, hasRecordedConnectedAnswer } from "./contracts.js";
+export function connectedTimestamp(value, units = "milliseconds") {
+    if (typeof value !== "number" && typeof value !== "string")
+        return null;
+    const time = new Date(typeof value === "number" && units === "seconds" ? value * 1_000 : value);
+    return Number.isFinite(time.getTime()) ? time.toISOString() : null;
+}
+export function connectedFileIdentity(file) {
+    return { path: file.path, contentHash: contentHash(file.text), sizeBytes: new TextEncoder().encode(file.text).length };
+}
+export function normalizeConnectedSession(input) {
+    if (input.events.length + (input.unmappedEvents?.length ?? 0) > CONNECTED_EVIDENCE_LIMITS.events)
+        throw new Error("connected_event_limit");
+    const events = input.events.map((event, sequence) => ({ ...event, sequence }));
+    if (new Set(events.map(event => event.id)).size !== events.length)
+        throw new Error("connected_duplicate_event");
+    const starts = events.flatMap((event, index) => event.kind === "message" && event.role === "user" ? [index] : []);
+    if (!starts.length)
+        throw new Error("The session has no retained user request.");
+    if (starts.length + (input.includeConversation === false ? 0 : 1) > CONNECTED_EVIDENCE_LIMITS.boundaries)
+        throw new Error("connected_boundary_limit");
+    const familyKey = `family-${contentHash([input.origin, input.parentSessionId ?? input.sessionId]).slice(0, 32)}`;
+    const boundaries = starts.map((start, position) => {
+        const end = starts[position + 1] ?? events.length;
+        const observed = events.slice(start + 1, end);
+        const answer = observed.filter(hasRecordedConnectedAnswer).at(-1);
+        const tools = observed.filter(event => event.kind === "tool_call" || event.kind === "tool_result");
+        const calls = new Set(tools.filter(event => event.kind === "tool_call").map(event => event.callId));
+        const results = new Set(tools.filter(event => event.kind === "tool_result").map(event => event.callId));
+        const incomplete = tools.some(event => !event.callId) || [...calls].some(id => !results.has(id)) || [...results].some(id => !calls.has(id));
+        const terminal = [...observed].reverse().find(event => event.kind === "terminal");
+        const status = terminal && typeof terminal.content === "object" && terminal.content !== null && !Array.isArray(terminal.content)
+            ? terminal.content.status : null;
+        const compacted = events.slice(0, start + 1).some(event => event.kind === "compaction");
+        const unknown = observed.some(event => event.kind === "unknown");
+        return {
+            id: `case-${contentHash([input.origin, input.sessionId, input.branchId ?? null, events[start].id]).slice(0, 40)}`,
+            familyKey, projection: "turn", requestEventId: events[start].id, start, end,
+            inputHash: contentHash(events.slice(0, start + 1)), outputHash: answer ? contentHash(answer.content) : null,
+            revisionHash: contentHash(observed), terminal: status === "completed" || status === "failed" || status === "cancelled" ? status : "unknown",
+            coverage: { answer: Boolean(answer), context: input.contextComplete === false ? "unknown" : compacted ? "compacted" : "retained",
+                process: !tools.length ? unknown ? "partial" : "absent" : incomplete || unknown ? "partial" : "retained",
+                artifacts: observed.some(event => event.kind === "artifact") ? "references_only" : "absent", replay: "unavailable",
+                gaps: [...(!answer ? ["No recorded assistant answer."] : []), ...(input.contextComplete === false ? ["The source omits preceding context."] : []), ...(compacted ? ["Earlier context was compacted by the source."] : []),
+                    ...(incomplete ? ["Tool call/result correlation is incomplete."] : []), ...(unknown ? ["Some source events have no supported process mapping."] : []),
+                    ...(!terminal ? ["No terminal receipt was recorded."] : []), "No resettable execution environment was admitted."] },
+        };
+    });
+    if (input.includeConversation !== false) {
+        const first = boundaries[0], last = boundaries.at(-1);
+        const observed = events.slice(first.start + 1), answers = observed.filter(hasRecordedConnectedAnswer);
+        boundaries.push({ ...first, id: `conversation-${contentHash([input.origin, input.sessionId, input.branchId ?? null]).slice(0, 40)}`,
+            projection: "conversation", end: events.length, outputHash: answers.length ? contentHash(answers.map(event => event.content)) : null,
+            revisionHash: contentHash(observed), terminal: last.terminal, coverage: { ...first.coverage,
+                answer: answers.length > 0, process: boundaries.some(item => item.coverage.process === "partial") ? "partial" : boundaries.some(item => item.coverage.process === "retained") ? "retained" : "absent",
+                context: boundaries.some(item => item.coverage.context === "unknown") ? "unknown" : boundaries.some(item => item.coverage.context === "compacted") ? "compacted" : "retained",
+                artifacts: boundaries.some(item => item.coverage.artifacts === "references_only") ? "references_only" : "absent",
+                gaps: [...new Set(boundaries.flatMap(item => item.coverage.gaps))].slice(0, 100) } });
+    }
+    const body = { schemaVersion: CONNECTED_EVIDENCE_VERSION, normalizerVersion: CONNECTED_NORMALIZER_VERSION,
+        origin: input.origin, sessionId: input.sessionId, branchId: input.branchId ?? null, parentSessionId: input.parentSessionId ?? null,
+        exporterVersion: input.exporterVersion ?? null, sourceFiles: input.files.map(connectedFileIdentity).sort((a, b) => a.path.localeCompare(b.path)),
+        events, unmappedEvents: (input.unmappedEvents ?? []).map((event, sequence) => ({ ...event, sequence })), boundaries, warnings: input.warnings ?? [] };
+    const session = ConnectedSessionSchema.parse({ ...body, contentHash: contentHash(body) });
+    if (new TextEncoder().encode(JSON.stringify(session)).length > CONNECTED_EVIDENCE_LIMITS.decodedBytes)
+        throw new Error("connected_normalized_size_limit");
+    return session;
+}
+export function connectedJsonLines(file) {
+    const lines = file.text.replace(/^\uFEFF/u, "").split(/\r?\n/u);
+    if (lines.length > CONNECTED_EVIDENCE_LIMITS.events + 1)
+        throw new Error("connected_event_limit");
+    return lines.flatMap((line, index) => {
+        if (!line.trim())
+            return [];
+        if (new TextEncoder().encode(line).length > CONNECTED_EVIDENCE_LIMITS.lineBytes)
+            throw new Error(`Source line ${index + 1} exceeds the limit.`);
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            throw new Error(`Invalid JSON on line ${index + 1}.`);
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`Unsupported record on line ${index + 1}.`);
+        return [value];
+    });
+}
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function event(input) {
+    return { sequence: 0, occurredAt: null, role: null, callId: null, parentId: null, usage: null, ...input };
+}
+export function json(value) { return JSON.parse(JSON.stringify(value ?? null)); }

package/dist/connected-evidence/python-correctness.js

@@ -0,0 +1,73 @@
+import { createRewardRelease } from "../rewards.js";
+import { createLearningTextAsset } from "../learning/assets.js";
+export const PYTHON_CORRECTNESS_PRESET_VERSION = "python-stdio-correctness-1";
+export 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 const PYTHON_CORRECTNESS_VERIFIER_SOURCE = String.raw `
+import { spawn } from "node:child_process";
+import { mkdtemp, writeFile, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+const unavailable = feedback => ({ score: null, passed: false, feedback, evidenceRefs: [] });
+async function run(args, stdin = "", milliseconds = 2000) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn("/usr/bin/bwrap", args, { detached: true, env: {}, stdio: ["pipe", "pipe", "pipe"] });
+    let chunks = [], bytes = 0, overflow = false, timedOut = false, settled = false;
+    const kill = () => { if (child.pid) try { process.kill(-child.pid, "SIGKILL"); } catch (error) { if (error.code !== "ESRCH") throw error; } };
+    const timer = setTimeout(() => { timedOut = true; kill(); }, milliseconds);
+    const add = (data, retain) => { bytes += data.length; if (bytes > 65536) { overflow = true; kill(); } else if (retain) chunks.push(data); };
+    child.stdout.on("data", data => add(data, true)); child.stderr.on("data", data => add(data, false));
+    child.stdin.on("error", () => {});
+    child.once("error", () => { if (!settled) { settled = true; clearTimeout(timer); reject(new Error("python_correctness_isolation_unavailable")); } });
+    child.once("close", code => { clearTimeout(timer); kill(); if (!settled) { settled = true; resolve({ code, stdout: Buffer.concat(chunks).toString("utf8"), overflow, timedOut }); } });
+    child.stdin.end(stdin);
+  });
+}
+const isolation = ["--unshare-all", "--die-with-parent", "--new-session", "--cap-drop", "ALL", "--ro-bind", "/usr", "/usr", "--ro-bind", "/lib", "/lib", "--ro-bind", "/lib64", "/lib64", "--proc", "/proc", "--dev", "/dev", "--tmpfs", "/tmp", "--tmpfs", "/case", "--clearenv", "--setenv", "PATH", "/usr/bin", "--chdir", "/case"];
+export async function verify({ task, output, expectedOutput }) {
+  const code = output?.pythonCode ?? output?.answer?.pythonCode;
+  const criteria = expectedOutput?.pythonCorrectness;
+  if (typeof code !== "string" || !code.trim() || Buffer.byteLength(code) > 65536) return unavailable("Python correctness requires a retained explicit pythonCode artifact of at most 64 KiB.");
+  if (!criteria || criteria.schemaVersion !== "openpond.pythonStdioTests.v1" || !Array.isArray(criteria.tests) || !criteria.tests.length || criteria.tests.length > 20
+      || criteria.tests.some(test => !test || typeof test.stdin !== "string" || typeof test.stdout !== "string" || Buffer.byteLength(test.stdin) > 65536 || Buffer.byteLength(test.stdout) > 65536))
+    return unavailable("Python correctness requires owner-authored private stdin/stdout tests; a captured answer is not a reference.");
+  const admission = criteria.runtime;
+  if (!admission || admission.runtime !== "bubblewrap-python-stdio-v1" || !/^[a-f0-9]{64}$/.test(admission.pythonSha256 ?? ""))
+    return unavailable("An owner-admitted pinned isolated Python runtime is required.");
+  try {
+    const binaryHash = createHash("sha256").update(await readFile("/usr/bin/python3")).digest("hex");
+    if (binaryHash !== admission.pythonSha256) return unavailable("The admitted Python binary changed; qualify and pin the current runtime.");
+    const probe = await run([...isolation, "--", "/usr/bin/python3", "-I", "-S", "-c", "import sys; print(sys.version_info.major)"]);
+    if (probe.code !== 0 || probe.stdout.trim() !== "3" || probe.overflow || probe.timedOut) return unavailable("Python namespace isolation is unavailable in this runtime.");
+  } catch { return unavailable("The pinned Python isolation runtime is unavailable."); }
+  const directory = await mkdtemp(join(tmpdir(), "openpond-python-correctness-"));
+  let passed = 0;
+  try {
+    const source = join(directory, "main.py"); await writeFile(source, code, { mode: 0o400 });
+    for (const test of criteria.tests) {
+      const result = await run([...isolation, "--ro-bind", source, "/case/main.py", "--", "/usr/bin/prlimit", "--as=268435456", "--cpu=2", "--fsize=65536", "--", "/usr/bin/python3", "-I", "-S", "/case/main.py"], test.stdin);
+      if (result.code === 0 && !result.overflow && !result.timedOut && result.stdout === test.stdout) passed++;
+    }
+    return { score: passed / criteria.tests.length, passed: passed === criteria.tests.length,
+      feedback: "Python correctness: " + passed + " of " + criteria.tests.length + " private tests passed.", evidenceRefs: [] };
+  } finally { await rm(directory, { recursive: true, force: true }); }
+}
+`;
+export function pythonCorrectnessAuthoringFields() {
+    return { kind: "custom_verifier", name: "Python correctness", description: PYTHON_CORRECTNESS_DESCRIPTION,
+        feedbackKey: "python_correctness", code: PYTHON_CORRECTNESS_VERIFIER_SOURCE, exportName: "verify", timeout: "60000", verifierRuntime: "sandbox_process" };
+}
+/** Explicit owner publication may import these genuine immutable assets like
+ * any other supplied grader. No publication, compute or capture happens here. */
+export function createPythonCorrectnessPreset() {
+    const asset = createLearningTextAsset({ text: PYTHON_CORRECTNESS_VERIFIER_SOURCE,
+        path: "graders/openpond-python-stdio-correctness-v1.mjs", mediaType: "application/javascript", visibility: "verifier" });
+    const reward = createRewardRelease({ schemaVersion: "openpond.rewardRelease.v1", id: "openpond-python-stdio-correctness", revision: 1,
+        name: "Python correctness", description: PYTHON_CORRECTNESS_DESCRIPTION, feedbackKey: "python_correctness",
+        implementation: { kind: "custom_verifier", runtime: "sandbox_process", verifierRef: asset.asset, exportName: "verify", timeoutMs: 60_000, networkPolicy: "none" },
+        rawScore: { minimum: 0, maximum: 1 }, assets: [asset.asset] });
+    return { reward, assets: [asset] };
+}

package/dist/connected-evidence/sources/claude-code.js

@@ -0,0 +1,71 @@
+import { contentHash } from "@openpond/harness";
+import { connectedTimestamp, event, json, normalizeConnectedSession, object } from "../normalize.js";
+import { sourceUsage } from "./usage.js";
+export function parseClaudeSession(file, rows, leafId) {
+    const messages = rows.filter(row => (row.type === "user" || row.type === "assistant") && typeof row.uuid === "string");
+    const sessionIds = new Set(messages.flatMap(row => typeof row.sessionId === "string" ? [row.sessionId] : []));
+    if (sessionIds.size !== 1 || !messages.length)
+        throw new Error("A supported Claude Code transcript must identify one session with UUID messages.");
+    const byId = new Map(messages.map(row => [row.uuid, row]));
+    if (byId.size !== messages.length)
+        throw new Error("Claude Code transcript contains duplicate message UUIDs.");
+    const parents = new Set(messages.flatMap(row => typeof row.parentUuid === "string" ? [row.parentUuid] : []));
+    const leaves = messages.filter(row => !parents.has(row.uuid));
+    if (!leafId && leaves.length !== 1)
+        throw new Error("This transcript has multiple branches. Select a branch leaf UUID before importing.");
+    let current = byId.get(leafId ?? leaves[0].uuid);
+    if (!current)
+        throw new Error("The selected Claude Code branch leaf is missing.");
+    const chain = [], seen = new Set();
+    let missingParent = false;
+    while (current) {
+        const id = current.uuid;
+        if (seen.has(id))
+            throw new Error("Claude Code branch contains a parent cycle.");
+        seen.add(id);
+        chain.unshift(current);
+        const parent = current.parentUuid;
+        if (typeof parent !== "string")
+            break;
+        current = byId.get(parent);
+        if (!current)
+            missingParent = true;
+    }
+    const events = [];
+    for (const row of chain) {
+        const message = object(row.message), content = message.content;
+        const base = { occurredAt: connectedTimestamp(row.timestamp), parentId: typeof row.parentUuid === "string" ? row.parentUuid : null };
+        const role = row.type === "user" ? "user" : "assistant";
+        const blocks = Array.isArray(content) ? content : [{ type: "text", text: content }];
+        const textBlocks = blocks.filter(block => object(block).type === "text");
+        // User tool_result messages are process evidence, not independent requests.
+        if (textBlocks.length)
+            events.push(event({ ...base, id: row.uuid, kind: "message", role, content: json(textBlocks) }));
+        if (role === "assistant" && message.usage)
+            events.push(event({ ...base, id: `${row.uuid}:usage`, kind: "usage", content: json(message.usage),
+                usage: sourceUsage(message.usage, typeof message.id === "string" ? message.id : row.uuid) }));
+        for (const [index, value] of blocks.entries()) {
+            const block = object(value);
+            if (block.type === "text" || block.type === "thinking" || block.type === "redacted_thinking")
+                continue;
+            const id = `${row.uuid}:${index}`;
+            if (block.type === "tool_use")
+                events.push(event({ ...base, id, kind: "tool_call", callId: typeof block.id === "string" ? block.id : null, content: json(block) }));
+            else if (block.type === "tool_result")
+                events.push(event({ ...base, id, kind: "tool_result", role: "tool", callId: typeof block.tool_use_id === "string" ? block.tool_use_id : null, content: json(block) }));
+            else
+                events.push(event({ ...base, id, kind: "unknown", content: json(block) }));
+        }
+        if (message.stop_reason === "end_turn")
+            events.push(event({ ...base, id: `${row.uuid}:terminal`, kind: "terminal", content: { status: "completed" } }));
+    }
+    if (rows.some(row => row.type === "system" && row.subtype === "compact_boundary"))
+        events.unshift(event({ id: `compaction-${contentHash(rows.filter(row => row.subtype === "compact_boundary")).slice(0, 32)}`, kind: "compaction", content: { source: "claude_compact_boundary" } }));
+    return normalizeConnectedSession({ origin: "claude_code", sessionId: [...sessionIds][0],
+        // A chosen leaf is a cutoff, not a new family or the identity of every turn.
+        branchId: null, parentSessionId: typeof chain[0]?.parentSessionId === "string" ? chain[0].parentSessionId : null,
+        exporterVersion: typeof chain.at(-1)?.version === "string" ? chain.at(-1).version : null,
+        files: [file], events, contextComplete: !missingParent, warnings: [...(missingParent ? ["The transcript omits an ancestor; complete context is unavailable."] : []),
+            ...(chain.some(row => row.isSidechain) ? ["This is a subagent/sidechain transcript; parent context is not implicitly imported."] : []),
+            "Claude Code transcript schema is internal; only the declared message shapes are normalized."] });
+}

package/dist/connected-evidence/sources/codex.js

@@ -0,0 +1,52 @@
+import { contentHash } from "@openpond/harness";
+import { connectedTimestamp, event, json, normalizeConnectedSession, object } from "../normalize.js";
+import { sourceUsage } from "./usage.js";
+export function parseCodexSession(file, rows) {
+    const metadata = object(rows.find(row => row.type === "session_meta")?.payload);
+    if (typeof metadata.id !== "string")
+        throw new Error("This is not a supported Codex rollout: session_meta.id is missing.");
+    const events = [];
+    let turnId = null;
+    for (const [ordinal, row] of rows.entries()) {
+        const payload = object(row.payload);
+        if (row.type === "session_meta")
+            continue;
+        if (row.type === "turn_context") {
+            turnId = typeof payload.turn_id === "string" ? payload.turn_id : turnId;
+            continue;
+        }
+        const id = typeof payload.id === "string" ? payload.id : `codex-event-${contentHash([ordinal, row]).slice(0, 32)}`;
+        const base = { id, occurredAt: connectedTimestamp(row.timestamp), parentId: turnId };
+        if (row.type === "response_item") {
+            if (payload.type === "message" && ["user", "assistant", "system", "developer"].includes(String(payload.role)))
+                events.push(event({ ...base, kind: "message", role: payload.role === "developer" ? "system" : payload.role, content: json(payload.content) }));
+            else if (payload.type === "function_call" || payload.type === "custom_tool_call")
+                events.push(event({ ...base, kind: "tool_call", callId: typeof payload.call_id === "string" ? payload.call_id : null, content: json(payload) }));
+            else if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output")
+                events.push(event({ ...base, kind: "tool_result", role: "tool", callId: typeof payload.call_id === "string" ? payload.call_id : null, content: json(payload.output) }));
+            else
+                events.push(event({ ...base, kind: "unknown", content: json(payload) }));
+        }
+        else if (row.type === "compacted")
+            events.push(event({ ...base, kind: "compaction", content: json(payload) }));
+        else if (row.type === "event_msg") {
+            // These events mirror response_item messages. Keeping both doubles turns.
+            if (["user_message", "agent_message", "agent_reasoning", "task_started"].includes(String(payload.type)))
+                continue;
+            if (payload.type === "task_complete" || payload.type === "turn_aborted")
+                events.push(event({ ...base, kind: "terminal", content: { status: payload.type === "task_complete" ? "completed" : "cancelled", source: json(payload) } }));
+            else if (payload.type === "token_count") {
+                const info = object(payload.info);
+                const usage = sourceUsage(info.total_token_usage, `codex-cumulative:${metadata.id}:${ordinal}`, "reported_cumulative");
+                events.push(event({ ...base, kind: "usage", usage, content: json(payload) }));
+            }
+            else
+                events.push(event({ ...base, kind: "unknown", content: json(payload) }));
+        }
+        else
+            events.push(event({ ...base, kind: "unknown", content: json(row) }));
+    }
+    return normalizeConnectedSession({ origin: "codex", sessionId: metadata.id, parentSessionId: typeof metadata.forked_from_id === "string" ? metadata.forked_from_id : null,
+        exporterVersion: typeof metadata.cli_version === "string" ? metadata.cli_version : null, files: [file], events,
+        warnings: ["Codex cumulative usage is retained as reported totals and is not summed as billed invocations.", "Referenced files are unavailable unless separately admitted."] });
+}

package/dist/connected-evidence/sources/history.js

@@ -0,0 +1,86 @@
+import { contentHash } from "@openpond/harness";
+import { connectedJsonLines, connectedTimestamp, event, json, normalizeConnectedSession, object } from "../normalize.js";
+import { sourceUsage } from "./usage.js";
+function historyEvents(messages, origin) {
+    const events = [];
+    for (const [index, value] of messages.entries()) {
+        const message = object(value);
+        const id = typeof message.entryId === "string" ? message.entryId : typeof message.id === "string" ? message.id : typeof message.id === "number" && Number.isSafeInteger(message.id) ? String(message.id)
+            : typeof message.message_id === "string" ? message.message_id : `${origin}-${contentHash([index, message]).slice(0, 32)}`;
+        const base = { occurredAt: connectedTimestamp(message.timestamp, origin === "hermes" ? "seconds" : "milliseconds"),
+            parentId: typeof message.parentId === "string" ? message.parentId : null };
+        if (message.role === "tool") {
+            events.push(event({ ...base, id, kind: "tool_result", role: "tool", callId: typeof message.tool_call_id === "string" ? message.tool_call_id : null, content: json(message.content) }));
+            continue;
+        }
+        if (!["user", "assistant", "system"].includes(String(message.role))) {
+            events.push(event({ ...base, id, kind: "unknown", content: json(message) }));
+            continue;
+        }
+        events.push(event({ ...base, id, kind: "message", role: message.role, content: json(message.content),
+            usage: sourceUsage(message.usage, id) }));
+        if (Array.isArray(message.tool_calls))
+            for (const [ordinal, value] of message.tool_calls.entries()) {
+                const call = object(value);
+                events.push(event({ ...base, id: `${id}:call:${ordinal}`, kind: "tool_call", callId: typeof call.id === "string" ? call.id : null, content: json(call) }));
+            }
+        if (message.finish_reason === "stop" || message.stop_reason === "end_turn")
+            events.push(event({ ...base, id: `${id}:terminal`, kind: "terminal", content: { status: "completed" } }));
+    }
+    return events;
+}
+export function parseHermesEvidence(file, row) {
+    const sessionId = typeof row.id === "string" ? row.id : typeof row.session_id === "string" ? row.session_id : null;
+    if (!sessionId || !Array.isArray(row.messages))
+        throw new Error("Hermes requires a full-session export with id or session_id and messages.");
+    if (row.message_count !== undefined && row.message_count !== row.messages.length)
+        throw new Error("Hermes full-session message count differs from the retained messages.");
+    const lineage = Array.isArray(row.lineage_session_ids) ? row.lineage_session_ids.find(id => typeof id === "string" && id) : null;
+    const events = historyEvents(row.messages, "hermes");
+    if (typeof row.system_prompt === "string" && row.system_prompt.trim())
+        events.unshift(event({ id: `hermes-system-${contentHash(row.system_prompt).slice(0, 32)}`, kind: "message", role: "system", content: row.system_prompt }));
+    return normalizeConnectedSession({ origin: "hermes", sessionId, parentSessionId: typeof lineage === "string" ? lineage : typeof row.parent_session_id === "string" ? row.parent_session_id : null,
+        exporterVersion: typeof row.version === "string" ? row.version : null, files: [file], events,
+        warnings: ["Reported usage is not an OpenPond billing receipt.", "Exporter redaction and missing tools/artifacts remain evidence gaps.", ...(row.session_id && !row.id ? ["This is a Hermes session backup. Exporter version and terminal receipts may be unavailable."] : [])] });
+}
+export function parseOpenClawEvidence(files) {
+    const read = (path) => { const file = files.find(file => file.path === path); if (!file)
+        throw new Error(`OpenClaw bundle is missing ${path}.`); return file; };
+    const manifest = object(JSON.parse(read("manifest.json").text));
+    const branch = object(JSON.parse(read("session-branch.json").text));
+    const eventsFile = read("events.jsonl"), rows = connectedJsonLines(eventsFile);
+    if (manifest.traceSchema !== "openclaw-trajectory" || manifest.schemaVersion !== 1 || typeof manifest.sessionId !== "string" || typeof manifest.traceId !== "string")
+        throw new Error("Unsupported OpenClaw trajectory manifest.");
+    if (manifest.leafId !== branch.leafId || manifest.eventCount !== rows.length || rows.some(row => row.traceSchema !== manifest.traceSchema || row.schemaVersion !== 1 || row.sessionId !== manifest.sessionId || row.traceId !== manifest.traceId))
+        throw new Error("OpenClaw bundle identity/count does not match its manifest.");
+    if (!Array.isArray(branch.entries))
+        throw new Error("OpenClaw active branch entries are missing.");
+    if (branch.header && object(branch.header).id !== manifest.sessionId)
+        throw new Error("OpenClaw branch header differs from the manifest session.");
+    const ids = new Set(), messages = [];
+    for (const [index, value] of branch.entries.entries()) {
+        const entry = object(value);
+        if (typeof entry.id !== "string" || ids.has(entry.id) || (index > 0 && entry.parentId !== object(branch.entries[index - 1]).id))
+            throw new Error("OpenClaw active branch is duplicate, incomplete or unordered.");
+        ids.add(entry.id);
+        if (entry.type === "message")
+            messages.push({ ...object(entry.message), entryId: entry.id,
+                parentId: entry.parentId ?? null, timestamp: entry.timestamp ?? object(entry.message).timestamp });
+    }
+    if (branch.entries.length && object(branch.entries.at(-1)).id !== branch.leafId)
+        throw new Error("OpenClaw branch does not reach its leaf.");
+    // Branch messages carry context/output. Retain original events separately as
+    // unknown process evidence until their exact lifecycle mapping is qualified.
+    const events = historyEvents(messages, "openclaw"), unmappedEvents = [];
+    const seenSequences = new Set();
+    for (const [index, row] of rows.entries()) {
+        if (!Number.isSafeInteger(row.seq) || row.seq < 0 || seenSequences.has(row.seq) || index > 0 && Number(rows[index - 1].seq) >= Number(row.seq))
+            throw new Error("OpenClaw events have invalid/duplicate/unordered sequences.");
+        seenSequences.add(row.seq);
+        unmappedEvents.push(event({ id: `trajectory:${manifest.traceId}:${row.seq}`, kind: "unknown", occurredAt: connectedTimestamp(row.ts), content: json(row) }));
+    }
+    return normalizeConnectedSession({ origin: "openclaw", sessionId: manifest.sessionId, files, events, unmappedEvents,
+        exporterVersion: typeof manifest.openclawVersion === "string" ? manifest.openclawVersion : null,
+        warnings: ["Raw trajectory events are retained; unqualified event types are not advertised as complete process grading.",
+            ...(Array.isArray(manifest.warnings) ? manifest.warnings.map(value => typeof object(value).message === "string" ? String(object(value).message).slice(0, 500) : "The source exporter reports incomplete evidence.") : [])].slice(0, 100) });
+}

package/dist/connected-evidence/sources/usage.js

@@ -0,0 +1,15 @@
+import { object } from "../normalize.js";
+export function sourceUsage(value, invocationId, provenance = "reported_invocation") {
+    const usage = object(value);
+    const number = (...values) => {
+        const value = values.find(item => typeof item === "number" && Number.isSafeInteger(item) && item >= 0);
+        return typeof value === "number" ? value : null;
+    };
+    const inputTokens = number(usage.input_tokens, usage.prompt_tokens);
+    const outputTokens = number(usage.output_tokens, usage.completion_tokens);
+    const cachedInputTokens = number(usage.cache_read_input_tokens, usage.cached_input_tokens, object(usage.input_tokens_details).cached_tokens);
+    const totalTokens = number(usage.total_tokens);
+    if (inputTokens === null && outputTokens === null && cachedInputTokens === null && totalTokens === null)
+        return null;
+    return { invocationId, inputTokens, outputTokens, cachedInputTokens, totalTokens, provenance };
+}

package/dist/connected-evidence/usage-summary.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+const count = z.number().int().nonnegative().nullable();
+export const ConnectedInvocationSchema = z.object({ requestId: z.string().min(1), startedAt: z.string().datetime(),
+    provider: z.string(), model: z.string(), mode: z.string(), status: z.string(), source: z.string(), projectId: z.string().nullable(),
+    inputTokens: count, cachedInputTokens: count, outputTokens: count, totalTokens: count }).strict();
+const empty = () => ({ invocations: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, totalTokens: 0,
+    missingInput: 0, missingCachedInput: 0, missingOutput: 0, missingTotal: 0, failures: 0, unattributed: 0 });
+const nonnegative = z.number().int().nonnegative();
+export const ConnectedUsageTotalsSchema = z.object({ invocations: nonnegative, inputTokens: nonnegative, cachedInputTokens: nonnegative,
+    outputTokens: nonnegative, totalTokens: nonnegative, missingInput: nonnegative, missingCachedInput: nonnegative,
+    missingOutput: nonnegative, missingTotal: nonnegative, failures: nonnegative, unattributed: nonnegative }).strict();
+export const ConnectedUsageSummarySchema = z.object({ total: ConnectedUsageTotalsSchema,
+    days: z.array(ConnectedUsageTotalsSchema.extend({ key: z.string().regex(/^\d{4}-\d{2}-\d{2}$/) })),
+    modes: z.array(ConnectedUsageTotalsSchema.extend({ key: z.string() })), models: z.array(ConnectedUsageTotalsSchema.extend({ key: z.string() })) }).strict();
+function add(total, row) {
+    total.invocations++;
+    total.failures += row.status === "completed" ? 0 : 1;
+    total.unattributed += row.projectId === null ? 1 : 0;
+    for (const [value, missing] of [["inputTokens", "missingInput"], ["cachedInputTokens", "missingCachedInput"], ["outputTokens", "missingOutput"], ["totalTokens", "missingTotal"]]) {
+        const measured = row[value];
+        if (measured === null)
+            total[missing]++;
+        else
+            total[value] += measured;
+        if (!Number.isSafeInteger(total[value]))
+            throw new Error("connected_usage_sum_overflow");
+    }
+}
+/** A billed retry has a new invocation identity; repeated copies of one receipt do not add spend.
+ * Unknown token fields remain unknown and are never inferred from another field.
+ */
+export function summarizeConnectedInvocations(raw) {
+    const unique = new Map();
+    for (const value of raw) {
+        const row = ConnectedInvocationSchema.parse(value), prior = unique.get(row.requestId);
+        if (prior && contentHash(prior) !== contentHash(row))
+            throw new Error("connected_usage_receipt_conflict");
+        unique.set(row.requestId, row);
+    }
+    const total = empty(), days = new Map(), modes = new Map(), models = new Map();
+    for (const row of unique.values()) {
+        add(total, row);
+        for (const [map, key] of [[days, row.startedAt.slice(0, 10)], [modes, row.mode], [models, `${row.provider}/${row.model}`]]) {
+            const aggregate = map.get(key) ?? empty();
+            add(aggregate, row);
+            map.set(key, aggregate);
+        }
+    }
+    const entries = (map) => [...map].sort(([a], [b]) => a.localeCompare(b)).map(([key, totals]) => ({ key, ...totals }));
+    return { total, days: entries(days), modes: entries(modes), models: entries(models) };
+}