evolcore 0.0.25 → 0.0.27

package/dist/trigger/scheduler.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import { CronExpressionParser } from 'cron-parser';
 import { logger } from '../utils/logger.js';
 import { matchTriggerEvent, TriggerEventSource } from './event-source.js';
-import { definitionRevision, parseDurationMs, previewText, renderTemplate, resolveScriptPath, sha256, validateConcurrencyCombination, } from './validation.js';
+import { definitionRevision, executionTimeoutMs, parseDurationMs, previewText, renderTemplate, resolveScriptPath, sha256, validateConcurrencyCombination, } from './validation.js';
 import { TargetSessionLockRegistry } from './session-lock.js';
 import { enterTrigger, formatTriggerPath } from '../core/causation/context.js';
 import { createRootCausation } from '../core/causation/context.js';
@@ -13,6 +13,13 @@ const MAX_TIMER_MS = 2_147_483_647;
 const RUN_ABORT_SETTLE_GRACE_MS = 1_000;
 const RUN_COMPLETION_BARRIER_MS = 1_500;
 const TRIGGER_RESTART_RESUME_PROMPT = 'EvolCore 服务已重启。请基于当前会话记录继续完成刚才被中断的 Trigger 任务；不要重新从头执行已经完成的步骤。';
+function eventSessionKey(payload, fallbackAgentAid) {
+    const agentAid = typeof payload.agentAid === 'string' && payload.agentAid.trim()
+        ? payload.agentAid.trim()
+        : fallbackAgentAid;
+    const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : '';
+    return `${agentAid}:${sessionId}`;
+}
 export class TriggerRuntimeScheduler {
     manager;
     state;
@@ -818,6 +825,7 @@ export class TriggerRuntimeScheduler {
                 attemptId: `${runId}:attempt:${attempt}`,
                 firedAt,
                 prompt,
+                sourcePayload,
                 dryRun,
                 causation,
                 signal,
@@ -869,7 +877,17 @@ export class TriggerRuntimeScheduler {
                 + ` model=${definition.execution.model ?? '<agent-default>'}`
                 + ` effort=${definition.execution.effort ?? '<agent-default>'}`);
             const attemptId = `${runId}:attempt:${attempt}`;
-            const executionDeadlineAt = this.daemonExecutionDeadlineAt(Date.now());
+            const executionStartedAt = Date.now();
+            const configuredExecutionTimeout = executionTimeoutMs(definition.execution);
+            const daemonExecutionDeadlineAt = this.daemonExecutionDeadlineAt(executionStartedAt);
+            const configuredExecutionDeadlineAt = configuredExecutionTimeout === undefined
+                ? undefined
+                : executionStartedAt + configuredExecutionTimeout;
+            const executionDeadlineAt = daemonExecutionDeadlineAt === undefined
+                ? configuredExecutionDeadlineAt
+                : configuredExecutionDeadlineAt === undefined
+                    ? daemonExecutionDeadlineAt
+                    : Math.min(daemonExecutionDeadlineAt, configuredExecutionDeadlineAt);
             const executionSession = await this.daemonChannel.getOrCreateConversationSession(definition, this.runtime.projectPath, runtimeBaseagent, runId, attemptId);
             const activeRun = this.state.startExecutionAttempt?.(definition.id, runId, {
                 attempt,
@@ -963,7 +981,13 @@ export class TriggerRuntimeScheduler {
         });
     }
     async checkConcurrency(definition, nextRunId, source) {
-        const runs = this.running.get(definition.id);
+        const allRuns = this.running.get(definition.id);
+        // An event-session trigger owns many independent sessions. Forbid/replace
+        // applies within the source session, so one failure cannot suppress another.
+        const runs = definition.feedback.strategy === 'event_session' && allRuns
+            ? new Map([...allRuns].filter(([, runtime]) => eventSessionKey(runtime.source.payload, definition.agentAid)
+                === eventSessionKey(source.payload, definition.agentAid)))
+            : allRuns;
         if (!runs || runs.size === 0 || definition.reliability.concurrency === 'allow')
             return undefined;
         const first = runs.values().next().value;
@@ -1753,7 +1777,7 @@ export class TriggerRuntimeScheduler {
     publishTriggerRunOutcome(definition, audit) {
         if (!this.eventBus || audit.status === 'dry-run')
             return;
-        const target = primaryTarget(definition);
+        const target = audit.feedback?.target ?? primaryTarget(definition);
         const targetChannel = target?.channelKey ?? 'daemon';
         const targetChannelId = target?.channelId ?? definition.agentAid;
         const base = {
@@ -2027,6 +2051,8 @@ function summarizeReply(reply, opts = {}) {
 function primaryTarget(definition) {
     if (definition.feedback.strategy === 'target')
         return definition.feedback.target;
+    if (definition.feedback.strategy === 'event_session')
+        return undefined;
     if (!definition.origin)
         return undefined;
     return {

package/dist/trigger/validation.js

@@ -3,6 +3,8 @@ import crypto from 'crypto';
 import { normalizePermissionMode as normalizePermissionModeContract } from '../core/permission/mode.js';
 import { formatChannelKey } from '../core/channel-loader.js';
 const MAX_SCRIPT_TIMEOUT_MS = 900_000;
+const TRIGGER_SESSION_TIMEOUT_MS = 30 * 60_000;
+const MAX_EXECUTION_TIMEOUT_MS = 2_147_483_647;
 export const TRIGGER_SCHEMA_VERSION = 3.1;
 const LEGACY_TRIGGER_SCHEMA_VERSION = 4;
 const DEFAULT_NOOP_SENTINEL = '[[NOOP]]';
@@ -35,7 +37,7 @@ export function normalizeTriggerDefinition(input, opts = {}) {
  * channelId shape inference at runtime.
  */
 export function assertExplicitAunDeliveryRoutes(definition) {
-    if (definition.feedback.strategy === 'silent')
+    if (definition.feedback.strategy === 'silent' || definition.feedback.strategy === 'event_session')
         return;
     const target = definition.feedback.strategy === 'target'
         ? definition.feedback.target
@@ -58,6 +60,11 @@ export function assertExplicitAunDeliveryRoutes(definition) {
 export function validateTriggerDefinition(definition) {
     normalizeTriggerDefinition(definition);
 }
+/** Resolve a model-backed attempt's deadline; target sessions are unlimited by default. */
+export function executionTimeoutMs(execution) {
+    return execution.timeoutMs ?? (execution.type === 'target_session'
+        ? undefined : TRIGGER_SESSION_TIMEOUT_MS);
+}
 /**
  * Keep legacy `per_run` definitions byte-stable while giving runtime code one
  * canonical representation for session selection and validation.
@@ -428,8 +435,14 @@ function normalizeExecution(value, _opts) {
         throw new Error('execution.type must be script, trigger_session, or target_session');
     }
     const thread = normalizeExecutionThread(raw.thread);
+    if (raw.timeoutMs !== undefined && (type === 'script'
+        || typeof raw.timeoutMs !== 'number' || !Number.isSafeInteger(raw.timeoutMs)
+        || raw.timeoutMs <= 0 || raw.timeoutMs > MAX_EXECUTION_TIMEOUT_MS)) {
+        throw new Error('execution.timeoutMs must be an integer between 1 and 2147483647 for a model-backed Trigger');
+    }
     const execution = {
         type,
+        ...(raw.timeoutMs !== undefined ? { timeoutMs: raw.timeoutMs } : {}),
         prompt: type === 'script' ? optionalString(raw.prompt) : requiredString(raw.prompt, 'execution.prompt'),
         script: type === 'script' ? normalizeScript(raw.script) : undefined,
         thread: type === 'trigger_session' ? (thread ?? 'by_trigger') : thread,
@@ -511,8 +524,8 @@ function normalizeFeedback(value, agentAid) {
         throw new Error('feedback must be an object');
     const raw = value;
     const strategy = requiredString(raw.strategy, 'feedback.strategy');
-    if (strategy !== 'origin' && strategy !== 'target' && strategy !== 'silent') {
-        throw new Error('feedback.strategy must be origin, target, or silent');
+    if (strategy !== 'origin' && strategy !== 'target' && strategy !== 'event_session' && strategy !== 'silent') {
+        throw new Error('feedback.strategy must be origin, target, event_session, or silent');
     }
     return {
         strategy,
@@ -630,6 +643,10 @@ function normalizeOnError(value) {
 }
 function validateTriggerSemantics(definition) {
     const execution = definition.execution;
+    if (definition.feedback.strategy === 'event_session'
+        && (definition.source.type !== 'event' || execution.type !== 'target_session')) {
+        throw new Error('feedback.strategy=event_session requires an event source and target_session execution');
+    }
     if (execution.type === 'script') {
         if (!execution.script)
             throw new Error('execution.script is required when execution.type=script');

package/dist/utils/cross-platform.js

@@ -449,7 +449,10 @@ export function resolveCliEntry(packageRoot) {
         try {
             const require = createRequire(path.join(packageRoot, 'package.json'));
             const tsxUrl = pathToFileURL(require.resolve('tsx')).href;
-            return { args: ['--import', tsxUrl, sourceEntry], usingSource: true, entry: sourceEntry };
+            const imports = process.platform === 'win32'
+                ? ['--import', 'data:text/javascript,globalThis.process.geteuid=()=>-1', '--import', tsxUrl]
+                : ['--import', tsxUrl];
+            return { args: [...imports, sourceEntry], usingSource: true, entry: sourceEntry };
         }
         catch {
             // tsx missing (e.g. `npm prune --production`): fall through to dist.
@@ -488,11 +491,37 @@ export function encodePath(projectPath) {
 /**
  * Cross-platform process liveness check.
  */
+function readLinuxProcessState(pid) {
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        // The comm field may contain ')', so use the final closing parenthesis.
+        const closeParen = stat.lastIndexOf(')');
+        if (closeParen < 0)
+            return null;
+        return stat.slice(closeParen + 2, closeParen + 3) || null;
+    }
+    catch {
+        // Keep the kill(0) fallback below for permission and procfs races.
+        return null;
+    }
+}
+/** Return the Linux proc state (for example Z, D, S, or R), when available. */
+export function getProcessState(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    return readLinuxProcessState(pid);
+}
 export function isProcessRunning(pid) {
     if (!Number.isInteger(pid) || pid <= 0)
         return false;
     if (isWindows)
         return isWindowsProcessRunning(pid);
+    // A zombie has exited; only its unreaped process-table entry remains.  A
+    // kill(pid, 0) probe alone reports such an entry as alive on Linux.
+    if (readLinuxProcessState(pid) === 'Z')
+        return false;
     try {
         process.kill(pid, 0);
         return true;

package/dist/utils/ecweb-utils.js

@@ -70,6 +70,7 @@ export async function fetchRemotePairingCode(authorizedBy) {
     try {
         const response = await ipcQuery(resolvePaths().socket, {
             type: 'remote-auth.pair-code',
+            source: 'host-cli',
             ...(authorizedBy?.trim() ? { authorizedBy: authorizedBy.trim() } : {}),
         }, 2_000);
         if (!response?.ok || typeof response.code !== 'string' || typeof response.expiresAt !== 'number')

package/dist/utils/error-dict.json

@@ -1,160 +1,160 @@
-{
-  "rules": [
-    {
-      "id": "context-too-long-cn",
-      "match": "上下文过长",
-      "action": "stop",
-      "type": "context_too_long",
-      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
-    },
-    {
-      "id": "context-too-long-en",
-      "match": "context too long",
-      "action": "stop",
-      "type": "context_too_long",
-      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
-    },
-    {
-      "id": "prompt-too-long",
-      "match": "prompt is too long",
-      "action": "stop",
-      "type": "context_too_long",
-      "message": "⚠️ 输入过长，请精简提问或使用 /compact 压缩上下文"
-    },
-    {
-      "id": "invalid-api-key",
-      "match": "invalid api key",
-      "action": "stop",
-      "type": "auth_error",
-      "message": "❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置"
-    },
-    {
-      "id": "key-not-found",
-      "match": "key_not_found",
-      "action": "stop",
-      "type": "auth_error",
-      "message": "❌ API Key 未找到，请检查密钥配置"
-    },
-    {
-      "id": "api-key-verifier-too-many-connections",
-      "match": "error 1040 (08004): too many connections",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ API 服务繁忙，请稍后重试"
-    },
-    {
-      "id": "credit-query-timeout",
-      "match": "积分查询超时",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ 积分查询超时，请稍后重试"
-    },
-    {
-      "id": "capacity-pool-switching-cn",
-      "match": "算力池切换",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ 当前算力池切换中，请稍后重试"
-    },
-    {
-      "id": "retry-attempt-stalled",
-      "match": "retry_attempt_stalled",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ API 重试调用长时间无响应"
-    },
-    {
-      "id": "selected-model-at-capacity",
-      "match": "selected model is at capacity",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ 当前模型繁忙，请稍后重试"
-    },
-    {
-      "id": "api-error-400",
-      "match": "api error: 400",
-      "action": "stop",
-      "type": "api_error",
-      "message": "❌ 请求格式错误，请检查输入内容"
-    },
-    {
-      "id": "model-not-supported-403",
-      "match": "api error: 403 不支持该模型",
-      "action": "stop",
-      "type": "model_unavailable",
-      "message": "❌ 当前模型不受支持，请正确配置模型后重试"
-    },
-    {
-      "id": "api-error-403",
-      "match": "api error: 403",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ API 访问受限，请稍后重试"
-    },
-    {
-      "id": "api-error-429",
-      "match": "api error: 429",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ 请求过于频繁，请稍后重试"
-    },
-    {
-      "id": "api-error-500",
-      "match": "api error: 500",
-      "action": "retry",
-      "type": "api_error",
-      "message": "❌ API 服务暂时不可用，请稍后重试"
-    },
-    {
-      "id": "api-error-502",
-      "match": "api error: 502",
-      "action": "retry",
-      "type": "api_error"
-    },
-    {
-      "id": "api-error-503",
-      "match": "api error: 503",
-      "action": "retry",
-      "type": "api_error"
-    },
-    {
-      "id": "api-error-504",
-      "match": "api error: 504",
-      "action": "retry",
-      "type": "api_error"
-    },
-    {
-      "id": "not-valid-json",
-      "match": "is not valid json",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ API 返回异常响应，请稍后重试"
-    },
-    {
-      "id": "json-parse-error",
-      "match": "json parse error",
-      "action": "retry",
-      "type": "api_error",
-      "message": "⚠️ API 返回 JSON 解析异常，请稍后重试"
-    },
-    {
-      "id": "feishu-permission",
-      "match": "im:resource",
-      "action": "stop",
-      "type": "unknown",
-      "message": "❌ 权限不足，请联系管理员配置应用权限"
-    },
-    {
-      "id": "stream-error",
-      "match": "stream",
-      "action": "retry",
-      "type": "stream_error"
-    },
-    {
-      "id": "request-aborted",
-      "match": "request was aborted",
-      "action": "ignore",
-      "type": "stream_error"
-    }
-  ]
-}
+{
+  "rules": [
+    {
+      "id": "context-too-long-cn",
+      "match": "上下文过长",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
+    },
+    {
+      "id": "context-too-long-en",
+      "match": "context too long",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
+    },
+    {
+      "id": "prompt-too-long",
+      "match": "prompt is too long",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 输入过长，请精简提问或使用 /compact 压缩上下文"
+    },
+    {
+      "id": "invalid-api-key",
+      "match": "invalid api key",
+      "action": "stop",
+      "type": "auth_error",
+      "message": "❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置"
+    },
+    {
+      "id": "key-not-found",
+      "match": "key_not_found",
+      "action": "stop",
+      "type": "auth_error",
+      "message": "❌ API Key 未找到，请检查密钥配置"
+    },
+    {
+      "id": "api-key-verifier-too-many-connections",
+      "match": "error 1040 (08004): too many connections",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 服务繁忙，请稍后重试"
+    },
+    {
+      "id": "credit-query-timeout",
+      "match": "积分查询超时",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 积分查询超时，请稍后重试"
+    },
+    {
+      "id": "capacity-pool-switching-cn",
+      "match": "算力池切换",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 当前算力池切换中，请稍后重试"
+    },
+    {
+      "id": "retry-attempt-stalled",
+      "match": "retry_attempt_stalled",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 重试调用长时间无响应"
+    },
+    {
+      "id": "selected-model-at-capacity",
+      "match": "selected model is at capacity",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 当前模型繁忙，请稍后重试"
+    },
+    {
+      "id": "api-error-400",
+      "match": "api error: 400",
+      "action": "stop",
+      "type": "api_error",
+      "message": "❌ 请求格式错误，请检查输入内容"
+    },
+    {
+      "id": "model-not-supported-403",
+      "match": "api error: 403 不支持该模型",
+      "action": "stop",
+      "type": "model_unavailable",
+      "message": "❌ 当前模型不受支持，请正确配置模型后重试"
+    },
+    {
+      "id": "api-error-403",
+      "match": "api error: 403",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 访问受限，请稍后重试"
+    },
+    {
+      "id": "api-error-429",
+      "match": "api error: 429",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 请求过于频繁，请稍后重试"
+    },
+    {
+      "id": "api-error-500",
+      "match": "api error: 500",
+      "action": "retry",
+      "type": "api_error",
+      "message": "❌ API 服务暂时不可用，请稍后重试"
+    },
+    {
+      "id": "api-error-502",
+      "match": "api error: 502",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "api-error-503",
+      "match": "api error: 503",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "api-error-504",
+      "match": "api error: 504",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "not-valid-json",
+      "match": "is not valid json",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 返回异常响应，请稍后重试"
+    },
+    {
+      "id": "json-parse-error",
+      "match": "json parse error",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 返回 JSON 解析异常，请稍后重试"
+    },
+    {
+      "id": "feishu-permission",
+      "match": "im:resource",
+      "action": "stop",
+      "type": "unknown",
+      "message": "❌ 权限不足，请联系管理员配置应用权限"
+    },
+    {
+      "id": "stream-error",
+      "match": "stream",
+      "action": "retry",
+      "type": "stream_error"
+    },
+    {
+      "id": "request-aborted",
+      "match": "request was aborted",
+      "action": "ignore",
+      "type": "stream_error"
+    }
+  ]
+}

package/dist/utils/error-utils.js

@@ -3,7 +3,36 @@ import path from 'path';
 import { getPackageRoot, resolvePaths } from '../paths.js';
 import { logger } from './logger.js';
 import { isSandboxInitializationFailure } from '../core/permission/sandbox-runtime.js';
+/** A deadline imposed by an outer executor, handled by the ordinary task timeout path. */
+export class ExecutionTimeoutError extends Error {
+    reason;
+    timeoutMs;
+    constructor(reason, timeoutMs) {
+        super('TOTAL_EXECUTION_TIMEOUT');
+        this.reason = reason;
+        this.timeoutMs = timeoutMs;
+        this.name = 'ExecutionTimeoutError';
+    }
+}
+export class OrphanedTargetSessionError extends Error {
+    reason = 'orphaned_target_session';
+    constructor() {
+        super('ORPHANED_TARGET_SESSION');
+        this.name = 'OrphanedTargetSessionError';
+    }
+}
+export function isExecutionFailure(error) {
+    return error instanceof ExecutionTimeoutError || error instanceof OrphanedTargetSessionError;
+}
 export const CLAUDE_STARTUP_ARGUMENTS_TOO_LONG = 'claude_startup_arguments_too_long';
+/** A completed provider response exhausted its output budget, rather than a transport failure. */
+export function isOutputTokenLimitError(error) {
+    const record = error && typeof error === 'object' ? error : undefined;
+    const message = String(record?.message ?? error ?? '');
+    return record?.code === 'max_output_tokens'
+        || /^\s*max_output_tokens\s*$/i.test(message)
+        || /\breason["']?\s*[:=]\s*["']?max_output_tokens\b/i.test(message);
+}
 /** Identify a Claude process-start failure without treating ordinary tool errors as startup failures. */
 export function isClaudeStartupArgumentsTooLong(error) {
     const code = error && typeof error === 'object' && 'code' in error
@@ -36,6 +65,7 @@ export var ErrorType;
     ErrorType["AUTH_ERROR"] = "auth_error";
     ErrorType["FILE_CORRUPT"] = "file_corrupt";
     ErrorType["STREAM_ERROR"] = "stream_error";
+    ErrorType["MAX_OUTPUT_TOKENS"] = "max_output_tokens";
     ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
     ErrorType["MODEL_UNAVAILABLE"] = "model_unavailable";
     ErrorType["SESSION_UNAVAILABLE"] = "session_unavailable";
@@ -78,6 +108,7 @@ const NON_INFRA_SUBTYPES = new Set([
     'stop',
 ]);
 const NON_INFRA_TERMINAL_REASONS = new Set([
+    'max_output_tokens',
     'rapid_refill_breaker',
     'tool_deferred',
     'stop_hook_prevented',
@@ -278,7 +309,18 @@ function hasRetryableHttpStatus(text) {
     return RETRYABLE_HTTP_STATUS_PATTERN.test(text);
 }
 export function classifyError(error) {
+    if (error?.code === 'RUNNER_INTERRUPT_UNCONFIRMED')
+        return ErrorType.SESSION_UNAVAILABLE;
     const msg = (error?.message || '').toLowerCase();
+    // A damaged ecagent JSONL transcript is deterministic local state. Retrying
+    // the provider request cannot repair it and can append more entries to the
+    // same unusable file.
+    if (msg.includes('invalid jsonl session file') || msg.includes('invalid session file')) {
+        return ErrorType.SESSION_UNAVAILABLE;
+    }
+    // The broad dictionary rule for "stream" must not hide a provider budget limit.
+    if (isOutputTokenLimitError(error))
+        return ErrorType.MAX_OUTPUT_TOKENS;
     if (error?.code === 'TOPIC_BACKEND_UNAVAILABLE') {
         return ErrorType.SESSION_UNAVAILABLE;
     }
@@ -333,8 +375,15 @@ export function classifyError(error) {
  * 注意：401 认证错误不可重试（API Key 无效不会因重试恢复）
  */
 export function isRetryableError(error) {
+    if (error?.code === 'RUNNER_INTERRUPT_UNCONFIRMED')
+        return false;
+    // Replaying the same request does not increase its output budget.
+    if (isOutputTokenLimitError(error))
+        return false;
     const msg = error?.message || String(error);
     const lower = msg.toLowerCase();
+    if (lower.includes('invalid jsonl session file') || lower.includes('invalid session file'))
+        return false;
     // 字典优先 — 命中则直接返回
     const rule = matchErrorRule(lower);
     if (rule)
@@ -350,6 +399,13 @@ export function isRetryableError(error) {
     return false;
 }
 export function getErrorMessage(error, terminalReason, includeEmoji = true) {
+    if (error?.code === 'RUNNER_INTERRUPT_UNCONFIRMED')
+        return `${includeEmoji ? '⚠️ ' : ''}${error.message}`;
+    if (terminalReason === 'max_output_tokens' || isOutputTokenLimitError(error)) {
+        const prefix = includeEmoji ? '⚠️ ' : '';
+        return `${prefix}模型响应达到输出上限（max_output_tokens），本轮未完成。`
+            + '请降低推理强度或提高模型服务的输出预算，然后在原会话发送“继续，先核对已完成操作，只完成剩余工作”；无需重发原任务。';
+    }
     if (isClaudeStartupArgumentsTooLong(error)) {
         const prefix = includeEmoji ? '⚠️ ' : '';
         return `${prefix}当前 Claude 启动参数过长，任务未执行`;
@@ -374,7 +430,7 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
             case 'permission_denied':
                 return `${prefix}权限被拒绝，操作已取消`;
             case 'sandbox_initialization_failed':
-                return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
+                return `${warnPrefix}执行沙箱启动失败（sandbox_initialization_failed），当前操作未执行；请检查文件系统挂载规则及 user namespace/seccomp 配置`;
             case 'claude_startup_arguments_too_long':
                 return `${warnPrefix}当前 Claude 启动参数过长，任务未执行`;
             case 'aborted_streaming':
@@ -386,6 +442,9 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
     const msg = error?.message || String(error);
     const warnPrefix = includeEmoji ? '⚠️ ' : '';
     const errPrefix = includeEmoji ? '❌ ' : '';
+    if (/invalid (?:jsonl )?session file/i.test(msg)) {
+        return `${errPrefix}ecagent 会话文件损坏，已停止自动重试；请使用 /repair 或 /new 恢复会话`;
+    }
     // Codex app-server reports this when another app-server still owns the
     // thread writer. Surface the handoff condition instead of hiding it behind
     // the generic "processing failed" message.
@@ -408,7 +467,7 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
             : `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
     }
     if (isSandboxInitializationFailure(error)) {
-        return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
+        return `${warnPrefix}执行沙箱启动失败（sandbox_initialization_failed），当前操作未执行；请检查文件系统挂载规则及 user namespace/seccomp 配置`;
     }
     if (msg.includes('401') || msg.includes('authentication_error') || msg.toLowerCase().includes('unauthorized')) {
         return `${errPrefix}API Key 无效，请检查密钥配置。使用 /status 查看当前配置`;