evolcore 0.0.27 → 0.0.29-test.0

package/dist/core/message/response-engine.js

@@ -5,12 +5,15 @@ import os from 'os';
 import crypto from 'crypto';
 import { BaseagentRunnerUnavailableError, hasCompact, autoCompactWindowForModel, isClaudeContextUsageModel, numericToken, formatAsyncQuestionAnswer, parseAsyncUserQuestions, } from '../../agents/runner-types.js';
 import { loadedBaseagentIds } from '../../agents/baseagent-availability.js';
+import { isDiagnosticSessionActive } from '../command/diag-service.js';
 import { evaluateInboundAdmissionPreflight, evaluateOrdinaryInboundAdmission } from './message-admission.js';
 import { authorizeAccess, authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
 import { buildTaskRuntimeEnv, ensureRuntimeLockDir, ensureSessionRuntimeDir } from '../../cli/task-context.js';
+import { memorySessionPolicyHook } from '../memory/memory-session-policy.js';
 import { IMRenderer } from './im-renderer.js';
+import { TaskActivityStore } from '../task/task-activity-store.js';
 import { createSendFileMarkerPattern } from './file-markers.js';
-import { createTextInferenceProvider } from '../inference/text-inference.js';
+import { createDecisionInferenceProvider, createTextInferenceProvider } from '../inference/text-inference.js';
 import { StreamIdleMonitor } from './stream-idle-monitor.js';
 import { logger } from '../../utils/logger.js';
 import { isHostChinese } from '../../utils/locale.js';
@@ -19,10 +22,10 @@ import { readEvolcoreRuntimeFlavor, tagErrorTextWithEvolcoreVersion } from '../.
 import { describeProactiveSendCommandFailure, isExactEvolcoreSendCommandForSession } from '../permission/ec-command-parser.js';
 import { summarizeToolInputForDisplay } from '../../utils/tool-summary.js';
 import { agentDataDir, agentDir as resolveAgentDir, agentMdPath, getPackageRoot, resolveRoot, resolvePaths } from '../../paths.js';
-import { renderKitSections } from '../../eck/kit-renderer.js';
+import { renderKitSections, resolveSessionManifest, DEFAULT_MANIFEST_FILE } from '../../eck/kit-renderer.js';
 import { renderMessageBody } from '../../eck/message-renderer.js';
 import { syncGroupRulesContext } from '../../eck/group-rules-sync.js';
-import { consumeHints, hintsToSubMessages, composeHintFallback } from './pending-hints.js';
+import { claimHints, commitHintClaim, releaseHintClaim, peekHints, hintsToSubMessages, composeHintFallback, OBSERVER_HINT_FAILURE_MESSAGES, } from './pending-hints.js';
 import { createRootCausation, deriveCausation, normalizeCausation } from '../causation/context.js';
 import { recordCausationLink, recordCausationSpan } from '../causation/audit.js';
 import { normalizeBaseagent } from '../../agents/baseagent.js';
@@ -32,6 +35,7 @@ import { buildEnvelope, isInteractionSendAccepted, replyContextFromSession, send
 import { isSystemOrServicePeer, resolveChatMode } from './peer-mode.js';
 import { AGENT_DELEGATION_TOKEN_ENV } from '../auth/agent-delegation.js';
 import { hasTrustedPrincipal } from '../auth/authenticated-actor.js';
+import { isValidAid } from '../../aun/aid/identity.js';
 // Re-export 工具函数（向后兼容，让其他模块可以从 response-engine 导入）
 export { buildEnvelope, sendInteractionPayload } from './message-utils.js';
 import { constrainResolvedModelForRole, isModelAllowedForRoleBaseagent } from '../model/model-permission.js';
@@ -53,10 +57,11 @@ import { registerBuiltinModes } from '../../response-system/modes/index.js';
 import { deriveSessionTitle, shouldAutoFillSessionTitle } from '../session/session-title.js';
 import { SessionTurnCoordinator } from '../session/session-turn-coordinator.js';
 import { recordTriggerExecutionAnomaly } from '../../trigger/anomaly-store.js';
-import { classifyToolErrorCode, normalizeToolErrorCode } from '../permission/tool-error-code.js';
+import { normalizeToolErrorClassification } from '../permission/tool-error-code.js';
 import { normalizeExecutionPermissionMode } from '../permission/mode.js';
 import { buildToolLifecycleEventKey } from '../audit/event-key.js';
-import { isFullAccessEnabled, loadDaemonConfig } from '../../config-store.js';
+import { aunMessageTranscriptUuid } from '../session/session-transcript.js';
+import { loadDaemonConfig } from '../../config-store.js';
 import { assertAgentPolicyAuthorization } from '../role/runtime-policy.js';
 import { auditFullAccessEvent } from '../auth/authorization-audit.js';
 import { TaskRecoveryService, isTaskRecoveryCurrent } from '../task/task-recovery-service.js';
@@ -888,6 +893,13 @@ export class ResponseEngine {
         const config = resolveEffective({ self: aid }, { cache: true, expand: true });
         return createTextInferenceProvider(baseagent, config);
     }
+    getDecisionInferenceProvider(selfAID) {
+        const aid = selfAID;
+        if (!aid)
+            return undefined;
+        const config = resolveEffective({ self: aid }, { cache: true, expand: true });
+        return createDecisionInferenceProvider(config.decision_model);
+    }
     getAvailableBaseagentsForOwner(evolName) {
         return loadedBaseagentIds(this.agentMap.keys(), evolName);
     }
@@ -1059,6 +1071,198 @@ export class ResponseEngine {
             hasChannel: (session) => !!this.resolveChannelInfo(session.metadata?.channelKey || session.channel),
         });
     }
+    observerHintConsumed;
+    observerHintFailed;
+    observerHintFailureReported = new WeakMap();
+    scheduledObserverHints = new Set();
+    setObserverHintConsumed(fn) {
+        this.observerHintConsumed = fn;
+    }
+    setObserverHintFailed(fn) {
+        this.observerHintFailed = fn;
+    }
+    observerHintStatusHint(hint, requestId) {
+        return requestId && !hint.promoteRequestId ? { ...hint, promoteRequestId: requestId } : hint;
+    }
+    reportObserverHintFailure(message, hint, target, code, requestId, action) {
+        const reported = this.observerHintFailureReported.get(message) ?? new Set();
+        if (reported.has(hint.id))
+            return;
+        reported.add(hint.id);
+        this.observerHintFailureReported.set(message, reported);
+        const statusAction = action ?? (hint.promoteRequestId ? 'promote' : 'add');
+        const statusRequestId = requestId ?? hint.promoteRequestId ?? (statusAction === 'add' ? message.observerHintRequestId : undefined);
+        const statusHint = this.observerHintStatusHint(hint, statusAction === 'promote' ? statusRequestId : undefined);
+        try {
+            this.observerHintFailed?.(statusHint, target, {
+                code, message: OBSERVER_HINT_FAILURE_MESSAGES[code], action: statusAction, requestId: statusRequestId,
+            });
+        }
+        catch (error) {
+            logger.warn(`[ResponseEngine] observer hint failure status failed id=${hint.id}: ${error}`);
+        }
+    }
+    reportObserverHintFailureForMessage(message, code, requestId) {
+        if (message.source !== 'owner-inject' || !message.observerHintId || !message.selfAID)
+            return;
+        const hint = peekHints(resolvePaths().sessionsDir, 'aun', message.channelId, message.selfAID, message.threadId, (message.chatType || 'private'), undefined, message.channel).find(item => item.id === message.observerHintId);
+        if (!hint)
+            return;
+        this.reportObserverHintFailure(message, hint, {
+            channelKey: message.channel,
+            channelId: message.channelId,
+            chatType: (message.chatType || 'private'),
+            threadId: message.threadId,
+        }, code, requestId, hint.promoteRequestId ? 'promote' : 'add');
+    }
+    observerHintFailureCodeForError(error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? error.code : undefined;
+        const knownCodes = [
+            'SESSION_NOT_FOUND', 'INTERRUPT_FAILED', 'INTERRUPT_TIMEOUT', 'QUEUE_FAILED',
+            'QUEUE_PERSIST_FAILED', 'RENDER_FAILED', 'RUNNER_START_FAILED',
+            'RUNNER_START_SUPERSEDED', 'HINT_UNAVAILABLE',
+        ];
+        if (typeof code === 'string' && knownCodes.includes(code)) {
+            return code;
+        }
+        const text = error instanceof Error ? error.message : String(error);
+        if (text === 'RUNNER_START_SUPERSEDED')
+            return 'RUNNER_START_SUPERSEDED';
+        if (text.includes('interrupt barrier timed out'))
+            return 'INTERRUPT_TIMEOUT';
+        if (text.includes('interrupt'))
+            return 'INTERRUPT_FAILED';
+        if (text.includes('queue is unavailable'))
+            return 'QUEUE_FAILED';
+        if (text.includes('enqueue') || text.includes('queue'))
+            return 'QUEUE_PERSIST_FAILED';
+        if (text.includes('renderMessageBody'))
+            return 'RENDER_FAILED';
+        if (text.includes('target session') || text.includes('SESSION_NOT_FOUND'))
+            return 'SESSION_NOT_FOUND';
+        return 'RUNNER_START_FAILED';
+    }
+    reportObserverHintFailureForClaim(message, session, claim, code) {
+        for (const hint of claim.hints) {
+            this.reportObserverHintFailure(message, hint, {
+                channelKey: session.channel,
+                channelId: claim.channelId,
+                chatType: claim.chatType,
+                threadId: claim.threadId || undefined,
+            }, code, hint.promoteRequestId ?? message.observerHintRequestId, hint.promoteRequestId ? 'promote' : 'add');
+        }
+    }
+    observerHintScheduleFailure(target, code) {
+        const hint = peekHints(resolvePaths().sessionsDir, 'aun', target.channelId, target.selfAid, target.threadId, target.chatType, undefined, target.channelKey).find(item => item.id === target.hintId);
+        if (!hint)
+            return;
+        const statusAction = hint.promoteRequestId ? 'promote' : 'add';
+        const statusHint = this.observerHintStatusHint(hint, statusAction === 'promote' ? target.requestId : undefined);
+        try {
+            this.observerHintFailed?.(statusHint, {
+                channelKey: target.channelKey,
+                channelId: target.channelId,
+                chatType: target.chatType,
+                threadId: target.threadId,
+            }, {
+                code, message: OBSERVER_HINT_FAILURE_MESSAGES[code], action: statusAction,
+                requestId: target.requestId ?? hint.promoteRequestId,
+            });
+        }
+        catch (error) {
+            logger.warn(`[ResponseEngine] observer hint schedule failure status failed id=${hint.id}: ${error}`);
+        }
+    }
+    async observerTargetSession(target) {
+        const session = target.threadId
+            ? await this.sessionManager.getThreadSession(target.channelKey, target.channelId, target.threadId)
+            : this.sessionManager.getActiveSessionSync(target.channelKey, target.channelId, 'aun', target.selfAid);
+        if (!session || session.deletedAt || session.selfAID !== target.selfAid || session.channel !== target.channelKey
+            || session.channelId !== target.channelId || session.chatType !== target.chatType
+            || (session.threadId || '') !== (target.threadId || '')
+            || !this.sessionManager.hasBoundAgentSession(session)
+            || (target.chatType === 'group' && (session.metadata?.groupId !== target.channelId
+                || !session.metadata?.observerLastActorId)))
+            return undefined;
+        return session;
+    }
+    async hasObserverTargetSession(target) {
+        return !!(await this.observerTargetSession(target));
+    }
+    async scheduleObserverHint(target) {
+        const session = await this.observerTargetSession(target);
+        if (!session) {
+            this.observerHintScheduleFailure(target, 'SESSION_NOT_FOUND');
+            return 'SESSION_NOT_FOUND';
+        }
+        if (!this.messageQueue) {
+            this.observerHintScheduleFailure(target, 'QUEUE_FAILED');
+            throw new Error('Observer hint queue is unavailable');
+        }
+        const scheduledKey = `${session.id}\u0000${target.hintId}`;
+        if (this.scheduledObserverHints.has(scheduledKey))
+            return 'duplicate';
+        this.scheduledObserverHints.add(scheduledKey);
+        try {
+            await this.messageQueue.withSessionBarrier(session.id, async (snapshot) => {
+                if (snapshot.active && !snapshot.dispatching) {
+                    let timeout;
+                    try {
+                        try {
+                            await Promise.race([
+                                this.messageQueue.interruptForPriority(session.id),
+                                new Promise((_, reject) => {
+                                    timeout = setTimeout(() => reject(new Error('Observer hint interrupt barrier timed out')), 30_000);
+                                    timeout.unref?.();
+                                }),
+                            ]);
+                        }
+                        catch (error) {
+                            const code = error instanceof Error
+                                && error.message === 'Observer hint interrupt barrier timed out'
+                                ? 'INTERRUPT_TIMEOUT' : 'INTERRUPT_FAILED';
+                            this.observerHintScheduleFailure(target, code);
+                            throw error;
+                        }
+                    }
+                    finally {
+                        if (timeout)
+                            clearTimeout(timeout);
+                    }
+                }
+                const receivedAt = Date.now();
+                const actorId = target.chatType === 'group'
+                    ? session.metadata.observerLastActorId : target.channelId;
+                try {
+                    await this.messageQueue.enqueuePersisted(session.id, {
+                        channel: session.channel, channelType: 'aun', channelId: session.channelId,
+                        selfAID: session.selfAID, baseagent: session.baseagent, threadId: session.threadId,
+                        chatType: target.chatType, groupId: target.chatType === 'group' ? target.channelId : undefined,
+                        peerId: actorId, peerName: session.metadata?.observerLastPeerName || session.metadata?.peerName,
+                        peerType: session.metadata?.observerLastPeerType || session.metadata?.peerType,
+                        replyContext: replyContextFromSession(session),
+                        boundSessionId: session.id, content: '', source: 'owner-inject', observerHintId: target.hintId,
+                        ...(target.requestId ? { observerHintRequestId: target.requestId } : {}),
+                        messageId: `owner-hint-${crypto.randomUUID()}`, receivedAt, timestamp: receivedAt,
+                    }, session.projectPath, {
+                        priority: true, interruptible: false, interruptSamePeer: false,
+                        agentName: this.agentRegistry?.resolveByChannel(session.channel)?.name,
+                        selfAID: target.selfAid, sessionKeyField: session.sessionKey,
+                    });
+                }
+                catch (error) {
+                    this.observerHintScheduleFailure(target, 'QUEUE_PERSIST_FAILED');
+                    throw error;
+                }
+            });
+            return 'queued';
+        }
+        catch (error) {
+            this.scheduledObserverHints.delete(scheduledKey);
+            throw error;
+        }
+    }
     async recoverTask(request) {
         if (!this.taskRecoveryService) {
             return { ok: false, status: 'not_recoverable', sessionId: request.sessionId, message: '消息队列尚未初始化' };
@@ -1159,7 +1363,7 @@ export class ResponseEngine {
         else
             await this.interruptSession(sessionId, error instanceof OrphanedTargetSessionError ? 'execution_error' : 'timeout');
     }
-    async interruptSession(sessionId, reason) {
+    async interruptSession(sessionId, reason, strict = false) {
         this.clearPauseSession(sessionId);
         // A retry delay has no active runner stream to abort. Wake it before any
         // session-store I/O so /stop and a newer message take effect immediately.
@@ -1239,6 +1443,8 @@ export class ResponseEngine {
         })();
         const runnerInterrupt = agent.interrupt(sessionId).catch(error => {
             logger.debug(`[ResponseEngine] interrupt barrier runner failure: session=${sessionId} error=${error instanceof Error ? error.message : String(error)}`);
+            if (strict)
+                throw error;
         });
         await Promise.all([terminalStatus, runnerInterrupt]);
     }
@@ -1393,32 +1599,30 @@ export class ResponseEngine {
         const globalCm = agent.config?.chatmode ?? this.globalSettings.chatmode;
         return agent.getContext(channelName, chatType, globalCm);
     }
-    /**
-     * 观察者插话（v0.3）：消费当前 (对端, thread) 的待用提示，转成 owner-hint SubMessage。
-     * 一次性语义：consumeHints 回放算有效集后清该 thread（其它 thread 残留则保留，否则删文件）。
-     * 仅 aun 渠道（pending-hints 落在 sessions/aun/<self>/<对端>/）。
-     */
+    /** Claim matching hints for this turn; only commit after the runner accepts its prompt. */
     consumeOwnerHints(session, message) {
+        if (message.source !== 'owner-inject' && message.source !== 'user' && message.source !== undefined)
+            return { items: [] };
         const channelType = session.channelType || message.channelType || session.channel;
         if (channelType !== 'aun')
-            return [];
+            return { items: [] };
         const selfAID = session.selfAID || message.selfAID;
         if (!selfAID)
-            return [];
+            return { items: [] };
         // 会话定位键：私聊=对端 AID，群聊=groupId（均为 session.channelId）。
         const peerChannelId = session.channelId;
         if (!peerChannelId)
-            return [];
+            return { items: [] };
         try {
-            const hints = consumeHints(resolvePaths().sessionsDir, 'aun', peerChannelId, selfAID, session.threadId);
-            if (hints.length === 0)
-                return [];
-            logger.info(`[ResponseEngine] consumed ${hints.length} owner-hint(s) for ${peerChannelId} thread=${session.threadId || 'main'}`);
-            return hintsToSubMessages(hints);
+            const claim = claimHints(resolvePaths().sessionsDir, 'aun', peerChannelId, selfAID, session.threadId, (message.chatType || session.chatType || 'private'), message.source === 'owner-inject' ? 'interrupt' : 'next', message.observerHintId, session.channel);
+            if (claim.hints.length === 0)
+                return { items: [] };
+            logger.info(`[ResponseEngine] claimed ${claim.hints.length} owner-hint(s) for ${peerChannelId} thread=${session.threadId || 'main'}`);
+            return { items: hintsToSubMessages(claim.hints), claim };
         }
         catch (e) {
             logger.warn(`[ResponseEngine] consumeOwnerHints failed: ${e instanceof Error ? e.message : String(e)}`);
-            return [];
+            return { items: [] };
         }
     }
     /**
@@ -1594,8 +1798,8 @@ export class ResponseEngine {
     }
     /**
      * A fullaccess Trigger may run with no current relation access for its
-     * origin actor, but only after the daemon gate and persisted owner
-     * provenance still validate. This is intentionally stricter than merely
+     * origin actor, but only after its persisted owner provenance still
+     * validates. This is intentionally stricter than merely
      * checking the message's requested permission mode.
      */
     isCurrentFullAccessTrigger(message) {
@@ -1609,8 +1813,7 @@ export class ResponseEngine {
             return false;
         }
         try {
-            return isFullAccessEnabled()
-                && new Set(loadDaemonConfig().owners ?? []).has(trigger.authorizedBy);
+            return new Set(loadDaemonConfig().owners ?? []).has(trigger.authorizedBy);
         }
         catch {
             return false;
@@ -1618,7 +1821,7 @@ export class ResponseEngine {
     }
     /**
      * The authorization envelope is immutable for one logical run, but the
-     * daemon gate, approving owner, and runner profile are live policy. Check
+     * approving owner and runner profile are live policy. Check
      * them immediately before every Runner invocation, including retries.
      */
     assertCurrentFullAccessExecutionAuthorization(authorization, agent) {
@@ -1639,9 +1842,6 @@ export class ResponseEngine {
         else if (authorization.source !== 'fullaccess-command' && authorization.source !== 'trigger') {
             throw new Error('fullaccess execution authorization has an unsupported source');
         }
-        if (!isFullAccessEnabled()) {
-            throw new Error('fullaccess execution is disabled by daemon.json');
-        }
         const currentOwners = new Set(loadDaemonConfig().owners ?? []);
         if (!currentOwners.has(authorization.authorizedBy)) {
             throw new Error('fullaccess execution authorization is no longer owned');
@@ -1831,7 +2031,7 @@ export class ResponseEngine {
         '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork',
         '/stop', '/pause', '/resume', '/clear', '/compact', '/renew', '/del', '/perm', '/file', '/check',
         '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/observable', '/chatmode',
-        '/aid', '/upgrade', '/evolagent', '/pair ',
+        '/aid', '/upgrade', '/evolagent', '/pair ', '/memory',
     ];
     /** 判断消息内容是否为已知命令 */
     isKnownCommand(content) {
@@ -1849,9 +2049,15 @@ export class ResponseEngine {
         }
         catch (error) {
             outerFailureReason = error instanceof Error ? error.message : String(error);
+            if (message.source === 'owner-inject') {
+                this.reportObserverHintFailureForMessage(message, this.observerHintFailureCodeForError(error));
+            }
             throw error;
         }
         finally {
+            if (message.source === 'owner-inject' && message.observerHintId && message.boundSessionId) {
+                this.scheduledObserverHints.delete(`${message.boundSessionId}\u0000${message.observerHintId}`);
+            }
             if (fallbackFullAccessAudit && !this.fullAccessTerminalMessages.has(message)) {
                 auditFullAccessEvent({
                     event: fallbackFullAccessAudit.authorization.source === 'trigger'
@@ -1878,6 +2084,28 @@ export class ResponseEngine {
     async processMessageWithMonitors(message) {
         const idleMs = (this.globalSettings.idleMonitor?.timeout ?? 120) * 1000;
         const totalExecutionMs = this.totalExecutionLimitMs();
+        // A discarded handoff must be dropped before any bound-session lookup.
+        // Restored origin deliveries may point at a session that has already been
+        // replaced; resolving it first would reactivate the stale session path.
+        if (message.handoffDelivery
+            && this.handoffRuntime
+            && this.handoffRuntime.isDiscardedDelivery(message)) {
+            logger.info(`[ResponseEngine] Skip stale handoff delivery before session resolution:`
+                + ` direction=${message.handoffDelivery.direction}`
+                + ` handoff=${message.handoffDelivery.handoffId}`);
+            return;
+        }
+        // Includes persisted queues, recovery triggers and delayed owner replies.
+        // A closed diagnostic must not activate its old main session again.
+        const diagnosticBoundId = message.boundSessionId ?? message.triggerMeta?.boundSessionId;
+        if (diagnosticBoundId) {
+            const bound = await this.sessionManager.getSessionById(diagnosticBoundId);
+            if (bound && (bound.metadata?.diagnostic || bound.metadata?.diagnosticStatus === 'cancelled')
+                && !isDiagnosticSessionActive(bound, this.sessionManager.getChatDir(bound))) {
+                logger.info(`[ResponseEngine] Skip closed diagnostic session ${bound.id}`);
+                return;
+            }
+        }
         if (message.taskRecovery) {
             const current = message.boundSessionId
                 ? await this.sessionManager.getSessionById(message.boundSessionId)
@@ -1887,17 +2115,16 @@ export class ResponseEngine {
                 return;
             }
         }
-        if (message.handoffDelivery
-            && this.handoffRuntime
-            && this.handoffRuntime.isDiscardedDelivery(message)) {
-            logger.info(`[ResponseEngine] Skip stale handoff delivery before session resolution:`
-                + ` direction=${message.handoffDelivery.direction}`
-                + ` handoff=${message.handoffDelivery.handoffId}`);
-            return;
-        }
         // 先解析会话，再优先用 session.metadata.channelKey 精确定位实例级 adapter
         // message.channel 现在存实例名（channelName），可直接用于精确路由
         const { session, absoluteProjectPath } = await this.resolveSession(message);
+        if (message.source === 'owner-inject' && (!message.observerHintId || !peekHints(resolvePaths().sessionsDir, 'aun', session.channelId, session.selfAID || '', session.threadId, session.chatType, 'interrupt', session.channel).some(item => item.id === message.observerHintId))) {
+            this.reportObserverHintFailureForMessage(message, 'HINT_UNAVAILABLE');
+            return;
+        }
+        if ((session.metadata?.diagnostic || session.metadata?.diagnosticStatus === 'cancelled')
+            && !isDiagnosticSessionActive(session, this.sessionManager.getChatDir(session)))
+            return;
         const accessChannelKey = this.messageChannelKey(message, session);
         const accessChannelInfo = this.resolveChannelInfo(accessChannelKey);
         const accessAdapter = accessChannelInfo?.adapter;
@@ -1986,6 +2213,21 @@ export class ResponseEngine {
             this.publishTriggerExecutionFailure(message, 'access_denied');
             return;
         }
+        if (message.chatType === 'group' && (message.source === 'user' || !message.source)) {
+            const actorId = message.items?.filter(item => item.peerId).at(-1)?.peerId || message.peerId;
+            if (actorId) {
+                try {
+                    await this.sessionManager.patchSessionMetadata(session.id, {
+                        observerLastActorId: actorId,
+                        observerLastPeerName: message.peerName,
+                        observerLastPeerType: message.peerType,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`[ResponseEngine] observer group actor snapshot failed: ${error}`);
+                }
+            }
+        }
         // thread(feishu) pending strategy: inject replyContext so first reply creates the thread
         if (message.triggerMeta?.pendingThread && message.triggerMeta?.rootMessageId) {
             message.replyContext = {
@@ -2017,6 +2259,7 @@ export class ResponseEngine {
         catch (error) {
             if (error instanceof BaseagentRunnerUnavailableError) {
                 logger.error(`[ResponseEngine] baseagent mismatch blocked: session=${session.id} channel=${channelKey} requested=${session.baseagent} owner=${error.evolagentName} available=${error.availableBaseagents.join(',') || '<none>'}`);
+                this.reportObserverHintFailureForMessage(message, 'RUNNER_START_FAILED');
                 await this.sendBaseagentMismatch(channelKey, message.channelId, session, error, message.replyContext);
                 this.publishTriggerExecutionFailure(message, `baseagent_unavailable:${error.baseagent}`);
                 return;
@@ -2213,8 +2456,7 @@ export class ResponseEngine {
             && commandAuthorization.authorizedBy.length > 0) {
             let currentOwner = false;
             try {
-                currentOwner = isFullAccessEnabled()
-                    && new Set(loadDaemonConfig().owners ?? []).has(commandAuthorization.authorizedBy);
+                currentOwner = new Set(loadDaemonConfig().owners ?? []).has(commandAuthorization.authorizedBy);
                 if (commandAuthorization.source === 'agent-policy')
                     assertAgentPolicyAuthorization(commandAuthorization);
             }
@@ -2330,6 +2572,8 @@ export class ResponseEngine {
         const isBootstrapping = lifecycle === 'bootstrapping';
         // Per-method agent name for stats bucketing (agent.name or '<unknown>')
         const agentNameForStats = owningAgentForTask?.name ?? taskAgentAid ?? '<unknown>';
+        let ownerHintClaim;
+        let observerHintFailureCode;
         if (!channelInfo) {
             logger.error(`[ResponseEngine] Unknown channel: ${channelKey}`);
             this.publishTriggerExecutionFailure(message, `unknown_channel:${channelKey}`);
@@ -2384,6 +2628,29 @@ export class ResponseEngine {
         }
         // 为本次任务处理生成唯一 task_id（客户端生成，格式 task-{10hex}）
         const taskId = `task-${crypto.randomUUID().replace(/-/g, '').slice(0, 10)}`;
+        let taskActivityStatus = 'running';
+        const taskActivityStore = runnerSelfAid ? new TaskActivityStore(runnerSelfAid) : undefined;
+        if (taskActivityStore) {
+            try {
+                const activityChatType = chatType === 'group' ? 'group' : 'private';
+                const activityChannelId = activityChatType === 'group'
+                    ? (message.groupId || session.metadata?.groupId || message.channelId)
+                    : (message.peerId || message.channelId);
+                taskActivityStore.createTask({
+                    taskId,
+                    sessionId: session.id,
+                    channel: message.channelType || session.channelType || message.channel,
+                    channelId: activityChannelId,
+                    chatType: activityChatType,
+                    ...(activityChatType === 'group' ? { groupId: activityChannelId } : {}),
+                    ...(activityChatType === 'private' ? { peerId: activityChannelId } : {}),
+                    taskStatus: taskActivityStatus,
+                });
+            }
+            catch (error) {
+                logger.warn(`[ResponseEngine] task activity store initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         const taskPauseController = this.getPauseController(session.id);
         let turnLease;
         const inputCausation = normalizeCausation(message.causation) ?? createRootCausation();
@@ -2479,10 +2746,12 @@ export class ResponseEngine {
         // this inbound actor.  Do not fall back to a stale session owner/admin
         // after an alias or Agent-role revocation; only use the persisted session
         // identity when role resolution itself was unavailable.
-        const peerRole = authorizationIdentity?.role
-            ?? (peerRoleDetail
-                ? (peerRoleDetail.effectiveRole ?? 'none')
-                : (session.identity?.role ?? 'none'));
+        const peerRole = message.autoMentionBatch && message.items?.some(item => item.peerRole && item.peerRole !== peerRoleDetail?.effectiveRole)
+            ? 'visitor'
+            : authorizationIdentity?.role
+                ?? (peerRoleDetail
+                    ? (peerRoleDetail.effectiveRole ?? 'none')
+                    : (session.identity?.role ?? 'none'));
         const effectiveAgentConfig = (() => {
             try {
                 return resolveEffective({ self: selfAid || undefined, peerKey }, { cache: true });
@@ -2565,6 +2834,9 @@ export class ResponseEngine {
         outputState.middleOutputMode = middleOutputMode;
         // 诊断日志：记录 inbound message_id 和生成的 task_id 的对应关系
         logger.info(`[ResponseEngine] Task created: inboundMsgId=${message.messageId ?? 'none'} taskId=${taskId} sessionId=${session.id} chatmode=${chatmode} mode=${resolvedMode?.mode.id ?? 'override/fallback'}`);
+        {
+            import('../../utils/msg-diag.js').then(m => m.diagLog('task_created', { aid: session.selfAID ?? '', msgId: message.messageId ?? '', taskId, text: message.content ?? '' })).catch(() => { });
+        }
         // 构建带 taskId/chatmode 的 ReplyContext（本次任务所有出站消息共用）
         const taskReplyContext = () => {
             const base = this.getReplyContext(message);
@@ -2588,6 +2860,19 @@ export class ResponseEngine {
             },
             modeConfig: resolvedMode.context.modeConfig,
             state: modeState,
+            sessionState: resolvedMode.context.sessionState,
+            continuation: message.taskRecovery
+                ? {
+                    kind: 'taskRecovery',
+                    taskId: message.taskRecovery.taskId,
+                    generation: message.taskRecovery.generation,
+                    groupId: message.groupId,
+                    threadId: message.threadId,
+                }
+                : message.restartResume?.submitted
+                    ? { kind: 'restartResume', groupId: message.groupId, threadId: message.threadId }
+                    : undefined,
+            previousTurnState: this.turnCoordinator.current(session),
             isSendCommand: (toolName, toolInput) => isExactEvolcoreSendCommandForSession(toolName, toolInput, session.channelId, chatType, selfAid),
             describeSendCommandFailure: describeProactiveSendCommandFailure,
             logger,
@@ -2824,7 +3109,18 @@ export class ResponseEngine {
                 this.publishTriggerExecutionSkipped(message, 'recovery_stale');
                 return;
             }
-            turnLease = await this.turnCoordinator.begin(session, taskId, undefined, configActorId ? {
+            const sourceMessageId = message.sourceMessageIds === undefined
+                ? message.messageId
+                : message.sourceMessageIds.length === 1 ? message.sourceMessageIds[0] : undefined;
+            const inputId = normalizeBaseagent(agent.name).canonical === 'claude'
+                && configChatType === 'private'
+                && (message.channelType ?? session.channelType) === 'aun'
+                && message.source !== 'trigger'
+                && !message.taskRecovery
+                && sourceMessageId
+                ? aunMessageTranscriptUuid(sourceMessageId)
+                : undefined;
+            turnLease = await this.turnCoordinator.begin(session, taskId, inputId, configActorId ? {
                 peerId: configActorId,
                 encrypted: message.encrypted ?? message.replyContext?.metadata?.encrypted,
                 baseagent: session.baseagent,
@@ -2834,7 +3130,11 @@ export class ResponseEngine {
                 triggerAttemptId: message.triggerMeta?.attemptId,
             } : undefined);
             // 记录开始处理
-            const taskEncrypt = message.replyContext?.metadata?.encrypted != null ? !!(message.replyContext.metadata.encrypted) : undefined;
+            const taskEncrypt = typeof message.encrypted === 'boolean'
+                ? message.encrypted
+                : message.replyContext?.metadata?.encrypted != null
+                    ? !!message.replyContext.metadata.encrypted
+                    : undefined;
             this.eventBus.publish({
                 type: 'task:started',
                 sessionId: session.id,
@@ -2866,6 +3166,9 @@ export class ResponseEngine {
             });
             // 创建 IMRenderer（统一 interactive/proactive 两条路径）
             let firstReply = true;
+            // 出站 debug.model：每次 runQuery 前更新（含备用模型切换）。单独声明是因为
+            // send 闭包早于下方 modelOverride/agentModel 的 let 声明，直接引用会撞 TDZ。
+            let debugRunnerModel;
             const renderer = new IMRenderer({
                 adapter,
                 envelope,
@@ -2874,8 +3177,32 @@ export class ResponseEngine {
                 flushDelay: (options?.flushDelay ?? this.agentRegistry?.resolveByChannel(channelKey)?.config?.flush_delay ?? 3) * 1000,
                 suppressActivityItems: isProactive ? false : middleOutputMode !== 'all',
                 suppressIntermediateText: isProactive ? false : middleOutputMode === 'none',
+                deferTextUntilBoundary: (message.channelType ?? session.channelType) === 'aun' && session.chatType === 'private',
                 operationalNoticesAsText: !isProactive && middleOutputMode !== 'none',
                 fileMarkerPattern: options?.fileMarkerPattern,
+                recordActivity: item => {
+                    if (!taskActivityStore || (turnLease && !this.turnCoordinator.canPublish(turnLease)))
+                        return;
+                    try {
+                        const activityChatType = chatType === 'group' ? 'group' : 'private';
+                        const activityChannelId = activityChatType === 'group'
+                            ? (message.groupId || session.metadata?.groupId || message.channelId)
+                            : (message.peerId || message.channelId);
+                        taskActivityStore.append({
+                            taskId,
+                            sessionId: session.id,
+                            channel: message.channelType || session.channelType || message.channel,
+                            channelId: activityChannelId,
+                            chatType: activityChatType,
+                            ...(activityChatType === 'group' ? { groupId: activityChannelId } : {}),
+                            ...(activityChatType === 'private' ? { peerId: activityChannelId } : {}),
+                            item,
+                        });
+                    }
+                    catch (error) {
+                        logger.warn(`[ResponseEngine] task activity record failed: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                },
                 send: async (payload) => {
                     if (turnLease && !this.turnCoordinator.canPublish(turnLease)) {
                         snapshot.pushOutbound(session.id, taskId, { kind: payload.kind, decision: 'suppressed-stale-turn' });
@@ -2907,8 +3234,13 @@ export class ResponseEngine {
                     }
                     opts.sessionId = session.id;
                     if (payload.kind === 'result.text' && payload.isFinal) {
-                        opts.title = '\u2705 \u6700\u7ec8\u56de\u590d:';
+                        opts.ext = { ...opts.ext, isFinal: true };
                     }
+                    opts.debug = {
+                        sessionId: session.id,
+                        ...(session.agentSessionId ? { agentSessionId: session.agentSessionId } : {}),
+                        ...(debugRunnerModel ? { model: debugRunnerModel } : {}),
+                    };
                     opts.metadata = withTaskMetadata({
                         ...(opts.metadata ?? {}),
                         ...(payload.kind === 'result.text' ? payload.metadata : {}),
@@ -3080,7 +3412,12 @@ export class ResponseEngine {
             const runModeConfig = resolvedMode?.mode.configureRun && modeProcessCtx
                 ? resolvedMode.mode.configureRun(modeProcessCtx)
                 : undefined;
-            const pureSessionPolicyHook = runModeConfig?.policyHook;
+            const modePolicyHook = runModeConfig?.policyHook;
+            // 整理会话：写工具全拦、Bash 只放行 ec memory create|update|archive，先于模式策略判定
+            const isMemorySession = (session.sessionType ?? session.metadata?.sessionType) === 'memory';
+            const pureSessionPolicyHook = isMemorySession
+                ? (toolName, toolInput) => memorySessionPolicyHook(toolName, toolInput) ?? modePolicyHook?.(toolName, toolInput)
+                : modePolicyHook;
             // 设置权限审批的交互上下文（支持交互卡片）
             const permissionContext = {
                 sendPrompt: permissionPromptForOrigin,
@@ -3203,6 +3540,9 @@ export class ResponseEngine {
                         const stBefore = modeState.get('proactive');
                         const wasFirstPending = stBefore && !stBefore.firstToolDone;
                         const result = pluginHook(toolName, toolInput);
+                        // 整理会话的拦截原因已经写清楚怎么改，不套 proactive 违规提醒
+                        if (result?.block && result.policyCode?.startsWith('memory_session_'))
+                            return result;
                         if (result?.block) {
                             // 拦截事件（首工具非表态 / 工具进展汇报未完成）
                             snapshot.set(session.id, taskId, { policyHook: { triggered: true, blocked: true, toolName } });
@@ -3264,10 +3604,9 @@ export class ResponseEngine {
                 if (!isProactive && channelInfo.adapter.capabilities?.file)
                     capParts.push('文件发送');
                 // Personal state is exposed to the manifest as vars. The manifest owns
-                // loading persona.md and working.md into the system prompt.
+                // loading persona.md into the system prompt.
                 const owningAgent = owningAgentForTask;
                 const persona = isActive ? (owningAgent?.getPersona?.() || undefined) : undefined;
-                const working = isActive ? (owningAgent?.getWorkingMemory?.() || undefined) : undefined;
                 // 计算 peerKey：群聊固定按 groupId/channelId，私聊按发送者 peerId。
                 // 这样单条和积压合并批次不会因队列状态不同而切换关系级配置。
                 const normalizedBaseagent = normalizeBaseagent(agent.name);
@@ -3609,6 +3948,10 @@ export class ResponseEngine {
                         },
                     }).allow;
                 };
+                // 会话原型与整理模式：必须在 kitCtx 构造之前读出，manifest 的 when 条件
+                // 依赖它们选段（缺了会 fail-closed —— 模式手册全不加载，且不报错）。
+                const renderedSessionType = session.sessionType ?? session.metadata?.sessionType ?? 'main';
+                const memoryMode = session.metadata?.memoryMode;
                 // Kit renderer: 组装上下文
                 const pkgRoot = getPackageRoot();
                 const kitCtx = {
@@ -3626,16 +3969,36 @@ export class ResponseEngine {
                         // evolcore 运行模式：dev=源码仓库 | install=全局安装包
                         evolcoreMode: readEvolcoreRuntimeFlavor(),
                         // 路径变量(用于 manifest 路径展开,resolvePath 用 ctx.vars 取真值)
+                        // AGENT_DIR 是 manifest 的合法别名（buildPathMappings 有注册），
+                        // 缺了它引用 $AGENT_DIR 的段（如技能索引）会整段静默丢弃。
+                        AGENT_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid) : undefined,
                         PERSONAL_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'personal') : undefined,
                         RELATIONS_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'relations') : undefined,
                         VENUES_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'venues') : undefined,
                         selfAid: selfAid || undefined,
+                        // ownerAid：当前 agent 的第一个 owner AID，用于 owner 作用域记忆路径展开。
+                        // 来源：getFirstStaticAgentOwner 读 config.json owners[0]；AID 格式不合法时置 undefined。
+                        ownerAid: (() => {
+                            const raw = selfAid ? getFirstStaticAgentOwner(selfAid) : undefined;
+                            if (!raw)
+                                return undefined;
+                            return isValidAid(raw) ? raw : undefined;
+                        })(),
+                        // 记忆系统开关变量（来自 effectiveAgentConfig.memory，默认全部启用）。
+                        // enableRelation 是总开关：relation 是所有记忆的唯一出生地。
+                        // memory.enableRelation 在 relation-config schema 里声明了 x-merge-logic: AND，
+                        // mergeLayers 会自动处理 agent 级与 relation 级的 AND 合并，无需手动读两层。
+                        memoryEnableRelation: effectiveAgentConfig?.memory?.enableRelation ?? true,
+                        memoryEnableAgent: effectiveAgentConfig?.memory?.enableAgent ?? true,
+                        memoryEnableOwner: effectiveAgentConfig?.memory?.enableOwner ?? true,
+                        // 会话原型与整理模式（manifest 的 when 条件靠它们选段）
+                        sessionType: renderedSessionType,
+                        memoryMode,
                         selfName: selfName || undefined,
                         agentMdPath: selfAid ? agentMdPath(selfAid) : undefined,
                         lifecycle,
                         isBootstrapping,
                         hasPersona: !!persona,
-                        hasWorkingMemory: !!working,
                         peerId: peerIdRaw || undefined,
                         peerKey,
                         peerName: peerName || undefined,
@@ -3686,9 +4049,10 @@ export class ResponseEngine {
                         // 默认值不在此硬编码，出厂默认由模式 schema 声明、经 buildState 落入 proactive.*。
                         proactivePreTool1stMsgChk: proactive?.preTool1stMsgChk ?? false,
                         proactiveToolUseReminder: proactive?.toolUseReminder ?? false,
-                        proactiveFirstSendRequired: proactive?.firstSendRequired ?? false,
+                        // 明确续跑已表态时，提示词和运行时门禁都不再要求重复开场。
+                        proactiveFirstSendRequired: proactive?.firstSendRequired === true && !proactive.firstToolDone,
                         proactiveToolReportRequired: proactive?.toolReportRequired ?? false,
-                        proactiveToolReportInterval: proactive?.toolReportInterval ?? 10,
+                        proactiveToolReportInterval: proactive?.toolReportInterval ?? 20,
                         proactiveSendTargetLabel: chatType === 'group' ? '群里' : '对方',
                         readonly: effectivePermissionMode === 'readonly',
                         baseAgent: normalizedBaseagent.canonical,
@@ -3704,15 +4068,20 @@ export class ResponseEngine {
                     },
                     sessionId: session.id,
                 };
-                // 按会话原型（sessionType）选 manifest 文件：config.sessionManifests 映射，缺省回退主 manifest。
-                const sessionType = session.sessionType ?? 'main';
+                // 确保技能索引是最新的（懒加载机制）
+                if (selfAid) {
+                    const { ensureSkillIndexUpToDate } = await import('../skill/startup.js');
+                    ensureSkillIndexUpToDate(resolveAgentDir(selfAid), selfAid);
+                }
+                // 按会话原型（sessionType）选 manifest 文件：config.sessionManifests 覆盖 → 内置映射 → 主 manifest。
+                const sessionType = renderedSessionType;
                 const sessionManifests = this.agentRegistry?.resolveByChannel(channelKey)?.config?.sessionManifests;
                 // Bootstrap always uses the lifecycle-gated main manifest. A custom
                 // session manifest (for example the auxiliary manifest with `always`
                 // sections) must not reintroduce normal rules or command context.
                 const manifestFile = isBootstrapping
-                    ? 'eck_manifest.json'
-                    : sessionManifests?.[sessionType] ?? 'eck_manifest.json';
+                    ? DEFAULT_MANIFEST_FILE
+                    : resolveSessionManifest(sessionType, sessionManifests);
                 const kitContext = renderKitSections(kitCtx, manifestFile);
                 effectiveSystemPrompt = [options?.systemPromptAppend, kitContext].filter(Boolean).join('\n') || undefined;
                 // ── Stats: context_breakdown 旁路采集（各段估算 token 数，字符数/4 近似） ──
@@ -3747,9 +4116,9 @@ export class ResponseEngine {
                 catch { /* non-fatal */ }
                 // 消息渲染层：用 message manifest 逐条渲染（时间 + 群聊发送者），组装成最终正文。
                 // 单条消息构造单元素 items；批量合并的消息 message.items 已由队列填充。
-                const hasContent = message.content.trim() || (message.items && message.items.length > 0);
+                const hasContent = !!message.observerHintId || message.content.trim() || !!message.images?.length || (message.items && message.items.length > 0);
                 if (hasContent) {
-                    const rawPeerItems = message.items && message.items.length > 0
+                    const rawPeerItems = message.source === 'owner-inject' ? [] : message.items && message.items.length > 0
                         ? message.items
                         : [{
                                 peerId: message.peerId, peerName: peerName || undefined,
@@ -3776,10 +4145,17 @@ export class ResponseEngine {
                         }
                         return rawPeerItems;
                     })();
-                    // 观察者插话（v0.3）：消费 (对端, thread) 的待用提示，包成 owner-hint item 排在对端消息前。
-                    // 一次性语义：consumeOwnerHints 读取并删除（见 pending-hints.ts）。在 try 外消费，
-                    // 这样即便 renderMessageBody 抛错走 raw 兜底，也把提示原文拼进去——绝不静默丢提示。
-                    const hintItems = this.consumeOwnerHints(session, message);
+                    // 将匹配的 pending hint 暂时 claim，排在真实消息之前；渲染或启动
+                    // 失败时释放 claim，只有 runner 接受 prompt 后才持久化 consumed。
+                    const hintResult = this.consumeOwnerHints(session, message);
+                    ownerHintClaim = hintResult.claim;
+                    const hintItems = hintResult.items;
+                    if (message.source === 'owner-inject' && hintItems.length === 0) {
+                        if (turnLease)
+                            await this.turnCoordinator.finish(session, turnLease, 'cancelled', 'owner_hint_unavailable');
+                        this.sessionManager.clearProcessingIfTask(session.id, taskId);
+                        return;
+                    }
                     const renderItems = hintItems.length > 0 ? [...hintItems, ...peerItems] : peerItems;
                     const fallbackContent = (() => {
                         if (!message.restartResume?.submitted || peerItems.length === 0)
@@ -3820,8 +4196,16 @@ export class ResponseEngine {
                             effectivePrompt = wrapPrompt(composeHintFallback(hintItems, fallbackContent));
                     }
                     catch (e) {
-                        logger.warn(`[ResponseEngine] renderMessageBody failed, using raw content: ${e instanceof Error ? e.message : String(e)}`);
-                        effectivePrompt = wrapPrompt(composeHintFallback(hintItems, fallbackContent));
+                        logger.warn(`[ResponseEngine] renderMessageBody failed: ${e instanceof Error ? e.message : String(e)}`);
+                        if (ownerHintClaim) {
+                            observerHintFailureCode = 'RENDER_FAILED';
+                            this.reportObserverHintFailureForClaim(message, session, ownerHintClaim, observerHintFailureCode);
+                            releaseHintClaim(ownerHintClaim);
+                            ownerHintClaim = undefined;
+                        }
+                        if (message.source === 'owner-inject')
+                            throw e;
+                        effectivePrompt = wrapPrompt(fallbackContent);
                     }
                     if (v2HandoffIds.length > 0 && renderResult?.body.trim())
                         handoffPromptRendered = true;
@@ -3835,6 +4219,12 @@ export class ResponseEngine {
                 // 空消息防护：在 agent 调用之前检查 prompt 是否为空
                 // 防止空消息（或纯空格消息）浪费 API 调用
                 if (!effectivePrompt.trim()) {
+                    if (ownerHintClaim) {
+                        observerHintFailureCode = 'HINT_UNAVAILABLE';
+                        this.reportObserverHintFailureForClaim(message, session, ownerHintClaim, observerHintFailureCode);
+                        releaseHintClaim(ownerHintClaim);
+                        ownerHintClaim = undefined;
+                    }
                     logger.info(`[ResponseEngine] Skip agent call: empty prompt after render. session=${session.id} task=${taskId}`);
                     if (turnLease)
                         await this.turnCoordinator.finish(session, turnLease, 'cancelled', 'empty_prompt');
@@ -3870,9 +4260,18 @@ export class ResponseEngine {
                     chatType: configChatType,
                     selfAid,
                     peerId: configActorId || undefined,
+                    peerKey,
                     peerName: peerName || undefined,
                     peerType: message.peerType || session.metadata?.peerType || undefined,
                     peerRole,
+                    // 会话原型与整理模式：ipc 侧靠 sessionType 拦非整理会话的写命令，
+                    // 靠 memoryMode 校验 --scope 是否与本模式匹配。
+                    sessionType: renderedSessionType,
+                    memoryMode: session.metadata?.memoryMode ?? undefined,
+                    memoryScope: session.metadata?.memoryScope ?? undefined,
+                    consolidationBatchDir: session.metadata?.consolidationBatchDir
+                        ?? session.metadata?.consolidationLogBase
+                        ?? undefined,
                     permissionMode: effectivePermissionMode,
                     ...(fullAccessAuthorization ? {
                         processRole: fullAccessAuthorization.processRole,
@@ -3932,6 +4331,7 @@ export class ResponseEngine {
                     let attemptTimeout;
                     try {
                         logger.info(`[ResponseEngine] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${runAttempt} apiRetries=${retryScheduler.apiRetryAttemptsMade} agentSessionId=${runAgentSessionId ?? 'none'} topicBinding=${session.threadId ? 'authoritative' : 'legacy'}`);
+                        import('../../utils/msg-diag.js').then(m => m.diagLog('task_start', { aid: session.selfAID ?? '', msgId: message.messageId ?? '', taskId, sessionId: runAgentSessionId ?? undefined, text: message.content ?? '' })).catch(() => { });
                         if (fullAccessAuthorization) {
                             this.assertCurrentFullAccessExecutionAuthorization(fullAccessAuthorization, agent);
                             if (fullAccessAuditStartedAt === undefined) {
@@ -3984,13 +4384,41 @@ export class ResponseEngine {
                             modelOverride = { ...modelOverride,
                                 enableRequestUserInput: effectiveAgentConfig?.baseagents?.codex?.enableRequestUserInput ?? true };
                         }
-                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, runAgentSessionId, renderResult?.images.length ? renderResult.images : message.images, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
+                        const sourceImages = renderResult?.images.length ? renderResult.images : message.images;
+                        const runnerImages = sourceImages?.map(image => ({
+                            data: image.data,
+                            mimeType: image.mimeType,
+                        }));
+                        debugRunnerModel = modelOverride?.model || agentModel;
+                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, runAgentSessionId, runnerImages, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
                         // The turn may be superseded while the runner is still creating its
                         // backend query. Replay the interrupt after runQuery resolves, when
                         // every runner is required to have an addressable cancellation handle.
                         if (await this.cancelStaleRunnerStart(agent, session.id, streamKey, turnLease, taskId)) {
                             throw new Error('RUNNER_START_SUPERSEDED');
                         }
+                        if (ownerHintClaim) {
+                            const accepted = ownerHintClaim;
+                            if (commitHintClaim(accepted)) {
+                                for (const hint of accepted.hints) {
+                                    try {
+                                        this.observerHintConsumed?.(hint, {
+                                            channelKey: session.channel, channelId: accepted.channelId,
+                                            chatType: accepted.chatType, threadId: accepted.threadId || undefined,
+                                        }, {
+                                            action: hint.promoteRequestId ? 'promote' : 'add',
+                                            requestId: hint.promoteRequestId ?? message.observerHintRequestId ?? (hint.mode === 'interrupt' ? hint.id : undefined),
+                                        });
+                                    }
+                                    catch (error) {
+                                        logger.warn(`[ResponseEngine] observer hint status failed id=${hint.id}: ${error}`);
+                                    }
+                                }
+                            }
+                            else
+                                releaseHintClaim(accepted);
+                            ownerHintClaim = undefined;
+                        }
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
                         if (shouldTimeoutRetryAttempt) {
@@ -4000,7 +4428,11 @@ export class ResponseEngine {
                         const processAttempt = this.processEventStream(stream, session, agent, renderer, (eventType, toolName) => {
                             resetTimer(eventType, toolName);
                             attemptTimeout?.reset();
-                        }, shouldSuppress, proactive, resolvedMode ? { mode: resolvedMode.mode, state: modeState } : undefined, taskCausation, turnLease, effectivePermissionMode, selfAid, async (request) => {
+                        }, shouldSuppress, proactive, resolvedMode ? {
+                            mode: resolvedMode.mode,
+                            state: modeState,
+                            sessionState: resolvedMode.context.sessionState,
+                        } : undefined, taskCausation, turnLease, effectivePermissionMode, selfAid, async (request) => {
                             if (!this.asyncQuestions)
                                 throw new Error('Async question service is unavailable');
                             if (permissionContext.approvalInteractionPolicy === 'deny') {
@@ -4166,6 +4598,7 @@ export class ResponseEngine {
                 }
             }
             catch (error) {
+                observerHintFailureCode = this.observerHintFailureCodeForError(error);
                 if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.agentSessionId && canCompactAgent(agent)) {
                     streamResult = await this.recoverFromContextLimit(streamResult, {
                         streamKey,
@@ -4420,6 +4853,11 @@ export class ResponseEngine {
             // 最终回复文本：suppressed 模式或无 text 事件时需要兜底添加
             const finalReplyText = streamResult.lastReplyText || streamResult.fullText;
             const visibleFinalReplyText = stripContextLimitErrorLines(finalReplyText);
+            const isDiagnosticFallback = streamResult.isError && !streamResult.hasReceivedText;
+            const isTriggerNoop = message.source === 'trigger'
+                && typeof message.triggerMeta?.noopSentinel === 'string'
+                && message.triggerMeta.noopSentinel.length > 0
+                && visibleFinalReplyText.trim() === message.triggerMeta.noopSentinel;
             if (!this.turnCoordinator.isCurrent(turnLease)) {
                 agent.cleanupStream(streamKey);
                 this.sessionManager.clearProcessingIfTask(session.id, taskId);
@@ -4431,7 +4869,7 @@ export class ResponseEngine {
                 await this.publishTriggerExecutionInterrupted(message, adapter, envelope, 'stale_turn', taskCausation);
                 return;
             }
-            if (visibleFinalReplyText) {
+            if (visibleFinalReplyText && !isDiagnosticFallback && !isTriggerNoop) {
                 // `hasReceivedText` 是任务级计数。工具调用前的文字已经显示，并不表示最后一轮
                 // （通常来自 complete.result）的文字也已显示；用本轮投影标记避免终态丢失。
                 if (shouldSuppress() || !streamResult.hasProjectedCurrentReplyText) {
@@ -4447,6 +4885,7 @@ export class ResponseEngine {
             }
             this.agentDelegationRegistry?.revokeTask(session.id, taskId);
             logger.info(`[ResponseEngine] session ${session.id} processing cleared task=${taskId}`);
+            import('../../utils/msg-diag.js').then(m => m.diagLog('task_done', { aid: session.selfAID ?? '', msgId: message.messageId ?? '', taskId, text: message.content ?? '' })).catch(() => { });
             // 降级模型回复末尾追加标记（代码层硬注入，不依赖模型输出）
             if (usedFallback) {
                 const curFbState = this.modelFallbackMap.get(session.id);
@@ -4518,6 +4957,7 @@ export class ResponseEngine {
                 // 这不是真正的失败，不应把诊断串暴露给用户，也不计入错误统计。
                 const isExpectedInterrupt = isNonErrorInterruptReason(interruptReason)
                     || isExpectedTerminalInterrupt(streamResult.terminalReason);
+                taskActivityStatus = isExpectedInterrupt ? 'interrupted' : 'error';
                 if (!isExpectedInterrupt && !permissionTerminalFailure) {
                     const terminalMetadata = {
                         errorType: rawSubtype,
@@ -4607,6 +5047,7 @@ export class ResponseEngine {
             }
             else {
                 // 真正的成功
+                taskActivityStatus = 'completed';
                 if (!this.turnCoordinator.canPublish(turnLease)) {
                     logger.info(`[ResponseEngine] Suppressing stale success path: session=${session.id} task=${taskId}`);
                     await this.publishTriggerExecutionInterrupted(message, adapter, envelope, 'stale_turn', taskCausation);
@@ -4809,6 +5250,7 @@ export class ResponseEngine {
                     durationMs: Date.now() - startTime,
                     agentName: agentNameForStats,
                     numTurns: streamResult.numTurns,
+                    encrypted: message.encrypted ?? message.replyContext?.metadata?.encrypted,
                     timestamp: Date.now(),
                     causation: taskCausation,
                 });
@@ -4847,6 +5289,15 @@ export class ResponseEngine {
             });
         }
         catch (error) {
+            if (error instanceof Error && (error.message === 'TOTAL_EXECUTION_TIMEOUT' || error.message === 'SDK_TIMEOUT')) {
+                taskActivityStatus = 'timeout';
+            }
+            else if (isNonErrorInterruptReason(this.interruptedSessions.get(session.id))) {
+                taskActivityStatus = 'interrupted';
+            }
+            else {
+                taskActivityStatus = 'error';
+            }
             fullAccessExecutionFailed = true;
             fullAccessExecutionFailureReason = error instanceof Error ? error.message : String(error);
             const authoritativeTimeoutError = timeoutControl?.claim();
@@ -5064,6 +5515,37 @@ export class ResponseEngine {
             }
         }
         finally {
+            if (taskActivityStore) {
+                try {
+                    taskActivityStore.updateStatus(taskId, taskActivityStatus);
+                }
+                catch (error) {
+                    logger.warn(`[ResponseEngine] task activity status update failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            if (turnLease && resolvedMode?.mode.onTurnEnd) {
+                try {
+                    const current = this.turnCoordinator.current(session);
+                    await resolvedMode.mode.onTurnEnd({
+                        session,
+                        state: modeState,
+                        sessionState: resolvedMode.context.sessionState,
+                        turn: turnLease,
+                        terminal: current.active ? undefined : current.lastTerminal,
+                        logger,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`[ResponseEngine] onTurnEnd failed: session=${session.id} task=${taskId} error=${String(error)}`);
+                }
+            }
+            if (ownerHintClaim) {
+                // A runner error, interruption, or pre-run failure leaves the durable
+                // hint pending for the next attempt.
+                this.reportObserverHintFailureForClaim(message, session, ownerHintClaim, observerHintFailureCode ?? 'RUNNER_START_FAILED');
+                releaseHintClaim(ownerHintClaim);
+                ownerHintClaim = undefined;
+            }
             if (fullAccessAuthorization) {
                 const startedAt = fullAccessAuditStartedAt;
                 const executed = fullAccessRunnerInvoked;
@@ -5212,6 +5694,30 @@ export class ResponseEngine {
      * 解析会话和项目路径
      */
     async resolveSession(message) {
+        if (message.source === 'owner-inject') {
+            const bound = message.boundSessionId
+                ? await this.sessionManager.getSessionById(message.boundSessionId) : undefined;
+            if (!message.observerHintId || !bound || bound.deletedAt || !bound.agentSessionId
+                || bound.channel !== message.channel || bound.channelId !== message.channelId
+                || bound.selfAID !== message.selfAID || bound.chatType !== message.chatType
+                || (bound.threadId || '') !== (message.threadId || '')) {
+                throw new Error('Observer hint target session is no longer available');
+            }
+            // An enqueued priority hint is bound to exactly the session selected at
+            // submission. A later /new, /renew, thread switch or missing provider
+            // file must never silently resume a stale/different backend session.
+            const current = await this.observerTargetSession({
+                channelKey: bound.channel, channelId: bound.channelId,
+                chatType: bound.chatType, threadId: bound.threadId,
+                selfAid: bound.selfAID,
+            });
+            if (current?.id !== bound.id || current.agentSessionId !== bound.agentSessionId) {
+                throw new Error('Observer hint target session is no longer available');
+            }
+            bound.identity = this.inferDirectSessionIdentity(message, this.agentRegistry?.resolveByChannel(bound.channel));
+            return { session: bound, absoluteProjectPath: path.isAbsolute(bound.projectPath)
+                    ? bound.projectPath : path.resolve(process.cwd(), bound.projectPath) };
+        }
         // 话题会话创建时写入创建者和 replyContext（threadId 路由）；主会话不写（避免群聊覆盖）
         const metadata = message.threadId
             ? {
@@ -5245,7 +5751,7 @@ export class ResponseEngine {
                 // valid mapped owner/admin to role=none at the execution boundary.
                 if (resolvedIdentity)
                     bound.identity = resolvedIdentity;
-                if (bound.threadId) {
+                if (bound.threadId || bound.metadata?.diagnostic) {
                     const absoluteProjectPath = path.isAbsolute(bound.projectPath)
                         ? bound.projectPath : path.resolve(process.cwd(), bound.projectPath);
                     return { session: bound, absoluteProjectPath };
@@ -5271,7 +5777,7 @@ export class ResponseEngine {
                 logger.warn(`[ResponseEngine] Bound session ${boundSessionId} not found, falling back to latest`);
             }
         }
-        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, message.topicName, message.peerId, message.chatType, resolvedBaseagent, message.selfAID, message.channelType, message.peerType, resolvedIdentity, message.lable);
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, message.topicName, message.peerId, message.chatType, resolvedBaseagent, message.selfAID, message.channelType, message.peerType, resolvedIdentity, message.label ?? message.lable, message.topicStatus);
         this.ensureSessionBaseagent(session, resolvedBaseagent);
         // 群名解析：群会话首次取群显示名（group.get），缓存到 metadata，供信封渲染。
         // 渠道私有方法 getGroupName 自带进程缓存 + 容错；取不到不阻塞（groupName 保持空，模板回退 groupId）。
@@ -5398,16 +5904,14 @@ export class ResponseEngine {
                     event = normalizeCompleteAgentEvent(event);
                 }
                 if (event.type === 'tool_result' && event.isError) {
-                    const classificationMissing = !normalizeToolErrorCode(event.errorCode)
-                        && event.decisionSource !== 'policy'
-                        && event.decisionSource !== 'approval';
-                    const errorCode = classifyToolErrorCode({
-                        errorCode: event.errorCode,
-                        decisionSource: event.decisionSource,
-                    });
-                    if (event.errorCode !== errorCode) {
-                        event = { ...event, errorCode, ...(classificationMissing ? { classificationMissing: true } : {}) };
-                    }
+                    const classification = normalizeToolErrorClassification(event);
+                    event = {
+                        ...event,
+                        errorCode: classification.errorCode,
+                        errorDetailCode: classification.errorDetailCode,
+                        classificationMissing: classification.classificationMissing || event.classificationMissing,
+                        classificationConflict: classification.classificationConflict || event.classificationConflict,
+                    };
                 }
                 // 每收到事件重置空闲超时
                 const toolName = event.type === 'tool_use' ? event.name : undefined;
@@ -5705,7 +6209,7 @@ export class ResponseEngine {
                             this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: visibleText, isFinal: false });
                         }
                         if (visibleText && !shouldSuppress()) {
-                            await renderer.addText(visibleText, event.outputTokens, event.turn, event.assistantUuid);
+                            await renderer.addText(visibleText, event.outputTokens, event.turn, event.assistantUuid, event.phase);
                             hasProjectedCurrentReplyText = true;
                         }
                     }
@@ -5785,7 +6289,7 @@ export class ResponseEngine {
                         if (!shouldSuppress()) {
                             if (event.callId)
                                 toolDescByCallId.set(event.callId, desc);
-                            renderer.addToolCall(event.name, event.input, event.callId, desc, event.turn, event.outputTokens);
+                            renderer.addToolCall(event.name, event.input, event.callId, desc, event.turn, event.outputTokens, event.assistantUuid);
                         }
                         if (event.callId && isCtlQueueReadCommand(event.name, event.input || {})) {
                             ctlQueueReadCallIds.add(event.callId);
@@ -5796,6 +6300,8 @@ export class ResponseEngine {
                             modeHooks.mode.onToolUse({
                                 session,
                                 state: modeHooks.state,
+                                sessionState: modeHooks.sessionState,
+                                turn: turnLease,
                                 toolName: event.name,
                                 toolInput: event.input || {},
                                 injectToModel: (text) => { agent.injectUserMessage?.(session.id, text); },
@@ -5844,14 +6350,12 @@ export class ResponseEngine {
                             toolName: event.name,
                             isError: event.isError,
                             ...(event.isError ? {
-                                errorCode: classifyToolErrorCode({
-                                    errorCode: event.errorCode,
-                                    decisionSource: event.decisionSource,
-                                }),
-                                ...((event.classificationMissing || (!normalizeToolErrorCode(event.errorCode)
-                                    && event.decisionSource !== 'policy'
-                                    && event.decisionSource !== 'approval')) ? { classificationMissing: true } : {}),
+                                errorCode: event.errorCode,
+                                ...(event.errorDetailCode ? { errorDetailCode: event.errorDetailCode } : {}),
+                                ...(event.classificationMissing ? { classificationMissing: true } : {}),
+                                ...(event.classificationConflict ? { classificationConflict: true } : {}),
                             } : {}),
+                            ...(event.exitCode !== undefined ? { exitCode: event.exitCode } : {}),
                             ...(event.callId ? { callId: event.callId } : {}),
                             ...(event.correlationId || event.callId ? { correlationId: event.correlationId ?? event.callId } : {}),
                             ...(event.requestId ? { requestId: event.requestId } : {}),
@@ -5907,6 +6411,8 @@ export class ResponseEngine {
                             await modeHooks.mode.onToolResult({
                                 session,
                                 state: modeHooks.state,
+                                sessionState: modeHooks.sessionState,
+                                turn: turnLease,
                                 toolName: original.name,
                                 toolInput: original.input,
                                 result: event.result,
@@ -5941,10 +6447,10 @@ export class ResponseEngine {
                             let errorMsg = event.error || (typeof event.result === 'string' ? event.result : JSON.stringify(event.result)) || '\u6267\u884c\u5931\u8d25';
                             // 移除 XML 风格的错误标签
                             errorMsg = errorMsg.replace(/<tool_use_error>(.*?)<\/tool_use_error>/gs, '$1');
-                            renderer.addToolResult(event.name || '\u5de5\u5177', false, undefined, errorMsg, event.callId, event.durationMs, cachedDesc, event);
+                            renderer.addToolResult(event.name || '\u5de5\u5177', false, undefined, errorMsg, event.callId, event.durationMs, cachedDesc, event, event.assistantUuid);
                         }
                         else if (!event.isError && !shouldSuppress()) {
-                            renderer.addToolResult(event.name || '\u5de5\u5177', true, event.result, undefined, event.callId, event.durationMs, cachedDesc);
+                            renderer.addToolResult(event.name || '\u5de5\u5177', true, event.result, undefined, event.callId, event.durationMs, cachedDesc, undefined, event.assistantUuid);
                         }
                     }
                     // 非终态运行时告警走 status notify，不进入 activity/thought 历史。