evolcore 0.0.32 → 0.0.33

package/dist/cli/thread-command.js

@@ -0,0 +1,620 @@
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { readDelegationCredential } from '../core/auth/agent-delegation.js';
+import { canonicalizeEvolcoreCommandArgv } from '../core/permission/ec-command-parser.js';
+const TOPIC_STATUSES = ['pending', 'in_progress', 'completed', 'archived'];
+const SORT_ORDERS = ['recent', 'created'];
+const HELP_TEXT = `
+ec thread <command> [options]
+
+命令:
+  peers                    列出有话题记录的所有对端（先用这个选对端）
+  list <peer>              列出与某对端的所有话题
+  show <ref>               查看单个话题的元数据
+  history <ref>            读取话题历史消息
+  create <peer> --name     新建话题
+  rename <ref> <名称>      修改话题名称（仅本端）
+  label <ref> <标签>       设置话题标签
+  status <ref> <状态>      更新话题业务状态
+  delete <ref>             删除话题（session 文件移入 _trash）
+  summary show <ref>       查看当前 summary
+  summary set <ref> <内容> --name <新标题|->   写入 summary（--name 必填；- 表示不改名）
+  summary log <ref>        查看 summary 历史版本
+  summary clear <ref>      清空当前 summary（历史版本保留）
+  rebuild-index            重建话题索引（丢失/损坏时使用）
+  rebuild-index --check    检查索引健康状态（只报告不写盘，区分严重/轻微）
+  check-index              同 rebuild-index --check
+
+典型工作流:
+  1. ec agent list                            # 查看本机所有 agent
+  2. ec thread peers --self <selfAid>         # 查看该 agent 的所有对端
+  3. ec thread list <peer> --self <selfAid>   # 查看与该对端的话题列表
+
+<ref> 格式（所有命令统一支持）:
+  current                  当前任务所在话题（托管会话自动注入）
+  <peer>                   该对端的主会话
+  <peer>/<threadId>        指定具体话题
+
+list 选项:
+  --status <s>             过滤状态 (pending|in_progress|completed|archived)
+  --label <l>              过滤标签
+  --unlabeled              仅未标记话题
+  --sort recent|created    排序方式（默认 recent）
+  --page <n>               页码
+  --limit <n>              每页条数
+
+history 选项:
+  --limit <n>              消息条数上限（默认 50）
+  --before <timestamp>     截止时间戳（ms）
+  --after <timestamp>      起始时间戳（ms）
+
+summary 与增量总结:
+  summary show <ref> 会打印 coveredThroughTs（本条摘要覆盖到的时间戳）。
+  下次总结时用它作起点读增量：
+    ec thread history <ref> --after <coveredThroughTs>
+  读完增量后 summary set 会自动把游标推进到话题最新一条。
+
+summary set 选项:
+  --name <新标题|->        必填。顺带把话题改名为该值；传 - 表示保持原标题不改。
+                           总结时正好把主题想清楚，一次命令写完摘要 + 标题。
+  --if-rev <n>             CAS 版本号（可选，多 agent 协作时防并发覆盖）
+
+create 选项:
+  --name <名称>            话题名称（必填）
+  --label <标签>           分类标签
+  --status <状态>          初始状态（默认 pending）
+  --group                  群话题（默认私聊）
+
+label 选项:
+  --clear                  清除标签
+
+状态值: pending | in_progress | completed | archived
+
+  --format json            以 JSON 格式输出
+  --self <selfAid>         宿主终端必填，指定本端 AID
+  --help                   显示帮助
+`.trim();
+function argValue(args, flag) {
+    const i = args.indexOf(flag);
+    return i >= 0 ? args[i + 1] : undefined;
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+async function sendThreadOp(req, commandArgv) {
+    const cred = readDelegationCredential();
+    const { socket } = resolvePaths();
+    const invokingSessionId = process.env.EVOLCORE_SESSION_ID;
+    const result = await ipcQuery(socket, {
+        ...req,
+        type: 'thread.op',
+        argv: commandArgv,
+        delegationToken: cred ?? undefined,
+        sessionId: invokingSessionId,
+    }, 10000);
+    if (!result)
+        return { ok: false, code: 'DAEMON_UNAVAILABLE', error: 'daemon 暂时不可用' };
+    return result;
+}
+function printResult(data, jsonFormat) {
+    if (jsonFormat) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (Array.isArray(data)) {
+        for (const item of data) {
+            printItem(item);
+        }
+    }
+    else {
+        printItem(data);
+    }
+}
+function printItem(item) {
+    if (typeof item !== 'object' || !item) {
+        console.log(String(item));
+        return;
+    }
+    const obj = item;
+    // ThreadHistoryResult — 必须在 ThreadIndexEntry 之前检查，两者都含 threadId
+    if ('messages' in obj && Array.isArray(obj.messages)) {
+        const result = obj;
+        console.log(`话题 ${result.threadId}（与 ${result.peer}）最近 ${result.count} 条消息：`);
+        for (const m of result.messages)
+            printItem(m);
+        return;
+    }
+    // ThreadIndexEntry
+    if ('threadId' in obj) {
+        const running = obj.running ? ' [运行中]' : '';
+        // 内部话题（daemon 会话记录）不是真实联系人，标注出来避免误认
+        const internal = obj.internal ? ' [内部会话记录·无消息]' : '';
+        console.log(`${obj.peer}/${obj.threadId}${running}${internal}`);
+        // 名称只放名称本身：状态、标签各自单独一行，避免污染标题（标题会被 summary set --name 引用）
+        console.log(`  名称: ${obj.name}`);
+        if (obj.topicStatus)
+            console.log(`  状态: ${obj.topicStatus}`);
+        if (obj.label)
+            console.log(`  标签: ${obj.label}`);
+        if (obj.createdAt)
+            console.log(`  创建: ${new Date(obj.createdAt).toLocaleString('zh-CN')}`);
+        // list 场景下 lastActiveAt 已由消息日志派生，故称"活跃"；show 场景下它仍是索引里的
+        // 管理动作时间，故称"最近变更"。
+        if (obj.lastActiveAt) {
+            const at = new Date(obj.lastActiveAt).toLocaleString('zh-CN');
+            console.log(obj.msgTotal !== undefined ? `  活跃: ${at}` : `  最近变更: ${at}`);
+        }
+        if (obj.msgTotal !== undefined) {
+            console.log(`  消息(24h/总计): ${obj.msg24h ?? 0}/${obj.msgTotal}`);
+        }
+        if (obj.lastMsgSnippet)
+            console.log(`  最后消息: ${obj.lastMsgSnippet}`);
+        if (obj.msgTotal !== undefined)
+            console.log(`  摘要: ${obj.summarySnippet ?? '未总结'}`);
+        console.log('');
+        return;
+    }
+    // ThreadHistoryMessage
+    if ('dir' in obj && 'content' in obj) {
+        const dir = obj.dir === 'in' ? '←' : '→';
+        console.log(`[${obj.time}] ${dir} ${obj.from}: ${String(obj.content).slice(0, 120)}`);
+        return;
+    }
+    // CreateThreadResult
+    if ('createdAt' in obj && 'sessionId' in obj) {
+        console.log(`✓ 话题创建成功: ${obj.threadId}`);
+        console.log(`  名称: ${obj.name}`);
+        console.log(`  对端: ${obj.peer}`);
+        return;
+    }
+    // RenameThreadResult
+    if ('changed' in obj) {
+        console.log(obj.changed ? `✓ 改名成功: ${obj.name}` : '✓ 名称未变更');
+        return;
+    }
+    // ListThreadsResult
+    if ('threads' in obj && Array.isArray(obj.threads)) {
+        const result = obj;
+        for (const t of result.threads)
+            printItem(t);
+        const shown = result.threads.length;
+        const totalPages = Math.ceil(result.total / (result.limit || 20));
+        console.log(`─────────────────────────────────────────────`);
+        console.log(`话题总数: ${result.total}  本页: ${shown} 条  第 ${result.page}/${totalPages} 页  每页: ${result.limit} 条`);
+        if (result.totalMsgCount !== undefined) {
+            console.log(`本页消息总数: ${result.totalMsgCount}`);
+        }
+        if (result.hasMore) {
+            const nextPage = result.page + 1;
+            const peerArg = result.peer ?? '<peer>';
+            const selfArg = result.selfAid ? `--self ${result.selfAid}` : '--self <selfAid>';
+            const sortArg = result.sort ? ` --sort ${result.sort}` : ' --sort recent';
+            const statusArg = result.status ? ` --status ${result.status}` : '';
+            const labelArg = result.label ? ` --label "${result.label}"` : '';
+            console.log(`下一页: ec thread list ${peerArg} ${selfArg} --page ${nextPage} --limit ${result.limit}${sortArg}${statusArg}${labelArg}`);
+        }
+        return;
+    }
+    // rebuild-index result
+    if ('rebuilt' in obj) {
+        if (obj.dryRun) {
+            // dry-run: handled in rebuild-index case directly, should not reach here
+            console.log(JSON.stringify(obj, null, 2));
+        }
+        else {
+            console.log(`✓ 索引重建完成，共 ${obj.rebuilt} 个话题`);
+        }
+        return;
+    }
+    console.log(JSON.stringify(obj, null, 2));
+}
+export async function runThreadCommand(args) {
+    const jsonFormat = hasFlag(args, '--format') && argValue(args, '--format') === 'json'
+        || hasFlag(args, '--json');
+    const sub = args[0];
+    if (!sub || hasFlag(args, '--help') || hasFlag(args, '-h')) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    const managedSessionId = process.env.EVOLCORE_SESSION_ID;
+    const selfAid = managedSessionId
+        ? (process.env.EVOLCORE_SELF_AID ?? argValue(args, '--self'))
+        : argValue(args, '--self');
+    const commandArgv = canonicalizeEvolcoreCommandArgv(['ec', 'thread', ...args]).slice(1);
+    const sendOp = (req) => sendThreadOp(req, commandArgv);
+    // resolve <ref> → peer + threadId
+    function resolveRef(ref) {
+        if (ref === 'current')
+            return {};
+        const slash = ref.lastIndexOf('/');
+        if (slash < 0)
+            return { peer: ref };
+        return { peer: ref.slice(0, slash), threadId: ref.slice(slash + 1) };
+    }
+    switch (sub) {
+        case 'list': {
+            const peer = args[1]?.startsWith('-') ? undefined : args[1];
+            // peer 是必填参数；不带 peer 没有意义（全量话题跨对端混排，含内部 daemon 话题）
+            if (!peer) {
+                console.error('用法: ec thread list <peer> [选项]\n提示: 用 ec thread peers --self <selfAid> 查看有话题的所有对端');
+                process.exitCode = 1;
+                return;
+            }
+            const statusVal = argValue(args, '--status');
+            // B9: 枚举校验
+            if (statusVal && !TOPIC_STATUSES.includes(statusVal)) {
+                console.error(`✗ 无效状态: ${statusVal}，可选: ${TOPIC_STATUSES.join('|')}`);
+                process.exitCode = 1;
+                return;
+            }
+            const sortVal = argValue(args, '--sort');
+            if (sortVal && !SORT_ORDERS.includes(sortVal)) {
+                console.error(`✗ 无效排序: ${sortVal}，可选: ${SORT_ORDERS.join('|')}`);
+                process.exitCode = 1;
+                return;
+            }
+            const label = argValue(args, '--label');
+            const unlabeled = hasFlag(args, '--unlabeled');
+            const page = argValue(args, '--page') ? Number(argValue(args, '--page')) : undefined;
+            const limit = argValue(args, '--limit') ? Number(argValue(args, '--limit')) : undefined;
+            const resp = await sendOp({ op: 'list', selfAid, peer, status: statusVal, label, unlabeled, sort: sortVal, page, limit });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(resp.result, jsonFormat);
+            break;
+        }
+        case 'show': {
+            const ref = args[1];
+            if (!ref) {
+                console.error('用法: ec thread show <ref>');
+                process.exitCode = 1;
+                return;
+            }
+            const { peer, threadId } = resolveRef(ref);
+            const resp = await sendOp({ op: 'show', selfAid, peer, threadId });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (resp.indexWarning)
+                console.warn(`⚠ ${resp.indexWarning}`);
+            printResult(resp.result, jsonFormat);
+            break;
+        }
+        case 'history': {
+            const ref = args[1];
+            if (!ref) {
+                console.error('用法: ec thread history <ref>');
+                process.exitCode = 1;
+                return;
+            }
+            const { peer, threadId } = resolveRef(ref);
+            const limit = argValue(args, '--limit') ? Number(argValue(args, '--limit')) : undefined;
+            const before = argValue(args, '--before') ? Number(argValue(args, '--before')) : undefined;
+            const after = argValue(args, '--after') ? Number(argValue(args, '--after')) : undefined;
+            // threadId 可选：不传时读主会话（threadId=null）消息，与 show <peer> 行为对齐
+            const resp = await sendOp({ op: 'history', selfAid, peer, threadId, limit, before, after });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(resp.result, jsonFormat);
+            break;
+        }
+        case 'create': {
+            const peer = args[1];
+            if (!peer || peer.startsWith('-')) {
+                console.error('用法: ec thread create <peer> --name "..."');
+                process.exitCode = 1;
+                return;
+            }
+            const name = argValue(args, '--name');
+            if (!name) {
+                console.error('✗ 必须指定 --name');
+                process.exitCode = 1;
+                return;
+            }
+            const label = argValue(args, '--label');
+            const topicStatus = argValue(args, '--status');
+            const peerKind = hasFlag(args, '--group') ? 'group' : 'private';
+            const resp = await sendOp({ op: 'create', selfAid, peer, name, label, topicStatus, peerKind });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(resp.result, jsonFormat);
+            break;
+        }
+        case 'rename': {
+            const ref = args[1];
+            const newName = args[2];
+            if (!ref || newName === undefined) {
+                console.error('用法: ec thread rename <ref> "<名称>"');
+                process.exitCode = 1;
+                return;
+            }
+            // B10: 空字符串应报错而非显示用法
+            if (!newName) {
+                console.error('✗ 名称不能为空');
+                process.exitCode = 1;
+                return;
+            }
+            const { peer, threadId } = resolveRef(ref);
+            const resp = await sendOp({ op: 'rename', selfAid, peer, threadId, name: newName });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(resp.result, jsonFormat);
+            break;
+        }
+        case 'label': {
+            const ref = args[1];
+            if (!ref) {
+                console.error('用法: ec thread label <ref> <标签>');
+                process.exitCode = 1;
+                return;
+            }
+            const { peer, threadId } = resolveRef(ref);
+            const label = hasFlag(args, '--clear') ? null : args[2] ?? null;
+            const resp = await sendOp({ op: 'label', selfAid, peer, threadId, label });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(label === null ? '✓ 标签已清除' : `✓ 标签设为: ${label}`);
+            break;
+        }
+        case 'status': {
+            const ref = args[1];
+            const statusVal = args[2];
+            if (!ref || !statusVal) {
+                console.error('用法: ec thread status <ref> <状态>');
+                process.exitCode = 1;
+                return;
+            }
+            if (!TOPIC_STATUSES.includes(statusVal)) {
+                console.error(`✗ 无效状态: ${statusVal}，可选: ${TOPIC_STATUSES.join('|')}`);
+                process.exitCode = 1;
+                return;
+            }
+            const { peer, threadId } = resolveRef(ref);
+            const resp = await sendOp({ op: 'status', selfAid, peer, threadId, topicStatus: statusVal });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`✓ 状态更新为: ${statusVal}`);
+            break;
+        }
+        case 'rebuild-index': {
+            const aid = argValue(args, '--agent') ?? selfAid;
+            const dryRun = hasFlag(args, '--check');
+            const resp = await sendOp({ op: 'rebuild-index', selfAid: aid, dryRun });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            const r = resp.result;
+            if (dryRun) {
+                if (r.missing === 0 && r.stale === 0) {
+                    console.log(`✓ 索引健康：共 ${r.rebuilt} 条话题，session 文件完整`);
+                }
+                else {
+                    if (r.missing > 0) {
+                        console.warn(`⚠ [严重] ${r.missing} 条话题 session 文件缺失——rebuild 后这些话题的 rename/label/status 改动将回退`);
+                    }
+                    if (r.stale > 0) {
+                        console.warn(`⚠ [轻微] ${r.stale} 条话题属性与 session 文件最后一行不一致（写盘时序），rebuild-index 可修复`);
+                    }
+                    console.warn(`  建议执行 ec thread rebuild-index 修复`);
+                    if (jsonFormat)
+                        console.log(JSON.stringify(r, null, 2));
+                }
+            }
+            else {
+                printResult(resp.result, jsonFormat);
+            }
+            if (resp.indexWarning)
+                console.warn(`⚠ ${resp.indexWarning}`);
+            break;
+        }
+        case 'check-index': {
+            const aid = argValue(args, '--agent') ?? selfAid;
+            const resp = await sendOp({ op: 'check-index', selfAid: aid });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            const r = resp.result;
+            if (r.missing === 0 && r.stale === 0) {
+                console.log(`✓ 索引健康：共 ${r.total} 条话题，session 文件完整`);
+            }
+            else {
+                if (r.missing > 0) {
+                    console.warn(`⚠ [严重] ${r.missing} 条话题 session 文件缺失——rebuild 后这些话题的 rename/label/status 改动将回退`);
+                }
+                if (r.stale > 0) {
+                    console.warn(`⚠ [轻微] ${r.stale} 条话题属性与 session 文件最后一行不一致（写盘时序），rebuild-index 可修复`);
+                }
+                console.warn(`  建议执行 ec thread rebuild-index 修复`);
+                if (jsonFormat)
+                    console.log(JSON.stringify(r, null, 2));
+            }
+            break;
+        }
+        case 'delete': {
+            const ref = args[1];
+            if (!ref) {
+                console.error('用法: ec thread delete <peer>/<threadId>');
+                process.exitCode = 1;
+                return;
+            }
+            const { peer, threadId } = resolveRef(ref);
+            // current ref 允许通过（daemon 侧通过 sessionId 反查）；其他情况必须带 threadId
+            if (ref !== 'current' && !threadId) {
+                console.error('✗ delete 必须指定 threadId（格式: <peer>/<threadId>）');
+                process.exitCode = 1;
+                return;
+            }
+            const resp = await sendOp({ op: 'delete', selfAid, peer, threadId });
+            if (!resp.ok) {
+                console.error(`✗ ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`✓ 话题已删除: ${threadId ?? 'current'}`);
+            break;
+        }
+        case 'summary': {
+            const subCmd = args[1];
+            const ref = args[2];
+            if (!subCmd || !ref) {
+                console.error('用法: ec thread summary <show|set|log|clear> <ref>');
+                process.exitCode = 1;
+                return;
+            }
+            if (subCmd === 'show') {
+                const resp = await sendOp({ op: 'summary-show', selfAid });
+                if (!resp.ok) {
+                    console.error(`✗ ${resp.error}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (!resp.result) {
+                    console.log('（暂无 summary）');
+                }
+                else {
+                    const s = resp.result;
+                    console.log(`rev ${s.rev}  [${new Date(s.updatedAt).toLocaleString('zh-CN')}]`);
+                    console.log(s.content);
+                }
+            }
+            else if (subCmd === 'set') {
+                // B6: extract flags first, then filter all known flags from remaining args to build content.
+                const ifRevRaw = args.includes('--if-rev') ? Number(args[args.indexOf('--if-rev') + 1]) : undefined;
+                const newName = args.includes('--name') ? argValue(args, '--name') : undefined;
+                const KNOWN_FLAGS = new Set(['--if-rev', '--name', '--self', '--as-session', '--format', '--json', '--help', '-h']);
+                const contentArgs = args.slice(3).filter((a, i, arr) => {
+                    if (KNOWN_FLAGS.has(a))
+                        return false;
+                    // drop the value following a known flag
+                    if (i > 0 && KNOWN_FLAGS.has(arr[i - 1]))
+                        return false;
+                    return true;
+                });
+                const content = contentArgs.join(' ');
+                if (!content) {
+                    console.error('✗ 必须提供 summary 内容');
+                    process.exitCode = 1;
+                    return;
+                }
+                // --name 必填：显式表达"这条摘要对应什么标题"，避免默认沿用陈旧名称。
+                // 不想改名时传 `-`（显式意图，比省略更难被忽略）。
+                if (newName === undefined) {
+                    console.error('✗ 必须指定 --name <新标题>');
+                    console.error('  不改名请显式传 --name -');
+                    console.error(`  例: ec thread summary set ${ref} "摘要内容" --name "话题的核心动作"`);
+                    process.exitCode = 1;
+                    return;
+                }
+                // 覆盖游标由 daemon 侧自动记录，无需传参
+                const { peer: setPeer, threadId: setThreadId } = resolveRef(ref);
+                const resp = await sendOp({
+                    op: 'summary-set', selfAid, content, ifRev: ifRevRaw,
+                    ...(setPeer ? { peer: setPeer } : {}),
+                    ...(setThreadId ? { threadId: setThreadId } : {}),
+                    name: newName,
+                });
+                if (!resp.ok) {
+                    console.error(`✗ ${resp.error}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const setRes = resp.result;
+                const cursorNote = setRes?.coveredThroughTs
+                    ? `  覆盖至 ${new Date(setRes.coveredThroughTs).toLocaleString('zh-CN')}`
+                    : '';
+                console.log(`✓ summary 已写入 rev ${setRes?.rev}${cursorNote}`);
+                if (setRes?.renamedTo)
+                    console.log(`✓ 话题已改名: ${setRes.renamedTo}`);
+                if (setRes?.renameError)
+                    console.log(`⚠ 改名失败（摘要已写入）: ${setRes.renameError}`);
+            }
+            else if (subCmd === 'log') {
+                const resp = await sendOp({ op: 'summary-log', selfAid });
+                if (!resp.ok) {
+                    console.error(`✗ ${resp.error}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const entries = resp.result;
+                if (!entries?.length) {
+                    console.log('（暂无历史）');
+                    return;
+                }
+                for (const e of entries) {
+                    console.log(`rev ${e.rev}  [${new Date(e.updatedAt).toLocaleString('zh-CN')}]`);
+                    console.log(e.content);
+                    console.log('');
+                }
+            }
+            else if (subCmd === 'clear') {
+                const resp = await sendOp({ op: 'summary-clear', selfAid });
+                if (!resp.ok) {
+                    console.error(`✗ ${resp.error}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                console.log('✓ summary 已清空（历史版本保留）');
+            }
+            else {
+                console.error(`✗ 未知 summary 子命令: ${subCmd}`);
+                process.exitCode = 1;
+            }
+            break;
+        }
+        default:
+            // peers 子命令：列出当前 agent 有话题记录的所有对端
+            if (sub === 'peers') {
+                if (!selfAid) {
+                    console.error('用法: ec thread peers --self <selfAid>');
+                    process.exitCode = 1;
+                    return;
+                }
+                const resp = await sendOp({ op: 'list-peers', selfAid });
+                if (!resp.ok) {
+                    console.error(`✗ ${resp.error}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const peers = resp.result?.peers ?? [];
+                if (!peers.length) {
+                    console.log('（暂无对端话题记录）');
+                    return;
+                }
+                if (jsonFormat) {
+                    console.log(JSON.stringify(peers, null, 2));
+                    return;
+                }
+                for (const p of peers) {
+                    const kind = p.peerKind === 'group' ? ' [群]' : '';
+                    console.log(`${p.peer}${kind}  话题数:${p.threadCount}  活跃:${new Date(p.lastActiveAt).toLocaleString('zh-CN')}`);
+                }
+                return;
+            }
+            console.error(`✗ 未知子命令: ${sub}`);
+            console.log(HELP_TEXT);
+            process.exitCode = 1;
+    }
+}

package/dist/cli/trigger-command.js

@@ -112,7 +112,7 @@ function printHelp() {
     console.log(`用法: ec trigger <subcommand>
 
 命令:
-  list [--agent <aid>] [--all] [--json]
+  list [--agent <aid>] [--all] [--thread-id <threadId>] [--json]
   show [--agent <aid>] <triggerId> [--json]
   history [--agent <aid>] [triggerId] [--limit <n>] [--json]
   create --exec <script|trigger-session|target-session> --file <trigger.json|trigger-dir> [--enable] [--json]
@@ -176,7 +176,8 @@ Update 参数:
 }
 async function listTriggers(args, json, response) {
     const agentAid = resolveAgentAid(args);
-    const res = response ?? await request({ type: 'trigger.list', agentAid, all: hasFlag(args, '--all') });
+    const threadId = flagValue(args, '--thread-id');
+    const res = response ?? await request({ type: 'trigger.list', agentAid, all: hasFlag(args, '--all'), ...(threadId ? { threadId } : {}) });
     if (json)
         return printJson(res);
     const triggers = res.triggers;
@@ -333,6 +334,7 @@ export async function buildTriggerCreateRequest(args, fileScope, defaultAgentAid
         enabled: hasFlag(args, '--enable'),
         createdAt: now,
         updatedAt: now,
+        ...(parsed.labels ? { labels: parsed.labels } : {}),
         source: sourceFromParsed(parsed),
         execution: {
             type: parsed.executionType,

package/dist/config/builtin-roles.js

@@ -76,6 +76,7 @@ export function getManagementCommandPermissions(role) {
         // Reload is valid from an Agent's own channel and the daemon control plane.
         // The control-channel gate still requires a daemon owner for cross-Agent reloads.
         'agent.reload': { allow: true, dangerous: true, scopes: ['agent', 'control'], constraints: { targetCurrentAgentOnly: true, requireAgentAdmin: true } },
+        'skill.refresh': { allow: true, scopes: ['agent', 'control'], constraints: { targetCurrentAgentOnly: true, requireAgentAdmin: true } },
         'dangerous:*': { allow: true, dangerous: true, constraints: { requireDaemonOwner: true } },
     };
 }

package/dist/config/config-field-policy.js

@@ -3,7 +3,6 @@ const BEHAVIOR_TOP_FIELDS = new Set([
     'chatmode',
     'mentionMode',
     'autoMentionQuietWindowMs',
-    'sessionIdleSec',
     'groupSlashRequireMentions',
     'responseMode',
     'responseModeParams',
@@ -128,8 +127,6 @@ export function resolveConfigFieldRule(fieldPath, scope) {
         return scalar(field, 'mention-mode');
     if (field === 'autoMentionQuietWindowMs')
         return scalar(field, 'nonnegative-number');
-    if (field === 'sessionIdleSec')
-        return scalar(field, 'finite-number');
     if (field === 'groupSlashRequireMentions')
         return scalar(field, 'boolean');
     if (field === 'show_activities')
@@ -142,6 +139,8 @@ export function resolveConfigFieldRule(fieldPath, scope) {
         return scalar('configSnapshots', 'boolean');
     if (field === 'restartRecovery.enabled')
         return scalar('restartRecovery.enabled', 'boolean');
+    if (field === 'skills.watch')
+        return scalar('skills.watch', 'boolean');
     if (top === 'chatmode') {
         if (parts.length === 1)
             return readonlyObject('chatmode');