evolcore 0.0.20 → 0.0.22

package/dist/paths.js

@@ -3,6 +3,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 import { DAEMON_CONFIG_FILENAME, DEFAULT_RUNTIME_HOME_DIRNAME, INSTANCE_SOCKET_FILENAME, RUNTIME_HOME_ENV, WINDOWS_PIPE_PREFIX, } from './product.js';
+import { migrateLegacyAgentJsonlLogs } from './core/audit/log-integrity.js';
 const isWindows = process.platform === 'win32';
 let _root = null;
 export function resolveRoot() {
@@ -118,9 +119,6 @@ export function agentVenuesDir(aid) {
 export function agentSessionsDir(aid) {
     return path.join(agentDir(aid), 'sessions');
 }
-export function agentLogsDir(aid) {
-    return path.join(agentDir(aid), 'logs');
-}
 export function agentDataDir(aid) {
     return path.join(agentDir(aid), 'data');
 }
@@ -133,6 +131,9 @@ export function agentHandoffDir(aid) {
 export function agentOutboxPath(aid) {
     return path.join(agentDataDir(aid), 'outbox.jsonl');
 }
+export function agentActivityOutboxPath(aid) {
+    return path.join(agentDataDir(aid), 'activity-outbox.jsonl');
+}
 /** Directory-safe channel instance key used by connector runtime state. */
 function encodePathKey(value) {
     return encodeURIComponent(value);
@@ -161,11 +162,84 @@ export function channelStatePath(channelKey, ...parts) {
 export function agentTriggersDir(aid) {
     return path.join(agentDir(aid), 'triggers');
 }
-function resolveInstanceSocketPath(root) {
-    if (isWindows) {
-        const hash = crypto.createHash('sha1').update(root).digest('hex').slice(0, 12);
-        return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-${hash}`;
+function stripTrailingWindowsSeparators(value) {
+    const stripped = value.replace(/[\\/]+$/g, '');
+    // Keep a drive-root separator. `C:` is a drive-relative path on Windows.
+    if (/^[a-zA-Z]:$/.test(stripped) && /^[a-zA-Z]:[\\/]+$/.test(value)) {
+        return `${stripped}\\`;
     }
+    return stripped;
+}
+function normalizeWindowsSocketRoot(root) {
+    // Use win32 semantics explicitly: EVOLCORE_HOME can come from Git Bash even
+    // when the daemon itself runs under native Windows Node.
+    return stripTrailingWindowsSeparators(path.win32.resolve(root)).toLowerCase();
+}
+function windowsSocketPathForRoot(root) {
+    const hash = crypto.createHash('sha1').update(root).digest('hex').slice(0, 12);
+    return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-${hash}`;
+}
+/**
+ * Normalize an IPC endpoint before it reaches node:net.
+ *
+ * Windows does not support Unix-domain socket files at ordinary filesystem
+ * paths. Callers that construct an ad-hoc `.sock` path (tests and embedded
+ * runtimes in particular) must therefore use the same deterministic named
+ * pipe on both the server and client sides. Existing named pipes and all
+ * non-Windows endpoints are preserved verbatim.
+ */
+export function normalizeIpcEndpoint(endpoint) {
+    // Windows object-manager paths are case-insensitive. Preserve an explicit
+    // named pipe verbatim even when a caller spells the namespace as `PIPE`.
+    if (!isWindows || endpoint.toLowerCase().startsWith('\\\\.\\pipe\\'))
+        return endpoint;
+    const normalized = path.win32.resolve(endpoint).toLowerCase();
+    const hash = crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 20);
+    return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-endpoint-${hash}`;
+}
+/**
+ * Return the canonical and pre-normalization Windows daemon pipe names.
+ *
+ * The extra candidates keep a daemon started by an older EvolCore build
+ * reachable while it is still running after the CLI has been upgraded.
+ */
+export function getWindowsInstanceSocketPathCandidates(root) {
+    const normalized = path.win32.normalize(root);
+    const normalizedForward = stripTrailingWindowsSeparators(normalized.replace(/\\/g, '/'));
+    const canonical = normalizeWindowsSocketRoot(root);
+    const baseVariants = [
+        canonical,
+        root,
+        normalized,
+        normalizedForward,
+        canonical.replace(/\\/g, '/'),
+        root.replace(/\\/g, '/'),
+        root.replace(/\//g, '\\'),
+    ];
+    const variants = new Set();
+    for (const variant of baseVariants) {
+        const stripped = stripTrailingWindowsSeparators(variant);
+        variants.add(variant);
+        variants.add(stripped);
+        if (stripped) {
+            variants.add(`${stripped}\\`);
+            variants.add(`${stripped}/`);
+        }
+    }
+    const seen = new Set();
+    const candidates = [];
+    for (const variant of variants) {
+        const socket = windowsSocketPathForRoot(variant);
+        if (seen.has(socket))
+            continue;
+        seen.add(socket);
+        candidates.push(socket);
+    }
+    return candidates;
+}
+function resolveInstanceSocketPath(root) {
+    if (isWindows)
+        return getWindowsInstanceSocketPathCandidates(root)[0];
     const filesystemPath = path.join(root, 'data', 'instance', INSTANCE_SOCKET_FILENAME);
     // Linux/macOS Unix-domain sockets have a small sockaddr path limit
     // (typically 108 bytes on Linux). Long managed TMPDIR prefixes can make a
@@ -196,6 +270,7 @@ export function ensureDataDirs() {
     fs.mkdirSync(p.outboxDir, { recursive: true });
     fs.mkdirSync(p.eckDir, { recursive: true });
     fs.mkdirSync(aidsDir(), { recursive: true });
+    migrateLegacyAgentJsonlLogs(p.agentsDir, p.logs);
     migrateFromAun();
 }
 const MIGRATION_MARKER = '.migrated-from-aun';

package/dist/response-system/context-builder.js

@@ -12,7 +12,6 @@
  * （Phase 6）真正需要时接入 Runner，当前提供明确的"未实现"占位，避免空壳代码。
  */
 import path from 'path';
-import fs from 'fs';
 export class ResponseModeContextBuilder {
     /** (sessionId::modeId) → sessionState，跨消息保持 */
     stateCache = new Map();
@@ -22,7 +21,7 @@ export class ResponseModeContextBuilder {
      */
     build(modeId, deps) {
         const sessionState = this.getOrCreateState(deps.session.id, modeId);
-        const dataDir = this.ensureDataDir(deps.agentDir, modeId);
+        const dataDir = path.join(deps.agentDir, 'response-system', modeId);
         return {
             session: deps.session,
             agentConfig: deps.agentConfig,
@@ -63,9 +62,4 @@ export class ResponseModeContextBuilder {
         }
         return state;
     }
-    ensureDataDir(agentDir, modeId) {
-        const dir = path.join(agentDir, 'response-system', modeId);
-        fs.mkdirSync(dir, { recursive: true });
-        return dir;
-    }
 }

package/dist/response-system/engines/v1/proactive-flow.js

@@ -197,6 +197,7 @@ export const proactiveFlow = {
                 const queueMsg = queueLen >= 5
                     ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
                     : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
+                ctx.recordReminder?.({ kind: 'queue_unread', text: queueMsg, queueLength: queueLen });
                 ctx.injectToModel(queueMsg);
             }
         }
@@ -208,13 +209,17 @@ export const proactiveFlow = {
             state.toolReportPending = true;
             const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
             const target = state.chatType === 'group' ? '群里' : '对方';
-            ctx.injectToModel(`⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`);
+            const reportMsg = `⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`;
+            ctx.recordReminder?.({ kind: 'tool_report', text: reportMsg, toolCount: state.toolCount });
+            ctx.injectToModel(reportMsg);
         }
     },
     // ─── onToolResult：成功发送回执后解除门禁 ───
     onToolResult(ctx) {
         const state = ctx.state.get(STATE_KEY);
-        if (!state || !ctx.isSendCommand(ctx.toolName, ctx.toolInput))
+        if (!state)
+            return;
+        if (!ctx.isSendCommand(ctx.toolName, ctx.toolInput))
             return;
         if (!hasSuccessfulSendReceipt(ctx.result, ctx.isError || !!ctx.error))
             return;

package/dist/stats/price-resolver.js

@@ -5,6 +5,10 @@
 import { resolvePriceRow, BILLING_FNS } from './billing.js';
 import fs from 'fs';
 import path from 'path';
+/** Keep wire/log metadata readable while preserving full precision in storage. */
+export function roundCostForOutput(value) {
+    return Number.isFinite(value) ? Number(value.toFixed(4)) : value;
+}
 // 网关价格表缓存（从用户覆盖层 model-prices-gateway.jsonl 读取）
 let _gatewayPriceCache = null;
 let _gatewayPriceCacheTs = 0;

package/dist/trigger/anomaly-store.js

@@ -252,6 +252,7 @@ function anomalyClassKey(anomaly) {
         anomaly.phase,
         anomaly.toolName,
         anomaly.policyCode,
+        anomaly.decisionSource,
         anomaly.policy,
         anomaly.agentAid,
         anomaly.sessionId,

package/dist/trigger/feedback.js

@@ -37,8 +37,11 @@ export class TriggerFeedbackDispatcher {
         const result = await this.dispatchDirect(input, renderedText, target);
         if (result.error)
             return { status: 'failed', reason: result.error.code, feedback, effects: result.effects, error: result.error };
+        const replyStatus = statusFromReply(input.reply);
         return {
-            status: statusFromReply(input.reply),
+            status: result.effects.some(effect => effect.status === 'queued') && replyStatus !== 'failed'
+                ? 'degraded'
+                : replyStatus,
             reason: reasonFromReply(input.reply),
             feedback,
             effects: result.effects,
@@ -204,6 +207,7 @@ export class TriggerFeedbackDispatcher {
                     originChannelType: input.trigger.origin?.channelType
                         ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
                     originControl: input.trigger.origin?.channelKey === 'daemon',
+                    authorizedBy: input.trigger.authorizedBy,
                 },
             };
             outcome = this.waitForTriggerOutcome(input.runId, input.attemptId, delivery.signal);
@@ -247,12 +251,24 @@ export class TriggerFeedbackDispatcher {
                     };
                 }
                 if (event?.type === 'trigger:skipped') {
+                    const interruption = event.executionState === 'interrupted' && event.decisionSource === 'infrastructure'
+                        ? {
+                            reasonCode: event.reasonCode ?? event.reason,
+                            decisionSource: event.decisionSource,
+                            executionState: event.executionState,
+                            ...(event.generation !== undefined ? { generation: event.generation } : {}),
+                            ...(event.currentGeneration !== undefined ? { currentGeneration: event.currentGeneration } : {}),
+                        }
+                        : undefined;
                     return {
-                        status: 'failed',
+                        status: interruption ? 'skipped' : 'failed',
                         reason: event.reason,
+                        ...(interruption ? { interruption } : {}),
                         feedback,
                         effects: [this.inboundEffect('success', target, session.id, startedAt)],
-                        error: { code: event.reason || 'target_session_skipped', message: event.reason || 'target session skipped' },
+                        error: interruption
+                            ? null
+                            : { code: event.reason || 'target_session_skipped', message: event.reason || 'target session skipped' },
                     };
                 }
                 return {
@@ -379,7 +395,7 @@ export class TriggerFeedbackDispatcher {
                     if (isAunTarget && !targetChatType(target)) {
                         throw Object.assign(new Error('AUN trigger feedback requires an explicit delivery route'), { code: 'AUN_OUTBOUND_ROUTE_REQUIRED' });
                     }
-                    await raceWithAbort(binding.adapter.send(buildEnvelope({
+                    const receipt = await raceWithAbort(binding.adapter.send(buildEnvelope({
                         taskId: `trigger:${input.runId}`,
                         channel: binding.adapter.channelKey,
                         channelId: target.channelId,
@@ -394,16 +410,60 @@ export class TriggerFeedbackDispatcher {
                         isFinal: true,
                         format: 'plain',
                     }), cancellation.signal);
-                    effects.push({
+                    const common = {
                         type: 'message.send',
-                        status: 'success',
                         channelKey: target.channelKey,
                         channelType: channelTypeFromKey(target.channelKey),
                         channelId: target.channelId,
                         attempt,
                         startedAt,
                         finishedAt: Date.now(),
-                    });
+                    };
+                    if (receipt?.status === 'sent' && receipt.messageId) {
+                        effects.push({ ...common, status: 'success', operationId: receipt.operationId, messageId: receipt.messageId });
+                        return { effects, error: null };
+                    }
+                    if (receipt?.status === 'queued') {
+                        effects.push({
+                            ...common,
+                            status: 'queued',
+                            operationId: receipt.operationId,
+                            outboxId: receipt.outboxId,
+                            error: receipt.error,
+                            code: receipt.code,
+                        });
+                        return { effects, error: null };
+                    }
+                    if (receipt?.status === 'failed') {
+                        effects.push({
+                            ...common,
+                            status: 'failed',
+                            operationId: receipt.operationId,
+                            outboxId: receipt.outboxId,
+                            error: receipt.error,
+                            code: receipt.code,
+                        });
+                        return {
+                            effects,
+                            error: {
+                                code: String(receipt.code ?? 'send_failed'),
+                                message: receipt.error,
+                            },
+                        };
+                    }
+                    if (receipt?.status === 'suppressed') {
+                        const message = `channel suppressed trigger feedback: ${receipt.reason}`;
+                        effects.push({ ...common, status: 'skipped', error: message, code: 'SEND_SUPPRESSED' });
+                        return { effects, error: { code: 'send_suppressed', message } };
+                    }
+                    if (isAunTarget) {
+                        const message = 'AUN adapter returned no delivery receipt';
+                        effects.push({ ...common, status: 'failed', error: message, code: 'MISSING_SEND_RECEIPT' });
+                        return { effects, error: { code: 'missing_send_receipt', message } };
+                    }
+                    // Non-AUN adapters are still allowed to use the legacy void result
+                    // until their receipt migration is complete.
+                    effects.push({ ...common, status: 'success' });
                     return { effects, error: null };
                 }
                 catch (err) {
@@ -527,6 +587,9 @@ export class TriggerFeedbackDispatcher {
         const status = Number(err?.status ?? err?.statusCode ?? err?.code);
         const rawCode = String(err?.code ?? err?.errorCode ?? '').toLowerCase();
         const lower = `${message} ${rawCode}`.toLowerCase();
+        if (rawCode === 'outbox_full') {
+            return { retryable: false, code: 'OUTBOX_FULL', message };
+        }
         if (status === 408 || status === 429 || status >= 500) {
             return { retryable: true, code: 'send_retryable_error', message };
         }

package/dist/trigger/history.js

@@ -2,7 +2,11 @@ import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { isManagedSessionRuntimeDir, SESSION_RUNTIME_DIR_ENV } from '../cli/task-context.js';
+import { findMessageLogOperationMessageId } from '../core/message/message-log.js';
+import { chatDirPath } from '../core/session/session-fs-store.js';
+import { resolvePaths } from '../paths.js';
 import { definitionRevision } from './validation.js';
+import * as aunOutbox from '../aun/outbox.js';
 export class TriggerHistoryStore {
     rootDir;
     agentAid;
@@ -66,7 +70,7 @@ export class TriggerHistoryStore {
                 continue;
             if (triggerId && event.triggerId !== triggerId)
                 continue;
-            out.push(event);
+            out.push(hydrateHistoryEvent(event));
         }
         return out;
     }
@@ -80,7 +84,7 @@ export class TriggerHistoryStore {
             if (!event || !isRunEvent(event))
                 continue;
             if (event.agentAid === this.agentAid && event.triggerId === triggerId) {
-                out.push(event.audit);
+                out.push(hydrateTriggerAudit(event.audit));
             }
         }
         return out;
@@ -95,7 +99,7 @@ export class TriggerHistoryStore {
             const event = parseHistoryEvent(lines[i], this.agentAid);
             if (!event || !isRunEvent(event) || !pending.has(event.triggerId))
                 continue;
-            latest.set(event.triggerId, event.audit);
+            latest.set(event.triggerId, hydrateTriggerAudit(event.audit));
             pending.delete(event.triggerId);
         }
         return latest;
@@ -125,7 +129,7 @@ export class TriggerHistoryStore {
             }
             if (!isRunEvent(event))
                 continue;
-            const record = event.audit;
+            const record = hydrateTriggerAudit(event.audit);
             if (record.status !== 'completed'
                 && record.status !== 'degraded'
                 && record.status !== 'noop'
@@ -310,6 +314,77 @@ function finiteNumber(value) {
 function nonNegativeInteger(value) {
     return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
 }
+function hydrateHistoryEvent(event) {
+    if (!isRunEvent(event))
+        return event;
+    return { ...event, audit: hydrateTriggerAudit(event.audit) };
+}
+/**
+ * Resolve queued AUN effects against the durable outbox at read time. The
+ * original audit is append-only, so this projection is what lets a later
+ * expiry become visibly failed without pretending that a missing outbox row
+ * was delivered.
+ */
+function hydrateTriggerAudit(audit) {
+    let changed = false;
+    let deliveryFailure;
+    const effects = audit.effects.map(effect => {
+        if (effect.status !== 'queued' || !effect.outboxId)
+            return effect;
+        const state = aunOutbox.deliveryState(audit.agentAid, effect.outboxId);
+        if (state.status === 'sent') {
+            changed = true;
+            return { ...effect, status: 'success', messageId: state.messageId };
+        }
+        if (state.status === 'failed') {
+            changed = true;
+            deliveryFailure ??= { code: String(state.code ?? 'OUTBOX_DELIVERY_FAILED'), message: state.error };
+            return { ...effect, status: 'failed', error: state.error, ...(state.code !== undefined ? { code: state.code } : {}) };
+        }
+        if (state.status === 'missing' && isAunEffect(effect)) {
+            const messageId = findDeliveredEffectMessageId(audit.agentAid, effect);
+            changed = true;
+            if (messageId) {
+                return { ...effect, status: 'success', messageId };
+            }
+            const code = 'OUTBOX_RESULT_MISSING';
+            const error = 'outbox delivery result is missing and no remote message_id was recorded';
+            deliveryFailure ??= { code, message: error };
+            return { ...effect, status: 'failed', error, code };
+        }
+        return effect;
+    });
+    if (!changed)
+        return audit;
+    if (!deliveryFailure) {
+        const hasQueuedEffect = effects.some(effect => effect.status === 'queued');
+        const hasFailedEffect = effects.some(effect => effect.status === 'failed');
+        const canRestoreReplyStatus = audit.status === 'degraded'
+            && !hasQueuedEffect
+            && !hasFailedEffect
+            && !audit.anomalies?.length;
+        const status = canRestoreReplyStatus
+            ? audit.reply?.outcome === 'noop' ? 'noop' : 'completed'
+            : audit.status;
+        return { ...audit, status, effects };
+    }
+    return {
+        ...audit,
+        status: 'failed',
+        reason: deliveryFailure.code,
+        effects,
+        error: deliveryFailure,
+    };
+}
+function isAunEffect(effect) {
+    return effect.channelType === 'aun' || effect.channelKey?.startsWith('aun#') === true;
+}
+function findDeliveredEffectMessageId(agentAid, effect) {
+    if (!effect.operationId || !effect.channelId)
+        return undefined;
+    const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', effect.channelId, agentAid);
+    return findMessageLogOperationMessageId(chatDir, effect.operationId);
+}
 function listAuditLogFiles(logDir) {
     let entries;
     try {

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

@@ -1,13 +1,13 @@
-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 historyChannels = new Set(['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom']);
     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))
+        if (!historyChannels.has(channel))
             return match;
         const isAun = channel === 'aun';
         const target = isAun ? second : first;

package/dist/trigger/parser.js

@@ -2,6 +2,7 @@ import { CronExpressionParser } from 'cron-parser';
 const TRIGGER_UPDATE_FLAGS = new Set([
     'once', 'delay', 'at', 'cron', 'every', 'event', 'tz',
     'prompt', 'name',
+    'script-file',
     'model', 'effort', 'permission',
     'max-runs', 'max-duration', 'concurrency', 'missed-policy',
 ]);
@@ -113,6 +114,7 @@ const PERMISSION_MODES = new Set([
     'auto',
     'request',
     'bypass',
+    'fullaccess',
 ]);
 const TRIGGER_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 function parsePermissionModeFlag(flags, opts = {}) {
@@ -124,10 +126,10 @@ function parsePermissionModeFlag(flags, opts = {}) {
     if (raw === 'inherit') {
         if (opts.allowInherit)
             return { ok: true, value: null };
-        return { ok: false, error: '--permission 创建时只能接受 readonly、auto、request 或 bypass' };
+        return { ok: false, error: '--permission 创建时只能接受 readonly、auto、request、bypass 或 fullaccess' };
     }
     if (!PERMISSION_MODES.has(raw)) {
-        return { ok: false, error: '--permission 只接受 readonly、auto、request 或 bypass' };
+        return { ok: false, error: '--permission 只接受 readonly、auto、request、bypass 或 fullaccess' };
     }
     return { ok: true, value: raw };
 }
@@ -551,7 +553,7 @@ export function parseTriggerUpdateArgv(nameOrId, args, opts = {}) {
     const parsedFlags = flagsFromArgv(args, 'update');
     if (!parsedFlags.ok)
         return { ok: false, error: withPromptFileHint(parsedFlags.error, args, opts) };
-    const parsed = parseTriggerUpdateFlags(nameOrId, parsedFlags.flags, opts);
+    const parsed = parseTriggerUpdateFlags(nameOrId, parsedFlags.flags, { ...opts, allowScriptFile: true });
     return parsed.ok ? parsed : { ok: false, error: withPromptFileHint(parsed.error, args, opts) };
 }
 function flagsFromArgv(args, command) {
@@ -584,6 +586,9 @@ function parseTriggerUpdateFlags(nameOrId, flags, opts = {}) {
         if (!TRIGGER_UPDATE_FLAGS.has(flag))
             return { ok: false, error: `update 不支持参数 --${flag}` };
     }
+    if (flags.has('script-file') && !opts.allowScriptFile) {
+        return { ok: false, error: '--script-file 仅支持 ec trigger update CLI；请通过受控 CLI 上传脚本文件' };
+    }
     const parsed = commonParsed(flags, { update: true, ...opts });
     if (!parsed.ok)
         return parsed;
@@ -606,6 +611,11 @@ function parseTriggerUpdateFlags(nameOrId, flags, opts = {}) {
         update.name = value.name;
     if (value.prompt !== undefined)
         update.prompt = value.prompt;
+    const scriptFile = optionalFlagString(flags, 'script-file');
+    if ('error' in scriptFile)
+        return { ok: false, error: scriptFile.error };
+    if (scriptFile.value !== undefined)
+        update.scriptFile = scriptFile.value;
     if (value.model !== undefined)
         update.model = value.model;
     if (value.effort !== undefined)

package/dist/trigger/scheduler.js

@@ -120,12 +120,12 @@ export class TriggerRuntimeScheduler {
     }
     listItems(definitions) {
         const latestRuns = this.audit.latest(definitions.map(definition => definition.id));
-        return definitions.map(definition => this.buildListItem(definition, latestRuns.get(definition.id)));
+        return definitions.map(definition => this.buildListItem(definition, latestRuns.get(definition.id), this.stats(definition.id)));
     }
     listItem(definition) {
-        return this.buildListItem(definition, this.audit.recent(definition.id, 1)[0]);
+        return this.buildListItem(definition, this.audit.recent(definition.id, 1)[0], this.stats(definition.id));
     }
-    buildListItem(definition, lastRun) {
+    buildListItem(definition, lastRun, stats = this.stats(definition.id)) {
         const schedule = this.state.readSchedule(definition.id);
         return {
             id: definition.id,
@@ -139,6 +139,10 @@ export class TriggerRuntimeScheduler {
                 ...(definition.feedback.target ? { target: definition.feedback.target } : {}),
             },
             ...(schedule ? { nextFireAt: schedule.nextFireAt } : {}),
+            fireCount: stats.fireCount,
+            failCount: stats.failCount,
+            ...(stats.lastFiredAt !== undefined ? { lastFiredAt: stats.lastFiredAt } : {}),
+            ...(stats.lastResult ? { lastResult: stats.lastResult } : {}),
             ...(lastRun ? { lastStatus: lastRun.status, lastFinishedAt: lastRun.finishedAt } : {}),
             updatedAt: definition.updatedAt,
         };
@@ -627,6 +631,7 @@ export class TriggerRuntimeScheduler {
                 effects: feedbackResult.effects,
                 error: feedbackResult.error,
                 conflictRunId: feedbackResult.conflictRunId,
+                interruption: feedbackResult.interruption,
                 causation,
             });
             if (!payload.dryRun) {
@@ -1147,6 +1152,7 @@ export class TriggerRuntimeScheduler {
                 anomalies,
                 effects: feedbackResult.effects,
                 error: feedbackResult.error,
+                interruption: feedbackResult.interruption,
                 causation,
             });
             this.audit.write(audit);
@@ -1469,6 +1475,7 @@ export class TriggerRuntimeScheduler {
             status: input.status,
             reason: input.reason,
             conflictRunId: input.conflictRunId,
+            ...(input.interruption ? { interruption: input.interruption } : {}),
             ...(activeRun?.executionSessionId ? { executionSessionId: activeRun.executionSessionId } : {}),
             ...(attempts?.length ? { attempts } : {}),
             ...(finalAttempt ? { finalAttempt: finalAttempt.attempt } : {}),
@@ -1783,6 +1790,7 @@ export class TriggerRuntimeScheduler {
                 type: 'trigger:skipped',
                 ...base,
                 reason: audit.reason ?? 'skipped',
+                ...(audit.interruption ?? {}),
             });
         }
     }
@@ -1900,6 +1908,15 @@ function errorReply(runId, durationMs, reason, text) {
 }
 function attemptSummaryFromExecution(attempt, attemptId, execution) {
     if (execution.feedbackResult) {
+        if (execution.feedbackResult.interruption) {
+            return {
+                status: 'interrupted',
+                error: {
+                    code: execution.feedbackResult.interruption.reasonCode,
+                    message: execution.feedbackResult.reason ?? execution.feedbackResult.interruption.reasonCode,
+                },
+            };
+        }
         const failed = execution.feedbackResult.status !== 'completed';
         return {
             status: failed ? 'failed' : 'completed',

package/dist/trigger/validation.js

@@ -13,6 +13,7 @@ const PERMISSION_MODES = new Set([
     'auto',
     'request',
     'bypass',
+    'fullaccess',
 ]);
 export function normalizeTriggerDefinition(input, opts = {}) {
     if (!isObject(input))
@@ -234,6 +235,7 @@ function normalizeV3Phase2(raw, opts) {
         enabled: raw.enabled === undefined ? true : requiredBoolean(raw.enabled, 'enabled'),
         name,
         description: optionalString(raw.description),
+        authorizedBy: optionalString(raw.authorizedBy),
         createdAt,
         updatedAt,
         origin: normalizeOrigin(raw.origin),
@@ -438,6 +440,9 @@ function normalizeExecution(value, _opts) {
         onError: normalizeOnError(raw.onError),
         noopSentinel: optionalString(raw.noopSentinel) ?? DEFAULT_NOOP_SENTINEL,
     };
+    if (execution.type === 'script' && execution.permissionMode === 'fullaccess') {
+        throw new Error('script Trigger already executes as the daemon OS user and cannot declare execution.permissionMode=fullaccess');
+    }
     return execution;
 }
 function normalizeExecutionBaseagent(value) {
@@ -478,7 +483,7 @@ function normalizeTriggerPermissionMode(value) {
     if (mode === 'edit' || mode === 'noask' || mode === 'plan') {
         return normalizePermissionModeContract(mode).mode;
     }
-    throw new Error('execution.permissionMode must be one of readonly, auto, request, bypass');
+    throw new Error('execution.permissionMode must be one of readonly, auto, request, bypass, fullaccess');
 }
 function normalizeScript(value) {
     if (!isObject(value))