evolcore 0.0.26 → 0.0.28

package/dist/cli/daemon-commands.js

@@ -9,22 +9,23 @@ import { loadDefaults, loadAllAgents, loadDaemonConfig, saveDaemonConfig } from
 import { resolveEffective } from '../config/config-manager.js';
 import { resolveAnthropicConfig } from '../agents/baseagent.js';
 import { migrateProject } from '../config-store.js';
-import { ipcQuery } from '../ipc.js';
+import { ipcQuery, IpcTransportError } from '../ipc.js';
 import { isHelpFlag } from './help.js';
 import { cmdInit, needsControlAidInit, initTail } from './init.js';
 import * as platform from '../utils/cross-platform.js';
 import { EventBus } from '../core/event-bus.js';
-import { tryUpgrade, tryUpgradeGlobalPkg, resolveGlobalPkg } from '../utils/npm-ops.js';
+import { tryUpgradeGlobalPkg, resolveGlobalPkg } from '../utils/npm-ops.js';
+import { ensureFreshPackageVersionInfo } from '../utils/package-version-info.js';
 import { ecwebVersionRequirementError, resolveEcwebLaunchCommand, fetchRemotePairingCode } from '../utils/ecweb-utils.js';
 import { isHostChinese } from '../utils/locale.js';
-import { scanInstances, cleanupInstances, findOrphanProcesses, killOrphans } from '../utils/instance-registry.js';
+import { scanInstances, cleanupInstances, findOrphanProcesses } from '../utils/instance-registry.js';
 import { filterLogFiles, deriveLogTypes, computePreChecked, validateLogTypes, shortLogName as shortLogNameLocal, isWatchLogFile } from './watch-logs.js';
 import { displaySessionTitle } from '../core/session/session-title.js';
 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 } from '../core/auth/agent-delegation.js';
-import { WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME } from '../product.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 { rotateStdoutLog } from '../utils/log-writer.js';
 import { inspectDataMigrationRequirement } from '../core/data-migration.js';
 import { isInitCancelledError, printInitCancelHint } from './init-cancel.js';
@@ -40,6 +41,8 @@ export function ensureCodexHookBeforeLifecycle(onRepaired) {
     try {
         const usesCodex = loadDefaults()?.active_baseagent === 'codex'
             || loadAllAgents().agents.some(agent => {
+                if (agent.enabled === false)
+                    return false;
                 try {
                     return resolveEffective({ self: agent.aid }).active_baseagent === 'codex';
                 }
@@ -146,7 +149,7 @@ function rejectPidIsolatedLifecycle(action, status, ping) {
 }
 async function tryDelegatedDaemonRestart(socketPath) {
     const sessionId = process.env.EVOLCORE_SESSION_ID;
-    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    const delegationToken = readDelegationCredential();
     if (!sessionId || !delegationToken)
         return false;
     const response = await ipcQuery(socketPath, {
@@ -248,27 +251,46 @@ function runSourceBuild() {
         });
     });
 }
-/**
- * Spawn the restart monitor and confirm it actually reached its own code.
- *
- * The daemon is already stopped at this point, so a monitor that dies on
- * startup leaves nothing running and nobody watching — the exact silent
- * failure this mechanism exists to prevent.
- */
-async function spawnRestartMonitorAndConfirm(monitorEntry, reportLine) {
-    const result = await platform.launchMonitorAndConfirm([...monitorEntry.args, 'restart-monitor'], { EVOLCORE_HOME: resolvePaths().root, ...(monitorEntry.env ?? {}) }, pid => scanInstances().restartMonitors.some(m => m.alive && m.record.pid === pid), pid => scanInstances().restartMonitors.some(m => m.alive && m.record.pid !== pid));
-    if (result.ok)
-        return { ok: true };
-    for (const line of (result.stderrTail ?? '').split(/\r?\n/).filter(Boolean).slice(-8)) {
-        reportLine(`  | ${line}`);
-    }
-    return { ok: false, reason: result.reason ?? 'unknown' };
-}
 async function requireFreshSourceBuild() {
     if (!sourceBuildNeedsRefresh())
         return true;
     return await runSourceBuild();
 }
+async function launchPackageLifecycle(source, log, options = {}) {
+    if (!options.prepared)
+        await ensureFreshPackageVersionInfo(undefined, { source, log });
+    const root = resolvePaths().root;
+    const launch = platform.resolveMonitorLaunch(getPackageRoot(), path.join(root, 'data', 'monitor-stage'));
+    if (launch.note)
+        log(launch.note);
+    if (!fs.existsSync(launch.entry)) {
+        if (launch.stageDir)
+            platform.cleanupMonitorStage(launch.stageDir);
+        return { ok: false, reason: 'RESTART_ENTRY_MISSING' };
+    }
+    const args = [...launch.args, 'restart-monitor', ...(options.clear ? ['--clear'] : [])];
+    const env = { ...options.env, [RUNTIME_HOME_ENV]: root, ...launch.env, [AGENT_DELEGATION_TOKEN_ENV]: '' };
+    if (options.foreground) {
+        return new Promise(resolve => {
+            const child = spawn(process.execPath, [...args, '--foreground'], {
+                stdio: 'inherit', detached: false, windowsHide: true, env: { ...process.env, ...env },
+            });
+            child.once('error', () => {
+                if (launch.stageDir)
+                    platform.cleanupMonitorStage(launch.stageDir);
+                resolve({ ok: false, reason: 'Foreground monitor could not start' });
+            });
+            child.once('exit', code => {
+                process.exitCode = code ?? 1;
+                resolve({ ok: code === 0, ...(code !== 0 ? { reason: 'Foreground lifecycle exited unsuccessfully' } : {}) });
+            });
+        });
+    }
+    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);
+    return { ok: result.ok, ...(!result.ok ? { reason: result.reason } : {}) };
+}
 function requireCompletedDataMigration(root, action = 'start') {
     const requirement = inspectDataMigrationRequirement(root);
     if (!requirement.required)
@@ -289,7 +311,11 @@ function requireCompletedDataMigration(root, action = 'start') {
  * A failed upgrade is reported, but the currently installed version remains
  * usable and the caller continues with its normal lifecycle.
  */
-export async function runUpgradeChecks(upgradeFn = signal => tryUpgrade({ signal }), ecwebUpgradeFn = signal => tryUpgradeGlobalPkg(() => resolveGlobalPkg(WEB_PACKAGE_NAME), WEB_PACKAGE_NAME, { signal }), timeoutMs = 60_000) {
+export async function runUpgradeChecks(upgradeFn, ecwebUpgradeFn, timeoutMs = 60_000) {
+    if (!upgradeFn || !ecwebUpgradeFn) {
+        await ensureFreshPackageVersionInfo(undefined, { source: 'start', log: console.log });
+        return;
+    }
     console.log('📦 Checking for updates...');
     const runWithTimeout = async (label, fn) => {
         const controller = new AbortController();
@@ -468,7 +494,9 @@ export async function cmdStart(opts = {}) {
         return;
     // A stopped container may miss the daily upgrade trigger. Check once on
     // every real start so the service does not stay on an old installation.
-    await (opts.upgradeChecks ?? runUpgradeChecks)();
+    const versionInfo = await ensureFreshPackageVersionInfo(undefined, { source: 'start', log: console.log });
+    if (opts.upgradeChecks)
+        await opts.upgradeChecks();
     // 旧配置自动迁移（daemon.json → 新结构）
     const { autoMigrateIfNeeded } = await import('../config-store.js');
     autoMigrateIfNeeded();
@@ -593,6 +621,20 @@ export async function cmdStart(opts = {}) {
         return;
     }
     reportOrphans(orphans);
+    if (versionInfo.some(result => result.hasUpdate)) {
+        cleanEnv();
+        const launched = await launchPackageLifecycle('start', console.log, {
+            prepared: true, foreground: opts.foreground, env: buildDaemonEnv(p, opts),
+        });
+        if (!launched.ok) {
+            console.error(`❌ 启动事务未能建立：${launched.reason}`);
+            process.exitCode = 1;
+        }
+        else if (!opts.foreground) {
+            console.log('📦 已交由 restart-monitor 应用缓存版本并启动服务');
+        }
+        return;
+    }
     console.log('🚀 Starting EvolCore...');
     const stdoutRotation = rotateStdoutLog(p.logs);
     if (stdoutRotation.rotatedPath) {
@@ -881,126 +923,18 @@ export async function cmdRestart(opts = {}) {
         if (initialRuntimeOrphans.length === 0 && rejectPidIsolatedLifecycle('restart', initialStatus, ping))
             return;
     }
-    // 构建交给 restart-monitor：它在 daemon 停止之后才编译，dist/ 不会被活进程
-    // 占用，失败还能回滚到上一份产物。这里再编译一次会落在事务保护之外。
-    // restart-monitor owns upgrade checks. Running them here as well caused a
-    // normal restart to perform every registry lookup twice, and in installed
-    // mode could race the monitor while it was preparing its rollback point.
+    // The shared launchPackageLifecycle path delegates to launchMonitorAndConfirm;
+    // the monitor retains shutdown, orphan checks, build and rollback ownership.
+    // Network preflight must finish before a confirmed monitor stops the daemon.
     if (!requireCompletedDataMigration(resolveRoot(), 'restart'))
         return;
-    // 停止所有活 main 进程（可能不止一个）
-    const status = initialStatus;
-    const aliveMains = status.mains.filter(m => m.alive);
-    if (aliveMains.length > 0) {
-        if (aliveMains.length > 1) {
-            console.log(`⚠ 检测到 ${aliveMains.length} 个 main 实例，将一并停止: ${aliveMains.map(m => m.record.pid).join(', ')}`);
-        }
-        const mainPids = new Set(aliveMains.map(entry => entry.record.pid));
-        const currentPing = await probeDaemon(socketPath);
-        const gracefulPid = currentPing && mainPids.has(currentPing.pid)
-            ? await requestDaemonShutdown(socketPath, DAEMON_SHUTDOWN_TIMEOUT_MS, 'ec restart', mainPids)
-            : null;
-        const stopped = await Promise.all(aliveMains.map(m => stopPid(m.record.pid, m.record.pid === gracefulPid, m.record.startedAt)));
-        if (stopped.some(result => !result)) {
-            console.error('❌ Restart aborted because an existing EvolCore process could not be stopped');
-            process.exitCode = 1;
-            return;
-        }
-        await sleep(500);
-    }
-    cleanupInstances();
-    const remainingMainProcesses = scanInstances().mains.filter(entry => entry.alive);
-    if (remainingMainProcesses.length > 0) {
-        console.error(`❌ Restart aborted: EvolCore process still registered and alive (PID: ${remainingMainProcesses.map(entry => entry.record.pid).join(', ')})`);
-        process.exitCode = 1;
-        return;
-    }
-    // 孤儿处理：同 HOME/同安装包的孤儿属于本运行时，先确认退出再替换；
-    // 跨 HOME 的孤儿只在 --clear 时 kill，否则仅警告。findOrphanProcesses
-    // 在 Windows 上需要一次 CIM 查询；保留一个快照，避免同一阶段重复扫描。
-    {
-        const orphans = findOrphanProcesses();
-        const confirmedTestDaemons = orphans.filter(o => o.confirmedTestDaemon);
-        if (confirmedTestDaemons.length > 0) {
-            const killed = killOrphans(confirmedTestDaemons);
-            console.log(`☠ 已清理 ${killed.length} 个泄漏的测试 daemon: ${killed.join(', ')}`);
-            await sleep(500);
-        }
-        const runtimeOrphans = orphans.filter(o => isRuntimeOrphan(o));
-        if (runtimeOrphans.length > 0) {
-            console.log(`⚠ 检测到未登记的 EvolCore 进程，将一并停止: ${runtimeOrphans.map(o => o.pid).join(', ')}`);
-            const orphanPids = new Set(runtimeOrphans.map(orphan => orphan.pid));
-            const currentPing = await probeDaemon(socketPath);
-            const gracefulPid = currentPing && orphanPids.has(currentPing.pid)
-                ? await requestDaemonShutdown(socketPath, DAEMON_SHUTDOWN_TIMEOUT_MS, 'ec restart', orphanPids)
-                : null;
-            const stopped = await Promise.all(runtimeOrphans.map(o => stopPid(o.pid, o.pid === gracefulPid)));
-            if (stopped.some(result => !result)) {
-                console.error('❌ Restart aborted because an unregistered EvolCore process could not be stopped');
-                process.exitCode = 1;
-                return;
-            }
-            await sleep(500);
-        }
-        // stopPid() already waited for every runtime orphan above, so avoid a
-        // second scan before handling cross-HOME records.
-        const otherHome = orphans.filter(o => !o.confirmedTestDaemon && !isRuntimeOrphan(o));
-        if (opts.clear && otherHome.length > 0) {
-            const killed = killOrphans(otherHome);
-            console.log(`☠ 已 SIGKILL ${killed.length} 个跨 HOME 孤儿进程: ${killed.join(', ')}`);
-            await sleep(500);
-        }
-        else if (otherHome.length > 0) {
-            reportOrphans(otherHome);
-        }
-        // Keep the post-stop ownership guard: a process that appeared during the
-        // cleanup window must still block replacement.
-        const remainingRuntimeOrphans = findOrphanProcesses().filter(o => isRuntimeOrphan(o));
-        if (remainingRuntimeOrphans.length > 0) {
-            console.error(`❌ Restart aborted: EvolCore process still running (PID: ${remainingRuntimeOrphans.map(o => o.pid).join(', ')})`);
-            process.exitCode = 1;
-            return;
-        }
-    }
-    // 只清理 EvolCore 自己登记的 codex app-server，不能影响桌面端实例。
-    {
-        const killed = stopCodexAppServerOrphans();
-        if (killed > 0) {
-            console.log(`☠ 已清理 ${killed} 个 EvolCore codex app-server 孤儿进程`);
-            await sleep(500);
-        }
-    }
-    console.log(`⏱ restart prep done in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s, starting...`);
-    // 通过 restart-monitor 启动，避免在 agent 内调用时自杀。
-    // 开发仓下 monitor 从源码跑；安装包下先复制到 stage 目录，两种情况都让看门狗
-    // 不住在会被替换的产物里。
-    const monitorEntry = platform.resolveMonitorLaunch(getPackageRoot(), path.join(resolvePaths().root, 'data', 'monitor-stage'));
-    if (monitorEntry.note)
-        console.log(`ℹ ${monitorEntry.note}`);
-    if (!fs.existsSync(monitorEntry.entry)) {
-        console.error(`❌ 重启中止：找不到 restart-monitor 入口 ${monitorEntry.entry}`);
-        console.error('  请先执行 npm run build 重建产物');
-        process.exitCode = 1;
-        return;
-    }
-    const monitorStarted = await spawnRestartMonitorAndConfirm(monitorEntry, log => console.error(log));
-    if (!monitorStarted.ok) {
-        if (monitorEntry.stageDir)
-            platform.cleanupMonitorStage(monitorEntry.stageDir);
-        console.error(`❌ 重启中止：restart-monitor 未能启动（${monitorStarted.reason}）`);
-        if (fs.existsSync(path.join(getPackageRoot(), 'src', 'cli', 'index.ts'))) {
-            console.error('  源码可能存在语法错误导致 tsx 无法加载。请执行 npx tsc --noEmit 检查。');
-        }
-        console.error('  服务已停止，请修复后执行 ec start。');
+    const launched = await launchPackageLifecycle('restart', console.log, { clear: opts.clear });
+    if (!launched.ok) {
+        console.error(`❌ 重启中止：restart-monitor 未能启动（${launched.reason}）；当前服务未主动停止`);
         process.exitCode = 1;
         return;
     }
-    console.log('🔄 Restart monitor started; service is coming back online in the background...');
-    // 代码统计（开发环境）
-    if (path.normalize(resolveRoot()) === path.normalize(getPackageRoot())) {
-        console.log('');
-        printCodeStats(getPackageRoot(), resolvePaths().logs);
-    }
+    console.log(`🔄 Restart monitor started (${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s); service is restarting...`);
 }
 function normalizeRuntimePath(value) {
     return value.replace(/[\\/]+/g, '/').toLowerCase();
@@ -1308,8 +1242,13 @@ export async function cmdStatus() {
         console.log('  请稍后再次执行 ec status。');
     }
     else {
-        console.log(ipcFailure ? '⚠ 无法确认 EvolCore 运行状态：IPC 不可用，且没有可见的存活 PID。' : '⚠ EvolCore is not running');
-        if (ipcFailure)
+        // With no live main/monitor, a missing Windows pipe is the normal stopped
+        // state. Preserve uncertainty for permissions, timeouts, unknown errors,
+        // and Unix callers that may be isolated from the daemon's PID namespace.
+        const stopped = !ipcFailure || (platform.isWindows && ipcFailure instanceof IpcTransportError
+            && ['ENOENT', 'ECONNREFUSED'].includes(ipcFailure.code));
+        console.log(stopped ? '⚠ EvolCore is not running' : '⚠ 无法确认 EvolCore 运行状态：IPC 不可用，且没有可见的存活 PID。');
+        if (!stopped && ipcFailure)
             console.log(`  ${ipcFailure instanceof Error ? ipcFailure.message : String(ipcFailure)}`);
     }
     // Session & Project statistics (从文件系统读)
@@ -2720,17 +2659,18 @@ function findAliveEcweb(p) {
     return alive[0] ?? null;
 }
 /**
- * 轻量 HTTP 就绪探测：GET / 返回 2xx 即视为就绪。
- * 不走 /api/pair-code（会触发配对码刷新副作用），不走 /api/health（不存在）。
- * 根路径由 serveStatic 处理，返回 index.html，无副作用。
+ * 轻量 HTTP 就绪探测：ECWeb 的健康端点必须返回明确的服务标识。
+ * 不走 /api/pair-code（会触发配对码刷新副作用），也不依赖静态页面内容。
  */
 async function probeEcwebReady(port) {
     try {
-        const res = await fetch(`http://127.0.0.1:${port}/`, {
-            method: 'GET',
+        const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
             signal: AbortSignal.timeout(2000),
         });
-        return res.ok;
+        if (!res.ok)
+            return false;
+        const body = await res.json();
+        return body.ok === true && body.service === 'ecweb';
     }
     catch {
         return false;
@@ -2756,8 +2696,9 @@ async function waitForExistingEcweb(p, timeoutMs = 3_000) {
 }
 /**
  * 输出 ECWeb 状态。判定口径：
- *   1. 进程是否存活（instance/ 下的 pid 文件 + isProcessRunning）
- *   2. HTTP 是否就绪——探测根路径 /（serveStatic → index.html, 无副作用）。
+ *   1. HTTP 是否就绪——探测 ECWeb 专用 /api/health 端点。
+ *   2. 进程是否存活（instance/ 下的 pid 文件 + isProcessRunning）仅用于补充诊断；
+ *      某些 CLI 运行在隔离 PID namespace 中，看不到宿主 ECWeb PID 是正常情况。
  */
 async function printEcwebStatus(p) {
     try {
@@ -2773,6 +2714,15 @@ async function printEcwebStatus(p) {
         // still provide an authoritative runtime status without local config access.
     }
     const entries = readEcwebInstanceEntries(p);
+    // Probe before consulting PID visibility. The daemon and CLI can be in
+    // different PID namespaces while sharing the host network namespace.
+    let readyEntry;
+    for (const entry of entries) {
+        if (await probeEcwebReady(entry.record.port)) {
+            readyEntry = entry;
+            break;
+        }
+    }
     const aliveEntries = [];
     for (const entry of entries) {
         if (platform.isProcessRunning(entry.record.pid)) {
@@ -2781,22 +2731,21 @@ async function printEcwebStatus(p) {
         else {
             // A stale EC Web record must never be used to report the PID of an
             // unrelated process that later inherited the port.
-            try {
-                fs.unlinkSync(entry.filePath);
+            // Keep a record whose dedicated health endpoint just proved live: the
+            // PID may be hidden by a namespace boundary rather than actually dead.
+            if (entry.filePath !== readyEntry?.filePath) {
+                try {
+                    fs.unlinkSync(entry.filePath);
+                }
+                catch { }
             }
-            catch { }
-        }
-    }
-    let readyEntry;
-    for (const entry of aliveEntries) {
-        if (await probeEcwebReady(entry.record.port)) {
-            readyEntry = entry;
-            break;
         }
     }
     if (readyEntry) {
         console.log('');
-        console.log(`🔭 ECWeb: 运行中 (PID: ${readyEntry.record.pid})  http://localhost:${readyEntry.record.port}`);
+        const pidVisible = aliveEntries.some(entry => entry.filePath === readyEntry.filePath);
+        const pidText = pidVisible ? `PID: ${readyEntry.record.pid}` : `PID: ${readyEntry.record.pid}（当前 namespace 不可见）`;
+        console.log(`🔭 ECWeb: 运行中 (${pidText})  http://localhost:${readyEntry.record.port}`);
         return;
     }
     const occupiedPids = new Set();
@@ -2991,7 +2940,7 @@ export async function startEcwebIfEnabled(p, options = {}) {
             console.log(`✓ ECWeb ${actionLabel} (PID: ${pid})  http://localhost:${port}`);
             if (pair) {
                 const mins = Math.max(0, Math.round((pair.expiresAt - Date.now()) / 60000));
-                console.log(`   配对码: ${pair.code}  (约 ${mins} 分钟内有效，已配对过的浏览器无需重新配对)`);
+                console.log(`   配对码: ${pair.code}  (约 ${mins} 分钟内有效，仅可配对一次，已配对过的浏览器无需重新配对)`);
             }
             else {
                 console.log('   daemon 尚未提供配对码；EvolCore 启动后可通过 /pair 或 ECWeb 页面获取');
@@ -3027,7 +2976,7 @@ async function printEcwebAccess(port) {
     }
     if (pair) {
         const mins = Math.max(0, Math.round((pair.expiresAt - Date.now()) / 60000));
-        console.log(`   配对码: ${pair.code}  (约 ${mins} 分钟内有效，配对后远程访问 token 缓存 30 天)`);
+        console.log(`   配对码: ${pair.code}  (约 ${mins} 分钟内有效，仅可配对一次，token 缓存 7 天，有访问自动续期)`);
     }
     else {
         console.log('   配对码: 暂不可用（稍后重试 ec watch web，或查看 logs/watch-web.log）');

package/dist/cli/diag.js

@@ -1,11 +1,11 @@
 import { ipcQuery } from '../ipc.js';
 import { resolvePaths } from '../paths.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { readDelegationCredential } from '../core/auth/agent-delegation.js';
 import { parseDiagArgs } from '../core/command/diag-service.js';
 import { wantsHelp } from './help.js';
 export async function cmdDiag(args) {
     if (wantsHelp(args)) {
-        console.log('用法：ec diag <问题描述> [--owner <daemonOwner-aid>] [--format json]\n      ec diag stop [--format json]\n未指定 --owner 时联系本机 daemon.json.owners[0]。');
+        console.log('用法：ec diag <问题描述> [--owner <daemonOwner-aid>] [--format json]\n      ec diag stop [--format json]\n未指定 --owner 时联系本机 daemon.json.owners[0]；有效诊断期间再次执行会追加到原 case。');
         return;
     }
     const json = args.at(-2) === '--format' && args.at(-1) === 'json';
@@ -17,7 +17,7 @@ export async function cmdDiag(args) {
             type: 'diag', argv,
             ...(process.env.EVOLCORE_SESSION_ID ? {
                 sessionId: process.env.EVOLCORE_SESSION_ID,
-                delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+                delegationToken: readDelegationCredential(),
             } : {}),
         }, 30_000) ?? { ok: false, code: 'DAEMON_UNAVAILABLE', message: 'daemon 未返回结果，请检查其运行状态；发送结果尚未确认' };
     }

package/dist/cli/fs-command.js

@@ -5,8 +5,8 @@ import { getArgValue, isHelpFlag, wantsHelp } from './help.js';
 import { agentmdGet, getAidStore, isValidAid, loadClient, SLOT } from '../aun/aid/index.js';
 import { ipcQuery } from '../ipc.js';
 import { resolvePaths } from '../paths.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
-import { downloadGroupFsBytes } from '../aun/group-fs-download.js';
+import { AGENT_DELEGATION_TOKEN_ENV, readDelegationCredential } from '../core/auth/agent-delegation.js';
+import { downloadGroupFsBytes } from '../aun/group/index.js';
 class FsCliError extends Error {
     code;
     suggestion;
@@ -209,7 +209,7 @@ export async function cmdFs(args) {
 }
 async function runManagedFs(args, formatJson) {
     const sessionId = process.env.EVOLCORE_SESSION_ID;
-    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    const delegationToken = readDelegationCredential();
     const fail = (code, message) => {
         if (formatJson)
             console.log(JSON.stringify({ ok: false, code, error: message }));

package/dist/cli/handoff-command.js

@@ -4,7 +4,7 @@ import { ipcQuery } from '../ipc.js';
 import { HANDOFF_QUERY_DEFAULT_LIMIT, HANDOFF_QUERY_MAX_LIMIT, HANDOFF_STATES } from '../core/handoff/types.js';
 import { HANDOFF_ID_RE } from '../core/handoff/store.js';
 import { isHelpFlag, wantsHelp } from './help.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { readDelegationCredential } from '../core/auth/agent-delegation.js';
 function parseLimit(value) {
     const limit = Number(value);
     if (!value || !Number.isInteger(limit) || limit < 1 || limit > HANDOFF_QUERY_MAX_LIMIT) {
@@ -186,7 +186,7 @@ Commands:
             sessionId: process.env.EVOLCORE_SESSION_ID,
             handoffId: parsed.handoffId,
             content: parsed.content,
-            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+            delegationToken: readDelegationCredential(),
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -216,7 +216,7 @@ Commands:
             sessionId: process.env.EVOLCORE_SESSION_ID,
             handoffId: parsed.handoffId,
             content: parsed.content,
-            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+            delegationToken: readDelegationCredential(),
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -235,7 +235,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-status', sessionId: process.env.EVOLCORE_SESSION_ID, handoffId,
-            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+            delegationToken: readDelegationCredential(),
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -267,7 +267,7 @@ Commands:
             state: parsed.state,
             filterSessionId: parsed.sessionId,
             limit: parsed.limit,
-            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+            delegationToken: readDelegationCredential(),
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -310,7 +310,7 @@ Commands:
             agent: parsed.agent,
             handoffId: parsed.handoffId,
             limit: parsed.limit,
-            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+            delegationToken: readDelegationCredential(),
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');

package/dist/cli/index.js

@@ -5,7 +5,7 @@ import fs from 'fs';
 import path from 'path';
 import { getPackageRoot, resolvePaths } from '../paths.js';
 import { ipcQuery } from '../ipc.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { readDelegationCredential } from '../core/auth/agent-delegation.js';
 import { cmdInit } from './init.js';
 import { cmdInitWechat, cmdInitFeishu, cmdInitDingtalk, cmdInitQQBot, cmdInitWecom, cmdInitAun } from './init-channel.js';
 import { isHelpFlag, wantsHelp, getArgValue } from './help.js';
@@ -34,6 +34,7 @@ Agent 与会话:
   agent             管理 EvolAgent
   ctl               当前托管会话的控制命令
   queue             查询或操作 agent 消息队列
+  task              恢复暂停或异常中断的会话任务
   trigger           管理定时与事件触发器
   handoff           查询和完成跨会话回流
   model             查看或设置模型与推理强度
@@ -247,7 +248,7 @@ export async function main(args) {
             }
             if (process.env.EVOLCORE_SESSION_ID) {
                 const sessionId = process.env.EVOLCORE_SESSION_ID;
-                const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+                const delegationToken = readDelegationCredential();
                 const result = await ipcQuery(resolvePaths().socket, {
                     type: 'status.auth', sessionId, delegationToken,
                 });
@@ -328,6 +329,11 @@ export async function main(args) {
         case 'queue':
             await cmdQueue(args.slice(1));
             break;
+        case 'task': {
+            const { cmdTask } = await import('./task-command.js');
+            await cmdTask(args.slice(1));
+            break;
+        }
         case 'trigger':
             {
                 const { cmdTrigger } = await import('./trigger-command.js');

package/dist/cli/init.js

@@ -7,7 +7,7 @@ import { commandExists } from '../utils/cross-platform.js';
 import { scanInstances } from '../utils/instance-registry.js';
 import { saveDefaultsSafe, loadAllAgents, loadDaemonConfig, saveDaemonConfig } from '../config-store.js';
 import { ecwebService, setEcwebEnabled } from '../config/daemon-services.js';
-import { generateControlAid, resolveControlAidDomain } from '../aun/aid/control-aid.js';
+import { ensureControlAgentMd, generateControlAid, resolveControlAidDomain } from '../aun/aid/control-aid.js';
 import { getCodexAppServerAvailability } from '../agents/codex-runner.js';
 import { DEFAULT_ECAGENT_BASE_URL, resolveEcagentConfig } from '../agents/baseagent.js';
 import { defaultProjectsRoot } from '../utils/project-path.js';
@@ -484,6 +484,12 @@ export async function initTail(options = {}) {
     let ownerBindingInterrupted = false;
     if (daemonConfig.aid) {
         console.log(`✓ 控制 AID 已存在: ${daemonConfig.aid}`);
+        try {
+            await ensureControlAgentMd(daemonConfig.aid);
+        }
+        catch (e) {
+            console.error(`⚠️ 控制 AID agent.md 补全失败（本次继续，后续启动会重试）: ${e?.message || e}`);
+        }
     }
     else {
         try {
@@ -861,6 +867,33 @@ export async function cmdInitNonInteractive(opts, dependencies = {}) {
             fail('CONTROL_AID_CREATE_FAILED', `control AID creation failed: ${e?.message || e}`, EXIT_RUNTIME, format);
         }
     }
+    if (controlAid) {
+        const certPath = path.join(resolvePaths().root, 'AIDs', controlAid, 'public', 'cert.pem');
+        if (!fs.existsSync(certPath)) {
+            // An externally supplied/pre-created AID without a local certificate
+            // cannot be signed or uploaded by this process. Avoid entering the SDK
+            // network path during non-interactive init; later daemon startup can
+            // retry once the identity material is provisioned.
+            console.error(`control AID agent.md publish skipped: local certificate not found for ${controlAid}`);
+        }
+        else {
+            try {
+                await ensureControlAgentMd(controlAid);
+            }
+            catch (e) {
+                // A registered control AID remains usable when the Name Service is
+                // temporarily unavailable; startup and the next init retry publication.
+                if (format === 'json') {
+                    // Keep the successful init result machine-readable; surface the
+                    // warning through stderr so stdout remains valid JSON.
+                    console.error(`control AID agent.md publish warning: ${e?.message || e}`);
+                }
+                else {
+                    console.error(`⚠️ 控制 AID agent.md 补全失败（本次继续，后续启动会重试）: ${e?.message || e}`);
+                }
+            }
+        }
+    }
     // ── 9. 写 daemon.json（aid + owners + ecweb）──
     try {
         const next = {

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

@@ -20,6 +20,7 @@ const MANAGED_TASK_COMMANDS = new Set([
     'stats',
     'status',
     'storage',
+    'task',
     'trigger',
     'version',
     '-v',
@@ -30,7 +31,7 @@ export class ManagedCommandNotAllowedError extends Error {
     command;
     code = 'NOT_ALLOWED';
     constructor(command) {
-        super(`Command ${command} is not available in a managed Agent task`);
+        super(`Command ${command} is not available in a managed Agent task; run it from the host terminal after the task completes`);
         this.command = command;
         this.name = 'ManagedCommandNotAllowedError';
     }

package/dist/cli/menu-client.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { getArgValue, wantsHelp } from './help.js';
-import { executeMenuClientRequest, MenuClientError } from '../aun/menu-client.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { executeMenuClientRequest, MenuClientError } from '../aun/menu/index.js';
+import { readDelegationCredential } from '../core/auth/agent-delegation.js';
 function parseDurationMs(value) {
     if (value === undefined)
         return undefined;
@@ -94,12 +94,16 @@ export async function cmdMenuClient(args) {
     }
     let response;
     if (process.env.EVOLCORE_SESSION_ID) {
-        const { ipcQuery } = await import('../ipc.js');
+        const { ipcQuery, IpcTransportError } = await import('../ipc.js');
         const { resolvePaths } = await import('../paths.js');
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'menu-client.request', argv: args, sessionId: process.env.EVOLCORE_SESSION_ID,
-            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
-        }, 250_000);
+            delegationToken: readDelegationCredential(),
+        }, 250_000, { throwOnError: true }).catch(error => {
+            if (!(error instanceof IpcTransportError))
+                throw error;
+            throw new MenuClientError(error.code, error.message);
+        });
         if (!result?.ok)
             throw new MenuClientError(result?.code ?? 'DAEMON_UNAVAILABLE', result?.error ?? 'Managed Menu daemon is unavailable');
         response = result.response;
@@ -107,4 +111,8 @@ export async function cmdMenuClient(args) {
     else
         response = await executeMenuClientRequest(parseMenuClientArgs(args));
     console.log(JSON.stringify(response, null, 2));
+    // Transport success does not imply the requested operation succeeded.
+    // Preserve the complete wire response for callers while failing the CLI.
+    if (response?.error)
+        process.exitCode = 1;
 }