@myagentroam/node 0.9.0 → 0.9.3

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

@@ -1,5 +1,7 @@
 import { extractId } from '../../util/runner-native-session-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { safeErrorCode } from '../../util/safe-error.js';
+import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export class CodexManagedRunController {
     runner;
@@ -32,10 +34,10 @@ export class CodexManagedRunController {
                     commandId: 'plan',
                     active: true,
                     label: 'Plan Mode',
-                    detail: '后续消息将以协作规划模式运行。',
+                    detail: 'Subsequent messages run in collaborative Plan Mode.',
                     closable: true,
                     closeInput: '/plan',
-                    continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
+                    continuation: { label: 'Implement', prompt: 'Implement the plan above.' }
                 });
             return { command: command.id, states: this.host.commandStates(session.id) };
         }
@@ -83,7 +85,8 @@ export class CodexManagedRunController {
             };
         }
         catch (error) {
-            this.host.emit(runId, 'run.failed', { code: error instanceof Error ? error.message : 'CODEX_COMPACT_FAILED' }, 'FAILED');
+            this.emitError(runId, error, 'CODEX_COMPACT_FAILED');
+            this.host.emit(runId, 'run.failed', runnerErrorProjection(error, 'CODEX_COMPACT_FAILED'), 'FAILED');
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);
@@ -183,16 +186,18 @@ export class CodexManagedRunController {
         if (notification.method === 'turn/completed') {
             const status = turn?.status;
             const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
-            this.host.emit(runId, 'run.completed', { status: status ?? 'unknown' }, terminal);
+            if (terminal === 'FAILED')
+                this.emitError(runId, turn?.error ?? turn, 'CODEX_RUN_FAILED');
+            const failure = terminal === 'FAILED'
+                ? runnerErrorProjection(turn?.error ?? turn, 'CODEX_RUN_FAILED')
+                : { status: status ?? 'unknown' };
+            this.host.emit(runId, terminal === 'FAILED' ? 'run.failed' : 'run.completed', failure, terminal);
             const active = this.runner.execution.runs.get(runId);
             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);
             if (titleRefresh === undefined)
                 this.runner.releaseEnvironment(runId);
@@ -283,7 +288,8 @@ export class CodexManagedRunController {
             secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
         }
         catch (error) {
-            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'MESSAGE_ATTACHMENTS_INVALID' }, 'FAILED');
+            this.emitError(runId, error, 'CODEX_RUN_FAILED');
+            this.host.emit(runId, 'run.rejected', runnerErrorProjection(error, 'MESSAGE_ATTACHMENTS_INVALID'), 'FAILED');
             return;
         }
         this.host.adopt({
@@ -311,7 +317,7 @@ export class CodexManagedRunController {
             this.runner.prepareEnvironment(secretEnvironment, runId);
         }
         catch (error) {
-            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'SECRET_ENVIRONMENT_INVALID' }, 'FAILED');
+            this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'SECRET_ENVIRONMENT_INVALID') }, 'FAILED');
             return;
         }
         this.host.addActive(runId);
@@ -381,10 +387,20 @@ export class CodexManagedRunController {
                 this.runner.releaseEnvironment(runId);
                 return;
             }
-            this.host.emit(runId, 'run.failed', { code: error instanceof Error ? error.message : 'CODEX_RUN_FAILED' }, 'FAILED');
+            this.emitError(runId, error, 'CODEX_RUN_FAILED');
+            this.host.emit(runId, 'run.failed', runnerErrorProjection(error, 'CODEX_RUN_FAILED'), 'FAILED');
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);
         }
     }
+    emitError(runId, error, fallbackCode) {
+        const projected = runnerErrorProjection(error, fallbackCode);
+        this.host.emitItem(runId, {
+            itemId: boundedConversationItemId('runner-error', runId),
+            kind: 'error',
+            status: 'FAILED',
+            payload: { ...projected, recoverable: true, retryAfterMs: null }
+        });
+    }
 }

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

@@ -13,6 +13,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     private environmentFingerprint;
     private readonly environmentRuns;
     private readonly profileCache;
+    private readonly profileCacheTimers;
     private readonly profileRefreshes;
     private readonly profileClients;
     private readonly profileKeyByEnvironment;
@@ -23,6 +24,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
     private refreshCodexProfile;
     private selectCachedProfile;
+    private cacheProfile;
     private fetchCodexProfile;
     available(capabilities: NodeCapabilities): boolean;
     executeGlobalCommand(commandId: string, input: string): unknown;
@@ -44,7 +46,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     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;
+    nativeImageRoots(session: NodeAgentSession): readonly string[];
     managedRunForNativeTurn(nativeTurnId: string): string | undefined;
     protected profileForValidation(): RunnerProfile;
     defaultConfiguration(_workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;

package/dist/runner/codex-runner.js

@@ -6,11 +6,12 @@ import { resolve } from 'node:path';
 import { createHash } from 'node:crypto';
 import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from '../native-session-history.js';
-import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, externalResumeFailureDetail, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
+import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
 import { codexSessionControl } from '../codex-app-server.js';
 import { extractId } from '../util/runner-native-session-parsers.js';
 import { nodeLog } from '../operational.js';
 const CODEX_MODEL_CACHE_MS = 10 * 60 * 1_000;
+const CODEX_PROFILE_ENTRY_TTL_MS = 30 * 60 * 1_000;
 const CODEX_MODEL_FAILURE_RETRY_MS = 30 * 1_000;
 const CODEX_MODEL_PAGE_SIZE = 100;
 export class CodexRunner extends AbstractRunner {
@@ -23,6 +24,7 @@ export class CodexRunner extends AbstractRunner {
     environmentFingerprint;
     environmentRuns = new Set();
     profileCache = new Map();
+    profileCacheTimers = new Map();
     profileRefreshes = new Map();
     profileClients = new Set();
     profileKeyByEnvironment = new Map();
@@ -74,7 +76,7 @@ export class CodexRunner extends AbstractRunner {
                 successful: true,
                 retryAt: 0
             };
-            this.profileCache.set(key, cache);
+            this.cacheProfile(key, cache);
             if (this.selectedProfileKey === key)
                 this.latestProfileCache = cache;
             return cache.profile;
@@ -88,7 +90,7 @@ export class CodexRunner extends AbstractRunner {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
                 return cached.profile;
             }
-            this.profileCache.set(key, {
+            this.cacheProfile(key, {
                 profile: { ...base, models: [] },
                 defaultConfiguration: emptyCodexConfiguration(),
                 fetchedAt: 0,
@@ -106,6 +108,25 @@ export class CodexRunner extends AbstractRunner {
             this.latestProfileCache = cached;
         return cached.profile;
     }
+    cacheProfile(key, cache) {
+        const previousTimer = this.profileCacheTimers.get(key);
+        if (previousTimer !== undefined)
+            clearTimeout(previousTimer);
+        this.profileCache.set(key, cache);
+        const timer = setTimeout(() => {
+            this.profileCacheTimers.delete(key);
+            this.profileCache.delete(key);
+            for (const [environmentKey, profileKey] of this.profileKeyByEnvironment)
+                if (profileKey === key)
+                    this.profileKeyByEnvironment.delete(environmentKey);
+            if (this.selectedProfileKey === key) {
+                this.selectedProfileKey = undefined;
+                this.latestProfileCache = undefined;
+            }
+        }, CODEX_PROFILE_ENTRY_TTL_MS);
+        timer.unref();
+        this.profileCacheTimers.set(key, timer);
+    }
     async fetchCodexProfile(base, environment) {
         const client = this.profileClientFactory();
         this.profileClients.add(client);
@@ -248,10 +269,13 @@ export class CodexRunner extends AbstractRunner {
         await this.start();
         return extractCodexThreads(await this.listThreads()).find((thread) => thread.id === nativeSessionId)?.title;
     }
-    nativeImageRoot(session) {
-        return session.externalSessionId === null
-            ? undefined
-            : resolve(homedir(), '.codex', 'generated_images', session.externalSessionId);
+    nativeImageRoots(session) {
+        return [
+            session.cwd,
+            ...(session.externalSessionId === null
+                ? []
+                : [resolve(homedir(), '.codex', 'generated_images', session.externalSessionId)])
+        ];
     }
     managedRunForNativeTurn(nativeTurnId) {
         return this.execution.managedTurns.get(nativeTurnId)?.runId;
@@ -313,11 +337,10 @@ export class CodexRunner extends AbstractRunner {
             }
             return { activity: 'IDLE', session: context.create(external) };
         }
-        catch (error) {
+        catch {
             return {
                 activity: 'UNAVAILABLE',
-                failureCode: 'RUNNER_RESUME_FAILED',
-                failureDetail: externalResumeFailureDetail(error)
+                failureCode: 'RUNNER_RESUME_FAILED'
             };
         }
     }
@@ -464,6 +487,13 @@ export class CodexRunner extends AbstractRunner {
             this.client.clearEnvironment();
         this.environmentFingerprint = undefined;
         this.environmentRuns.clear();
+        for (const timer of this.profileCacheTimers.values())
+            clearTimeout(timer);
+        this.profileCacheTimers.clear();
+        this.profileCache.clear();
+        this.profileKeyByEnvironment.clear();
+        this.latestProfileCache = undefined;
+        this.selectedProfileKey = undefined;
     }
     request(method, params) {
         return this.client.request(method, params);

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

@@ -18,10 +18,14 @@ export declare function openCodeQuestions(value: unknown): {
     allowOther: boolean;
     multiSelect: boolean;
 }[];
-export declare function openCodePatchChanges(value: unknown): {
-    path: string;
-    change: string;
-    additions: null;
-    deletions: null;
-    diffAvailable: boolean;
-}[];
+export declare function openCodePatchToolPayload(): {
+    namespace: string;
+    toolName: string;
+    title: string;
+    inputSummary: null;
+    outputSummary: string;
+    outputSummaryCode: string;
+    progressLabel: null;
+    errorCode: null;
+    truncated: boolean;
+};

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

@@ -1,4 +1,3 @@
-import { basename } from 'node:path';
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
 export function openCodeConversationPage(session, messages, input, managedTurn) {
     const records = messages.flatMap((value) => {
@@ -114,10 +113,11 @@ function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequen
     if (part.type === 'compaction')
         return item(session, turnId, part.id, 'context_compaction', 'COMPLETED', {
             phase: 'COMPLETED',
-            summary: '上下文已整理'
+            summary: 'Context compacted',
+            summaryCode: 'CONTEXT_COMPACTED'
         }, startedAt, completedAt, sequence);
     if (part.type === 'patch')
-        return item(session, turnId, part.id, 'file_change', 'COMPLETED', { changes: openCodePatchChanges(part.files) }, startedAt, completedAt, sequence);
+        return item(session, turnId, part.id, 'tool_call', 'COMPLETED', openCodePatchToolPayload(), startedAt, completedAt, sequence);
     if (part.type === 'step-start' || part.type === 'step-finish')
         return undefined;
     if (part.type === 'text' || part.type === 'reasoning')
@@ -128,7 +128,7 @@ function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequen
     }, startedAt, completedAt, sequence);
 }
 export function openCodeQuestions(value) {
-    if (!Array.isArray(value) || value.length === 0 || value.length > 4)
+    if (!Array.isArray(value) || value.length === 0)
         return [];
     return value.flatMap((value, index) => {
         const question = record(value);
@@ -162,18 +162,18 @@ export function openCodeQuestions(value) {
         ];
     });
 }
-export function openCodePatchChanges(value) {
-    return (Array.isArray(value) ? value : []).flatMap((path) => typeof path === 'string' && path.length > 0
-        ? [
-            {
-                path: basename(path),
-                change: 'MODIFIED',
-                additions: null,
-                deletions: null,
-                diffAvailable: false
-            }
-        ]
-        : []);
+export function openCodePatchToolPayload() {
+    return {
+        namespace: 'opencode',
+        toolName: 'patch',
+        title: 'patch',
+        inputSummary: null,
+        outputSummary: 'OpenCode applied the patch',
+        outputSummaryCode: 'OPENCODE_PATCH_APPLIED',
+        progressLabel: null,
+        errorCode: null,
+        truncated: false
+    };
 }
 function item(session, turnId, nativeId, kind, status, payload, startedAt, completedAt, sequence) {
     return {

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

@@ -7,6 +7,7 @@ interface OpenCodeManagedRunHost {
     intercepted(): boolean;
     readonly active: Set<string>;
     parseAttachments(value: unknown): readonly RunnerImageAttachment[];
+    persistAttachments(cwd: string, runId: string, attachments: readonly RunnerImageAttachment[]): Promise<readonly string[]>;
     emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
     emitItem(runId: string, item: OpenCodePublicItem): void;
     adopt(input: {
@@ -16,10 +17,13 @@ interface OpenCodeManagedRunHost {
         cwd: string;
         externalSessionId?: string;
     }): void;
+    run(runId: string): {
+        readonly id: string;
+    };
+    hasActiveSessionLease(sessionId: string): boolean;
     promote(sessionId: string, nativeSessionId: string): void;
     rememberNative(nativeSessionId: string, sessionId: string): void;
     send(type: string, payload: unknown): void;
-    captureSnapshot(runId: string, cwd: string): Promise<void>;
     createApproval(input: {
         readonly runId: string;
         readonly approvalId: string;
@@ -40,7 +44,7 @@ interface OpenCodeManagedRunHost {
 }
 type OpenCodePublicItem = {
     readonly itemId: string;
-    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'file_change' | 'unknown';
+    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'error' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;
@@ -59,6 +63,8 @@ export declare class OpenCodeManagedRunController {
     executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, context: {
         readonly secretEnvironment: Readonly<Record<string, string>>;
     }): Promise<unknown>;
+    private compact;
+    private runCompact;
     start(envelope: NodeEnvelope): void;
     cancel(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
     decideApproval(input: {

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

@@ -1,6 +1,7 @@
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
-import { openCodePatchChanges, openCodeQuestions } from './conversation-parser.js';
+import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 export class OpenCodeManagedRunController {
     runner;
     host;
@@ -18,7 +19,7 @@ export class OpenCodeManagedRunController {
     }
     async executeCommand(session, command, context) {
         if (command.id === 'compact')
-            return this.runner.executeCompact(session, context.secretEnvironment);
+            return this.compact(session, context.secretEnvironment);
         if (command.id !== 'plan')
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const current = this.host.commandState(session.id, 'plan');
@@ -29,13 +30,60 @@ export class OpenCodeManagedRunController {
                 commandId: 'plan',
                 active: true,
                 label: 'Plan Mode',
-                detail: '后续消息将由 OpenCode 原生 Plan Agent 只读分析并制定计划。',
+                detail: 'Subsequent messages use the OpenCode Plan Agent for read-only analysis.',
                 closable: true,
                 closeInput: '/plan',
-                continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
+                continuation: { label: 'Implement', prompt: 'Implement the plan above.' }
             });
         return { command: command.id, states: this.host.commandStates(session.id) };
     }
+    compact(session, environment) {
+        if (session.externalSessionId === null ||
+            session.model === null ||
+            session.nativeControl !== 'MAR_MANAGED' ||
+            this.host.hasActiveSessionLease(session.id))
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const runId = crypto.randomUUID();
+        const client = this.runner.managedClient(environment);
+        this.host.adopt({
+            runId,
+            sessionId: session.id,
+            runner: 'opencode',
+            cwd: session.cwd,
+            externalSessionId: session.externalSessionId
+        });
+        this.host.active.add(runId);
+        this.runner.execution.set(runId, {
+            runId,
+            sessionId: session.id,
+            nativeSessionId: session.externalSessionId,
+            cwd: session.cwd,
+            client,
+            abort: new AbortController(),
+            access: session.access ?? 'default',
+            agent: 'build'
+        });
+        this.host.emit(runId, 'run.started', { command: 'compact' }, 'STARTING');
+        void this.runCompact(runId, session.model);
+        return {
+            command: 'compact',
+            run: this.host.run(runId),
+            states: this.host.commandStates(session.id)
+        };
+    }
+    async runCompact(runId, model) {
+        const execution = this.runner.execution.get(runId);
+        if (execution === undefined)
+            return;
+        this.host.emit(runId, 'run.running', { command: 'compact' }, 'RUNNING');
+        try {
+            await execution.client.summarize(execution.cwd, execution.nativeSessionId, model);
+            this.finish(runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
+        }
+        catch (error) {
+            this.finish(runId, 'FAILED', 'run.failed', error, 'OPENCODE_COMPACT_FAILED');
+        }
+    }
     start(envelope) {
         const payload = envelope.payload;
         if (payload.runner !== 'opencode' ||
@@ -56,7 +104,14 @@ export class OpenCodeManagedRunController {
             attachments = this.host.parseAttachments(payload.attachments);
         }
         catch (error) {
-            this.host.emit(payload.runId, 'run.rejected', { code: error instanceof Error ? error.message : 'RUNNER_INPUT_INVALID' }, 'FAILED');
+            const projected = runnerErrorProjection(error, 'RUNNER_INPUT_INVALID');
+            this.host.emitItem(payload.runId, {
+                itemId: boundedConversationItemId('runner-error', payload.runId),
+                kind: 'error',
+                status: 'FAILED',
+                payload: { ...projected, recoverable: true, retryAfterMs: null }
+            });
+            this.host.emit(payload.runId, 'run.rejected', projected, 'FAILED');
             return;
         }
         void this.run({
@@ -122,8 +177,8 @@ export class OpenCodeManagedRunController {
         return true;
     }
     async run(input) {
-        // OpenCode 的动态 MCP 注册属于 Server 进程状态。加载 MCP 的 Run 使用独立 Server，
-        // 避免同一工作区的并行会话共享 MCP 进程、配置或浏览器上下文。
+        // OpenCode dynamic MCP registration belongs to Server process state. Runs that load MCP use an
+        // isolated Server so parallel sessions in one workspace do not share MCP processes or context.
         const client = this.runner.managedClient(input.environment, hasMcpConfiguration(input.mcp) ? input.runId : undefined);
         this.startingClients.set(input.runId, client);
         this.startingCwds.set(input.runId, input.cwd);
@@ -180,18 +235,19 @@ export class OpenCodeManagedRunController {
                     rejectReady(error);
                     return;
                 }
-                this.finish(input.runId, 'FAILED', 'run.failed', {
-                    code: error instanceof Error ? error.message : 'OPENCODE_EVENT_FAILED'
-                });
+                this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_EVENT_FAILED');
             });
             await subscriptionReady;
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
             // The initial SSE snapshot can contain an idle event from before this prompt.
             this.pendingIdle.delete(input.runId);
+            const attachmentPaths = input.attachments.length === 0
+                ? []
+                : await this.host.persistAttachments(input.cwd, input.runId, input.attachments);
             await client.prompt({
                 directory: input.cwd,
                 sessionID: nativeSessionId,
-                text: input.input,
+                text: openCodeImageInput(input.input, attachmentPaths),
                 model: input.model,
                 variant: input.effort,
                 agent: input.agent,
@@ -202,9 +258,7 @@ export class OpenCodeManagedRunController {
                 this.finish(input.runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
         }
         catch (error) {
-            this.finish(input.runId, 'FAILED', 'run.failed', {
-                code: error instanceof Error ? error.message : 'OPENCODE_RUN_START_FAILED'
-            });
+            this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_RUN_START_FAILED');
         }
     }
     event(runId, nativeSessionId, value) {
@@ -227,7 +281,7 @@ export class OpenCodeManagedRunController {
             return;
         }
         if (event?.type === 'session.error') {
-            this.finish(runId, 'FAILED', 'run.failed', { code: 'OPENCODE_SESSION_ERROR' });
+            this.finish(runId, 'FAILED', 'run.failed', properties?.error ?? properties);
             return;
         }
         if (event?.type === 'message.part.updated') {
@@ -305,7 +359,7 @@ export class OpenCodeManagedRunController {
         if (execution === undefined || requestId === undefined)
             return;
         const questions = openCodeQuestions(rawQuestions);
-        if (questions.length === 0 || questions.length > 4 || this.questions.has(requestId))
+        if (questions.length === 0 || this.questions.has(requestId))
             return;
         const timer = setTimeout(() => {
             const pending = this.questions.get(requestId);
@@ -336,7 +390,7 @@ export class OpenCodeManagedRunController {
             payload: { requestId, questions }
         });
     }
-    finish(runId, status, eventType, payload) {
+    finish(runId, status, eventType, payload, fallbackCode = 'OPENCODE_RUN_FAILED') {
         const execution = this.runner.execution.get(runId);
         const cwd = execution?.cwd ?? this.startingCwds.get(runId);
         const client = execution?.client ?? this.startingClients.get(runId);
@@ -359,13 +413,27 @@ export class OpenCodeManagedRunController {
                 clearTimeout(pending.timer);
                 this.questions.delete(id);
             }
+        if (status === 'FAILED') {
+            const projected = runnerErrorProjection(payload, fallbackCode);
+            this.host.emitItem(runId, {
+                itemId: boundedConversationItemId('runner-error', runId),
+                kind: 'error',
+                status: 'FAILED',
+                payload: { ...projected, recoverable: true, retryAfterMs: null }
+            });
+            payload = projected;
+        }
         this.host.emit(runId, eventType, payload, status);
         if (client !== undefined)
             this.runner.releaseManagedClient(client);
-        if (cwd !== undefined)
-            void this.host.captureSnapshot(runId, cwd);
     }
 }
+function openCodeImageInput(input, attachmentPaths) {
+    if (attachmentPaths.length === 0)
+        return input;
+    const paths = attachmentPaths.map((path) => `- ${JSON.stringify(path)}`).join('\n');
+    return `${input}\n\nIf an inline image in this message is unavailable, use the read tool on the corresponding copy below. Do not read it again when the inline image is already visible:\n${paths}`;
+}
 function hasMcpConfiguration(value) {
     return value !== null && typeof value === 'object' && Object.keys(value).length > 0;
 }
@@ -425,14 +493,18 @@ function openCodePart(part, planMode = false) {
             itemId,
             kind: 'context_compaction',
             status: 'COMPLETED',
-            payload: { phase: 'COMPLETED', summary: '上下文已整理' }
+            payload: {
+                phase: 'COMPLETED',
+                summary: 'Context compacted',
+                summaryCode: 'CONTEXT_COMPACTED'
+            }
         };
     if (part.type === 'patch')
         return {
             itemId,
-            kind: 'file_change',
+            kind: 'tool_call',
             status: 'COMPLETED',
-            payload: { changes: openCodePatchChanges(part.files) },
+            payload: openCodePatchToolPayload(),
             merge: true
         };
     if (part.type === 'step-start' || part.type === 'step-finish')

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

@@ -19,6 +19,7 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     readonly discoveryScope: "WORKSPACE_REQUIRED";
     private readonly modelsByWorkspace;
     private readonly contextLimitsByWorkspace;
+    private readonly profileTimersByWorkspace;
     readonly execution: Map<string, OpenCodeManagedExecution>;
     readonly managedTurns: Map<string, string>;
     private readonly environmentClients;
@@ -56,6 +57,8 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
         maxTokens: number;
     } | undefined>;
     stop(): Promise<void>;
+    private scheduleProfileExpiry;
+    private clearProfileTimer;
     managedClient(environment: Readonly<Record<string, string>>, isolationKey?: string): OpenCodeServerClient;
     releaseManagedClient(client: OpenCodeServerClient): void;
 }

package/dist/runner/opencode-runner.js

@@ -5,6 +5,7 @@ import { AbstractRunner } from './abstract-runner.js';
 import { isWithinWorkspace } from './codex/conversation-parser.js';
 import { createHash } from 'node:crypto';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
+const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
 export class OpenCodeRunner extends AbstractRunner {
     client;
     clientFactory;
@@ -12,6 +13,7 @@ export class OpenCodeRunner extends AbstractRunner {
     discoveryScope = 'WORKSPACE_REQUIRED';
     modelsByWorkspace = new Map();
     contextLimitsByWorkspace = new Map();
+    profileTimersByWorkspace = new Map();
     execution = new Map();
     managedTurns = new Map();
     environmentClients = new Map();
@@ -39,11 +41,13 @@ export class OpenCodeRunner extends AbstractRunner {
             const models = openCodeProfileModels(catalog);
             this.modelsByWorkspace.set(workspace.path, models);
             this.contextLimitsByWorkspace.set(workspace.path, openCodeContextLimits(catalog));
+            this.scheduleProfileExpiry(workspace.path);
             return { ...this.profile(capabilities), models };
         }
         catch {
             this.modelsByWorkspace.delete(workspace.path);
             this.contextLimitsByWorkspace.delete(workspace.path);
+            this.clearProfileTimer(workspace.path);
         }
         finally {
             this.releaseManagedClient(client);
@@ -279,6 +283,11 @@ export class OpenCodeRunner extends AbstractRunner {
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
+        for (const timer of this.profileTimersByWorkspace.values())
+            clearTimeout(timer);
+        this.profileTimersByWorkspace.clear();
+        this.modelsByWorkspace.clear();
+        this.contextLimitsByWorkspace.clear();
         const stopping = [
             this.client.stop(),
             ...[...this.environmentClients.values()].map(({ client }) => client.stop()),
@@ -288,6 +297,22 @@ export class OpenCodeRunner extends AbstractRunner {
         await Promise.allSettled(stopping);
         this.stoppingClients.clear();
     }
+    scheduleProfileExpiry(workspacePath) {
+        this.clearProfileTimer(workspacePath);
+        const timer = setTimeout(() => {
+            this.profileTimersByWorkspace.delete(workspacePath);
+            this.modelsByWorkspace.delete(workspacePath);
+            this.contextLimitsByWorkspace.delete(workspacePath);
+        }, PROFILE_ENTRY_TTL_MS);
+        timer.unref();
+        this.profileTimersByWorkspace.set(workspacePath, timer);
+    }
+    clearProfileTimer(workspacePath) {
+        const timer = this.profileTimersByWorkspace.get(workspacePath);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.profileTimersByWorkspace.delete(workspacePath);
+    }
     managedClient(environment, isolationKey) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
         if (entries.length === 0 && isolationKey === undefined)