evolcore 0.0.5 → 0.0.7

package/dist/paths.js

@@ -25,15 +25,19 @@ export function _resetRoot() {
 }
 export function resolvePaths() {
     const root = resolveRoot();
+    const agentsDir = path.join(root, 'agents');
     return {
         root,
-        sessionsDir: path.join(root, 'data', 'sessions'),
+        // Session storage is partitioned by owning Agent. Keep the historical
+        // location separately so the explicit data migration can inventory it.
+        sessionsDir: agentsDir,
+        legacySessionsDir: path.join(root, 'data', 'sessions'),
         instanceDir: path.join(root, 'data', 'instance'),
         outboxDir: path.join(root, 'data', 'outbox'),
         dataDir: path.join(root, 'data'),
         claudeModelCache: path.join(root, 'data', 'claude-model-cache.json'),
         logs: path.join(root, 'logs'),
-        agentsDir: path.join(root, 'agents'),
+        agentsDir,
         lineStats: path.join(root, 'logs', 'line-stats.log'),
         readySignal: path.join(root, 'data', 'instance', 'ready.signal'),
         controlToken: path.join(root, 'data', 'instance', 'control.token'),
@@ -126,8 +130,36 @@ export function agentDataDir(aid) {
 export function agentDataCacheDir(aid) {
     return path.join(agentDataDir(aid), 'cache');
 }
+export function agentHandoffDir(aid) {
+    return path.join(agentDataDir(aid), 'handoff');
+}
+export function agentOutboxPath(aid) {
+    return path.join(agentDataDir(aid), 'outbox.jsonl');
+}
+/** Directory-safe channel instance key used by connector runtime state. */
+function encodePathKey(value) {
+    return encodeURIComponent(value);
+}
+export function daemonDataDir() {
+    return path.join(resolveRoot(), 'data', 'daemon');
+}
+export function daemonControlDir() {
+    return path.join(daemonDataDir(), 'control');
+}
+export function daemonQueuePath() {
+    return path.join(daemonDataDir(), 'message-queue.json');
+}
+export function channelStateDir(channelKey) {
+    if (!channelKey || channelKey === '.' || channelKey === '..') {
+        throw new Error('channelKey is required');
+    }
+    return path.join(resolveRoot(), 'data', 'channel-state', encodePathKey(channelKey));
+}
+export function channelStatePath(channelKey, ...parts) {
+    return path.join(channelStateDir(channelKey), ...parts);
+}
 export function agentTriggersDir(aid) {
-    return path.join(resolveRoot(), 'data', 'triggers', aid);
+    return path.join(agentDir(aid), 'triggers');
 }
 function resolveInstanceSocketPath(root) {
     if (isWindows) {
@@ -147,7 +179,6 @@ export function ensureDataDirs() {
     fs.mkdirSync(p.outboxDir, { recursive: true });
     fs.mkdirSync(p.eckDir, { recursive: true });
     fs.mkdirSync(aidsDir(), { recursive: true });
-    seedConfigTemplates();
     migrateFromAun();
 }
 const MIGRATION_MARKER = '.migrated-from-aun';
@@ -211,29 +242,6 @@ function migrateFromAun() {
     }
     catch { }
 }
-/**
- * 首次运行时从 assets/ 模板拷贝 .env 到 $EVOLCORE_HOME。
- * 已存在则跳过，不覆盖用户修改。
- */
-function seedConfigTemplates() {
-    const root = resolveRoot();
-    const assetsDir = path.join(getPackageRoot(), 'assets');
-    const templates = [
-        { src: '.env.template', dst: '.env' },
-    ];
-    for (const { src, dst } of templates) {
-        const dstPath = path.join(root, dst);
-        if (fs.existsSync(dstPath))
-            continue;
-        const srcPath = path.join(assetsDir, src);
-        if (!fs.existsSync(srcPath))
-            continue;
-        try {
-            fs.copyFileSync(srcPath, dstPath);
-        }
-        catch { /* best-effort */ }
-    }
-}
 // ── kits 路径（始终从包内读取，不复制到 EVOLCORE_HOME）──
 export function kitsDir() {
     return path.join(getPackageRoot(), 'kits');

package/dist/trigger/feedback.js

@@ -69,6 +69,7 @@ export class TriggerFeedbackDispatcher {
         const deadlineTimer = setTimeout(() => abortDelivery('timeout', new Error(`target session timed out after ${TARGET_SESSION_DEADLINE_MS}ms`)), TARGET_SESSION_DEADLINE_MS);
         deadlineTimer.unref?.();
         let outcome;
+        let releaseSessionLock;
         try {
             if (delivery.signal.aborted) {
                 const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, false);
@@ -128,6 +129,20 @@ export class TriggerFeedbackDispatcher {
                 }
                 return this.failed(feedback, [], 'session_error', err?.message || String(err));
             }
+            if (input.onSessionResolved) {
+                const access = await input.onSessionResolved(session);
+                if (access.kind === 'conflict') {
+                    return {
+                        status: 'skipped',
+                        reason: 'concurrency_forbid',
+                        conflictRunId: access.conflictRunId,
+                        feedback,
+                        effects: [],
+                        error: null,
+                    };
+                }
+                releaseSessionLock = access.release;
+            }
             const message = {
                 channel: target.channelKey,
                 channelType,
@@ -241,6 +256,7 @@ export class TriggerFeedbackDispatcher {
             }
         }
         finally {
+            releaseSessionLock?.();
             clearTimeout(deadlineTimer);
             input.signal?.removeEventListener('abort', onInputAbort);
             outcome?.cancel();

package/dist/trigger/legacy-session-history.js

@@ -0,0 +1,19 @@
+const HISTORY_CHANNELS = new Set(['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom']);
+/**
+ * Turns legacy raw session-file references into the controlled history CLI.
+ * The replacement deliberately keeps the explicit peer/channel scope but
+ * never carries a filesystem location into a Trigger prompt.
+ */
+export function rewriteLegacyTriggerSessionPaths(prompt, triggerAid) {
+    const legacyPath = /data\/sessions\/([A-Za-z0-9_-]+)\/([^/\s`"'<>]+)(?:\/([^/\s`"'<>]+))?\/messages\.jsonl/g;
+    return prompt.replace(legacyPath, (match, channel, first, second) => {
+        if (!HISTORY_CHANNELS.has(channel))
+            return match;
+        const isAun = channel === 'aun';
+        const target = isAun ? second : first;
+        const selfAid = triggerAid ?? (isAun ? first : undefined);
+        if (!selfAid || !target)
+            return match;
+        return `ec msg history ${selfAid} ${target} --channel ${channel} --session all --direction in --format json`;
+    });
+}

package/dist/trigger/manager.js

@@ -4,6 +4,7 @@ import { agentTriggersDir } from '../paths.js';
 import { definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
 import { atomicWriteJson } from '../core/session/session-fs-store.js';
 import { TriggerHistoryStore } from './history.js';
+import { rewriteLegacyTriggerSessionPaths } from './legacy-session-history.js';
 export class TriggerDefinitionManager {
     agentAid;
     rootDir;
@@ -34,7 +35,17 @@ export class TriggerDefinitionManager {
         if (!fs.existsSync(file))
             return undefined;
         const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        return normalizeTriggerDefinition(raw);
+        const definition = normalizeTriggerDefinition(raw);
+        if (typeof definition.execution.prompt === 'string') {
+            const rewritten = rewriteLegacyTriggerSessionPaths(definition.execution.prompt, definition.agentAid);
+            if (rewritten !== definition.execution.prompt) {
+                definition.execution = { ...definition.execution, prompt: rewritten };
+                definition.updatedAt = Date.now();
+                this.writeDefinition(definition);
+                this.history.recordDefinition('trigger.updated', definition, { reason: 'legacy-session-history-paths' });
+            }
+        }
+        return definition;
     }
     require(triggerId) {
         const def = this.get(triggerId);

package/dist/trigger/parser.js

@@ -210,11 +210,13 @@ function parseTriggerThread(flags) {
         return { ok: false, error: '--trigger-thread 不能为空' };
     if (raw === 'per-run')
         return { ok: true, value: 'per_run' };
+    if (raw === 'by-run')
+        return { ok: true, value: 'by_run' };
     if (raw === 'by-trigger')
         return { ok: true, value: 'by_trigger' };
-    if (raw === 'per_run' || raw === 'by_trigger')
+    if (raw === 'per_run' || raw === 'by_run' || raw === 'by_trigger')
         return { ok: true, value: raw };
-    return { ok: false, error: '--trigger-thread 只接受 per-run 或 by-trigger' };
+    return { ok: false, error: '--trigger-thread 只接受 by-run 或 by-trigger（兼容 per-run）' };
 }
 function parseTargetSession(flags) {
     if (!flags.has('target-session'))

package/dist/trigger/scheduler.js

@@ -3,7 +3,8 @@ 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, } from './validation.js';
+import { definitionRevision, 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';
 import { recordCausationSpan } from '../core/causation/audit.js';
@@ -21,6 +22,7 @@ export class TriggerRuntimeScheduler {
     daemonChannel;
     runtime;
     eventBus;
+    targetSessionLocks;
     timers = new Map();
     running = new Map();
     runStartLocks = new Map();
@@ -28,7 +30,7 @@ export class TriggerRuntimeScheduler {
     eventSource;
     initialized = false;
     stopping = false;
-    constructor(manager, state, audit, scriptExecutor, feedback, daemonChannel, runtime, eventBus) {
+    constructor(manager, state, audit, scriptExecutor, feedback, daemonChannel, runtime, eventBus, targetSessionLocks = new TargetSessionLockRegistry()) {
         this.manager = manager;
         this.state = state;
         this.audit = audit;
@@ -37,6 +39,7 @@ export class TriggerRuntimeScheduler {
         this.daemonChannel = daemonChannel;
         this.runtime = runtime;
         this.eventBus = eventBus;
+        this.targetSessionLocks = targetSessionLocks;
         if (eventBus) {
             this.eventSource = new TriggerEventSource(eventBus, (triggerId, event) => {
                 void this.fireEventTrigger(triggerId, event);
@@ -391,6 +394,31 @@ export class TriggerRuntimeScheduler {
             return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'stopped' };
         }
         const source = this.buildSourceInfo(definition.source, firedAt, payload.scheduledAt, payload.payload);
+        try {
+            validateConcurrencyCombination(definition.execution, definition.reliability);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt: firedAt,
+                status: 'failed',
+                reason: 'invalid_execution_configuration',
+                source,
+                script: null,
+                reply: null,
+                feedback: null,
+                effects: [],
+                error: { code: 'invalid_execution_configuration', message },
+                causation: payload.causation,
+            });
+            if (!payload.dryRun) {
+                this.audit.write(audit);
+                this.publishTriggerRunOutcome(definition, audit);
+            }
+            return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'invalid_execution_configuration', audit, error: message };
+        }
         const executionAuthorization = this.runtime.authorizeExecution?.(definition);
         if (executionAuthorization && !executionAuthorization.allowed) {
             const reason = executionAuthorization.reason || 'execution_authorization_denied';
@@ -455,6 +483,7 @@ export class TriggerRuntimeScheduler {
             definitionRevision: definitionRevision(definition),
             source,
             resumeCount: 0,
+            attempts: [],
             events: [{ seq: 0, event: 'run.started', ts: startedAt }],
         };
         if (!payload.dryRun) {
@@ -597,6 +626,7 @@ export class TriggerRuntimeScheduler {
                 anomalies: executionAnomalies,
                 effects: feedbackResult.effects,
                 error: feedbackResult.error,
+                conflictRunId: feedbackResult.conflictRunId,
                 causation,
             });
             if (!payload.dryRun) {
@@ -680,7 +710,7 @@ export class TriggerRuntimeScheduler {
         let attempt = 1;
         let anomalies = [];
         try {
-            let execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt);
+            let execution = await this.runRecordedExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt);
             anomalies = accumulateTriggerExecutionAnomalies(anomalies, mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(runId)));
             onAnomalies?.(anomalies);
             for (let retryCount = 0; shouldRetryExecutionResult(execution) && retryCount < maxAttempts && !signal.aborted; retryCount++) {
@@ -688,7 +718,7 @@ export class TriggerRuntimeScheduler {
                 if (!backoffCompleted || signal.aborted)
                     break;
                 attempt += 1;
-                execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt);
+                execution = await this.runRecordedExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, retryContextFromExecution(attempt - 1, `${runId}:attempt:${attempt - 1}`, execution));
                 anomalies = accumulateTriggerExecutionAnomalies(anomalies, mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(runId)));
                 onAnomalies?.(anomalies);
             }
@@ -703,7 +733,34 @@ export class TriggerRuntimeScheduler {
             throw new TriggerExecutionFailure(error, anomalies);
         }
     }
-    async runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt = 1) {
+    async runRecordedExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, previousAttempt) {
+        const attemptId = `${runId}:attempt:${attempt}`;
+        if (!dryRun) {
+            this.state.startExecutionAttempt?.(definition.id, runId, {
+                attempt,
+                attemptId,
+                startedAt: Date.now(),
+            });
+        }
+        try {
+            const execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, previousAttempt);
+            if (!dryRun) {
+                const summary = attemptSummaryFromExecution(attempt, attemptId, execution);
+                this.state.completeExecutionAttempt?.(definition.id, runId, attemptId, summary);
+            }
+            return execution;
+        }
+        catch (error) {
+            if (!dryRun) {
+                this.state.completeExecutionAttempt?.(definition.id, runId, attemptId, {
+                    status: 'failed',
+                    error: errorSummary(error, 'execution_exception'),
+                });
+            }
+            throw error;
+        }
+    }
+    async runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt = 1, previousAttempt) {
         if (signal.aborted) {
             return {
                 script: null,
@@ -735,12 +792,15 @@ export class TriggerRuntimeScheduler {
                 reply,
             };
         }
-        const prompt = renderTemplate(definition.execution.prompt ?? '', {
+        const originalPrompt = renderTemplate(definition.execution.prompt ?? '', {
             trigger: definition,
             timestamp: firedAt,
             event: sourcePayload,
             source: { type: definition.source.type, payload: sourcePayload },
         });
+        const prompt = previousAttempt
+            ? renderRetryContinuationPrompt(originalPrompt, previousAttempt)
+            : originalPrompt;
         const processing = {
             mode: definition.execution.type,
             renderedTextHash: sha256(prompt),
@@ -756,6 +816,20 @@ export class TriggerRuntimeScheduler {
                 dryRun,
                 causation,
                 signal,
+                onSessionResolved: async (session) => {
+                    this.state.startExecutionAttempt?.(definition.id, runId, {
+                        attempt,
+                        attemptId: `${runId}:attempt:${attempt}`,
+                        startedAt: Date.now(),
+                        executionSessionId: session.id,
+                    });
+                    // runExecution is also used by focused unit tests without a live
+                    // scheduler runtime. Production calls always have a RunningRun.
+                    if (!this.running.get(definition.id)?.has(runId)) {
+                        return { kind: 'acquired', release: () => undefined };
+                    }
+                    return await this.acquireTargetSessionLock(definition, runId, session.id);
+                },
             });
             return {
                 script: null,
@@ -792,19 +866,13 @@ export class TriggerRuntimeScheduler {
             const attemptId = `${runId}:attempt:${attempt}`;
             const executionDeadlineAt = this.daemonExecutionDeadlineAt(Date.now());
             const executionSession = await this.daemonChannel.getOrCreateConversationSession(definition, this.runtime.projectPath, runtimeBaseagent, runId, attemptId);
-            const activeRun = this.state.setPhase?.(definition.id, runId, 'running', {
+            const activeRun = this.state.startExecutionAttempt?.(definition.id, runId, {
                 attempt,
                 attemptId,
+                startedAt: Date.now(),
                 executionSessionId: executionSession.id,
                 executionDeadlineAt,
             });
-            this.state.appendEvent?.(definition.id, runId, {
-                event: 'execution.attempt.started',
-                ts: Date.now(),
-                attempt,
-                attemptId,
-                executionSessionId: executionSession.id,
-            });
             const daemonReply = await this.daemonChannel.converse(prompt, {
                 trigger: definition,
                 runId,
@@ -869,6 +937,26 @@ export class TriggerRuntimeScheduler {
             signal,
         });
     }
+    async acquireTargetSessionLock(definition, runId, sessionId) {
+        const concurrency = definition.reliability.concurrency;
+        if (concurrency === 'allow') {
+            throw new Error('target_session concurrency=allow must be rejected before session dispatch');
+        }
+        const runtime = this.running.get(definition.id)?.get(runId);
+        if (!runtime) {
+            throw new Error(`target session lock requested for non-running Trigger run: ${definition.id}/${runId}`);
+        }
+        return await this.targetSessionLocks.acquire(sessionId, concurrency, {
+            triggerId: definition.id,
+            runId,
+            replace: async () => {
+                await this.terminateRun(runId, runtime, {
+                    reason: 'replaced',
+                    message: `target session run replaced: trigger=${definition.id} run=${runId}`,
+                });
+            },
+        });
+    }
     async checkConcurrency(definition, nextRunId, source) {
         const runs = this.running.get(definition.id);
         if (!runs || runs.size === 0 || definition.reliability.concurrency === 'allow')
@@ -1118,7 +1206,16 @@ export class TriggerRuntimeScheduler {
     async runRecoveredExecution(definition, runtime, session) {
         const { run, source, controller, causation } = runtime;
         let attempt = run.attempt;
+        const attemptId = run.attemptId ?? `${run.runId}:attempt:${attempt}`;
+        this.state.startExecutionAttempt(definition.id, run.runId, {
+            attempt,
+            attemptId,
+            startedAt: run.startedAt,
+            executionSessionId: session.id,
+            executionDeadlineAt: run.executionDeadlineAt,
+        });
         let execution = await this.runRecoveredExecutionAttempt(definition, runtime, session);
+        this.state.completeExecutionAttempt(definition.id, run.runId, attemptId, attemptSummaryFromExecution(attempt, attemptId, execution));
         let anomalies = accumulateTriggerExecutionAnomalies([], mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(run.runId)));
         runtime.anomalies = anomalies;
         const maxAttempt = 1 + (definition.execution.onError === 'retry'
@@ -1129,7 +1226,7 @@ export class TriggerRuntimeScheduler {
             if (!backoffCompleted || controller.signal.aborted)
                 break;
             attempt += 1;
-            execution = await this.runExecutionAttempt(definition, run.runId, source.firedAt, source.payload, controller.signal, false, causation, attempt);
+            execution = await this.runRecordedExecutionAttempt(definition, run.runId, source.firedAt, source.payload, controller.signal, false, causation, attempt, retryContextFromExecution(attempt - 1, `${run.runId}:attempt:${attempt - 1}`, execution));
             anomalies = accumulateTriggerExecutionAnomalies(anomalies, mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(run.runId)));
             runtime.anomalies = anomalies;
         }
@@ -1356,6 +1453,12 @@ export class TriggerRuntimeScheduler {
     }
     buildAudit(input) {
         const reply = summarizeReply(input.reply, { omitText: input.script?.result !== undefined });
+        const activeRun = this.state.list?.(input.definition.id).find(run => run.runId === input.runId);
+        const attempts = activeRun?.attempts?.map(attempt => ({
+            ...attempt,
+            ...(attempt.error ? { error: { ...attempt.error } } : {}),
+        }));
+        const finalAttempt = attempts?.at(-1);
         return {
             runId: input.runId,
             triggerId: input.definition.id,
@@ -1365,6 +1468,9 @@ export class TriggerRuntimeScheduler {
             status: input.status,
             reason: input.reason,
             conflictRunId: input.conflictRunId,
+            ...(activeRun?.executionSessionId ? { executionSessionId: activeRun.executionSessionId } : {}),
+            ...(attempts?.length ? { attempts } : {}),
+            ...(finalAttempt ? { finalAttempt: finalAttempt.attempt } : {}),
             definition: {
                 schemaVersion: input.definition.$schema_version,
                 revision: definitionRevision(input.definition),
@@ -1522,6 +1628,10 @@ export class TriggerRuntimeScheduler {
             this.removeRunning(triggerId, runId);
             return;
         }
+        // terminateRun owns the terminal audit and must retain active attempt
+        // snapshots until its completion barrier has settled.
+        if (runtime?.termination)
+            return;
         this.finishRun(triggerId, runId);
     }
     suspendedRuntimeResult(runtime, triggerId, runId) {
@@ -1787,6 +1897,65 @@ function errorReply(runId, durationMs, reason, text) {
         },
     };
 }
+function attemptSummaryFromExecution(attempt, attemptId, execution) {
+    if (execution.feedbackResult) {
+        const failed = execution.feedbackResult.status !== 'completed';
+        return {
+            status: failed ? 'failed' : 'completed',
+            ...(execution.feedbackResult.error
+                ? { error: execution.feedbackResult.error }
+                : failed
+                    ? { error: {
+                            code: execution.feedbackResult.reason ?? 'target_session_failed',
+                            message: execution.feedbackResult.reason ?? 'target session execution did not start',
+                        } }
+                    : {}),
+        };
+    }
+    const reply = execution.reply;
+    if (!reply) {
+        return { status: 'failed', error: { code: 'execution_missing_reply', message: 'execution completed without a reply' } };
+    }
+    switch (reply.outcome) {
+        case 'success': return { status: 'completed' };
+        case 'noop': return { status: 'noop' };
+        case 'interrupted': return { status: 'interrupted', error: replyErrorSummary(reply, 'interrupted') };
+        case 'timeout': return { status: 'timeout', error: replyErrorSummary(reply, 'timeout') };
+        case 'error': return { status: 'failed', error: replyErrorSummary(reply, 'execution_error') };
+    }
+}
+function retryContextFromExecution(attempt, attemptId, execution) {
+    return {
+        attempt,
+        attemptId,
+        ...attemptSummaryFromExecution(attempt, attemptId, execution),
+    };
+}
+function replyErrorSummary(reply, fallbackCode) {
+    return {
+        code: reply.error?.reason || fallbackCode,
+        message: previewText(reply.error?.text || `Trigger attempt ${fallbackCode}`, 600),
+    };
+}
+function errorSummary(error, fallbackCode) {
+    const cause = error instanceof TriggerExecutionFailure ? error.cause : error;
+    return {
+        code: fallbackCode,
+        message: previewText(cause instanceof Error ? cause.message : String(cause), 600),
+    };
+}
+function renderRetryContinuationPrompt(originalPrompt, previous) {
+    const error = previous.error
+        ? `${previous.error.code}: ${previous.error.message}`
+        : previous.status;
+    return [
+        '这是同一个 Trigger run 的恢复执行，不是新任务。',
+        `上一 attempt 为 ${previous.attempt}（${previous.attemptId}），结果：${error}。`,
+        '请先检查当前会话已有上下文、工具结果和已完成步骤，只继续未完成的工作。',
+        '原始任务：',
+        originalPrompt,
+    ].join('\n');
+}
 function summarizeScript(script) {
     if (!script)
         return null;
@@ -1833,6 +2002,7 @@ function summarizeReply(reply, opts = {}) {
         durationMs: reply.meta.durationMs,
         numTurns: reply.meta.numTurns,
         tokenUsage: reply.meta.tokenUsage,
+        contextRecoveryAttempts: reply.meta.contextRecoveryAttempts,
         toolCallCount: reply.meta.toolCallCount,
     };
 }

package/dist/trigger/session-lock.js

@@ -0,0 +1,62 @@
+/**
+ * Process-wide ownership for target sessions. Schedulers are created per
+ * agent, so per-scheduler maps cannot protect a session shared by triggers.
+ */
+export class TargetSessionLockRegistry {
+    owners = new Map();
+    mutations = new Map();
+    async acquire(sessionId, concurrency, owner) {
+        return await this.withMutation(sessionId, async () => {
+            const current = this.owners.get(sessionId);
+            if (!current)
+                return this.claim(sessionId, owner);
+            if (concurrency === 'forbid') {
+                return {
+                    kind: 'conflict',
+                    conflictTriggerId: current.triggerId,
+                    conflictRunId: current.runId,
+                };
+            }
+            await current.replace();
+            const remaining = this.owners.get(sessionId);
+            if (remaining) {
+                return {
+                    kind: 'conflict',
+                    conflictTriggerId: remaining.triggerId,
+                    conflictRunId: remaining.runId,
+                };
+            }
+            return this.claim(sessionId, owner);
+        });
+    }
+    claim(sessionId, owner) {
+        this.owners.set(sessionId, owner);
+        let released = false;
+        return {
+            kind: 'acquired',
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                if (this.owners.get(sessionId) === owner)
+                    this.owners.delete(sessionId);
+            },
+        };
+    }
+    async withMutation(sessionId, action) {
+        const previous = this.mutations.get(sessionId) ?? Promise.resolve();
+        let releaseCurrent;
+        const current = new Promise(resolve => { releaseCurrent = resolve; });
+        const tail = previous.then(() => current);
+        this.mutations.set(sessionId, tail);
+        await previous;
+        try {
+            return await action();
+        }
+        finally {
+            releaseCurrent();
+            if (this.mutations.get(sessionId) === tail)
+                this.mutations.delete(sessionId);
+        }
+    }
+}