evolcore 0.0.12 → 0.0.13

package/dist/paths.js

@@ -149,6 +149,9 @@ export function daemonControlDir() {
 export function daemonQueuePath() {
     return path.join(daemonDataDir(), 'message-queue.json');
 }
+export function daemonMessageDedupPath() {
+    return path.join(daemonDataDir(), 'message-dedup.json');
+}
 export function channelStateDir(channelKey) {
     if (!channelKey || channelKey === '.' || channelKey === '..') {
         throw new Error('channelKey is required');

package/dist/trigger/feedback.js

@@ -23,9 +23,13 @@ export class TriggerFeedbackDispatcher {
                 dryRunText: renderedText,
             };
         }
-        const target = this.resolveDeliveryTarget(input.trigger);
-        if (!target)
+        const unresolvedTarget = this.resolveDeliveryTarget(input.trigger);
+        if (!unresolvedTarget)
             return this.failed(feedback, [], 'target_missing', 'trigger feedback target is missing');
+        const target = unresolvedTarget;
+        if (channelTypeFromKey(target.channelKey) === 'aun' && !targetChatType(target)) {
+            return this.failed(feedback, [], 'route_missing', 'AUN trigger feedback has no explicit delivery route');
+        }
         feedback.target = target;
         if (input.dryRun) {
             return { status: 'dry-run', feedback, effects: [], error: null, dryRunText: renderedText };
@@ -43,9 +47,13 @@ export class TriggerFeedbackDispatcher {
     }
     async dispatchTargetSession(input) {
         const feedback = this.auditFeedback(input.trigger);
-        const target = this.resolveDeliveryTarget(input.trigger);
-        if (!target)
+        const unresolvedTarget = this.resolveDeliveryTarget(input.trigger);
+        if (!unresolvedTarget)
             return this.failed(feedback, [], 'target_missing', 'target_session feedback target is missing');
+        const target = unresolvedTarget;
+        if (channelTypeFromKey(target.channelKey) === 'aun' && !targetChatType(target)) {
+            return this.failed(feedback, [], 'route_missing', 'AUN target_session has no explicit delivery route');
+        }
         feedback.target = target;
         feedback.renderedTextHash = sha256(input.prompt);
         feedback.renderedTextPreview = previewText(input.prompt);
@@ -105,7 +113,14 @@ export class TriggerFeedbackDispatcher {
                         ? undefined
                         : await raceWithAbort(Promise.resolve(mainLookup), delivery.signal);
                     const mainMetadata = main?.metadata;
-                    const chatType = main?.chatType === 'group' ? 'group' : 'private';
+                    const targetDelivery = targetDeliveryFor(target);
+                    const chatType = targetDelivery?.chatType
+                        ?? (main?.chatType === 'group' ? 'group' : 'private');
+                    const groupId = targetDelivery?.chatType === 'group'
+                        ? targetDelivery.groupId
+                        : targetDelivery?.chatType === 'private'
+                            ? undefined
+                            : mainMetadata?.groupId;
                     const peerId = mainMetadata?.peerId ?? `trigger:${input.trigger.id}`;
                     const peerType = mainMetadata?.peerType ?? 'system';
                     session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, main?.projectPath ?? binding.projectPath, target.threadId, {
@@ -113,13 +128,20 @@ export class TriggerFeedbackDispatcher {
                         peerId,
                         peerName: mainMetadata?.peerName ?? input.trigger.name,
                         peerType,
-                        ...(mainMetadata?.groupId ? { groupId: mainMetadata.groupId } : {}),
+                        ...(groupId ? { groupId } : {}),
                         ...(mainMetadata?.groupName ? { groupName: mainMetadata.groupName } : {}),
                         replyContext: replyContextFromTarget(target),
                     }, input.trigger.name, peerId, chatType, main?.baseagent ?? binding.baseagent, main?.selfAID ?? input.trigger.agentAid, main?.channelType ?? channelType, peerType), delivery.signal);
                 }
                 else {
-                    session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, binding.projectPath, undefined, { channelKey: target.channelKey, peerId: `trigger:${input.trigger.id}`, peerName: input.trigger.name }, input.trigger.name, undefined, 'private', binding.baseagent, input.trigger.agentAid, channelType, 'system'), delivery.signal);
+                    const targetDelivery = targetDeliveryFor(target);
+                    session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, binding.projectPath, undefined, {
+                        channelKey: target.channelKey,
+                        peerId: `trigger:${input.trigger.id}`,
+                        peerName: input.trigger.name,
+                        ...(targetDelivery?.chatType === 'group' ? { groupId: targetDelivery.groupId } : {}),
+                        replyContext: replyContextFromTarget(target),
+                    }, input.trigger.name, undefined, targetDelivery?.chatType === 'group' ? 'group' : 'private', binding.baseagent, input.trigger.agentAid, channelType, 'system'), delivery.signal);
                 }
             }
             catch (err) {
@@ -143,6 +165,12 @@ export class TriggerFeedbackDispatcher {
                 }
                 releaseSessionLock = access.release;
             }
+            // The persisted session can predate an explicit target route, and the
+            // same channelId may legally be used by both private and group sends.
+            // Keep the per-trigger route authoritative for this queued message.
+            const targetDelivery = targetDeliveryFor(target);
+            const targetChatType = targetDelivery?.chatType;
+            const messageChatType = targetChatType ?? (session.chatType === 'group' ? 'group' : 'private');
             const message = {
                 channel: target.channelKey,
                 channelType,
@@ -150,7 +178,7 @@ export class TriggerFeedbackDispatcher {
                 selfAID: input.trigger.agentAid,
                 baseagent: session.baseagent || binding.baseagent,
                 threadId: session.threadId || '',
-                chatType: session.chatType === 'group' ? 'group' : 'private',
+                chatType: messageChatType,
                 peerId: `trigger:${input.trigger.id}`,
                 peerName: input.trigger.name,
                 peerType: 'system',
@@ -159,6 +187,8 @@ export class TriggerFeedbackDispatcher {
                 timestamp: Date.now(),
                 source: 'trigger',
                 causation: input.causation,
+                groupId: targetChatType === 'group' ? targetDelivery.groupId : undefined,
+                replyContext: replyContextFromTarget(target),
                 triggerMeta: {
                     triggerId: input.trigger.id,
                     runId: input.runId,
@@ -346,6 +376,9 @@ export class TriggerFeedbackDispatcher {
                 const startedAt = Date.now();
                 try {
                     const isAunTarget = channelTypeFromKey(target.channelKey) === 'aun';
+                    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({
                         taskId: `trigger:${input.runId}`,
                         channel: binding.adapter.channelKey,
@@ -579,12 +612,32 @@ function originAsTarget(origin) {
         channelId: origin.channelId,
         session: origin.session,
         threadId: origin.threadId,
+        chatType: origin.delivery?.chatType,
     };
 }
 function replyContextFromTarget(target) {
-    if (target.session !== 'thread' || !target.threadId)
-        return undefined;
-    return { threadId: target.threadId };
+    const ctx = {};
+    const delivery = targetDeliveryFor(target);
+    if (delivery)
+        ctx.delivery = delivery;
+    if (target.session === 'thread' && target.threadId)
+        ctx.threadId = target.threadId;
+    return Object.keys(ctx).length > 0 ? ctx : undefined;
+}
+function targetChatType(target) {
+    return target.chatType;
+}
+function targetDeliveryFor(target) {
+    const chatType = targetChatType(target);
+    if (chatType === 'private')
+        return { chatType: 'private' };
+    if (chatType === 'group') {
+        return {
+            chatType: 'group',
+            groupId: target.channelId,
+        };
+    }
+    return undefined;
 }
 function replyContextWithCausation(target, causation) {
     const base = replyContextFromTarget(target);

package/dist/trigger/manager.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { agentTriggersDir } from '../paths.js';
-import { definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
+import { assertExplicitAunDeliveryRoutes, definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
 import { atomicWriteJson } from '../core/session/session-fs-store.js';
 import { TriggerHistoryStore } from './history.js';
 import { rewriteLegacyTriggerSessionPaths } from './legacy-session-history.js';
@@ -36,6 +36,12 @@ export class TriggerDefinitionManager {
             return undefined;
         const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
         const definition = normalizeTriggerDefinition(raw);
+        if (legacyFeedbackTargetNeedsMigration(raw, definition)) {
+            definition.feedback.target.chatType ??= 'private';
+            definition.updatedAt = Date.now();
+            this.writeDefinition(definition);
+            this.history.recordDefinition('trigger.updated', definition, { reason: 'legacy-aun-target-chat-type' });
+        }
         if (typeof definition.execution.prompt === 'string') {
             const rewritten = rewriteLegacyTriggerSessionPaths(definition.execution.prompt, definition.agentAid);
             if (rewritten !== definition.execution.prompt) {
@@ -56,6 +62,7 @@ export class TriggerDefinitionManager {
     create(input, files = [], opts = {}) {
         const now = Date.now();
         const definition = normalizeTriggerDefinition(input, { now });
+        assertExplicitAunDeliveryRoutes(definition);
         this.assertAgent(definition);
         if (opts.enable !== undefined)
             definition.enabled = opts.enable;
@@ -82,6 +89,7 @@ export class TriggerDefinitionManager {
             id: triggerId,
             ...(origin ? { origin } : {}),
         }, { now: Date.now() });
+        assertExplicitAunDeliveryRoutes(updated);
         this.assertAgent(updated);
         if (existing.execution.baseagent !== updated.execution.baseagent) {
             throw new Error('execution.baseagent is immutable; create a new Trigger to use another baseagent');
@@ -101,6 +109,8 @@ export class TriggerDefinitionManager {
     }
     setEnabled(triggerId, enabled) {
         const definition = this.require(triggerId);
+        if (enabled)
+            assertExplicitAunDeliveryRoutes(definition);
         definition.enabled = enabled;
         definition.updatedAt = Date.now();
         this.writeDefinition(definition);
@@ -270,6 +280,16 @@ export class TriggerDefinitionManager {
 function optionalString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
+function legacyFeedbackTargetNeedsMigration(raw, definition) {
+    if (!isRecord(raw) || !definition.feedback.target)
+        return false;
+    const feedback = isRecord(raw.feedback) ? raw.feedback : undefined;
+    const target = feedback && isRecord(feedback.target) ? feedback.target : undefined;
+    if (!target || target.chatType !== undefined)
+        return false;
+    const channelKey = optionalString(target.channelKey);
+    return !!channelKey && (channelKey === 'aun' || channelKey.startsWith('aun#'));
+}
 function mergeOrigin(existing, incoming) {
     if (existing?.channelKey && existing.channelId)
         return existing;

package/dist/trigger/parser.js

@@ -9,7 +9,7 @@ const TRIGGER_CREATE_FLAGS = new Set([
     'once', 'delay', 'at', 'cron', 'every', 'event', 'tz',
     'exec', 'prompt', 'name', 'agent',
     'script-path', 'script-runtime', 'script-args', 'script-timeout',
-    'feedback', 'target-channel', 'target-channel-id', 'target-session', 'target-thread-id',
+    'feedback', 'target-channel', 'target-channel-id', 'target-chat-type', 'target-session', 'target-thread-id',
     'trigger-thread', 'baseagent',
     'model', 'effort', 'permission', 'max-runs', 'max-duration',
 ]);
@@ -375,13 +375,22 @@ function commonParsed(flags, opts = {}) {
     const targetChannelId = flags.get('target-channel-id');
     if (targetChannelId === true)
         return { ok: false, error: '--target-channel-id 不能为空' };
+    const targetChatType = flags.get('target-chat-type');
+    if (targetChatType === true)
+        return { ok: false, error: '--target-chat-type 不能为空' };
+    if (targetChatType !== undefined && targetChatType !== 'private' && targetChatType !== 'group') {
+        return { ok: false, error: '--target-chat-type 只接受 private 或 group' };
+    }
     const targetThreadId = flags.get('target-thread-id');
     if (targetThreadId === true)
         return { ok: false, error: '--target-thread-id 不能为空' };
-    const hasTargetField = targetChannel !== undefined || targetChannelId !== undefined || targetSession.value !== undefined || targetThreadId !== undefined;
+    const hasTargetField = targetChannel !== undefined || targetChannelId !== undefined || targetChatType !== undefined || targetSession.value !== undefined || targetThreadId !== undefined;
     if ((targetChannel === undefined) !== (targetChannelId === undefined)) {
         return { ok: false, error: '--target-channel 与 --target-channel-id 必须同时指定或同时省略' };
     }
+    if (targetChatType !== undefined && targetChannelId === undefined) {
+        return { ok: false, error: '--target-chat-type 必须与 --target-channel/--target-channel-id 一起使用' };
+    }
     if (!opts.update && !execution.value) {
         return { ok: false, error: '创建 trigger 必须显式指定 --exec script|trigger-session|target-session' };
     }
@@ -409,6 +418,7 @@ function commonParsed(flags, opts = {}) {
             feedbackStrategy,
             targetChannel: targetChannel,
             targetChannelId: targetChannelId,
+            targetChatType: targetChatType,
             targetSession: targetSessionValue,
             targetThreadId: targetThreadId,
             agentId: flags.has('agent') ? flags.get('agent') : undefined,
@@ -447,6 +457,7 @@ export function parseTriggerSet(args) {
             feedbackStrategy: value.feedbackStrategy,
             targetChannel: value.targetChannel,
             targetChannelId: value.targetChannelId,
+            targetChatType: value.targetChatType,
             targetSession: value.targetSession,
             targetThreadId: value.targetThreadId,
             agentId: value.agentId,
@@ -486,6 +497,7 @@ export function parseTriggerSetArgv(args, opts = {}) {
             feedbackStrategy: value.feedbackStrategy,
             targetChannel: value.targetChannel,
             targetChannelId: value.targetChannelId,
+            targetChatType: value.targetChatType,
             targetSession: value.targetSession,
             targetThreadId: value.targetThreadId,
             agentId: value.agentId,

package/dist/trigger/scheduler.js

@@ -2016,6 +2016,7 @@ function primaryTarget(definition) {
         channelId: definition.origin.channelId,
         session: definition.origin.session,
         threadId: definition.origin.threadId,
+        chatType: definition.origin.delivery?.chatType,
     };
 }
 function eventTestMatchError(reason, eventPattern) {

package/dist/trigger/validation.js

@@ -26,6 +26,34 @@ export function normalizeTriggerDefinition(input, opts = {}) {
     }
     return normalizeV3Phase2(raw, opts);
 }
+/**
+ * Write-time route contract for trigger definitions.
+ *
+ * Normalization keeps old AUN definitions readable so operators can inspect
+ * and remove them, but new writes must never persist a target that would need
+ * channelId shape inference at runtime.
+ */
+export function assertExplicitAunDeliveryRoutes(definition) {
+    if (definition.feedback.strategy === 'silent')
+        return;
+    const target = definition.feedback.strategy === 'target'
+        ? definition.feedback.target
+        : definition.origin;
+    if (!target)
+        return;
+    const channelType = ('channelType' in target ? target.channelType : undefined)
+        ?? target.channelKey.split('#', 1)[0];
+    if (channelType !== 'aun')
+        return;
+    const chatType = definition.feedback.strategy === 'target'
+        ? definition.feedback.target?.chatType
+        : definition.origin?.delivery?.chatType;
+    if (!chatType) {
+        throw Object.assign(new Error('AUN trigger feedback target requires an explicit delivery route'), {
+            code: 'AUN_OUTBOUND_ROUTE_REQUIRED',
+        });
+    }
+}
 export function validateTriggerDefinition(definition) {
     normalizeTriggerDefinition(definition);
 }
@@ -232,16 +260,30 @@ function normalizeOrigin(value) {
         throw new Error('origin.threadId is required when origin.session=thread');
     const rawChannelId = requiredString(raw.channelId, 'origin.channelId');
     const peerId = optionalString(raw.peerId);
-    const legacyGroupOrigin = !!peerId && rawChannelId !== peerId;
+    const channelKey = requiredString(raw.channelKey, 'origin.channelKey');
+    const channelType = optionalString(raw.channelType);
+    const isAunOrigin = channelType === 'aun' || channelKey === 'aun' || channelKey.startsWith('aun#');
+    // Legacy non-AUN definitions used channelId/peerId shape to represent a
+    // group-created trigger. AUN routes deliberately do not get that recovery:
+    // the transport type must have been persisted explicitly.
+    const legacyGroupOrigin = !isAunOrigin && raw.delivery === undefined && !!peerId && rawChannelId !== peerId;
+    const legacyPrivateOrigin = !isAunOrigin && raw.delivery === undefined && !!peerId && rawChannelId === peerId;
     const session = legacyGroupOrigin ? 'main' : rawSession;
+    const channelId = legacyGroupOrigin ? peerId : rawChannelId;
+    const delivery = raw.delivery === undefined
+        ? legacyGroupOrigin || legacyPrivateOrigin || !isAunOrigin
+            ? { chatType: 'private' }
+            : undefined
+        : normalizeDeliveryTarget(raw.delivery, 'origin.delivery', channelId);
     return {
-        channelKey: requiredString(raw.channelKey, 'origin.channelKey'),
-        channelType: optionalString(raw.channelType),
-        channelId: peerId ?? rawChannelId,
+        channelKey,
+        channelType,
+        channelId,
         session,
         threadId: session === 'thread' ? threadId : undefined,
         peerId,
         sessionKey: legacyGroupOrigin ? undefined : optionalString(raw.sessionKey),
+        delivery,
     };
 }
 function normalizeSource(value) {
@@ -486,14 +528,33 @@ function normalizeFeedbackTarget(value, label, agentAid) {
     if (session === 'thread' && !threadId)
         throw new Error(`${label}.threadId is required when ${label}.session=thread`);
     const channelKey = requiredString(raw.channelKey, `${label}.channelKey`);
-    return {
+    const channelId = requiredString(raw.channelId, `${label}.channelId`);
+    const rawChatType = raw.chatType;
+    if (rawChatType !== undefined && rawChatType !== 'private' && rawChatType !== 'group') {
+        throw new Error(`${label}.chatType must be private or group`);
+    }
+    const target = {
         channelKey: channelKey === 'aun'
             ? formatChannelKey({ type: 'aun', selfAID: agentAid, name: 'main' })
             : channelKey,
-        channelId: requiredString(raw.channelId, `${label}.channelId`),
+        channelId,
         session,
         threadId,
+        chatType: rawChatType,
     };
+    return target;
+}
+function normalizeDeliveryTarget(value, label, channelId) {
+    if (!isObject(value))
+        throw new Error(`${label} must be an object`);
+    if (value.chatType === 'private')
+        return { chatType: 'private' };
+    if (value.chatType !== 'group')
+        throw new Error(`${label}.chatType must be private or group`);
+    const groupId = requiredString(value.groupId, `${label}.groupId`);
+    if (groupId !== channelId)
+        throw new Error(`${label}.groupId must match channelId`);
+    return { chatType: 'group', groupId };
 }
 function normalizeFeedbackTemplate(value, label) {
     if (value === undefined)