deepline 0.2.51 → 0.2.53

package/dist/bundling-sources/sdk/src/client.ts

@@ -819,7 +819,7 @@ export type MonitorsNamespace = {
     definition: MonitorDefinition,
     options?: { dryRun?: boolean },
   ) => Promise<MonitorDeployResult>;
-  /** List deployed monitors (active by default). `includeConsumers` requires limit <= 20. */
+  /** List deployed monitors (active by default). `includeConsumers` requires a limit of 20 or fewer. */
   list: (options?: MonitorsListOptions) => Promise<MonitorsListResult>;
   /** Fetch one deployed monitor by public key with bounded current listener health. */
   get: (key: string) => Promise<MonitorDetail>;

package/dist/bundling-sources/sdk/src/release.ts

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.51',
+  version: '0.2.53',
   contracts: {
     api: {
       name: 'sdk-http-api',

package/dist/cli/index.js

@@ -1044,7 +1044,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.51",
+  version: "0.2.53",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -30191,9 +30191,46 @@ function selectiveCompactToolResults(raw) {
   return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
 }
+function compactCodexEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const isCodex = parsedEvents.some(
+    (event) => event && typeof event === "object" && event.type === "session_meta"
+  );
+  if (!isCodex) return raw;
+  let lastTokenCountIndex = -1;
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") return;
+    const payload = event.payload;
+    if (payload && typeof payload === "object" && payload.type === "token_count") {
+      lastTokenCountIndex = index;
+    }
+  });
+  const lines = [];
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") {
+      lines.push(rawLines[index] ?? "");
+      return;
+    }
+    const record = event;
+    if (record.type === "world_state") return;
+    const payload = record.payload;
+    const payloadType = payload && typeof payload === "object" ? String(payload.type ?? "") : "";
+    if (payloadType === "token_count" && index !== lastTokenCountIndex) return;
+    if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output" || payloadType === "tool_search_output") {
+      const record_payload = payload;
+      record_payload.output = compactEventValue(record_payload.output);
+      lines.push(JSON.stringify(record));
+      return;
+    }
+    lines.push(rawLines[index] ?? "");
+  });
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
 function prepareSessionBuffer(raw) {
   return selectiveCompactToolResults(
-    dedupConsecutiveEvents(stripNoiseEvents(raw))
+    dedupConsecutiveEvents(compactCodexEvents(stripNoiseEvents(raw)))
   );
 }
 function buildSessionUploadContent(raw) {

package/dist/cli/index.mjs

@@ -1030,7 +1030,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.51",
+  version: "0.2.53",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -30244,9 +30244,46 @@ function selectiveCompactToolResults(raw) {
   return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
 }
+function compactCodexEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const isCodex = parsedEvents.some(
+    (event) => event && typeof event === "object" && event.type === "session_meta"
+  );
+  if (!isCodex) return raw;
+  let lastTokenCountIndex = -1;
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") return;
+    const payload = event.payload;
+    if (payload && typeof payload === "object" && payload.type === "token_count") {
+      lastTokenCountIndex = index;
+    }
+  });
+  const lines = [];
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") {
+      lines.push(rawLines[index] ?? "");
+      return;
+    }
+    const record = event;
+    if (record.type === "world_state") return;
+    const payload = record.payload;
+    const payloadType = payload && typeof payload === "object" ? String(payload.type ?? "") : "";
+    if (payloadType === "token_count" && index !== lastTokenCountIndex) return;
+    if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output" || payloadType === "tool_search_output") {
+      const record_payload = payload;
+      record_payload.output = compactEventValue(record_payload.output);
+      lines.push(JSON.stringify(record));
+      return;
+    }
+    lines.push(rawLines[index] ?? "");
+  });
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
 function prepareSessionBuffer(raw) {
   return selectiveCompactToolResults(
-    dedupConsecutiveEvents(stripNoiseEvents(raw))
+    dedupConsecutiveEvents(compactCodexEvents(stripNoiseEvents(raw)))
   );
 }
 function buildSessionUploadContent(raw) {

package/dist/index.d.mts

@@ -2201,7 +2201,7 @@ type MonitorsNamespace = {
     deploy: (definition: MonitorDefinition, options?: {
         dryRun?: boolean;
     }) => Promise<MonitorDeployResult>;
-    /** List deployed monitors (active by default). `includeConsumers` requires limit <= 20. */
+    /** List deployed monitors (active by default). `includeConsumers` requires a limit of 20 or fewer. */
     list: (options?: MonitorsListOptions) => Promise<MonitorsListResult>;
     /** Fetch one deployed monitor by public key with bounded current listener health. */
     get: (key: string) => Promise<MonitorDetail>;

package/dist/index.d.ts

@@ -2201,7 +2201,7 @@ type MonitorsNamespace = {
     deploy: (definition: MonitorDefinition, options?: {
         dryRun?: boolean;
     }) => Promise<MonitorDeployResult>;
-    /** List deployed monitors (active by default). `includeConsumers` requires limit <= 20. */
+    /** List deployed monitors (active by default). `includeConsumers` requires a limit of 20 or fewer. */
     list: (options?: MonitorsListOptions) => Promise<MonitorsListResult>;
     /** Fetch one deployed monitor by public key with bounded current listener health. */
     get: (key: string) => Promise<MonitorDetail>;

package/dist/index.js

@@ -763,7 +763,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.51",
+  version: "0.2.53",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/index.mjs

@@ -689,7 +689,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.51",
+  version: "0.2.53",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/viewer/viewer.css

@@ -341,10 +341,11 @@ body {
     min-width: 70px;
 }
 .tool-name.bash { color: var(--blue); }
-.tool-name.read, .tool-name.write, .tool-name.edit { color: var(--purple); }
+.tool-name.read, .tool-name.write, .tool-name.edit, .tool-name.delete { color: var(--purple); }
 .tool-name.skill, .tool-name.task { color: var(--orange); }
-.tool-name.grep, .tool-name.glob { color: var(--cyan); }
+.tool-name.grep, .tool-name.glob, .tool-name.toolsearch { color: var(--cyan); }
 .tool-name.webfetch, .tool-name.websearch { color: var(--yellow); }
+.tool-name.wait, .tool-name.stdin { color: var(--text-dim); }
 .tool-cmd {
     color: var(--text-dim);
     overflow: hidden;
@@ -881,6 +882,14 @@ body {
 .expectation-result.pass { color: var(--green); }
 .expectation-result.fail { color: var(--red); }
 .expectation-result.unknown { color: var(--yellow); }
+.expectation-failure-reason {
+    margin-top: 5px;
+    color: color-mix(in srgb, var(--red) 80%, var(--text-dim));
+    font-size: 10px;
+    font-weight: 400;
+    line-height: 1.4;
+    overflow-wrap: anywhere;
+}
 .infra-signals {
     margin-top: 10px;
     border: 1px solid color-mix(in srgb, var(--red) 45%, var(--viewer-border));
@@ -899,6 +908,52 @@ body {
 .lane-prompt, .lane-result { border-bottom: 1px solid var(--viewer-border); }
 .lane-prompt summary, .lane-result summary { cursor: pointer; padding: 8px 13px; color: var(--text-dim); font-size: 11px; font-weight: 650; }
 .lane-prompt .prompt-text, .lane-result .md-rendered { padding: 0 13px 12px; font-size: 12px; }
+
+.final-artifacts {
+    margin: 18px 0 4px;
+    border: 1px solid var(--viewer-border);
+    border-radius: 8px;
+    background: var(--bg-secondary);
+    overflow: hidden;
+}
+.final-artifacts-heading {
+    padding: 12px 14px;
+    border-bottom: 1px solid var(--viewer-border);
+    background: var(--bg-tertiary);
+}
+.final-artifacts-heading > div { display: flex; align-items: center; gap: 8px; }
+.final-artifacts-heading span { font-size: 12px; font-weight: 700; color: var(--text); text-transform: uppercase; letter-spacing: .04em; }
+.final-artifacts-heading strong { color: var(--viewer-primary); font-size: 12px; }
+.final-artifacts-heading p { margin: 4px 0 0; color: var(--text-dim); font-size: 11px; }
+.final-artifact-file { border-bottom: 1px solid var(--viewer-border); }
+.final-artifact-file:last-child { border-bottom: 0; }
+.final-artifact-file summary {
+    display: flex;
+    justify-content: space-between;
+    gap: 16px;
+    cursor: pointer;
+    padding: 10px 14px;
+    color: var(--text);
+    font-size: 12px;
+}
+.final-artifact-file summary span { color: var(--text-dim); font-weight: 400; }
+.final-artifact-meta { padding: 0 14px 9px; color: var(--text-dim); font-size: 10px; }
+.final-artifact-meta code { color: var(--text-dim); overflow-wrap: anywhere; }
+.final-artifact-meta span { margin-left: 10px; color: var(--viewer-primary); }
+.final-artifact-file pre {
+    max-height: 560px;
+    overflow: auto;
+    margin: 0;
+    padding: 13px 14px;
+    border-top: 1px solid var(--viewer-border);
+    background: var(--bg);
+    color: var(--text);
+    white-space: pre;
+    font-size: 11px;
+    line-height: 1.5;
+}
+.final-artifact-omitted { padding: 0 14px 12px; color: var(--text-dim); font-size: 11px; }
+.lane-session .final-artifacts { margin: 0; border-width: 1px 0 0; border-radius: 0; }
 .lane-timeline { padding: 10px 7px 16px; }
 .lane-timeline .tool-row { gap: 8px; padding-left: 5px; padding-right: 5px; font-size: 11px; }
 .lane-timeline .tool-name { min-width: 58px; }

package/dist/viewer/viewer.js

@@ -78,7 +78,7 @@ function extractSessionMetaCodex(events) {
     for (const d of events) {
         if (d.type !== 'session_meta') continue;
         const p = d.payload || {};
-        meta.model = p.model || p.model_provider || null;
+        meta.model = p.model || null;
         meta.session_id = p.id || null;
         meta.cwd = p.cwd || null;
         meta.environment = {
@@ -89,9 +89,42 @@ function extractSessionMetaCodex(events) {
         };
         break;
     }
+    // session_meta usually carries only model_provider ("openai"); the real model
+    // name lives on the first turn_context.
+    if (!meta.model) {
+        for (const d of events) {
+            if (d.type !== 'turn_context') continue;
+            const p = d.payload || {};
+            if (typeof p.model === 'string' && p.model) { meta.model = p.model; break; }
+        }
+    }
+    if (!meta.model) {
+        for (const d of events) {
+            if (d.type !== 'session_meta') continue;
+            meta.model = (d.payload || {}).model_provider || null;
+            break;
+        }
+    }
     return meta;
 }
 
+function extractResultCodex(events) {
+    let result = null;
+    for (const d of events) {
+        const p = d.payload || {};
+        if (d.type !== 'event_msg' || p.type !== 'task_complete') continue;
+        result = {
+            is_error: false,
+            duration_ms: Number(p.duration_ms) || 0,
+            duration_api_ms: 0,
+            num_turns: null,
+            result_text: String(p.last_agent_message || '').slice(0, 2000),
+            total_cost_usd: null,
+        };
+    }
+    return result;
+}
+
 function extractResultStream(events) {
     for (let i = events.length - 1; i >= 0; i--) {
         const d = events[i];
@@ -192,15 +225,43 @@ function codexContentText(content) {
     return parts.join('\n').trim();
 }
 
+// Codex injects several synthetic "user" turns before the real prompt (plugin
+// catalog, AGENTS.md, environment context). They are transport, not intent —
+// the Claude path skips its own equivalent ("Base directory for this skill:").
+const CODEX_SYNTHETIC_PREFIXES = [
+    '<recommended_plugins>',
+    '<environment_context>',
+    '<INSTRUCTIONS>',
+    '<user_instructions>',
+    '<skills_instructions>',
+    '<permissions instructions>',
+    '# AGENTS.md instructions',
+];
+
+function isCodexSyntheticMessage(text) {
+    const trimmed = String(text || '').replace(/^\s+/, '');
+    if (!trimmed) return true;
+    for (const prefix of CODEX_SYNTHETIC_PREFIXES) {
+        if (trimmed.startsWith(prefix)) return true;
+    }
+    return false;
+}
+
 function extractPromptCodex(events) {
+    // event_msg carries the prompt the user actually typed; response_item
+    // user messages also include the injected preambles, so they are a fallback.
     for (const d of events) {
         const p = d.payload || {};
-        if (d.type === 'event_msg' && p.type === 'user_message' && typeof p.message === 'string') {
+        if (d.type === 'event_msg' && p.type === 'user_message'
+            && typeof p.message === 'string' && !isCodexSyntheticMessage(p.message)) {
             return p.message;
         }
+    }
+    for (const d of events) {
+        const p = d.payload || {};
         if (d.type === 'response_item' && p.type === 'message' && p.role === 'user') {
             const text = codexContentText(p.content);
-            if (text) return text;
+            if (text && !isCodexSyntheticMessage(text)) return text;
         }
     }
     return null;
@@ -476,33 +537,395 @@ function codexToolName(p) {
     return p.name || p.tool_name || p.type || 'tool';
 }
 
-function codexToolCommand(name, input) {
-    const normalized = String(name || '').toLowerCase();
-    if (typeof input.cmd === 'string') return input.cmd;
-    if (typeof input.command === 'string') return input.command;
-    if (typeof input.query === 'string') return input.query;
-    if (typeof input.url === 'string') return input.url;
-    if (typeof input.path === 'string') return input.path;
-    if (typeof input.file_path === 'string') return input.file_path;
-    if (typeof input.arguments === 'string') return input.arguments.slice(0, 120);
-    if (normalized === 'apply patch') return 'apply patch';
-    return JSON.stringify(input).slice(0, 120);
-}
-
 function codexSkillReadName(command) {
-    const match = String(command || '').match(/\/(?:\.agents|\.claude|\.codex)\/skills\/([^/\s'"]+)\/SKILL\.md\b/);
+    // The path is often workspace-relative (".agents/skills/x/SKILL.md"), so do
+    // not require a leading slash.
+    const match = String(command || '')
+        .match(/(?:^|[/\s'"])\.(?:agents|claude|codex)\/skills\/([^/\s'"]+)\/SKILL\.md\b/);
     return match ? match[1] : null;
 }
 
+// ---------------------------------------------------------------------------
+// Codex tool-call normalization
+//
+// Subscription Codex does not send structured tool arguments. It sends a
+// JavaScript snippet that calls tools.exec_command / tools.apply_patch and
+// prints the result, and returns the result as an array of content blocks
+// wrapped in a "Script completed / Wall time / Output:" preamble.
+//
+// Everything below unwraps that into the same {tool, command, input,
+// result_content, is_error} shape buildTimeline() produces for Claude
+// transcripts, so both agents share renderTimeline(), toolCommandSummary(),
+// formatToolInputHtml() and buildFileTouchMap().
+// ---------------------------------------------------------------------------
+
+const CODEX_SHELL_TOOLS = [
+    'exec', 'exec_command', 'execcommand', 'shell', 'bash',
+    'unified_exec', 'local_shell', 'run_command', 'container.exec',
+];
+
+// Walks a JS source string from an opening bracket to its match, respecting
+// string literals and escapes. Returns the index just past the closer, or -1.
+function codexScanBalanced(src, start) {
+    const closers = {'(': ')', '[': ']', '{': '}'};
+    const stack = [];
+    let quote = null;
+    for (let i = start; i < src.length; i++) {
+        const ch = src[i];
+        if (quote) {
+            if (ch === '\\') { i++; continue; }
+            if (ch === quote) quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') { quote = ch; continue; }
+        if (closers[ch]) { stack.push(closers[ch]); continue; }
+        if (ch === ')' || ch === ']' || ch === '}') {
+            if (!stack.length || stack.pop() !== ch) return -1;
+            if (!stack.length) return i + 1;
+        }
+    }
+    return -1;
+}
+
+function codexScanString(src, start) {
+    const quote = src[start];
+    for (let i = start + 1; i < src.length; i++) {
+        if (src[i] === '\\') { i++; continue; }
+        if (src[i] === quote) return i + 1;
+    }
+    return -1;
+}
+
+function codexParseLiteral(text) {
+    const trimmed = String(text || '').trim();
+    if (!trimmed) return null;
+    const first = trimmed[0];
+    if (first === '{' || first === '[' || first === '"') {
+        try { return JSON.parse(trimmed); } catch(e) { /* not a JSON literal */ }
+    }
+    if (first === "'" && trimmed[trimmed.length - 1] === "'") {
+        const body = trimmed.slice(1, -1).replace(/\\'/g, "'").replace(/"/g, '\\"');
+        try { return JSON.parse('"' + body + '"'); } catch(e) { /* not a JS string */ }
+    }
+    return null;
+}
+
+// Codex often binds the patch or args to a const first, then passes the name.
+function codexLocalConstants(src) {
+    const constants = {};
+    const re = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*/g;
+    let match;
+    while ((match = re.exec(src))) {
+        const valueStart = match.index + match[0].length;
+        const ch = src[valueStart];
+        let end = -1;
+        if (ch === '{' || ch === '[') end = codexScanBalanced(src, valueStart);
+        else if (ch === '"' || ch === "'") end = codexScanString(src, valueStart);
+        if (end < 0) continue;
+        const parsed = codexParseLiteral(src.slice(valueStart, end));
+        if (parsed !== null) constants[match[1]] = parsed;
+        re.lastIndex = end;
+    }
+    return constants;
+}
+
+// Spans of string literals in the snippet. A patch payload is itself a string,
+// and the file it writes can contain `tools.execute(...)` in its own source —
+// matching that would invent tool calls the agent never made.
+function codexStringSpans(src) {
+    const spans = [];
+    for (let i = 0; i < src.length; i++) {
+        const ch = src[i];
+        if (ch !== '"' && ch !== "'" && ch !== '`') continue;
+        const end = codexScanString(src, i);
+        if (end < 0) break;
+        spans.push([i, end]);
+        i = end - 1;
+    }
+    return spans;
+}
+
+function parseCodexExecScript(source) {
+    const src = String(source || '');
+    if (src.indexOf('tools.') < 0) return [];
+    const constants = codexLocalConstants(src);
+    const stringSpans = codexStringSpans(src);
+    const insideString = (index) =>
+        stringSpans.some(([start, end]) => index >= start && index < end);
+    const calls = [];
+    const re = /tools\.([A-Za-z_$][\w$]*)\s*\(/g;
+    let match;
+    while ((match = re.exec(src))) {
+        if (insideString(match.index)) continue;
+        const openParen = match.index + match[0].length - 1;
+        const end = codexScanBalanced(src, openParen);
+        if (end < 0) continue;
+        const argText = src.slice(openParen + 1, end - 1).trim();
+        let args = codexParseLiteral(argText);
+        if (args === null && /^[A-Za-z_$][\w$]*$/.test(argText) && Object.prototype.hasOwnProperty.call(constants, argText)) {
+            args = constants[argText];
+        }
+        if (args === null) args = argText ? {source: argText} : {};
+        calls.push({tool: match[1], args});
+        re.lastIndex = end;
+    }
+    return calls;
+}
+
+function codexCommandFromArgs(args) {
+    if (typeof args === 'string') return args;
+    if (!args || typeof args !== 'object') return '';
+    if (typeof args.cmd === 'string') return args.cmd;
+    if (typeof args.command === 'string') return args.command;
+    if (Array.isArray(args.cmd)) return args.cmd.join(' ');
+    if (Array.isArray(args.command)) return args.command.join(' ');
+    if (typeof args.script === 'string') return args.script;
+    return '';
+}
+
+function codexPatchText(args) {
+    if (typeof args === 'string') return args;
+    if (!args || typeof args !== 'object') return '';
+    for (const key of ['patch', 'input', 'source', 'diff', 'content']) {
+        if (typeof args[key] === 'string') return args[key];
+    }
+    return '';
+}
+
+function parseCodexPatch(patchText) {
+    const text = String(patchText || '');
+    const ops = [];
+    if (text.indexOf('***') < 0) return ops;
+    let current = null;
+    const flush = () => { if (current) ops.push(current); current = null; };
+    for (const line of text.split('\n')) {
+        const header = line.match(/^\*\*\* (Add|Update|Delete) File:\s*(.+)$/);
+        if (header) {
+            flush();
+            current = {op: header[1].toLowerCase(), file_path: header[2].trim(), added: [], removed: []};
+            continue;
+        }
+        if (/^\*\*\* (Begin|End) Patch/.test(line)) { flush(); continue; }
+        if (!current) continue;
+        if (line[0] === '+') current.added.push(line.slice(1));
+        else if (line[0] === '-') current.removed.push(line.slice(1));
+    }
+    flush();
+    return ops;
+}
+
+// Maps one codex tool invocation onto one or more Claude-shaped entries.
+// `seenSkills` makes the first read of a skill's SKILL.md the Skill invocation
+// (Claude emits exactly one Skill call per skill); later paged reads of the same
+// file stay Bash, so sequential `sed -n '241,520p'` reads are not mistaken for a
+// retry loop by annotateTimeline().
+function codexToolIdentity(rawName, args, seenSkills) {
+    const name = String(rawName || '').toLowerCase();
+
+    if (CODEX_SHELL_TOOLS.indexOf(name) >= 0) {
+        const command = codexCommandFromArgs(args);
+        if (!command) return [{tool: 'Bash', input: parseCodexArguments(args)}];
+        const skill = codexSkillReadName(command);
+        if (skill && (!seenSkills || !seenSkills.has(skill))) {
+            if (seenSkills) seenSkills.add(skill);
+            return [{tool: 'Skill', input: {skill, command}, command: skill}];
+        }
+        return [{tool: 'Bash', input: {command}}];
+    }
+
+    if (name === 'apply_patch' || name === 'applypatch' || name === 'edit_file') {
+        const ops = parseCodexPatch(codexPatchText(args));
+        if (ops.length) {
+            return ops.map(op => {
+                if (op.op === 'add') {
+                    return {tool: 'Write', input: {file_path: op.file_path, content: op.added.join('\n')}};
+                }
+                if (op.op === 'delete') {
+                    return {tool: 'Delete', input: {file_path: op.file_path}, command: op.file_path};
+                }
+                return {tool: 'Edit', input: {
+                    file_path: op.file_path,
+                    old_string: op.removed.join('\n'),
+                    new_string: op.added.join('\n'),
+                }};
+            });
+        }
+        return [{tool: 'Write', input: parseCodexArguments(args)}];
+    }
+
+    if (name === 'wait') {
+        const input = parseCodexArguments(args);
+        const cell = input.cell_id != null ? String(input.cell_id) : '';
+        return [{tool: 'Wait', input, command: cell ? 'cell ' + cell : 'wait'}];
+    }
+
+    // Feeds keystrokes to a still-running exec cell; the Wait row shows the result.
+    if (name === 'write_stdin' || name === 'writestdin') {
+        const input = parseCodexArguments(args);
+        const cell = input.session_id != null ? String(input.session_id) : '';
+        return [{tool: 'Stdin', input, command: cell ? 'cell ' + cell : 'stdin'}];
+    }
+
+    if (name === 'read_file' || name === 'view_file' || name === 'read') {
+        const input = parseCodexArguments(args);
+        return [{tool: 'Read', input: {file_path: input.file_path || input.path || ''}}];
+    }
+
+    if (name === 'write_file' || name === 'create_file') {
+        const input = parseCodexArguments(args);
+        return [{tool: 'Write', input: {
+            file_path: input.file_path || input.path || '',
+            content: input.content || input.contents || '',
+        }}];
+    }
+
+    // Codex's web tool batches work into one call: `search_query` is a list of
+    // searches, `open` a list of pages. Each becomes its own step, the same way
+    // Claude issues one WebSearch/WebFetch tool_use per query or URL.
+    if (name === 'web__run' || name === 'web_run' || name === 'webrun') {
+        const input = parseCodexArguments(args);
+        const entries = [];
+        for (const item of asArray(input.search_query)) {
+            const query = typeof item === 'string' ? item : (item && (item.q || item.query)) || '';
+            if (query) entries.push({tool: 'WebSearch', input: {query}});
+        }
+        for (const item of asArray(input.open)) {
+            const url = typeof item === 'string' ? item : (item && (item.ref_id || item.url)) || '';
+            if (url) entries.push({tool: 'WebFetch', input: {url}});
+        }
+        if (entries.length) return entries;
+        return [{tool: 'WebSearch', input}];
+    }
+
+    if (name === 'web_search' || name === 'websearch' || name === 'web_search_call') {
+        const input = parseCodexArguments(args);
+        return [{tool: 'WebSearch', input: {query: input.query || input.q || ''}}];
+    }
+
+    if (name === 'tool_search' || name === 'tool_search_call') {
+        const input = parseCodexArguments(args);
+        return [{tool: 'ToolSearch', input: {query: input.query || input.q || ''}}];
+    }
+
+    return [{tool: normalizeStepToolName(rawName), input: parseCodexArguments(args)}];
+}
+
+function codexCallEntries(p, seenSkills) {
+    const rawArgs = p.arguments != null ? p.arguments : p.input;
+
+    // Unwrap the JS wrapper first; it is the only place the real command lives.
+    if (typeof rawArgs === 'string') {
+        const nested = parseCodexExecScript(rawArgs);
+        if (nested.length) {
+            const entries = [];
+            for (const call of nested) {
+                for (const entry of codexToolIdentity(call.tool, call.args, seenSkills)) entries.push(entry);
+            }
+            if (entries.length) return entries;
+        }
+    }
+
+    if (p.type === 'web_search_call' || p.type === 'tool_search_call') {
+        return codexToolIdentity(p.type, rawArgs != null ? rawArgs : (p.action || p.query || {}), seenSkills);
+    }
+    return codexToolIdentity(codexToolName(p), rawArgs, seenSkills);
+}
+
+// A wrapper that fans out with Promise.all prints the outputs joined by a
+// separator of its own choosing, e.g. `.join("\n\n---NEXT---\n\n")`. Recover the
+// separator from the source so each parallel step shows only its own output.
+function codexSplitJoinedOutput(source, text, count) {
+    if (count < 2 || !text) return null;
+    const match = String(source || '').match(/\.join\(\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*\)/);
+    if (!match) return null;
+    const separator = codexParseLiteral(match[1]);
+    if (typeof separator !== 'string' || !separator.trim()) return null;
+    const parts = String(text).split(separator);
+    return parts.length === count ? parts : null;
+}
+
+function codexOutputBlocksText(output) {
+    if (typeof output === 'string') return output;
+    if (!Array.isArray(output)) return '';
+    const parts = [];
+    for (const block of output) {
+        if (typeof block === 'string') { parts.push(block); continue; }
+        if (!block || typeof block !== 'object') continue;
+        if (typeof block.text === 'string') parts.push(block.text);
+        else if (typeof block.output_text === 'string') parts.push(block.output_text);
+        else if (typeof block.content === 'string') parts.push(block.content);
+    }
+    return parts.join('');
+}
+
 function codexToolOutputText(p) {
     if (typeof p.output === 'string') return p.output;
+    if (Array.isArray(p.output)) return codexOutputBlocksText(p.output);
     if (typeof p.content === 'string') return p.content;
+    if (Array.isArray(p.content)) return codexOutputBlocksText(p.content);
     if (typeof p.message === 'string') return p.message;
     if (p.output && typeof p.output === 'object') return JSON.stringify(p.output, null, 2);
     if (p.content && typeof p.content === 'object') return JSON.stringify(p.content, null, 2);
     return '';
 }
 
+// Strips the wrapper's "Script completed / Wall time / Output:" preamble and,
+// when the snippet printed JSON.stringify({exit_code, output}), unwraps that too.
+function normalizeCodexOutput(rawText) {
+    let text = String(rawText || '');
+    let pending = false;
+    let wallS = null;
+    let exitCode = null;
+
+    const preamble = text.match(/^Script (completed|running with cell ID [^\n]*)\n(?:Wall time ([\d.]+) seconds\n)?Output:\n?/);
+    if (preamble) {
+        pending = preamble[1] !== 'completed';
+        wallS = preamble[2] ? Number(preamble[2]) : null;
+        text = text.slice(preamble[0].length);
+    }
+
+    const trimmed = text.trim();
+    if (trimmed.startsWith('{') && trimmed.indexOf('"exit_code"') >= 0) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && parsed.exit_code != null) {
+                exitCode = Number(parsed.exit_code);
+                text = typeof parsed.output === 'string' ? parsed.output : JSON.stringify(parsed, null, 2);
+            }
+        } catch(e) { /* not the wrapper's JSON envelope */ }
+    }
+
+    if (pending) {
+        const note = '(backgrounded' + (wallS != null ? ' after ' + wallS + 's' : '')
+            + ' — output arrives with the following Wait call)';
+        text = text.trim() ? note + '\n\n' + text : note;
+    }
+    return {text, pending, wall_s: wallS, exit_code: exitCode};
+}
+
+// Same markers scripts/eval-extract-metrics.py uses: the wrapper always reports
+// "Script completed", so failure has to be read out of the command output.
+function codexTextIndicatesFailure(text) {
+    const s = String(text || '');
+    const exited = s.match(/Process exited with code\s+(\d+)/);
+    if (exited) return Number(exited[1]) !== 0;
+    const exitCode = s.match(/^\s*exit_code:\s*(\d+)/m);
+    if (exitCode) return Number(exitCode[1]) !== 0;
+    if (/^Error:/m.test(s)) return true;
+    return false;
+}
+
+function codexOutputResult(p) {
+    const normalized = normalizeCodexOutput(codexToolOutputText(p));
+    let isError;
+    if (p.is_error === true || p.status === 'error' || p.status === 'failed') isError = true;
+    else if (normalized.exit_code != null) isError = normalized.exit_code !== 0;
+    else if (normalized.pending) isError = null;
+    else if (codexTextIndicatesFailure(normalized.text)) isError = true;
+    else isError = false;
+    return {text: normalized.text, is_error: isError};
+}
+
 function buildCodexTimeline(events, firstTs) {
     const outputsByCallId = {};
     const hasEventUserMessages = events.some(d => {
@@ -519,12 +942,25 @@ function buildCodexTimeline(events, firstTs) {
         if (p.type !== 'function_call_output' && p.type !== 'custom_tool_call_output' && p.type !== 'tool_search_output') continue;
         const callId = p.call_id || p.id || '';
         if (!callId) continue;
-        outputsByCallId[callId] = {
-            text: codexToolOutputText(p),
-            is_error: p.is_error === true || p.status === 'error' || p.status === 'failed',
-        };
+        outputsByCallId[callId] = codexOutputResult(p);
     }
 
+    // patch_apply_end carries the authoritative result of an apply_patch, but its
+    // call_id ("exec-<uuid>") does not match the originating call ("call_<id>"),
+    // so it is consumed in document order instead.
+    const patchResults = [];
+    for (const d of events) {
+        const p = d.payload || {};
+        if (d.type === 'event_msg' && p.type === 'patch_apply_end') {
+            patchResults.push({
+                text: String(p.stdout || '') + (p.stderr ? '\n' + p.stderr : ''),
+                is_error: p.success === false,
+            });
+        }
+    }
+    let patchResultIndex = 0;
+    const seenSkills = new Set();
+
     const timeline = [];
     let step = 0;
     let eventIndex = 0;
@@ -549,7 +985,9 @@ function buildCodexTimeline(events, firstTs) {
             if (p.role === 'user') {
                 if (hasEventUserMessages) continue;
                 const text = codexContentText(p.content);
-                if (text) timeline.push({kind: 'user_message', text, event_index: eventIndex, elapsed});
+                if (text && !isCodexSyntheticMessage(text)) {
+                    timeline.push({kind: 'user_message', text, event_index: eventIndex, elapsed});
+                }
             } else if (p.role === 'assistant') {
                 if (hasEventAgentMessages) continue;
                 const text = codexContentText(p.content);
@@ -572,31 +1010,44 @@ function buildCodexTimeline(events, firstTs) {
             || p.type === 'web_search_call';
         if (!isToolCall) continue;
 
-        step++;
-        const input = parseCodexArguments(p.arguments || p.input);
         const callId = p.call_id || p.id || '';
         const output = outputsByCallId[callId] || null;
-        let tool = normalizeStepToolName(codexToolName(p));
-        let command = codexToolCommand(tool, input);
-        const skillName = codexSkillReadName(command);
-        if (skillName) {
-            tool = 'Skill';
-            command = skillName;
-            input.skill = skillName;
-            input.command = input.command || input.cmd || command;
+        const entries = codexCallEntries(p, seenSkills);
+
+        // One record can carry several commands (Promise.all of exec_command, or a
+        // multi-file patch). Each becomes its own step flagged `parallel`, mirroring
+        // how buildTimeline() expands multiple tool_use blocks from one Claude
+        // assistant message. scripts/eval-extract-metrics.py still counts one call
+        // per record, so the viewer's tool-call total can legitimately exceed the
+        // tool_calls value in results.jsonl. Do not "reconcile" one to the other.
+        const parallel = entries.length > 1;
+        const rawArgs = p.arguments != null ? p.arguments : p.input;
+        const splitOutputs = output
+            ? codexSplitJoinedOutput(rawArgs, output.text, entries.length)
+            : null;
+
+        for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
+            const entry = entries[entryIndex];
+            step++;
+            const isPatch = entry.tool === 'Write' || entry.tool === 'Edit' || entry.tool === 'Delete';
+            const patchResult = isPatch && patchResultIndex < patchResults.length
+                ? patchResults[patchResultIndex++]
+                : null;
+            const resolved = patchResult
+                || (splitOutputs ? {text: splitOutputs[entryIndex], is_error: output.is_error} : output);
+            timeline.push({
+                kind: 'tool_call',
+                step,
+                tool: entry.tool,
+                command: entry.command != null ? entry.command : toolCommandSummary(entry.tool, entry.input),
+                input: entry.input,
+                result_content: resolved ? resolved.text : null,
+                is_error: resolved ? resolved.is_error : null,
+                parallel,
+                event_index: eventIndex,
+                elapsed,
+            });
         }
-        timeline.push({
-            kind: 'tool_call',
-            step,
-            tool,
-            command,
-            input,
-            result_content: output ? output.text : null,
-            is_error: output ? output.is_error : null,
-            parallel: false,
-            event_index: eventIndex,
-            elapsed,
-        });
     }
     return timeline;
 }
@@ -831,7 +1282,7 @@ function processRawSession(raw) {
     } else if (isCodex) {
         processedEvents = events;
         meta = extractSessionMetaCodex(events);
-        result = null;
+        result = extractResultCodex(events);
         const [dur, fts] = computeCodexDuration(events);
         totalDurationS = Math.round(dur * 10) / 10;
         firstTs = fts;
@@ -1346,7 +1797,10 @@ function renderExpectationMiniTable(session) {
     const rows = expectations.map(item => {
         const result = String(item.result || '—').toUpperCase();
         const resultClass = result === 'PASS' ? 'pass' : (result === 'FAIL' ? 'fail' : 'unknown');
-        return `<tr title="${esc(item.reason || '')}"><td>${esc(item.expectation || '—')}</td><td>${esc(item.category || 'other')}</td><td><span class="expectation-result ${resultClass}">${esc(result)}</span></td></tr>`;
+        const reason = result === 'FAIL' && item.reason
+            ? `<div class="expectation-failure-reason">${esc(item.reason)}</div>`
+            : '';
+        return `<tr><td>${esc(item.expectation || '—')}${reason}</td><td>${esc(item.category || 'other')}</td><td><span class="expectation-result ${resultClass}">${esc(result)}</span></td></tr>`;
     }).join('');
     return `<div class="expectations-mini ${statusClass}">
         <div class="expectations-mini-heading"><span>Eval results</span><strong>${passed}/${total} passed</strong></div>
@@ -1370,6 +1824,51 @@ function renderInfraSignals(metric) {
     return `<div class="infra-signals"><div class="infra-signals-heading">Infrastructure signals</div><ul>${rows}</ul></div>`;
 }
 
+function formatFileSize(bytes) {
+    const value = Number(bytes || 0);
+    if (value < 1024) return value + ' B';
+    if (value < 1024 * 1024) return (value / 1024).toFixed(1) + ' KB';
+    return (value / (1024 * 1024)).toFixed(1) + ' MB';
+}
+
+function artifactDisplayContent(artifact) {
+    const content = typeof artifact.content === 'string' ? artifact.content : null;
+    if (content == null) return null;
+    const language = String(artifact.language || '').toLowerCase();
+    try {
+        if (language === 'json') return JSON.stringify(JSON.parse(content), null, 2);
+        if (language === 'jsonl') {
+            return content.split('\n').filter(line => line.trim()).map(line => JSON.stringify(JSON.parse(line), null, 2)).join('\n');
+        }
+    } catch (_) {
+        return content;
+    }
+    return content;
+}
+
+function renderFinalArtifacts(session) {
+    const metric = session.evalMetric || {};
+    const artifacts = Array.isArray(metric.final_artifacts) ? metric.final_artifacts : [];
+    if (!artifacts.length) return '';
+    const files = artifacts.map((artifact, index) => {
+        const content = artifactDisplayContent(artifact);
+        const digest = String(artifact.sha256 || '');
+        const formatted = content != null && ['json', 'jsonl'].includes(String(artifact.language || '').toLowerCase());
+        const omission = artifact.content_omitted_reason
+            ? `<div class="final-artifact-omitted">Content not embedded: ${esc(artifact.content_omitted_reason)}</div>`
+            : '';
+        return `<details class="final-artifact-file" ${index === 0 ? 'open' : ''}>
+            <summary><strong>${esc(artifact.path || 'artifact')}</strong><span>${esc(formatFileSize(artifact.size_bytes))}</span></summary>
+            <div class="final-artifact-meta">SHA-256 <code>${esc(digest)}</code>${formatted ? '<span>JSON formatted for display</span>' : ''}</div>
+            ${content != null ? `<pre><code class="language-${esc(artifact.language || 'text')}">${esc(content)}</code></pre>` : omission}
+        </details>`;
+    }).join('');
+    return `<section class="final-artifacts">
+        <div class="final-artifacts-heading"><div><span>Final files</span><strong>${artifacts.length}</strong></div><p>Captured from the run directory after the agent exited.</p></div>
+        ${files}
+    </section>`;
+}
+
 function renderLaneSession(session) {
     const i = session.sourceIndex;
     const d = session.dimensions;
@@ -1397,6 +1896,7 @@ function renderLaneSession(session) {
     if (session.result && session.result.result_text) {
         html += `<details class="lane-result"><summary>Final output</summary><div class="md-rendered">${renderMarkdown(session.result.result_text)}</div></details>`;
     }
+    html += renderFinalArtifacts(session);
     return html + '</article>';
 }
 
@@ -1576,6 +2076,8 @@ function renderSession(i) {
         </div>`;
     }
 
+    html += renderFinalArtifacts(s);
+
     main.innerHTML = html;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.2.51",
+  "version": "0.2.53",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {