evolcore 0.0.32 → 0.0.34

package/dist/core/thread/command-parser.js

@@ -0,0 +1,125 @@
+import { isValidAid } from '../../aun/aid/validation.js';
+import { normalizeThreadPeer } from './thread-service.js';
+const STATUSES = new Set(['pending', 'in_progress', 'completed', 'archived']);
+const COMMON_OPTIONS = ['--self', '--format', '--json'];
+const VALUE_OPTIONS = new Set(['--self', '--agent', '--format', '--name', '--label', '--status', '--sort', '--page', '--limit', '--before', '--after', '--if-rev']);
+const OPTIONS = {
+    peers: [], list: ['--status', '--label', '--unlabeled', '--sort', '--page', '--limit'],
+    show: [], history: ['--limit', '--before', '--after'],
+    create: ['--name', '--label', '--status', '--group'], rename: [], label: ['--clear'], status: [],
+    delete: [], 'rebuild-index': ['--check', '--agent'], 'check-index': ['--agent'],
+    'summary-show': [], 'summary-set': ['--name', '--if-rev'], 'summary-log': [], 'summary-clear': [],
+};
+export function resolveThreadCommandArgv(argv) {
+    if (argv[0] !== 'thread' || argv.some(value => typeof value !== 'string' || value.includes('\0')))
+        throw new Error('Invalid thread argv');
+    const command = argv[1] === 'summary' ? `summary-${argv[2]}` : argv[1];
+    if (!Object.hasOwn(OPTIONS, command))
+        throw new Error('Unknown thread command');
+    const allowed = new Set([...COMMON_OPTIONS, ...OPTIONS[command]]);
+    const options = new Map();
+    const positional = [];
+    for (let index = command.startsWith('summary-') ? 3 : 2; index < argv.length; index++) {
+        const value = argv[index];
+        if (!value.startsWith('--')) {
+            positional.push(value);
+            continue;
+        }
+        if (!allowed.has(value) || options.has(value))
+            throw new Error(`Invalid or duplicate option: ${value}`);
+        if (!VALUE_OPTIONS.has(value)) {
+            options.set(value, true);
+            continue;
+        }
+        const argument = argv[++index];
+        if (argument === undefined || argument.startsWith('--'))
+            throw new Error(`Missing value: ${value}`);
+        options.set(value, argument);
+    }
+    const text = (flag) => options.get(flag);
+    const number = (flag, minimum = 0) => {
+        if (!options.has(flag))
+            return undefined;
+        const value = Number(text(flag));
+        if (!Number.isSafeInteger(value) || value < minimum)
+            throw new Error(`Invalid number: ${flag}`);
+        return value;
+    };
+    const selfAidValue = text('--self');
+    const agentAidValue = text('--agent');
+    const selfAid = (agentAidValue ?? selfAidValue)?.replace(/^@/, '');
+    if (selfAidValue !== undefined && agentAidValue !== undefined
+        && selfAidValue.replace(/^@/, '') !== agentAidValue.replace(/^@/, '')) {
+        throw new Error('--self and --agent must target the same Agent');
+    }
+    if (selfAid !== undefined && !isValidAid(selfAid))
+        throw new Error('Invalid self AID');
+    if (text('--format') !== undefined && text('--format') !== 'json')
+        throw new Error('Only JSON format is supported');
+    const status = text('--status') ?? (command === 'status' ? positional[1] : undefined);
+    if (status !== undefined && !STATUSES.has(status))
+        throw new Error('Invalid topic status');
+    const sort = text('--sort');
+    if (sort !== undefined && sort !== 'recent' && sort !== 'created')
+        throw new Error('Invalid sort order');
+    const maximum = ['peers', 'rebuild-index', 'check-index'].includes(command) ? 0
+        : ['rename', 'status', 'label'].includes(command) ? 2 : command === 'summary-set' ? Infinity : 1;
+    const minimum = maximum === 0 ? 0 : ['rename', 'status', 'summary-set'].includes(command) ? 2 : 1;
+    if (positional.length < minimum || positional.length > maximum)
+        throw new Error('Invalid thread arguments');
+    const op = (command === 'peers' ? 'list-peers' : command);
+    const request = { type: 'thread.op', op, selfAid };
+    if (command === 'list' || command === 'create') {
+        request.peer = normalizeThreadPeer(positional[0]);
+        if (!request.peer)
+            throw new Error('Invalid peer');
+    }
+    else if (maximum !== 0) {
+        request.ref = positional[0];
+        if (request.ref !== 'current') {
+            const pieces = positional[0].split('/');
+            if (pieces.length > 2 || !pieces[0] || pieces[1] === '')
+                throw new Error('Invalid thread reference');
+            request.peer = normalizeThreadPeer(pieces[0]);
+            request.threadId = pieces[1];
+            if (!request.peer || request.threadId && !/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(request.threadId))
+                throw new Error('Invalid thread reference');
+        }
+    }
+    if (command === 'list')
+        Object.assign(request, {
+            status, label: text('--label'), unlabeled: options.has('--unlabeled'), sort,
+            page: number('--page', 1), limit: number('--limit', 1),
+        });
+    if (command === 'history')
+        Object.assign(request, { limit: number('--limit', 1), before: number('--before'), after: number('--after') });
+    if (command === 'create') {
+        if (!text('--name')?.trim())
+            throw new Error('Topic name is required');
+        Object.assign(request, { name: text('--name'), label: text('--label'), topicStatus: status, peerKind: options.has('--group') ? 'group' : 'private' });
+    }
+    if (command === 'rename') {
+        if (!positional[1].trim())
+            throw new Error('Topic name is required');
+        request.name = positional[1];
+    }
+    if (command === 'label') {
+        if (options.has('--clear') ? positional.length !== 1 : positional.length !== 2)
+            throw new Error('Specify a label or --clear');
+        request.label = options.has('--clear') ? null : positional[1];
+    }
+    if (command === 'status')
+        request.topicStatus = status;
+    if (command === 'rebuild-index')
+        request.dryRun = options.has('--check');
+    if (command === 'summary-set') {
+        if (!text('--name')?.trim())
+            throw new Error('Summary requires --name; use - to keep the current name');
+        request.name = text('--name');
+        request.content = positional.slice(1).join(' ');
+        if (!request.content.trim())
+            throw new Error('Summary content is required');
+        request.ifRev = number('--if-rev');
+    }
+    return request;
+}

package/dist/core/thread/index.js

@@ -0,0 +1 @@
+export { ThreadService, ThreadServiceError, normalizeThreadPeer } from './thread-service.js';

package/dist/core/thread/ipc-operation.js

@@ -0,0 +1,95 @@
+import { trustedExecutionIdentityInput } from '../auth/agent-delegation.js';
+import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
+import { isManagementRole } from '../../config/builtin-roles.js';
+import { parsePeerKey } from '../relation/peer-identity.js';
+import { resolveThreadCommandArgv } from './command-parser.js';
+import { executeThreadOperation } from './thread-operation.js';
+import { ThreadService } from './thread-service.js';
+export function createThreadOperationExecutor(dependencies) {
+    const threadService = new ThreadService(dependencies.sessionManager);
+    return async (incoming) => {
+        try {
+            if (!Array.isArray(incoming.argv))
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Thread operations require argv' };
+            const request = resolveThreadCommandArgv(incoming.argv);
+            const token = typeof incoming.delegationToken === 'string' ? incoming.delegationToken.trim() : '';
+            let currentPeer;
+            let relationOnly = false;
+            if (token) {
+                if (!incoming.sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'Caller sessionId is required' };
+                const delegation = dependencies.agentDelegationRegistry.validate(token, incoming.sessionId, incoming.delegationCommandHash);
+                if (!delegation.ok)
+                    return { ok: false, code: delegation.code, error: delegation.reason };
+                const session = await dependencies.sessionManager.getSessionById(incoming.sessionId);
+                if (!session || session.selfAID !== delegation.grant.selfAid)
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation does not match the caller session' };
+                if (request.selfAid && request.selfAid !== delegation.grant.selfAid)
+                    return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current Agent can be targeted' };
+                request.selfAid = delegation.grant.selfAid;
+                const peer = parsePeerKey(delegation.grant.peerKey);
+                currentPeer = peer.channelId;
+                const subject = buildAuthSubject({
+                    selfAid: request.selfAid, actorId: delegation.grant.actorId,
+                    channel: delegation.grant.channel, channelType: delegation.grant.channelType,
+                    channelId: currentPeer, conversationId: currentPeer, chatType: delegation.grant.chatType,
+                    permissionMode: delegation.grant.permissionMode, processOwners: dependencies.getProcessOwners(),
+                    ...trustedExecutionIdentityInput(delegation.grant),
+                });
+                relationOnly = subject.dataScope === 'relation';
+                const readOnly = ['list', 'list-peers', 'show', 'history', 'check-index', 'summary-show', 'summary-log'].includes(request.op);
+                const management = isManagementRole(subject.role) || subject.processRole === 'fullaccess-run';
+                if (delegation.grant.chatType === 'group' && !management) {
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Group thread operations require an administrator role' };
+                }
+                if (!readOnly && (!management || subject.permissionMode === 'readonly'))
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Thread changes require a writable administrator task' };
+                const globalOperation = ['list-peers', 'check-index', 'rebuild-index'].includes(request.op);
+                const decision = authorizeOperation({
+                    source: 'agent-tool', subject,
+                    intent: { operation: `ec.thread.${request.op}`, scope: globalOperation && !(relationOnly && request.op === 'list-peers') ? 'agent' : 'relation', source: 'agent-tool', args: { self: request.selfAid, peer: request.peer ?? currentPeer, peerKey: delegation.grant.peerKey } },
+                    auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
+                });
+                if (!decision.allow)
+                    return { ok: false, code: decision.code, error: decision.reason };
+                if (relationOnly && globalOperation && request.op !== 'list-peers')
+                    return { ok: false, code: 'SCOPE_MISMATCH', error: 'Index management requires Agent scope' };
+                if (request.ref === 'current') {
+                    const indexed = threadService.resolveCurrentThread(request.selfAid, session.id);
+                    request.peer = indexed?.peer ?? currentPeer;
+                    request.threadId = indexed?.threadId ?? session.threadId ?? undefined;
+                    request.sessionId = session.id;
+                }
+            }
+            else {
+                if (incoming.sessionId || incoming.delegationToken || incoming.localControl !== true)
+                    return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'Valid local control token is required' };
+                if (!request.selfAid)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'Host commands require --self' };
+                if (request.ref === 'current')
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'current requires a managed caller session' };
+            }
+            if (relationOnly && request.peer && request.peer !== currentPeer)
+                return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current relation can be targeted' };
+            if (request.op.startsWith('summary-') && !request.sessionId) {
+                const target = request.threadId
+                    ? await threadService.showThread({ selfAid: request.selfAid, peer: request.peer, threadId: request.threadId })
+                    : await threadService.showMainSession(request.selfAid, request.peer);
+                if (!target)
+                    return { ok: false, code: 'NOT_FOUND', error: 'Target session not found' };
+                request.sessionId = target.sessionId;
+            }
+            if (request.sessionId && !/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(request.sessionId))
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Invalid target sessionId' };
+            const response = await executeThreadOperation(request, threadService, dependencies.sendSystemMsg);
+            if (response.ok && request.op === 'delete' && request.threadId)
+                dependencies.onDeleted?.(request.selfAid, request.threadId);
+            if (response.ok && relationOnly && request.op === 'list-peers')
+                response.result = { peers: response.result.peers.filter(entry => entry.peer === currentPeer) };
+            return response;
+        }
+        catch (error) {
+            return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+}

package/dist/core/thread/thread-context-storage.js

@@ -0,0 +1,131 @@
+import fs from 'fs';
+import path from 'path';
+import { agentThreadInboxDir, agentThreadInboxPath, agentSessionsDir } from '../../paths.js';
+import { appendJsonl, readAllJsonlLines } from '../session/session-fs-store.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * Thread Context 收件箱（thread-inbox）。
+ *
+ * 跨话题发送成功后，发送方把「我从哪个话题跨到哪个话题发了什么」写进自己的
+ * inbox；目标会话下次被唤醒时读取一次、注入渲染、然后物理删除整个文件。
+ *
+ * 设计要点：
+ * - 无「已消费」标记 —— 注入即删除，文件为空即删除文件
+ * - 一个目标会话一个文件，多条记录追加（支持多方并发）
+ * - 读取时跳过损坏行，不因单行损坏丢失全部提醒
+ */
+export class ThreadContextStorage {
+    /** 追加一条 inbox 记录。 */
+    append(aid, entry) {
+        const filePath = agentThreadInboxPath(aid, entry.targetSessionId);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        appendJsonl(filePath, entry);
+    }
+    /** 读取某目标会话的全部 inbox 记录。文件不存在或损坏时返回空数组。 */
+    readAll(aid, targetSessionId) {
+        const filePath = agentThreadInboxPath(aid, targetSessionId);
+        if (!fs.existsSync(filePath))
+            return [];
+        // readAllJsonlLines 内部已跳过损坏行
+        return readAllJsonlLines(filePath).filter(entry => entry && typeof entry.messageId === 'string' && typeof entry.targetSessionId === 'string');
+    }
+    /**
+     * 删除 inbox 文件。注入完成后调用 —— 这是「注入一次」语义的落点。
+     * 文件不存在时静默返回。
+     */
+    deleteFile(aid, targetSessionId) {
+        const filePath = agentThreadInboxPath(aid, targetSessionId);
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                logger.warn(`[ThreadContext] 删除 inbox 失败: ${filePath}: ${e.message}`);
+            }
+        }
+    }
+    /** inbox 目录是否为空（无任何待注入记录）。 */
+    isEmpty(aid) {
+        const dir = agentThreadInboxDir(aid);
+        try {
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+            for (const file of files) {
+                if (readAllJsonlLines(path.join(dir, file)).length > 0)
+                    return false;
+            }
+            return true;
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return true;
+            throw e;
+        }
+    }
+    /**
+     * 空洞检测：来源话题在 (afterTimestamp, now] 区间内有多少条真实对话消息。
+     *
+     * 只统计对话消息（in/out），跳过协议/系统消息。检测失败时返回保守值
+     * （hasNewMessages=false + error），不因检测异常打断消息处理主流程。
+     */
+    detectGap(aid, originSessionId, afterTimestamp) {
+        try {
+            const sessionsDir = agentSessionsDir(aid);
+            const chatDir = this.findChatDirForSession(sessionsDir, originSessionId);
+            if (!chatDir)
+                return { hasNewMessages: false, count: 0 };
+            const logPath = path.join(chatDir, 'messages.jsonl');
+            if (!fs.existsSync(logPath))
+                return { hasNewMessages: false, count: 0 };
+            const now = Date.now();
+            const hits = readAllJsonlLines(logPath).filter((m) => {
+                const ts = typeof m?.ts === 'number' ? m.ts : undefined;
+                if (ts === undefined || ts <= afterTimestamp || ts > now)
+                    return false;
+                // 只算真实对话消息
+                return m.dir === 'in' || m.dir === 'out';
+            });
+            if (hits.length === 0)
+                return { hasNewMessages: false, count: 0 };
+            const stamps = hits.map((m) => m.ts).sort((a, b) => a - b);
+            return {
+                hasNewMessages: true,
+                count: hits.length,
+                firstTimestamp: stamps[0],
+                lastTimestamp: stamps[stamps.length - 1],
+            };
+        }
+        catch (e) {
+            logger.warn(`[ThreadContext] 空洞检测失败: session=${originSessionId}: ${e.message}`);
+            return { hasNewMessages: false, count: 0, error: '无法检测' };
+        }
+    }
+    /**
+     * 按会话 ID 定位 chatDir。sessionId 形如 meta_xxx，其所在 chatDir 由
+     * sessions/<channelKey>/ 布局决定，需要扫描定位（与 SessionManager 同策略）。
+     */
+    findChatDirForSession(sessionsDir, sessionId) {
+        let roots;
+        try {
+            roots = fs.readdirSync(sessionsDir);
+        }
+        catch {
+            return undefined;
+        }
+        for (const root of roots) {
+            const rootPath = path.join(sessionsDir, root);
+            // 顶层：sessions/<channelKey>/<sessionId>.jsonl
+            try {
+                if (fs.statSync(path.join(rootPath, `${sessionId}.jsonl`)).isFile())
+                    return rootPath;
+            }
+            catch { /* 继续找 */ }
+            // 话题：sessions/<channelKey>/_threads/<sessionId>.jsonl
+            try {
+                if (fs.statSync(path.join(rootPath, '_threads', `${sessionId}.jsonl`)).isFile())
+                    return rootPath;
+            }
+            catch { /* 继续找 */ }
+        }
+        return undefined;
+    }
+}

package/dist/core/thread/thread-operation.js

@@ -0,0 +1,258 @@
+import { normalizeThreadPeer } from './thread-service.js';
+export function executeThreadOperation(request, threadService, sendSystemMsg) {
+    return _executeThreadOperation(request, threadService, sendSystemMsg);
+}
+async function _executeThreadOperation(request, threadService, sendSystemMsg) {
+    const op = String(request.op);
+    const selfAid = typeof request.selfAid === 'string' ? request.selfAid : '';
+    if (!selfAid)
+        return { ok: false, code: 'MISSING_SELF_AID', error: 'selfAid is required' };
+    // 入口归一：调用方可能传入裸 ID 或带渠道前缀的写法，统一成索引里存储的形态。
+    // 归一失败（解析不出）时保留原值，由下游按"无此对端"处理，不改变 arg 缺失的语义。
+    request = { ...request, peer: normalizeThreadPeer(request.peer) ?? request.peer };
+    try {
+        switch (op) {
+            case 'list': {
+                const result = threadService.listThreads({
+                    selfAid,
+                    peer: request.peer,
+                    status: request.status,
+                    label: request.label ?? undefined,
+                    unlabeled: request.unlabeled,
+                    sort: request.sort,
+                    page: request.page,
+                    limit: request.limit,
+                });
+                const threads = result.threads.map(t => ({
+                    ...t,
+                    running: false,
+                    peerName: t.peerName ?? t.peer,
+                }));
+                return { ok: true, result: { ...result, threads } };
+            }
+            case 'list-peers': {
+                const peers = threadService.listPeers(selfAid);
+                return { ok: true, result: { peers } };
+            }
+            case 'show': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer is required' };
+                // peer-only ref (no threadId) → show main session
+                if (!threadId) {
+                    const result = await threadService.showMainSession(selfAid, peer);
+                    if (!result)
+                        return { ok: false, code: 'NOT_FOUND', error: `与 ${peer} 无活跃主会话` };
+                    return { ok: true, result };
+                }
+                const result = await threadService.showThread({ selfAid, peer, threadId });
+                // 索引健康检查：检测 session 文件是否存在
+                const indexWarning = result._indexWarning;
+                const resp = { ok: true, result };
+                if (indexWarning)
+                    resp.indexWarning = indexWarning;
+                return resp;
+            }
+            case 'check-index': {
+                const result = threadService.checkIndex(selfAid);
+                let warning;
+                if (result.missing > 0 && result.stale > 0) {
+                    warning = `索引异常：${result.missing} 条 session 文件缺失（数据问题），${result.stale} 条属性与文件不一致（写盘时序）`;
+                }
+                else if (result.missing > 0) {
+                    warning = `索引异常：${result.missing} 条 session 文件缺失，rebuild-index 后相关话题的 rename/label/status 改动将回退`;
+                }
+                else if (result.stale > 0) {
+                    warning = `索引轻微不一致：${result.stale} 条话题属性（name/label/status）与 session 文件最后一行不同步，rebuild-index 可修复`;
+                }
+                return { ok: true, result, indexWarning: warning };
+            }
+            case 'history': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if (!peer && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                // threadId 可选：不传时读主会话（threadId=null）消息
+                if (!peer)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer is required' };
+                const result = await threadService.historyThread({
+                    selfAid,
+                    peer,
+                    threadId,
+                    limit: request.limit,
+                    before: request.before,
+                    after: request.after,
+                    direction: request.direction,
+                });
+                return { ok: true, result };
+            }
+            case 'create': {
+                if (!request.peer || !request.name)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and name required' };
+                const result = await threadService.createThread({
+                    selfAid,
+                    peer: request.peer,
+                    peerKind: request.peerKind ?? 'private',
+                    name: request.name,
+                    label: request.label ?? undefined,
+                    topicStatus: request.topicStatus,
+                });
+                if (sendSystemMsg) {
+                    try {
+                        await sendSystemMsg({
+                            from: selfAid,
+                            to: request.peer,
+                            threadId: result.threadId,
+                            topicName: result.name,
+                            peerKind: request.peerKind ?? 'private',
+                        });
+                    }
+                    catch {
+                        // 系统消息发送失败不影响本地创建
+                    }
+                }
+                return { ok: true, result };
+            }
+            case 'rename': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId || !request.name)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer, threadId and name required' };
+                const result = await threadService.renameThread({ selfAid, peer, threadId, name: request.name });
+                return { ok: true, result };
+            }
+            case 'label': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and threadId required' };
+                await threadService.labelThread({ selfAid, peer, threadId, label: request.label ?? null });
+                return { ok: true };
+            }
+            case 'status': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId || !request.topicStatus)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer, threadId and topicStatus required' };
+                await threadService.statusThread({ selfAid, peer, threadId, topicStatus: request.topicStatus });
+                return { ok: true };
+            }
+            case 'rebuild-index': {
+                const dryRun = request.dryRun === true;
+                const result = await threadService.rebuildIndex(selfAid, dryRun);
+                if (dryRun) {
+                    const { rebuilt } = result;
+                    const check = threadService.checkIndex(selfAid);
+                    return { ok: true, result: { rebuilt, missing: check.missing, missingIds: check.missingIds, dryRun: true } };
+                }
+                return { ok: true, result };
+            }
+            case 'delete': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and threadId required' };
+                await threadService.deleteThread(selfAid, peer, threadId);
+                return { ok: true };
+            }
+            case 'summary-show': {
+                if (!request.sessionId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId required' };
+                const result = threadService.showSummary(selfAid, request.sessionId);
+                return { ok: true, result: result ?? null };
+            }
+            case 'summary-set': {
+                if (!request.sessionId || !request.content)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId and content required' };
+                // 覆盖游标由 service 自动记录（写入时刻话题最后一条消息的 ts），调用方不用传。
+                const result = threadService.setSummary(selfAid, request.sessionId, request.content, request.ifRev);
+                // 顺带改名：总结时往往正好把话题主题想清楚了，一次命令写完更省事。
+                // 调用方（CLI / slash）保证 name 一定存在；`-` 表示"保持原标题不改"。
+                // 主会话没有话题名可改（threadId 为空），忽略该参数而不是报错。
+                const rawName = typeof request.name === 'string' ? request.name.trim() : '';
+                let name = rawName && rawName !== '-' ? rawName : undefined;
+                let threadId = request.threadId;
+                if (name && !threadId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    threadId = resolved?.threadId;
+                }
+                let peer = request.peer;
+                if (name && threadId && !peer) {
+                    peer = threadService.readThreadIndex(selfAid).threads.find(t => t.threadId === threadId)?.peer;
+                }
+                if (name && threadId && peer) {
+                    try {
+                        const renamed = await threadService.renameThread({ selfAid, peer, threadId, name });
+                        return { ok: true, result: { ...result, renamedTo: renamed.name, renamedChanged: renamed.changed } };
+                    }
+                    catch (e) {
+                        // 摘要已写入，改名失败不回滚——如实返回，让调用方知道只有改名这步没成
+                        return {
+                            ok: true,
+                            result: { ...result, renameError: e?.message ?? String(e) },
+                        };
+                    }
+                }
+                return { ok: true, result };
+            }
+            case 'summary-log': {
+                if (!request.sessionId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId required' };
+                const result = threadService.logSummary(selfAid, request.sessionId);
+                return { ok: true, result };
+            }
+            case 'summary-clear': {
+                if (!request.sessionId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId required' };
+                threadService.clearSummary(selfAid, request.sessionId);
+                return { ok: true };
+            }
+            default:
+                return { ok: false, code: 'UNKNOWN_OP', error: `Unknown op: ${op}` };
+        }
+    }
+    catch (error) {
+        return { ok: false, code: error.code ?? 'ERROR', error: error.message ?? String(error) };
+    }
+}

package/dist/core/thread/thread-route.js

@@ -0,0 +1,33 @@
+import { sameGroupAid } from '../../aun/group/identity.js';
+import { ThreadService } from './thread-service.js';
+/**
+ * 解析 `--thread` 跨话题发送的目标话题。
+ *
+ * 话题必须存在于发送方本端索引、属于 AUN 渠道、peerKind 与发送 scope 一致；
+ * 给出 target 时还必须与话题 peer 相同（群按群 AID 规范化比较）。
+ * 返回 undefined 表示该 thread 不能作为跨话题路由依据。
+ */
+export function resolveThreadRouteTarget(selfAid, threadId, scope, target) {
+    if (!selfAid || !threadId)
+        return undefined;
+    let entry;
+    try {
+        entry = ThreadService.findThreadById(selfAid.replace(/^@/, ''), threadId);
+    }
+    catch {
+        return undefined;
+    }
+    if (!entry)
+        return undefined;
+    if ((entry.channelType ?? 'aun') !== 'aun')
+        return undefined;
+    if (entry.peerKind !== (scope === 'group' ? 'group' : 'private'))
+        return undefined;
+    if (target === undefined)
+        return entry;
+    const normalizedTarget = target.replace(/^@/, '');
+    const matches = scope === 'group'
+        ? sameGroupAid(entry.peer, normalizedTarget)
+        : entry.peer === normalizedTarget;
+    return matches ? entry : undefined;
+}