@myagentroam/node 0.1.4 → 0.1.6

package/dist/runner/abstract-runner.d.ts

@@ -19,9 +19,10 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
     readonly interceptsRuns: boolean;
     abstract readonly discoveryScope: 'ALL_WORKSPACES' | 'WORKSPACE_REQUIRED';
     abstract profile(capabilities: NodeCapabilities): RunnerProfile | undefined;
+    refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile | undefined>;
     abstract available(capabilities: NodeCapabilities): boolean;
-    abstract defaultConfiguration(): RunnerDefaultConfiguration;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration): boolean;
+    abstract defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
     protected abstract profileForValidation(): RunnerProfile;
     abstract resumeExternal(session: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
     abstract discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
@@ -37,6 +38,8 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
         readonly title?: string | null;
         readonly pinned?: boolean;
     }, database: NodeDatabase): Promise<void>;
+    removeNative(session: NodeAgentSession, nativeSessionId: string): Promise<boolean>;
+    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string | null>;
     projectedRunnerTitle(metadata: ReturnType<NodeDatabase['getNativeSessionMetadata']>, input: RunnerProjectionTitleInput, database: NodeDatabase | undefined): string | null;
     managedAliasId(nativeSessionId: string): string | undefined;
     nativeAliasesFor(managedSessionId: string): readonly string[];
@@ -57,6 +60,7 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
     startManagedRun(envelope: NodeEnvelope): void;
     cancelManagedRun(runId: string, intent: RunnerCancellationIntent): boolean;
     decideApproval(input: RunnerApprovalDecision): boolean;
+    respondUserInput(runId: string, requestId: string, answers: Record<string, unknown>): boolean;
     bindCommandControl(control: RunnerCommandControl): void;
     executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {
         readonly secretEnvironment: Readonly<Record<string, string>>;
@@ -67,6 +71,7 @@ export interface RunnerControl {
     start(envelope: NodeEnvelope): void;
     cancel(runId: string, intent: RunnerCancellationIntent): boolean;
     decideApproval?(input: RunnerApprovalDecision): boolean;
+    respondUserInput?(runId: string, requestId: string, answers: Record<string, unknown>): boolean;
 }
 export interface RunnerCommandControl {
     execute(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {

package/dist/runner/abstract-runner.js

@@ -11,7 +11,12 @@ export class AbstractRunner {
     /** Test-only runners are registered explicitly but never advertised. */
     advertised = true;
     interceptsRuns = false;
-    supportsConfiguration(configuration) {
+    async refreshProfile(capabilities, workspace, environment = {}) {
+        void [workspace, environment];
+        return this.profile(capabilities);
+    }
+    supportsConfiguration(configuration, workspace) {
+        void workspace;
         const profile = this.profileForValidation();
         const model = profile.models.find((candidate) => candidate.id === configuration.model);
         return (configuration.runner === this.name &&
@@ -56,6 +61,14 @@ export class AbstractRunner {
             ...(input.pinned === undefined ? {} : { pinned: input.pinned })
         });
     }
+    async removeNative(session, nativeSessionId) {
+        void [session, nativeSessionId];
+        return false;
+    }
+    async forkNative(session, boundary, title) {
+        void [session, boundary, title];
+        throw new RunnerCapabilityError(this.name, 'session.rewind');
+    }
     projectedRunnerTitle(metadata, input, database) {
         void database;
         return input.title ?? metadata?.runnerTitle ?? null;
@@ -116,6 +129,9 @@ export class AbstractRunner {
     decideApproval(input) {
         return this.control?.decideApproval?.(input) === true;
     }
+    respondUserInput(runId, requestId, answers) {
+        return this.control?.respondUserInput?.(runId, requestId, answers) === true;
+    }
     bindCommandControl(control) {
         if (this.commandControl !== undefined)
             throw new Error(`RUNNER_COMMAND_CONTROL_ALREADY_BOUND:${this.name}`);
@@ -136,4 +152,3 @@ export class RunnerCapabilityError extends Error {
         this.capability = capability;
     }
 }
-//# sourceMappingURL=abstract-runner.js.map

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

@@ -2,6 +2,7 @@ import { createEnvelope } from '@myagentroam/protocol';
 import { ClaudeChannelGate } from '../../claude-channel.js';
 import { boundedConversationItemId, claudePlanText, compactRunnerText, compactRunnerValue, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolResults, extractClaudeToolUses, isClaudeCommandTool } from '../codex/conversation-parser.js';
 import { isTerminalRunStatus } from '../../util/node-operation-parsers.js';
+import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 export class ClaudeManagedRunController {
     runner;
@@ -229,6 +230,25 @@ export class ClaudeManagedRunController {
                                     }
                             });
                         }
+                        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)}`
+                                }
+                            });
+                        }
                     }
                     if (record.type === 'tool_progress' && typeof record.tool_use_id === 'string') {
                         const kind = toolKinds.get(record.tool_use_id);
@@ -304,4 +324,3 @@ export class ClaudeManagedRunController {
         }
     }
 }
-//# sourceMappingURL=managed-run-controller.js.map

package/dist/runner/claude-code-runner.d.ts

@@ -8,10 +8,11 @@ import type { NodeAgentSession, NodeWorkspace } from '../database.js';
 import { type NativeSessionHistory } from '../native-session-history.js';
 export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
     private readonly client;
+    private readonly environment;
     readonly name: "claude-code";
     readonly discoveryScope: "WORKSPACE_REQUIRED";
     readonly execution: ClaudeExecutionState;
-    constructor(client?: ClaudeAgentSdkAdapter);
+    constructor(client?: ClaudeAgentSdkAdapter, environment?: NodeJS.ProcessEnv);
     profile(capabilities: NodeCapabilities): RunnerProfile;
     available(capabilities: NodeCapabilities): boolean;
     protected profileForValidation(): RunnerProfile;
@@ -19,6 +20,7 @@ export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeClaudeContextUsage | undefined>;
+    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string | null>;
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;
     channelToken(sessionId: string): string | undefined;

package/dist/runner/claude-code-runner.js

@@ -1,22 +1,26 @@
 import { ClaudeAgentSdkAdapter } from '../claude-agent-sdk.js';
 import { AbstractRunner } from './abstract-runner.js';
-import { declaredRunnerProfiles } from '../runner-profiles.js';
+import { claudeDefaultModel, declaredRunnerProfiles } from '../runner-profiles.js';
 import { withClaudePlanTag } from '../runner-command-engine.js';
 import { discoverNativeSessions, readNativeSession, readClaudeNativeContextUsage } from '../native-session-history.js';
 import { claudeDiscoveredSession, deduplicateDirectSessions, externalResumeFailureDetail, isNativeHistory, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
 export class ClaudeCodeRunner extends AbstractRunner {
     client;
+    environment;
     name = 'claude-code';
     discoveryScope = 'WORKSPACE_REQUIRED';
     execution = new ClaudeExecutionState();
-    constructor(client = new ClaudeAgentSdkAdapter()) {
+    constructor(client = new ClaudeAgentSdkAdapter(), environment = process.env) {
         super();
         this.client = client;
+        this.environment = environment;
     }
     profile(capabilities) {
         return declaredRunnerProfiles({
             codexAvailable: capabilities.codex.available,
-            claudeCodeAvailable: capabilities.claudeCode.available
+            claudeCodeAvailable: capabilities.claudeCode.available,
+            environment: this.environment,
+            openCodeAvailable: capabilities.openCode?.available === true
         }).find((profile) => profile.runner === this.name);
     }
     available(capabilities) {
@@ -29,11 +33,17 @@ export class ClaudeCodeRunner extends AbstractRunner {
             nodeAppVersion: 'validation',
             nodeVersion: 'validation',
             codex: { available: false },
-            claudeCode: { available: true }
+            claudeCode: { available: true },
+            openCode: { available: false }
         });
     }
     defaultConfiguration() {
-        return { runner: this.name, model: 'sonnet', effort: 'medium', access: 'default' };
+        return {
+            runner: this.name,
+            model: claudeDefaultModel(this.environment),
+            effort: 'medium',
+            access: 'default'
+        };
     }
     async resumeExternal(external, context) {
         if (external.runner !== this.name ||
@@ -112,6 +122,13 @@ export class ClaudeCodeRunner extends AbstractRunner {
             ? Promise.resolve(undefined)
             : readClaudeNativeContextUsage(session.cwd, session.externalSessionId);
     }
+    forkNative(session, boundary, title) {
+        if (session.externalSessionId === null)
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        return boundary === null
+            ? Promise.resolve(null)
+            : this.client.forkSession(session.externalSessionId, session.cwd, boundary, title);
+    }
     presentSession(session, capabilities, context) {
         if (capabilities.claudeCode.available && session.nativeControl === 'MAR_MANAGED') {
             const runtimeCapabilities = [
@@ -124,7 +141,8 @@ export class ClaudeCodeRunner extends AbstractRunner {
                 'approval.respond',
                 'session.rename',
                 'session.remove',
-                'session.pin'
+                'session.pin',
+                ...(session.externalSessionId === null ? [] : ['session.rewind'])
             ];
             return {
                 activity: context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE',
@@ -142,7 +160,8 @@ export class ClaudeCodeRunner extends AbstractRunner {
                 'turn.start',
                 'session.rename',
                 'session.remove',
-                'session.pin'
+                'session.pin',
+                'session.rewind'
             ];
             return {
                 activity: 'IDLE',
@@ -265,4 +284,3 @@ export class ClaudeExecutionState {
     approvals = new Map();
     userInputs = new Map();
 }
-//# sourceMappingURL=claude-code-runner.js.map

package/dist/runner/codex/conversation-parser.d.ts

@@ -1,7 +1,7 @@
 import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn, NodeMessageAttachmentInput } from '../../database.js';
 export type PublicConversationItem = {
     readonly itemId: string;
-    readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan';
+    readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;
@@ -27,8 +27,6 @@ export declare function codexNativeItemIds(values: readonly unknown[]): Readonly
 export declare function conversationItemNativeId(itemId: string): string | undefined;
 /** Keep a custom tool invocation and its output in one Workbench card. */
 export declare function codexOfficialItems(session: NodeAgentSession, nativeTurnId: string, values: readonly unknown[], turnSequence: number, startedAt: number | null, completedAt: number | null): NodeConversationItem[];
-/** Keep history-only and history-plus-live projections in the same narrative order. */
-export declare function orderCodexConversationItems(items: readonly NodeConversationItem[]): NodeConversationItem[];
 export declare function codexPairedToolCallId(value: unknown): string | undefined;
 export declare function mergeCodexCustomToolItems(invocation: NodeConversationItem, result: NodeConversationItem): NodeConversationItem;
 export declare function coalesceImageGenerationItems(items: readonly NodeConversationItem[]): readonly NodeConversationItem[];

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

@@ -7,14 +7,17 @@ export function codexOfficialConversationPage(session, result, input, managedTur
     const thread = result.thread;
     if (thread.id !== session.externalSessionId || !Array.isArray(thread.turns))
         return undefined;
-    const allTurns = thread.turns.flatMap((value, sequence) => {
-        const turn = codexOfficialTurn(session, value, sequence, typeof value === 'object' &&
-            value !== null &&
-            typeof value.id === 'string'
-            ? managedTurnForNative(value.id)
-            : undefined);
-        return turn === undefined ? [] : [turn];
+    const parsedTurns = thread.turns.flatMap((value, sequence) => {
+        const nativeTurnId = typeof value === 'object' && value !== null && typeof value.id === 'string'
+            ? value.id
+            : undefined;
+        const turn = codexOfficialTurn(session, value, sequence, nativeTurnId === undefined ? undefined : managedTurnForNative(nativeTurnId));
+        return turn === undefined || nativeTurnId === undefined ? [] : [{ nativeTurnId, turn }];
     });
+    const allTurns = parsedTurns.map(({ nativeTurnId, turn }, index) => ({
+        ...turn,
+        rewind: { before: parsedTurns[index - 1]?.nativeTurnId ?? null, after: nativeTurnId }
+    }));
     if (allTurns.length === 0)
         return undefined;
     const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
@@ -38,23 +41,31 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
     if (managedTurn !== undefined) {
         const localUser = managedTurn.items.find((item) => item.kind === 'user_message');
         const officialNativeItemIds = codexNativeItemIds(value.items);
-        const officialAssistantMessage = items.some((item) => item.kind === 'assistant_message');
+        const officialAssistantCount = items.filter((item) => item.kind === 'assistant_message').length;
+        const officialAssistantMessage = officialAssistantCount > 0;
+        const managedAssistants = managedTurn.items.filter((item) => item.kind === 'assistant_message');
+        const managedAssistantCandidates = officialAssistantCount === 0 ? [] : managedAssistants.slice(-officialAssistantCount);
         const assistantLength = (values) => values.reduce((length, item) => {
             if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
                 return length;
             return length + (typeof item.payload.text === 'string' ? item.payload.text.length : 0);
         }, 0);
         const preferLocalAssistant = officialAssistantMessage &&
-            (assistantLength(managedTurn.items) > assistantLength(items) ||
+            (assistantLength(managedAssistantCandidates) > assistantLength(items) ||
                 ((managedTurn.completedAt ?? 0) > (completedAt ?? 0) &&
-                    assistantLength(managedTurn.items) > 0));
+                    assistantLength(managedAssistantCandidates) > 0));
+        const replacedManagedAssistantIds = new Set(preferLocalAssistant
+            ? []
+            : officialAssistantCount === 0
+                ? []
+                : managedAssistantCandidates.map((item) => item.id));
         const localLiveItems = managedTurn.items.filter((item) => {
             if (item.kind === 'user_message')
                 return false;
             // `item/agentMessage/delta` uses a synthetic runtime ID. Once
             // `thread/read` returns the final Agent message, it is the same reply
             // without a shared native item ID and must replace that transient item.
-            if (item.kind === 'assistant_message' && officialAssistantMessage && !preferLocalAssistant)
+            if (item.kind === 'assistant_message' && replacedManagedAssistantIds.has(item.id))
                 return false;
             const nativeItemId = conversationItemNativeId(item.id);
             return nativeItemId === undefined || !officialNativeItemIds.has(nativeItemId);
@@ -68,14 +79,50 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
         ];
         if (localUser !== undefined && !officialItems.some((item) => item.kind === 'user_message'))
             officialItems.unshift({ ...localUser, turnId: managedTurn.id });
+        const retainedLocalIds = new Set(localLiveItems.map((item) => item.id));
+        const consumedOfficialIds = new Set();
+        const officialUser = officialItems.find((item) => item.kind === 'user_message');
+        const officialAssistants = officialItems.filter((item) => item.kind === 'assistant_message');
+        const officialItemMarker = `:official:${value.id}:`;
+        const officialByNativeId = new Map(officialItems.flatMap((item) => {
+            const markerIndex = item.id.lastIndexOf(officialItemMarker);
+            return markerIndex < 0
+                ? []
+                : [[item.id.slice(markerIndex + officialItemMarker.length), item]];
+        }));
+        const reconciledItems = [];
+        for (const managedItem of managedTurn.items) {
+            let replacement;
+            if (managedItem.kind === 'user_message')
+                replacement = officialUser;
+            else {
+                const nativeId = conversationItemNativeId(managedItem.id);
+                if (nativeId !== undefined)
+                    replacement = officialByNativeId.get(nativeId);
+                if (replacement === undefined &&
+                    managedItem.kind === 'assistant_message' &&
+                    replacedManagedAssistantIds.has(managedItem.id))
+                    replacement = officialAssistants.find((item) => !consumedOfficialIds.has(item.id));
+            }
+            if (replacement !== undefined) {
+                if (!consumedOfficialIds.has(replacement.id)) {
+                    reconciledItems.push(replacement);
+                    consumedOfficialIds.add(replacement.id);
+                }
+            }
+            else if (retainedLocalIds.has(managedItem.id))
+                reconciledItems.push(managedItem);
+        }
+        for (const item of officialItems)
+            if (!consumedOfficialIds.has(item.id))
+                reconciledItems.push(item);
         return {
             ...managedTurn,
             status: 'SUCCEEDED',
-            // App Server history is authoritative, but can lag a live item that is
-            // not represented in `thread/read`.  A planning result is terminal for
-            // this turn, so any such retained tool card belongs before it; never
-            // append it after the plan/Implement affordance.
-            items: orderCodexConversationItems([...officialItems, ...localLiveItems]),
+            // Reconcile against the managed runtime order. Official items replace
+            // matching live projections in place; newly visible terminal items such
+            // as a plan are appended after the commentary and tools that preceded it.
+            items: reconciledItems,
             startedAt,
             completedAt
         };
@@ -172,20 +219,7 @@ export function codexOfficialItems(session, nativeTurnId, values, turnSequence,
         const result = invocation === item ? previous : item;
         items[existingIndex] = mergeCodexCustomToolItems(invocation, result);
     }
-    // A tool card is evidence for the reply.  Keep the prompt first, then show
-    // every command/tool action before Agent prose so the visible narrative does
-    // not claim a result before its supporting execution is available.
-    return orderCodexConversationItems(items);
-}
-/** Keep history-only and history-plus-live projections in the same narrative order. */
-export function orderCodexConversationItems(items) {
-    return [
-        ...items.filter((item) => item.kind === 'user_message'),
-        ...items.filter((item) => item.kind === 'command_execution' || item.kind === 'tool_call'),
-        ...items.filter((item) => item.kind !== 'user_message' &&
-            item.kind !== 'command_execution' &&
-            item.kind !== 'tool_call')
-    ];
+    return items;
 }
 export function codexPairedToolCallId(value) {
     if (!isPlainRecord(value))
@@ -311,6 +345,38 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
             kind: 'assistant_message',
             payload: { text: value.text, format: 'markdown', source: 'codex-app-server' }
         };
+    if (value.type === 'reasoning') {
+        const sections = Array.isArray(value.summary)
+            ? value.summary.flatMap((text, index) => typeof text === 'string' && text.trim().length > 0
+                ? [{ index, text: compactRunnerText(text, 10_000) }]
+                : [])
+            : [];
+        return { ...base, kind: 'reasoning_summary', payload: { sections } };
+    }
+    if (value.type === 'commandExecution') {
+        const output = typeof value.aggregatedOutput === 'string' ? value.aggregatedOutput : '';
+        return {
+            ...base,
+            kind: 'command_execution',
+            payload: {
+                command: typeof value.command === 'string'
+                    ? compactRunnerText(value.command, 10_000)
+                    : '（未提供命令）',
+                cwd: typeof value.cwd === 'string' ? compactRunnerText(value.cwd, 4_096) : null,
+                outputPreview: compactRunnerText(output, 10_000),
+                outputRef: null,
+                exitCode: typeof value.exitCode === 'number' && Number.isInteger(value.exitCode)
+                    ? value.exitCode
+                    : null,
+                durationMs: typeof value.durationMs === 'number' &&
+                    Number.isInteger(value.durationMs) &&
+                    value.durationMs >= 0
+                    ? value.durationMs
+                    : null,
+                truncated: output.length > 10_000
+            }
+        };
+    }
     if (value.type === 'mcpToolCall')
         return {
             ...base,
@@ -387,8 +453,12 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
     if (value.type === 'fileChange' && Array.isArray(value.changes))
         return { ...base, kind: 'file_change', payload: { changes: value.changes } };
     if (value.type === 'contextCompaction')
-        return { ...base, kind: 'context_compaction', payload: { summary: '上下文已整理' } };
-    return undefined;
+        return {
+            ...base,
+            kind: 'context_compaction',
+            payload: { phase: 'COMPLETED', summary: '上下文已整理' }
+        };
+    return codexUnknownOfficialItem(base, value);
 }
 export function codexLiveConversationItem(value, completed, imageAttachments = []) {
     if (typeof value.type !== 'string')
@@ -469,6 +539,57 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             }
         };
     }
+    if (value.type === 'webSearch')
+        return {
+            itemId,
+            kind: 'tool_call',
+            status: completed ? 'COMPLETED' : 'IN_PROGRESS',
+            payload: {
+                namespace: 'web',
+                toolName: 'search',
+                title: 'Web Search',
+                inputSummary: typeof value.query === 'string' ? compactRunnerText(value.query, 10_000) : null,
+                outputSummary: null,
+                progressLabel: completed ? null : '正在搜索',
+                errorCode: null,
+                truncated: false
+            }
+        };
+    if (value.type === 'fileChange' && Array.isArray(value.changes))
+        return {
+            itemId,
+            kind: 'file_change',
+            status: completed ? 'COMPLETED' : 'IN_PROGRESS',
+            payload: { changes: value.changes },
+            merge: true
+        };
+    if (value.type === 'imageGeneration')
+        return {
+            itemId,
+            kind: 'tool_call',
+            status: codexItemStatus(value.status, completed),
+            payload: {
+                namespace: 'codex',
+                toolName: 'imagegen',
+                title: 'imagegen',
+                inputSummary: typeof value.revisedPrompt === 'string'
+                    ? compactRunnerText(value.revisedPrompt, 10_000)
+                    : null,
+                outputSummary: completed ? '图片生成完成' : null,
+                progressLabel: completed ? null : '正在生成图片',
+                errorCode: value.status === 'failed' ? 'IMAGE_GENERATION_FAILED' : null,
+                truncated: false,
+                ...(imageAttachments.length === 0 ? {} : { attachments: imageAttachments })
+            },
+            merge: true
+        };
+    if (value.type === 'contextCompaction')
+        return {
+            itemId,
+            kind: 'context_compaction',
+            status: completed ? 'COMPLETED' : 'IN_PROGRESS',
+            payload: { phase: completed ? 'COMPLETED' : 'STARTED', summary: null }
+        };
     if (value.type === 'dynamicToolCall' ||
         value.type === 'custom_tool_call' ||
         value.type === 'custom_tool_call_output' ||
@@ -516,7 +637,27 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             }
         };
     }
-    return undefined;
+    return codexUnknownLiveItem(itemId, value.type, completed);
+}
+function codexUnknownOfficialItem(base, value) {
+    if (value.type === 'userMessage' || value.type === 'agentMessage')
+        return undefined;
+    const type = typeof value.type === 'string' ? value.type : 'unknown';
+    return {
+        ...base,
+        kind: 'unknown',
+        payload: { sourceEventType: `codex:${type}`, label: `Codex ${compactRunnerText(type, 128)}` }
+    };
+}
+function codexUnknownLiveItem(itemId, type, completed) {
+    if (type === 'userMessage' || type === 'agentMessage')
+        return undefined;
+    return {
+        itemId,
+        kind: 'unknown',
+        status: completed ? 'COMPLETED' : 'IN_PROGRESS',
+        payload: { sourceEventType: `codex:${type}`, label: `Codex ${compactRunnerText(type, 128)}` }
+    };
 }
 export function codexImageAttachments(value) {
     const found = [];
@@ -673,4 +814,3 @@ export function isCodexImageBlock(value) {
 }
 import { codexTimestamp, compactRunnerText, compactRunnerValue, boundedConversationItemId, isCanonicalBase64, isPlainRecord, nativePageEnd } from '../../util/node-operation-parsers.js';
 export * from '../../util/node-operation-parsers.js';
-//# sourceMappingURL=conversation-parser.js.map

package/dist/runner/codex/managed-run-controller.d.ts

@@ -44,7 +44,7 @@ export interface CodexManagedRunHost<TAttachment> {
     }): void;
     emitItem(runId: string, item: {
         readonly itemId: string;
-        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan';
+        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'unknown';
         readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
         readonly payload: Record<string, unknown>;
         readonly merge?: boolean;
@@ -52,6 +52,7 @@ export interface CodexManagedRunHost<TAttachment> {
     }): void;
     appendImages(runId: string, images: readonly NodeMessageAttachmentInput[]): readonly Record<string, unknown>[];
     captureSnapshot(runId: string, cwd: string): Promise<void>;
+    syncTitle(sessionId: string, nativeSessionId: string, cwd: string): Promise<void>;
     commandState(sessionId: string, commandId: string): RunnerCommandState | undefined;
     setCommandState(sessionId: string, state: RunnerCommandState): void;
     clearCommandState(sessionId: string, commandId: string): void;

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

@@ -70,7 +70,8 @@ export class CodexManagedRunController {
         this.runner.execution.runs.set(runId, {
             sessionId: session.id,
             threadId,
-            cwd: session.cwd
+            cwd: session.cwd,
+            refreshTitle: false
         });
         this.host.emit(runId, 'run.started', { command: 'compact' }, 'STARTING');
         try {
@@ -184,10 +185,19 @@ export class CodexManagedRunController {
             const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
             this.host.emit(runId, 'run.completed', { status: status ?? 'unknown' }, terminal);
             const active = this.runner.execution.runs.get(runId);
-            if (active !== undefined)
+            const titleRefresh = active === undefined ||
+                active.refreshTitle === false ||
+                this.host.session(active.sessionId)?.titleSource !== 'AUTO'
+                ? undefined
+                : this.host.syncTitle(active.sessionId, active.threadId, active.cwd);
+            if (active !== undefined) {
                 void this.host.captureSnapshot(runId, active.cwd);
+            }
             this.runner.execution.runs.delete(runId);
-            this.runner.releaseEnvironment(runId);
+            if (titleRefresh === undefined)
+                this.runner.releaseEnvironment(runId);
+            else
+                void titleRefresh.finally(() => this.runner.releaseEnvironment(runId));
             this.host.removeActive(runId);
         }
     }
@@ -376,4 +386,3 @@ export class CodexManagedRunController {
         }
     }
 }
-//# sourceMappingURL=managed-run-controller.js.map

package/dist/runner/codex-runner.d.ts

@@ -31,6 +31,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     } | undefined>;
     readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "MANAGED_ACTIVE" | "EXTERNAL_ACTIVE" | "IDLE" | undefined>;
     acceptsTruncatedNativeHistory(): boolean;
+    readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
     nativeImageRoot(session: NodeAgentSession): string | undefined;
     managedRunForNativeTurn(nativeTurnId: string): string | undefined;
     protected profileForValidation(): RunnerProfile;
@@ -49,6 +50,8 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     listThreads(): Promise<unknown>;
     readThread(threadId: string, includeTurns?: boolean): Promise<unknown>;
     startThread(cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
+    forkThread(threadId: string, cwd: string, lastTurnId: string, configuration?: CodexRunConfiguration): Promise<unknown>;
+    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string>;
     resumeThread(threadId: string, cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
     startTurn(threadId: string, text: string, cwd: string, configuration?: CodexRunConfiguration, attachments?: readonly Extract<CodexComposerInput, {
         readonly type: 'localImage';
@@ -63,6 +66,7 @@ export declare class CodexExecutionState {
         threadId: string;
         turnId?: string;
         cwd: string;
+        refreshTitle?: boolean;
     }>;
     readonly managedTurns: Map<string, {
         sessionId: string;