evolcore 0.0.3 → 0.0.5

package/dist/trigger/scheduler.js

@@ -11,6 +11,7 @@ import { accumulateTriggerExecutionAnomalies, drainTriggerExecutionAnomalies, me
 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 任务；不要重新从头执行已经完成的步骤。';
 export class TriggerRuntimeScheduler {
     manager;
     state;
@@ -23,6 +24,7 @@ export class TriggerRuntimeScheduler {
     timers = new Map();
     running = new Map();
     runStartLocks = new Map();
+    recoveredOneShotIds = new Set();
     eventSource;
     initialized = false;
     stopping = false;
@@ -44,10 +46,14 @@ export class TriggerRuntimeScheduler {
     async init() {
         await this.stop();
         this.stopping = false;
+        this.recoveredOneShotIds.clear();
         await this.recoverOpenRuns();
         for (const definition of this.manager.list()) {
+            if (this.recoveredOneShotIds.has(definition.id))
+                continue;
             this.schedule(definition);
         }
+        this.recoveredOneShotIds.clear();
         this.initialized = true;
         logger.info(`[Trigger] scheduler initialized for ${this.manager.agentAid}`);
     }
@@ -70,6 +76,35 @@ export class TriggerRuntimeScheduler {
         this.initialized = false;
         await Promise.all(settlements);
     }
+    /**
+     * Stop process-local work while keeping durable runs open for the next daemon.
+     * Explicit scheduler replacement/unload must continue to use stop().
+     */
+    async suspendForDaemonExit() {
+        this.stopping = true;
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        this.eventSource?.stop();
+        const settlements = [];
+        for (const runs of Array.from(this.running.values())) {
+            for (const [runId, runtime] of Array.from(runs.entries())) {
+                const durableRun = this.state.list(runtime.definition.id).find(candidate => candidate.runId === runId);
+                if (durableRun)
+                    runtime.run = durableRun;
+                const resumable = !!durableRun && this.isResumableCheckpoint(runtime.definition, durableRun);
+                settlements.push(this.terminateRun(runId, runtime, {
+                    reason: resumable ? 'suspended' : 'stopped',
+                    message: resumable
+                        ? 'trigger scheduler stopped for daemon restart'
+                        : 'trigger scheduler stopped',
+                }));
+            }
+        }
+        settlements.push(...this.runStartLocks.values());
+        this.initialized = false;
+        await Promise.all(settlements);
+    }
     async waitForIdle(timeoutMs = 5_000) {
         const deadline = Date.now() + timeoutMs;
         while ((this.running.size > 0 || this.runStartLocks.size > 0) && Date.now() < deadline) {
@@ -341,7 +376,9 @@ export class TriggerRuntimeScheduler {
             await runPromise;
             return;
         }
-        await runPromise;
+        const result = await runPromise;
+        if (result.status === 'running' && result.reason === 'daemon_restart_resume_pending')
+            return;
         const fresh = this.manager.get(triggerId);
         if (fresh?.enabled && definitionRevision(fresh) === firedRevision) {
             this.setEnabled(triggerId, false);
@@ -415,6 +452,9 @@ export class TriggerRuntimeScheduler {
             triggerId: definition.id,
             runId,
             startedAt,
+            definitionRevision: definitionRevision(definition),
+            source,
+            resumeCount: 0,
             events: [{ seq: 0, event: 'run.started', ts: startedAt }],
         };
         if (!payload.dryRun) {
@@ -476,9 +516,12 @@ export class TriggerRuntimeScheduler {
             if (runningRuntime)
                 runningRuntime.anomalies = executionAnomalies;
             if (!payload.dryRun && controller.signal.aborted) {
-                const reason = triggerCancellationReason(controller.signal);
                 if (this.isRunning(definition.id, runId))
-                    this.finishRun(definition.id, runId);
+                    this.finishAbortedRun(runningRuntime, definition.id, runId);
+                const suspended = this.suspendedRuntimeResult(runningRuntime, definition.id, runId);
+                if (suspended)
+                    return suspended;
+                const reason = triggerCancellationReason(controller.signal);
                 return {
                     ok: false,
                     runId,
@@ -524,9 +567,12 @@ export class TriggerRuntimeScheduler {
                 signal: controller.signal,
             }), controller.signal, RUN_ABORT_SETTLE_GRACE_MS, 'feedback');
             if (!payload.dryRun && controller.signal.aborted) {
-                const reason = triggerCancellationReason(controller.signal);
                 if (this.isRunning(definition.id, runId))
-                    this.finishRun(definition.id, runId);
+                    this.finishAbortedRun(runningRuntime, definition.id, runId);
+                const suspended = this.suspendedRuntimeResult(runningRuntime, definition.id, runId);
+                if (suspended)
+                    return suspended;
+                const reason = triggerCancellationReason(controller.signal);
                 return {
                     ok: false,
                     runId,
@@ -581,9 +627,12 @@ export class TriggerRuntimeScheduler {
             executionAnomalies = mergeTriggerExecutionAnomalies(executionAnomalies, executionAnomaliesFromError(err));
             const message = err?.message || String(err);
             if (!payload.dryRun && controller.signal.aborted) {
-                const reason = triggerCancellationReason(controller.signal);
                 if (this.isRunning(definition.id, runId))
-                    this.finishRun(definition.id, runId);
+                    this.finishAbortedRun(runningRuntime, definition.id, runId);
+                const suspended = this.suspendedRuntimeResult(runningRuntime, definition.id, runId);
+                if (suspended)
+                    return suspended;
+                const reason = triggerCancellationReason(controller.signal);
                 return {
                     ok: false,
                     runId,
@@ -740,17 +789,33 @@ export class TriggerRuntimeScheduler {
                 + ` baseagent=${runtimeBaseagent}`
                 + ` model=${definition.execution.model ?? '<agent-default>'}`
                 + ` effort=${definition.execution.effort ?? '<agent-default>'}`);
-            const executionSession = await this.daemonChannel.getOrCreateConversationSession(definition, this.runtime.projectPath, runtimeBaseagent, runId, `${runId}:attempt:${attempt}`);
+            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', {
+                attempt,
+                attemptId,
+                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,
-                attemptId: `${runId}:attempt:${attempt}`,
+                attemptId,
                 firedAt,
                 projectPath: this.runtime.projectPath,
                 baseagent: runtimeBaseagent,
                 session: executionSession,
                 causation,
                 signal,
+                executionDeadlineAt: activeRun?.executionDeadlineAt ?? executionDeadlineAt,
                 onStateChange: (state, metadata) => {
                     if (state === 'requires_action') {
                         this.state.setPhase(definition.id, runId, 'requires-action');
@@ -834,41 +899,338 @@ export class TriggerRuntimeScheduler {
             if (activeRuns.length === 0)
                 continue;
             for (const run of activeRuns) {
-                const status = run.phase === 'feedback-pending' ? 'skipped' : 'failed';
-                const audit = this.buildAudit({
-                    definition,
-                    runId: run.runId,
-                    startedAt: run.startedAt,
-                    status,
-                    reason: 'daemon_restart',
-                    source: this.buildSourceInfo(definition.source, run.startedAt, run.startedAt, this.sourcePayload(definition.source)),
-                    script: null,
-                    reply: null,
-                    feedback: null,
-                    effects: [],
-                    error: status === 'failed' ? { code: 'daemon_restart', message: 'daemon restarted while run was open' } : null,
+                if (await this.reclaimOpenRun(definition, run))
+                    continue;
+                await this.closeOpenRunAfterRestart(definition, run);
+            }
+        }
+    }
+    async reclaimOpenRun(definition, run) {
+        if (!definition.enabled || !this.isResumableCheckpoint(definition, run))
+            return false;
+        const executionAuthorization = this.runtime.authorizeExecution?.(definition);
+        if (executionAuthorization && !executionAuthorization.allowed)
+            return false;
+        const session = await this.daemonChannel.getResumableConversationSession(run.executionSessionId);
+        if (!session) {
+            logger.warn(`[Trigger] resumable session unavailable: trigger=${definition.id} run=${run.runId} session=${run.executionSessionId}`);
+            return false;
+        }
+        const entered = enterTrigger(undefined, definition.id, run.runId);
+        if (!entered.ok)
+            return false;
+        const causation = entered.causation;
+        const controller = new AbortController();
+        let settleCompletion;
+        const completion = new Promise(resolve => { settleCompletion = resolve; });
+        const runtime = {
+            run,
+            definition,
+            source: run.source,
+            causation,
+            controller,
+            completion,
+            anomalies: [],
+        };
+        this.addRunning(definition.id, run.runId, runtime);
+        if (this.isOneShot(definition.source))
+            this.recoveredOneShotIds.add(definition.id);
+        const resumeCount = (run.resumeCount ?? 0) + 1;
+        const patched = this.state.setPhase(definition.id, run.runId, 'running', { resumeCount });
+        if (patched)
+            runtime.run = patched;
+        this.state.appendEvent(definition.id, run.runId, {
+            event: 'execution.recovered',
+            ts: Date.now(),
+            attempt: run.attempt,
+            attemptId: run.attemptId,
+            executionSessionId: session.id,
+            resumeCount,
+        });
+        recordCausationSpan(causation, 'trigger.run', {
+            status: 'started',
+            refs: { triggerId: definition.id, runId: run.runId },
+            reason: 'daemon_restart_resume',
+        });
+        void this.continueRecoveredRun(definition, runtime, session)
+            .then(settleCompletion, error => {
+            const anomalies = executionAnomaliesFromError(error) ?? [];
+            runtime.anomalies = anomalies;
+            if (this.isRunning(definition.id, run.runId))
+                this.finishAbortedRun(runtime, definition.id, run.runId);
+            logger.error(`[Trigger] recovered run crashed: trigger=${definition.id} run=${run.runId} error=${error instanceof Error ? error.message : String(error)}`);
+            settleCompletion({ anomalies });
+        });
+        logger.info(`[Trigger] resumed open run: trigger=${definition.id} run=${run.runId} session=${session.id} attempt=${run.attempt} resume=${resumeCount}`);
+        return true;
+    }
+    isResumableCheckpoint(definition, run) {
+        return definition.execution.type === 'trigger_session'
+            && run.phase === 'running'
+            && !!run.source
+            && Number.isFinite(run.source.firedAt)
+            && isRecord(run.source.payload)
+            && Number.isInteger(run.attempt)
+            && run.attempt >= 1
+            && typeof run.attemptId === 'string'
+            && !!run.attemptId
+            && typeof run.executionSessionId === 'string'
+            && !!run.executionSessionId
+            && typeof run.executionDeadlineAt === 'number'
+            && Number.isFinite(run.executionDeadlineAt)
+            && run.executionDeadlineAt > Date.now()
+            && run.definitionRevision === definitionRevision(definition);
+    }
+    async continueRecoveredRun(definition, runtime, session) {
+        const { run, source, controller, causation } = runtime;
+        const runId = run.runId;
+        let processing = null;
+        let reply = null;
+        let anomalies = [];
+        let incomplete;
+        try {
+            const originalPrompt = renderTemplate(definition.execution.prompt ?? '', {
+                trigger: definition,
+                timestamp: source.firedAt,
+                event: source.payload,
+                source: { type: definition.source.type, payload: source.payload },
+            });
+            processing = {
+                mode: definition.execution.type,
+                renderedTextHash: sha256(originalPrompt),
+                renderedTextPreview: previewText(originalPrompt),
+            };
+            const execution = await awaitWithAbortSettleGrace(this.runRecoveredExecution(definition, runtime, session), controller.signal, RUN_ABORT_SETTLE_GRACE_MS, 'execution');
+            reply = execution.reply ?? null;
+            anomalies = execution.anomalies ?? [];
+            runtime.anomalies = anomalies;
+            if (controller.signal.aborted) {
+                if (this.isRunning(definition.id, runId))
+                    this.finishAbortedRun(runtime, definition.id, runId);
+                return { anomalies };
+            }
+            const executionFailed = execution.reply
+                ? shouldRetryExecution(execution.reply)
+                : execution.feedbackResult?.status === 'failed';
+            this.state.appendEvent(definition.id, runId, {
+                event: executionFailed ? 'execution.failed' : 'execution.completed',
+                ts: Date.now(),
+                mode: definition.execution.type,
+                outcome: execution.reply?.outcome ?? execution.feedbackResult?.status,
+                ...(anomalies.length ? { anomalyCount: anomalies.length } : {}),
+            });
+            if (!execution.feedbackResult) {
+                this.state.setPhase(definition.id, runId, 'feedback-pending', {
+                    deadlineAt: Date.now() + 30_000,
                 });
-                this.audit.write(audit);
-                if (status === 'failed') {
-                    const reply = errorReply(run.runId, Math.max(0, Date.now() - run.startedAt), 'daemon_restart', 'daemon restarted while run was waiting or executing');
-                    try {
-                        await this.feedback.dispatch({
-                            trigger: definition,
-                            runId: run.runId,
-                            firedAt: run.startedAt,
-                            branch: 'onFailure',
-                            reply,
-                            sourcePayload: this.sourcePayload(definition.source),
-                            causation: createRootCausation(),
+                this.state.appendEvent(definition.id, runId, {
+                    event: 'feedback.pending',
+                    ts: Date.now(),
+                    branch: execution.branch,
+                });
+            }
+            const feedbackResult = execution.feedbackResult ?? await awaitWithAbortSettleGrace(this.feedback.dispatch({
+                trigger: definition,
+                runId,
+                firedAt: source.firedAt,
+                branch: execution.branch,
+                reply: execution.reply,
+                sourcePayload: source.payload,
+                causation,
+                signal: controller.signal,
+            }), controller.signal, RUN_ABORT_SETTLE_GRACE_MS, 'feedback');
+            if (controller.signal.aborted) {
+                if (this.isRunning(definition.id, runId))
+                    this.finishAbortedRun(runtime, definition.id, runId);
+                return { anomalies };
+            }
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt: run.startedAt,
+                status: statusWithExecutionAnomalies(feedbackResult.status, anomalies),
+                reason: feedbackResult.reason,
+                source,
+                processing,
+                script: null,
+                reply,
+                feedback: feedbackResult.feedback,
+                anomalies,
+                effects: feedbackResult.effects,
+                error: feedbackResult.error,
+                causation,
+            });
+            this.audit.write(audit);
+            this.publishTriggerRunOutcome(definition, audit);
+            this.finishRecoveredRun(definition, runId);
+            recordCausationSpan(causation, 'trigger.run', {
+                status: audit.status === 'failed' ? 'failed' : 'completed',
+                refs: { triggerId: definition.id, runId },
+                reason: audit.reason,
+            });
+            return { anomalies };
+        }
+        catch (error) {
+            if (error instanceof AbortSettleGraceError) {
+                incomplete = {
+                    reason: 'abort_settle_grace_exceeded',
+                    phase: error.phase,
+                    timeoutMs: error.graceMs,
+                    anomalyCapture: 'truncated',
+                };
+            }
+            anomalies = mergeTriggerExecutionAnomalies(anomalies, executionAnomaliesFromError(error));
+            runtime.anomalies = anomalies;
+            if (controller.signal.aborted) {
+                if (this.isRunning(definition.id, runId))
+                    this.finishAbortedRun(runtime, definition.id, runId);
+                return { anomalies, ...(incomplete ? { incomplete } : {}) };
+            }
+            const message = error?.message || String(error);
+            const audit = this.buildAudit({
+                definition,
+                runId,
+                startedAt: run.startedAt,
+                status: 'failed',
+                reason: 'daemon_error',
+                source,
+                processing,
+                script: null,
+                reply,
+                feedback: null,
+                anomalies,
+                incomplete,
+                effects: [],
+                error: { code: 'daemon_error', message },
+                causation,
+            });
+            this.audit.write(audit);
+            this.publishTriggerRunOutcome(definition, audit);
+            this.finishRecoveredRun(definition, runId);
+            recordCausationSpan(causation, 'trigger.run', {
+                status: 'failed',
+                refs: { triggerId: definition.id, runId },
+                reason: 'daemon_error',
+            });
+            return { anomalies, ...(incomplete ? { incomplete } : {}) };
+        }
+    }
+    async runRecoveredExecution(definition, runtime, session) {
+        const { run, source, controller, causation } = runtime;
+        let attempt = run.attempt;
+        let execution = await this.runRecoveredExecutionAttempt(definition, runtime, session);
+        let anomalies = accumulateTriggerExecutionAnomalies([], mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(run.runId)));
+        runtime.anomalies = anomalies;
+        const maxAttempt = 1 + (definition.execution.onError === 'retry'
+            ? definition.reliability.retry.maxAttempts
+            : 0);
+        while (shouldRetryExecutionResult(execution) && attempt < maxAttempt && !controller.signal.aborted) {
+            const backoffCompleted = await sleep(definition.reliability.retry.backoffMs, controller.signal);
+            if (!backoffCompleted || controller.signal.aborted)
+                break;
+            attempt += 1;
+            execution = await this.runExecutionAttempt(definition, run.runId, source.firedAt, source.payload, controller.signal, false, causation, attempt);
+            anomalies = accumulateTriggerExecutionAnomalies(anomalies, mergeTriggerExecutionAnomalies(execution.reply?.anomalies, drainTriggerExecutionAnomalies(run.runId)));
+            runtime.anomalies = anomalies;
+        }
+        if (execution.reply && anomalies.length) {
+            execution = { ...execution, reply: { ...execution.reply, anomalies } };
+        }
+        return anomalies.length ? { ...execution, anomalies } : execution;
+    }
+    async runRecoveredExecutionAttempt(definition, runtime, session) {
+        const { run, source, controller, causation } = runtime;
+        try {
+            const daemonReply = await this.daemonChannel.converse(TRIGGER_RESTART_RESUME_PROMPT, {
+                trigger: definition,
+                runId: run.runId,
+                attemptId: run.attemptId,
+                firedAt: source.firedAt,
+                projectPath: session.projectPath,
+                baseagent: session.baseagent,
+                session,
+                causation,
+                signal: controller.signal,
+                executionDeadlineAt: run.executionDeadlineAt,
+                onStateChange: (state, metadata) => {
+                    if (state === 'requires_action') {
+                        this.state.setPhase(definition.id, run.runId, 'requires-action');
+                        this.state.appendEvent(definition.id, run.runId, {
+                            event: 'execution.requires_action',
+                            ts: Date.now(),
+                            requestId: metadata?.requestId,
+                            expiresAt: metadata?.expiresAt,
                         });
                     }
-                    catch (error) {
-                        logger.warn(`[Trigger] daemon restart feedback failed: trigger=${definition.id} run=${run.runId} error=${error instanceof Error ? error.message : String(error)}`);
+                    else {
+                        this.state.setPhase(definition.id, run.runId, 'running');
+                        this.state.appendEvent(definition.id, run.runId, {
+                            event: 'execution.resumed',
+                            ts: Date.now(),
+                            requestId: metadata?.requestId,
+                        });
                     }
-                }
+                },
+            });
+            const sentinel = definition.execution.noopSentinel ?? '[[NOOP]]';
+            const reply = {
+                ...daemonReply,
+                outcome: daemonReply.outcome === 'success' && daemonReply.text.trim() === sentinel ? 'noop' : daemonReply.outcome,
+                text: daemonReply.text.trim() === sentinel ? '' : daemonReply.text,
+            };
+            return {
+                branch: branchFromReply(reply),
+                script: null,
+                processing: { mode: definition.execution.type },
+                reply,
+            };
+        }
+        catch (error) {
+            const reply = errorReply(run.runId, 0, 'agent_execution_error', error?.message || String(error));
+            return {
+                branch: 'onFailure',
+                script: null,
+                processing: { mode: definition.execution.type },
+                reply,
+            };
+        }
+    }
+    async closeOpenRunAfterRestart(definition, run) {
+        const status = run.phase === 'feedback-pending' ? 'skipped' : 'failed';
+        const source = run.source
+            ?? this.buildSourceInfo(definition.source, run.startedAt, run.startedAt, this.sourcePayload(definition.source));
+        const audit = this.buildAudit({
+            definition,
+            runId: run.runId,
+            startedAt: run.startedAt,
+            status,
+            reason: 'daemon_restart',
+            source,
+            script: null,
+            reply: null,
+            feedback: null,
+            effects: [],
+            error: status === 'failed' ? { code: 'daemon_restart', message: 'daemon restarted while run was open' } : null,
+        });
+        this.audit.write(audit);
+        if (status === 'failed') {
+            const reply = errorReply(run.runId, Math.max(0, Date.now() - run.startedAt), 'daemon_restart', 'daemon restarted while run was waiting or executing');
+            try {
+                await this.feedback.dispatch({
+                    trigger: definition,
+                    runId: run.runId,
+                    firedAt: source.firedAt,
+                    branch: 'onFailure',
+                    reply,
+                    sourcePayload: source.payload,
+                    causation: createRootCausation(),
+                });
+            }
+            catch (error) {
+                logger.warn(`[Trigger] daemon restart feedback failed: trigger=${definition.id} run=${run.runId} error=${error instanceof Error ? error.message : String(error)}`);
             }
-            this.state.clear(definition.id);
         }
+        this.state.remove(definition.id, run.runId);
     }
     resolveScheduledAt(definition) {
         const now = Date.now();
@@ -1102,6 +1464,13 @@ export class TriggerRuntimeScheduler {
     }
     async settleTerminatedRun(runId, runtime, termination) {
         const completion = await settleWithin(runtime.completion, RUN_COMPLETION_BARRIER_MS);
+        if (termination.reason === 'suspended') {
+            if (!completion.settled) {
+                logger.warn(`[Trigger] suspended run did not settle before daemon exit: trigger=${runtime.definition.id} run=${runId} timeoutMs=${RUN_COMPLETION_BARRIER_MS}`);
+            }
+            this.removeRunning(runtime.definition.id, runId);
+            return;
+        }
         const completedAnomalies = mergeTriggerExecutionAnomalies(runtime.anomalies, completion.settled ? completion.value.anomalies : undefined);
         const anomalies = accumulateTriggerExecutionAnomalies(completedAnomalies, drainTriggerExecutionAnomalies(runId));
         if (!completion.settled) {
@@ -1148,16 +1517,49 @@ export class TriggerRuntimeScheduler {
         }
         this.finishRun(runtime.definition.id, runId);
     }
-    finishRun(triggerId, runId) {
+    finishAbortedRun(runtime, triggerId, runId) {
+        if (runtime?.termination?.reason === 'suspended') {
+            this.removeRunning(triggerId, runId);
+            return;
+        }
+        this.finishRun(triggerId, runId);
+    }
+    suspendedRuntimeResult(runtime, triggerId, runId) {
+        if (runtime?.termination?.reason !== 'suspended')
+            return undefined;
+        return {
+            ok: true,
+            runId,
+            triggerId,
+            status: 'running',
+            reason: 'daemon_restart_resume_pending',
+        };
+    }
+    removeRunning(triggerId, runId) {
         const runs = this.running.get(triggerId);
         runs?.delete(runId);
         if (runs && runs.size === 0)
             this.running.delete(triggerId);
+    }
+    finishRun(triggerId, runId) {
+        this.removeRunning(triggerId, runId);
         this.state.remove(triggerId, runId);
     }
+    finishRecoveredRun(definition, runId) {
+        this.finishRun(definition.id, runId);
+        if (!this.isOneShot(definition.source))
+            return;
+        const fresh = this.manager.get(definition.id);
+        if (fresh?.enabled && definitionRevision(fresh) === definitionRevision(definition)) {
+            this.setEnabled(definition.id, false);
+        }
+    }
     isRunning(triggerId, runId) {
         return this.running.get(triggerId)?.has(runId) === true;
     }
+    daemonExecutionDeadlineAt(startedAt) {
+        return this.daemonChannel.executionDeadlineAt?.(startedAt) ?? startedAt + 60 * 60 * 1_000;
+    }
     clearTimer(triggerId) {
         const timer = this.timers.get(triggerId);
         if (timer)

package/dist/utils/cross-platform.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'url';
 import { execFileSync, execFile, spawn, spawnSync } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs';
+import { getProcessStartTime } from './process-introspect.js';
 const execFileAsync = promisify(execFile);
 export const isWindows = process.platform === 'win32';
 const ENCODE_PATH_MAX = 200;
@@ -133,10 +134,15 @@ export function getProcessInfo(pid) {
             }
         }
         else {
-            const etimes = execFileSync('ps', ['-p', String(pid), '-o', 'etimes='], { encoding: 'utf-8' }).trim();
+            // procps `etimes` can overflow for freshly spawned processes in some
+            // container/time-namespace combinations. /proc start time is reliable
+            // on Linux and is already used for PID reuse protection elsewhere.
+            const startedAt = process.platform === 'linux' ? getProcessStartTime(pid) : null;
+            const uptime = startedAt !== null
+                ? formatUptime(Math.max(0, Math.floor((Date.now() - startedAt) / 1000)))
+                : formatUptime(parseInt(execFileSync('ps', ['-p', String(pid), '-o', 'etimes='], { encoding: 'utf-8' }).trim(), 10));
             const cpu = execFileSync('ps', ['-p', String(pid), '-o', '%cpu='], { encoding: 'utf-8' }).trim();
             const mem = execFileSync('ps', ['-p', String(pid), '-o', 'rss='], { encoding: 'utf-8' }).trim();
-            const uptime = formatUptime(parseInt(etimes, 10));
             return { uptime, cpu, memory: mem };
         }
     }

package/dist/utils/error-dict.json

@@ -56,6 +56,13 @@
       "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",

package/dist/utils/evolcore-version.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import path from 'path';
+import { getPackageRoot } from '../paths.js';
+let cachedVersion;
+export function readInstalledEvolcoreVersion() {
+    if (cachedVersion !== undefined)
+        return cachedVersion;
+    let version;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(getPackageRoot(), 'package.json'), 'utf-8'));
+        version = typeof pkg.version === 'string' && pkg.version ? pkg.version : 'unknown';
+    }
+    catch {
+        version = 'unknown';
+    }
+    cachedVersion = version;
+    return version;
+}
+export function _resetInstalledEvolcoreVersionForTests() {
+    cachedVersion = undefined;
+}

package/dist/utils/logger.js

@@ -51,8 +51,8 @@ function log(level, ...args) {
     getWriters().main.write(msg);
 }
 /**
- * 设置日志级别（config 加载后调用，覆盖环境变量默认值）
- * 优先级：config.debug.logLevel → LOG_LEVEL 环境变量 → 'INFO'
+ * 设置日志级别（daemon.json 加载后调用，覆盖环境变量默认值）
+ * 优先级：daemon.json debug.logLevel → LOG_LEVEL 环境变量 → 'INFO'
  */
 export function setLogLevel(level) {
     const upper = level.toUpperCase();