evolcore 0.0.33 → 0.0.35-test.0

package/dist/cli/memory-command.js

@@ -11,9 +11,10 @@
  * 整理会话（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 } from './help.js';
+import { isHelpFlag, wantsHelp, getArgValue } from './help.js';
 import { readDelegationCredential } from '../core/auth/agent-delegation.js';
 import { canonicalizeEvolcoreCommandArgv } from '../core/permission/ec-command-parser.js';
 import { formatQueueDetails } from '../core/memory/consolidation-queue-format.js';
@@ -28,20 +29,23 @@ const MEMORY_HELP = `用法: ec memory <command> [选项]
   demote       把记忆降级回上一层（agent→relation，owner→agent）
   consolidate  触发记忆整理（启动整理会话）
 
-ec memory note --slug <slug> [--tags <tag1,tag2,...>] <content>
+ec memory note --slug <slug> [--tags '<tag1>,<tag2>'] '<content>'
 
 选项:
   --slug <slug>      文件名标识，字母/数字/连字符，长度 1-64（必填）
-  --tags <...>       标签列表，逗号分隔；取值见 \$KITS_DOCS/evolcore/memory-tags.md
+  --tags <...>       标签列表，单引号包住、逗号分隔；取值见 \$KITS_DOCS/evolcore/memory-tags.md
+  --speakers <...>   群聊专用：本条 note 涉及的发言人，单引号包住、逗号分隔，
+                     如 --speakers '<aid1>,<aid2>'；
+                     整理会话据此把发言人信息分流写入各自的 relation 记忆
 
-ec memory note update <slug> [--slug <新slug>] [--tags <...>] [<content>]
+ec memory note update <slug> [--slug <新slug>] [--tags '<tag1>,<tag2>'] ['<content>']
 ec memory note drop <slug>
 ec memory note list
 
-ec memory create --scope <relation|agent|owner> --slug <slug> --desc <description> \\
-    --tags <...> [--keywords <...>] [--replaces <path,...>] <content>
+ec memory create --scope <relation|agent|owner> --slug <slug> --desc '<description>' \\
+    --tags '<tag1>,<tag2>' [--keywords '<kw1>,<kw2>'] [--replaces '<path1>,<path2>'] '<content>'
 
-ec memory update <path> [--tags <...>] [--touch]
+ec memory update <path> [--tags '<tag1>,<tag2>'] [--touch]
 
 ec memory archive <path...>
 
@@ -51,18 +55,21 @@ ec memory consolidate [--mode <notes|generalize|promote|profile|forget>]
   --mode              整理模式（默认 notes）
 
 公共选项（所有子命令）:
+  --format json       以 JSON 格式输出：成功时输出 daemon 返回的结果对象，
+                      失败时输出 { ok: false, code, error }，均写到 stdout
   --debug <sessionId> 在宿主终端模拟该会话的托管环境（仅开发仓 daemon 支持）；
                       会话没有运行中任务时，daemon 从会话文件重建运行时上下文
 
 示例:
-  ec memory note --slug commit-convention --tags "rule,long-term" "commit 消息必须用中文"
-  ec memory note update commit-convention --tags "rule,done" "commit 消息必须用中文"
+  ec memory note --slug commit-convention --tags 'rule,long-term' 'commit 消息必须用中文'
+  ec memory note update commit-convention --tags 'rule,done' 'commit 消息必须用中文'
   ec memory note drop commit-convention
   ec memory note list
+  ec memory note list --format json
   ec memory consolidate
   ec memory consolidate --mode promote
-  ec memory create --scope relation --slug profile --desc "对端画像" --tags "profile" --replaces consolidated/profile.md "（画像正文）"
-  ec memory update consolidated/commit-convention.md --tags "rule,done"
+  ec memory create --scope relation --slug profile --desc '对端画像' --tags 'profile' --replaces consolidated/profile.md '（画像正文）'
+  ec memory update consolidated/commit-convention.md --tags 'rule,done'
   ec memory archive consolidated/obsolete.md`;
 export async function cmdMemory(args) {
     args = canonicalizeEvolcoreCommandArgv(['ec', 'memory', ...args]).slice(2);
@@ -70,51 +77,69 @@ export async function cmdMemory(args) {
         console.log(MEMORY_HELP);
         return;
     }
+    // --format 的取值先于一切校验：后续任何报错都要按它决定输出 JSON 还是文本
+    try {
+        assertFormatValues(args);
+    }
+    catch (e) {
+        console.error(`❌ ${e.message}`);
+        process.exit(1);
+    }
+    const json = getArgValue(args, '--format') === 'json';
     const sub = args[0];
     if (sub === 'note') {
-        await cmdMemoryNote(args.slice(1));
+        await cmdMemoryNote(args.slice(1), json);
     }
     else if (sub === 'consolidate') {
-        await cmdMemoryConsolidate(args.slice(1));
+        await cmdMemoryConsolidate(args.slice(1), json);
     }
     else if (sub === 'create') {
-        await cmdMemoryCreate(args.slice(1));
+        await cmdMemoryCreate(args.slice(1), json);
     }
     else if (sub === 'update') {
-        await cmdMemoryConsolidatedUpdate(args.slice(1));
+        await cmdMemoryConsolidatedUpdate(args.slice(1), json);
     }
     else if (sub === 'archive') {
-        await cmdMemoryArchive(args.slice(1));
+        await cmdMemoryArchive(args.slice(1), json);
     }
     else if (sub === 'demote') {
-        await cmdMemoryDemote(args.slice(1));
-    }
-    else if (sub === 'feedback') {
-        await cmdMemoryFeedback(args.slice(1));
+        await cmdMemoryDemote(args.slice(1), json);
     }
     else {
-        console.error(`❌ 未知子命令: ${sub}`);
-        console.error(MEMORY_HELP);
-        process.exit(1);
+        fail(json, 'INVALID_ARGUMENT', `未知子命令: ${sub}`, { text: `❌ 未知子命令: ${sub}\n${MEMORY_HELP}` });
     }
 }
+/** 所有子命令都认的公共参数，不用每处声明。 */
+const COMMON_FLAGS = ['--debug', '--format'];
+/** `--format` 只支持 json；每次出现都检查，避免重复给出时 CLI 与 daemon 各取一个值。 */
+function assertFormatValues(args) {
+    args.forEach((a, i) => {
+        if (a === '--format' && args[i + 1] !== 'json') {
+            throw new Error(`--format 仅支持 json: ${args[i + 1] ?? '（缺少取值）'}`);
+        }
+    });
+}
 /**
- * 解析 `--key value` 与位置参数。未识别的 `--xxx` 一律报错，避免静默忽略。
- * `--debug <sessionId>` 是所有子命令的公共参数，不用每处声明。
+ * 解析 `--key value` 与位置参数。
+ *
+ * flag 判定采用**精确匹配已知 flag 集合**，而非 `startsWith('--')`——正文是自由
+ * 文本，可能以 `--` 开头（如「--as-session 通道测试」），把它当未知参数拒绝会让
+ * 正文受命令行位置影响。不在已知集合里的 token 一律按正文处理。
+ *
+ * 另支持 POSIX `--` end-of-options：其后所有 token 无条件按正文。
  */
-function parseArgs(args, known, throwOnUnknown = false) {
+function parseArgs(args, known) {
+    assertFormatValues(args);
     const flags = new Map();
     const positional = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if (a.startsWith('--')) {
-            if (a !== '--debug' && !known.includes(a)) {
-                if (throwOnUnknown)
-                    throw new Error(`未知参数: ${a}`);
-                console.error(`❌ 未知参数: ${a}`);
-                process.exit(1);
-            }
-            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;
@@ -127,6 +152,9 @@ function parseArgs(args, known, throwOnUnknown = false) {
     }
     return { flags, positional };
 }
+function isKnownFlagToken(token, known) {
+    return COMMON_FLAGS.includes(token) || known.includes(token);
+}
 function parseTags(raw) {
     if (raw === undefined)
         return undefined;
@@ -141,11 +169,15 @@ export function resolveMemoryCommandArgv(argv) {
     const known = {
         note: ['--slug', '--tags', '--speakers'], 'note.update': ['--slug', '--tags'],
         'note.drop': [], 'note.list': [], create: ['--scope', '--slug', '--desc', '--tags', '--keywords', '--replaces', '--peer'],
-        update: ['--tags', '--touch'], archive: [], demote: ['--scope'], consolidate: ['--mode'], feedback: [],
+        update: ['--tags', '--touch'], archive: [], demote: ['--scope'], consolidate: ['--mode'],
     };
+    // feedback 已移除：旧会话/旧文档可能还在调用，给一句能照做的说明而不是泛化的非法命令。
+    if (kind === 'feedback') {
+        throw new Error('`ec memory feedback` 已移除：整理反馈由会话直接写入任务书给出的反馈文件');
+    }
     if (!Object.prototype.hasOwnProperty.call(known, kind))
         throw new Error('Invalid memory command');
-    const { flags, positional } = parseArgs(argv.slice(noteSub ? 3 : 2), known[kind], true);
+    const { flags, positional } = parseArgs(argv.slice(noteSub ? 3 : 2), known[kind]);
     const required = (value, name) => {
         if (!value)
             throw new Error(`${name} is required`);
@@ -201,124 +233,162 @@ export function resolveMemoryCommandArgv(argv) {
             throw new Error('Invalid consolidation mode');
         return { type, mode };
     }
-    return { type, text: required(content, 'feedback') };
+    throw new Error(`Unhandled memory command kind: ${kind}`);
 }
 /** 各子命令的一行完整用法：缺参报错时附上，模型照抄即可重试。 */
 const USAGE = {
-    note: 'ec memory note --slug <slug> [--tags <tag1,tag2>] [--speakers <aid1,aid2>] "<正文>"',
-    noteUpdate: 'ec memory note update <slug> [--slug <新slug>] [--tags <...>] ["<新正文>"]',
+    note: "ec memory note --slug <slug> [--tags '<tag1>,<tag2>'] [--speakers '<aid1>,<aid2>'] '<正文>'",
+    noteUpdate: "ec memory note update <slug> [--slug <新slug>] [--tags '<tag1>,<tag2>'] ['<新正文>']",
     noteDrop: 'ec memory note drop <slug>',
-    create: 'ec memory create --scope <relation|agent|owner> --slug <slug> --desc "<描述>" --tags <tag1,tag2> [--keywords <...>] [--replaces <路径,...>] [--peer <peerKey>] "<正文>"',
-    update: 'ec memory update <路径> [--tags <tag1,tag2>] [--touch]（至少给一项）',
+    create: "ec memory create --scope <relation|agent|owner> --slug <slug> --desc '<描述>' --tags '<tag1>,<tag2>' [--keywords '<kw1>,<kw2>'] [--replaces '<路径1>,<路径2>'] [--peer <peerKey>] '<正文>'",
+    update: "ec memory update <路径> [--tags '<tag1>,<tag2>'] [--touch]（至少给一项）",
     archive: 'ec memory archive <路径...>',
 };
-function failWithUsage(message, usage) {
-    console.error(`❌ ${message}`);
-    console.error(`用法: ${usage}`);
+/**
+ * 统一失败出口。JSON 模式与 `ec fs` / `ec response` 一致：stdout 输出 `{ ok: false, code, error }`；
+ * 文本模式默认输出 `❌ <message>`（有 usage 时再加一行用法）；`text` 给出时整段原样输出，保留各处既有措辞。
+ */
+function fail(json, code, message, opts = {}) {
+    if (json) {
+        console.log(JSON.stringify({ ok: false, code, error: message, ...(opts.usage ? { usage: opts.usage } : {}) }, null, 2));
+    }
+    else {
+        console.error(opts.text ?? (opts.usage ? `❌ ${message}\n用法: ${opts.usage}` : `❌ ${message}`));
+    }
     process.exit(1);
 }
+function failWithUsage(json, message, usage) {
+    fail(json, 'INVALID_ARGUMENT', message, { usage });
+}
+/** CLI 侧解析：参数错误按输出格式报错退出。 */
+function parseCliArgs(args, known, json) {
+    try {
+        return parseArgs(args, known);
+    }
+    catch (e) {
+        return fail(json, 'INVALID_ARGUMENT', e.message);
+    }
+}
 /**
  * 取当前会话。`--debug <sessionId>` 在宿主终端模拟托管环境（仅开发仓 daemon 认）；
  * 否则读 EVOLCORE_SESSION_ID。
  */
-function requireManagedSession(cmd, flags) {
-    const debugSessionId = flags.get('--debug');
-    if (flags.has('--debug') && !debugSessionId) {
-        console.error(`❌ --debug 需要提供 sessionId（如 --debug meta_20260910_1789013149542）`);
-        process.exit(1);
-    }
-    const sessionId = debugSessionId || process.env.EVOLCORE_SESSION_ID;
+function requireManagedSession(cmd, flags, json) {
+    const explicitDebugSessionId = flags.get('--debug');
+    if (flags.has('--debug') && !explicitDebugSessionId) {
+        fail(json, 'INVALID_ARGUMENT', '--debug 需要提供 sessionId（如 --debug meta_20260910_1789013149542）');
+    }
+    // `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) {
-        console.error(`错误: EVOLCORE_SESSION_ID 未设置（${cmd} 仅在 evolcore 托管环境中可用；调试可加 --debug <sessionId>）`);
-        process.exit(1);
+        const message = `EVOLCORE_SESSION_ID 未设置（${cmd} 仅在 evolcore 托管环境中可用；调试可加 --debug <sessionId> 或 --as-session <sessionId>）`;
+        fail(json, 'NO_SESSION', message, { text: `错误: ${message}` });
+    }
+    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 报错 */ }
     }
-    if (debugSessionId)
-        console.error(`[debug] 模拟会话 ${debugSessionId}`);
     return {
         sessionId,
         socketPath: resolvePaths().socket,
-        delegationToken: readDelegationCredential(),
-        ...(debugSessionId ? { debug: true } : {}),
+        // debug 身份必须用 control token；带 delegationToken 会被 daemon 直接拒绝
+        ...(debugMode ? { controlToken, debug: true } : { delegationToken: readDelegationCredential() }),
     };
 }
 // ── note ───────────────────────────────────────────────────────────────────
-async function cmdMemoryNote(args) {
+async function cmdMemoryNote(args, json) {
     if (wantsHelp(args)) {
         console.log(MEMORY_HELP);
         return;
     }
     const sub = args[0];
     if (sub === 'update')
-        return cmdMemoryNoteUpdate(args.slice(1));
+        return cmdMemoryNoteUpdate(args.slice(1), json);
     if (sub === 'drop')
-        return cmdMemoryNoteDrop(args.slice(1));
+        return cmdMemoryNoteDrop(args.slice(1), json);
     if (sub === 'list')
-        return cmdMemoryNoteList(args.slice(1));
-    return cmdMemoryNoteCreate(args);
+        return cmdMemoryNoteList(args.slice(1), json);
+    return cmdMemoryNoteCreate(args, json);
 }
-async function cmdMemoryNoteCreate(args) {
-    const { flags, positional } = parseArgs(args, ['--slug', '--tags', '--speakers']);
+async function cmdMemoryNoteCreate(args, json) {
+    const { flags, positional } = parseCliArgs(args, ['--slug', '--tags', '--speakers'], json);
     const content = positional.join(' ').trim();
     const slug = flags.get('--slug');
     const tags = parseTags(flags.get('--tags'));
     const speakers = parseTags(flags.get('--speakers'));
     if (!slug)
-        failWithUsage('必须提供 --slug', USAGE.note);
+        failWithUsage(json, '必须提供 --slug', USAGE.note);
     if (!content)
-        failWithUsage('必须提供记忆内容（content）', USAGE.note);
-    const { socketPath, ...session } = requireManagedSession('ec memory note', flags);
+        failWithUsage(json, '必须提供记忆内容（content）', USAGE.note);
+    const { socketPath, ...session } = requireManagedSession('ec memory note', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.note', argv: ['memory', 'note', ...args], ...session, slug, content, tags,
         speakers: speakers && speakers.length > 0 ? speakers : undefined,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         if (r.filePath)
             console.log(r.filePath);
     });
 }
-async function cmdMemoryNoteUpdate(args) {
-    const { flags, positional } = parseArgs(args, ['--slug', '--tags']);
+async function cmdMemoryNoteUpdate(args, json) {
+    const { flags, positional } = parseCliArgs(args, ['--slug', '--tags'], json);
     const slug = positional[0];
     const content = positional.slice(1).join(' ').trim();
     const newSlug = flags.get('--slug');
     const tagsRaw = flags.get('--tags');
     const tags = parseTags(tagsRaw);
     if (!slug)
-        failWithUsage('必须提供要修改的 slug', USAGE.noteUpdate);
+        failWithUsage(json, '必须提供要修改的 slug', USAGE.noteUpdate);
     if (!newSlug && tagsRaw === undefined && !content) {
-        failWithUsage('至少提供一项要改的内容（--slug / --tags / 正文）', USAGE.noteUpdate);
+        failWithUsage(json, '至少提供一项要改的内容（--slug / --tags / 正文）', USAGE.noteUpdate);
     }
-    const { socketPath, ...session } = requireManagedSession('ec memory note update', flags);
+    const { socketPath, ...session } = requireManagedSession('ec memory note update', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.note.update', argv: ['memory', 'note', 'update', ...args], ...session, slug,
         newSlug, tags, tagsProvided: tagsRaw !== undefined,
         content: content || undefined,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         if (r.filePath)
             console.log(r.filePath);
     });
 }
-async function cmdMemoryNoteDrop(args) {
-    const { flags, positional } = parseArgs(args, []);
+async function cmdMemoryNoteDrop(args, json) {
+    const { flags, positional } = parseCliArgs(args, [], json);
     const slug = positional[0];
     if (!slug)
-        failWithUsage('必须提供要撤销的 slug', USAGE.noteDrop);
-    const { socketPath, ...session } = requireManagedSession('ec memory note drop', flags);
+        failWithUsage(json, '必须提供要撤销的 slug', USAGE.noteDrop);
+    const { socketPath, ...session } = requireManagedSession('ec memory note drop', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.note.drop', argv: ['memory', 'note', 'drop', ...args], ...session, slug,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         console.log(`✓ 已撤销: ${r.filePath ?? slug}`);
     });
 }
-async function cmdMemoryNoteList(args) {
-    const { flags } = parseArgs(args, []);
-    const { socketPath, ...session } = requireManagedSession('ec memory note list', flags);
+async function cmdMemoryNoteList(args, json) {
+    const { flags } = parseCliArgs(args, [], json);
+    const { socketPath, ...session } = requireManagedSession('ec memory note list', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.note.list', argv: ['memory', 'note', 'list', ...args], ...session,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         const notes = r.notes ?? [];
         if (notes.length === 0) {
             console.log('（没有待整理的 note）');
@@ -333,10 +403,10 @@ async function cmdMemoryNoteList(args) {
     });
 }
 // ── create / update / archive（仅整理会话） ─────────────────────────────────
-async function cmdMemoryCreate(args) {
-    const { flags, positional } = parseArgs(args, [
+async function cmdMemoryCreate(args, json) {
+    const { flags, positional } = parseCliArgs(args, [
         '--scope', '--slug', '--desc', '--tags', '--keywords', '--replaces', '--peer',
-    ]);
+    ], json);
     const content = positional.join(' ').trim();
     const scope = flags.get('--scope');
     const slug = flags.get('--slug');
@@ -346,20 +416,20 @@ async function cmdMemoryCreate(args) {
     const replacesRaw = flags.get('--replaces');
     const targetPeerKey = flags.get('--peer');
     if (!scope || !['agent', 'relation', 'owner'].includes(scope)) {
-        failWithUsage('--scope 必须是 agent / relation / owner 之一', USAGE.create);
+        failWithUsage(json, '--scope 必须是 agent / relation / owner 之一', USAGE.create);
     }
     if (!slug)
-        failWithUsage('必须提供 --slug', USAGE.create);
+        failWithUsage(json, '必须提供 --slug', USAGE.create);
     if (!desc)
-        failWithUsage('必须提供 --desc', USAGE.create);
+        failWithUsage(json, '必须提供 --desc', USAGE.create);
     if (tagsRaw === undefined)
-        failWithUsage('必须提供 --tags', USAGE.create);
+        failWithUsage(json, '必须提供 --tags', USAGE.create);
     if (!content)
-        failWithUsage('必须提供记忆内容（content）', USAGE.create);
+        failWithUsage(json, '必须提供记忆内容（content）', USAGE.create);
     if (targetPeerKey !== undefined && scope !== 'relation') {
-        failWithUsage('--peer 只在 --scope relation 时有效', USAGE.create);
+        failWithUsage(json, '--peer 只在 --scope relation 时有效', USAGE.create);
     }
-    const { socketPath, ...session } = requireManagedSession('ec memory create', flags);
+    const { socketPath, ...session } = requireManagedSession('ec memory create', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.create', argv: ['memory', 'create', ...args], ...session, scope, slug, description: desc,
         content,
@@ -368,7 +438,7 @@ async function cmdMemoryCreate(args) {
         replaces: replacesRaw ? replacesRaw.split(',').map(s => s.trim()).filter(Boolean) : undefined,
         targetPeerKey: targetPeerKey ?? undefined,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         if (r.filePath)
             console.log(r.filePath);
         if (Array.isArray(r.archived) && r.archived.length > 0) {
@@ -376,33 +446,33 @@ async function cmdMemoryCreate(args) {
         }
     });
 }
-async function cmdMemoryConsolidatedUpdate(args) {
-    const { flags, positional } = parseArgs(args, ['--tags', '--touch']);
+async function cmdMemoryConsolidatedUpdate(args, json) {
+    const { flags, positional } = parseCliArgs(args, ['--tags', '--touch'], json);
     const filePath = positional[0];
     const tagsRaw = flags.get('--tags');
     const touch = flags.has('--touch');
     if (!filePath)
-        failWithUsage('必须提供要修改的记忆文件路径', USAGE.update);
+        failWithUsage(json, '必须提供要修改的记忆文件路径', USAGE.update);
     if (tagsRaw === undefined && !touch)
-        failWithUsage('至少提供 --tags 或 --touch', USAGE.update);
-    const { socketPath, ...session } = requireManagedSession('ec memory update', flags);
+        failWithUsage(json, '至少提供 --tags 或 --touch', USAGE.update);
+    const { socketPath, ...session } = requireManagedSession('ec memory update', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.update', argv: ['memory', 'update', ...args], ...session, filePath,
         tags: parseTags(tagsRaw), touch,
     }, 15_000);
-    reportResult(result, () => {
+    reportResult(result, json, () => {
         console.log(`✓ 已更新: ${filePath}`);
     });
 }
-async function cmdMemoryArchive(args) {
-    const { flags, positional } = parseArgs(args, []);
+async function cmdMemoryArchive(args, json) {
+    const { flags, positional } = parseCliArgs(args, [], json);
     if (positional.length === 0)
-        failWithUsage('必须提供至少一个要归档的文件路径', USAGE.archive);
-    const { socketPath, ...session } = requireManagedSession('ec memory archive', flags);
+        failWithUsage(json, '必须提供至少一个要归档的文件路径', USAGE.archive);
+    const { socketPath, ...session } = requireManagedSession('ec memory archive', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.archive', argv: ['memory', 'archive', ...args], ...session, filePaths: positional,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         const archived = r.archived ?? positional;
         console.log(`✓ 已归档 ${archived.length} 个文件:`);
         for (const f of archived)
@@ -410,27 +480,26 @@ async function cmdMemoryArchive(args) {
     });
 }
 // ── consolidate ────────────────────────────────────────────────────────────
-async function cmdMemoryDemote(args) {
+async function cmdMemoryDemote(args, json) {
     if (wantsHelp(args)) {
         console.log(MEMORY_HELP);
         return;
     }
-    const { flags, positional } = parseArgs(args, ['--scope']);
+    const { flags, positional } = parseCliArgs(args, ['--scope'], json);
     const slug = positional[0];
     if (!slug) {
-        console.error('用法: ec memory demote <slug> [--scope agent|owner]');
-        process.exit(1);
+        const usage = 'ec memory demote <slug> [--scope agent|owner]';
+        fail(json, 'INVALID_ARGUMENT', '必须提供要降级的 slug', { usage, text: `用法: ${usage}` });
     }
     const scope = flags.get('--scope') ?? 'agent';
     if (scope !== 'agent' && scope !== 'owner') {
-        console.error('--scope 必须是 agent 或 owner');
-        process.exit(1);
+        fail(json, 'INVALID_ARGUMENT', '--scope 必须是 agent 或 owner', { text: '--scope 必须是 agent 或 owner' });
     }
-    const { socketPath, ...session } = requireManagedSession('ec memory demote', flags);
+    const { socketPath, ...session } = requireManagedSession('ec memory demote', flags, json);
     const result = await ipcQuery(socketPath, {
         type: 'memory.demote', argv: ['memory', 'demote', ...args], ...session, slug, scope,
     }, 15_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         if (r.conflictArchived) {
             console.log(`⚠ 目标层已有同名文件，当前记忆已归档至:`);
             console.log(`  ${r.conflictArchived}`);
@@ -441,28 +510,28 @@ async function cmdMemoryDemote(args) {
         }
     });
 }
-async function cmdMemoryConsolidate(args) {
+async function cmdMemoryConsolidate(args, json) {
     if (wantsHelp(args)) {
         console.log(MEMORY_HELP);
         return;
     }
     // 先于通用解析处理已废弃的 --scope，给出可操作的提示而不是「未知参数」
     if (args.includes('--scope')) {
-        console.error('❌ `--scope` 已废弃。作用域由模式唯一决定，请改用 `--mode <notes|generalize|promote|profile|forget>`');
-        process.exit(1);
+        fail(json, 'INVALID_ARGUMENT', '`--scope` 已废弃。作用域由模式唯一决定，请改用 `--mode <notes|generalize|promote|profile|forget>`');
     }
-    const { flags } = parseArgs(args, ['--mode']);
+    const { flags } = parseCliArgs(args, ['--mode'], json);
     const mode = (flags.get('--mode') ?? 'notes');
     if (!MEMORY_MODES.includes(mode)) {
-        console.error(`❌ --mode 必须是 ${MEMORY_MODES.join(' / ')} 之一`);
-        process.exit(1);
+        fail(json, 'INVALID_ARGUMENT', `--mode 必须是 ${MEMORY_MODES.join(' / ')} 之一`);
     }
-    const { socketPath, ...session } = requireManagedSession('ec memory consolidate', flags);
-    console.log(`正在触发记忆整理（mode=${mode}）...`);
+    const { socketPath, ...session } = requireManagedSession('ec memory consolidate', flags, json);
+    // JSON 模式下 stdout 只留结果对象
+    if (!json)
+        console.log(`正在触发记忆整理（mode=${mode}）...`);
     const result = await ipcQuery(socketPath, {
         type: 'memory.consolidate', argv: ['memory', 'consolidate', ...args], ...session, mode,
     }, 30_000);
-    reportResult(result, (r) => {
+    reportResult(result, json, (r) => {
         if (r.queued) {
             console.log(`⏳ 整理请求已入队（${mode} 模式），前一个整理会话结束后自动启动`);
             for (const line of formatQueueDetails(r.queued))
@@ -480,43 +549,18 @@ async function cmdMemoryConsolidate(args) {
         console.log('整理会话在后台继续运行。');
     });
 }
-// ── feedback（整理会话反馈）─────────────────────────────────────────────────
-/**
- * 整理会话用 `ec memory feedback "<文本>"` 记录本次整理的反馈内容。
- * 文本写入批次目录的 ops.jsonl（op=feedback-set），收尾时据此投递回发起会话。
- * 未调用则不写，收尾回退到默认统计模板。
- */
-async function cmdMemoryFeedback(args) {
-    if (wantsHelp(args)) {
-        console.log(MEMORY_HELP);
-        return;
-    }
-    const { flags, positional } = parseArgs(args, []);
-    const text = positional.join(' ').trim();
-    if (!text) {
-        console.error('用法: ec memory feedback "<反馈文本>"');
-        process.exit(1);
-    }
-    const { socketPath, ...session } = requireManagedSession('ec memory feedback', flags);
-    const result = await ipcQuery(socketPath, {
-        type: 'memory.feedback', argv: ['memory', 'feedback', ...args], ...session, text,
-    }, 15_000);
-    reportResult(result, () => {
-        console.log('✓ 已记录反馈内容');
-    });
-}
 // ── 结果输出 ───────────────────────────────────────────────────────────────
-function reportResult(result, ok) {
+function reportResult(result, json, ok) {
     if (!result) {
-        console.error('错误: 无法连接 evolcore 服务');
-        process.exit(1);
+        fail(json, 'DAEMON_UNAVAILABLE', '无法连接 evolcore 服务', { text: '错误: 无法连接 evolcore 服务' });
     }
     const r = result;
-    if (r.ok) {
-        ok(r);
-    }
-    else {
-        console.error(r.error || '操作失败');
-        process.exit(1);
+    if (!r.ok) {
+        const message = r.error || '操作失败';
+        fail(json, r.code || 'MEMORY_OPERATION_FAILED', message, { text: message });
     }
+    if (json)
+        console.log(JSON.stringify(r, null, 2));
+    else
+        ok(r);
 }