@zewstid/zeye-capture 0.3.0 → 0.3.1

package/README.md

@@ -8,7 +8,7 @@ redaction. Hidden model reasoning is never captured.
 Install the public CLI with Node 20.18.1 or newer:
 
 ```sh
-npm install --global @zewstid/zeye-capture@0.3.0
+npm install --global @zewstid/zeye-capture@0.3.1
 ```
 
 Capture `0.3.x` uses the `@zewstid/zeye-shared` `0.5.x` contracts.

package/dist/src/host.js

@@ -13,8 +13,15 @@ function parseCodexCheckpoint(cursor) {
     try {
         const parsed = JSON.parse(cursor);
         const completedLines = parsed.completedLines;
-        if (parsed.version === 2 && Number.isInteger(completedLines) && completedLines !== undefined && completedLines >= 0 && typeof parsed.sourceGenerationId === 'string' && parsed.sourceGenerationId) {
-            return { version: 2, completedLines, lastLineHash: typeof parsed.lastLineHash === 'string' ? parsed.lastLineHash : undefined, sourceGenerationId: parsed.sourceGenerationId };
+        if ((parsed.version === 2 || parsed.version === 3) && Number.isInteger(completedLines) && completedLines !== undefined && completedLines >= 0 && typeof parsed.sourceGenerationId === 'string' && parsed.sourceGenerationId) {
+            return {
+                version: parsed.version,
+                completedLines,
+                lastLineHash: typeof parsed.lastLineHash === 'string' ? parsed.lastLineHash : undefined,
+                sourceGenerationId: parsed.sourceGenerationId,
+                sourceSessionId: typeof parsed.sourceSessionId === 'string' ? parsed.sourceSessionId : undefined,
+                clientVersion: typeof parsed.clientVersion === 'string' ? parsed.clientVersion : undefined,
+            };
         }
     }
     catch { /* legacy cursor */ }
@@ -47,17 +54,45 @@ async function importCodexJsonl(outbox, filePath, context, captureContent = fals
     // replacement without ever storing the source record itself.
     const checkpointMatches = Boolean(checkpoint && completedLines <= lines.length && (!checkpoint.lastLineHash || completedLines === 0 || checkpoint.lastLineHash === (0, canonical_1.sha256)(lines[completedLines - 1])));
     const rotated = Boolean(checkpoint && !checkpointMatches);
-    const start = rotated ? 0 : completedLines;
+    // v2 checkpoints advanced past records that omitted a per-line session ID.
+    // Reprocess them once under v3; the outbox's source-key idempotency safely
+    // collapses the records that were already captured while recovering those
+    // that the old parser skipped.
+    const checkpointNeedsIdentityUpgrade = Boolean(checkpoint && checkpoint.version !== 3);
+    const start = rotated || checkpointNeedsIdentityUpgrade ? 0 : completedLines;
     const generationId = checkpoint && !rotated && checkpoint.sourceGenerationId
         ? checkpoint.sourceGenerationId
         : sourceGenerationId(filePath, lines[0], file);
+    let streamIdentity = rotated
+        ? {}
+        : { sessionId: checkpoint?.sourceSessionId, clientVersion: checkpoint?.clientVersion };
+    // Session metadata is normally first, but pre-scan content-blind identity so
+    // resumed imports and provider ordering changes remain safe.
+    for (const line of lines) {
+        try {
+            const identity = (0, providers_1.codexStreamIdentity)(JSON.parse(line));
+            streamIdentity = {
+                sessionId: streamIdentity.sessionId || identity.sessionId,
+                clientVersion: streamIdentity.clientVersion || identity.clientVersion,
+            };
+            if (streamIdentity.sessionId && streamIdentity.clientVersion)
+                break;
+        }
+        catch { /* the ordered import below owns malformed-line handling */ }
+    }
     let imported = 0;
     let skipped = 0;
     let deferred = raw.length > 0 && !(raw.endsWith('\n') || raw.endsWith('\r\n')) ? 1 : 0;
     let consumed = start;
     for (let index = start; index < lines.length; index += 1) {
         try {
-            const observation = (0, providers_1.fromCodexJsonl)(JSON.parse(lines[index]), (0, node_path_1.basename)(filePath), captureContent);
+            const parsedLine = JSON.parse(lines[index]);
+            const identity = (0, providers_1.codexStreamIdentity)(parsedLine);
+            streamIdentity = {
+                sessionId: identity.sessionId || streamIdentity.sessionId,
+                clientVersion: identity.clientVersion || streamIdentity.clientVersion,
+            };
+            const observation = (0, providers_1.fromCodexJsonl)(parsedLine, (0, node_path_1.basename)(filePath), captureContent, streamIdentity);
             if (!observation) {
                 skipped += 1;
                 consumed = index + 1;
@@ -83,7 +118,14 @@ async function importCodexJsonl(outbox, filePath, context, captureContent = fals
             break;
         }
     }
-    await outbox.checkpoint('codex', scope, checkpointCursor({ version: 2, completedLines: consumed, lastLineHash: consumed ? (0, canonical_1.sha256)(lines[consumed - 1]) : undefined, sourceGenerationId: generationId }));
+    await outbox.checkpoint('codex', scope, checkpointCursor({
+        version: 3,
+        completedLines: consumed,
+        lastLineHash: consumed ? (0, canonical_1.sha256)(lines[consumed - 1]) : undefined,
+        sourceGenerationId: generationId,
+        sourceSessionId: streamIdentity.sessionId,
+        clientVersion: streamIdentity.clientVersion,
+    }));
     return { imported, skipped, deferred, rotated };
 }
 async function flushIfConfigured(outbox, config) {

package/dist/src/providers.d.ts

@@ -1,4 +1,15 @@
 import type { MetadataCaptureEvent } from "./types";
+export type CodexStreamIdentity = {
+    sessionId?: string;
+    clientVersion?: string;
+};
+/**
+ * Current Codex rollout logs put stream identity on `session_meta.payload`,
+ * while subsequent records carry only turn/item identifiers. Keep this small
+ * helper content-blind so the importer can safely inherit identity without
+ * inspecting prompts, responses, tool arguments, or reasoning.
+ */
+export declare function codexStreamIdentity(input: unknown): CodexStreamIdentity;
 /** Parse provider-visible Claude transcript JSONL without hidden thinking blocks. */
 export declare function fromClaudeTranscriptJsonl(input: unknown, fallbackSessionId?: string): MetadataCaptureEvent | null;
 /** Parse a Claude Code hook payload without retaining prompt/tool/file content. */
@@ -8,7 +19,7 @@ export declare function fromClaudeCodeHook(input: unknown, captureContent?: bool
  * format evolves, so unknown record kinds become a safe capture warning rather
  * than being misrepresented as a complete observation.
  */
-export declare function fromCodexJsonl(input: unknown, sourceFile?: string, captureContent?: boolean): MetadataCaptureEvent | null;
+export declare function fromCodexJsonl(input: unknown, sourceFile?: string, captureContent?: boolean, inheritedIdentity?: CodexStreamIdentity): MetadataCaptureEvent | null;
 /**
  * Convert a deliberately small event emitted by a VS Code/Copilot companion
  * extension. This is not a transcript importer: workspace paths, chat text,

package/dist/src/providers.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexStreamIdentity = codexStreamIdentity;
 exports.fromClaudeTranscriptJsonl = fromClaudeTranscriptJsonl;
 exports.fromClaudeCodeHook = fromClaudeCodeHook;
 exports.fromCodexJsonl = fromCodexJsonl;
@@ -24,6 +25,29 @@ function opaqueId(value, fallback) {
     return (candidate ||
         (0, node_crypto_1.createHash)("sha256").update(fallback).digest("hex").slice(0, 32));
 }
+/**
+ * Current Codex rollout logs put stream identity on `session_meta.payload`,
+ * while subsequent records carry only turn/item identifiers. Keep this small
+ * helper content-blind so the importer can safely inherit identity without
+ * inspecting prompts, responses, tool arguments, or reasoning.
+ */
+function codexStreamIdentity(input) {
+    const record = asRecord(input);
+    const payload = asRecord(record.payload);
+    const kind = string(record.type) || string(record.kind);
+    return {
+        sessionId: string(record.session_id) ||
+            string(record.sessionId) ||
+            string(payload.session_id) ||
+            string(payload.sessionId) ||
+            (kind === "session_meta" ? string(payload.id) : undefined),
+        clientVersion: string(record.client_version) ||
+            string(record.clientVersion) ||
+            string(payload.cli_version) ||
+            string(payload.client_version) ||
+            string(payload.clientVersion),
+    };
+}
 const relationships = new Set([
     "ROOT",
     "RESUMED_FROM",
@@ -57,7 +81,11 @@ function usagePayload(value) {
         inputTokens: ["inputTokens", "input_tokens"],
         outputTokens: ["outputTokens", "output_tokens"],
         cachedInputTokens: ["cachedInputTokens", "cached_input_tokens"],
-        reasoningTokens: ["reasoningTokens", "reasoning_tokens"],
+        reasoningTokens: [
+            "reasoningTokens",
+            "reasoning_tokens",
+            "reasoning_output_tokens",
+        ],
         costMicros: ["costMicros", "cost_micros"],
     };
     for (const [target, keys] of Object.entries(aliases)) {
@@ -219,17 +247,31 @@ function fromClaudeCodeHook(input, captureContent = false) {
  * format evolves, so unknown record kinds become a safe capture warning rather
  * than being misrepresented as a complete observation.
  */
-function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = false) {
+function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = false, inheritedIdentity = {}) {
     const record = asRecord(input);
     const payload = asRecord(record.payload);
-    const sourceSessionId = string(record.session_id) ||
-        string(record.sessionId) ||
-        string(payload.session_id) ||
-        string(payload.sessionId);
+    const identity = codexStreamIdentity(record);
+    const sourceSessionId = identity.sessionId || inheritedIdentity.sessionId;
     if (!sourceSessionId)
         return null;
     const kind = string(record.type) || string(record.kind) || "unknown";
     const eventName = string(payload.type) || string(payload.event) || kind;
+    // Current Codex emits these bookkeeping/wrapper records alongside the
+    // canonical response_item/token_usage_record stream. They do not describe a
+    // distinct user-visible event, and reasoning is provider-private. Ignoring
+    // them avoids duplicate evidence and never turns hidden reasoning into a
+    // transcript or misleading schema warning.
+    if (kind === "turn_context" ||
+        kind === "world_state" ||
+        (kind === "response_item" && eventName === "reasoning") ||
+        (kind === "event_msg" && [
+            "item_completed",
+            "token_count",
+            "thread_settings_applied",
+            "task_started",
+            "task_complete",
+        ].includes(eventName)))
+        return null;
     let type = "capture.warning";
     if (kind === "session_meta" ||
         eventName === "session_started" ||
@@ -244,12 +286,12 @@ function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = fa
     else if (eventName === "task_complete" || eventName === "session_ended")
         type = "session.ended";
     else if (kind === "response_item" &&
-        (string(payload.type) === "function_call" ||
-            string(payload.item_type) === "function_call"))
+        (["function_call", "custom_tool_call"].includes(string(payload.type) || "") ||
+            ["function_call", "custom_tool_call"].includes(string(payload.item_type) || "")))
         type = "tool.started";
     else if (kind === "response_item" &&
-        (string(payload.type) === "function_call_output" ||
-            string(payload.item_type) === "function_call_output"))
+        (["function_call_output", "custom_tool_call_output"].includes(string(payload.type) || "") ||
+            ["function_call_output", "custom_tool_call_output"].includes(string(payload.item_type) || "")))
         type = "tool.completed";
     else if (eventName === "subagent_started")
         type = "subagent.started";
@@ -259,11 +301,13 @@ function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = fa
         type = "message.recorded";
     else if (eventName === "user_message" || eventName === "agent_message")
         type = "message.recorded";
-    else if (eventName === "usage" || eventName === "usage_recorded")
+    else if (kind === "token_usage_record" ||
+        eventName === "usage" ||
+        eventName === "usage_recorded")
         type = "usage.recorded";
     const lineId = string(record.id) ||
         string(payload.id) ||
-        `${sourceFile}:${kind}:${record.timestamp || ""}:${eventName}`;
+        `${sourceFile}:${kind}:${record.ordinal || ""}:${record.timestamp || ""}:${eventName}`;
     const parent = string(payload.parent_session_id) ||
         string(payload.parentSessionId) ||
         string(record.parent_session_id) ||
@@ -274,9 +318,12 @@ function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = fa
         string(payload.text);
     const toolName = string(payload.name) || string(payload.tool_name);
     const toolInput = string(payload.arguments) ||
+        string(payload.input) ||
         (payload.arguments && typeof payload.arguments === "object"
             ? JSON.stringify(payload.arguments)
-            : undefined);
+            : payload.input && typeof payload.input === "object"
+                ? JSON.stringify(payload.input)
+                : undefined);
     const toolOutput = textParts(payload.output) || string(payload.result);
     const visible = type === "message.recorded"
         ? transcript(role === "assistant" || eventName === "agent_message"
@@ -299,7 +346,7 @@ function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = fa
         adapter: "codex",
         provider: "codex",
         clientName: "Codex",
-        clientVersion: string(record.client_version) || string(record.clientVersion),
+        clientVersion: identity.clientVersion || inheritedIdentity.clientVersion,
         sessionId: sourceSessionId,
         sourceEventId: opaqueId(lineId, sourceSessionId),
         occurredAt: timestamp(record.timestamp || payload.timestamp),
@@ -308,7 +355,7 @@ function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = fa
             recordKind: kind,
             eventName,
             sourceFilePresent: Boolean(sourceFile),
-            ...usagePayload(payload),
+            ...usagePayload(kind === "token_usage_record" ? asRecord(payload.usage) : payload),
         },
         sourceGenerationId: generation(record, payload),
         relationship: relationship(payload.relationship ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zewstid/zeye-capture",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Consented coding-session capture and continuous sync for Zeye Engineering Memory.",
   "license": "UNLICENSED",
   "publishConfig": { "access": "public" },