@myagentroam/node 0.11.1 → 0.11.3

package/dist/connector.js

@@ -1343,7 +1343,7 @@ export class NodeConnector {
             this.workspaceCoordinator.clearWatches(workspaceId);
             this.workspaceWorkbenchService.clearWorkspace(workspaceId);
             this.promptCompletion?.invalidateWorkspace(workspaceId);
-        });
+        }, (workspaceId) => this.workspaceCoordinator.gitPolicyChanged(workspaceId));
         this.workspaceWorkbenchService = new WorkspaceWorkbenchService({
             requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
             inspectWorkspace: (workspace) => this.workspaceCoordinator.inspectMetadata(workspace),

package/dist/database.js

@@ -2,6 +2,7 @@ import { NODE_SCHEMA_MIGRATION_V17 } from './migrations/v017.js';
 import { NODE_SCHEMA_MIGRATION_V18 } from './migrations/v018.js';
 import { NODE_SCHEMA_MIGRATION_V19 } from './migrations/v019.js';
 import { NODE_SCHEMA_MIGRATION_V20 } from './migrations/v020.js';
+import { NODE_SCHEMA_MIGRATION_V21 } from './migrations/v021.js';
 import { normalizeSessionPrompt } from './util/personal-instructions.js';
 import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
@@ -23,7 +24,8 @@ export const NODE_SCHEMA_MIGRATIONS = [
     NODE_SCHEMA_MIGRATION_V17,
     NODE_SCHEMA_MIGRATION_V18,
     NODE_SCHEMA_MIGRATION_V19,
-    NODE_SCHEMA_MIGRATION_V20
+    NODE_SCHEMA_MIGRATION_V20,
+    NODE_SCHEMA_MIGRATION_V21
 ];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 const OBSOLETE_NODE_SCHEMA_V16 = 16;
@@ -71,27 +73,22 @@ export class NodeDatabase {
         this.raw.close();
     }
     getRunnerDefaults() {
-        const rows = this.raw
-            .prepare('SELECT runner, model, effort, access FROM runner_defaults ORDER BY runner')
-            .all();
-        return rows.flatMap((row) => {
-            const parsed = runnerDefaultConfigurationSchema.safeParse({
-                runner: stringValue(row, 'runner'),
-                model: stringValue(row, 'model'),
-                effort: stringValue(row, 'effort'),
-                access: stringValue(row, 'access')
-            });
+        return Object.entries(this.getNodeSettings().runnerDefaults ?? {})
+            .sort(([a], [b]) => a.localeCompare(b))
+            .flatMap(([runner, settings]) => {
+            const parsed = runnerDefaultConfigurationSchema.safeParse({ runner, ...settings });
             return parsed.success ? [parsed.data] : [];
         });
     }
+    getNodeSettings() {
+        const row = this.raw.prepare('SELECT settings FROM node_settings WHERE id = 1').get();
+        return JSON.parse(stringValue(row, 'settings'));
+    }
     saveRunnerDefaults(input) {
+        const { runner, ...settings } = runnerDefaultConfigurationSchema.parse(input);
         this.raw
-            .prepare(`INSERT INTO runner_defaults (runner, model, effort, access)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(runner) DO UPDATE SET
-           model = excluded.model, effort = excluded.effort,
-           access = excluded.access`)
-            .run(input.runner, input.model, input.effort, input.access);
+            .prepare(`UPDATE node_settings SET settings = json_patch(settings, ?) WHERE id = 1`)
+            .run(JSON.stringify({ runnerDefaults: { [runner]: settings } }));
         return input;
     }
     listMcpInstallations(targetKind, targetId = '') {
@@ -188,45 +185,64 @@ export class NodeDatabase {
     }
     saveWorkspace(input) {
         const current = this.raw
-            .prepare('SELECT id, preserve_git_config FROM workspaces WHERE path = ?')
+            .prepare('SELECT id, settings FROM workspaces WHERE path = ?')
             .get(input.path);
+        const settings = current === undefined
+            ? {
+                git: {
+                    preserveGitConfig: input.preserveGitConfig ?? false,
+                    includeParentRepository: input.includeParentRepository ?? true
+                }
+            }
+            : JSON.parse(stringValue(current, 'settings'));
         const workspace = {
             id: current === undefined ? (input.id ?? randomUUID()) : stringValue(current, 'id'),
             path: input.path,
             kind: input.kind,
             gitSummary: input.gitSummary,
-            preserveGitConfig: current === undefined
-                ? (input.preserveGitConfig ?? false)
-                : Number(current.preserve_git_config) === 1
+            settings,
+            includeParentRepository: settings.git?.includeParentRepository ?? true,
+            preserveGitConfig: settings.git?.preserveGitConfig ?? false
         };
         const timestamp = this.now();
         this.raw
-            .prepare(`INSERT INTO workspaces (id, path, kind, git_summary, created_at, updated_at, preserve_git_config)
+            .prepare(`INSERT INTO workspaces (id, path, kind, git_summary, created_at, updated_at, settings)
          VALUES (?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(path) DO UPDATE SET kind = excluded.kind,
            git_summary = excluded.git_summary, updated_at = excluded.updated_at`)
-            .run(workspace.id, workspace.path, workspace.kind, workspace.gitSummary === null ? null : JSON.stringify(workspace.gitSummary), timestamp, timestamp, workspace.preserveGitConfig ? 1 : 0);
+            .run(workspace.id, workspace.path, workspace.kind, workspace.gitSummary === null ? null : JSON.stringify(workspace.gitSummary), timestamp, timestamp, JSON.stringify(settings));
         return workspace;
     }
     listWorkspaces() {
         return this.raw
-            .prepare('SELECT id, path, kind, git_summary, preserve_git_config FROM workspaces ORDER BY created_at ASC')
+            .prepare('SELECT id, path, kind, git_summary, settings FROM workspaces ORDER BY created_at ASC')
             .all()
             .map((row) => workspace(row));
     }
     getWorkspace(id) {
         const row = this.raw
-            .prepare('SELECT id, path, kind, git_summary, preserve_git_config FROM workspaces WHERE id = ?')
+            .prepare('SELECT id, path, kind, git_summary, settings FROM workspaces WHERE id = ?')
             .get(id);
         return row === undefined ? undefined : workspace(row);
     }
-    /** Unregisters a Workspace registration without deleting its local directory. */
-    setWorkspaceGitPolicy(id, preserveGitConfig) {
+    getWorkspaceByPath(path) {
+        const row = this.raw
+            .prepare('SELECT id, path, kind, git_summary, settings FROM workspaces WHERE path = ?')
+            .get(path);
+        return row === undefined ? undefined : workspace(row);
+    }
+    /** Updates only supplied policy fields without replacing Workspace metadata. */
+    setWorkspaceGitPolicy(id, preserveGitConfig, includeParentRepository) {
         if (this.getWorkspace(id) === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
         this.raw
-            .prepare('UPDATE workspaces SET preserve_git_config=?, updated_at=? WHERE id=?')
-            .run(preserveGitConfig ? 1 : 0, this.now(), id);
+            .prepare('UPDATE workspaces SET settings=json_patch(settings, ?), updated_at=? WHERE id=?')
+            .run(JSON.stringify({
+            git: {
+                preserveGitConfig,
+                ...(includeParentRepository === undefined ? {} : { includeParentRepository })
+            }
+        }), this.now(), id);
         return this.getWorkspace(id);
     }
     /** Unregisters a Workspace registration without deleting its local directory. */
@@ -474,7 +490,10 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
         throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
     if (migratedVersions.some((version, index) => version !== NODE_SCHEMA_VERSION_V13 + index))
         throw new Error('NODE_DATABASE_MIGRATION_HISTORY_INVALID');
-    assertNodeSchemaV13(database);
+    if (current < NODE_SCHEMA_MIGRATION_V21.version)
+        assertNodeSchemaV13(database);
+    else
+        catalog[current - NODE_SCHEMA_VERSION_V13 - 1].assert(database);
     for (const entry of catalog) {
         if (entry.version <= current)
             continue;
@@ -623,9 +642,12 @@ function acquireNodeMigrationLock(databasePath) {
 }
 function workspace(row) {
     const summary = nullableString(row, 'git_summary');
+    const settings = JSON.parse(stringValue(row, 'settings'));
     return {
         id: stringValue(row, 'id'),
-        preserveGitConfig: Number(row.preserve_git_config) === 1,
+        settings,
+        preserveGitConfig: settings.git?.preserveGitConfig ?? false,
+        includeParentRepository: settings.git?.includeParentRepository ?? true,
         path: stringValue(row, 'path'),
         kind: stringValue(row, 'kind'),
         gitSummary: summary === null ? null : JSON.parse(summary)

package/dist/migrations/v021.js

@@ -0,0 +1,64 @@
+import { DatabaseSync } from 'node:sqlite';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './v016.js';
+import { NODE_SCHEMA_MIGRATION_V17 } from './v017.js';
+import { NODE_SCHEMA_MIGRATION_V18 } from './v018.js';
+import { NODE_SCHEMA_MIGRATION_V19 } from './v019.js';
+import { NODE_SCHEMA_MIGRATION_V20 } from './v020.js';
+const sql = `ALTER TABLE workspaces ADD COLUMN settings TEXT NOT NULL DEFAULT '{}'
+  CHECK (json_valid(settings) AND json_type(settings) = 'object');
+UPDATE workspaces SET settings = json_object('git', json_object(
+  'preserveGitConfig', json(CASE WHEN preserve_git_config = 1 THEN 'true' ELSE 'false' END),
+  'includeParentRepository', json('true')));
+ALTER TABLE workspaces DROP COLUMN preserve_git_config;
+CREATE TABLE node_settings (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  settings TEXT NOT NULL CHECK (json_valid(settings) AND json_type(settings) = 'object')
+) STRICT;
+INSERT INTO node_settings (id, settings)
+SELECT 1, json_object('runnerDefaults', json_group_object(runner,
+  json_object('model', model, 'effort', effort, 'access', access))) FROM runner_defaults;
+DROP TABLE runner_defaults;`;
+export const NODE_SCHEMA_MIGRATION_V21 = {
+    version: 21,
+    sql,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V20.assert(database),
+    assert(database) {
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            for (const migration of [
+                NODE_SCHEMA_MIGRATION_V14,
+                NODE_SCHEMA_MIGRATION_V15,
+                NODE_SCHEMA_MIGRATION_V16,
+                NODE_SCHEMA_MIGRATION_V17,
+                NODE_SCHEMA_MIGRATION_V18,
+                NODE_SCHEMA_MIGRATION_V19,
+                NODE_SCHEMA_MIGRATION_V20
+            ])
+                reference.exec(migration.sql);
+            reference.exec(sql);
+            const schema = (db) => db
+                .prepare("SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name")
+                .all()
+                .map((row) => [
+                row.type,
+                row.name,
+                row.name === 'node_schema_migrations'
+                    ? String(row.sql).replace(/\s+/g, '')
+                    : String(row.sql).replace(/\s+/g, ' ').trim()
+            ]);
+            const expected = schema(reference);
+            const actual = schema(database);
+            const mismatch = expected.find((row) => !actual.some((value) => JSON.stringify(value) === JSON.stringify(row))) ??
+                actual.find((row) => !expected.some((value) => JSON.stringify(value) === JSON.stringify(row)));
+            if (mismatch !== undefined)
+                throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${String(mismatch[1])}`);
+        }
+        finally {
+            reference.close();
+        }
+    }
+};

package/dist/native-session-history.js

@@ -7,6 +7,8 @@ import { nodeLog } from './operational.js';
 import { stripClaudePlanTag } from './runner-command-engine.js';
 import { stripGoalStartPrompt } from './service/goal-runtime.js';
 import { parseCodexComposerImageMarkers } from './runner/codex/composer-image-markers.js';
+import { codexTranscriptSourceItemId } from './runner/codex/conversation-parser.js';
+import { claudeAssistantBlocks, extractClaudeThinkingText } from './runner/claude/conversation-parser.js';
 import { extractClaudeToolResults } from './runner/claude/tool-normalizer.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
@@ -477,9 +479,11 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
         const generatedImage = codexGeneratedImageEvent(value);
         if (generatedImage !== undefined)
             items.push(generatedImage);
+        const sourceItemId = runner === 'codex' ? codexTranscriptSourceItemId(value, codexTurnId) : undefined;
         for (const parsedItem of transcriptItems(runner, value)) {
             const item = {
                 ...parsedItem,
+                ...(sourceItemId === undefined ? {} : { sourceItemId }),
                 ...(recordId === undefined ? {} : { nativeId: recordId }),
                 ...(runner === 'codex' &&
                     parsedItem.kind === 'message' &&
@@ -615,6 +619,32 @@ function positiveInteger(value) {
     return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 function transcriptItems(runner, record) {
+    if (runner === 'claude-code' && record.type === 'assistant') {
+        return claudeAssistantBlocks(record).flatMap(({ record: blockRecord, blockIndex, sourceItemId }) => {
+            const block = contentBlocks(blockRecord)[0];
+            if (block?.type === 'thinking') {
+                const text = extractClaudeThinkingText(blockRecord)[0] ?? '';
+                return text.length === 0
+                    ? []
+                    : [
+                        {
+                            kind: 'reasoning_summary',
+                            representation: 'visible_thinking',
+                            sections: [{ index: blockIndex, text }],
+                            createdAt: timestampOf(record),
+                            ...(sourceItemId === undefined ? {} : { sourceItemId })
+                        }
+                    ];
+            }
+            return transcriptRecordItems(runner, blockRecord).map((item) => ({
+                ...item,
+                ...(sourceItemId === undefined ? {} : { sourceItemId })
+            }));
+        });
+    }
+    return transcriptRecordItems(runner, record);
+}
+function transcriptRecordItems(runner, record) {
     const createdAt = timestampOf(record);
     const results = [...toolResultsOf(record, createdAt), ...codexToolResultsOf(record, createdAt)];
     if (results.length > 0)
@@ -689,7 +719,7 @@ function codexReasoningSummariesOf(record, createdAt) {
             return text.length === 0 ? [] : [{ index, text }];
         })
         : [];
-    return [{ kind: 'reasoning_summary', sections, createdAt }];
+    return [{ kind: 'reasoning_summary', representation: 'summary', sections, createdAt }];
 }
 function unsupportedTranscriptItems(record, createdAt) {
     return contentBlocks(record).flatMap((block) => {

package/dist/runner/claude/conversation-parser.js

@@ -0,0 +1,42 @@
+import { boundedConversationItemId, isPlainRecord, claudeContentBlocks, compactRunnerText } from '../../util/node-operation-parsers.js';
+export function extractClaudeThinkingText(record) {
+    return claudeContentBlocks(record).flatMap((block) => {
+        // Completed public blocks only; signatures and redacted/encrypted data are never read.
+        if (block.type !== 'thinking' || typeof block.thinking !== 'string')
+            return [];
+        const text = compactRunnerText(block.thinking.trim(), 10_000);
+        return text.length === 0 ? [] : [text];
+    });
+}
+/** Preserve native block order and identity across SDK callbacks and transcript reads. */
+export function claudeAssistantBlocks(record) {
+    const message = isPlainRecord(record.message) ? record.message : undefined;
+    if (message === undefined)
+        return [];
+    const content = typeof message.content === 'string'
+        ? [{ type: 'text', text: message.content }]
+        : Array.isArray(message.content)
+            ? message.content
+            : [];
+    const messageId = typeof record.uuid === 'string'
+        ? record.uuid
+        : typeof message.id === 'string'
+            ? message.id
+            : undefined;
+    return content.flatMap((block, blockIndex) => {
+        if (!isPlainRecord(block))
+            return [];
+        const sourceItemId = block.type === 'tool_use' && typeof block.id === 'string'
+            ? boundedConversationItemId('claude-tool', block.id)
+            : messageId === undefined
+                ? undefined
+                : JSON.stringify(['claude', messageId, blockIndex]);
+        return [
+            {
+                record: { ...record, message: { ...message, content: [block] } },
+                blockIndex,
+                ...(sourceItemId === undefined ? {} : { sourceItemId })
+            }
+        ];
+    });
+}

package/dist/runner/claude/managed-run-controller.js

@@ -1,8 +1,9 @@
+import { claudeAssistantBlocks, extractClaudeThinkingText } from './conversation-parser.js';
 import { ClaudeUsageNormalizer } from './tool-normalizer.js';
 import { createEnvelope } from '@myagentroam/protocol';
 import { ClaudeChannelGate } from '../../claude-channel.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
-import { boundedConversationItemId, claudePlanText, compactRunnerText, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolUses } from '../codex/conversation-parser.js';
+import { boundedConversationItemId, claudePlanText, compactRunnerText, extractClaudeText, extractClaudeToolUses } from '../codex/conversation-parser.js';
 import { normalizeClaudeTool, extractClaudeToolResults } from './tool-normalizer.js';
 import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
@@ -344,67 +345,84 @@ export class ClaudeManagedRunController {
                             finalOutputTokens.set(snapshotId, snapshotUsage.output_tokens);
                             settleGeneration(snapshotId, receiptAt);
                         }
-                        const text = extractClaudeText(record);
-                        if (mainTask && (text.length > 0 || extractClaudeThinkingSummaries(record).length > 0))
-                            observeResponse(typeof record.message?.id === 'string'
-                                ? record.message.id
-                                : undefined);
-                        const planText = claudePlanText(text);
-                        if (planText !== undefined)
-                            this.host.emitItem(runId, {
-                                itemId: boundedConversationItemId('claude-plan', typeof record.uuid === 'string' ? record.uuid : `${runId}:plan`),
-                                kind: 'plan',
-                                status: 'COMPLETED',
-                                payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
-                            });
-                        else if (text.length > 0)
-                            this.host.emit(runId, 'text.delta', { text });
-                        for (const [index, text] of extractClaudeThinkingSummaries(record).entries()) {
-                            this.host.emitItem(runId, {
-                                itemId: boundedConversationItemId('claude-reasoning', `${typeof record.uuid === 'string' ? record.uuid : runId}:${index}`),
-                                kind: 'reasoning_summary',
-                                status: 'COMPLETED',
-                                payload: { sections: [{ index, text }] }
-                            });
-                        }
-                        for (const tool of extractClaudeToolUses(record)) {
-                            const latencyMs = mainTask ? responseLatency.toolStarted(tool.id) : undefined;
-                            if (latencyMs !== undefined)
-                                this.host.emit(runId, 'run.performance', { latencyMs });
-                            if (tool.name === 'AskUserQuestion') {
-                                toolKinds.set(tool.id, 'user_input_request');
-                                continue;
+                        const fallbackMessageId = crypto.randomUUID();
+                        for (const { record: blockRecord, blockIndex, sourceItemId } of claudeAssistantBlocks(record)) {
+                            const text = extractClaudeText(blockRecord);
+                            if (mainTask &&
+                                (text.length > 0 || extractClaudeThinkingText(blockRecord).length > 0))
+                                observeResponse(typeof record.message?.id === 'string'
+                                    ? record.message.id
+                                    : undefined);
+                            const planText = claudePlanText(text);
+                            if (planText !== undefined)
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-plan', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'plan',
+                                    status: 'COMPLETED',
+                                    payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
+                                });
+                            else if (text.length > 0)
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-text', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'assistant_message',
+                                    status: 'COMPLETED',
+                                    payload: { text, format: 'markdown', model: null }
+                                });
+                            for (const text of extractClaudeThinkingText(blockRecord)) {
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-reasoning', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'reasoning',
+                                    status: 'COMPLETED',
+                                    payload: {
+                                        representation: 'visible_thinking',
+                                        sections: [{ index: blockIndex, text }]
+                                    }
+                                });
                             }
-                            const itemId = boundedConversationItemId('claude-tool', tool.id);
-                            toolInputs.set(tool.id, tool);
-                            const normalized = normalizeClaudeTool(tool.name, tool.input, null, false, tool.inputTruncated, knownSubagents);
-                            const kind = normalized.kind;
-                            toolKinds.set(tool.id, kind);
-                            this.host.emitItem(runId, {
-                                itemId,
-                                kind,
-                                status: 'IN_PROGRESS',
-                                payload: normalized.payload
-                            });
-                        }
-                        for (const [index, block] of claudeContentBlocks(record).entries()) {
-                            const type = typeof block.type === 'string' ? block.type : 'unknown';
-                            if (type === 'text' ||
-                                type === 'thinking' ||
-                                type === 'redacted_thinking' ||
-                                type === 'encrypted_thinking' ||
-                                type === 'tool_use' ||
-                                type === 'tool_result')
-                                continue;
-                            this.host.emitItem(runId, {
-                                itemId: boundedConversationItemId('claude-item', `${typeof record.uuid === 'string' ? record.uuid : runId}:${index}`),
-                                kind: 'unknown',
-                                status: 'COMPLETED',
-                                payload: {
-                                    sourceEventType: `claude-code:${type}`,
-                                    label: `Claude Code ${compactRunnerText(type, 128)}`
+                            for (const tool of extractClaudeToolUses(blockRecord)) {
+                                const latencyMs = mainTask ? responseLatency.toolStarted(tool.id) : undefined;
+                                if (latencyMs !== undefined)
+                                    this.host.emit(runId, 'run.performance', { latencyMs });
+                                if (tool.name === 'AskUserQuestion') {
+                                    toolKinds.set(tool.id, 'user_input_request');
+                                    continue;
                                 }
-                            });
+                                const itemId = boundedConversationItemId('claude-tool', tool.id);
+                                toolInputs.set(tool.id, tool);
+                                const normalized = normalizeClaudeTool(tool.name, tool.input, null, false, tool.inputTruncated, knownSubagents);
+                                const kind = normalized.kind;
+                                toolKinds.set(tool.id, kind);
+                                this.host.emitItem(runId, {
+                                    itemId,
+                                    sourceItemId: itemId,
+                                    kind,
+                                    status: 'IN_PROGRESS',
+                                    payload: normalized.payload
+                                });
+                            }
+                            for (const block of claudeContentBlocks(blockRecord)) {
+                                const type = typeof block.type === 'string' ? block.type : 'unknown';
+                                if (type === 'text' ||
+                                    type === 'thinking' ||
+                                    type === 'redacted_thinking' ||
+                                    type === 'encrypted_thinking' ||
+                                    type === 'tool_use' ||
+                                    type === 'tool_result')
+                                    continue;
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-item', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'unknown',
+                                    status: 'COMPLETED',
+                                    payload: {
+                                        sourceEventType: `claude-code:${type}`,
+                                        label: `Claude Code ${compactRunnerText(type, 128)}`
+                                    }
+                                });
+                            }
                         }
                     }
                     if (record.type === 'tool_progress' && typeof record.tool_use_id === 'string') {

package/dist/runner/claude/tool-normalizer.js

@@ -135,6 +135,16 @@ export function normalizeClaudeTool(toolName, input, output, failed, truncated,
             progressLabel: null,
             errorCode: failed ? 'TOOL_EXECUTION_FAILED' : null,
             truncated: outputTruncated,
+            ...(toolName === 'Read'
+                ? {
+                    toolPresentation: {
+                        kind: 'READ',
+                        paths: typeof values?.file_path === 'string' && values.file_path.length > 0
+                            ? [compactRunnerText(values.file_path, 4096)]
+                            : []
+                    }
+                }
+                : {}),
             ...subagent
         }
     };

package/dist/runner/codex/conversation-parser.js

@@ -629,6 +629,20 @@ export function codexPlanText(value) {
  * A final Claude tagged Plan Mode plan is fully wrapped in `<proposed_plan>` tags;
  * text with missing or unclosed tags remains a regular assistant message.
  */
+export function codexSourceItemId(nativeTurnId, itemId) {
+    return JSON.stringify([nativeTurnId, itemId]);
+}
+export function codexTranscriptSourceItemId(record, nativeTurnId) {
+    if (nativeTurnId === undefined ||
+        record.type !== 'response_item' ||
+        !isPlainRecord(record.payload))
+        return undefined;
+    const payload = record.payload;
+    const id = typeof payload.call_id === 'string' ? payload.call_id : payload.id;
+    return typeof id === 'string'
+        ? codexSourceItemId(nativeTurnId, boundedConversationItemId('codex', id))
+        : undefined;
+}
 export function codexOfficialItem(session, nativeTurnId, value, turnSequence, itemSequence, startedAt, completedAt) {
     if (!isPlainRecord(value) || typeof value.type !== 'string' || value.type === 'subAgentActivity')
         return undefined;
@@ -645,6 +659,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                 : `${nativeTurnId}:${itemSequence}`;
     const base = {
         id: `${session.id}:official:${nativeTurnId}:${id}`,
+        sourceItemId: codexSourceItemId(nativeTurnId, boundedConversationItemId('codex', id)),
         sessionId: session.id,
         turnId: `${session.id}:official:${nativeTurnId}`,
         runId: null,
@@ -689,7 +704,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                 ? [{ index, text: compactRunnerText(text, 10_000) }]
                 : [])
             : [];
-        return { ...base, kind: 'reasoning_summary', payload: { sections } };
+        return { ...base, kind: 'reasoning', payload: { representation: 'summary', sections } };
     }
     if (value.type === 'commandExecution') {
         const output = typeof value.aggregatedOutput === 'string' ? value.aggregatedOutput : '';
@@ -835,9 +850,9 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             : [];
         return {
             itemId,
-            kind: 'reasoning_summary',
+            kind: 'reasoning',
             status: completed ? 'COMPLETED' : 'IN_PROGRESS',
-            payload: { sections }
+            payload: { representation: 'summary', sections }
         };
     }
     const planText = codexPlanText(value);