evolcore 0.0.26 → 0.0.28

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/atomic-write.js

@@ -15,6 +15,9 @@
  */
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+import { isProcessRunning } from './cross-platform.js';
 const HOT = '_'; // foo.json_   旧版热备
 const TMP = '__'; // foo.json__  写入中
 const HOT_BACKUP_FALLBACK_CODES = new Set(['EACCES', 'ENOSYS', 'ENOTSUP', 'EPERM', 'EXDEV']);
@@ -178,3 +181,98 @@ export function atomicWriteBytes(filePath, content) {
     fs.writeFileSync(tmp, content);
     fs.renameSync(tmp, filePath);
 }
+const pauseFileWrite = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** Cross-process lock for package state. A complete owner file is linked into place atomically. */
+export async function withFileLock(file, action, timeoutMs = 30000) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const token = randomUUID();
+    const candidate = `${file}.${process.pid}.${token}.candidate`;
+    const owner = JSON.stringify({ token, pid: process.pid, host: os.hostname() });
+    fs.writeFileSync(candidate, owner, { flag: 'wx', mode: 0o600 });
+    const deadline = Date.now() + timeoutMs;
+    try {
+        while (true) {
+            try {
+                fs.linkSync(candidate, file);
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+            try {
+                const raw = fs.readFileSync(file, 'utf8');
+                const existing = JSON.parse(raw);
+                if (typeof existing.token === 'string' && /^[a-f0-9-]{36}$/.test(existing.token)
+                    && existing.host === os.hostname() && existing.pid !== process.pid
+                    && Number.isSafeInteger(existing.pid) && existing.pid > 0 && !isProcessRunning(existing.pid)
+                    && fs.readFileSync(file, 'utf8') === raw) {
+                    fs.unlinkSync(file);
+                    continue;
+                }
+            }
+            catch { /* Unknown or concurrently released owner: wait. */ }
+            if (Date.now() >= deadline)
+                throw new Error('Package state lock timed out');
+            await pauseFileWrite(40 + Math.floor(Math.random() * 20));
+        }
+        const lockIdentity = fs.statSync(file);
+        try {
+            return await action();
+        }
+        finally {
+            const releaseDeadline = Date.now() + 5000;
+            while (true) {
+                try {
+                    const current = fs.statSync(file);
+                    if (current.dev !== lockIdentity.dev || current.ino !== lockIdentity.ino) {
+                        throw new Error('Package lock ownership changed');
+                    }
+                    fs.unlinkSync(file);
+                    break;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        break;
+                    if (!['EPERM', 'EACCES', 'EBUSY'].includes(error.code ?? '')
+                        || Date.now() >= releaseDeadline)
+                        throw error;
+                    await pauseFileWrite(50);
+                }
+            }
+        }
+    }
+    finally {
+        fs.rmSync(candidate, { force: true });
+    }
+}
+/** Atomic replacement without the in-place Windows fallback used by protected config files. */
+export async function atomicReplaceJson(file, value) {
+    const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        const fd = fs.openSync(temporary, 'wx', 0o600);
+        try {
+            fs.writeFileSync(fd, JSON.stringify(value, null, 2) + '\n', 'utf8');
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        const deadline = Date.now() + 5000;
+        for (let attempt = 0;; attempt++) {
+            try {
+                fs.renameSync(temporary, file);
+                return;
+            }
+            catch (error) {
+                if (!['EPERM', 'EACCES', 'EBUSY'].includes(error.code ?? '')
+                    || Date.now() >= deadline)
+                    throw error;
+                await pauseFileWrite(Math.min(200, 25 * (attempt + 1)) + Math.floor(Math.random() * 25));
+            }
+        }
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}

package/dist/utils/cross-platform.js

@@ -6,6 +6,7 @@ import { promisify } from 'util';
 import fs from 'fs';
 import { getProcessStartTime, parseCimDate } from './process-introspect.js';
 import { decodeWindowsOutput } from './windows-output.js';
+import { resolveTrustedWindowsCmdPath } from './windows-shell-trust.js';
 const execFileAsync = promisify(execFile);
 const CLI_PROBE_FAILURE_BACKOFF_MS = 5_000;
 const CLI_PROBE_PACKAGES = {
@@ -17,9 +18,70 @@ const cliPathCache = new Map();
 const cliInstallationCache = new Map();
 const cliProbeCache = new Map();
 export const isWindows = process.platform === 'win32';
+// Keep this in sync with the Windows command-line metacharacters. The whole
+// `/c` expression is passed as one verbatim argument so paths with spaces and
+// shim-forwarded values such as `%`, `!`, `&`, and quotes stay data.
+const WINDOWS_CMD_META_RE = /([()[\]%!^"`<>&|;, *?])/g;
+function escapeWindowsCmdCommand(value) {
+    return value.replace(WINDOWS_CMD_META_RE, '^$1');
+}
+function escapeWindowsCmdArgument(value) {
+    let escaped = String(value);
+    escaped = escaped.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+    escaped = escaped.replace(/(?=(\\+?)?)\1$/g, '$1$1');
+    escaped = `"${escaped}"`;
+    return escaped.replace(WINDOWS_CMD_META_RE, '^$1');
+}
+/** Build one argv-based CLI launch without consulting the parent terminal. */
+export function buildCliLaunchCommand(executable, args, options = {}) {
+    const windows = options.isWindows ?? isWindows;
+    const extension = windows ? path.win32.extname(executable).toLowerCase() : '';
+    const shim = extension === '.cmd' || extension === '.bat';
+    if (!shim) {
+        return {
+            command: executable,
+            args,
+            resolvedPath: executable,
+            launcherKind: 'native-exe',
+            launcherPath: executable,
+        };
+    }
+    const resolveWindowsCmd = options.resolveWindowsCmd ?? resolveTrustedWindowsCmdPath;
+    const launcherPath = resolveWindowsCmd(options.comSpec);
+    if (!launcherPath) {
+        throw Object.assign(new Error('未找到受信任的系统 cmd.exe，已拒绝启动 Windows CLI shim'), {
+            code: 'EACCES',
+            path: executable,
+        });
+    }
+    const shellCommand = [
+        escapeWindowsCmdCommand(executable),
+        ...args.map(escapeWindowsCmdArgument),
+    ].join(' ');
+    return {
+        command: launcherPath,
+        args: ['/d', '/s', '/v:off', '/c', `"${shellCommand}"`],
+        resolvedPath: executable,
+        launcherKind: extension === '.cmd' ? 'cmd-shim' : 'bat-shim',
+        launcherPath,
+        windowsVerbatimArguments: true,
+    };
+}
 /** Resolve a CLI executable without spawning where/which. */
 export function resolveProbePath(command) {
-    const pathKey = `${command}\0${process.cwd()}\0${process.env.PATH ?? ''}\0${process.env.PATHEXT ?? ''}`;
+    const extensions = isWindows
+        ? (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(ext => /\.(com|exe|bat|cmd)$/i.test(ext))
+        : [''];
+    return resolveProbePathWithExtensions(command, extensions, 'executable');
+}
+/** Diagnose an incomplete npm installation without ever executing its PS1 shim. */
+export function resolvePowerShellShimPath(command) {
+    if (!isWindows)
+        return null;
+    return resolveProbePathWithExtensions(command, ['.ps1'], 'powershell-shim');
+}
+function resolveProbePathWithExtensions(command, extensions, cacheKind) {
+    const pathKey = `${cacheKind}\0${command}\0${process.cwd()}\0${process.env.PATH ?? ''}\0${extensions.join(';')}`;
     const cachedPath = cliPathCache.get(pathKey);
     if (cachedPath && fs.existsSync(cachedPath))
         return cachedPath;
@@ -27,9 +89,6 @@ export function resolveProbePath(command) {
     const directories = (process.env.PATH ?? '').split(path.delimiter);
     if (isWindows)
         directories.unshift(process.cwd());
-    const extensions = isWindows
-        ? (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(ext => /\.(com|exe|bat|cmd)$/i.test(ext))
-        : [''];
     for (const directory of directories) {
         for (const extension of extensions) {
             const candidate = path.resolve(directory.replace(/^"|"$/g, ''), command + extension);
@@ -98,20 +157,25 @@ export function invalidateCliProbes() {
 function cliProbeTimeouts(command, options) {
     return options.timeouts?.length ? options.timeouts : command === 'codex' ? [3_000, 15_000] : [3_000];
 }
-function prepareCliProbe(command, args) {
-    const executable = resolveProbePath(command);
+function prepareCliProbe(command, args, options = {}) {
+    const executable = options.executable ?? resolveProbePath(command);
     if (!executable)
         throw Object.assign(new Error(`${command} CLI not found`), { code: 'ENOENT' });
-    const identity = `${probeInstallationIdentity(command, executable)}|${process.env.ComSpec ?? ''}`;
+    const launchCommand = buildCliLaunchCommand(executable, args);
+    const launch = launchCommand;
+    const identity = `${probeInstallationIdentity(command, executable)}|${cliFileIdentity(launch.launcherPath)}`;
     const key = JSON.stringify([command, args]);
     let entry = cliProbeCache.get(key);
     if (!entry || entry.identity !== identity || (entry.retryAt !== undefined && Date.now() >= entry.retryAt)) {
         entry = { identity };
         cliProbeCache.set(key, entry);
     }
-    const shim = isWindows && /\.(cmd|bat)$/i.test(executable);
-    return { entry, command: shim ? process.env.ComSpec ?? 'cmd.exe' : executable,
-        args: shim ? ['/d', '/s', '/c', executable, ...args] : args };
+    return {
+        entry,
+        command: launchCommand.command,
+        args: launchCommand.args,
+        launch,
+    };
 }
 function failCliProbe(entry, error) {
     entry.error = error;
@@ -119,7 +183,7 @@ function failCliProbe(entry, error) {
     throw error;
 }
 export function probeCliSync(command, args, options = {}) {
-    const request = prepareCliProbe(command, args);
+    const request = prepareCliProbe(command, args, options);
     if (request.entry.output !== undefined)
         return request.entry.output;
     if (request.entry.error !== undefined)
@@ -127,10 +191,14 @@ export function probeCliSync(command, args, options = {}) {
     for (const [index, timeout] of cliProbeTimeouts(command, options).entries()) {
         const startedAt = Date.now();
         try {
-            return request.entry.output = execFileSync(request.command, request.args, { encoding: 'utf8', timeout, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+            return request.entry.output = execFileSync(request.command, request.args, {
+                encoding: 'utf8', timeout, windowsHide: true,
+                windowsVerbatimArguments: request.launch.windowsVerbatimArguments,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
         }
         catch (error) {
-            options.onFailure?.(args, startedAt, error, timeout);
+            options.onFailure?.(args, startedAt, error, timeout, request.launch);
             if (error.code !== 'ETIMEDOUT' || index === cliProbeTimeouts(command, options).length - 1)
                 return failCliProbe(request.entry, error);
         }
@@ -138,7 +206,7 @@ export function probeCliSync(command, args, options = {}) {
     throw new Error('CLI probe exhausted');
 }
 export async function probeCli(command, args, options = {}) {
-    const request = prepareCliProbe(command, args);
+    const request = prepareCliProbe(command, args, options);
     if (request.entry.output !== undefined)
         return request.entry.output;
     if (request.entry.error !== undefined)
@@ -151,7 +219,10 @@ export async function probeCli(command, args, options = {}) {
             const startedAt = Date.now();
             try {
                 const output = await new Promise((resolve, reject) => {
-                    const child = execFile(request.command, request.args, { encoding: 'utf8', timeout, windowsHide: true }, (error, stdout, stderr) => {
+                    const child = execFile(request.command, request.args, {
+                        encoding: 'utf8', timeout, windowsHide: true,
+                        windowsVerbatimArguments: request.launch.windowsVerbatimArguments,
+                    }, (error, stdout, stderr) => {
                         if (error) {
                             if (error.killed && error.signal === 'SIGTERM' && error.code == null)
                                 error.code = 'ETIMEDOUT';
@@ -166,7 +237,7 @@ export async function probeCli(command, args, options = {}) {
                 return request.entry.output = output;
             }
             catch (error) {
-                options.onFailure?.(args, startedAt, error, timeout);
+                options.onFailure?.(args, startedAt, error, timeout, request.launch);
                 if (error.code !== 'ETIMEDOUT' || index === timeouts.length - 1)
                     return failCliProbe(request.entry, error);
             }

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-utils.js

@@ -3,6 +3,27 @@ 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) {
@@ -288,7 +309,15 @@ 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;
@@ -346,11 +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)
@@ -366,6 +399,8 @@ 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），本轮未完成。`
@@ -395,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':
@@ -407,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.
@@ -429,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 查看当前配置`;

package/dist/utils/logger.js

@@ -3,7 +3,7 @@ import { resolvePaths } from '../paths.js';
 import { LogWriter } from './log-writer.js';
 import { classifyToolErrorCode, normalizeToolErrorCode } from '../core/permission/tool-error-code.js';
 import { normalizePermissionMode } from '../core/permission/mode.js';
-import { buildToolLifecycleEventKey } from '../core/audit/event-key.js';
+import { buildToolLifecycleEventKey, normalizeToolCorrelation } from '../core/audit/event-key.js';
 let currentLevel = process.env.LOG_LEVEL || 'INFO';
 const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
 const config = {
@@ -53,8 +53,18 @@ export function normalizeStructuredLog(data) {
     const nested = data.event && typeof data.event === 'object' ? data.event : undefined;
     const eventType = data.type ?? nested?.type;
     const eventKey = data.eventKey ?? data.event_key ?? nested?.eventKey ?? nested?.event_key;
-    const eventPhase = data.eventPhase ?? data.event_phase ?? nested?.eventPhase ?? nested?.event_phase;
-    const correlationId = data.correlationId
+    const isToolResult = eventType === 'tool:result' || eventType === 'tool_result';
+    const isToolUse = eventType === 'tool:use' || eventType === 'tool_use';
+    const lifecycleRecord = isToolUse || isToolResult;
+    const eventPhase = data.eventPhase ?? data.event_phase ?? nested?.eventPhase ?? nested?.event_phase
+        ?? (isToolUse ? 'use' : isToolResult ? 'result' : undefined);
+    const toolCorrelation = normalizeToolCorrelation({
+        callId: data.callId ?? data.call_id ?? data.toolUseId ?? data.tool_use_id
+            ?? nested?.callId ?? nested?.call_id ?? nested?.toolUseId ?? nested?.tool_use_id,
+        correlationId: data.correlationId ?? data.correlation_id ?? nested?.correlationId ?? nested?.correlation_id,
+        requestId: data.requestId ?? data.request_id ?? nested?.requestId ?? nested?.request_id,
+    });
+    const correlationId = lifecycleRecord ? toolCorrelation.correlationId : data.correlationId
         ?? data.correlation_id
         ?? data.callId
         ?? data.call_id
@@ -69,7 +79,9 @@ export function normalizeStructuredLog(data) {
         ?? nested?.callId
         ?? nested?.call_id
         ?? nested?.toolUseId
-        ?? nested?.tool_use_id;
+        ?? nested?.tool_use_id
+        ?? nested?.requestId
+        ?? nested?.request_id;
     const sessionId = data.sessionId ?? data.session_id ?? nested?.sessionId ?? nested?.session_id;
     const agentAid = data.agentAid ?? data.agent_aid ?? data.selfAid ?? nested?.agentAid ?? nested?.agent_aid ?? nested?.selfAid;
     const rawAgentName = data.agentName ?? data.agent_name ?? nested?.agentName ?? nested?.agent_name;
@@ -91,18 +103,17 @@ export function normalizeStructuredLog(data) {
         ? normalizePermissionMode(rawPermissionMode).mode
         : rawPermissionMode;
     const toolName = data.toolName ?? data.tool ?? data.name ?? nested?.toolName ?? nested?.name;
-    const isToolResult = eventType === 'tool:result' || eventType === 'tool_result';
-    const isToolUse = eventType === 'tool:use' || eventType === 'tool_use';
     const isError = data.isError ?? data.is_error ?? (data.ok === false ? true : undefined)
         ?? nested?.isError ?? nested?.is_error ?? (nested?.ok === false ? true : undefined);
     const decisionSource = data.decisionSource ?? data.decision_source
-        ?? nested?.decisionSource ?? nested?.decision_source;
+        ?? nested?.decisionSource ?? nested?.decision_source
+        ?? (lifecycleRecord ? 'runner' : undefined);
     const decision = data.decision
+        ?? nested?.decision
         ?? data.status
         ?? (isToolResult && isError === true ? 'error' : undefined)
         ?? (isToolResult && isError === false ? 'allow' : undefined)
-        ?? (isToolUse ? 'started' : undefined)
-        ?? nested?.decision;
+        ?? (isToolUse ? 'pending' : undefined);
     const executed = data.executed ?? nested?.executed
         ?? (isToolResult ? true : isToolUse ? false : undefined);
     const executionState = data.executionState ?? data.execution_state
@@ -118,13 +129,10 @@ export function normalizeStructuredLog(data) {
     const classificationMissing = isToolResult && isError === true
         && !normalizeToolErrorCode(explicitErrorCode)
         && decisionSource !== 'policy' && decisionSource !== 'approval';
-    const lifecycleRecord = isToolUse || isToolResult;
     const lifecycleEventKey = lifecycleRecord
         ? (eventKey ?? buildToolLifecycleEventKey({
             sessionId,
-            callId: data.callId ?? data.call_id ?? data.toolUseId ?? data.tool_use_id ?? nested?.callId ?? nested?.call_id,
-            correlationId: data.correlationId ?? data.correlation_id ?? nested?.correlationId ?? nested?.correlation_id,
-            requestId: data.requestId ?? data.request_id ?? nested?.requestId ?? nested?.request_id,
+            ...toolCorrelation,
         }))
         : undefined;
     const missingContextFields = lifecycleRecord
@@ -134,6 +142,8 @@ export function normalizeStructuredLog(data) {
         ...data,
         ...(lifecycleEventKey ? { eventKey: lifecycleEventKey } : {}),
         ...(eventPhase ? { eventPhase } : {}),
+        ...(lifecycleRecord ? toolCorrelation : {}),
+        ...(lifecycleRecord && !toolCorrelation.callId ? { correlationMissing: true } : {}),
         ...(correlationId ? { correlationId } : {}),
         ...(sessionId ? { sessionId } : lifecycleRecord ? { sessionId: 'unknown' } : {}),
         ...(agentAid ? { agentAid } : lifecycleRecord ? { agentAid: 'unknown' } : {}),