@openpond/evals 0.11.18 → 0.11.19

package/dist/connected-evidence/contracts.js

@@ -8,7 +8,7 @@ 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 ConnectedSourceKindSchema = z.enum(["native_chat", "native_work", "codex", "claude_code", "hermes", "openclaw", "opencode", "grok_build", "pi", "oh_my_pi"]);
 export const ConnectedUsageSchema = z.object({
     invocationId: Id, inputTokens: Tokens, outputTokens: Tokens, cachedInputTokens: Tokens,
     totalTokens: Tokens, provenance: z.enum(["billed_invocation", "reported_invocation", "reported_cumulative"]),
@@ -33,6 +33,7 @@ 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(),
+    acquisition: z.object({ machineId: Id, sourceInstanceId: Id }).strict().optional(),
     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),
@@ -48,8 +49,8 @@ export function hasRecordedConnectedAnswer(event) {
         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) {
+/** Shared integrity verification for metadata and evaluator evidence. */
+function verifiedConnectedBoundary(sessionValue, boundaryId) {
     const session = ConnectedSessionSchema.parse(sessionValue);
     const { contentHash: actual, ...body } = session;
     if (contentHash(body) !== actual)
@@ -65,7 +66,16 @@ export function resolveConnectedBoundary(sessionValue, boundaryId) {
     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 };
+    return { input, observed, answer, boundary };
+}
+/** Status/discovery returns no evaluator payload. Large retained histories still
+ * require the exact session, input, observed-output and answer hashes to match. */
+export function resolveConnectedBoundaryMetadata(sessionValue, boundaryId) {
+    return verifiedConnectedBoundary(sessionValue, boundaryId).boundary;
+}
+/** Bytes stay in one immutable snapshot; cases retain cutoffs, not copied history. */
+export function resolveConnectedBoundary(sessionValue, boundaryId) {
+    const value = verifiedConnectedBoundary(sessionValue, boundaryId);
     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

@@ -1,17 +1,32 @@
 import { contentHash } from "@openpond/harness";
-import { CONNECTED_EVIDENCE_LIMITS } from "./contracts.js";
-import { connectedJsonLines } from "./normalize.js";
+import { CONNECTED_EVIDENCE_LIMITS, CONNECTED_NORMALIZER_VERSION, } from "./contracts.js";
+import { connectedJsonLines, normalizeConnectedSession } from "./normalize.js";
+import { parseGrokBuildSession } from "./sources/grok-build.js";
+import { parsePiSession } from "./sources/pi.js";
+import { parseOpenCodeSession } from "./sources/opencode.js";
+import { CODEX_AUTHORIZATION_PROJECTION_POLICY } from "./sources/codex-authorization.js";
 import { parseCodexSession } from "./sources/codex.js";
 import { parseClaudeSession } from "./sources/claude-code.js";
-import { parseHermesEvidence, parseOpenClawEvidence } from "./sources/history.js";
+import { parseHermesEvidence, parseOpenClawEvidence, } from "./sources/history.js";
+/** Cache identity includes source projection policy, independent of file mtimes. */
+export function agentImportNormalizerRevision(source) {
+    return source === "codex" ? `${CONNECTED_NORMALIZER_VERSION}/${CODEX_AUTHORIZATION_PROJECTION_POLICY}` : CONNECTED_NORMALIZER_VERSION;
+}
 /** 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)
+    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))
+        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;
@@ -21,22 +36,47 @@ export function previewAgentImport(input) {
     const sessions = [], issues = [];
     const attempt = (file, parse) => {
         try {
-            sessions.push(...parse());
+            sessions.push(...parse().map((session) => input.acquisition
+                ? normalizeConnectedSession({
+                    origin: session.origin,
+                    sessionId: session.sessionId,
+                    branchId: session.branchId,
+                    parentSessionId: session.parentSessionId,
+                    exporterVersion: session.exporterVersion,
+                    files: input.files.filter((item) => session.sourceFiles.some((file) => file.path === item.path)),
+                    events: session.events,
+                    unmappedEvents: session.unmappedEvents,
+                    warnings: session.warnings,
+                    contextComplete: !session.boundaries.some((boundary) => boundary.coverage.context === "unknown"),
+                    acquisition: input.acquisition,
+                })
+                : session));
         }
         catch (error) {
-            issues.push({ file, message: error instanceof Error ? error.message : "Unsupported session." });
+            issues.push({
+                file,
+                message: error instanceof Error ? error.message : "Unsupported session.",
+            });
         }
     };
-    if (input.source === "openclaw")
+    if (input.source === "openclaw" &&
+        input.files.some((file) => file.path.endsWith("manifest.json")))
         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;
+            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, () => {
+                if (input.source === "opencode")
+                    return [parseOpenCodeSession(file, JSON.parse(file.text))];
                 let rows;
                 if (input.source === "hermes" && file.path.endsWith(".json")) {
                     const value = JSON.parse(file.text.replace(/^\uFEFF/u, ""));
@@ -46,26 +86,46 @@ export function previewAgentImport(input) {
                 }
                 else
                     rows = connectedJsonLines(file);
+                if (input.source === "grok_build")
+                    return [parseGrokBuildSession(file, rows)];
+                if (input.source === "pi" ||
+                    input.source === "oh_my_pi" ||
+                    input.source === "openclaw")
+                    return [parsePiSession(file, rows, input.source, input.branchLeafId)];
                 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));
+                    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)
+    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 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 };
+    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/normalize.js

@@ -20,7 +20,7 @@ export function normalizeConnectedSession(input) {
         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 familyKey = `family-${contentHash([input.origin, ...(input.acquisition ? [input.acquisition.sourceInstanceId] : []), 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);
@@ -35,7 +35,7 @@ export function normalizeConnectedSession(input) {
         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)}`,
+            id: `case-${contentHash([input.origin, ...(input.acquisition ? [input.acquisition.sourceInstanceId] : []), 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",
@@ -50,7 +50,7 @@ export function normalizeConnectedSession(input) {
     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)}`,
+        boundaries.push({ ...first, id: `conversation-${contentHash([input.origin, ...(input.acquisition ? [input.acquisition.sourceInstanceId] : []), 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",
@@ -61,6 +61,7 @@ export function normalizeConnectedSession(input) {
     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)),
+        ...(input.acquisition ? { acquisition: input.acquisition } : {}),
         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)

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

@@ -0,0 +1,52 @@
+import { contentHash } from "@openpond/harness";
+import { connectedTimestamp, object } from "../normalize.js";
+/** One native graph owns selection, import and Desktop inspection semantics. */
+export function claudeGraph(rows) {
+    const messages = rows.filter(row => (row.type === "user" || row.type === "assistant") && typeof row.uuid === "string");
+    const sessions = new Set(messages.flatMap(row => typeof row.sessionId === "string" ? [row.sessionId] : []));
+    if (sessions.size !== 1 || !messages.length)
+        throw new Error("A supported Claude Code transcript must identify one session with UUID messages.");
+    const sessionId = [...sessions][0];
+    const nodes = rows.filter(row => typeof row.uuid === "string" && row.sessionId === sessionId);
+    const byId = new Map(nodes.map(row => [row.uuid, row]));
+    if (byId.size !== nodes.length)
+        throw new Error("Claude Code transcript contains duplicate message UUIDs.");
+    const parents = new Set(nodes.flatMap(row => typeof row.parentUuid === "string" ? [row.parentUuid] : []));
+    const leaves = nodes.filter(row => !parents.has(row.uuid));
+    if (!leaves.length)
+        throw new Error("Claude Code transcript has no selectable branch leaf.");
+    function select(leafId) {
+        let current = byId.get(leafId);
+        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;
+        }
+        return { chain, missingParent, chainHash: contentHash(chain) };
+    }
+    function branches() {
+        if (leaves.length > 256)
+            throw new Error("This transcript exceeds the 256-branch inspection limit.");
+        return leaves.map(leaf => {
+            const selected = select(leaf.uuid);
+            const messages = selected.chain.filter(row => row.type === "user" || row.type === "assistant");
+            const last = messages.at(-1);
+            const content = object(last?.message).content;
+            const title = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap(block => typeof object(block).text === "string" ? [object(block).text] : []).join(" ") : "";
+            return { leafId: leaf.uuid, chainHash: selected.chainHash, title: title.slice(0, 180), updatedAt: connectedTimestamp(last?.timestamp), messages: messages.length };
+        });
+    }
+    return { sessionId, leaves, select, branches };
+}

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

@@ -1,38 +1,16 @@
+import { claudeGraph } from "./claude-branches.js";
 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)
+    const graph = claudeGraph(rows);
+    if (!leafId && graph.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 { chain, missingParent } = graph.select(leafId ?? graph.leaves[0].uuid);
     const events = [];
     for (const row of chain) {
+        if (row.type !== "user" && row.type !== "assistant")
+            continue;
         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";
@@ -61,7 +39,7 @@ export function parseClaudeSession(file, rows, leafId) {
     }
     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],
+    return normalizeConnectedSession({ origin: "claude_code", sessionId: graph.sessionId,
         // 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,

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

@@ -0,0 +1,40 @@
+import { contentHash } from "@openpond/harness";
+import { object } from "../normalize.js";
+export const CODEX_AUTHORIZATION_PROJECTION_POLICY = "codex-native-authorization-v1";
+const POLICY = CODEX_AUTHORIZATION_PROJECTION_POLICY;
+/** Native approved-command rules are account authority, not observed tool calls.
+ * Retain all other context and the original file/event identity. Unknown formats
+ * remain untouched for ordinary privacy admission; this is not secret scrubbing.
+ */
+export function projectCodexAuthorization(row) {
+    const omissions = [];
+    const omit = (sourcePath, value, entries) => {
+        const receipt = { policy: POLICY, sourcePath, sourceHash: contentHash(value), entries };
+        omissions.push(receipt);
+        return receipt;
+    };
+    const permissionsText = (text, path) => text.replace(/<permissions instructions>[\s\S]*?<\/permissions instructions>/gu, block => block.replace(/^## Approved command prefixes\r?\n[\s\S]*?(?=^## |<\/permissions instructions>)/gmu, section => {
+        const receipt = omit(path, section, null);
+        return `## Approved command prefixes\n[Native authorization rules omitted; policy ${receipt.policy}; source hash ${receipt.sourceHash}]\n`;
+    }));
+    const payload = object(row.payload);
+    if (row.type === "response_item" && payload.type === "message" && ["system", "developer"].includes(String(payload.role))) {
+        const content = typeof payload.content === "string"
+            ? permissionsText(payload.content, "/payload/content")
+            : Array.isArray(payload.content) ? payload.content.map((value, index) => {
+                const block = object(value);
+                return typeof block.text === "string"
+                    ? { ...block, text: permissionsText(block.text, `/payload/content/${index}/text`) }
+                    : value;
+            }) : payload.content;
+        return { row: { ...row, payload: { ...payload, content } }, omissions };
+    }
+    if (row.type === "world_state") {
+        const state = object(payload.state), permissions = object(state.permissions);
+        if (Array.isArray(permissions.approved_command_prefixes)) {
+            const receipt = omit("/payload/state/permissions/approved_command_prefixes", permissions.approved_command_prefixes, permissions.approved_command_prefixes.length);
+            return { row: { ...row, payload: { ...payload, state: { ...state, permissions: { ...permissions, approved_command_prefixes: { omitted: "native_authorization_state", ...receipt } } } } }, omissions };
+        }
+    }
+    return { row, omissions };
+}

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

@@ -1,5 +1,6 @@
 import { contentHash } from "@openpond/harness";
 import { connectedTimestamp, event, json, normalizeConnectedSession, object } from "../normalize.js";
+import { projectCodexAuthorization } from "./codex-authorization.js";
 import { sourceUsage } from "./usage.js";
 export function parseCodexSession(file, rows) {
     const metadata = object(rows.find(row => row.type === "session_meta")?.payload);
@@ -7,8 +8,11 @@ export function parseCodexSession(file, rows) {
         throw new Error("This is not a supported Codex rollout: session_meta.id is missing.");
     const events = [];
     let turnId = null;
+    let authorizationOmissions = 0;
     for (const [ordinal, row] of rows.entries()) {
-        const payload = object(row.payload);
+        const projected = projectCodexAuthorization(row);
+        authorizationOmissions += projected.omissions.length;
+        const payload = object(projected.row.payload);
         if (row.type === "session_meta")
             continue;
         if (row.type === "turn_context") {
@@ -44,9 +48,9 @@ export function parseCodexSession(file, rows) {
                 events.push(event({ ...base, kind: "unknown", content: json(payload) }));
         }
         else
-            events.push(event({ ...base, kind: "unknown", content: json(row) }));
+            events.push(event({ ...base, kind: "unknown", content: json(projected.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."] });
+        warnings: ["Codex cumulative usage is retained as reported totals and is not summed as billed invocations.", "Referenced files are unavailable unless separately admitted.", ...(authorizationOmissions ? [`Codex native authorization state excluded by codex-native-authorization-v1 from ${authorizationOmissions} locations. Omission markers retain source-section hashes; sourceFiles retains original byte hashes. Other conversation evidence is unchanged and still requires privacy admission.`] : [])] });
 }

package/dist/connected-evidence/sources/grok-build.js

@@ -0,0 +1,137 @@
+import { connectedTimestamp, event, json, normalizeConnectedSession, object, } from "../normalize.js";
+import { sourceUsage } from "./usage.js";
+/** Retained ACP updates are native Grok history; Markdown exports are not accepted. */
+export function parseGrokBuildSession(file, rows) {
+    const sessions = new Set(rows
+        .map((row) => object(row.params).sessionId)
+        .filter((value) => typeof value === "string"));
+    if (sessions.size !== 1)
+        throw new Error("Grok Build updates must identify exactly one retained session.");
+    const events = [], ids = new Set(), calls = new Map();
+    let user = null, answer = null, completed = true;
+    for (const row of rows) {
+        const params = object(row.params), update = object(params.update), metadata = object(params._meta), kind = update.sessionUpdate;
+        if (typeof metadata.eventId !== "string" || ids.has(metadata.eventId))
+            throw new Error("Grok Build updates require unique native event IDs.");
+        ids.add(metadata.eventId);
+        const id = metadata.eventId, time = connectedTimestamp(metadata.agentTimestampMs ??
+            (typeof row.timestamp === "number" ? row.timestamp * 1000 : null));
+        const content = object(update.content);
+        if (kind === "user_message_chunk") {
+            if (content.type !== "text" || typeof content.text !== "string")
+                throw new Error("Grok user content type requires a qualified adapter.");
+            if (!user || completed) {
+                user = event({
+                    id,
+                    kind: "message",
+                    role: "user",
+                    occurredAt: time,
+                    content: content.text,
+                });
+                events.push(user);
+                answer = null;
+                completed = false;
+            }
+            else
+                user.content = String(user.content) + content.text;
+        }
+        else if (kind === "agent_message_chunk") {
+            if (content.type !== "text" || typeof content.text !== "string") {
+                events.push(event({
+                    id,
+                    kind: "unknown",
+                    occurredAt: time,
+                    content: json(update),
+                }));
+                continue;
+            }
+            if (!answer) {
+                answer = event({
+                    id,
+                    kind: "message",
+                    role: "assistant",
+                    occurredAt: time,
+                    content: content.text,
+                });
+                events.push(answer);
+            }
+            else
+                answer.content = String(answer.content) + content.text;
+        }
+        else if (kind === "tool_call" || kind === "tool_call_update") {
+            const callId = typeof update.toolCallId === "string" ? update.toolCallId : null;
+            if (!callId) {
+                events.push(event({
+                    id,
+                    kind: "unknown",
+                    occurredAt: time,
+                    content: json(update),
+                }));
+                continue;
+            }
+            let call = calls.get(callId);
+            if (!call) {
+                call = event({
+                    id: `${id}:call`,
+                    kind: "tool_call",
+                    callId,
+                    occurredAt: time,
+                    content: json({ title: update.title, input: update.rawInput }),
+                });
+                calls.set(callId, call);
+                events.push(call);
+            }
+            else if (update.rawInput !== undefined)
+                call.content = json({ title: update.title, input: update.rawInput });
+            if (update.status === "completed" || update.status === "failed")
+                events.push(event({
+                    id: `${id}:result`,
+                    kind: "tool_result",
+                    role: "tool",
+                    callId,
+                    occurredAt: time,
+                    content: json({
+                        status: update.status,
+                        output: update.rawOutput,
+                        content: update.content,
+                    }),
+                }));
+        }
+        else if (kind === "turn_completed") {
+            const usage = object(update.usage), invocationId = typeof update.prompt_id === "string" ? update.prompt_id : id;
+            events.push(event({
+                id,
+                kind: "terminal",
+                occurredAt: time,
+                content: {
+                    status: update.stop_reason === "end_turn"
+                        ? "completed"
+                        : update.stop_reason === "cancelled"
+                            ? "cancelled"
+                            : "failed",
+                },
+                usage: sourceUsage({
+                    input_tokens: usage.inputTokens,
+                    output_tokens: usage.outputTokens,
+                    cached_input_tokens: usage.cachedReadTokens,
+                    total_tokens: usage.totalTokens,
+                }, invocationId),
+            }));
+            completed = true;
+            answer = null;
+            user = null;
+        }
+        else if (kind !== "agent_thought_chunk")
+            events.push(event({ id, kind: "unknown", occurredAt: time, content: json(update) }));
+    }
+    return normalizeConnectedSession({
+        origin: "grok_build",
+        sessionId: String([...sessions][0]),
+        files: [file],
+        events,
+        contextComplete: false,
+        warnings: [
+            "Grok retained ACP updates omit system context and encrypted reasoning. Tool coverage reflects only logged updates.",
+        ],
+    });
+}

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

@@ -0,0 +1,101 @@
+import { connectedTimestamp, event, json, normalizeConnectedSession, object, } from "../normalize.js";
+import { sourceUsage } from "./usage.js";
+export function parseOpenCodeSession(file, value) {
+    const root = object(value), info = object(root.info);
+    if (typeof info.id !== "string" || !Array.isArray(root.messages))
+        throw new Error("OpenCode requires its native JSON session export (info and messages).");
+    const events = [];
+    for (const raw of root.messages) {
+        const item = object(raw), message = object(item.info), time = object(message.time);
+        if (typeof message.id !== "string" ||
+            message.sessionID !== info.id ||
+            !Array.isArray(item.parts))
+            throw new Error("OpenCode message identity does not match its session.");
+        const role = message.role;
+        if (role !== "user" && role !== "assistant")
+            throw new Error("Unsupported OpenCode message role.");
+        const base = {
+            occurredAt: connectedTimestamp(time.created),
+            parentId: typeof message.parentID === "string" ? message.parentID : null,
+        };
+        const parts = item.parts.map(object);
+        if (parts.some((part) => part.sessionID !== info.id ||
+            part.messageID !== message.id ||
+            typeof part.id !== "string"))
+            throw new Error("OpenCode part identity does not match its message.");
+        const text = parts
+            .filter((part) => part.type === "text")
+            .map((part) => String(part.text ?? ""))
+            .join("\n");
+        const tokens = object(message.tokens), cache = object(tokens.cache);
+        const usage = sourceUsage({
+            input_tokens: tokens.input,
+            output_tokens: tokens.output,
+            cached_input_tokens: cache.read,
+            total_tokens: tokens.total,
+        }, message.id);
+        if (text || role === "user")
+            events.push(event({
+                ...base,
+                id: message.id,
+                kind: "message",
+                role,
+                content: text,
+                usage,
+            }));
+        else if (usage)
+            events.push(event({
+                ...base,
+                id: `${message.id}:usage`,
+                kind: "usage",
+                content: null,
+                usage,
+            }));
+        for (const part of parts) {
+            const id = String(part.id);
+            if (part.type === "tool") {
+                const state = object(part.state), callId = typeof part.callID === "string" ? part.callID : null;
+                events.push(event({
+                    ...base,
+                    id: `${id}:call`,
+                    kind: "tool_call",
+                    callId,
+                    content: json({ name: part.tool, arguments: state.input }),
+                }));
+                if (state.status === "completed" || state.status === "error")
+                    events.push(event({
+                        ...base,
+                        id: `${id}:result`,
+                        kind: "tool_result",
+                        role: "tool",
+                        callId,
+                        content: json({
+                            output: state.output,
+                            error: state.error,
+                            status: state.status,
+                        }),
+                    }));
+            }
+            else if (part.type === "compaction")
+                events.push(event({ ...base, id, kind: "compaction", content: json(part) }));
+            else if (!["text", "reasoning", "step-start", "step-finish"].includes(String(part.type)))
+                events.push(event({ ...base, id, kind: "unknown", content: json(part) }));
+        }
+        if (role === "assistant" && (message.finish === "stop" || message.error))
+            events.push(event({
+                ...base,
+                id: `${message.id}:terminal`,
+                kind: "terminal",
+                content: { status: message.error ? "failed" : "completed" },
+            }));
+    }
+    return normalizeConnectedSession({
+        origin: "opencode",
+        sessionId: info.id,
+        parentSessionId: typeof info.parentID === "string" ? info.parentID : null,
+        exporterVersion: typeof info.version === "string" ? info.version : null,
+        files: [file],
+        events,
+        warnings: ["Source-reported usage is not an OpenPond billing receipt."],
+    });
+}