evolcore 0.0.4 → 0.0.6

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);
+        }
+    }
+}

package/dist/trigger/state.js

@@ -48,6 +48,70 @@ export class TriggerRunStateStore {
         this.write(triggerId, active);
         return run;
     }
+    startExecutionAttempt(triggerId, runId, input) {
+        const active = this.read(triggerId);
+        const run = active.runs[runId];
+        if (!run)
+            return undefined;
+        const attempts = run.attempts ?? (run.attempts = []);
+        const existing = attempts.find(attempt => attempt.attemptId === input.attemptId);
+        if (existing) {
+            if (input.executionSessionId)
+                existing.executionSessionId = input.executionSessionId;
+        }
+        else {
+            attempts.push({
+                attempt: input.attempt,
+                attemptId: input.attemptId,
+                startedAt: input.startedAt,
+                status: 'running',
+                ...(input.executionSessionId ? { executionSessionId: input.executionSessionId } : {}),
+            });
+            run.events.push({
+                seq: run.events.length,
+                event: 'execution.attempt.started',
+                ts: input.startedAt,
+                attempt: input.attempt,
+                attemptId: input.attemptId,
+                ...(input.executionSessionId ? { executionSessionId: input.executionSessionId } : {}),
+            });
+        }
+        run.attempt = input.attempt;
+        run.attemptId = input.attemptId;
+        if (input.executionSessionId)
+            run.executionSessionId = input.executionSessionId;
+        if (input.executionDeadlineAt !== undefined)
+            run.executionDeadlineAt = input.executionDeadlineAt;
+        this.write(triggerId, active);
+        return run;
+    }
+    completeExecutionAttempt(triggerId, runId, attemptId, result) {
+        const active = this.read(triggerId);
+        const run = active.runs[runId];
+        if (!run)
+            return undefined;
+        const attempt = run.attempts?.find(item => item.attemptId === attemptId);
+        if (!attempt || attempt.status !== 'running')
+            return run;
+        const finishedAt = result.finishedAt ?? Date.now();
+        attempt.status = result.status;
+        attempt.finishedAt = finishedAt;
+        if (result.error)
+            attempt.error = result.error;
+        run.events.push({
+            seq: run.events.length,
+            event: result.status === 'completed' || result.status === 'noop'
+                ? 'execution.attempt.completed'
+                : 'execution.attempt.failed',
+            ts: finishedAt,
+            attempt: attempt.attempt,
+            attemptId,
+            status: result.status,
+            ...(result.error ? { error: result.error } : {}),
+        });
+        this.write(triggerId, active);
+        return run;
+    }
     remove(triggerId, runId) {
         const active = this.read(triggerId);
         delete active.runs[runId];

package/dist/trigger/validation.js

@@ -29,6 +29,35 @@ export function normalizeTriggerDefinition(input, opts = {}) {
 export function validateTriggerDefinition(definition) {
     normalizeTriggerDefinition(definition);
 }
+/**
+ * Keep legacy `per_run` definitions byte-stable while giving runtime code one
+ * canonical representation for session selection and validation.
+ */
+export function normalizeExecutionMode(execution) {
+    if (execution.type !== 'trigger_session')
+        return { type: execution.type };
+    return {
+        type: execution.type,
+        thread: execution.thread === 'per_run' || execution.thread === 'by_run'
+            ? 'by_run'
+            : 'by_trigger',
+    };
+}
+/** Validate the run-concurrency policy against the session ownership model. */
+export function validateConcurrencyCombination(execution, reliability) {
+    // Scripts do not share a model session, so all run-level policies remain valid.
+    if (execution.type === 'script')
+        return;
+    if (reliability.concurrency === 'allow') {
+        const mode = normalizeExecutionMode(execution);
+        if (mode.type === 'target_session') {
+            throw new Error('invalid Trigger concurrency: execution.type=target_session, concurrency=allow; allowed values are forbid or replace');
+        }
+        if (mode.thread === 'by_trigger') {
+            throw new Error('invalid Trigger concurrency: execution.type=trigger_session, thread=by_trigger, concurrency=allow; allowed values are forbid or replace');
+        }
+    }
+}
 export function definitionRevision(definition) {
     const stable = stableStringify(definition);
     return `sha256:${sha256(stable)}`;
@@ -381,8 +410,8 @@ function normalizeExecutionThread(value) {
     const thread = optionalString(value);
     if (thread === undefined)
         return undefined;
-    if (thread !== 'per_run' && thread !== 'by_trigger') {
-        throw new Error('execution.thread must be per_run or by_trigger');
+    if (thread !== 'per_run' && thread !== 'by_run' && thread !== 'by_trigger') {
+        throw new Error('execution.thread must be per_run, by_run, or by_trigger');
     }
     return thread;
 }
@@ -572,6 +601,7 @@ function validateTriggerSemantics(definition) {
     if (execution.type !== 'script' && (definition.feedback.onReply || definition.feedback.onNoop || definition.feedback.onFailure)) {
         throw new Error('feedback.onReply/onNoop/onFailure are only allowed when execution.type=script');
     }
+    validateConcurrencyCombination(execution, definition.reliability);
 }
 function generateTriggerId() {
     return `trig_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;

package/dist/utils/aid-bind.js

@@ -291,7 +291,7 @@ function resolveBaseagentInfo(config) {
     return { active_baseagent, model, effort };
 }
 function pickFirstBaseagent(baseagents) {
-    for (const name of ['claude', 'codex', 'gemini']) {
+    for (const name of ['claude', 'codex', 'gemini', 'ecagent']) {
         if (baseagents[name] !== undefined)
             return name;
     }

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

@@ -54,6 +54,15 @@ const NON_INFRA_TERMINAL_REASONS = new Set([
     'aborted_streaming',
     'aborted_tools',
 ]);
+/**
+ * SDK terminal reasons that mean the current turn was stopped before normal
+ * completion.  In particular, Claude reports a declined/expired
+ * AskUserQuestion as `aborted_tools`; that is a user interaction outcome, not
+ * an infrastructure or agent execution failure.
+ */
+export function isAbortTerminalReason(terminalReason) {
+    return terminalReason === 'aborted_streaming' || terminalReason === 'aborted_tools';
+}
 export function isInfraError(subtype, terminalReason) {
     // terminalReason 优先级更高（更精确）
     if (terminalReason && NON_INFRA_TERMINAL_REASONS.has(terminalReason)) {

package/dist/utils/process-introspect.js

@@ -8,8 +8,25 @@
  */
 import fs from 'fs';
 import { spawnSync } from 'child_process';
-import { isWindows } from './cross-platform.js';
+const isWindows = process.platform === 'win32';
 const isMacOS = process.platform === 'darwin';
+function readLinuxClockTicks() {
+    if (process.platform !== 'linux')
+        return 100;
+    try {
+        const result = spawnSync('getconf', ['CLK_TCK'], {
+            encoding: 'utf-8',
+            timeout: 1000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const value = Number.parseInt(result.stdout?.trim() || '', 10);
+        return value > 0 ? value : 100;
+    }
+    catch {
+        return 100;
+    }
+}
+const linuxClockTicks = readLinuxClockTicks();
 /** 容差：2 秒（覆盖 macOS 秒级精度 + 时钟漂移） */
 export const START_TIME_TOLERANCE_MS = 2000;
 /**
@@ -72,8 +89,7 @@ function getStartTimeLinux(pid) {
     }
     if (isNaN(btimeSec))
         return null;
-    const clkTck = 100;
-    return (btimeSec + starttimeJiffies / clkTck) * 1000;
+    return (btimeSec + starttimeJiffies / linuxClockTicks) * 1000;
 }
 // ── macOS ──
 function getStartTimeMacOS(pid) {

package/dist/utils/welcome.js

@@ -8,8 +8,7 @@
  * - 所有 IM 渠道（Feishu/WeChat/DingTalk/QQBot/WeCom）：首次交互时发送给交互用户（被动响应）
  */
 import fs from 'fs';
-import path from 'path';
-import { resolvePaths } from '../paths.js';
+import { channelStatePath } from '../paths.js';
 import { loadAgent, saveAgent } from '../config-store.js';
 import { withLifecycleForWrite } from '../config/lifecycle.js';
 import { logger } from './logger.js';
@@ -157,7 +156,7 @@ export class FirstInteractionWelcomeManager {
         this.agentAid = agentAid;
         this.channelName = channelName;
         // 每个 channel instance 独立的已欢迎用户记录
-        this.greetedUsersFile = path.join(resolvePaths().dataDir, `${channelType}-greeted-${channelName}.jsonl`);
+        this.greetedUsersFile = channelStatePath(channelName, 'welcome.jsonl');
         this.loadGreetedUsers();
     }
     /**

package/ecagent/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.