mixdog 1.3.5 → 1.4.1

package/src/runtime/agent/orchestrator/session/compaction-archive.mjs

@@ -194,38 +194,63 @@ async function archiveIndexFor(path, handle) {
   return entries;
 }
 
-/** One page of a session's archive sidecar (see pageFromSegments). The
- *  open handle pins the file a concurrent atomic replace may swap out, so
- *  the index and the segment reads describe the same bytes. */
-export async function readCompactionArchivePage(storeDir, sessionId, range = {}) {
+/** Runs `use(entries, load)` over a session's archive sidecar: its segment
+ *  index and a loader of one segment's items. The open handle pins the file
+ *  a concurrent atomic replace may swap out, so the index and the segment
+ *  reads describe the same bytes. `fallback` when the archive is absent or
+ *  unreadable (display-only history: it shows nothing then). */
+async function withArchive(storeDir, sessionId, fallback, use) {
   const path = compactionArchivePath(storeDir, sessionId);
-  if (!path) return { items: [], hasOlder: false };
+  if (!path) return fallback;
   let handle;
   try {
     handle = await open(path, 'r');
   } catch {
-    // Display-only history: an absent or unreadable archive shows nothing.
     archiveIndexes.delete(path);
-    return { items: [], hasOlder: false };
+    return fallback;
   }
   try {
     const entries = await archiveIndexFor(path, handle);
-    return await pageFromSegments(
-      entries,
-      async (entry) => {
-        const buffer = Buffer.alloc(entry.length);
-        await handle.read(buffer, 0, entry.length, entry.start);
-        return segmentItems(buffer.toString('utf8'));
-      },
-      range
-    );
+    return await use(entries, async (entry) => {
+      const buffer = Buffer.alloc(entry.length);
+      await handle.read(buffer, 0, entry.length, entry.start);
+      return segmentItems(buffer.toString('utf8'));
+    });
   } catch {
-    return { items: [], hasOlder: false };
+    return fallback;
   } finally {
     await handle.close().catch(() => {});
   }
 }
 
+/** One page of a session's archive sidecar (see pageFromSegments). */
+export function readCompactionArchivePage(storeDir, sessionId, range = {}) {
+  return withArchive(storeDir, sessionId, { items: [], hasOlder: false }, (entries, load) =>
+    pageFromSegments(entries, load, range)
+  );
+}
+
+/** Hands every visible segment of the archive (numbered in (after, before),
+ *  oldest first) to `visit` as its items, one segment at a time, so a whole
+ *  walk never holds more than one segment. True when the walk completed;
+ *  false when the archive was absent or unreadable (the visits made so far
+ *  are then incomplete). */
+export function visitCompactionArchive(
+  storeDir,
+  sessionId,
+  { after = 0, before = Number.POSITIVE_INFINITY } = {},
+  visit
+) {
+  return withArchive(storeDir, sessionId, false, async (entries, load) => {
+    for (const entry of entries) {
+      const { seq, count } = entry.head;
+      if (seq <= after || seq >= before || count < 1) continue;
+      visit(await load(entry));
+    }
+    return true;
+  });
+}
+
 // Delete fence: every deletion bumps the session's epoch. A writer captures
 // the epoch before it starts and publishes only if it is unchanged at the
 // (synchronous) rename, so a delete that lands while a segment is being

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -581,8 +581,20 @@ function reasoningBreakdown(message, fullTextTokens) {
       };
     }
   }
+  // Price each reasoning item that is actually sent (a non-empty replay
+  // replaces content) at its own cost; the whole-minus-visible difference only
+  // caps the sum so the rows never exceed the total.
+  const sent = message.providerReplay?.items?.length ? message.providerReplay.items.filter(isReasoningBlock) : blocks;
   return {
-    tokens: blocks.length ? Math.max(0, fullTextTokens() - messageTextTokens(visible)) : 0,
+    tokens: blocks.length
+      ? Math.max(
+          0,
+          Math.min(
+            sent.reduce((sum, block) => sum + estimateTokens(nativeBlocksEstimateText(block)), 0),
+            fullTextTokens() - messageTextTokens(visible)
+          )
+        )
+      : 0,
     blocks,
     message: visible,
   };

package/src/runtime/agent/orchestrator/session/conversation-import/claude.mjs

@@ -3,12 +3,21 @@
  * import turns. The active branch is followed from the last main-chain entry
  * back through `parentUuid` (and `logicalParentUuid` across a compaction), so
  * replayed or abandoned branches never duplicate. Kept: text blocks and
- * `tool_use` as `[ran tool: <name>]` notes; images become an omission marker;
- * a compaction summary only when the history it replaced is no longer linked.
- * Dropped: sidechains, meta entries, tool results, thinking, signatures and
- * Claude Code's own command/notification envelopes.
+ * `tool_use` as tool notes; images become an omission marker; a compaction
+ * summary (as an assistant recap) only when the history it replaced is gone;
+ * a slash command as `/name args` unless the app answered it locally; pasted
+ * text without the app's paste envelope. Dropped: sidechains, meta entries,
+ * tool results, thinking, signatures and Claude Code's own
+ * command-output/notification envelopes.
  */
-import { IMAGE_OMITTED_TEXT, IMPORT_WARNING_IMAGE_OMITTED, isWholeElement, textPart, toolNote } from './turns.mjs';
+import {
+  IMAGE_OMITTED_TEXT,
+  IMPORT_WARNING_IMAGE_OMITTED,
+  isWholeElement,
+  textPart,
+  titleFromText,
+  toolNote,
+} from './turns.mjs';
 
 const CLAUDE_ENVELOPE_TAGS = [
   'local-command-stdout',
@@ -20,11 +29,54 @@ const CLAUDE_ENVELOPE_TAGS = [
   'bash-input',
   'bash-stdout',
   'bash-stderr',
+  // The app's own instructions behind its "create PR" action.
+  'create-pr-command',
 ];
-const SLASH_COMMAND_RE = /^(?:\s*<(command-name|command-message|command-args)>[\s\S]*?<\/\1>)+\s*$/;
+const LOCAL_OUTPUT_TAGS = ['local-command-stdout', 'local-command-stderr'];
+const SLASH_COMMAND_RE = /^(?:\s*<(command-name|command-message|command-args|skill-format)>[\s\S]*?<\/\1>)+\s*$/;
 const INTERRUPTED_RE = /^\[Request interrupted by user[^\]\n]*\]$/;
 // Claude Code's text annotation that accompanies a pasted image block.
 const IMAGE_ANNOTATION_RE = /^\[Image\b[^\n]*\]$/;
+// The desktop app's paste envelope: `<pasted_content id="hhhh">\n` body
+// `\n</pasted_content id="hhhh">`, one four-hex id on both tags.
+const PASTE_OPEN = '<pasted_content id="';
+const PASTE_ID_RE = /^[0-9a-f]{4}$/;
+
+/**
+ * Text with the app's paste envelopes unwrapped the way the app displays it:
+ * each paste body in place, the text around it trimmed toward it, pieces on
+ * their own lines. Only a complete envelope with a matching id is unwrapped; any
+ * other `<pasted_content…>` is the user's own text and stays as typed.
+ */
+export function unwrapClaudePastes(text) {
+  const pieces = [];
+  let cursor = 0;
+  let search = 0;
+  for (;;) {
+    const open = text.indexOf(PASTE_OPEN, search);
+    if (open < 0) break;
+    const idStart = open + PASTE_OPEN.length;
+    const id = text.slice(idStart, idStart + 4);
+    const bodyStart = idStart + 7; // past `hhhh">\n`
+    if (!PASTE_ID_RE.test(id) || text.slice(idStart + 4, bodyStart) !== '">\n') {
+      search = idStart;
+      continue;
+    }
+    const closeTag = `\n</pasted_content id="${id}">`;
+    // The line feed ending the open tag may also start the close tag (an empty paste).
+    const close = text.indexOf(closeTag, bodyStart - 1);
+    if (close < 0) break;
+    // Trimmed only toward a paste: the first fragment keeps its leading text.
+    const before = text.slice(cursor, open);
+    pieces.push(cursor ? before.trim() : before.trimEnd(), text.slice(bodyStart, Math.max(close, bodyStart)));
+    cursor = close + closeTag.length;
+    search = cursor;
+  }
+  if (!pieces.length) return text;
+  pieces.push(text.slice(cursor).trimStart());
+  const unwrapped = pieces.filter((piece, index) => index % 2 === 1 || piece).join('\n');
+  return unwrapped.trim() ? unwrapped : text;
+}
 
 export function isClaudeEnvelopeText(text) {
   const trimmed = String(text || '').trim();
@@ -37,6 +89,17 @@ export function isClaudeEnvelopeText(text) {
   );
 }
 
+const tagValue = (text, tag) => new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`).exec(text)?.[1].trim() || '';
+
+/** A slash-command envelope as Claude Code shows it (`/name args`), else null. */
+export function claudeCommandText(text) {
+  const trimmed = String(text || '').trim();
+  if (!SLASH_COMMAND_RE.test(trimmed)) return null;
+  const name = (tagValue(trimmed, 'command-name') || tagValue(trimmed, 'command-message')).replace(/^\//, '');
+  if (!name) return null;
+  return [`/${name}`, tagValue(trimmed, 'command-args')].filter(Boolean).join(' ');
+}
+
 const isMessageEntry = (record) => record?.type === 'user' || record?.type === 'assistant';
 const stringOrNull = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
 const uuidOrNull = (value) => (typeof value === 'string' ? value : null);
@@ -49,42 +112,69 @@ const metadataLength = (entry) =>
   (entry.logicalParentUuid?.length || 0) +
   (typeof entry.at === 'string' ? entry.at.length : 0);
 
+// The main-chain message written last before file position `seq`: the leaf of
+// the history a compaction boundary replaced.
+function precedingMain(entries, seq) {
+  for (let index = seq - 1; index >= 0; index--) {
+    if (entries[index].main && entries[index].uuid !== null) return entries[index];
+  }
+  return null;
+}
+
 /**
  * The active branch, root first: walked back from the last main-chain entry.
- * `crossedCompaction` tells whether a compaction boundary led back into the
- * history it replaced (Claude Code often no longer keeps that history).
+ * A compaction boundary links back to the history it replaced through its
+ * logical parent, or, when Claude Code never wrote that message, to the last
+ * message before the boundary. `replaced` holds the compaction summaries whose
+ * history the walk crossed into (that history is imported instead).
  */
 function activeChain(entries) {
   const main = entries.filter((entry) => entry.main);
   const leaf = main[main.length - 1];
-  if (!leaf || leaf.uuid === null) return { chain: main, crossedCompaction: false };
+  if (!leaf || leaf.uuid === null) return { chain: main, replaced: new Set() };
   const byUuid = new Map();
   for (const entry of entries) {
     if (entry.uuid !== null) byUuid.set(entry.uuid, entry);
   }
   const chain = [];
   const seen = new Set();
-  let crossedCompaction = false;
+  const replaced = new Set();
+  let summary = null;
   let current = leaf;
   while (current && !seen.has(current.uuid)) {
     seen.add(current.uuid);
     chain.push(current);
+    if (current.summary) summary = current;
     const parent = current.parentUuid !== null ? byUuid.get(current.parentUuid) : null;
-    const logical = !parent && current.logicalParentUuid !== null ? byUuid.get(current.logicalParentUuid) : null;
-    if (logical) crossedCompaction = true;
+    const logical =
+      !parent && current.logicalParentUuid !== null
+        ? byUuid.get(current.logicalParentUuid) || precedingMain(entries, current.seq)
+        : null;
+    if (logical && summary) {
+      replaced.add(summary);
+      summary = null;
+    }
     current = parent || logical;
   }
-  return { chain: chain.reverse().filter((entry) => entry.main), crossedCompaction };
+  return { chain: chain.reverse().filter((entry) => entry.main), replaced };
 }
 
-function entryParts(role, content, warnings) {
+/** Kept parts of a message; a slash command is a `command` part, a local command's output marks `localOutput`. */
+function entryParts(role, content, warnings, marks) {
   const blocks = typeof content === 'string' ? [{ type: 'text', text: content }] : content;
   if (!Array.isArray(blocks)) return [];
   const parts = [];
   for (const block of blocks) {
     if (!block || typeof block !== 'object') continue;
     if (block.type === 'text' && typeof block.text === 'string') {
-      if (role === 'user' && isClaudeEnvelopeText(block.text)) continue;
+      if (role === 'user') {
+        const command = claudeCommandText(block.text);
+        if (command) parts.push({ ...textPart(command), command: true });
+        if (isWholeElement(block.text, LOCAL_OUTPUT_TAGS)) marks.localOutput = true;
+        if (isClaudeEnvelopeText(block.text)) continue;
+        parts.push(textPart(unwrapClaudePastes(block.text)));
+        continue;
+      }
       parts.push(textPart(block.text));
     } else if (block.type === 'image') {
       warnings.add(IMPORT_WARNING_IMAGE_OMITTED);
@@ -96,6 +186,31 @@ function entryParts(role, content, warnings) {
   return parts;
 }
 
+/**
+ * The title Claude Code's resume list shows from the records it appends to a
+ * transcript: the last `custom-title` (a `/rename`), else the last `ai-title`,
+ * then the last `summary`, then the last `last-prompt`. A blank custom title
+ * (a cleared rename) ends the name tier without falling back to the AI title.
+ * Other record types, such as `task-summary` or `agent-name`, never name it.
+ */
+export function createClaudeTitleScan() {
+  let custom;
+  let ai;
+  let summary;
+  let lastPrompt;
+  return {
+    push(record) {
+      if (record.type === 'custom-title' && typeof record.customTitle === 'string') custom = record.customTitle;
+      else if (record.type === 'ai-title' && typeof record.aiTitle === 'string') ai = record.aiTitle;
+      else if (record.type === 'summary' && typeof record.summary === 'string') summary = record.summary;
+      else if (record.type === 'last-prompt' && typeof record.lastPrompt === 'string') lastPrompt = record.lastPrompt;
+    },
+    title() {
+      return titleFromText(custom ?? ai) || titleFromText(summary) || titleFromText(lastPrompt);
+    },
+  };
+}
+
 function skippedEntry(record) {
   // Claude Code flags its compaction summary transcript-only as well.
   if (record.isCompactSummary === true) return false;
@@ -111,9 +226,12 @@ function skippedEntry(record) {
  */
 export function createClaudeReducer() {
   const entries = [];
+  const titleScan = createClaudeTitleScan();
   let recognized = false;
   let foreignSessionId = null;
   let cwd = null;
+  let sidechainSeen = false;
+  let mainSeen = false;
   let chars = 0;
   let metadataBytes = 0;
   return {
@@ -126,10 +244,23 @@ export function createClaudeReducer() {
     get metadataBytes() {
       return metadataBytes;
     },
+    /** Cheap running check: messages seen so far are all sidechain (a verdict only at the end of the file). */
+    get sidechainOnly() {
+      return sidechainSeen && !mainSeen;
+    },
+    /** Feed a record for its stored title only (a transcript's tail window). */
+    pushTitle(record) {
+      titleScan.push(record);
+    },
     push(record) {
+      titleScan.push(record);
       const message = isMessageEntry(record);
       if (message) recognized = true;
       const main = message && record.isSidechain !== true;
+      if (message) {
+        if (main) mainSeen = true;
+        else sidechainSeen = true;
+      }
       if (main) {
         foreignSessionId ||= stringOrNull(record.sessionId);
         cwd ||= stringOrNull(record.cwd);
@@ -145,13 +276,14 @@ export function createClaudeReducer() {
         parts: null,
         warnings: null,
         at: timestampOrNull(record.timestamp),
+        seq: entries.length,
       };
       metadataBytes += ENTRY_OVERHEAD_BYTES + metadataLength(entry);
       if (main && !skippedEntry(record)) {
         const body = record.message && typeof record.message === 'object' ? record.message : null;
         entry.role = body?.role === 'user' || body?.role === 'assistant' ? body.role : record.type;
         const warnings = new Set();
-        entry.parts = entryParts(entry.role, body ? body.content : null, warnings);
+        entry.parts = entryParts(entry.role, body ? body.content : null, warnings, entry);
         if (record.isCompactSummary === true) {
           entry.summary = true;
           entry.parts = entry.parts.map((part) => ({ ...part, summary: true }));
@@ -164,15 +296,24 @@ export function createClaudeReducer() {
     result() {
       const warnings = new Set();
       const rawTurns = [];
-      const { chain, crossedCompaction } = activeChain(entries);
-      for (const entry of chain) {
+      const { chain, replaced } = activeChain(entries);
+      for (const [index, entry] of chain.entries()) {
         if (!entry.parts?.length) continue;
-        // The summary stands in for history only when that history is gone.
-        if (entry.summary && crossedCompaction) continue;
-        rawTurns.push({ role: entry.role, parts: entry.parts, at: entry.at });
+        // The summary stands in for history only when that history is gone,
+        // and then as the model's recap, never as something the user wrote.
+        if (entry.summary && replaced.has(entry)) continue;
+        const role = entry.summary ? 'assistant' : entry.role;
+        // A local command (`/model`, `/rename`…) answered by the app itself is not part of the conversation.
+        const local =
+          entry.parts.some((part) => part.command) &&
+          chain.slice(index + 1).find((next) => next.parts?.length || next.localOutput)?.localOutput;
+        const parts = local ? entry.parts.filter((part) => !part.command) : entry.parts;
+        rawTurns.push({ role, parts, at: entry.at });
         for (const code of entry.warnings || []) warnings.add(code);
       }
-      return { recognized, foreignSessionId, cwd, rawTurns, warnings };
+      // A transcript whose every message is a sidechain is a subagent's own, not a conversation.
+      const internalKind = this.sidechainOnly ? 'subagent' : null;
+      return { recognized, foreignSessionId, cwd, internalKind, rawTurns, warnings, storedTitle: titleScan.title() };
     },
   };
 }

package/src/runtime/agent/orchestrator/session/conversation-import/codex.mjs

@@ -1,7 +1,7 @@
 /**
  * Codex CLI rollout (`rollout-*.jsonl`) → raw import turns. Kept: the first
  * `session_meta` (foreign id, cwd), user/assistant `message` items as text and
- * tool calls as `[ran tool: <name>]` notes. Dropped: developer/system
+ * tool calls as tool notes. Dropped: developer/system
  * messages, Codex's own wrapper user messages, tool outputs, reasoning,
  * event_msg, token counts and turn_context.
  */
@@ -17,6 +17,7 @@ const CODEX_ENVELOPE_TAGS = [
   'user_shell_command',
   'subagent_notification',
   'skills_instructions',
+  'external_codex_apps_open_page',
 ];
 const TOOL_CALL_TYPES = new Set(['function_call', 'custom_tool_call', 'local_shell_call']);
 
@@ -29,6 +30,17 @@ export function isCodexEnvelopeText(text) {
   return /^<image\b[^>]*>$/.test(trimmed) || trimmed === '</image>';
 }
 
+// Codex shows a user message after the last of these headings: what precedes it
+// is context the app adds for the model (IDE state, mentioned files, response
+// annotations, an earlier request it already carries).
+const USER_REQUEST_HEADING = '## My request for Codex:';
+
+/** A user text part as Codex displays it. */
+export function codexUserDisplayText(text) {
+  const at = text.lastIndexOf(USER_REQUEST_HEADING);
+  return at < 0 ? text : text.slice(at + USER_REQUEST_HEADING.length).trim();
+}
+
 function messageParts(payload, warnings) {
   const content = typeof payload.content === 'string' ? [{ type: 'text', text: payload.content }] : payload.content;
   if (!Array.isArray(content)) return [];
@@ -41,8 +53,8 @@ function messageParts(payload, warnings) {
       continue;
     }
     if (typeof item.text !== 'string') continue;
-    if (payload.role === 'user' && isCodexEnvelopeText(item.text)) continue;
-    parts.push(textPart(item.text));
+    if (payload.role !== 'user') parts.push(textPart(item.text));
+    else if (!isCodexEnvelopeText(item.text)) parts.push(textPart(codexUserDisplayText(item.text)));
   }
   return parts;
 }
@@ -53,6 +65,31 @@ function toolName(payload) {
 }
 
 const stringOrNull = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+
+// `session_meta.thread_source` values Codex gives threads it runs for itself.
+const INTERNAL_THREAD_SOURCES = {
+  subagent: 'subagent',
+  guardian_review: 'guardianReview',
+  memory_consolidation: 'internal',
+};
+
+/**
+ * What kind of Codex-internal record a `session_meta` payload marks, else null
+ * for a conversation the user had. Markers are Codex's own: `thread_source`
+ * (`subagent`, `guardian_review`, `memory_consolidation`) and a `source` of the
+ * form `{ subagent: … }` (spawned agent, review, compact; `{ other: "guardian" }`
+ * is the approval reviewer) or `{ internal: … }`. Other sources (cli, vscode,
+ * exec, mcp, custom) and features (automation, voice chat) are the user's.
+ */
+export function codexInternalKind(payload) {
+  const byThread = INTERNAL_THREAD_SOURCES[payload?.thread_source];
+  if (byThread) return byThread;
+  const source = payload?.source;
+  if (!source || typeof source !== 'object') return null;
+  if ('subagent' in source) return source.subagent?.other === 'guardian' ? 'guardianReview' : 'subagent';
+  if ('internal' in source) return source.internal === 'guardian' ? 'guardianReview' : 'internal';
+  return null;
+}
 // Rough fixed cost of one retained turn object, so tiny turns still count.
 const ENTRY_OVERHEAD_BYTES = 64;
 
@@ -67,6 +104,8 @@ export function createCodexReducer() {
   let recognized = false;
   let foreignSessionId = null;
   let cwd = null;
+  let internalKind = null;
+  let historyBase = null;
   let metaSeen = false;
   let chars = 0;
   let metadataBytes = 0;
@@ -86,15 +125,19 @@ export function createCodexReducer() {
     get metadataBytes() {
       return metadataBytes;
     },
-    push(record) {
+    /** `inherited` records come from a history base: its session metadata is not this thread's. */
+    push(record, inherited = false) {
       const payload = record?.payload && typeof record.payload === 'object' ? record.payload : null;
       if (!payload) return;
       if (record.type === 'session_meta') {
+        if (inherited) return;
         recognized = true;
         if (!metaSeen) {
           metaSeen = true;
           foreignSessionId = stringOrNull(payload.id) || stringOrNull(payload.session_id);
           cwd = stringOrNull(payload.cwd);
+          internalKind = codexInternalKind(payload);
+          if (payload.history_base && typeof payload.history_base === 'object') historyBase = payload.history_base;
         }
         return;
       }
@@ -108,23 +151,95 @@ export function createCodexReducer() {
       }
     },
     result() {
-      return { recognized, foreignSessionId, cwd, rawTurns, warnings };
+      return { recognized, foreignSessionId, cwd, internalKind, historyBase, rawTurns, warnings };
     },
   };
 }
 
-/** id/cwd of a `session_meta` first line cut off by a bounded prefix read. */
-export function codexMetaFromTruncatedLine(line) {
-  const text = String(line || '');
-  if (!/"type"\s*:\s*"session_meta"/.test(text)) return null;
-  const field = (name) => {
-    const match = new RegExp(`"${name}"\\s*:\\s*("(?:[^"\\\\]|\\\\.)*")`).exec(text);
-    if (!match) return null;
-    try {
-      return stringOrNull(JSON.parse(match[1]));
-    } catch {
-      return null;
+// ── bounded-prefix `session_meta` scan ───────────────────────────────────────
+// Index after the string starting at `i`, or -1 when the text ends inside it.
+function scanString(text, i) {
+  for (let j = i + 1; j < text.length; j++) {
+    if (text[j] === '\\') j++;
+    else if (text[j] === '"') return j + 1;
+  }
+  return -1;
+}
+
+// Index after the JSON value starting at `i`, or -1 when the text ends inside it.
+function scanValue(text, i) {
+  if (text[i] === '"') return scanString(text, i);
+  if (text[i] === '{' || text[i] === '[') {
+    let depth = 0;
+    for (let j = i; j < text.length; j++) {
+      if (text[j] === '"') {
+        j = scanString(text, j) - 1;
+        if (j < 0) return -1;
+      } else if (text[j] === '{' || text[j] === '[') depth++;
+      else if ((text[j] === '}' || text[j] === ']') && --depth === 0) return j + 1;
     }
+    return -1;
+  }
+  const literal = /[^,}\]\s]+/y;
+  literal.lastIndex = i;
+  literal.exec(text);
+  return literal.lastIndex < text.length ? literal.lastIndex : -1;
+}
+
+/**
+ * Complete top-level values (raw JSON text) of the record object and of its
+ * `payload` object in a possibly cut-off line. Nested values are never
+ * inspected, so a key inside custom metadata is not mistaken for a payload field.
+ */
+function recordFields(text) {
+  const top = {};
+  const payload = {};
+  const walk = (start, target, descend) => {
+    let j = start + 1;
+    for (;;) {
+      while (/[\s,]/.test(text[j] ?? '')) j++;
+      if (text[j] !== '"') return;
+      const keyEnd = scanString(text, j);
+      if (keyEnd < 0) return;
+      const key = JSON.parse(text.slice(j, keyEnd));
+      j = keyEnd;
+      while (/\s/.test(text[j] ?? '')) j++;
+      if (text[j] !== ':') return;
+      j++;
+      while (/\s/.test(text[j] ?? '')) j++;
+      if (descend && key === 'payload' && text[j] === '{') return walk(j, payload, false);
+      const end = scanValue(text, j);
+      if (end < 0) return;
+      target[key] = text.slice(j, end);
+      j = end;
+    }
+  };
+  const open = text.indexOf('{');
+  if (open >= 0) walk(open, top, true);
+  return { top, payload };
+}
+
+const jsonOrNull = (raw) => {
+  try {
+    return raw === undefined ? null : JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * id/cwd/internal kind of a `session_meta` first line cut off by a bounded
+ * prefix read, from the payload fields that arrived whole. A marker that did
+ * not arrive whole leaves the record unclassified (`internalKind: null`).
+ */
+export function codexMetaFromTruncatedLine(line) {
+  const { top, payload } = recordFields(String(line || ''));
+  if (jsonOrNull(top.type) !== 'session_meta') return null;
+  const field = (name) => stringOrNull(jsonOrNull(payload[name]));
+  const meta = { thread_source: field('thread_source'), source: jsonOrNull(payload.source) };
+  return {
+    foreignSessionId: field('id') || field('session_id'),
+    cwd: field('cwd'),
+    internalKind: codexInternalKind(meta),
   };
-  return { foreignSessionId: field('id') || field('session_id'), cwd: field('cwd') };
 }