evolcore 0.0.35 → 0.0.37

package/dist/trigger/local-files.js

@@ -15,12 +15,13 @@ export function decodeTriggerScriptFile(contentBase64) {
     }
     return contents;
 }
-export function resolveTriggerLocalPath(input, scope) {
+export function resolveManagedLocalPath(input, scope, kind) {
+    const messages = managedLocalFileMessages(kind);
     if (!input || /[\0\r\n]/.test(input) || hasUnsafeWindowsPathSyntax(input))
-        throw new Error('invalid Trigger input path');
+        throw new Error(messages.invalidPath);
     const normalizedInput = input.replace(/\\/g, '/');
     if (normalizedInput.split('/').includes('..'))
-        throw new Error('Trigger input path cannot traverse parent directories');
+        throw new Error(messages.parentTraversal);
     const lexical = path.resolve(scope?.cwd ?? process.cwd(), input);
     if (!scope)
         return fs.realpathSync.native(lexical);
@@ -28,17 +29,17 @@ export function resolveTriggerLocalPath(input, scope) {
     const runtime = scope.sessionRuntimeDir
         ? fs.realpathSync.native(scope.sessionRuntimeDir)
         : undefined;
-    assertSessionRuntimeScope(lexical, runtime);
+    assertSessionRuntimeScope(lexical, runtime, messages.otherSessionTemp);
     const inProjectLexically = isSameOrDescendant(lexical, project);
     const inSessionTempLexically = !!runtime && isSameOrDescendant(lexical, runtime);
     if (!inProjectLexically && !inSessionTempLexically) {
-        throw new Error('Trigger input must be inside the current project or session TMPDIR');
+        throw new Error(messages.outsideScope);
     }
     let current = lexical;
     while (true) {
         const stat = fs.lstatSync(current);
         if (stat.isSymbolicLink()) {
-            throw new Error('Trigger input must not traverse a symbolic link or junction');
+            throw new Error(messages.symbolicLink);
         }
         if (current === project || current === runtime)
             break;
@@ -48,23 +49,49 @@ export function resolveTriggerLocalPath(input, scope) {
         current = parent;
     }
     const resolved = fs.realpathSync.native(lexical);
-    assertSessionRuntimeScope(resolved, runtime);
+    assertSessionRuntimeScope(resolved, runtime, messages.otherSessionTemp);
     const inProject = isSameOrDescendant(lexical, project) && isSameOrDescendant(resolved, project);
     const inSessionTemp = !!runtime
         && isSameOrDescendant(lexical, runtime)
         && isSameOrDescendant(resolved, runtime);
     if (!inProject && !inSessionTemp) {
-        throw new Error('Trigger input must be inside the current project or session TMPDIR');
+        throw new Error(messages.outsideScope);
     }
     const root = resolveRoot();
     const lexicalClass = classifyProtectedPath(lexical, { root, selfAid: scope.selfAid });
     const resolvedClass = classifyProtectedPath(resolved, { root, selfAid: scope.selfAid });
-    if (isProtectedTriggerInputClass(lexicalClass) || isProtectedTriggerInputClass(resolvedClass)) {
-        throw new Error('Trigger input references a protected path');
+    if (isProtectedManagedInputClass(lexicalClass) || isProtectedManagedInputClass(resolvedClass)) {
+        throw new Error(messages.protectedPath);
     }
     return resolved;
 }
-function isProtectedTriggerInputClass(value) {
+export function resolveTriggerLocalPath(input, scope) {
+    return resolveManagedLocalPath(input, scope, 'trigger');
+}
+export function resolveAttachmentLocalPath(input, scope) {
+    return resolveManagedLocalPath(input, scope, 'attachment');
+}
+function managedLocalFileMessages(kind) {
+    if (kind === 'trigger') {
+        return {
+            invalidPath: 'invalid Trigger input path',
+            parentTraversal: 'Trigger input path cannot traverse parent directories',
+            outsideScope: 'Trigger input must be inside the current project or session TMPDIR',
+            symbolicLink: 'Trigger input must not traverse a symbolic link or junction',
+            protectedPath: 'Trigger input references a protected path',
+            otherSessionTemp: 'Trigger input must not reference another session TMPDIR',
+        };
+    }
+    return {
+        invalidPath: 'Invalid attachment source path',
+        parentTraversal: 'Attachment source path cannot traverse parent directories',
+        outsideScope: 'Attachment source must be inside the current project or session TMPDIR',
+        symbolicLink: 'Attachment source must not traverse a symbolic link or junction',
+        protectedPath: 'Attachment source references a protected path',
+        otherSessionTemp: 'Attachment source must not reference another session TMPDIR',
+    };
+}
+function isProtectedManagedInputClass(value) {
     return value === 'h-file' || value === 'h-directory' || value === 'l-path' || value === 'unknown';
 }
 function hasUnsafeWindowsPathSyntax(input) {
@@ -74,7 +101,7 @@ function hasUnsafeWindowsPathSyntax(input) {
     const withoutDrive = /^[A-Za-z]:\//.test(normalized) ? normalized.slice(2) : normalized;
     return withoutDrive.includes(':') || withoutDrive.split('/').some(segment => (/[. ]$/.test(segment) && segment !== '.' && segment !== '..') || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment));
 }
-function assertSessionRuntimeScope(candidate, runtime) {
+function assertSessionRuntimeScope(candidate, runtime, errorMessage) {
     if (!runtime)
         return;
     const parent = path.dirname(runtime);
@@ -83,27 +110,29 @@ function assertSessionRuntimeScope(candidate, runtime) {
     const firstSegment = path.relative(parent, candidate).split(path.sep)[0];
     if (/^ec-session-[a-f0-9]{24}$/i.test(firstSegment)
         && !isSameOrDescendant(candidate, runtime)) {
-        throw new Error('Trigger input must not reference another session TMPDIR');
+        throw new Error(errorMessage);
     }
 }
-export function readTriggerLocalFile(input, scope) {
-    const resolved = resolveTriggerLocalPath(input, scope);
+export function readManagedLocalFile(input, scope, kind) {
+    const sourceLabel = kind === 'trigger' ? 'Trigger input' : 'Attachment source';
+    const resolved = resolveManagedLocalPath(input, scope, kind);
     const expected = fs.lstatSync(resolved);
     if (!expected.isFile())
-        throw new Error('Trigger input must be a regular file');
+        throw new Error(`${sourceLabel} must be a regular file`);
     if (scope && expected.nlink !== 1)
-        throw new Error('Trigger input must not be hard-linked');
+        throw new Error(`${sourceLabel} must not be hard-linked`);
     const noFollow = fs.constants.O_NOFOLLOW ?? 0;
     const descriptor = fs.openSync(resolved, fs.constants.O_RDONLY | noFollow);
     try {
         const opened = fs.fstatSync(descriptor);
         if (!opened.isFile() || opened.dev !== expected.dev || opened.ino !== expected.ino
             || (scope && opened.nlink !== 1)
-            || resolveTriggerLocalPath(input, scope) !== resolved) {
-            throw new Error('Trigger input changed during validation');
+            || resolveManagedLocalPath(input, scope, kind) !== resolved) {
+            throw new Error(`${sourceLabel} changed during validation`);
+        }
+        if (opened.size > TRIGGER_LOCAL_FILE_LIMIT) {
+            throw new Error(`${sourceLabel} exceeds the 4 MiB limit`);
         }
-        if (opened.size > TRIGGER_LOCAL_FILE_LIMIT)
-            throw new Error('Trigger input exceeds the 4 MiB limit');
         const openedMtime = opened.mtimeMs;
         const openedCtime = opened.ctimeMs;
         const buffer = Buffer.alloc(Math.min(opened.size + 1, TRIGGER_LOCAL_FILE_LIMIT + 1));
@@ -122,8 +151,8 @@ export function readTriggerLocalFile(input, scope) {
             || !afterPath.isFile() || afterPath.isSymbolicLink()
             || afterPath.size !== opened.size || afterPath.mtimeMs !== openedMtime || afterPath.ctimeMs !== openedCtime
             || (scope && (afterRead.nlink !== 1 || afterPath.nlink !== 1))
-            || resolveTriggerLocalPath(input, scope) !== resolved) {
-            throw new Error('Trigger input changed during reading');
+            || resolveManagedLocalPath(input, scope, kind) !== resolved) {
+            throw new Error(`${sourceLabel} changed during reading`);
         }
         return buffer.subarray(0, length);
     }
@@ -131,3 +160,6 @@ export function readTriggerLocalFile(input, scope) {
         fs.closeSync(descriptor);
     }
 }
+export function readTriggerLocalFile(input, scope) {
+    return readManagedLocalFile(input, scope, 'trigger');
+}

package/dist/trigger/scheduler.js

@@ -8,6 +8,7 @@ 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';
+import { isRetryableError } from '../utils/error-utils.js';
 import { accumulateTriggerExecutionAnomalies, drainTriggerExecutionAnomalies, mergeTriggerExecutionAnomalies, } from './anomaly-store.js';
 const MAX_TIMER_MS = 2_147_483_647;
 const RUN_ABORT_SETTLE_GRACE_MS = 1_000;
@@ -441,7 +442,7 @@ export class TriggerRuntimeScheduler {
             }
             return { ok: false, runId, triggerId: definition.id, status: 'failed', reason: 'invalid_execution_configuration', audit, error: message };
         }
-        const executionAuthorization = this.runtime.authorizeExecution?.(definition);
+        const executionAuthorization = await this.runtime.authorizeExecution?.(definition);
         if (executionAuthorization && !executionAuthorization.allowed) {
             const reason = executionAuthorization.reason || 'execution_authorization_denied';
             const audit = this.buildAudit({
@@ -583,7 +584,7 @@ export class TriggerRuntimeScheduler {
             }
             if (!payload.dryRun) {
                 const executionFailed = execution.reply
-                    ? shouldRetryExecution(execution.reply)
+                    ? !['success', 'noop'].includes(execution.reply.outcome)
                     : execution.feedbackResult?.status === 'failed';
                 this.state.appendEvent(definition.id, runId, {
                     event: executionFailed ? 'execution.failed' : 'execution.completed',
@@ -758,7 +759,7 @@ export class TriggerRuntimeScheduler {
     }
     async runRecordedExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, previousAttempt) {
         const attemptId = `${runId}:attempt:${attempt}`;
-        const executionAuthorization = this.runtime.authorizeExecution?.(definition);
+        const executionAuthorization = await this.runtime.authorizeExecution?.(definition);
         if (executionAuthorization && !executionAuthorization.allowed) {
             const reply = errorReply(runId, 0, 'authorization_denied', executionAuthorization.reason || 'Trigger execution authorization denied');
             const execution = {
@@ -836,11 +837,30 @@ export class TriggerRuntimeScheduler {
                 reply,
             };
         }
+        // 复查通知里"第 N 次 / 已过多久"是**渲染期**数据，必须在每次 fire 时重算。
+        // fireCount 来自 history 聚合（skipped / dry-run 不计），本轮尚未落历史，
+        // 因此本轮序号 = 已完成次数 + 1。
+        const runNumber = this.audit.stats(definition.id).fireCount + 1;
+        const firstSentAt = Number(definition.labels?.firstSentAt);
+        const elapsedMs = Number.isFinite(firstSentAt) && firstSentAt > 0 ? Math.max(0, firedAt - firstSentAt) : undefined;
+        const triggerView = {
+            ...definition,
+            labels: {
+                ...(definition.labels ?? {}),
+                ...(Number.isFinite(firstSentAt) && firstSentAt > 0
+                    ? { firstSentAtTime: new Date(firstSentAt).toLocaleString('zh-CN', { hour12: false }) }
+                    : {}),
+            },
+        };
         const originalPrompt = renderTemplate(definition.execution.prompt ?? '', {
-            trigger: definition,
+            trigger: triggerView,
             timestamp: firedAt,
             event: sourcePayload,
             source: { type: definition.source.type, payload: sourcePayload },
+            run: {
+                number: runNumber,
+                elapsed: elapsedMs === undefined ? '' : formatElapsed(elapsedMs),
+            },
         });
         const prompt = previousAttempt
             ? renderRetryContinuationPrompt(originalPrompt, previousAttempt)
@@ -973,7 +993,8 @@ export class TriggerRuntimeScheduler {
             };
         }
         catch (err) {
-            const reply = errorReply(runId, 0, 'agent_execution_error', err?.message || String(err));
+            const errorText = err?.message || String(err);
+            const reply = errorReply(runId, 0, 'agent_execution_error', errorText, isRetryableError(err));
             return {
                 branch: 'onFailure',
                 script: null,
@@ -1059,7 +1080,7 @@ export class TriggerRuntimeScheduler {
     async reclaimOpenRun(definition, run) {
         if (!definition.enabled || !this.isResumableCheckpoint(definition, run))
             return false;
-        const executionAuthorization = this.runtime.authorizeExecution?.(definition);
+        const executionAuthorization = await this.runtime.authorizeExecution?.(definition);
         if (executionAuthorization && !executionAuthorization.allowed)
             return false;
         const session = await this.daemonChannel.getResumableConversationSession(run.executionSessionId);
@@ -1162,7 +1183,7 @@ export class TriggerRuntimeScheduler {
                 return { anomalies };
             }
             const executionFailed = execution.reply
-                ? shouldRetryExecution(execution.reply)
+                ? !['success', 'noop'].includes(execution.reply.outcome)
                 : execution.feedbackResult?.status === 'failed';
             this.state.appendEvent(definition.id, runId, {
                 event: executionFailed ? 'execution.failed' : 'execution.completed',
@@ -1348,7 +1369,8 @@ export class TriggerRuntimeScheduler {
             };
         }
         catch (error) {
-            const reply = errorReply(run.runId, 0, 'agent_execution_error', error?.message || String(error));
+            const errorText = error?.message || String(error);
+            const reply = errorReply(run.runId, 0, 'agent_execution_error', errorText, isRetryableError(error));
             return {
                 branch: 'onFailure',
                 script: null,
@@ -1839,6 +1861,7 @@ export class TriggerRuntimeScheduler {
                 ...base,
                 messageId: this.triggerOutcomeMessageId(audit),
                 error: audit.error?.message ?? audit.reason ?? 'trigger failed',
+                recoverable: audit.error?.recoverable,
                 phase: 'execute',
             });
             return;
@@ -1929,6 +1952,10 @@ function branchFromReply(reply) {
     return 'onFailure';
 }
 function shouldRetryExecution(reply) {
+    if (reply.outcome === 'success' || reply.outcome === 'noop' || reply.error?.reason === 'authorization_denied')
+        return false;
+    if (reply.error?.recoverable !== undefined)
+        return reply.error.recoverable;
     return reply.outcome === 'error'
         ? reply.error?.reason !== 'authorization_denied'
         : reply.outcome === 'timeout' || reply.outcome === 'interrupted';
@@ -1948,17 +1975,18 @@ function triggerCancellationReason(signal) {
 function shouldRetryExecutionResult(execution) {
     if (execution.reply)
         return shouldRetryExecution(execution.reply);
-    return execution.feedbackResult?.status === 'failed';
+    return execution.feedbackResult?.status === 'failed'
+        && execution.feedbackResult.error?.recoverable === true;
 }
 function statusWithExecutionAnomalies(status, anomalies) {
     return status === 'completed' && anomalies.length ? 'degraded' : status;
 }
-function errorReply(runId, durationMs, reason, text) {
+function errorReply(runId, durationMs, reason, text, recoverable) {
     return {
         outcome: 'error',
         text: '',
         files: [],
-        error: { reason, text },
+        error: { reason, text, ...(recoverable !== undefined ? { recoverable } : {}) },
         meta: {
             runId,
             durationMs,
@@ -2013,6 +2041,7 @@ function replyErrorSummary(reply, fallbackCode) {
     return {
         code: reply.error?.reason || fallbackCode,
         message: previewText(reply.error?.text || `Trigger attempt ${fallbackCode}`, 600),
+        ...(reply.error?.recoverable !== undefined ? { recoverable: reply.error.recoverable } : {}),
     };
 }
 function errorSummary(error, fallbackCode) {
@@ -2224,6 +2253,23 @@ function executionAnomaliesFromError(error) {
 function limitsSignature(limits) {
     return JSON.stringify(limits ?? null);
 }
+/** 人类可读的时长（复查通知里"已过"字段）：`25 分钟` / `3 小时 5 分钟` / `2 天`。 */
+function formatElapsed(ms) {
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 1)
+        return '不到 1 分钟';
+    const days = Math.floor(minutes / 1440);
+    const hours = Math.floor((minutes % 1440) / 60);
+    const mins = minutes % 60;
+    const parts = [];
+    if (days)
+        parts.push(`${days} 天`);
+    if (hours)
+        parts.push(`${hours} 小时`);
+    if (mins)
+        parts.push(`${mins} 分钟`);
+    return parts.join(' ') || '不到 1 分钟';
+}
 function mergeStats(legacy, current) {
     if (!legacy)
         return current;

package/dist/trigger/system-definitions.js

@@ -102,6 +102,7 @@ export function seedTaskRecoveryTrigger(manager, owner) {
         source: {
             type: 'event',
             eventPattern: 'task:error',
+            filter: { match: { recoverable: true } },
         },
         execution: {
             type: 'target_session',

package/dist/trigger/validation.js

@@ -2,6 +2,7 @@ import path from 'path';
 import crypto from 'crypto';
 import { normalizePermissionMode as normalizePermissionModeContract } from '../core/permission/mode.js';
 import { formatChannelKey } from '../core/channel-loader.js';
+import { isTopicThreadId } from '../core/thread/topic-id.js';
 const MAX_SCRIPT_TIMEOUT_MS = 900_000;
 const TRIGGER_SESSION_TIMEOUT_MS = 30 * 60_000;
 const MAX_EXECUTION_TIMEOUT_MS = 2_147_483_647;
@@ -204,6 +205,7 @@ export function renderTemplate(template, ctx) {
         error: ctx.error,
         event: ctx.event,
         source: ctx.source,
+        run: ctx.run,
     };
     const source = template ?? defaultTemplate(fullCtx);
     return source.replace(/\{\{\s*([A-Za-z0-9_.]+)\s*\}\}/g, (_m, key) => {
@@ -243,6 +245,7 @@ function normalizeV3Phase2(raw, opts) {
         name,
         description: optionalString(raw.description),
         authorizedBy: optionalString(raw.authorizedBy),
+        operatorPeers: normalizeOperatorPeers(raw.operatorPeers),
         createdAt,
         updatedAt,
         origin: normalizeOrigin(raw.origin),
@@ -269,18 +272,35 @@ function normalizeV3Phase2(raw, opts) {
     validateTriggerSemantics(definition);
     return definition;
 }
+/** 操作主体列表：字符串数组、去重、截断到 16 项；保证落盘值可直接用于权限比对。 */
+function normalizeOperatorPeers(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new Error('operatorPeers must be an array of AID strings');
+    const peers = [];
+    for (const item of value) {
+        if (typeof item !== 'string' || !item.trim()) {
+            throw new Error('operatorPeers entries must be non-empty strings');
+        }
+        const peer = item.trim();
+        if (!peers.includes(peer))
+            peers.push(peer);
+    }
+    if (peers.length === 0)
+        return undefined;
+    if (peers.length > 16)
+        throw new Error('operatorPeers supports at most 16 entries');
+    return peers;
+}
 function normalizeOrigin(value) {
     if (value === undefined)
         return undefined;
     if (!isObject(value))
         throw new Error('origin must be an object');
     const raw = value;
-    const rawSession = normalizeSessionKind(raw.session, 'origin.session');
     const threadId = optionalString(raw.threadId);
-    if (rawSession === 'main' && threadId)
-        throw new Error('origin.threadId is not allowed when origin.session=main');
-    if (rawSession === 'thread' && !threadId)
-        throw new Error('origin.threadId is required when origin.session=thread');
+    const rawSession = inferSessionKind(threadId, raw.session, 'origin.session');
     const rawChannelId = requiredString(raw.channelId, 'origin.channelId');
     const peerId = optionalString(raw.peerId);
     const channelKey = requiredString(raw.channelKey, 'origin.channelKey');
@@ -572,12 +592,8 @@ function normalizeFeedbackTarget(value, label, agentAid) {
     if (!isObject(value))
         throw new Error(`${label} must be an object`);
     const raw = value;
-    const session = normalizeSessionKind(raw.session, `${label}.session`);
     const threadId = optionalString(raw.threadId);
-    if (session === 'main' && threadId)
-        throw new Error(`${label}.threadId is not allowed when ${label}.session=main`);
-    if (session === 'thread' && !threadId)
-        throw new Error(`${label}.threadId is required when ${label}.session=thread`);
+    const session = inferSessionKind(threadId, raw.session, `${label}.session`);
     const channelKey = requiredString(raw.channelKey, `${label}.channelKey`);
     const channelId = requiredString(raw.channelId, `${label}.channelId`);
     const rawChatType = raw.chatType;
@@ -615,11 +631,24 @@ function normalizeFeedbackTemplate(value, label) {
     const raw = value;
     return { template: optionalTemplate(raw.template) };
 }
-function normalizeSessionKind(value, label) {
-    const session = optionalString(value) ?? 'main';
-    if (session !== 'main' && session !== 'thread')
-        throw new Error(`${label} must be main or thread`);
-    return session;
+/**
+ * 从 threadId 自动推导 session 类型。用户填写的 session 必须与推导结果一致。
+ * - threadId 不存在 → 'main'
+ * - threadId 是主话题 id → 'main'
+ * - threadId 是话题 id → 'thread'
+ */
+function inferSessionKind(threadId, rawSession, label) {
+    const inferred = threadId && isTopicThreadId(threadId) ? 'thread' : 'main';
+    const explicit = optionalString(rawSession);
+    if (explicit !== undefined) {
+        if (explicit !== 'main' && explicit !== 'thread') {
+            throw new Error(`${label} must be main or thread`);
+        }
+        if (explicit !== inferred) {
+            throw new Error(`${label}=${explicit} conflicts with threadId: ${threadId ? `"${threadId}" requires session=` + inferred : 'missing threadId requires session=main'}`);
+        }
+    }
+    return inferred;
 }
 function normalizeReliability(value) {
     if (value === undefined) {