evolcore 0.0.31 → 0.0.33

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

@@ -12,20 +12,18 @@ const STATE_KEY = 'proactive';
 const SNAPSHOT_KEY = 'proactive:continuation';
 const OWNER_KEY = 'proactive:owner';
 const SNAPSHOT_MAX_AGE_MS = 30 * 60 * 1_000;
-const TOOL_REPORT_INTERVAL = 20;
+/** 计数器初值与提示档位：计数 = 该值时放行并提示，> 该值时只放行意图表达 */
+export const INTENT_GATE_INTERVAL = 15;
+const TOOL_REPORT_INTERVAL = INTENT_GATE_INTERVAL;
+/** 队列未读提醒长度跨轮次持久化的 sessionState key（问题3修复） */
+const QUEUE_REMINDER_SESSION_KEY = 'proactive:lastQueueReminderLen';
+/** 熔断已触发标记，存 sessionState 供 afterProcess 发渠道消息（F5修复） */
+const CIRCUIT_BREAK_SESSION_KEY = 'proactive:circuitBreak';
+/** 单轮内允许的最大违规次数；超过后触发熔断而非继续注入提醒（问题1/2修复） */
+export const VIOLATION_CIRCUIT_BREAK_THRESHOLD = 2;
 const SEND_RECEIPT_RE = /["']?(?:message[_ -]?id|handoff[_ -]?id)["']?\s*[:=]\s*["']?([A-Za-z0-9][A-Za-z0-9._:-]*)/gi;
 const HANDOFF_TEXT_RECEIPT_RE = /\bhandoff\s+(h-[A-Za-z0-9._-]+)/i;
 const RETURN_CONTENT_RE = /["']?(?:return[_ -]?content|returnContent)["']?\s*[:=]\s*["']?([^}\n,]*)/i;
-function hasRequiredReturnFlag(toolInput) {
-    if (!toolInput || typeof toolInput !== 'object')
-        return false;
-    const input = toolInput;
-    const commandValues = ['command', 'cmd', 'script'].flatMap(key => {
-        const value = input[key];
-        return typeof value === 'string' ? [value] : [];
-    });
-    return commandValues.some(command => /(?:^|\s)--return(?:=|\s+)['"]?required(?:['"]?)(?=\s|$)/i.test(command));
-}
 function hasSuccessfulSendReceipt(result, isError, requiresBusinessReturn = false) {
     if (isError === true)
         return false;
@@ -137,6 +135,57 @@ function hasSuccessfulSendReceipt(result, isError, requiresBusinessReturn = fals
         return true;
     return false;
 }
+function sendHint(state) {
+    return state.chatType === 'group'
+        ? { cmdHint: 'ec group send', target: '群里' }
+        : { cmdHint: 'ec msg send', target: '对方' };
+}
+/**
+ * 结算当前轮：本轮有意图表达成功 → 清零（不再 +1）；否则 +1。
+ * 被拒绝的调用不会产生成功回执，因此不能触发清零。
+ */
+function settleRound(state) {
+    if (!state.roundOpen)
+        return;
+    state.roundOpen = false;
+    state.roundPending = 0;
+    state.roundCounter = state.roundHasIntentSuccess ? 0 : state.roundCounter + 1;
+}
+/**
+ * 进入一轮。turn 为 runner 提供的模型返回序号：
+ * - 有 turn：同一 turn 视为同一轮；turn 变化时先结算上一轮
+ * - 无 turn（runner 不支持）：已有未结算的轮则沿用，结算由飞行数归零触发
+ */
+function beginRound(state, turn) {
+    if (typeof turn === 'number' && Number.isFinite(turn)) {
+        state.turnAware = true;
+        // 先由拿不到 turn 的调用开了轮：认领这个 turn，而不是当成新轮结算
+        if (state.roundOpen && state.roundTurn === undefined) {
+            state.roundTurn = turn;
+            return;
+        }
+        if (state.roundOpen && state.roundTurn === turn)
+            return;
+        settleRound(state);
+    }
+    else if (state.roundOpen) {
+        return;
+    }
+    state.roundOpen = true;
+    state.roundTurn = typeof turn === 'number' ? turn : undefined;
+    state.roundStartCounter = state.roundCounter;
+    state.roundPending = 0;
+    state.roundHasIntentAttempt = false;
+    state.roundHasIntentSuccess = false;
+    state.roundWarned = false;
+}
+/** 新输入（新消息、插入消息、队列合并、续跑、任务恢复）到来：计数重置为初值 */
+export function resetIntentCounter(state) {
+    state.roundOpen = false;
+    state.roundPending = 0;
+    state.roundTurn = undefined;
+    state.roundCounter = INTENT_GATE_INTERVAL;
+}
 function isHumanFacingMessage(message) {
     if (message.source === 'trigger')
         return false;
@@ -161,7 +210,17 @@ function buildState(message, cfg) {
         firstSendRequired: preTool1stMsgChk && humanFacing,
         toolReportRequired: toolUseReminder && humanFacing,
         toolReportInterval: TOOL_REPORT_INTERVAL,
-        toolReportPending: false,
+        violationCount: 0,
+        intentGateRequired: (preTool1stMsgChk || toolUseReminder) && humanFacing,
+        roundCounter: INTENT_GATE_INTERVAL,
+        roundOpen: false,
+        roundStartCounter: INTENT_GATE_INTERVAL,
+        roundTurn: undefined,
+        turnAware: false,
+        roundPending: 0,
+        roundHasIntentAttempt: false,
+        roundHasIntentSuccess: false,
+        roundWarned: false,
     };
 }
 function normalizedThread(threadId) {
@@ -169,7 +228,10 @@ function normalizedThread(threadId) {
 }
 function isResumableTerminal(terminal) {
     return terminal?.status === 'interrupted' && terminal.reason === 'daemon_restart'
-        || terminal?.status === 'cancelled' && (terminal.reason === 'stop' || terminal.reason === 'explicit_cancel');
+        || terminal?.status === 'cancelled' && (terminal.reason === 'stop'
+            || terminal.reason === 'explicit_cancel'
+        // 熔断中断走 agent.interrupt() 默认路径，reason 为 explicit_cancel，此处已覆盖
+        );
 }
 function canRestoreSnapshot(ctx, state, snapshot) {
     const previous = ctx.previousTurnState;
@@ -182,7 +244,7 @@ function canRestoreSnapshot(ctx, state, snapshot) {
     const age = Date.now() - snapshot.finishedAt;
     if (!Number.isFinite(age) || age < 0 || age > SNAPSHOT_MAX_AGE_MS
         || !Number.isSafeInteger(snapshot.toolCount) || snapshot.toolCount < 0
-        || typeof snapshot.firstToolDone !== 'boolean' || typeof snapshot.toolReportPending !== 'boolean'
+        || typeof snapshot.firstToolDone !== 'boolean'
         || snapshot.sessionId !== ctx.session.id || snapshot.selfAid !== ctx.session.selfAID
         || snapshot.channel !== ctx.session.channel || snapshot.channelId !== ctx.session.channelId
         || snapshot.chatType !== ctx.message.chatType || snapshot.chatType !== ctx.session.chatType
@@ -230,10 +292,10 @@ function saveContinuation(ctx) {
         finishedAt: terminal.finishedAt,
         firstToolDone: state.firstToolDone,
         toolCount: state.toolCount,
-        toolReportPending: state.toolReportPending,
         firstSendRequired: state.firstSendRequired,
         toolReportRequired: state.toolReportRequired,
         toolReportInterval: state.toolReportInterval,
+        violationCount: state.violationCount, // F4修复：跨续跑保留违规计数
     };
     ctx.sessionState.set(SNAPSHOT_KEY, snapshot);
 }
@@ -265,10 +327,25 @@ export const proactiveFlow = {
         const state = buildState(ctx.message, ctx.modeConfig ?? {});
         const snapshot = ctx.sessionState?.get(SNAPSHOT_KEY);
         ctx.sessionState?.delete(SNAPSHOT_KEY);
-        if (snapshot && canRestoreSnapshot(ctx, state, snapshot)) {
+        const snapshotRestored = snapshot && canRestoreSnapshot(ctx, state, snapshot);
+        if (snapshotRestored) {
             state.firstToolDone = snapshot.firstToolDone;
             state.toolCount = snapshot.toolCount;
-            state.toolReportPending = state.toolReportRequired && snapshot.toolReportPending;
+            // F4修复：跨续跑恢复违规计数，防止每次续跑都重置熔断配额
+            if (typeof snapshot.violationCount === 'number')
+                state.violationCount = snapshot.violationCount;
+            // 轮次计数不恢复：续跑/任务恢复属于新输入，buildState 已置为初值
+        }
+        else if (snapshot) {
+            // F8修复：快照存在但恢复失败（channel/chatType 变化等），
+            // 状态已不连续，清除过期的队列提醒长度，避免错误抑制新轮次的提醒
+            ctx.sessionState?.delete(QUEUE_REMINDER_SESSION_KEY);
+        }
+        // 问题3修复：从 sessionState 恢复跨轮次的队列提醒长度，
+        // 避免每轮重置为 0 后队列 ≥ 3 就反复触发未读提醒。
+        const persistedQueueLen = ctx.sessionState?.get(QUEUE_REMINDER_SESSION_KEY);
+        if (typeof persistedQueueLen === 'number' && persistedQueueLen > 0) {
+            state.lastQueueReminderLen = persistedQueueLen;
         }
         ctx.state.set(STATE_KEY, state);
         ctx.sessionState?.set(OWNER_KEY, state);
@@ -279,109 +356,121 @@ export const proactiveFlow = {
         if (!state)
             return undefined;
         return {
-            policyHook: (toolName, toolInput) => {
+            policyHook: (toolName, toolInput, meta) => {
                 // Codex only invokes this hook for local tool paths. Hosted tools stay
-                // enabled and do not satisfy or clear the pending first-send gate.
+                // enabled and do not satisfy the intent gate.
                 const isSendCommand = ctx.isSendCommand(toolName, toolInput);
-                if (!isSendCommand && ((state.firstSendRequired && !state.firstToolDone) || state.toolReportPending)) {
-                    const sendFailure = ctx.describeSendCommandFailure?.(toolName, toolInput);
-                    if (sendFailure)
-                        return { block: true, policyCode: 'proactive_send_invalid', reason: sendFailure };
+                const { cmdHint, target } = sendHint(state);
+                beginRound(state, meta?.turn);
+                // 意图表达工具始终放行；是否清零看执行结果（onToolResult）
+                if (isSendCommand) {
+                    state.roundHasIntentAttempt = true;
+                    return undefined;
                 }
-                if (state.firstSendRequired && !state.firstToolDone) {
-                    if (!isSendCommand) {
-                        const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
-                        const target = state.chatType === 'group' ? '群里' : '对方';
-                        return {
-                            block: true,
-                            policyCode: 'proactive_first_send_required',
-                            reason: `请先用 ${cmdHint} 向${target}说明你的意图，再执行其他工具`,
-                        };
+                // 非 send 命令：先检查格式是否"像 send 但解析失败"（F2修复：计入违规）
+                const sendFailure = ctx.describeSendCommandFailure?.(toolName, toolInput);
+                if (sendFailure) {
+                    state.violationCount++;
+                    if (state.violationCount >= VIOLATION_CIRCUIT_BREAK_THRESHOLD) {
+                        return { block: true, policyCode: 'proactive_circuit_break', reason: `连续违规 ${state.violationCount} 次，任务已中断，请重新描述需求` };
                     }
+                    return { block: true, policyCode: 'proactive_send_invalid', reason: sendFailure };
                 }
-                if (state.toolReportPending) {
-                    if (!isSendCommand) {
-                        const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
-                        const target = state.chatType === 'group' ? '群里' : '对方';
-                        return {
-                            block: true,
-                            policyCode: 'proactive_tool_report_required',
-                            reason: `工具调用已达到 ${state.toolCount} 次，请先用 ${cmdHint} 向${target}汇报当前情况和下一步意图，再执行其他工具`,
-                        };
+                if (!state.intentGateRequired)
+                    return undefined;
+                // 计数 < 15：本条消息内已有意图表达，放行
+                if (state.roundStartCounter < INTENT_GATE_INTERVAL)
+                    return undefined;
+                // 计数 = 15：全部放行，提示下一轮先做意图表达（本轮已有发送则不提示）
+                if (state.roundStartCounter === INTENT_GATE_INTERVAL) {
+                    if (!state.roundHasIntentAttempt && !state.roundWarned) {
+                        state.roundWarned = true;
+                        state.pendingRoundReminder = `⚠️ 本轮未包含意图表达，下一轮必须先用 ${cmdHint} 向${target}说明当前情况和下一步意图，否则其他工具会被拒绝。`;
                     }
+                    return undefined;
+                }
+                // 计数 ≥ 16：只放行意图表达，其他调用全部拒绝
+                state.violationCount++;
+                if (state.violationCount >= VIOLATION_CIRCUIT_BREAK_THRESHOLD) {
+                    return { block: true, policyCode: 'proactive_circuit_break', reason: `连续违规 ${state.violationCount} 次，任务已中断，请重新描述需求` };
                 }
-                return undefined;
+                return {
+                    block: true,
+                    policyCode: 'proactive_intent_required',
+                    reason: `上一轮未包含意图表达，本轮只允许 ${cmdHint}；请先向${target}说明当前情况和下一步意图，再执行其他工具`,
+                };
             },
         };
     },
-    // ─── onToolUse：队列未读提醒 + 工具汇报提醒 ───
+    // ─── onToolUse：轮次计数 + 队列未读提醒 + 工具汇报提醒 ───
     onToolUse(ctx) {
         const state = ctx.state.get(STATE_KEY);
         if (!state)
             return;
-        // PreToolUse 和 tool_use 都发生在命令执行前，不能推进发送门禁。
-        // 只有成功的 tool_result 携带明确回执时才提交状态。
+        // 轮次追踪：按模型返回序号进轮，每次工具调用开始时 pending+1
+        beginRound(state, ctx.modelTurn);
+        state.roundPending++;
+        // 15 档提示由 policyHook 写入，这里注入给模型
+        if (state.pendingRoundReminder) {
+            ctx.injectToModel(state.pendingRoundReminder);
+            ctx.recordReminder?.({ kind: 'tool_report', text: state.pendingRoundReminder, toolCount: state.roundStartCounter });
+            state.pendingRoundReminder = undefined;
+        }
         const isAllowedTool = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
         if (!state.toolUseReminder)
             return;
-        // 工具计数（排除表态命令白名单）
+        // 非发送工具才计入 toolCount（仅审计）
         if (state.toolReportRequired && !isAllowedTool)
             state.toolCount++;
-        // 队列未读变化提醒：首次达到 3 条立即提醒，后续复用工具汇报的计数间隔，
-        // 避免连续工具调用时每次队列数量变化都重复注入。
+        // 队列未读变化提醒
         const queueLen = ctx.getQueueLength();
         const queueChanged = queueLen !== state.lastQueueReminderLen;
-        const toolReportDue = state.toolReportRequired
-            && !isAllowedTool
-            && state.toolCount > 0
-            && state.toolCount % state.toolReportInterval === 0;
         let queueReminder;
         const queueReminderDue = state.lastQueueReminderLen === 0
             ? queueLen >= 3
-            : toolReportDue;
+            : false; // 汇报间隔改由轮次控制
         if (queueLen === 0) {
             state.lastQueueReminderLen = 0;
+            ctx.sessionState?.delete(QUEUE_REMINDER_SESSION_KEY);
         }
         else if (queueChanged && queueReminderDue) {
             state.lastQueueReminderLen = queueLen;
+            ctx.sessionState?.set(QUEUE_REMINDER_SESSION_KEY, queueLen);
             queueReminder = queueLen >= 5
                 ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
                 : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
             ctx.recordReminder?.({ kind: 'queue_unread', text: queueReminder, queueLength: queueLen });
-        }
-        if (queueReminder && !toolReportDue) {
             ctx.injectToModel(queueReminder);
         }
-        // 每 N 次工具调用警告
-        // 只有计数推进到新阈值时才提醒；发送工具不能重新打开已解除的汇报门禁。
-        if (toolReportDue) {
-            state.toolReportPending = true;
-            const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
-            const target = state.chatType === 'group' ? '群里' : '对方';
-            const reportMsg = `⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`;
-            ctx.recordReminder?.({ kind: 'tool_report', text: reportMsg, toolCount: state.toolCount });
-            ctx.injectToModel(queueReminder ? `${queueReminder}\n${reportMsg}` : reportMsg);
-        }
     },
-    // ─── onToolResult：成功发送回执后解除门禁 ───
+    // ─── onToolResult：轮次推进 + 成功发送回执后更新标志位 ───
     onToolResult(ctx) {
         const state = ctx.state.get(STATE_KEY);
         if (!state)
             return;
-        if (!ctx.isSendCommand(ctx.toolName, ctx.toolInput))
-            return;
-        const requiresBusinessReturn = hasRequiredReturnFlag(ctx.toolInput)
-            && (typeof ctx.result === 'string'
-                ? HANDOFF_TEXT_RECEIPT_RE.test(ctx.result)
-                : !!ctx.result && typeof ctx.result === 'object'
-                    && ('handoff_id' in ctx.result || 'handoffId' in ctx.result));
-        HANDOFF_TEXT_RECEIPT_RE.lastIndex = 0;
-        if (!hasSuccessfulSendReceipt(ctx.result, ctx.isError || !!ctx.error, requiresBusinessReturn))
-            return;
-        if (state.firstSendRequired && !state.firstToolDone)
-            state.firstToolDone = true;
-        if (state.toolReportPending)
-            state.toolReportPending = false;
+        const isSend = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
+        // tool_use 事件可能先于 PreToolUse 到达，15 档提示在这里补注入
+        if (state.pendingRoundReminder) {
+            ctx.injectToModel(state.pendingRoundReminder);
+            ctx.recordReminder?.({ kind: 'tool_report', text: state.pendingRoundReminder, toolCount: state.roundStartCounter });
+            state.pendingRoundReminder = undefined;
+        }
+        // 先记成功，再结算：被拒绝/失败的调用不能触发清零
+        const succeeded = !ctx.isError && !ctx.error
+            && ctx.executionState !== 'blocked' && ctx.executionState !== 'failed'
+            && ctx.decision !== 'deny' && ctx.executed !== false;
+        if (isSend && succeeded) {
+            state.roundHasIntentSuccess = true;
+            if (!state.firstToolDone)
+                state.firstToolDone = true;
+            state.violationCount = 0;
+        }
+        // 轮次追踪：pending-1。拿得到模型返回序号时由下一轮 beginRound 结算；
+        // 拿不到时（runner 不提供 turn）退回飞行数归零结算
+        if (state.roundPending > 0)
+            state.roundPending--;
+        if (state.roundPending === 0 && !state.turnAware)
+            settleRound(state);
     },
     // ─── onComplete：标志位检查 ───
     async onComplete(ctx) {

package/dist/trigger/authorization.js

@@ -8,6 +8,7 @@ import { validateModelSelectionForRole } from '../core/model/model-permission.js
 import { isValidAunDeliveryForChannel } from '../core/message/outbound.js';
 import { tryParseChannelKey } from '../core/channel-loader.js';
 import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride, } from '../core/role/runtime-policy.js';
+import { resolveThreadRouteTarget } from '../core/thread/thread-route.js';
 export function originFromActorSession(session, authenticatedPeerId, authenticatedChannelKey, authenticatedChatType) {
     const peerId = authenticatedPeerId || session.metadata?.peerId;
     if (!peerId)
@@ -15,16 +16,21 @@ export function originFromActorSession(session, authenticatedPeerId, authenticat
     const sessionChannelKey = session.metadata?.channelKey || session.channel;
     const channelKey = authenticatedChannelKey || sessionChannelKey;
     const sameConversation = channelKey === sessionChannelKey;
+    if (authenticatedChatType && (authenticatedChatType === 'group') !== (session.chatType === 'group')) {
+        return undefined;
+    }
     const isGroup = authenticatedChatType === 'group' || session.chatType === 'group';
+    const channelId = isGroup ? session.channelId : peerId;
+    const sessionKind = sameConversation && session.threadId ? 'thread' : 'main';
     return {
         channelKey,
         channelType: session.channelType || tryParseChannelKey(channelKey)?.type || channelKey,
-        channelId: peerId,
-        session: sameConversation && !isGroup && session.threadId ? 'thread' : 'main',
-        threadId: sameConversation && !isGroup ? (session.threadId || undefined) : undefined,
+        channelId,
+        session: sessionKind,
+        threadId: sessionKind === 'thread' ? session.threadId : undefined,
         peerId,
-        sessionKey: sameConversation && !isGroup ? session.sessionKey : undefined,
-        delivery: { chatType: 'private' },
+        sessionKey: sameConversation ? session.sessionKey : undefined,
+        delivery: isGroup ? { chatType: 'group', groupId: channelId } : { chatType: 'private' },
     };
 }
 export function daemonPrivilegedTriggerReason(definition) {
@@ -76,6 +82,36 @@ export function validateTriggerFeedbackChannels(definition, getTriggerChannel) {
 export function hasDaemonTriggerAuthority(subject) {
     return subject.isDaemonOwner || subject.processRole === 'daemon-service' || subject.dataScope === 'daemon';
 }
+function triggerOriginChatType(origin) {
+    return origin.delivery?.chatType ?? 'private';
+}
+function feedbackTargetMatchesOrigin(target, origin) {
+    return target.channelKey === origin.channelKey
+        && target.channelId === origin.channelId
+        && target.session === origin.session
+        && (target.threadId ?? '') === (origin.threadId ?? '')
+        && (target.chatType === undefined || target.chatType === triggerOriginChatType(origin));
+}
+function feedbackTargetIsSamePeerThread(definition, target, origin) {
+    if (!target || !origin || target.session !== 'thread' || !target.threadId)
+        return false;
+    if (target.channelKey !== origin.channelKey || target.channelId !== origin.channelId)
+        return false;
+    const originChatType = triggerOriginChatType(origin);
+    if (target.chatType !== originChatType)
+        return false;
+    return !!resolveThreadRouteTarget(definition.agentAid, target.threadId, target.chatType === 'group' ? 'group' : 'msg', target.channelId);
+}
+function feedbackTargetAllowedForNonManagement(definition, origin) {
+    const target = definition.feedback.target;
+    if (!target || !origin)
+        return false;
+    if (feedbackTargetMatchesOrigin(target, origin))
+        return true;
+    if (target.chatType === 'group')
+        return false;
+    return feedbackTargetIsSamePeerThread(definition, target, origin);
+}
 export function validateTriggerDefinitionForActor(definition, actor, dependencies) {
     if (definition.execution.permissionMode === 'fullaccess') {
         if (!actor.daemonOwner && !actor.fullAccess) {
@@ -127,14 +163,8 @@ export function validateTriggerDefinitionForActor(definition, actor, dependencie
         throw new Error('event-session feedback requires owner/admin');
     }
     if (!actor.management && definition.feedback.strategy === 'target') {
-        const target = definition.feedback.target;
-        const origin = actor.origin;
-        if (!target || !origin
-            || target.channelKey !== origin.channelKey
-            || target.channelId !== origin.channelId
-            || target.session !== origin.session
-            || (target.threadId ?? '') !== (origin.threadId ?? '')) {
-            throw new Error('non-management trigger target must be the creator private conversation');
+        if (!feedbackTargetAllowedForNonManagement(definition, actor.origin)) {
+            throw new Error('non-management trigger target must be the creator conversation or an existing same-peer private thread');
         }
     }
 }
@@ -187,13 +217,15 @@ export function authorizeTriggerExecution(definition, dependencies) {
     const channelType = origin.channelType || tryParseChannelKey(origin.channelKey)?.type;
     if (!channelType)
         return { allowed: false, reason: 'trigger origin channel type is missing' };
+    const chatType = triggerOriginChatType(origin);
+    const conversationId = chatType === 'group' ? origin.channelId : origin.peerId;
     const roleDetail = resolvePeerRoleDetail({
         selfAid: definition.agentAid,
         channelKey: origin.channelKey,
         channelType,
-        chatType: 'private',
+        chatType,
         actorId: origin.peerId,
-        conversationId: origin.peerId,
+        conversationId,
     });
     const role = roleDetail.effectiveRole;
     if (!checkRoleAccess(role, definition.agentAid)) {
@@ -205,8 +237,8 @@ export function authorizeTriggerExecution(definition, dependencies) {
         channel: origin.channelKey,
         channelType,
         channelId: origin.channelId,
-        chatType: 'private',
-        conversationId: origin.peerId,
+        chatType,
+        conversationId,
         roleDetail,
         identity: roleToSessionIdentity(role),
         processOwners: dependencies.getDaemonOwners(),
@@ -236,18 +268,13 @@ export function authorizeTriggerExecution(definition, dependencies) {
         return { allowed: false, reason: 'event-session feedback requires current owner/admin role' };
     }
     if (definition.feedback.strategy === 'target' && !isManagementRole(role)) {
-        const target = definition.feedback.target;
-        if (!target
-            || target.channelKey !== origin.channelKey
-            || target.channelId !== origin.channelId
-            || target.session !== origin.session
-            || (target.threadId ?? '') !== (origin.threadId ?? '')) {
-            return { allowed: false, reason: `cross-conversation target requires current owner/admin role (role=${role ?? 'none'})` };
+        if (!feedbackTargetAllowedForNonManagement(definition, origin)) {
+            return { allowed: false, reason: `cross-conversation target requires current owner/admin role or an existing same-peer private thread (role=${role ?? 'none'})` };
         }
     }
     const permissionDecision = constrainRuntimePermissionMode({
         selfAid: definition.agentAid,
-        role,
+        role: typeof role === 'string' ? role : undefined,
         requestedValue: definition.execution.permissionMode,
     });
     if (definition.execution.permissionMode && permissionDecision.constrained) {
@@ -260,6 +287,7 @@ export function authorizeTriggerExecution(definition, dependencies) {
         allowed: true,
         scope: privilegedReason && hasDaemonTriggerAuthority(subject) ? 'daemon' : 'agent',
         permissionMode: permissionDecision.effectiveValue,
+        role: role ?? undefined,
     };
 }
 export async function authenticatedTriggerActor(dependencies, agentAid, actorSessionId, delegationToken, delegationCommandHash, controlToken, contextOnly = false) {
@@ -313,13 +341,15 @@ export async function authenticatedTriggerActor(dependencies, agentAid, actorSes
     if (validation.grant.actorId !== actorOrigin.peerId) {
         throw new Error('trigger delegation actor does not match session peer');
     }
+    const actorChatType = triggerOriginChatType(actorOrigin);
+    const actorConversationId = actorChatType === 'group' ? actorOrigin.channelId : actorOrigin.peerId;
     const roleDetail = resolvePeerRoleDetail({
         selfAid: agentAid,
         channelKey: validation.grant.channel,
         channelType: validation.grant.channelType,
-        chatType: 'private',
+        chatType: actorChatType,
         actorId: validation.grant.actorId,
-        conversationId: validation.grant.actorId,
+        conversationId: actorConversationId,
     });
     const currentRole = roleDetail.effectiveRole;
     const subject = buildAuthSubject({
@@ -328,8 +358,8 @@ export async function authenticatedTriggerActor(dependencies, agentAid, actorSes
         channel: validation.grant.channel,
         channelType: validation.grant.channelType,
         channelId: actorOrigin.channelId,
-        chatType: 'private',
-        conversationId: validation.grant.actorId,
+        chatType: actorChatType,
+        conversationId: actorConversationId,
         roleDetail,
         identity: roleToSessionIdentity(currentRole),
         processOwners: dependencies.getDaemonOwners(),

package/dist/trigger/feedback.js

@@ -272,10 +272,16 @@ export class TriggerFeedbackDispatcher {
                     originChannelKey: eventSession ? target.channelKey : input.trigger.origin?.channelKey,
                     originChannelType: eventSession ? channelType : input.trigger.origin?.channelType
                         ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
-                    ...(eventSession ? { originChatType: messageChatType, originConversationId: target.channelId } : {}),
+                    originChatType: eventSession ? messageChatType : input.trigger.origin?.delivery?.chatType,
+                    originConversationId: eventSession
+                        ? target.channelId
+                        : input.trigger.origin?.delivery?.chatType === 'group'
+                            ? input.trigger.origin.channelId
+                            : input.trigger.origin?.peerId,
                     originControl: !eventSession && input.trigger.origin?.channelKey === 'daemon',
                     noopSentinel: input.trigger.execution.noopSentinel,
                     authorizedBy: input.trigger.authorizedBy,
+                    labels: input.trigger.labels,
                 },
             };
             outcome = this.waitForTriggerOutcome(input.runId, input.attemptId, delivery.signal);