evolcore 0.0.31 → 0.0.33

package/dist/cli/contact.js

@@ -11,8 +11,14 @@ export async function cmdContact(args) {
     }
     const json = getArgValue(args, '--format') === 'json';
     if (process.env.EVOLCORE_SESSION_ID) {
-        const result = await runManaged(args, json);
-        output(result, json);
+        try {
+            const result = await runManaged(args, json);
+            output(result, json);
+        }
+        catch (err) {
+            console.error(`❌ ${err.message ?? String(err)}`);
+            process.exitCode = 1;
+        }
         return;
     }
     if (!args.includes('--self') && isListCommand(args) && !process.env.EVOLCORE_SELF_AID?.trim()) {

package/dist/cli/ctl-command.js

@@ -41,11 +41,10 @@ export async function cmdCtl(args) {
         console.error('错误: EVOLCORE_SESSION_ID 未设置（仅在 evolcore 托管环境中可用）');
         process.exit(1);
     }
-    const cmd = '/' + args.join(' ');
     const socketPath = resolvePaths().socket;
     const result = await ipcQuery(socketPath, {
         type: 'ctl',
-        cmd,
+        argv: ['ctl', ...args],
         sessionId,
         delegationToken: readDelegationCredential(),
     }, 10_000);

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 { RUNTIME_HOME_ENV, WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME } from '../product.js';
+import { MAIN_CLI_BIN, RUNTIME_HOME_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';
@@ -34,8 +34,34 @@ import { listCodexAppServerProcesses, unregisterCodexAppServerProcess } from '..
 import { DEFAULT_ECWEB_PORT, ecwebService, setEcwebEnabled } from '../config/daemon-services.js';
 import { checkCodexProjectPath, inspectCodexManagedHook, ensureCodexManagedHook, runCodexHookLaunchDiagnostic, } from '../agents/codex/diagnostics.js';
 const execFileAsync = promisify(execFile);
+export async function confirmCodexHookRebind(state, packageRoot) {
+    console.log('⚠️ Codex 受管 Hook 绑定的另一套 EvolCore/Node 路径仍存在，需确认是否切换：');
+    console.log(`  现有包: ${state.managedPackageRoot}`);
+    console.log(`  现有 Node: ${state.managedNodePath}`);
+    console.log(`  当前包: ${packageRoot}`);
+    console.log(`  当前 Node: ${process.execPath}`);
+    console.log('  切换会更新机器级 Hook，影响共享此策略的 Codex 会话；不会执行数据迁移。');
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.warn(`  非交互模式不自动选择。请在交互式终端运行 ${MAIN_CLI_BIN} start 确认；也可使用现有安装的 CLI。`);
+        return false;
+    }
+    const terminal = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (confirmed) => {
+            if (settled)
+                return;
+            settled = true;
+            terminal.close();
+            resolve(confirmed);
+        };
+        terminal.once('close', () => finish(false));
+        terminal.once('SIGINT', () => finish(false));
+        terminal.question('  [1] 切换到当前包/Node 并修复  [2] 保留原绑定并取消本次启动 [1/2，默认 2]: ', answer => finish(answer.trim() === '1'));
+    });
+}
 /** Run before launch, and before restart stops any existing daemon. */
-export function ensureCodexHookBeforeLifecycle(onRepaired) {
+export async function ensureCodexHookBeforeLifecycle(onRepaired) {
     if (!platform.isWindows)
         return true;
     try {
@@ -53,19 +79,31 @@ export function ensureCodexHookBeforeLifecycle(onRepaired) {
             });
         if (!usesCodex)
             return true;
-        const result = ensureCodexManagedHook({
-            packageRoot: getPackageRoot(),
-            onInstallRequired: () => console.log('🔧 Codex 运行组件缺失，正在自动安装；Windows 提示管理员授权时请选择“是”。'),
+        const packageRoot = getPackageRoot();
+        const result = await ensureCodexManagedHook({
+            packageRoot,
+            repairDecision: state => confirmCodexHookRebind(state, packageRoot),
+            onInstallRequired: state => console.log(state.status === 'stale'
+                ? '🔧 Codex 受管 Hook 路径已过期，正在修复；Windows 提示管理员授权时请选择“是”。'
+                : '🔧 Codex 运行组件缺失，正在自动安装；Windows 提示管理员授权时请选择“是”。'),
         });
         if (result.status === 'installed') {
             if (result.repaired) {
-                console.log('✅ Codex Windows managed hook 已自动安装并验证');
+                console.log('✅ Codex Windows managed hook 已修复并验证');
                 onRepaired?.();
             }
             return true;
         }
-        console.error(`❌ Codex Windows managed hook 未就绪：${result.error || result.reason || result.status}`);
-        if (result.status === 'missing') {
+        if (result.cancelled) {
+            console.warn('ℹ 未确认切换 Codex 受管 Hook，保留原绑定；本次启动/重启已取消，现有服务未停止。');
+            process.exitCode = 1;
+            return false;
+        }
+        console.error(`❌ Codex Windows managed hook 启动检查未通过：${result.error || result.reason || result.status}`);
+        if (result.status === 'stale') {
+            console.error(`  本次操作已停止，现有服务未停止。请在交互式终端运行 ${MAIN_CLI_BIN} start 确认修复，或使用原安装的 CLI。`);
+        }
+        else if (result.status === 'missing') {
             console.error('  本次操作已停止。下次启动或重启会再次自动尝试安装，需要允许 Windows 管理员授权。');
         }
         else {
@@ -154,7 +192,7 @@ async function tryDelegatedDaemonRestart(socketPath) {
         return false;
     const response = await ipcQuery(socketPath, {
         type: 'ctl',
-        cmd: '/restart',
+        argv: ['ctl', 'restart'],
         sessionId,
         delegationToken,
     }, 15_000);
@@ -192,6 +230,7 @@ function buildDaemonEnv(p, opts) {
         EVENT_LOG: process.env.EVENT_LOG || 'true',
         ...(opts.diagnose ? { EVOLCORE_DIAGNOSE: '1' } : {}),
         ...(opts.bindBootstrap ? { EVOLCORE_BIND_BOOTSTRAP: '1' } : {}),
+        ...(opts.debug ? { EVOLCORE_DEBUG_MODE: '1' } : {}),
     };
 }
 function latestSourceMtime(dir) {
@@ -474,10 +513,10 @@ export async function cmdStart(opts = {}) {
     const existingDaemon = await probeDaemon(p.socket);
     if (existingDaemon) {
         let hookRepaired = false;
-        if (!ensureCodexHookBeforeLifecycle(() => { hookRepaired = true; }))
+        if (!await ensureCodexHookBeforeLifecycle(() => { hookRepaired = true; }))
             return;
         if (hookRepaired) {
-            console.log('🔄 Codex 运行组件已补齐，正在自动重启服务以加载策略...');
+            console.log('🔄 Codex 运行组件已修复，正在自动重启服务以加载策略...');
             await cmdRestart({ diagnose: opts.diagnose });
             return;
         }
@@ -524,7 +563,7 @@ export async function cmdStart(opts = {}) {
     // The initialization path can create the first Codex agent, so perform the
     // machine-hook check after config migration/auto-init and before any daemon
     // process is launched.
-    if (!ensureCodexHookBeforeLifecycle())
+    if (!await ensureCodexHookBeforeLifecycle())
         return;
     // 控制 AID 门禁：缺 aid 且交互式 → 只补全控制 AID + owners（不重走 baseagent 向导）。
     // 非 TTY（restart-monitor/systemd/管道）不补全（无法交互），只提示后继续启动，daemon 侧 warn 兜底。
@@ -666,6 +705,21 @@ export async function cmdStart(opts = {}) {
             console.log(`  EVOLCORE_HOME: ${resolveRoot()}`);
             console.log(`  Logs: ${p.logs}/`);
             console.log(`⏱ ready in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
+            if (opts.debug) {
+                console.log('');
+                console.log('🔧 调试模式已启用（EVOLCORE_DEBUG_MODE=1）');
+                console.log('  在宿主终端以任意 session 身份执行命令：');
+                console.log('');
+                console.log('    ec msg send "消息内容" --as-session <sessionId>');
+                console.log('    ec trigger list --as-session <sessionId>');
+                console.log('    ec memory list --as-session <sessionId>');
+                console.log('');
+                console.log('  查看可用会话（运行后将在此处列出）：');
+                console.log('    ec msg send "test" --as-session   # 不带 sessionId 自动列出');
+                console.log('');
+                console.log('  注意：重启 daemon（ec restart）会清除调试模式，');
+                console.log('        需重新执行 ec start --debug 才能恢复。');
+            }
             void waitForExistingEcweb(p).then((ecweb) => {
                 if (shouldPrintNoSelfAgentHints) {
                     printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: ecweb !== null, skipped });
@@ -769,6 +823,21 @@ export async function cmdStart(opts = {}) {
                 printCodeStats(getPackageRoot(), p.logs);
             }
             console.log(`⏱ done in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
+            if (opts.debug) {
+                console.log('');
+                console.log('🔧 调试模式已启用（EVOLCORE_DEBUG_MODE=1）');
+                console.log('  在宿主终端以任意 session 身份执行命令：');
+                console.log('');
+                console.log('    ec msg send "消息内容" --as-session <sessionId>');
+                console.log('    ec trigger list --as-session <sessionId>');
+                console.log('    ec memory list --as-session <sessionId>');
+                console.log('');
+                console.log('  查看可用会话（运行后将在此处列出）：');
+                console.log('    ec msg send "test" --as-session   # 不带 sessionId 自动列出');
+                console.log('');
+                console.log('  注意：重启 daemon（ec restart）会清除调试模式，');
+                console.log('        需重新执行 ec start --debug 才能恢复。');
+            }
             // ECWeb lifecycle belongs to the daemon; the CLI only reports whether
             // the supervised instance became healthy.
             const ecwebStarted = await waitForExistingEcweb(p) !== null;
@@ -904,7 +973,7 @@ export async function cmdStop() {
 export async function cmdRestart(opts = {}) {
     const cmdStartedAt = Date.now();
     console.log('🔄 Restarting EvolCore...');
-    if (!ensureCodexHookBeforeLifecycle())
+    if (!await ensureCodexHookBeforeLifecycle())
         return;
     const initialStatus = scanInstances();
     const socketPath = resolvePaths().socket;

package/dist/cli/debug-mode.js

@@ -0,0 +1,154 @@
+/**
+ * debug-mode.ts — `--as-session <sessionId>` 调试路径
+ *
+ * 在外部终端（宿主 CC 终端）以任意 agent 身份执行托管命令。
+ * 调用方在检查 EVOLCORE_SESSION_ID 之前先调用 resolveDebugContext(args)；
+ * 注入完成后 process.env.EVOLCORE_SESSION_ID 已设好，后续走统一托管路径。
+ */
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, debugSessionsDir } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { buildTaskRuntimeEnv } from './task-context.js';
+const AS_SESSION_FLAG = '--as-session';
+function formatTimeAgo(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}秒前`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}分钟前`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}小时前`;
+    return `${Math.floor(h / 24)}天前`;
+}
+function listAvailableSessions() {
+    const dir = debugSessionsDir();
+    if (!fs.existsSync(dir))
+        return { sessions: [], dirExists: false };
+    try {
+        const sessions = fs.readdirSync(dir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null && !!s.sessionId)
+            .sort((a, b) => b.writtenAt - a.writtenAt)
+            .slice(0, 20);
+        return { sessions, dirExists: true };
+    }
+    catch {
+        return { sessions: [], dirExists: true };
+    }
+}
+function printSessionList(result) {
+    const { sessions, dirExists } = result;
+    if (!dirExists) {
+        console.error('❌ 调试模式未启用。请先执行：ec start --debug');
+        return;
+    }
+    if (sessions.length === 0) {
+        console.error('ℹ️  调试模式已启用，但暂无可用会话。');
+        console.error('   请等待 agent 收到至少一条消息后再试。');
+        return;
+    }
+    console.error('\n可用会话（最近 20 个）：');
+    for (const s of sessions) {
+        const age = formatTimeAgo(Date.now() - s.writtenAt);
+        console.error(`  ${s.sessionId}  ${s.selfAid} → ${s.channelId}  ${age}`);
+    }
+}
+/**
+ * 检测命令行参数中是否包含 --as-session，若有则执行调试路径：
+ * 1. 互斥检查（托管会话中拒绝）
+ * 2. 读临时文件
+ * 3. 调 debug-issue-token IPC 现取 token
+ * 4. 注入 process.env，后续命令走统一托管路径
+ *
+ * 不带 --as-session 时直接返回，不做任何事。
+ */
+export async function resolveDebugContext(args) {
+    const flagIdx = args.indexOf(AS_SESSION_FLAG);
+    if (flagIdx === -1)
+        return;
+    // 互斥检查：托管会话里不允许 --as-session
+    if (process.env.EVOLCORE_SESSION_ID) {
+        console.error('❌ --as-session 仅限外部终端使用，托管会话中不可用');
+        process.exit(1);
+    }
+    const sessionId = args[flagIdx + 1];
+    // 不带 sessionId 或 sessionId 以 - 开头（下一个 flag）
+    if (!sessionId || sessionId.startsWith('-')) {
+        console.error('❌ --as-session 需要指定 sessionId\n');
+        console.error(`使用：ec <命令> --as-session <sessionId>`);
+        printSessionList(listAvailableSessions());
+        process.exit(1);
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(sessionId)) {
+        console.error('❌ 无效 sessionId');
+        process.exit(1);
+    }
+    // 读临时文件（session bind 时已写入）
+    const snapshotPath = path.join(debugSessionsDir(), `${sessionId}.json`);
+    if (!fs.existsSync(snapshotPath)) {
+        const result = listAvailableSessions();
+        if (!result.dirExists) {
+            console.error('❌ 调试模式未启用。请先执行：ec start --debug');
+        }
+        else {
+            console.error(`❌ 调试会话不存在：${sessionId}\n`);
+            printSessionList(result);
+        }
+        process.exit(1);
+    }
+    // 调 debug-issue-token IPC 现取 token
+    let response;
+    try {
+        response = await ipcQuery(resolvePaths().socket, { type: 'debug-issue-token', sessionId }, 5000);
+    }
+    catch (err) {
+        console.error(`❌ 无法连接 daemon：${err instanceof Error ? err.message : String(err)}`);
+        console.error('请确认 daemon 正在以 debug 模式运行：ec start --debug');
+        process.exit(1);
+    }
+    if (!response) {
+        console.error('❌ daemon 无响应，请确认 daemon 正在以 debug 模式运行：ec start --debug');
+        process.exit(1);
+    }
+    if (!response.ok) {
+        console.error(`❌ 无法获取调试 token：${response.error}`);
+        process.exit(1);
+    }
+    const { token, runtimeContext } = response;
+    // 注入 process.env，后续代码走统一托管路径
+    // 注意：去掉 daemonRuntimeEpoch——debug session 不是真实任务，
+    // 不应该受 ipc.ts 里的 daemon epoch 检查约束，否则 msg send --thread 后续命令会报
+    // "The task delegation token belongs to a previous daemon runtime"
+    const ctxWithoutEpoch = { ...runtimeContext, daemonRuntimeEpoch: undefined };
+    Object.assign(process.env, buildTaskRuntimeEnv(ctxWithoutEpoch));
+    process.env[AGENT_DELEGATION_TOKEN_ENV] = token;
+    // thread 命令从 EVOLCORE_SELF_AID 读 selfAid（不走 taskRuntimeContext），单独注入
+    if (runtimeContext.selfAid)
+        process.env.EVOLCORE_SELF_AID = runtimeContext.selfAid;
+}
+/** 从 args 中去掉 --as-session <sessionId> 两个元素，返回净化后的参数列表 */
+export function stripAsSessionArgs(args) {
+    const result = [];
+    let i = 0;
+    while (i < args.length) {
+        if (args[i] === AS_SESSION_FLAG) {
+            i += 2; // 跳过 flag 和 sessionId
+        }
+        else {
+            result.push(args[i++]);
+        }
+    }
+    return result;
+}

package/dist/cli/diag.js

@@ -8,11 +8,11 @@ export async function cmdDiag(args) {
         console.log('用法：ec diag <问题描述> [--owner <daemonOwner-aid>] [--format json]\n      ec diag stop [--format json]\n未指定 --owner 时联系本机 daemon.json.owners[0]；有效诊断期间再次执行会追加到原 case。');
         return;
     }
+    const argv = ['diag', ...args];
     const json = args.at(-2) === '--format' && args.at(-1) === 'json';
-    const argv = json ? args.slice(0, -2) : args;
     let result;
     try {
-        parseDiagArgs(argv);
+        parseDiagArgs(args);
         result = await ipcQuery(resolvePaths().socket, {
             type: 'diag', argv,
             ...(process.env.EVOLCORE_SESSION_ID ? {

package/dist/cli/handoff-command.js

@@ -6,6 +6,7 @@ import { HANDOFF_ID_RE } from '../core/handoff/store.js';
 import { isHelpFlag, wantsHelp } from './help.js';
 import { readDelegationCredential } from '../core/auth/agent-delegation.js';
 import { canonicalizeEvolcoreCommandArgv } from '../core/permission/ec-command-parser.js';
+import { MAIN_CLI_BIN } from '../product.js';
 function parseLimit(value) {
     const limit = Number(value);
     if (!value || !Number.isInteger(limit) || limit < 1 || limit > HANDOFF_QUERY_MAX_LIMIT) {
@@ -70,8 +71,9 @@ export function parseTrace(args) {
     }
     return parsed;
 }
-export function parseReturn(args) {
-    args = canonicalizeEvolcoreCommandArgv(['ec', 'handoff', 'return', ...args]).slice(3);
+export function parseReturn(args, options = {}) {
+    if (!options.canonical)
+        args = canonicalizeEvolcoreCommandArgv([MAIN_CLI_BIN, 'handoff', 'return', ...args]).slice(3);
     const dash = args.indexOf('--');
     if (dash >= 0) {
         const beforeDash = args.slice(0, dash);
@@ -96,8 +98,10 @@ export function parseReturn(args) {
     if (filePath && contentArgs.length > 0)
         throw new Error('HANDOFF_CONTENT_FILE_CONFLICT');
     if (filePath) {
+        if (options.deferFileRead)
+            return { handoffId, content: '' };
         try {
-            return { handoffId, content: fs.readFileSync(filePath, 'utf8') };
+            return { handoffId, content: options.readFile ? options.readFile(filePath) : fs.readFileSync(filePath, 'utf8') };
         }
         catch {
             throw new Error('HANDOFF_CONTENT_FILE_READ_FAILED');
@@ -153,10 +157,14 @@ function formatTimestamp(value) {
     return new Date(value).toISOString();
 }
 export async function cmdHandoff(args) {
+    args = canonicalizeEvolcoreCommandArgv([MAIN_CLI_BIN, 'handoff', ...args]).slice(2);
     const sub = args[0];
     if (!sub || isHelpFlag(sub) || wantsHelp(args)) {
         console.log(`用法: ec handoff <command> [args]
 
+⚠  ec handoff 已废弃，请改用话题链（ec thread + ec msg send --thread）。
+   本命令保留以兼容现有脚本，将在 P2 后续版本中移除。
+
 Commands:
   return [handoff-id] [content]       提交一个回流结果；required 可用同一 ID 追加多个结果
   return [handoff-id] --text-from-file <path>
@@ -170,7 +178,7 @@ Commands:
     if (sub === 'return') {
         let parsed;
         try {
-            parsed = parseReturn(args.slice(1));
+            parsed = parseReturn(args.slice(1), { canonical: true, deferFileRead: !!process.env.EVOLCORE_SESSION_ID });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -185,6 +193,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-return',
+            argv: ['handoff', ...args],
             sessionId: process.env.EVOLCORE_SESSION_ID,
             handoffId: parsed.handoffId,
             content: parsed.content,
@@ -201,7 +210,7 @@ Commands:
     if (sub === 'recover-return') {
         let parsed;
         try {
-            parsed = parseReturn(args.slice(1));
+            parsed = parseReturn(args.slice(1), { canonical: true, deferFileRead: !!process.env.EVOLCORE_SESSION_ID });
         }
         catch (error) {
             console.error(`✗ ${error instanceof Error ? error.message : String(error)}`);
@@ -215,6 +224,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-recover-return',
+            argv: ['handoff', ...args],
             sessionId: process.env.EVOLCORE_SESSION_ID,
             handoffId: parsed.handoffId,
             content: parsed.content,
@@ -237,6 +247,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-status', sessionId: process.env.EVOLCORE_SESSION_ID, handoffId,
+            argv: ['handoff', ...args],
             delegationToken: readDelegationCredential(),
         }, 5000);
         if (!result) {
@@ -264,6 +275,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-list',
+            argv: ['handoff', ...args],
             sessionId: process.env.EVOLCORE_SESSION_ID,
             agent: parsed.agent,
             state: parsed.state,
@@ -308,6 +320,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-trace',
+            argv: ['handoff', ...args],
             sessionId: process.env.EVOLCORE_SESSION_ID,
             agent: parsed.agent,
             handoffId: parsed.handoffId,