evolcore 0.0.27 → 0.0.29-test.0

package/dist/core/command/diag-service.js

@@ -1,5 +1,9 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { isValidAid } from '../../aun/aid/validation.js';
+import { atomicReadJson, atomicWriteJson } from '../../utils/atomic-write.js';
 import { remoteAccessService } from '../auth/remote-access-store.js';
+import { KeyedFairMutex } from '../handoff/mutex.js';
 export const DIAGNOSTIC_AGENT_AID = 'diag.agentid.cn';
 /** IPC verifies local control authority; managed calls must independently prove their actor. */
 export async function executeDiagIpc(service, registry, owners, cmd) {
@@ -55,11 +59,17 @@ export class DiagService {
     context;
     send;
     tokens;
+    sessionControlTail = Promise.resolve();
     constructor(context, send, tokens = remoteAccessService) {
         this.context = context;
         this.send = send;
         this.tokens = tokens;
     }
+    withSessionControl(operation) {
+        const pending = this.sessionControlTail.then(operation, operation);
+        this.sessionControlTail = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
     /** Local CLI authority is checked by IPC; slash identity is authenticated AUN peerId. */
     async execute(command, actorAid) {
         const { controlAid, owners } = this.context();
@@ -72,47 +82,302 @@ export class DiagService {
             if (!previous)
                 return { ok: true, message: '当前没有诊断授权' };
             const diag = previous.diagnostic;
-            try {
-                await this.send(diag.agentAid, `诊断授权已取消。目标 daemon：${controlAid}；case：${diag.caseId}；沟通 Owner：${diag.ownerAid}。请停止这次诊断的后续访问，并告知 Owner。`);
-                return { ok: true, message: '诊断授权已撤销，已通知诊断 Agent' };
-            }
-            catch {
-                return { ok: true, code: 'DIAG_STOP_NOTICE_FAILED', message: '诊断授权已撤销；取消通知发送失败，诊断 Agent 后续访问将被拒绝' };
-            }
+            return this.withSessionControl(async () => {
+                try {
+                    await this.send(diag.agentAid, [
+                        '诊断事件：cancel',
+                        '诊断授权已取消。',
+                        `目标 daemon：${controlAid}`,
+                        `case：${diag.caseId}`,
+                        `沟通 Owner：${diag.ownerAid}`,
+                        '请停止该 case 的后续 Menu 访问，并告知 Owner 该 case 已取消。',
+                        '不要把本通知当作新的诊断请求；请向 Owner 发送取消确认。',
+                    ].join('\n'));
+                }
+                catch {
+                    return { ok: true, code: 'DIAG_STOP_NOTICE_FAILED', message: '诊断授权已撤销；取消通知发送失败，诊断 Agent 后续访问将被拒绝' };
+                }
+                return { ok: true, message: '诊断授权已撤销，已通知诊断 Agent 停止该 case；远端执行状态未确认' };
+            });
         }
         const ownerAid = actorAid ?? command.ownerAid ?? owners[0];
         if (!ownerAid || !isValidAid(ownerAid) || !owners.includes(ownerAid))
             return { ok: false, code: 'DAEMON_OWNER_REQUIRED', message: '请配置本机 owners，或指定其中一个有效 Owner AID' };
         if (!command.problem?.trim() || command.problem.length > 16_000)
             return { ok: false, code: 'INVALID_ARGUMENT', message: '请提供 1 到 16000 字符的问题描述' };
+        const appendExisting = async (existing) => {
+            if (!existing.diagnostic)
+                return { ok: false, code: 'DIAG_AUTH_FAILED', message: '当前诊断授权记录无效' };
+            if (existing.diagnostic.ownerAid !== ownerAid) {
+                return { ok: false, code: 'DIAG_OWNER_MISMATCH', message: `当前诊断已绑定沟通 Owner ${existing.diagnostic.ownerAid}，不能由 ${ownerAid} 追加信息` };
+            }
+            const { caseId } = existing.diagnostic;
+            const append = [
+                '诊断事件：append',
+                '当前诊断 case 的追加信息（不要新建诊断授权或 case）：',
+                `目标 daemon：${controlAid}`,
+                `沟通 Owner：${ownerAid}`,
+                `case：${caseId}`,
+                `问题补充：\n${command.problem.trim()}`,
+                '请在现有诊断上下文中处理；继续使用原有授权，必要时向 Owner 汇报新增影响。',
+            ].join('\n');
+            return this.withSessionControl(async () => {
+                if (this.tokens.getDiagnosticToken(controlAid)?.token !== existing.token) {
+                    return { ok: false, code: 'DIAG_CANCELLED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid, message: '追加信息发送前诊断授权已取消' };
+                }
+                try {
+                    await this.send(existing.diagnostic.agentAid, append);
+                }
+                catch (error) {
+                    const reason = error instanceof Error ? error.message : String(error);
+                    return { ok: false, code: 'DIAG_APPEND_FAILED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid,
+                        message: `诊断追加信息发送失败：${reason}；原诊断授权仍保持有效` };
+                }
+                if (this.tokens.getDiagnosticToken(controlAid)?.token !== existing.token) {
+                    return { ok: false, code: 'DIAG_CANCELLED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid, message: '追加信息发送期间诊断授权已取消' };
+                }
+                return { ok: true, code: 'DIAG_APPENDED', caseId, ownerAid, agentAid: existing.diagnostic.agentAid,
+                    message: `已将补充信息追加到现有诊断 case ${caseId}，未创建新的诊断授权` };
+            });
+        };
+        const existing = this.tokens.getDiagnosticToken(controlAid);
+        if (existing?.diagnostic)
+            return appendExisting(existing);
         let record;
         try {
             record = this.tokens.issueDiagnosticToken(controlAid, DIAGNOSTIC_AGENT_AID, ownerAid);
         }
         catch (error) {
+            // Another request may have reserved the grant after the inspection above.
+            // Treat that reservation as the same case and append instead of surfacing a duplicate error.
+            const current = error?.code === 'DIAG_ALREADY_ACTIVE' ? this.tokens.getDiagnosticToken(controlAid) : undefined;
+            if (current?.diagnostic)
+                return appendExisting(current);
             return { ok: false, code: error.code ?? 'DIAG_AUTH_FAILED', message: error.message };
         }
         const caseId = record.diagnostic.caseId;
-        const invitation = [
-            '请协助诊断以下主机，并主动联系指定 Owner 展示进展、追问和报告。',
-            `目标 daemon Control AID：${controlAid}`, `沟通 Owner AID：${ownerAid}`, `case：${caseId}`,
-            `远程访问 Token：${record.token}`,
-            '请通过标准 Menu 调用诊断；Token 放入 E2EE 受保护头。权限复用该主机既有 Control Menu，包含 restart。有效访问滑动续期，空闲 60 分钟失效。',
-            '先给 Owner 发开始消息，使用通用 handoff 保留目标、Token、问题和发现；无需等待 Owner 回复即可开始。授权失效后停止访问。',
-            `问题描述：\n${command.problem.trim()}`,
-        ].join('\n');
-        try {
-            await this.send(DIAGNOSTIC_AGENT_AID, invitation);
-        }
-        catch (error) {
-            this.tokens.revokeDiagnosticToken(controlAid, record.token);
-            const reason = error instanceof Error ? error.message : String(error);
-            return { ok: false, code: 'DIAG_INVITATION_FAILED', message: `未能确认诊断邀请发送成功：${reason}。本次授权已撤销，请重试` };
+        const sessionName = `diag-${caseId.slice(0, 8)}`;
+        return this.withSessionControl(async () => {
+            if (this.tokens.getDiagnosticToken(controlAid)?.token !== record.token) {
+                return { ok: false, code: 'DIAG_CANCELLED', message: '邀请发送前授权已撤销，本次诊断已取消' };
+            }
+            const invitation = [
+                '诊断事件：new',
+                '请协助诊断以下主机，并主动联系指定 Owner 展示进展、追问和报告。',
+                `目标 daemon Control AID：${controlAid}`, `沟通 Owner AID：${ownerAid}`, `case：${caseId}`,
+                `诊断创建时间（Unix毫秒）：${record.createdAt}`,
+                `远程访问 Token：${record.token}`,
+                '请通过标准 Menu 调用诊断；Token 放入 E2EE 受保护头。权限复用该主机既有 Control Menu，包含 restart。有效访问滑动续期，空闲 60 分钟失效。',
+                `诊断端应在处理前按 case 建立或选择独立 EvolCore 会话「${sessionName}」，不得恢复或复用其他 case 的 Codex 执行会话。`,
+                '先给 Owner 发开始消息，使用通用 handoff 保留目标、Token、问题和发现；无需等待 Owner 回复即可开始。授权失效后停止访问。若会话隔离失败，先告知 Owner 并暂停 Menu 访问。',
+                `问题描述：\n${command.problem.trim()}`,
+            ].join('\n');
+            try {
+                await this.send(DIAGNOSTIC_AGENT_AID, invitation);
+            }
+            catch (error) {
+                this.tokens.revokeDiagnosticToken(controlAid, record.token);
+                const reason = error instanceof Error ? error.message : String(error);
+                return { ok: false, code: 'DIAG_INVITATION_FAILED', message: `未能确认诊断邀请发送成功：${reason}。本次授权已撤销，请重试` };
+            }
+            // A stop may race with delivery; never report an already revoked grant as active.
+            if (this.tokens.getDiagnosticToken(controlAid)?.token !== record.token)
+                return { ok: false, code: 'DIAG_CANCELLED', message: '邀请发送期间授权已撤销，本次诊断已取消' };
+            return { ok: true, caseId, ownerAid, agentAid: DIAGNOSTIC_AGENT_AID,
+                message: `诊断邀请已发出；诊断 Agent 收到后会按 case 建立独立执行会话，并联系 ${ownerAid}。` };
+        });
+    }
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const INVITATION = '请协助诊断以下主机，并主动联系指定 Owner 展示进展、追问和报告。';
+const APPEND = '当前诊断 case 的追加信息（不要新建诊断授权或 case）：';
+const diagnosticLocks = new KeyedFairMutex();
+const diagnosticLedgerPath = (chatDir) => path.join(chatDir, 'diagnostic-cases.json');
+export const diagnosticTokenHash = (token) => createHash('sha256').update(token).digest('hex');
+/** Parse only the generated header, never quoted text or the user's problem. */
+export function parseDiagnosticEvent(content) {
+    const text = content.trim().replace(/\r\n/g, '\n');
+    const first = text.split('\n', 1)[0];
+    const explicit = /^诊断事件[：:]\s*(new|append|cancel)$/.exec(first)?.[1];
+    if (first.startsWith('诊断事件') && !explicit)
+        throw new Error('未知诊断事件，未选择执行会话');
+    // Existing released senders need no new slash command or protocol support.
+    const kind = explicit ?? (first === INVITATION ? 'new' : first === APPEND ? 'append'
+        : text.startsWith('诊断授权已取消。') ? 'cancel' : undefined);
+    if (!kind)
+        return undefined;
+    const header = text.split(/^问题(?:描述|补充)[：:]/m, 1)[0];
+    const legacyCancel = !explicit && kind === 'cancel';
+    const fields = legacyCancel ? header.replace(/^诊断授权已取消。/, '').replace(/；/g, '\n') : header;
+    const field = (label) => {
+        const matches = [...fields.matchAll(new RegExp(`^${label}[：:]([^\\n]*)$`, 'gm'))];
+        return matches.length === 1 ? matches[0][1].trim() : undefined;
+    };
+    const caseId = field('case')?.toLowerCase();
+    const controlAid = field('目标 daemon(?: Control AID)?');
+    const ownerAid = legacyCancel
+        ? field('沟通 Owner')?.split('。', 1)[0]
+        : field('沟通 Owner(?: AID)?');
+    if (!caseId || !UUID.test(caseId) || !controlAid || !isValidAid(controlAid) || !ownerAid || !isValidAid(ownerAid)) {
+        throw new Error('诊断通知字段无效，未选择执行会话');
+    }
+    if (kind !== 'new')
+        return { kind, caseId, controlAid, ownerAid };
+    const token = field('远程访问 Token');
+    if (!token || !/^[0-9a-f]{64}$/i.test(token))
+        throw new Error('诊断邀请缺少有效 Token，未选择执行会话');
+    const created = field('诊断创建时间（Unix毫秒）');
+    const createdAt = created === undefined ? undefined : Number(created);
+    if (createdAt !== undefined && (!Number.isSafeInteger(createdAt) || createdAt <= 0))
+        throw new Error('诊断创建时间无效');
+    return { kind, caseId, controlAid, ownerAid, tokenHash: diagnosticTokenHash(token), createdAt };
+}
+function readDiagnosticLedger(chatDir) {
+    const value = atomicReadJson(diagnosticLedgerPath(chatDir));
+    if (!value)
+        return { version: 1, cases: {} };
+    if (value.version !== 1 || !value.cases || typeof value.cases !== 'object' || Array.isArray(value.cases)
+        || Object.entries(value.cases).some(([key, record]) => !UUID.test(key) || !record
+            || !['active', 'closed'].includes(record.state) || !isValidAid(record.ownerAid))) {
+        throw new Error('诊断会话记录损坏，已阻止恢复旧会话');
+    }
+    return value;
+}
+/** Called again at execution and Menu boundaries, including delayed/recovered work. */
+export function isDiagnosticSessionActive(session, chatDir) {
+    if (session.metadata?.diagnosticStatus === 'cancelled')
+        return false;
+    const binding = session.metadata?.diagnostic;
+    if (!binding)
+        return true;
+    const ledger = readDiagnosticLedger(chatDir);
+    const record = ledger.cases[binding.caseId];
+    return ledger.activeCaseId === binding.caseId && record?.state === 'active'
+        && record.sessionId === session.id && record.tokenHash === binding.tokenHash
+        && record.ownerAid === binding.ownerAid && session.channelId === binding.controlAid;
+}
+/** Invalid authorization is terminal; it must not be revived by a retry/append. */
+export function closeDiagnosticSession(session, chatDir) {
+    const binding = session.metadata?.diagnostic;
+    if (!binding)
+        return;
+    const ledger = readDiagnosticLedger(chatDir);
+    const record = ledger.cases[binding.caseId];
+    if (record?.sessionId !== session.id)
+        return;
+    record.state = 'closed';
+    atomicWriteJson(diagnosticLedgerPath(chatDir), ledger);
+}
+/** The bridge already applies normal authentication/admission before calling this. */
+export class DiagnosticSessionRouter {
+    sessions;
+    stopSession;
+    constructor(sessions, stopSession) {
+        this.sessions = sessions;
+        this.stopSession = stopSession;
+    }
+    async route(input) {
+        const { event, message, channel, channelType, selfAid, chatDir } = input;
+        if (channelType !== 'aun' || selfAid !== DIAGNOSTIC_AGENT_AID || message.chatType !== 'private'
+            || message.threadId || (message.source !== undefined && message.source !== 'user')
+            || !(message.encrypted ?? message.replyContext?.metadata?.encrypted)
+            || message.peerId !== event.controlAid || message.channelId !== event.controlAid || !message.messageId) {
+            throw new Error('诊断通知来源或会话不匹配，未执行会话切换');
         }
-        // A stop may race with delivery; never report an already revoked grant as active.
-        if (this.tokens.getDiagnosticToken(controlAid)?.token !== record.token)
-            return { ok: false, code: 'DIAG_CANCELLED', message: '邀请发送期间授权已撤销，本次诊断已取消' };
-        return { ok: true, caseId, ownerAid, agentAid: DIAGNOSTIC_AGENT_AID,
-            message: `诊断邀请已发出，远程诊断 Agent 将联系 ${ownerAid}，请在与 ${DIAGNOSTIC_AGENT_AID} 的会话中查看处理过程。` };
+        return diagnosticLocks.forKey(diagnosticLedgerPath(chatDir)).runExclusive(async () => {
+            const all = await this.sessions.listSessions(channel, message.channelId, { archiveFilter: 'all' });
+            const ledger = readDiagnosticLedger(chatDir);
+            const find = (caseId) => all.find(s => !s.threadId && s.selfAID === selfAid
+                && s.metadata?.diagnostic?.caseId === caseId && s.metadata.diagnostic.controlAid === event.controlAid);
+            let record = ledger.cases[event.caseId];
+            if (record && record.ownerAid !== event.ownerAid)
+                throw new Error('诊断通知 Owner 与原授权不一致');
+            if (event.kind === 'cancel') {
+                let session = find(event.caseId);
+                if (!session) {
+                    const legacy = this.sessions.getActiveSessionSync(channel, message.channelId, channelType, selfAid);
+                    if (legacy && !legacy.threadId && !legacy.metadata?.diagnostic) {
+                        await this.sessions.patchSessionMetadata(legacy.id, { diagnosticStatus: 'cancelled' });
+                        session = legacy;
+                    }
+                }
+                // Keep a tombstone even if cancellation overtook the first invitation.
+                ledger.cases[event.caseId] = { ...record, ownerAid: event.ownerAid, state: 'closed', sessionId: record?.sessionId ?? session?.id };
+                atomicWriteJson(diagnosticLedgerPath(chatDir), ledger);
+                if (session)
+                    await this.stopSession(session.id);
+                return { notice: '已关闭该诊断并停止其待处理任务。' };
+            }
+            if (record?.state === 'closed')
+                return { notice: '该诊断已结束，旧邀请和追加消息不会重新执行。' };
+            if (event.kind === 'append' && !record)
+                throw new Error('未找到该诊断的独立会话，请停止诊断后重新发起');
+            if (record && event.kind === 'new' && record.tokenHash !== event.tokenHash)
+                throw new Error('相同诊断的授权不一致，未恢复会话');
+            if (!record) {
+                if (find(event.caseId))
+                    throw new Error('诊断生命周期记录缺失，拒绝恢复旧会话');
+                const sequence = Number.isSafeInteger(message.gatewaySeq) ? message.gatewaySeq : undefined;
+                const last = ledger.activeCaseId ? ledger.cases[ledger.activeCaseId] : undefined;
+                const stale = last && (sequence !== undefined && last.sequence !== undefined
+                    ? sequence <= last.sequence
+                    : event.createdAt !== undefined && last.createdAt !== undefined
+                        ? event.createdAt <= last.createdAt : true);
+                if (stale)
+                    return { notice: '邀请顺序已过期或无法确认，未恢复旧诊断。' };
+                // Persist all revocations before interruption/creation. A crash here
+                // cannot let a restored old task use its previous authorization.
+                for (const previous of Object.values(ledger.cases))
+                    previous.state = 'closed';
+                record = { state: 'active', ownerAid: event.ownerAid, tokenHash: event.tokenHash, sequence, createdAt: event.createdAt };
+                ledger.cases[event.caseId] = record;
+                ledger.activeCaseId = event.caseId;
+                atomicWriteJson(diagnosticLedgerPath(chatDir), ledger);
+            }
+            if (ledger.activeCaseId !== event.caseId)
+                return { notice: '该诊断已被新诊断替代。' };
+            const oldActive = this.sessions.getActiveSessionSync(channel, message.channelId, channelType, selfAid);
+            if (!record.cleanupComplete && oldActive && !oldActive.threadId && !oldActive.metadata?.diagnostic) {
+                // Migration from the historical shared Control conversation. Owner
+                // conversations and sessions belonging to other hosts are untouched.
+                await this.sessions.patchSessionMetadata(oldActive.id, { diagnosticStatus: 'cancelled' });
+                await this.stopSession(oldActive.id);
+            }
+            // Retry interruption too after an interrupted creation attempt.
+            for (const previous of record.cleanupComplete ? [] : all) {
+                if (!previous.threadId && previous.metadata?.diagnostic?.controlAid === event.controlAid
+                    && previous.metadata.diagnostic.caseId !== event.caseId)
+                    await this.stopSession(previous.id);
+            }
+            let session = find(event.caseId);
+            if (record.sessionId && (!session || record.sessionId !== session.id))
+                throw new Error('诊断会话绑定缺失，拒绝回退到历史会话');
+            if (!session) {
+                if (event.kind !== 'new' || !input.baseagent)
+                    throw new Error('无法创建诊断执行会话');
+                const metadata = {
+                    channelKey: channel, peerId: event.controlAid, peerName: message.peerName,
+                    diagnostic: { caseId: event.caseId, controlAid: event.controlAid, ownerAid: event.ownerAid, tokenHash: record.tokenHash },
+                };
+                // The case binding is committed in the first session snapshot. Replay
+                // can find it even if the process died before saving the ledger pointer.
+                session = await this.sessions.createNewSession(channel, message.channelId, input.projectPath, `diag-${event.caseId.slice(0, 8)}`, input.baseagent, metadata);
+                if (session.agentSessionId || session.metadata?.agentSessions || session.metadata?.resumeAt) {
+                    throw new Error('诊断会话错误继承了旧执行上下文');
+                }
+            }
+            if (session.metadata?.diagnostic?.tokenHash !== record.tokenHash)
+                throw new Error('诊断会话授权绑定不一致');
+            // A concurrent Menu response can close this case while we await runner
+            // interruption/session creation. Never overwrite that terminal state.
+            const latest = readDiagnosticLedger(chatDir);
+            const current = latest.cases[event.caseId];
+            if (latest.activeCaseId !== event.caseId || current?.state !== 'active')
+                return { notice: '该诊断已结束。' };
+            current.sessionId = session.id;
+            current.cleanupComplete = true;
+            atomicWriteJson(diagnosticLedgerPath(chatDir), latest);
+            return { session };
+        });
     }
 }

package/dist/core/command/memory-slash.js

@@ -0,0 +1,270 @@
+/**
+ * memory-slash.ts — `/memory` 斜杠命令：记忆查看、维护与整理
+ *
+ * 权限（按作用域）：
+ *  - relation：私聊里当前对端可看、admin+ 可写；群聊只有 admin+ 可看可写，且只能操作本群关系
+ *  - agent：admin+ 可看可写（私聊）
+ *  - owner：仅该 owner 本人（agent 配置的第一个 owner）可看可写（私聊）
+ * 不支持跨关系浏览：relation 永远是发起命令的这段关系。
+ */
+import { CONSOLIDATION_MODES, MODE_SCOPE } from '../memory/consolidation-context.js';
+import { MEMORY_SCOPES, isMemoryScope, memoryOverview, listMemoryFiles, formatMemoryFiles, readMemoryIndex, showMemoryFile, formatPendingNotes, showPendingNote, reindexScope, dropNote, archiveMemoryFile, restoreMemoryFile, } from '../memory/memory-admin.js';
+const USAGE = [
+    '用法:',
+    '  /memory                         记忆概览',
+    '  /memory notes                   待整理 note 列表',
+    '  /memory note <slug>             查看 note',
+    '  /memory note drop <slug>        撤销 note',
+    '  /memory index <scope>           查看 MEMORY.md 索引',
+    '  /memory list <scope> [archived] 正式 / 已归档记忆列表',
+    '  /memory show <scope> <slug> [archived]  查看单条记忆',
+    '  /memory archive <scope> <slug>  归档记忆（可用 restore 恢复）',
+    '  /memory restore <scope> <slug>  恢复已归档记忆',
+    '  /memory reindex <scope>         重建索引',
+    '  /memory consolidate [mode] [scope]  拉起整理（mode: notes|generalize|promote|profile|forget；forget 需指定 scope）',
+    'scope: relation | agent | owner',
+].join('\n');
+const result = (text) => ({ kind: 'command.result', text });
+const error = (text) => ({ kind: 'command.error', text: `❌ ${text}` });
+export function canViewMemoryScope(ctx, scope) {
+    if (ctx.chatType === 'group')
+        return scope === 'relation' && ctx.isAdmin;
+    if (scope === 'relation')
+        return ctx.role !== 'none';
+    if (scope === 'agent')
+        return ctx.isAdmin;
+    return ctx.isOwnerSelf;
+}
+export function canWriteMemoryScope(ctx, scope) {
+    if (ctx.chatType === 'group')
+        return scope === 'relation' && ctx.isAdmin;
+    if (scope === 'owner')
+        return ctx.isOwnerSelf;
+    return ctx.isAdmin;
+}
+/** evolhelp / 菜单是否展示 /memory：至少能看一个作用域。 */
+export function canUseMemorySlash(ctx) {
+    return MEMORY_SCOPES.some(scope => canViewMemoryScope(ctx, scope));
+}
+const SCOPE_LABEL = { relation: '当前关系', agent: 'Agent 级', owner: 'Owner 级' };
+/**
+ * evolhelp「记忆管理」条目：能一键执行的都展开成无参数条目，只有需要 slug 的才带 args。
+ * 可见范围与 canViewMemoryScope / canWriteMemoryScope 一致。
+ */
+export function memoryHelpEntries(ctx) {
+    const category = '记忆管理';
+    const roles = [ctx.role];
+    const view = MEMORY_SCOPES.filter(s => canViewMemoryScope(ctx, s));
+    if (view.length === 0)
+        return [];
+    const write = MEMORY_SCOPES.filter(s => canWriteMemoryScope(ctx, s));
+    const out = [];
+    const add = (command, description, args) => out.push({ command, ...(args ? { args } : {}), description, category, roles });
+    add('/memory', '记忆概览：条数、待整理 note、索引大小');
+    if (view.includes('relation'))
+        add('/memory notes', '待整理 note 列表');
+    for (const s of view)
+        add(`/memory list ${s}`, `${SCOPE_LABEL[s]}正式记忆列表`);
+    for (const s of view)
+        add(`/memory index ${s}`, `${SCOPE_LABEL[s]}索引 MEMORY.md`);
+    for (const s of view)
+        add(`/memory list ${s} archived`, `${SCOPE_LABEL[s]}已归档记忆`);
+    if (write.length > 0) {
+        if (write.includes('relation')) {
+            add('/memory consolidate notes', '整理待处理 note');
+            add('/memory consolidate profile', '重新生成关系画像');
+        }
+        if (write.includes('agent') && view.includes('relation'))
+            add('/memory consolidate generalize', '泛化为 Agent 级记忆');
+        if (write.includes('owner') && view.includes('relation'))
+            add('/memory consolidate promote', '提升为 Owner 级记忆');
+        for (const s of write)
+            add(`/memory consolidate forget ${s}`, `${SCOPE_LABEL[s]}遗忘审查`);
+        for (const s of write)
+            add(`/memory reindex ${s}`, `重建${SCOPE_LABEL[s]}索引`);
+    }
+    // 以下需要 slug，必须输入
+    add('/memory show', '查看单条记忆正文（slug 见 list 结果）', '<scope> <slug> [archived]');
+    if (view.includes('relation'))
+        add('/memory note', '查看单条 note', '<slug>');
+    if (write.length > 0) {
+        add('/memory archive', '归档一条记忆', '<scope> <slug>');
+        add('/memory restore', '恢复已归档记忆', '<scope> <slug>');
+        if (write.includes('relation'))
+            add('/memory note drop', '撤销一条 note', '<slug>');
+    }
+    add('/memory help', '全部子命令说明');
+    return out;
+}
+function denied(scope, write, chatType) {
+    if (chatType === 'group')
+        return '群聊中只有管理员可以查看和维护本群的 relation 记忆';
+    if (scope === 'owner')
+        return 'owner 级记忆仅限该 owner 本人操作';
+    return write ? `无权限：${scope} 级记忆的维护仅限管理员` : `无权限：${scope} 级记忆仅限管理员查看`;
+}
+export async function handleMemorySlash(ctx) {
+    if (!ctx.selfAid)
+        return error('无法确定当前 agent AID');
+    const args = ctx.content.trim().split(/\s+/).slice(1);
+    const sub = args[0];
+    const target = {
+        selfAid: ctx.selfAid,
+        peerKey: ctx.peerKey,
+        ownerAid: ctx.ownerAid,
+        memoryConfig: ctx.memoryConfig,
+    };
+    const needScope = (raw, write) => {
+        if (!isMemoryScope(raw))
+            return error(`scope 必须是 relation / agent / owner\n\n${USAGE}`);
+        const allowed = write ? canWriteMemoryScope(ctx, raw) : canViewMemoryScope(ctx, raw);
+        if (!allowed)
+            return error(denied(raw, write, ctx.chatType));
+        if (raw === 'relation' && !ctx.peerKey)
+            return error('当前会话没有关系上下文，无法操作 relation 记忆');
+        if (raw === 'owner' && !ctx.ownerAid)
+            return error('当前 agent 未配置 owner');
+        return raw;
+    };
+    const isPayload = (v) => typeof v === 'object' && v !== null;
+    try {
+        if (!sub) {
+            const scopes = MEMORY_SCOPES.filter(s => canViewMemoryScope(ctx, s)
+                && (s !== 'relation' || !!ctx.peerKey) && (s !== 'owner' || !!ctx.ownerAid));
+            if (scopes.length === 0)
+                return error('无权限查看记忆');
+            return result(`${memoryOverview(target, scopes)}\n\n输入 /memory help 查看全部子命令`);
+        }
+        if (sub === 'help')
+            return result(USAGE);
+        if (sub === 'notes') {
+            const scope = needScope('relation', false);
+            if (isPayload(scope))
+                return scope;
+            return result(await formatPendingNotes(target));
+        }
+        if (sub === 'note') {
+            if (args[1] === 'drop') {
+                const scope = needScope('relation', true);
+                if (isPayload(scope))
+                    return scope;
+                if (!args[2])
+                    return error('用法: /memory note drop <slug>');
+                await dropNote(target, args[2]);
+                return result(`✅ 已撤销 note: ${args[2]}`);
+            }
+            const scope = needScope('relation', false);
+            if (isPayload(scope))
+                return scope;
+            if (!args[1])
+                return error('用法: /memory note <slug>');
+            return result(showPendingNote(target, args[1]));
+        }
+        if (sub === 'index') {
+            const scope = needScope(args[1], false);
+            if (isPayload(scope))
+                return scope;
+            return result(readMemoryIndex(target, scope));
+        }
+        if (sub === 'list') {
+            const scope = needScope(args[1], false);
+            if (isPayload(scope))
+                return scope;
+            const archived = args[2] === 'archived';
+            return result(formatMemoryFiles(scope, listMemoryFiles(target, scope, archived), archived));
+        }
+        if (sub === 'show') {
+            const scope = needScope(args[1], false);
+            if (isPayload(scope))
+                return scope;
+            if (!args[2])
+                return error('用法: /memory show <scope> <slug> [archived]');
+            return result(await showMemoryFile(target, scope, args[2], args[3] === 'archived'));
+        }
+        if (sub === 'archive' || sub === 'restore') {
+            const scope = needScope(args[1], true);
+            if (isPayload(scope))
+                return scope;
+            if (!args[2])
+                return error(`用法: /memory ${sub} <scope> <slug>`);
+            if (sub === 'archive') {
+                await archiveMemoryFile(target, scope, args[2]);
+                return result(`✅ 已归档 ${scope}/${args[2]}，索引已重建\n恢复: /memory restore ${scope} ${args[2]}`);
+            }
+            await restoreMemoryFile(target, scope, args[2]);
+            return result(`✅ 已恢复 ${scope}/${args[2]}，索引已重建`);
+        }
+        if (sub === 'reindex') {
+            const scope = needScope(args[1], true);
+            if (isPayload(scope))
+                return scope;
+            const r = await reindexScope(target, scope);
+            return result(`✅ ${scope} 索引已重建（${r.indexed} 条）`);
+        }
+        if (sub === 'consolidate')
+            return await consolidate(ctx, target, args[1], args[2], needScope, isPayload);
+        return error(`未知子命令: ${sub}\n\n${USAGE}`);
+    }
+    catch (e) {
+        return error(e?.message || String(e));
+    }
+}
+async function consolidate(ctx, target, rawMode, rawScope, needScope, isPayload) {
+    const mode = (rawMode ?? 'notes');
+    if (!CONSOLIDATION_MODES.includes(mode))
+        return error(`mode 必须是 ${CONSOLIDATION_MODES.join(' / ')}`);
+    // 与 ipc checkMemoryEnabled 一致的开关检查
+    const mc = target.memoryConfig;
+    if (mc?.enableRelation === false)
+        return error('记忆系统已停用（memory.enableRelation=false）');
+    if (mode === 'generalize' && mc?.enableAgent === false)
+        return error('泛化模式已停用（memory.enableAgent=false）');
+    if (mode === 'promote' && mc?.enableOwner === false)
+        return error('提升模式已停用（memory.enableOwner=false）');
+    // 产出写到哪一层，就按那一层的写权限判定；整理都需要关系上下文（notes/profile 读当前关系）
+    let scopeOverride;
+    let writeScope;
+    if (mode === 'forget') {
+        if (!rawScope)
+            return error('forget 模式需要指定 scope: /memory consolidate forget <relation|agent|owner>');
+        const s = needScope(rawScope, true);
+        if (isPayload(s))
+            return s;
+        scopeOverride = s;
+        writeScope = s;
+    }
+    else {
+        writeScope = MODE_SCOPE[mode];
+        const s = needScope(writeScope, true);
+        if (isPayload(s))
+            return s;
+    }
+    if ((mode === 'notes' || mode === 'profile' || mode === 'generalize') && !ctx.peerKey) {
+        return error('当前会话没有关系上下文，无法整理');
+    }
+    if (!ctx.launcher)
+        return error('daemon 未注入整理入口，无法拉起整理会话');
+    const launched = await ctx.launcher({
+        taskCtx: {
+            selfAid: target.selfAid,
+            peerKey: ctx.peerKey,
+            channel: ctx.channelType,
+            peerId: ctx.peerId,
+            chatType: ctx.chatType,
+            threadId: ctx.threadId,
+            sessionId: ctx.sessionId,
+            baseagent: ctx.baseagent,
+        },
+        mode,
+        triggeredBy: 'manual',
+        ownerAid: ctx.ownerAid,
+        ownerInvolved: ctx.isOwnerSelf,
+        forgetAfterDays: mc?.forgetAfterDays,
+        ...(scopeOverride ? { scopeOverride } : {}),
+    });
+    const label = `${mode}${scopeOverride ? `(${scopeOverride})` : ''}`;
+    if (!launched || launched.queued) {
+        return result(`⏳ 整理请求已入队（${label}），前一个整理会话结束后自动开始`);
+    }
+    return result(`✅ 已拉起整理会话（${label}）${launched.executionSessionId ? `\n会话: ${launched.executionSessionId}` : ''}\n完成后会在当前对话反馈结果`);
+}

package/dist/core/command/menu-catalog.js

@@ -69,6 +69,7 @@ const ENTRIES = [
     relation('effort.relation', 'effort', '推理强度', 20, '/effort', 'model.effort.current', { options: { cmd: '/effort', operation: 'model.effort.current', scope: 'relation', mode: 'dynamic', dependsOn: ['model.relation'] }, update: { cmd: '/effort', operation: 'model.effort', scope: 'relation' }, control: 'select' }),
     relation('chatmode.relation', 'chatmode', '对话模式', 30, '/chatmode', 'chatmode.current', { options: { cmd: '/chatmode', operation: 'chatmode.current', scope: 'relation', mode: 'static', items: [{ value: 'interactive', label: '交互模式' }, { value: 'proactive', label: '主动模式' }] }, update: { cmd: '/chatmode', operation: 'chatmode.update', scope: 'relation' }, control: 'select' }),
     relation('activity.relation', 'activity', '中间输出', 40, '/activity', 'activity.current', { options: { cmd: '/activity', operation: 'activity.current', scope: 'relation', mode: 'static', items: [{ value: 'all', label: '私聊显示' }, { value: 'text', label: '仅文字进展' }, { value: 'none', label: '全部静默' }] }, update: { cmd: '/activity', operation: 'activity.update', scope: 'relation' }, control: 'select' }),
+    { id: 'task.activities', type: 'list', contexts: ['private_relation', 'group_relation'], name: 'task', label: '任务活动', section: 'relation_behavior', order: 45, query: { cmd: '/task', args: { view: 'activities' }, operation: 'task.activity.read', scope: 'relation', mode: 'dynamic' }, control: 'list' },
     relation('permissionMode.relation', 'permission', '权限模式', 50, '/perm', 'permission.current', { query: { cmd: '/perm', args: { scope: 'role' }, operation: 'permission.current', scope: 'relation' }, options: undefined, update: { cmd: '/perm', operation: 'permission.current', scope: 'relation', supported: false }, control: 'select' }),
     relation('mentionMode.relation', 'group', '群消息响应', 60, '/group', 'group.mentionmode.current', { contexts: ['group_relation'], query: { cmd: '/group', args: { view: 'mentionMode', scope: 'relation' }, operation: 'group.mentionmode.current', scope: 'relation' }, options: { cmd: '/group', args: { option: 'mentionMode', scope: 'relation' }, operation: 'group.mentionmode.current', scope: 'relation' }, update: { cmd: '/group', args: { resource: 'mentionMode', scope: 'relation' }, operation: 'group.mentionmode.update', scope: 'relation' }, control: 'select' }),
     relation('rulesPolicy.relation', 'group', '群规则策略', 70, '/group', 'group.rulespolicy.current', { contexts: ['group_relation'], query: { cmd: '/group', args: { view: 'rulesPolicy', scope: 'relation' }, operation: 'group.rulespolicy.current', scope: 'relation' }, options: { cmd: '/group', args: { option: 'rulesPolicy', scope: 'relation' }, operation: 'group.rulespolicy.current', scope: 'relation' }, update: { cmd: '/group', args: { resource: 'rulesPolicy', scope: 'relation' }, operation: 'group.rulespolicy.update', scope: 'relation' }, control: 'select' }),