evolcore 0.0.26 → 0.0.28

package/dist/agents/ecagent-runner.js

@@ -1,4 +1,4 @@
-import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable } from '../core/model/model-catalog.js';
+import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable, TRANSPORT_EFFORTS, resolveCatalogModel, } from '../core/model/model-catalog.js';
 // Ecagent/OpenAI API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
 import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 import fs from 'fs';
@@ -12,13 +12,14 @@ import { requestDangerousCommandPermission } from '../core/permission/approval-g
 import { normalizeExecutionPermissionMode, normalizePermissionMode } from '../core/permission/mode.js';
 import { checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
 import { logger } from '../utils/logger.js';
+import { ErrorType } from '../utils/error-utils.js';
 import { summarizeToolInputForAudit } from '../utils/tool-summary.js';
 import { auditToolPreflightDenial } from '../core/auth/authorization-audit.js';
 import { resolveEcagentConfig } from './baseagent.js';
 import { buildModelRequestHeaders } from './request-identity.js';
 import { appendRequestPath } from './request-identity.js';
 import { getManagedTaskTempDir } from '../cli/task-context.js';
-import { hasTrustedFullAccessContext } from './runner-types.js';
+import { unsettledInterruptError, withInterruptDeadline, hasTrustedFullAccessContext } from './runner-types.js';
 const PROVIDER_ID = 'evolcore-gateway';
 const DEFAULT_SYSTEM_PROMPT = `You are ecagent, the coding agent built into EvolCore.
 Work directly in the current project. Inspect relevant files before changing them, keep edits scoped, and verify the result.
@@ -679,6 +680,8 @@ function extractToolResult(result) {
 }
 function errorType(message) {
     const normalized = message.toLowerCase();
+    if (normalized.includes('invalid jsonl session file') || normalized.includes('session file'))
+        return ErrorType.SESSION_UNAVAILABLE;
     if (normalized.includes('[auth]') || normalized.includes('401') || normalized.includes('403'))
         return 'auth';
     if (normalized.includes('context') && (normalized.includes('long') || normalized.includes('length')))
@@ -690,6 +693,7 @@ function errorType(message) {
 export class EcagentRunner {
     name = 'ecagent';
     capabilities = {
+        taskRecovery: true,
         fullaccess: true,
         clear: true, compact: true, fork: true, askUserQuestion: false, planApproval: false, fileRewind: 'unsupported',
     };
@@ -700,6 +704,9 @@ export class EcagentRunner {
     effort;
     permissionMode = DEFAULT_PERMISSION_MODE;
     runtimes = new Map();
+    /** Serialize harness lifecycles that share one durable ecagent session file. */
+    sessionRunTails = new Map();
+    sessionRuns = new Map();
     activeStreams = new Map();
     /** Queue identity prevents an old run's finally from consuming a new run's interrupt. */
     pendingInterrupts = new Map();
@@ -755,7 +762,15 @@ export class EcagentRunner {
         return catalog.models.map(m => m.id);
     }
     async getAvailableEfforts(model) {
-        return catalogEfforts(await this.getModelCatalog(), model, 'ecagent');
+        const catalog = await this.getModelCatalog();
+        const efforts = catalogEfforts(catalog, model, 'ecagent');
+        if (efforts.length > 0)
+            return efforts;
+        // The embedded transport advertises reasoning support for every model it
+        // constructs. Older gateways may omit reasoningLevels from /models; keep
+        // menu.options aligned with the actual runner capability in that case.
+        const entry = catalog.models.find(item => item.id === resolveCatalogModel(catalog, model));
+        return entry && entry.reasoningLevels === undefined ? [...TRANSPORT_EFFORTS.ecagent] : efforts;
     }
     registerStream(key, stream) { this.activeStreams.set(key, stream); }
     cleanupStream(key) {
@@ -799,6 +814,7 @@ export class EcagentRunner {
         // Keep managed tasks from silently inheriting the daemon-wide TMPDIR when
         // their session-owned runtime directory is unavailable.
         getManagedTaskTempDir(runtimeEnv);
+        this.assertInterruptSettled(sessionId);
         const topicBinding = modelOverride?.backend?.kind === 'topic';
         if (topicBinding && (!modelOverride?.turn || modelOverride.turn.sessionId !== sessionId || !this.onSessionIdUpdate)) {
             const error = new Error('topic backend run requires an active TurnLease and binding callback');
@@ -806,20 +822,43 @@ export class EcagentRunner {
             throw error;
         }
         const queue = new AsyncEventQueue();
+        const lifecycle = { queue, cancelled: false };
+        const runs = this.sessionRuns.get(sessionId) ?? new Set();
+        runs.add(lifecycle);
+        this.sessionRuns.set(sessionId, runs);
         this.activeStreams.set(sessionId, queue);
-        void this.executeRun(queue, {
+        const request = {
             sessionId, prompt, projectPath: path.resolve(projectPath), initialAgentSessionId, images,
             systemPromptAppend, modelOverride, runtimeEnv,
+        };
+        const previous = this.sessionRunTails.get(sessionId) ?? Promise.resolve();
+        const run = previous.catch(() => undefined).then(() => {
+            if (!lifecycle.cancelled)
+                return this.executeRun(queue, request, lifecycle);
         });
+        lifecycle.done = run;
+        this.sessionRunTails.set(sessionId, run);
+        const release = () => {
+            runs.delete(lifecycle);
+            if (this.sessionRuns.get(sessionId) === runs && runs.size === 0)
+                this.sessionRuns.delete(sessionId);
+            if (this.sessionRunTails.get(sessionId) === run)
+                this.sessionRunTails.delete(sessionId);
+        };
+        void run.then(release, release);
         return queue;
     }
-    async executeRun(queue, request) {
-        const stats = { startedAt: Date.now(), text: '', numTurns: 0, usage: {}, modelCalls: [] };
+    async executeRun(queue, request, lifecycle) {
+        const stats = {
+            startedAt: Date.now(), text: '', textBlocks: new Map(), numTurns: 0, usage: {}, modelCalls: [],
+        };
         let completeSent = false;
         try {
             await fs.promises.mkdir(request.projectPath, { recursive: true });
             const previousRuntime = this.runtimes.get(request.sessionId);
             const runtime = await this.getOrCreateRuntime(request.sessionId, request.projectPath, request.initialAgentSessionId, request.modelOverride);
+            if (lifecycle.cancelled)
+                throw new Error('ecagent run interrupted');
             if (previousRuntime !== runtime) {
                 queue.push({ type: 'session_id', sessionId: runtime.agentSessionId });
             }
@@ -870,13 +909,16 @@ export class EcagentRunner {
                 throw new Error('ecagent run interrupted');
             }
             harness.on('tool_call', async (event, signal) => {
+                if (lifecycle.cancelled || signal?.aborted)
+                    return { block: true, reason: '工具调用已取消' };
                 const pauseController = this.permissionContexts.get(request.sessionId)?.pauseController;
                 if (pauseController) {
                     const pauseResult = await pauseController.waitAtToolBoundary(signal);
                     if (pauseResult === 'cancelled')
                         return { block: true, reason: '工具调用已取消' };
                 }
-                return this.authorizeTool(request.sessionId, request.projectPath, permissionMode, event.toolName, event.input);
+                const decision = await this.authorizeTool(request.sessionId, request.projectPath, permissionMode, event.toolName, event.input);
+                return lifecycle.cancelled || signal?.aborted ? { block: true, reason: '工具调用已取消' } : decision;
             });
             const unsubscribe = harness.subscribe(event => this.mapHarnessEvent(queue, event, stats, model, effort));
             queue.push({ type: 'state_changed', state: 'running' });
@@ -890,20 +932,36 @@ export class EcagentRunner {
             }
             finally {
                 unsubscribe();
-                runtime.harness = undefined;
+                this.finishTextBlocks(queue, stats);
+                if (runtime.harness === harness)
+                    runtime.harness = undefined;
             }
-            if (result.stopReason === 'error' || result.stopReason === 'aborted') {
-                const message = result.errorMessage || (result.stopReason === 'aborted' ? 'ecagent run interrupted' : 'ecagent run failed');
-                queue.push({ type: 'error', error: message, errorType: errorType(message) });
+            const outputLimit = result.stopReason === 'length';
+            if (result.stopReason === 'error' || result.stopReason === 'aborted' || outputLimit) {
+                const message = result.errorMessage || (result.stopReason === 'aborted'
+                    ? 'ecagent run interrupted'
+                    : outputLimit
+                        ? 'ecagent response reached the output limit (max_output_tokens)'
+                        : 'ecagent run failed');
+                queue.push({ type: 'error', error: message, errorType: outputLimit ? ErrorType.MAX_OUTPUT_TOKENS : errorType(message) });
             }
             const title = await runtime.session.getSessionName();
             queue.push({ type: 'state_changed', state: 'idle' });
             queue.push({
                 type: 'complete',
                 result: stats.text,
-                isError: result.stopReason === 'error' || result.stopReason === 'aborted',
-                errors: result.errorMessage ? [result.errorMessage] : undefined,
-                terminalReason: result.stopReason === 'aborted' ? 'interrupted' : result.stopReason,
+                ...(outputLimit ? { subtype: 'max_output_tokens' } : {}),
+                isError: result.stopReason === 'error' || result.stopReason === 'aborted' || outputLimit,
+                errors: result.errorMessage
+                    ? [result.errorMessage]
+                    : outputLimit
+                        ? ['max_output_tokens']
+                        : undefined,
+                terminalReason: result.stopReason === 'aborted'
+                    ? 'interrupted'
+                    : outputLimit
+                        ? 'max_output_tokens'
+                        : result.stopReason,
                 durationMs: Date.now() - stats.startedAt,
                 ttftMs: stats.firstTextAt ? stats.firstTextAt - stats.startedAt : undefined,
                 sessionTitle: title,
@@ -916,6 +974,7 @@ export class EcagentRunner {
             completeSent = true;
         }
         catch (error) {
+            this.finishTextBlocks(queue, stats);
             const message = error instanceof Error ? error.message : String(error);
             const interrupted = message === 'ecagent run interrupted';
             logger.error(`[EcagentRunner] run failed for session ${request.sessionId}:`, error);
@@ -948,7 +1007,11 @@ export class EcagentRunner {
         const targetId = topicBinding
             ? (requestedTopicAgentSessionId || undefined)
             : requestedId || current?.agentSessionId;
-        if (current
+        const recoverySessionId = modelOverride?.recovery?.agentSessionId;
+        if (modelOverride?.recovery && (!recoverySessionId || targetId !== recoverySessionId)) {
+            throw new Error('Task recovery requires the original ecagent session binding');
+        }
+        if (current && !recoverySessionId
             && current.projectPath === projectPath
             && (!targetId || current.agentSessionId === targetId)
             && (!topicBinding || (!!targetId && current.agentSessionId === targetId)))
@@ -959,6 +1022,9 @@ export class EcagentRunner {
         if (targetId) {
             const metadata = (await repo.list({ cwd: projectPath })).find(item => item.id === targetId);
             if (!metadata) {
+                if (recoverySessionId) {
+                    throw new Error(`Task recovery backend is unavailable: ${recoverySessionId}`);
+                }
                 if (topicBinding) {
                     const error = new Error(`bound topic backend is unavailable: ${targetId}`);
                     error.code = 'TOPIC_BACKEND_UNAVAILABLE';
@@ -979,6 +1045,9 @@ export class EcagentRunner {
                 : await repo.create({ cwd: projectPath, id: sessionId });
         }
         const metadata = await session.getMetadata();
+        if (recoverySessionId && metadata.id !== recoverySessionId) {
+            throw new Error('Task recovery cannot replace the original ecagent session');
+        }
         const runtime = { agentSessionId: metadata.id, projectPath, repo, session };
         if ((topicBinding && metadata.id !== requestedTopicAgentSessionId) || metadata.id !== targetId) {
             const turn = modelOverride?.turn;
@@ -997,6 +1066,29 @@ export class EcagentRunner {
         this.runtimes.set(sessionId, runtime);
         return runtime;
     }
+    endTextBlock(queue, stats, contentIndex, content) {
+        if (stats.textBlocks.get(contentIndex)?.ended)
+            return;
+        // Commit synchronously before enqueueing. message_end/finally may close the
+        // same block again, but cannot append or project its text a second time.
+        stats.textBlocks.set(contentIndex, { text: content, ended: true });
+        stats.text += content;
+        // Match Codex: only the completed body enters the common runner protocol.
+        queue.push({ type: 'text', text: content, turn: stats.numTurns + 1 });
+    }
+    /** Recover a missing text_end from the final message, or the received deltas. */
+    finishTextBlocks(queue, stats, message) {
+        if (message) {
+            message.content.forEach((block, index) => {
+                if (block.type === 'text')
+                    this.endTextBlock(queue, stats, index, block.text);
+            });
+        }
+        for (const [index, block] of stats.textBlocks) {
+            if (!block.ended)
+                this.endTextBlock(queue, stats, index, block.text);
+        }
+    }
     mapHarnessEvent(queue, event, stats, model, effort) {
         if (event.type === 'message_update'
             && (event.assistantMessageEvent.type === 'thinking_start'
@@ -1005,14 +1097,38 @@ export class EcagentRunner {
             queue.push({ type: 'heartbeat', source: 'reasoning', turn: stats.numTurns + 1 });
             return;
         }
-        if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
-            if (!stats.firstTextAt)
-                stats.firstTextAt = Date.now();
-            stats.text += event.assistantMessageEvent.delta;
-            queue.push({ type: 'text', text: event.assistantMessageEvent.delta, turn: stats.numTurns + 1 });
+        if (event.type === 'message_update') {
+            const update = event.assistantMessageEvent;
+            if (update.type === 'text_start') {
+                if (!stats.textBlocks.has(update.contentIndex)) {
+                    stats.textBlocks.set(update.contentIndex, { text: '', ended: false });
+                    queue.push({ type: 'text_start', contentIndex: update.contentIndex, turn: stats.numTurns + 1 });
+                }
+                return;
+            }
+            if (update.type === 'text_delta') {
+                const block = stats.textBlocks.get(update.contentIndex) ?? { text: '', ended: false };
+                if (block.ended)
+                    return;
+                if (!stats.firstTextAt)
+                    stats.firstTextAt = Date.now();
+                block.text += update.delta;
+                stats.textBlocks.set(update.contentIndex, block);
+                // Keep the stream alive without exposing partial text to the renderer.
+                queue.push({ type: 'heartbeat', source: 'text', turn: stats.numTurns + 1 });
+                return;
+            }
+            if (update.type === 'text_end') {
+                this.endTextBlock(queue, stats, update.contentIndex, update.content);
+                return;
+            }
+        }
+        if (event.type === 'message_end' && event.message.role === 'assistant') {
+            this.finishTextBlocks(queue, stats, event.message);
             return;
         }
         if (event.type === 'tool_execution_start') {
+            this.finishTextBlocks(queue, stats);
             queue.push({ type: 'tool_use', name: event.toolName, input: event.args, callId: event.toolCallId, turn: stats.numTurns + 1 });
             return;
         }
@@ -1025,6 +1141,8 @@ export class EcagentRunner {
             return;
         }
         if (event.type === 'turn_end' && event.message.role === 'assistant') {
+            this.finishTextBlocks(queue, stats, event.message);
+            stats.textBlocks.clear();
             stats.numTurns++;
             const usage = event.message.usage;
             stats.usage.input_tokens = Number(stats.usage.input_tokens ?? 0) + usage.input;
@@ -1150,13 +1268,36 @@ export class EcagentRunner {
         this.permissionContexts.get(sessionKey)?.pauseController?.cancel();
         this.permissionGateway?.cancelAll(sessionKey, 'interrupted');
         const harness = this.runtimes.get(sessionKey)?.harness;
-        if (harness) {
-            await harness.abort();
+        const runs = [...(this.sessionRuns.get(sessionKey) ?? [])];
+        for (const run of runs) {
+            if (run.cancelled)
+                continue;
+            run.cancelled = true;
+            run.queue.push({ type: 'complete', isError: true, terminalReason: 'interrupted' });
+            run.queue.end();
+        }
+        if (runs.length === 0 && !harness) {
+            const stream = this.activeStreams.get(sessionKey);
+            if (stream)
+                this.pendingInterrupts.set(sessionKey, stream);
             return;
         }
-        const stream = this.activeStreams.get(sessionKey);
-        if (stream)
-            this.pendingInterrupts.set(sessionKey, stream);
+        // Ending the event stream releases the message queue, not the durable
+        // session writer. Keep the run tail until all old code has actually exited.
+        try {
+            await withInterruptDeadline(Promise.all([
+                harness?.abort(),
+                ...runs.map(run => run.done),
+            ]), 'ecagent');
+        }
+        catch (error) {
+            logger.warn(`[EcagentRunner] Interrupted execution still requires quiescence: session=${sessionKey} error=${String(error)}`);
+        }
+    }
+    assertInterruptSettled(sessionId) {
+        if ([...(this.sessionRuns.get(sessionId) ?? [])].some(run => run.cancelled)) {
+            throw unsettledInterruptError('ecagent');
+        }
     }
     injectUserMessage(sessionId, text) {
         const harness = this.runtimes.get(sessionId)?.harness;
@@ -1169,6 +1310,7 @@ export class EcagentRunner {
         const runtime = this.runtimes.get(sessionId);
         const stream = this.activeStreams.get(sessionId);
         await this.interrupt(sessionId).catch(() => { });
+        this.assertInterruptSettled(sessionId);
         if (runtime && this.runtimes.get(sessionId) === runtime)
             this.runtimes.delete(sessionId);
         if (stream && this.activeStreams.get(sessionId) === stream) {
@@ -1183,6 +1325,7 @@ export class EcagentRunner {
         try {
             const currentRuntime = this.runtimes.get(sessionId);
             await this.interrupt(sessionId);
+            this.assertInterruptSettled(sessionId);
             const env = new NodeExecutionEnv({ cwd: projectPath });
             const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
             const metadata = (await repo.list({ cwd: path.resolve(projectPath) })).find(item => item.id === agentSessionId);
@@ -1328,6 +1471,8 @@ export class EcagentRunner {
     async dispose() {
         await Promise.allSettled([...this.runtimes.keys()].map(sessionId => this.closeSession(sessionId)));
         this.runtimes.clear();
+        this.sessionRuns.clear();
+        this.sessionRunTails.clear();
         this.activeStreams.clear();
         this.pendingInterrupts.clear();
     }

package/dist/agents/gemini-runner.js

@@ -12,6 +12,7 @@ import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js
  *   GeminiRunner  →  spawn `gemini -p ...`  →  stdout JSONL stream
  */
 import { spawn } from 'child_process';
+import { MAIN_CLI_BIN } from '../product.js';
 import { createInterface } from 'readline';
 import fs from 'fs';
 import path from 'path';
@@ -143,6 +144,10 @@ const GEMINI_EC_COMMAND_PATTERNS = [
     String.raw `\x00"command":"[ ]*ec[ ]+(?:[^"\x00;&|$()<>\x60\r\n\\]|\\(?:\\|"))*"\x00`,
 ];
 const GEMINI_BOOTSTRAP_PERSONA_COMMAND_PATTERN = String.raw `^\{\x00"command":"[ ]*ec[ ]+agent[ ]+persona(?:[ ]+show|[ ]+--(?:text|file)[ ]+(?:[^"\x00;&|$()<>\x60\r\n\\]|\\(?:\\|"))+)[ ]*"\x00\}$`;
+// A single-quoted shell argument can safely carry multiline Markdown, backticks,
+// dollar signs and semicolons. Outside that argument only --format json is legal.
+const GEMINI_WELCOME_ESCAPED_QUOTE = escapeGeminiArgsRegex(JSON.stringify("'\\''").slice(1, -1));
+const GEMINI_BOOTSTRAP_WELCOME_COMMAND_PATTERN = String.raw `^\{\x00"command":"[ ]*${escapeGeminiArgsRegex(MAIN_CLI_BIN)}[ ]+agent[ ]+welcome[ ]+(?:show|--text[ ]+'(?:[^'"\x00\\]|\\(?:\\|"|n|r|t)|${GEMINI_WELCOME_ESCAPED_QUOTE})*')(?:[ ]+--format[ ]+json)?[ ]*"\x00\}$`;
 export function resolveGeminiPermissionProfile(value, bootstrap = false) {
     if (value === 'fullaccess')
         return { mode: 'fullaccess', approvalMode: 'yolo' };
@@ -212,6 +217,7 @@ export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath, personalMd
         appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, geminiExactShellCommandPattern(`ec aid agentmd put ${bootstrap.aid}`));
         appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, geminiExactShellCommandPattern(`ec agent ready ${bootstrap.aid}`));
         appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, GEMINI_BOOTSTRAP_PERSONA_COMMAND_PATTERN);
+        appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, GEMINI_BOOTSTRAP_WELCOME_COMMAND_PATTERN);
         if (personalMdPath) {
             const personalPathPattern = geminiManagedIdentityPathPattern(personalMdPath);
             appendGeminiPolicyRule(lines, 'read_file', 'allow', 989, personalPathPattern);

package/dist/agents/runner-types.js

@@ -13,6 +13,30 @@ export class BaseagentRunnerUnavailableError extends Error {
         this.name = 'BaseagentRunnerUnavailableError';
     }
 }
+/** Codex's native asynchronous reply envelope used by its rich clients. */
+export function formatAsyncQuestionAnswer(answer) {
+    return '<send_user_message_question_reply>' + JSON.stringify({
+        questionItemId: answer.questionItemId,
+        question: answer.question,
+        answer: answer.answer,
+    }) + '</send_user_message_question_reply>';
+}
+export function parseAsyncUserQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+        throw new Error('Invalid asynchronous question list');
+    }
+    return value.map(question => {
+        if (!question || typeof question !== 'object' || typeof question.title !== 'string'
+            || !question.title.trim() || question.title.length > 16_384) {
+            throw new Error('Invalid asynchronous question title');
+        }
+        if (question.options != null && (!Array.isArray(question.options) || !question.options.length
+            || question.options.length > 20 || question.options.some((option) => typeof option !== 'string' || !option.trim() || option.length > 4_096))) {
+            throw new Error('Invalid asynchronous question options');
+        }
+        return { title: question.title, ...(question.options ? { options: [...question.options] } : {}) };
+    });
+}
 export function hasTrustedFullAccessContext(context) {
     const authorization = context?.executionPermission;
     if (!authorization
@@ -20,8 +44,10 @@ export function hasTrustedFullAccessContext(context) {
         || authorization.processRole !== 'fullaccess-run'
         || authorization.dataScope !== 'daemon')
         return false;
-    if (authorization.source === 'fullaccess-command') {
-        return typeof authorization.authorizedBy === 'string' && authorization.authorizedBy.length > 0;
+    if (authorization.source === 'fullaccess-command' || authorization.source === 'agent-policy') {
+        return typeof authorization.authorizedBy === 'string' && authorization.authorizedBy.length > 0
+            && (authorization.source !== 'agent-policy'
+                || (typeof authorization.agentAid === 'string' && authorization.agentAid.length > 0));
     }
     return authorization.source === 'trigger'
         && typeof authorization.authorizedBy === 'string' && authorization.authorizedBy.length > 0
@@ -32,6 +58,28 @@ export function hasTrustedFullAccessContext(context) {
         // being mistaken for a runnable privileged invocation.
         && typeof authorization.attemptId === 'string' && authorization.attemptId.length > 0;
 }
+/** Bounds waiting only; the caller must retain ownership until execution stops. */
+export async function withInterruptDeadline(operation, label, timeoutMs = 5_000) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${label}: interrupt deadline exceeded`)), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export function unsettledInterruptError(runner) {
+    return Object.assign(new Error(`${runner} 的上一次执行尚未确认停止，本次任务未启动；旧执行结束后可在原会话继续。`), {
+        code: 'RUNNER_INTERRUPT_UNCONFIRMED',
+    });
+}
 // ── 类型守卫 ──
 export function hasModelSwitcher(agent) {
     return typeof agent.setModel === 'function' && typeof agent.listModels === 'function';