evolcore 0.0.34 → 0.0.35

package/dist/cli/aun-commands.js

@@ -259,14 +259,18 @@ async function runManagedMsg(args, formatJson) {
         }
     }
     else {
-        if (runtime && (runtime.channel !== 'aun' || runtime.chatType !== 'private')) {
+        // `--thread` 是话题作用域的读取：目标对端由话题推断，数据是本 agent 自己的
+        // 消息日志，因此既不受"当前必须是私聊"限制（群会话里也要能查 A↔C 的话题），
+        // 也不受"只能查当前对端"限制。不带 --thread 时保持原有边界。
+        const threadScoped = parsed.command.kind === 'history' && !!parsed.command.threadId;
+        if (runtime && (runtime.channel !== 'aun' || runtime.chatType !== 'private') && !threadScoped) {
             failManagedGroup(formatJson, 'SCOPE_MISMATCH', 'ec msg history/online 只能读取当前 AUN 私聊关系');
         }
         // owner/admin 可以跨对端读历史（每次查询仍只针对一个对端）。这里只是快速
         // 预检：角色未知时放行交给 daemon 判定，daemon 侧 handleMsgOperation 才是
         // 权威关卡，member 由 currentRelationOnly 约束、visitor 直接拒绝。
         const mayReadCrossPeer = parsed.command.kind === 'history'
-            && (runtime?.peerRole === undefined || isManagementRole(runtime.peerRole));
+            && (threadScoped || runtime?.peerRole === undefined || isManagementRole(runtime.peerRole));
         if (!mayReadCrossPeer && runtime?.channelId && parsed.command.target !== runtime.channelId.replace(/^@/, '')) {
             failManagedGroup(formatJson, 'SCOPE_MISMATCH', `只能读取当前 AUN 私聊对端：${runtime.channelId}`);
         }
@@ -2065,10 +2069,15 @@ Options:
 // ==================== Group ====================
 const GROUP_FROM_AID_FORMAT_EXAMPLE = 'sender.example.invalid';
 const GROUP_AID_FORMAT_EXAMPLE = '12345.example.invalid';
-function printGroupSendAidHint() {
-    console.error('正确格式: ec group send <发送方AID> <真实群AID> <正文或文件参数>');
-    console.error(`仅格式示例（.example.invalid 是保留的虚构域，不是真实 AID）: ec group send ${GROUP_FROM_AID_FORMAT_EXAMPLE} ${GROUP_AID_FORMAT_EXAMPLE} "hello"`);
-    console.error('查询真实群 AID: ec group list <发送方AID>');
+function printGroupArgsHint(sub) {
+    if (sub === 'send') {
+        console.error('正确格式: ec group send <发送方AID> <真实群AID> <正文或文件参数>');
+    }
+    else {
+        console.error(`正确格式: ec group ${sub} <发送方AID> <真实群AID> [选项]`);
+    }
+    console.error(`仅格式示例（.example.invalid 是保留的虚构域，不是真实 AID）: ec group ${sub} ${GROUP_FROM_AID_FORMAT_EXAMPLE} ${GROUP_AID_FORMAT_EXAMPLE}`);
+    console.error('顺序固定为「先发送方 AID，后群 AID」；查询真实群 AID: ec group list <发送方AID>');
 }
 function printGroupRulesUsage() {
     console.log(`用法:
@@ -2173,7 +2182,7 @@ Options:
                         无值时默认 5m；Trigger 名：check-<目标threadId>-from-<来源threadId>-<唯一后缀>
                         取消/调整用返回的 trigger_id（trig_…），show/update/cancel 只认 id
   --trigger-prompt <text> 自定义复查 Trigger prompt 中的用户段（仅 --check-every）
-  --mention <...>       发送时 @ 某个成员。写法固定为单引号包住、逗号分隔多个 aid
+  --mention <...>       发送时 @ 某个成员。单引号包住、逗号分隔多个 aid
                         （如 --mention 'alice.agentid.pub,bob.agentid.pub'），可多次传入
   --mention-all         发送时 @ 所有人
   --content-type <mime> 显式覆盖 MIME（仅 --file 模式）
@@ -2208,13 +2217,28 @@ g- 是名称的一部分，会完整保留；默认命名格式为 g-10000 至 g
         console.error('❌ 缺少 <from-aid> 参数');
         process.exit(1);
     }
+    // 第 1 个位置参数必须是「发送方 AID」。群 ID 与私聊 AID 语法相同，isValidAid
+    // 会放行，随后在加载证书时抛 CERT_NOT_FOUND——这条路径既不说明原因也不给出
+    // 正确写法。因此先用明确的群 ID 形态判定，把"参数写反了"当场指出来。
+    // 例外：invites 是多值标志/邀请列表，第 1 个位置参数不是 from；create/list 的
+    // 形态不同，也在下面各自的用法里处理，这里只拦截"以群 ID 打头"这一种错位。
     const { isValidAid } = await import('../aun/aid/index.js');
+    if (isExplicitGroupId(from)) {
+        const second = args[2];
+        console.error(`❌ 第 1 个位置参数 <from-aid> 无效：收到了群 ID: ${from}`);
+        if (second && isValidAid(second) && !isExplicitGroupId(second)) {
+            console.error(`检测到参数顺序写反了：第 2 个参数 ${second} 才是发送方 AID。`);
+            console.error(`请改成: ec group ${sub} ${second} ${from}` + (sub === 'send' ? ' <正文>' : ''));
+        }
+        else {
+            console.error('当前命令缺少发送方 AID，后续参数发生了错位。');
+        }
+        printGroupArgsHint(sub);
+        process.exit(1);
+    }
     if (!isValidAid(from)) {
         console.error(`❌ 第 1 个位置参数 <from-aid> 无效: ${from}`);
-        if (isExplicitGroupId(from)) {
-            console.error('检测到这里填写的是群 ID；当前命令缺少发送方 AID，后续参数发生了错位。');
-        }
-        printGroupSendAidHint();
+        printGroupArgsHint(sub);
         process.exit(1);
     }
     if ((process.env.EVOLCORE_SESSION_ID || (sub === 'history' && readDelegationCredential())) && sub !== 'send') {
@@ -2286,7 +2310,7 @@ g- 是名称的一部分，会完整保留；默认命名格式为 g-10000 至 g
         const gid = args[2];
         if (!gid) {
             console.error('❌ 缺少第 2 个位置参数 <group-aid>');
-            printGroupSendAidHint();
+            printGroupArgsHint(sub);
             process.exit(1);
         }
         try {
@@ -2294,7 +2318,7 @@ g- 是名称的一部分，会完整保留；默认命名格式为 g-10000 至 g
         }
         catch (error) {
             console.error(`❌ 第 2 个位置参数 <group-aid> 不是有效群 AID: ${gid}: ${error.message}`);
-            printGroupSendAidHint();
+            printGroupArgsHint(sub);
             process.exit(1);
         }
     };

package/dist/cli/daemon-commands.js

@@ -25,7 +25,7 @@ import { isNonAgentSessionChannel } from '../core/system-channels.js';
 import { printCodeStats } from './code-stats.js';
 import { getProcessStartTime, startTimeMatches } from '../utils/process-introspect.js';
 import { AGENT_DELEGATION_TOKEN_ENV, readDelegationCredential } from '../core/auth/agent-delegation.js';
-import { MAIN_CLI_BIN, RUNTIME_HOME_ENV, WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME } from '../product.js';
+import { MAIN_CLI_BIN, RUNTIME_HOME_ENV, TARGET_PACKAGE_ROOT_ENV, WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME, } from '../product.js';
 import { rotateStdoutLog } from '../utils/log-writer.js';
 import { inspectDataMigrationRequirement } from '../core/data-migration.js';
 import { isInitCancelledError, printInitCancelHint } from './init-cancel.js';
@@ -79,7 +79,7 @@ export async function ensureCodexHookBeforeLifecycle(onRepaired) {
             });
         if (!usesCodex)
             return true;
-        const packageRoot = getPackageRoot();
+        const packageRoot = process.env[TARGET_PACKAGE_ROOT_ENV] || getPackageRoot();
         const result = await ensureCodexManagedHook({
             packageRoot,
             repairDecision: state => confirmCodexHookRebind(state, packageRoot),
@@ -328,6 +328,11 @@ async function launchPackageLifecycle(source, log, options = {}) {
     const result = await platform.launchMonitorAndConfirm(args, env, pid => scanInstances().restartMonitors.some(item => item.alive && item.record.pid === pid), pid => scanInstances().restartMonitors.some(item => item.alive && item.record.pid !== pid));
     if (!result.ok && launch.stageDir)
         platform.cleanupMonitorStage(launch.stageDir);
+    if (!result.ok) {
+        for (const line of (result.stderrTail ?? '').split(/\r?\n/).filter(Boolean).slice(-8)) {
+            console.error(`  | ${line}`);
+        }
+    }
     return { ok: result.ok, ...(!result.ok ? { reason: result.reason } : {}) };
 }
 function requireCompletedDataMigration(root) {
@@ -3304,12 +3309,13 @@ export async function cmdDiagnose(args = []) {
             console.log('[diagnose] - Codex managed hook: 跳过（没有 Agent 使用 Codex）');
         }
         else {
-            const hook = inspectCodexManagedHook({ packageRoot: getPackageRoot() });
+            const packageRoot = process.env[TARGET_PACKAGE_ROOT_ENV] || getPackageRoot();
+            const hook = inspectCodexManagedHook({ packageRoot });
             if (hook.status === 'installed') {
                 console.log(`[diagnose] ✓ Codex managed hook 已安装: ${hook.hookPath}`);
                 if (runHookLaunchProbe) {
                     try {
-                        const launch = runCodexHookLaunchDiagnostic({ packageRoot: getPackageRoot() });
+                        const launch = runCodexHookLaunchDiagnostic({ packageRoot });
                         if (launch.status === 'ok') {
                             console.log('[diagnose] ✓ Codex managed hook 启动探针报告: ' + launch.output);
                             for (const result of launch.results) {

package/dist/cli/fs-command.js

@@ -56,7 +56,7 @@ Options:
   --content-type <mime>           上传时指定内容类型
   --public                        上传后公开可读（personal storage）
   --visibility <public|private>   chmod 可见性
-  --allow-roles <roles>           chmod 角色约束，写法固定为单引号包住、逗号分隔，
+  --allow-roles <roles>           chmod 角色约束，单引号包住、逗号分隔，
                                   如 --allow-roles 'owner,admin'
   -m aid:<aid>:<perms>            setfacl 新增/更新 ACL
   -x aid:<aid>                    setfacl 移除 ACL

package/dist/cli/getmeta-command.js

@@ -0,0 +1,211 @@
+import path from 'path';
+import fs from 'fs';
+import { resolvePaths, agentThreadIndexPath } from '../paths.js';
+import { scanChatDirs, readLastJsonlLine, } from '../core/session/session-fs-store.js';
+const HELP_TEXT = `
+ec getmeta <id> [选项]
+
+按任意一种会话标识查询本地会话的完整元数据（不经过 daemon，直接读存档）。
+
+<id> 接受三种形态:
+  meta_YYYYMMDD_<ts>   ec 会话 id（meta 文件名）
+  thread-<...>         话题 id（threadId）
+  <uuid>               provider 侧会话 id（agentSessionId）
+
+输出字段:
+  sessionId / threadId / agentSessionId / peer / selfAID / baseagent
+  name / chatType / projectPath / updatedAt / metaFile
+  source              命中位置：meta（主会话）/ thread（话题）/ active / trash
+  indexed             该会话是否登记在话题索引里
+
+选项:
+  --self <aid>         只扫描指定 agent，减少全量扫描开销
+  --format json        以 JSON 格式输出
+`.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);
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 该 agent 的话题索引里是否登记了 (peer, threadId, sessionId)。 */
+function isIndexed(selfAID, peer, threadId, sessionId) {
+    if (!selfAID)
+        return false;
+    const raw = readJsonFile(agentThreadIndexPath(selfAID));
+    if (!raw?.threads)
+        return false;
+    return raw.threads.some(t => (t.sessionId === sessionId
+        && (t.threadId ?? '') === threadId
+        && (peer == null || t.peer === peer)));
+}
+function makeHit(meta, metaFile, source, selfAID, chatPeer) {
+    const threadId = meta.threadId ?? '';
+    return {
+        sessionId: meta.id,
+        threadId,
+        agentSessionId: meta.agentSessionId ?? null,
+        peer: meta.channelId ?? chatPeer ?? null,
+        selfAID: meta.selfAID ?? selfAID,
+        baseagent: meta.baseagent ?? null,
+        name: meta.name ?? null,
+        chatType: meta.chatType ?? null,
+        projectPath: meta.projectPath ?? null,
+        updatedAt: meta.updatedAt ?? null,
+        updatedAtStr: meta.updatedAtStr ?? null,
+        createdAtStr: meta.createdAtStr ?? null,
+        metaFile,
+        source,
+        indexed: isIndexed(meta.selfAID ?? selfAID, meta.channelId ?? chatPeer ?? null, threadId, meta.id),
+    };
+}
+/**
+ * id 形态判定。
+ * - `meta_...` 按文件名直接命中，不读文件内容
+ * - `thread-...` / uuid 需要扫末行比对，成本高但只在必要时发生
+ */
+function classifyId(id) {
+    if (id.startsWith('meta_'))
+        return 'session';
+    if (id.startsWith('thread-'))
+        return 'thread';
+    return 'agentSession';
+}
+async function cmdGetMeta(args) {
+    const jsonFormat = hasFlag(args, '--format') && argValue(args, '--format') === 'json'
+        || hasFlag(args, '--json');
+    // 位置参数 = 第一个不是 flag、也不属于任何 flag 取值的参数。
+    // 不能简单取"首个非 - 开头"，否则 `--self <aid>` 的值会被当成 id。
+    const VALUE_FLAGS = new Set(['--self', '--format']);
+    let rawId;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith('-')) {
+            if (VALUE_FLAGS.has(a))
+                i++;
+            continue;
+        }
+        rawId = a;
+        break;
+    }
+    if (!rawId) {
+        console.error('用法: ec getmeta <sessionId|threadId|agentSessionId> [--self <aid>] [--format json]');
+        process.exitCode = 1;
+        return;
+    }
+    const id = rawId.endsWith('.jsonl') ? rawId.slice(0, -'.jsonl'.length) : rawId;
+    const selfFilter = argValue(args, '--self');
+    const kind = classifyId(id);
+    const p = resolvePaths();
+    const chatDirs = scanChatDirs(p.sessionsDir).filter(c => !selfFilter || c.selfAID === selfFilter);
+    const hits = [];
+    for (const chat of chatDirs) {
+        // 主会话 meta 在目录根，话题在 _threads/，已删除话题在 _trash/
+        const locations = [
+            { dir: chat.dirPath, source: 'meta' },
+            { dir: path.join(chat.dirPath, '_threads'), source: 'thread' },
+            { dir: path.join(chat.dirPath, '_trash'), source: 'trash' },
+        ];
+        for (const loc of locations) {
+            let entries;
+            try {
+                entries = fs.readdirSync(loc.dir);
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.endsWith('.jsonl') || entry.includes('.fork-history'))
+                    continue;
+                const entryId = entry.slice(0, -'.jsonl'.length);
+                // 文件名直接命中时只读这一个文件；否则必须读末行比对
+                if (kind === 'session' && entryId !== id)
+                    continue;
+                const filePath = path.join(loc.dir, entry);
+                const meta = readLastJsonlLine(filePath);
+                if (!meta)
+                    continue;
+                if (kind === 'thread' && (meta.threadId ?? '') !== id)
+                    continue;
+                if (kind === 'agentSession' && (meta.agentSessionId ?? '') !== id)
+                    continue;
+                if (kind === 'session' && meta.id !== id && entryId !== id)
+                    continue;
+                hits.push(makeHit(meta, filePath, loc.source, chat.selfAID, chat.channelId));
+            }
+        }
+    }
+    // 兜底：active.json 的 id/threadId/agentSessionId 也可能命中（active 是 meta 的最新快照）
+    if (hits.length === 0) {
+        for (const chat of chatDirs) {
+            const active = readJsonFile(path.join(chat.dirPath, 'active.json'));
+            if (!active)
+                continue;
+            const match = kind === 'session'
+                ? active.id === id
+                : kind === 'thread'
+                    ? (active.threadId ?? '') === id
+                    : (active.agentSessionId ?? '') === id;
+            if (!match)
+                continue;
+            hits.push(makeHit(active, path.join(chat.dirPath, 'active.json'), 'active', chat.selfAID, chat.channelId));
+        }
+    }
+    if (hits.length === 0) {
+        if (jsonFormat) {
+            console.log(JSON.stringify({ ok: false, id, kind, hits: [] }, null, 2));
+        }
+        else {
+            console.error(`✗ 未找到会话 ${id}（${kind === 'session' ? 'ec 会话 id' : kind === 'thread' ? '话题 id' : 'provider 会话 id'}；已扫描 ${chatDirs.length} 个 chat 目录）`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    if (jsonFormat) {
+        console.log(JSON.stringify({ ok: true, id, kind, hits }, null, 2));
+        return;
+    }
+    const sourceLabel = {
+        meta: '主会话 meta 文件',
+        thread: '话题 meta 文件',
+        active: 'active.json 快照',
+        trash: '已删除（_trash）',
+    };
+    for (const h of hits) {
+        console.log(`会话 id: ${h.sessionId}`);
+        console.log(`  话题 id: ${h.threadId || '(主会话)'}`);
+        console.log(`  provider 会话: ${h.agentSessionId ?? '(空)'}`);
+        console.log(`  来源: ${sourceLabel[h.source]}${h.source === 'trash' ? '  ⚠ 话题已删除' : ''}`);
+        console.log(`  索引: ${h.indexed ? '已登记' : '未登记（仅磁盘存档）'}`);
+        console.log(`  名称: ${h.name ?? '(未命名)'}`);
+        if (h.chatType)
+            console.log(`  类型: ${h.chatType === 'group' ? '群聊' : '单聊'}`);
+        console.log(`  对端: ${h.peer ?? ''}`);
+        console.log(`  本端 AID: ${h.selfAID ?? ''}`);
+        if (h.baseagent)
+            console.log(`  基座: ${h.baseagent}`);
+        if (h.projectPath)
+            console.log(`  项目: ${h.projectPath}`);
+        if (h.updatedAtStr)
+            console.log(`  最近更新: ${h.updatedAtStr}`);
+        console.log(`  文件: ${h.metaFile}`);
+        console.log('');
+    }
+}
+export async function runGetMetaCommand(args) {
+    const sub = args[0];
+    if (!sub || sub === 'help' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    await cmdGetMeta(args);
+}

package/dist/cli/index.js

@@ -37,6 +37,7 @@ Agent 与会话:
   ctl               当前托管会话的控制命令
   queue             查询或操作 agent 消息队列
   session           按 ec 会话 id 查询本地 session 存档（含 agentSessionId）
+  getmeta           按会话 id / threadId / agentSessionId 查询会话元数据
   task              恢复暂停或异常中断的会话任务
   trigger           管理定时与事件触发器
   handoff           查询和完成跨会话回流
@@ -449,6 +450,11 @@ export async function main(args) {
             await runSessionCommand(strippedArgs.slice(1));
             break;
         }
+        case 'getmeta': {
+            const { runGetMetaCommand } = await import('./getmeta-command.js');
+            await runGetMetaCommand(strippedArgs.slice(1));
+            break;
+        }
         case 'group': {
             const { suppressSdkLogs } = await import('../aun/aid/index.js');
             suppressSdkLogs();

package/dist/cli/managed-command-guard.js

@@ -21,6 +21,9 @@ const MANAGED_TASK_COMMANDS = new Set([
     // `session` 按 ec 会话 id 只读查询本地 session 存档（meta 文件尾行的
     // agentSessionId 等），不触碰 daemon 与进程生命周期。
     'session',
+    // `getmeta` 按 ec 会话 id / threadId / agentSessionId 之一只读查询本地
+    // 会话存档，同样不触碰 daemon 与进程生命周期。
+    'getmeta',
     // `skill` 管理 EC 技能（安装/开关/校验）。它的主要使用者就是 agent 自己——
     // ec-skill 技能的 SKILL.md 明确指导 agent 调用它。脚本只读写
     // `thread` 提供话题链操作，通过 thread.op IPC 鉴权

package/dist/cli/memory-command.js

@@ -11,6 +11,7 @@
  * 整理会话（sessionType=memory）另有 create / update / archive 三个写命令，
  * 实现见 core/memory/memory-writer.ts，在这里只做 CLI 分发与权限委托。
  */
+import fs from 'node:fs';
 import { resolvePaths } from '../paths.js';
 import { ipcQuery } from '../ipc.js';
 import { isHelpFlag, wantsHelp, getArgValue } from './help.js';
@@ -32,8 +33,8 @@ ec memory note --slug <slug> [--tags '<tag1>,<tag2>'] '<content>'
 
 选项:
   --slug <slug>      文件名标识，字母/数字/连字符，长度 1-64（必填）
-  --tags <...>       标签列表，写法固定为单引号包住、逗号分隔；取值见 \$KITS_DOCS/evolcore/memory-tags.md
-  --speakers <...>   群聊专用：本条 note 涉及的发言人，写法固定为单引号包住、逗号分隔，
+  --tags <...>       标签列表，单引号包住、逗号分隔；取值见 \$KITS_DOCS/evolcore/memory-tags.md
+  --speakers <...>   群聊专用：本条 note 涉及的发言人，单引号包住、逗号分隔，
                      如 --speakers '<aid1>,<aid2>'；
                      整理会话据此把发言人信息分流写入各自的 relation 记忆
 
@@ -119,7 +120,13 @@ function assertFormatValues(args) {
     });
 }
 /**
- * 解析 `--key value` 与位置参数。未识别的 `--xxx` 一律报错，避免静默忽略。
+ * 解析 `--key value` 与位置参数。
+ *
+ * flag 判定采用**精确匹配已知 flag 集合**，而非 `startsWith('--')`——正文是自由
+ * 文本，可能以 `--` 开头（如「--as-session 通道测试」），把它当未知参数拒绝会让
+ * 正文受命令行位置影响。不在已知集合里的 token 一律按正文处理。
+ *
+ * 另支持 POSIX `--` end-of-options：其后所有 token 无条件按正文。
  */
 function parseArgs(args, known) {
     assertFormatValues(args);
@@ -127,10 +134,12 @@ function parseArgs(args, known) {
     const positional = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if (a.startsWith('--')) {
-            if (!COMMON_FLAGS.includes(a) && !known.includes(a))
-                throw new Error(`未知参数: ${a}`);
-            if (i + 1 >= args.length || args[i + 1].startsWith('--')) {
+        if (a === '--') {
+            positional.push(...args.slice(i + 1));
+            break;
+        }
+        if (COMMON_FLAGS.includes(a) || known.includes(a)) {
+            if (i + 1 >= args.length || args[i + 1] === '--' || isKnownFlagToken(args[i + 1], known)) {
                 // --touch 这类布尔开关不带值
                 flags.set(a, '');
                 continue;
@@ -143,6 +152,9 @@ function parseArgs(args, known) {
     }
     return { flags, positional };
 }
+function isKnownFlagToken(token, known) {
+    return COMMON_FLAGS.includes(token) || known.includes(token);
+}
 function parseTags(raw) {
     if (raw === undefined)
         return undefined;
@@ -262,22 +274,41 @@ function parseCliArgs(args, known, json) {
  * 否则读 EVOLCORE_SESSION_ID。
  */
 function requireManagedSession(cmd, flags, json) {
-    const debugSessionId = flags.get('--debug');
-    if (flags.has('--debug') && !debugSessionId) {
+    const explicitDebugSessionId = flags.get('--debug');
+    if (flags.has('--debug') && !explicitDebugSessionId) {
         fail(json, 'INVALID_ARGUMENT', '--debug 需要提供 sessionId（如 --debug meta_20260910_1789013149542）');
     }
-    const sessionId = debugSessionId || process.env.EVOLCORE_SESSION_ID;
+    // `ec … --as-session <id>` 由 debug-mode.ts 在进程启动时注入会话环境，
+    // 与 `--debug <id>` 是同一种调试身份。判据：注入了 delegation token、
+    // 但来自从属会话的 daemon runtime epoch，这是 debug-issue-token 的固定形态
+    // （真正的托管任务两者都有）。两者都必须走 daemon 的 debug 分支：
+    // 该分支只认本地 control token，不接受 task delegation。
+    const asSessionDebug = !explicitDebugSessionId
+        && !!process.env.EVOLCORE_SESSION_ID
+        && !!readDelegationCredential()
+        && !process.env.EVOLCORE_DAEMON_RUNTIME_EPOCH;
+    const debugMode = !!explicitDebugSessionId || asSessionDebug;
+    const sessionId = explicitDebugSessionId || process.env.EVOLCORE_SESSION_ID;
     if (!sessionId) {
-        const message = `EVOLCORE_SESSION_ID 未设置（${cmd} 仅在 evolcore 托管环境中可用；调试可加 --debug <sessionId>）`;
+        const message = `EVOLCORE_SESSION_ID 未设置（${cmd} 仅在 evolcore 托管环境中可用；调试可加 --debug <sessionId> 或 --as-session <sessionId>）`;
         fail(json, 'NO_SESSION', message, { text: `错误: ${message}` });
     }
-    if (debugSessionId)
-        console.error(`[debug] 模拟会话 ${debugSessionId}`);
+    if (explicitDebugSessionId)
+        console.error(`[debug] 模拟会话 ${explicitDebugSessionId}`);
+    else if (asSessionDebug)
+        console.error(`[debug] --as-session 会话 ${sessionId}`);
+    let controlToken;
+    if (debugMode) {
+        try {
+            controlToken = fs.readFileSync(resolvePaths().controlToken, 'utf8').trim() || undefined;
+        }
+        catch { /* 交给 daemon 报错 */ }
+    }
     return {
         sessionId,
         socketPath: resolvePaths().socket,
-        delegationToken: readDelegationCredential(),
-        ...(debugSessionId ? { debug: true } : {}),
+        // debug 身份必须用 control token；带 delegationToken 会被 daemon 直接拒绝
+        ...(debugMode ? { controlToken, debug: true } : { delegationToken: readDelegationCredential() }),
     };
 }
 // ── note ───────────────────────────────────────────────────────────────────

package/dist/cli/thread-command.js

@@ -128,9 +128,13 @@ function printItem(item) {
         const running = obj.running ? ' [运行中]' : '';
         // 内部话题（daemon 会话记录）不是真实联系人，标注出来避免误认
         const internal = obj.internal ? ' [内部会话记录·无消息]' : '';
-        console.log(`${obj.peer}/${obj.threadId}${running}${internal}`);
-        // 名称只放名称本身：状态、标签各自单独一行，避免污染标题（标题会被 summary set --name 引用）
-        console.log(`  名称: ${obj.name}`);
+        // 主会话的 threadId 是空串；显示成 /main 比留一个空尾巴好读。
+        console.log(`${obj.peer}/${obj.threadId || 'main'}${running}${internal}`);
+        // 名称只放名称本身：状态、标签各自单独一行，避免污染标题（标题会被 summary set --name 引用）。
+        // 主会话（threadId 为空）加 `[主会话]` 前缀，与普通话题区分开；前缀只在展示层加，
+        // 不进索引与 session 的 name 字段，避免被 summary set --name 当成真实标题。
+        const namePrefix = obj.threadId ? '' : '[主会话] ';
+        console.log(`  名称: ${namePrefix}${obj.name}`);
         if (obj.topicStatus)
             console.log(`  状态: ${obj.topicStatus}`);
         if (obj.label)
@@ -230,7 +234,11 @@ export async function runThreadCommand(args) {
         const slash = ref.lastIndexOf('/');
         if (slash < 0)
             return { peer: ref };
-        return { peer: ref.slice(0, slash), threadId: ref.slice(slash + 1) };
+        const raw = ref.slice(slash + 1);
+        // 主会话的 threadId 是空串；`<peer>/main` 是同义写法，`list` 也这样显示。
+        if (raw === 'main')
+            return { peer: ref.slice(0, slash), threadId: '' };
+        return { peer: ref.slice(0, slash), threadId: raw };
     }
     switch (sub) {
         case 'list': {

package/dist/config/resolved-config-op.js

@@ -208,7 +208,10 @@ function resolveFieldCommand(argv, subcommand, options = {}) {
         else {
             if (!route)
                 return { ok: false, code: 'UNKNOWN_FIELD', reason: `Unknown config field: ${field}` };
-            value = coerceConfigValue(rawValue, route);
+            const coerced = coerceConfigValue(rawValue, route, field);
+            if (!coerced.ok)
+                return { ok: false, code: 'INVALID_CONFIG_VALUE', reason: coerced.reason };
+            value = coerced.value;
         }
     }
     return {
@@ -506,18 +509,32 @@ function buildGlobalCanonicalArgv(command) {
         argv.push('--format', command.format);
     return argv;
 }
-function coerceConfigValue(raw, route) {
+function coerceConfigValue(raw, route, field) {
     if (route.merge === 'list')
-        return [raw];
+        return { ok: true, value: [raw] };
     if (route.enum)
-        return raw;
+        return { ok: true, value: raw };
+    if (route.merge === 'dict' && field === route.field) {
+        const trimmed = raw.trim();
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return { ok: false, reason: `Config field ${route.field} requires a JSON object value` };
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return { ok: false, reason: `Config field ${route.field} requires a JSON object value` };
+        }
+        return { ok: true, value: parsed };
+    }
     if (raw === 'true')
-        return true;
+        return { ok: true, value: true };
     if (raw === 'false')
-        return false;
+        return { ok: true, value: false };
     if (/^-?\d+(\.\d+)?$/.test(raw))
-        return Number(raw);
-    return raw;
+        return { ok: true, value: Number(raw) };
+    return { ok: true, value: raw };
 }
 function parseOwnersValue(raw) {
     let values;

package/dist/core/auth/operation-authorizer.js

@@ -331,14 +331,21 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
         };
     }
     let matchResult = matchCommandPermission(operation, opMeta.category, roleDef.commandPermissions || {}, opMeta.dangerous);
+    // `ec.thread.*` 是 agent-tool 专用的自数据操作：索引、会话、摘要都在
+    // `agents/<self>/data/threads/` 下，目标对端只是数据条目，不是访问边界。
+    // 因此只继承 `session.topic.list` 的"读"授权，不继承它的 currentRelationOnly /
+    // ownPeerOnly —— 那两条针对的是"当前关系下的会话视图"（menu/slash 场景），
+    // 套到话题链上会让 member 无法发现任何第三方话题。
     if (!matchResult && operation.startsWith('ec.thread.') && opMeta.category === 'read' && intent.scope === 'relation') {
         const permission = roleDef.commandPermissions?.['session.topic.list'];
-        if (permission?.allow)
+        if (permission?.allow) {
+            const { currentRelationOnly: _relOnly, ownPeerOnly: _ownPeer, ...restConstraints } = permission.constraints ?? {};
             matchResult = {
-                permission: { ...permission, scopes: ['relation'], constraints: { ...permission.constraints, currentRelationOnly: true, targetCurrentAgentOnly: true } },
+                permission: { ...permission, scopes: ['relation'], constraints: { ...restConstraints, targetCurrentAgentOnly: true } },
                 matchedRule: 'session.topic.list',
                 rank: 1000,
             };
+        }
     }
     // Agent self-service contact add deliberately reuses the same low-trust
     // relation boundary as ec.msg.send. Older per-Agent role files may still
@@ -768,6 +775,10 @@ function checkCurrentRelation(ctx, resolvedConfigCommand) {
     if (!ctx.selfAid || !requestedSelf || requestedSelf !== ctx.selfAid) {
         return { ok: false, reason: 'Only the current agent relation can be targeted' };
     }
+    // 话题作用域的历史读取（`ec msg history --thread <id>`）目标是话题本身，
+    // 不是当前关系的对端；消息日志仍落在调用方自己的会话目录里，因此不比对对端。
+    if (ctx.intent.operation === 'ec.msg.history' && stringArg(ctx.intent.args.threadId))
+        return { ok: true };
     const requestedPeer = resolvedConfigCommand?.peerKey || stringArg(ctx.intent.args.peerKey) || stringArg(ctx.intent.args.peer);
     if (!ctx.peerKey || !requestedPeer) {
         return { ok: false, reason: 'Current relation context is required' };
@@ -917,6 +928,14 @@ function checkOwnPeer(ctx) {
     const isMsgSend = ctx.intent.operation === 'ec.msg.send' || ctx.intent.operation === 'ec.msg.file';
     if (isMsgSend)
         return { ok: true };
+    // Same reasoning for `ec.thread.*`: args.peer is the *indexed peer whose local
+    // thread data is being read or written*. All of it lives under
+    // `agents/<self>/data/threads/`, so targeting a peer other than the current
+    // relation's counterpart does not cross a data boundary — it is the whole
+    // point of cross-topic routing. Ownership of the data stays with the caller,
+    // which `targetCurrentAgentOnly` already covers.
+    if (ctx.intent.operation.startsWith('ec.thread.'))
+        return { ok: true };
     if (ctx.actorId) {
         if (requestedPeerId && requestedPeerId !== ctx.actorId) {
             return { ok: false, reason: ownPeerOnlyDenialReason(ctx, requestedPeerId) };

package/dist/core/channel-runtime.js

@@ -390,7 +390,7 @@ export function wrapChannelSend(inst, dependencies) {
                             from: owningAgent?.aid ?? envelope.agentName ?? session.selfAID ?? 'self',
                             to: String(target || envelope.channelId),
                             sessionId: session.id,
-                            threadId: envelope.replyContext?.threadId || session.threadId || null,
+                            threadId: envelope.replyContext?.threadId || session.threadId || '',
                             chatType: isGroup ? 'group' : 'private',
                             groupId: isGroup ? String(session.metadata?.groupId || session.channelId) : null,
                             msgId: `${envelope.taskId || 'out'}_${Date.now()}`,