@spexcode/transcript 0.7.0-next.2 → 0.7.0-next.4

package/dist/parsers.js

@@ -54,8 +54,22 @@ const lineCount = (value) => value ? value.split(/\r?\n/).length : 0;
 // --- the seven native shapes -------------------------------------------------------------------------------
 export function claudeEvent(value) {
     const entry = object(value);
-    const message = object(entry?.message);
-    if (!entry || !message)
+    if (!entry)
+        return null;
+    // A message steered into a RUNNING turn (stream-json `type:user` on stdin, a queued command in the TUI) is not
+    // recorded as a `user` message: Claude writes it as an `attachment` of type `queued_command` carrying the prompt
+    // blocks. It is the person's turn all the same, and the one place a steer becomes observable — hooks never fire
+    // for it — so the reader draws it as a user turn at the moment it entered the conversation.
+    if (entry.type === 'attachment') {
+        const attachment = object(entry.attachment);
+        const queuedAt = at(entry);
+        if (attachment?.type !== 'queued_command' || queuedAt === null)
+            return null;
+        const text = items(attachment.prompt).map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
+        return text ? { at: queuedAt, turn: { id: idOf(entry), at: queuedAt, role: 'user', text, tools: [] } } : null;
+    }
+    const message = object(entry.message);
+    if (!message)
         return null;
     const eventAt = at(entry) ?? at(message);
     if (eventAt === null)
@@ -90,6 +104,9 @@ export function claudeEvent(value) {
     }
     return null;
 }
+const blockText = (content) => typeof content === 'string'
+    ? string(content)
+    : items(content).map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
 export function codexEvent(value) {
     const entry = object(value);
     const payload = object(entry?.payload);
@@ -99,16 +116,25 @@ export function codexEvent(value) {
     if (eventAt === null)
         return { at: null, turn: null };
     const type = string(payload.type);
-    if ((entry.type === 'event_msg' && type === 'user_message')
-        || (entry.type === 'response_item' && (type === 'message' || type === 'input_message') && payload.role === 'user')) {
+    // THE PERSON'S MESSAGE is the `user_message` event. Codex also records it as a `response_item` message (the API
+    // form, `input_text` blocks) beside harness injections that no person typed (the AGENTS.md instructions), so
+    // that form is not a turn — the event is, once.
+    if (entry.type === 'event_msg' && type === 'user_message') {
         const text = typeof payload.message === 'string' ? payload.message : compact(payload.message ?? payload.content ?? '');
         return text ? { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'user', text, tools: [] } } : null;
     }
-    // commentary AND the final answer are both what the agent said; only structured reasoning stays private
+    if (entry.type === 'response_item' && (type === 'message' || type === 'input_message') && payload.role === 'user')
+        return { at: eventAt, turn: null };
+    // WHAT THE AGENT SAID is the `agent_message` event — commentary and the final answer alike. Codex 0.146 also
+    // records the same prose as a `response_item` message (`output_text` blocks) beside it, so that form is not read:
+    // reading both would say every sentence twice. An empty event (a final answer that was a tool call) is a clock,
+    // not a turn. Structured reasoning stays private.
     if (entry.type === 'event_msg' && type === 'agent_message') {
         const text = string(payload.message ?? payload.text);
-        return text ? { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', text, tools: [] } } : null;
+        return text ? { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', text, tools: [] } } : { at: eventAt, turn: null };
     }
+    if (entry.type === 'response_item' && type === 'message' && payload.role === 'assistant')
+        return { at: eventAt, turn: null };
     if (entry.type === 'response_item' && (type === 'custom_tool_call' || type === 'function_call')) {
         const id = string(payload.call_id ?? payload.id) ?? 'tool';
         return { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', tools: [{ id, name: string(payload.name ?? payload.tool_name) ?? 'tool', input: payload.input === undefined && payload.arguments === undefined ? undefined : compact(payload.input ?? payload.arguments), outputLines: 0, outputBytes: 0 }] } };
@@ -215,9 +241,6 @@ export function codexAppServerStream() {
         return parsed;
     };
 }
-const blockText = (content) => typeof content === 'string'
-    ? string(content)
-    : items(content).map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
 export function piEvent(value) {
     const entry = object(value);
     const message = object(entry?.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/transcript",
-  "version": "0.7.0-next.2",
+  "version": "0.7.0-next.4",
   "type": "module",
   "description": "Normalized agent transcripts: one parser per harness, a bounded interval reader over a native thread file or an in-memory event stream, and the full/delta frame protocol every transport and renderer share.",
   "files": [