evolcore 0.0.35 → 0.0.36

package/dist/core/message/aun-request-registry.js

@@ -0,0 +1,226 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { resolvePaths } from '../../paths.js';
+import { appendJsonlDurable } from '../session/session-fs-store.js';
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+const MAX_TIMER_MS = 2_147_483_647;
+/** AUN message.send accepts volatile TTL values from 1 through 3600 seconds. */
+export const MAX_AUN_VOLATILE_TTL_SECONDS = 3_600;
+export function requestTtlSeconds(timeoutMs) {
+    const value = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error('request timeout must be a positive number');
+    }
+    const ttl = Math.ceil(value / 1_000);
+    if (ttl > MAX_AUN_VOLATILE_TTL_SECONDS) {
+        throw new Error(`request timeout cannot exceed ${MAX_AUN_VOLATILE_TTL_SECONDS}s for volatile AUN messages`);
+    }
+    return Math.max(1, ttl);
+}
+function requestFile(selfAid) {
+    return path.join(resolvePaths().dataDir, 'aun-requests', `${encodeURIComponent(selfAid)}.jsonl`);
+}
+function randomRequestId() {
+    return `req_${Date.now().toString(36)}_${crypto.randomBytes(8).toString('hex')}`;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeTimeoutMs(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return DEFAULT_REQUEST_TIMEOUT_MS;
+    return Math.min(MAX_TIMER_MS, Math.max(1, value));
+}
+export class AunRequestRegistry {
+    records = new Map();
+    waiters = new Map();
+    loaded = new Set();
+    key(selfAid, requestId) {
+        return `${selfAid}\0${requestId}`;
+    }
+    ensureLoaded(selfAid) {
+        if (this.loaded.has(selfAid))
+            return;
+        this.loaded.add(selfAid);
+        const file = requestFile(selfAid);
+        try {
+            const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event?.event !== 'upsert' || !event.record?.requestId)
+                        continue;
+                    const recovered = event.record.state === 'created' || event.record.state === 'sending'
+                        ? { ...event.record, state: 'unknown', updatedAt: Date.now() }
+                        : event.record;
+                    this.records.set(this.key(selfAid, recovered.requestId), recovered);
+                }
+                catch { /* ignore an incomplete/corrupt historical line */ }
+            }
+            for (const record of this.recordsFor(selfAid)) {
+                for (const alias of record.correlationKeys)
+                    this.records.set(this.key(selfAid, alias), record);
+            }
+        }
+        catch { /* first use */ }
+    }
+    recordsFor(selfAid) {
+        const seen = new Set();
+        for (const record of this.records.values())
+            if (record.selfAid === selfAid)
+                seen.add(record);
+        return [...seen];
+    }
+    persist(record) {
+        const file = requestFile(record.selfAid);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        appendJsonlDurable(file, { event: 'upsert', record });
+        this.records.set(this.key(record.selfAid, record.requestId), record);
+        for (const alias of record.correlationKeys)
+            this.records.set(this.key(record.selfAid, alias), record);
+    }
+    notify(record) {
+        if (!['completed', 'failed', 'unknown', 'pending'].includes(record.state))
+            return;
+        const waiters = this.waiters.get(this.key(record.selfAid, record.requestId));
+        if (!waiters)
+            return;
+        for (const waiter of waiters)
+            waiter(record);
+        this.waiters.delete(this.key(record.selfAid, record.requestId));
+    }
+    prepare(params) {
+        this.ensureLoaded(params.selfAid);
+        const requestId = stringValue(params.payload.request_id);
+        const callId = stringValue(params.payload.call_id);
+        const chosen = requestId || callId || randomRequestId();
+        const keys = [...new Set([chosen, requestId, callId].filter((value) => !!value))];
+        if (keys.some(key => this.records.has(this.key(params.selfAid, key)))) {
+            throw Object.assign(new Error('Request correlation ID is already registered'), { code: 'REQUEST_ID_CONFLICT' });
+        }
+        const correlationKind = requestId || !callId ? 'request_id' : 'call_id';
+        const now = Date.now();
+        const timeoutMs = normalizeTimeoutMs(params.timeoutMs);
+        const record = {
+            selfAid: params.selfAid,
+            targetAid: params.targetAid,
+            requestId: chosen,
+            correlationKind,
+            correlationKeys: keys,
+            ...(params.origin ? { origin: { ...params.origin } } : {}),
+            state: 'created',
+            createdAt: now,
+            updatedAt: now,
+            deadlineAt: now + timeoutMs,
+        };
+        const payload = { ...params.payload };
+        if (!requestId && !callId)
+            payload.request_id = chosen;
+        this.persist(record);
+        return { requestId: chosen, payload, record };
+    }
+    markSending(selfAid, requestId) {
+        return this.update(selfAid, requestId, { state: 'sending' });
+    }
+    markTransportAccepted(selfAid, requestId, messageId, status) {
+        const current = this.get(selfAid, requestId);
+        if (!current)
+            return undefined;
+        const state = current.state === 'created' || current.state === 'sending' ? 'sent' : current.state;
+        return this.update(selfAid, requestId, { state, outboundMessageId: messageId, transportStatus: status });
+    }
+    markFailed(selfAid, requestId, error) {
+        const current = this.get(selfAid, requestId);
+        if (current?.state === 'completed' || current?.state === 'failed')
+            return current;
+        return this.update(selfAid, requestId, { state: 'failed', error });
+    }
+    update(selfAid, requestId, patch) {
+        this.ensureLoaded(selfAid);
+        const existing = this.records.get(this.key(selfAid, requestId));
+        if (!existing)
+            return undefined;
+        const record = { ...existing, ...patch, updatedAt: Date.now() };
+        this.persist(record);
+        this.notify(record);
+        return record;
+    }
+    updateWithoutNotify(selfAid, requestId, patch) {
+        this.ensureLoaded(selfAid);
+        const existing = this.records.get(this.key(selfAid, requestId));
+        if (!existing)
+            return undefined;
+        const record = { ...existing, ...patch, updatedAt: Date.now() };
+        this.persist(record);
+        return record;
+    }
+    isIntermediateResponse(payload) {
+        // A generic application ACK means that the request was accepted. A later
+        // response carrying the same correlation key remains eligible to finish
+        // the wait; the transport does not interpret any business message type.
+        return payload.role === 'ack';
+    }
+    resolveIncoming(params) {
+        if (!params.payload || typeof params.payload !== 'object' || Array.isArray(params.payload))
+            return undefined;
+        this.ensureLoaded(params.selfAid);
+        const payload = params.payload;
+        const keys = [stringValue(payload.request_id), stringValue(payload.call_id)].filter((value) => !!value);
+        for (const key of keys) {
+            const record = this.records.get(this.key(params.selfAid, key));
+            if (!record || record.targetAid !== params.fromAid || ['failed', 'completed'].includes(record.state))
+                continue;
+            if (this.isIntermediateResponse(payload)) {
+                return this.updateWithoutNotify(params.selfAid, record.requestId, {
+                    ackMessageId: params.messageId,
+                    ackPayload: payload,
+                });
+            }
+            const updated = this.update(params.selfAid, record.requestId, {
+                state: 'completed',
+                responseMessageId: params.messageId,
+                responsePayload: payload,
+            });
+            return updated;
+        }
+        return undefined;
+    }
+    get(selfAid, requestId) {
+        this.ensureLoaded(selfAid);
+        const record = this.records.get(this.key(selfAid, requestId));
+        if (record && record.state === 'sent' && record.deadlineAt !== undefined && record.deadlineAt <= Date.now()) {
+            return this.update(selfAid, record.requestId, { state: 'pending' });
+        }
+        return record;
+    }
+    async wait(selfAid, requestId, timeoutMs) {
+        const current = this.get(selfAid, requestId);
+        if (!current || ['completed', 'failed', 'unknown'].includes(current.state))
+            return current;
+        const normalizedTimeoutMs = normalizeTimeoutMs(timeoutMs);
+        const waitMs = Math.max(0, Math.min(normalizedTimeoutMs, current.deadlineAt ? current.deadlineAt - Date.now() : normalizedTimeoutMs));
+        if (waitMs === 0)
+            return this.update(selfAid, requestId, { state: 'pending' });
+        return new Promise(resolve => {
+            const key = this.key(selfAid, requestId);
+            const callback = (record) => { clearTimeout(timer); resolve(record); };
+            const waiters = this.waiters.get(key) ?? new Set();
+            waiters.add(callback);
+            this.waiters.set(key, waiters);
+            const timer = setTimeout(() => {
+                if (!this.waiters.get(key)?.delete(callback))
+                    return;
+                if (this.waiters.get(key)?.size === 0)
+                    this.waiters.delete(key);
+                resolve(this.update(selfAid, requestId, { state: 'pending' }));
+            }, waitMs);
+        });
+    }
+}
+let defaultRegistry;
+export function getAunRequestRegistry() {
+    return defaultRegistry ??= new AunRequestRegistry();
+}

package/dist/core/message/create-status.js

@@ -1,5 +1,7 @@
 import fs from 'fs';
 import path from 'path';
+import { randomUUID } from 'node:crypto';
+import { creationOwnershipBinding } from '../ownership/owner-resolver.js';
 const FILE = 'create-status.json';
 export function readCreateStatus(agentDir) {
     try {
@@ -22,12 +24,13 @@ export function removeCreateStatus(agentDir) {
 export class CreateStatusWriter {
     agentDir;
     status;
-    constructor(agentDir, aid) {
+    creationId = randomUUID();
+    constructor(agentDir, aid, context) {
         this.agentDir = agentDir;
         const now = Date.now();
-        this.status = { aid, status: 'in_progress', currentPhase: null, steps: [], error: null, startedAt: now, updatedAt: now };
+        this.status = { aid, creationId: this.creationId, ...context, status: 'in_progress', currentPhase: null, steps: [], error: null, startedAt: now, updatedAt: now };
         fs.mkdirSync(agentDir, { recursive: true });
-        this.flush();
+        this.flush(true);
     }
     begin(phase) {
         this.status.currentPhase = phase;
@@ -36,6 +39,28 @@ export class CreateStatusWriter {
     }
     done(phase, detail) { this.mark(phase, 'done', detail); }
     warn(phase, detail) { this.mark(phase, 'warn', detail); }
+    /** Immutable correlation; a later CLI bind/transfer must not replace it. */
+    setOwnershipBinding(binding) {
+        const expected = creationOwnershipBinding({
+            operation: binding.operation, operation_id: binding.operationId,
+            sub_aid: binding.subjectAid, owner_aid: binding.ownerAid,
+            base_relation_version: binding.baseRelationVersion, target_relation_version: binding.targetRelationVersion,
+            status: 'pending',
+        }, this.status.aid, this.status.ownerAid ?? '');
+        if (!this.status.requesterAid || binding.source !== 'agent_create' || !expected) {
+            throw new Error('Creation Ownership binding does not match the creation request');
+        }
+        if (this.status.ownershipBinding) {
+            if (this.status.ownershipBinding.operationId !== binding.operationId) {
+                throw new Error('Creation Ownership binding is already recorded');
+            }
+            return;
+        }
+        if (this.status.status !== 'in_progress')
+            throw new Error('Agent creation has already finished');
+        this.status.ownershipBinding = expected;
+        this.flush();
+    }
     finishReady() { this.status.status = 'ready'; this.status.currentPhase = null; this.flush(); }
     finishFailed(phase, error) {
         this.mark(phase, 'failed', error);
@@ -57,7 +82,11 @@ export class CreateStatusWriter {
         }
         this.flush();
     }
-    flush() {
+    flush(initial = false) {
+        // A failed worker or a deleted Agent must not overwrite a newer creation.
+        if (!initial && readCreateStatus(this.agentDir)?.creationId !== this.creationId) {
+            throw new Error('Agent creation record was removed or replaced');
+        }
         this.status.updatedAt = Date.now();
         const file = path.join(this.agentDir, FILE);
         const tmp = `${file}.tmp`;

package/dist/core/message/message-bridge.js

@@ -1,4 +1,5 @@
 import { loadAgent } from '../../config-store.js';
+import { subscribeUpgradeJob } from '../../utils/upgrade-jobs.js';
 import { initializationBlocksTasks } from '../../cli/agent-create.js';
 import { createHash, randomBytes } from 'crypto';
 import fs from 'fs';
@@ -17,6 +18,8 @@ import { resolveContactView, resolvePeerDisplayLabel, resolvePrincipal } from '.
 import { findContactRequestNote, expirePendingContactRequests, reviewContactRequest, submitContactRequest, contactRequestSubmissionProtocolResult, queryOwnContactRequestStatus, } from '../../config/contact-request-service.js';
 import { isValidAid } from '../../aun/aid/validation.js';
 import { PeerIdentityCache, formatPeerKey } from '../relation/peer-identity.js';
+import { ownerResolver } from '../ownership/owner-resolver.js';
+import { isTopicSession, sessionLocalTopicId } from '../thread/topic-id.js';
 import { resolveEffective } from '../../config/config-manager.js';
 import { createDecisionInferenceProvider } from '../inference/text-inference.js';
 import { AutoMentionGate } from './auto-mention-gate.js';
@@ -116,8 +119,8 @@ export class MessageBridge {
                 self: item.selfAid,
                 peerKey: formatPeerKey('aun', item.groupId),
             }, { cache: true, expand: true });
-            const model = config.decision_model?.model?.trim();
-            const provider = createDecisionInferenceProvider(config.decision_model);
+            const model = config.Services?.decision ? config.Services.decision.model?.trim() : config.decision_model?.model?.trim();
+            const provider = createDecisionInferenceProvider(config.decision_model, config.Services);
             return model && provider ? { model, provider } : undefined;
         },
         resolveResources: async (item) => {
@@ -245,11 +248,11 @@ export class MessageBridge {
         this.groupInviteReviewService?.attach(binding);
     }
     /**
-     * AUN supplies an authenticated sender AID, while the IM-side code proves
-     * possession of the external account. This command only creates that
-     * identity mapping; it never changes a role assignment.
+     * Handle AUN's two slash-bind forms: bare `/bind` requests protocol
+     * ownership from the first configured Owner; `/bind <channel>` creates an
+     * external-channel contact mapping.
      */
-    handleAunSelfServiceContactBind(input) {
+    async handleAunBindCommand(input) {
         const match = /^\s*\/bind(?:\s+(.+?))?\s*$/i.exec(input.content);
         if (!match)
             return { handled: false };
@@ -270,7 +273,42 @@ export class MessageBridge {
             };
         }
         const args = String(match[1] || '').trim().split(/\s+/).filter(Boolean);
-        if (args.length < 1 || args.length > 2) {
+        if (args.length === 0) {
+            const configuredOwner = ownerResolver.configuredOwnerList(selfAid)[0];
+            if (configuredOwner !== actorId) {
+                return { handled: true, status: 'not-first-owner', reply: '仅 Agent 配置中的首个 Owner 可在 AUN 私聊发送 /bind 发起 ownership 绑定。' };
+            }
+            try {
+                const state = await ownerResolver.bind(selfAid, actorId);
+                const alreadyBound = state.consensusStatus === 'consensus' && state.ownerAid === actorId;
+                if (!alreadyBound && state.task && ['rejected', 'stopped', 'error'].includes(state.task.status)) {
+                    return {
+                        handled: true,
+                        status: 'ownership-failed',
+                        reply: `协议 Owner 绑定未完成：${state.task.reason ?? state.task.code ?? state.task.status}`,
+                    };
+                }
+                return {
+                    handled: true,
+                    status: alreadyBound ? 'already-bound' : 'ownership-submitted',
+                    reply: alreadyBound
+                        ? '协议 Owner 已绑定，无需重复操作。'
+                        : state.task?.status === 'completed'
+                            ? '绑定任务已完成，等待协议共识核验。'
+                            : `已向 ${actorId} 发起 ownership 绑定邀约，请在 Evol 中确认。`,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.warn(`[MessageBridge] AUN ownership bind failed: subject=${selfAid} owner=${actorId} error=${message}`);
+                return {
+                    handled: true,
+                    status: 'ownership-failed',
+                    reply: `协议 Owner 绑定未完成：${message}`,
+                };
+            }
+        }
+        if (args.length > 2) {
             return { handled: true, status: 'format', reply: this.aunSelfServiceBindUsage() };
         }
         const channelType = args[0].toLowerCase();
@@ -359,7 +397,7 @@ export class MessageBridge {
         }
     }
     aunSelfServiceBindUsage() {
-        return `用法：/bind <渠道> [实例名]。支持渠道：${SELF_SERVICE_CONTACT_BIND_TYPES.join('、')}。`;
+        return `用法：/bind（首个配置 Owner 发起 ownership 绑定）；/bind <渠道> [实例名]（联系人绑定）。支持渠道：${SELF_SERVICE_CONTACT_BIND_TYPES.join('、')}。`;
     }
     aunSelfServiceBindInstances(channelType, instances) {
         const names = instances.map(instance => String(instance.name || '').trim()).filter(Boolean);
@@ -396,7 +434,7 @@ export class MessageBridge {
             return true;
         }
         if (context.channelType === 'aun') {
-            const aunSelfServiceBind = this.handleAunSelfServiceContactBind({
+            const aunSelfServiceBind = await this.handleAunBindCommand({
                 selfAid: context.selfAid,
                 actorId: context.actorId,
                 chatType: context.chatType,
@@ -404,7 +442,7 @@ export class MessageBridge {
                 owningAgent,
             });
             if (aunSelfServiceBind.handled) {
-                logger.info(`[MessageBridge] AUN self-service contact bind handled before admission: channel=${context.channelKey} actor=${context.actorId || '<none>'} status=${aunSelfServiceBind.status}`);
+                logger.info(`[MessageBridge] AUN bind command handled before admission: channel=${context.channelKey} actor=${context.actorId || '<none>'} status=${aunSelfServiceBind.status}`);
                 if (aunSelfServiceBind.reply) {
                     await this.sendAdmissionControlReply(context, msg, sendReply, aunSelfServiceBind.reply);
                 }
@@ -1414,7 +1452,7 @@ export class MessageBridge {
                     releaseAdmission = await this.acquireAdmission(admissionRoute);
                 const hadMainSession = msg.threadId ? true : this.sessionManager.hasMainSession(channelName, msg.channelId, msg.channelType || effectiveChannelType, msg.selfAID || selfAid);
                 let session = diagnosticSession ?? await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, this.extractTopicName(msg), msg.peerId, chatType, owningAgent?.baseagent, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType, identity, readTopicLabel(msg) ?? readTopicLabel(msg.replyContext?.metadata), readTopicStatus(msg) ?? readTopicStatus(msg.replyContext?.metadata));
-                if (session.threadId && typeof this.messageQueue.reserveSessionIngress === 'function') {
+                if (isTopicSession(session) && typeof this.messageQueue.reserveSessionIngress === 'function') {
                     releaseSessionIngress = this.messageQueue.reserveSessionIngress(session.id);
                 }
                 const replyToMessageId = typeof msg.replyContext?.metadata?.refMessageId === 'string'
@@ -1549,7 +1587,8 @@ export class MessageBridge {
                             from: msg.peerId || 'unknown',
                             to: msg.selfAID || 'self',
                             sessionId: session.id,
-                            threadId: session.threadId || '',
+                            // 消息日志用本端身份（含主话题规范 id），与出站日志的 localTopicId 一致。
+                            threadId: sessionLocalTopicId(session) ?? '',
                             chatType,
                             groupId: msg.groupId ?? null,
                             msgId: msg.messageId ?? null,
@@ -1608,7 +1647,7 @@ export class MessageBridge {
                         const member = item.value;
                         appendMessageLog(inboundEntry.chatDir, buildInboundEntry({
                             from: item.sender, to: selfAid || '', sessionId: session.id,
-                            threadId: session.threadId || '', chatType: 'group', groupId: msg.groupId,
+                            threadId: sessionLocalTopicId(session) ?? '', chatType: 'group', groupId: msg.groupId,
                             msgId: item.messageId, content: member.messageLogContent ?? item.content,
                             permMode: item.role, timestamp: item.receivedAt,
                             receivedAt: member.receivedAt, gatewaySeq: member.gatewaySeq,
@@ -2047,6 +2086,16 @@ export class MessageBridge {
         try {
             await adapter.send(envelope, { kind: 'custom', channelType: channel, payload: timedResponse });
             logMenuRequestCompleted(request, timedResponse, flowContext, { delivery: 'sent' });
+            const upgradeData = 'data' in response ? response.data : undefined;
+            if (request.type === 'menu.action' && request.action === 'upgrade' && (request.name === 'system' || request.cmd === '/system') && upgradeData?.jobId) {
+                const jobId = upgradeData.jobId;
+                subscribeUpgradeJob(jobId, async (event) => {
+                    const permission = await this.cmdHandler.execMenuAction('/system', 'upgrade', { mode: 'status', jobId }, channel, msg.channelId, msg.peerId, undefined, msg.replyContext?.delivery?.chatType, undefined, false, undefined, 'menu', msg.replyContext);
+                    if ('error' in permission)
+                        throw new Error('Upgrade event authorization expired');
+                    await adapter.send(envelope, { kind: 'custom', channelType: channel, payload: event });
+                }, [channel, msg.channelId, msg.peerId, msg.peerDeviceId || '', jobId].join('\u001f'));
+            }
         }
         catch (error) {
             logMenuRequestCompleted(request, timedResponse, flowContext, {

package/dist/core/message/message-log.js

@@ -21,7 +21,6 @@ const TRANSIENT_PROTOCOL_TYPES = new Set([
     'handoff_state',
     'handoff_result',
     'topic-created', // 话题创建系统消息，不进大模型上下文
-    'topic-renamed', // 话题改名通知，由 channel 层直接消费，不进大模型上下文
 ]);
 const KNOWN_AUN_PAYLOAD_TYPES = new Set([
     'text',

package/dist/core/message/message-queue.js

@@ -5,6 +5,7 @@ import { LogicalQueueBridge } from './logical-queue-bridge.js';
 import { normalizeCausation } from '../causation/context.js';
 import { KeyedFairMutex } from '../handoff/mutex.js';
 import { ExecutionTimeoutError, OrphanedTargetSessionError, isExecutionFailure } from '../../utils/error-utils.js';
+import { isTopicThreadId } from '../thread/topic-id.js';
 const DEFAULT_AGENT_NAME = '<unknown>';
 const RESTART_RESUME_CONTENT = 'evolcore 服务已重启，请继续之前未完成的任务。';
 export class MessageQueue {
@@ -462,7 +463,9 @@ export class MessageQueue {
             return false;
         if (scope.groupId !== undefined && message.groupId !== scope.groupId)
             return false;
-        if (scope.threadId !== undefined && (message.threadId || '') !== (scope.threadId || ''))
+        // 主会话的三种形态（'' / 'main' / 规范 id）视为同一个：只比较话题 id。
+        if (scope.threadId !== undefined
+            && (isTopicThreadId(message.threadId) ? message.threadId : '') !== (isTopicThreadId(scope.threadId) ? scope.threadId : ''))
             return false;
         return true;
     }

package/dist/core/message/message-utils.js

@@ -3,6 +3,7 @@
  *
  * 从 message-processor.ts 提取的独立工具函数，供 ResponseEngine 和其他模块使用。
  */
+import { sessionLocalTopicId, sessionTopicThreadId } from '../thread/topic-id.js';
 import { renderCommandCardAsText, renderActionAsText } from '../interaction-router.js';
 /** A legacy adapter resolved its send call without providing a structured receipt. */
 export const LEGACY_INTERACTION_ACCEPTED = 'legacy-accepted';
@@ -99,9 +100,15 @@ export function deliveryTargetFromSession(session) {
 }
 /** Preserve channel-specific reply fields while filling the session route. */
 export function replyContextFromSession(session, context) {
+    const topicThreadId = sessionTopicThreadId(session);
+    const localTopicId = sessionLocalTopicId(session);
     return {
         ...(session.metadata?.replyContext ?? {}),
-        ...(session.threadId ? { threadId: session.threadId } : {}),
+        // 线上只带话题 id：主话题 id 是"本端+对端"拼出来的身份，发出去会让对端
+        // 凭空建一个叫 `main:…` 的话题。主话题的线上形态就是"不带话题字段"。
+        ...(topicThreadId ? { threadId: topicThreadId } : {}),
+        // 本地日志要的是完整身份（含主话题规范 id），单独用不线上的字段携带。
+        ...(localTopicId ? { localTopicId } : {}),
         ...(context ?? {}),
         // Session chatType/groupId is the persisted routing authority. The nested
         // reply context can outlive a route correction, so only an explicit

package/dist/core/message/peer-mode.js

@@ -1,6 +1,7 @@
 import { loadSchema } from '../../config/schema-registry.js';
 import { resolveEffective } from '../../config/config-manager.js';
 import { resolveRuntimeStringField } from '../role/runtime-policy.js';
+import { isManagementRole } from '../../config/builtin-roles.js';
 /** Resolve the effective chat mode from the ConfigManager layering context. */
 export function resolveChatMode(params) {
     let configured;
@@ -20,6 +21,11 @@ export function resolveChatMode(params) {
     if (kind === 'agent')
         return 'proactive';
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
+    // 人类私聊的角色门槛（硬约束）：interactive 是「输出即回复」的高信任模式，
+    // 只有 owner/admin 才走下面的分层配置；其余角色（含未分配/未知）直接 proactive，
+    // 关系级或 agent 级把 chatmode.private 写成 interactive 都不生效。
+    if (isPrivateChatmodeRoleLocked(field, params.role))
+        return 'proactive';
     const decision = resolveRuntimeStringField({
         selfAid: params.self,
         role: params.role,
@@ -32,16 +38,18 @@ export function resolveChatMode(params) {
         : chatmodeFactoryDefaults()[field];
 }
 /**
- * 出站发送路径（`ec msg send` / daemon 私聊发送）用的最小判定。
- *
- * 这两条路径只有对端身份、拿不到角色，因此不能复用 `resolveChatMode` 的
- * 分层配置。口径与 `resolveChatMode` 的硬约束保持一致：
+ * 人类私聊（chatmode.private）是否被角色锁定为 proactive。
+ * owner/admin 之外的任何角色（含 null/'none'/未知）都锁定。
+ */
+export function isPrivateChatmodeRoleLocked(field, role) {
+    return field === 'private' && !isManagementRole(role);
+}
+/**
+ * 出站发送路径（`ec msg send` / daemon 私聊发送）用的判定，与入站共用
+ * `resolveChatMode` 的硬约束：
  *   - 非人类对端（isMachine）→ proactive
- *   - 人类但角色未知 → proactive（保守侧）
- *   - 人类且 owner/admin → interactive
- *
- * 角色未知时不能假设高信任：interactive 表示"输出即回复"的同步交互，
- * 只应给已确认的管理者。
+ *   - 人类且非 owner/admin（含角色未知）→ proactive
+ *   - 人类且 owner/admin → 分层配置（未配置时取出厂默认）
  */
 export function chatmodeForPeerIdentity(identity, role) {
     if (identity.isMachine)