evolcore 0.0.11 → 0.0.13

package/dist/cli/daemon-commands.js

@@ -14,21 +14,21 @@ 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, tryUpgradeAunSdk, tryUpgradeGlobalPkg, resolveGlobalPkg } from '../utils/npm-ops.js';
+import { tryUpgrade, tryUpgradeGlobalPkg, resolveGlobalPkg } from '../utils/npm-ops.js';
 import { ecwebVersionRequirementError, fetchEcwebPairCode, resolveEcwebLaunchCommand } from '../utils/ecweb-utils.js';
 import { isHostChinese } from '../utils/locale.js';
-import { resolveAunCoreSdkPkg, AUN_CORE_SDK_PKG } from '../aun/aid/client.js';
 import { scanInstances, cleanupInstances, findOrphanProcesses, killOrphans } from '../utils/instance-registry.js';
 import { filterLogFiles, deriveLogTypes, computePreChecked, validateLogTypes, shortLogName as shortLogNameLocal } 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 } from '../utils/process-introspect.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 { rotateStdoutLog } from '../utils/log-writer.js';
 import { inspectDataMigrationRequirement } from '../core/data-migration.js';
 import { isInitCancelledError, printInitCancelHint } from './init-cancel.js';
+import { listCodexAppServerProcesses, unregisterCodexAppServerProcess } from '../utils/codex-app-server-registry.js';
 const execFileAsync = promisify(execFile);
 async function runAutomaticInit(action) {
     try {
@@ -389,9 +389,6 @@ export async function cmdStart(opts = {}) {
     cleanEnv();
     // 在启动前确保 serviceProxy 配置完整（如果 ecweb 启用但 serviceProxy 未配置）
     ensureServiceProxyConfigBeforeStart(p);
-    const ecwebStartedBeforeDaemon = serviceProxyNeedsEcweb(loadDaemonConfig())
-        ? await startEcwebIfEnabled(p)
-        : false;
     // 删除旧的 ready signal
     try {
         fs.unlinkSync(p.readySignal);
@@ -421,23 +418,11 @@ 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 (!ecwebStartedBeforeDaemon) {
-                startEcwebIfEnabled(p)
-                    .then((ecwebStarted) => {
-                    if (shouldPrintNoSelfAgentHints) {
-                        printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted, skipped });
-                    }
-                })
-                    .catch((err) => {
-                    console.error(`⚠ ECWeb 启动检查失败: ${err instanceof Error ? err.message : String(err)}`);
-                    if (shouldPrintNoSelfAgentHints) {
-                        printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: false, skipped });
-                    }
-                });
-            }
-            else if (shouldPrintNoSelfAgentHints) {
-                printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: true, skipped });
-            }
+            void waitForExistingEcweb(p).then((ecweb) => {
+                if (shouldPrintNoSelfAgentHints) {
+                    printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: ecweb !== null, skipped });
+                }
+            });
         }, 500);
         let forwardingShutdown = false;
         const forwardSignal = (signal) => {
@@ -536,8 +521,9 @@ export async function cmdStart(opts = {}) {
                 printCodeStats(getPackageRoot(), p.logs);
             }
             console.log(`⏱ done in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
-            // ECWeb 自动后台启动
-            const ecwebStarted = ecwebStartedBeforeDaemon || await startEcwebIfEnabled(p);
+            // ECWeb lifecycle belongs to the daemon; the CLI only reports whether
+            // the supervised instance became healthy.
+            const ecwebStarted = await waitForExistingEcweb(p) !== null;
             if (shouldPrintNoSelfAgentHints) {
                 printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted, skipped });
             }
@@ -668,19 +654,7 @@ export async function cmdRestart(opts = {}) {
             console.log(`⚠ Upgrade failed (${upgrade.from} → ${upgrade.to}), continuing with current version`);
             break;
     }
-    // AUN SDK 版本检查与升级
-    const aunUpgrade = await tryUpgradeAunSdk(resolveAunCoreSdkPkg, AUN_CORE_SDK_PKG);
-    switch (aunUpgrade.status) {
-        case 'upgraded':
-            console.log(`✅ AUN SDK upgraded: ${aunUpgrade.from} → ${aunUpgrade.to}`);
-            break;
-        case 'no-update':
-            break; // silent
-        case 'failed':
-            console.log(`⚠ AUN SDK upgrade failed (${aunUpgrade.from} → ${aunUpgrade.to})`);
-            break;
-    }
-    // EC Web 版本检查与升级（已安装才检查，与 AUN SDK 同级）
+    // EC Web 是独立全局包，已安装时单独检查升级。
     const ecwebUpgrade = await tryUpgradeGlobalPkg(() => resolveGlobalPkg(WEB_PACKAGE_NAME), WEB_PACKAGE_NAME);
     switch (ecwebUpgrade.status) {
         case 'upgraded':
@@ -753,22 +727,20 @@ export async function cmdRestart(opts = {}) {
             reportOrphans(otherHome);
         }
     }
-    // 清理 codex app-server 孤儿进程（无 HOME 区分，全局清理）
+    // 只清理 EvolCore 自己登记的 codex app-server，不能影响桌面端实例。
     {
         const killed = stopCodexAppServerOrphans();
         if (killed > 0) {
-            console.log(`☠ 已清理 ${killed} 个 codex app-server 孤儿进程`);
+            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 内调用时自杀
     const appCli = path.join(getPackageRoot(), 'dist', 'cli', 'index.js');
-    spawn('node', [appCli, 'restart-monitor'], {
-        detached: true,
-        stdio: 'ignore',
-        env: { ...process.env, EVOLCORE_HOME: resolvePaths().root }
-    }).unref();
+    platform.spawnDetachedNode([appCli, 'restart-monitor'], {
+        EVOLCORE_HOME: resolvePaths().root,
+    });
     console.log('🔄 Restart monitor started, waiting for service to come back online...');
     await sleep(2000);
     // 代码统计（开发环境）
@@ -2436,6 +2408,24 @@ async function probeEcwebReady(port) {
         return false;
     }
 }
+/**
+ * Wait briefly for an already-launched ECWeb to become healthy.  `ec start`,
+ * restart-monitor, and the daemon can overlap by a few milliseconds; treating
+ * a healthy instance as an adoption target avoids killing/replacing it.
+ */
+async function waitForExistingEcweb(p, timeoutMs = 3_000) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+        for (const entry of findAliveEcwebs(p)) {
+            if (await probeEcwebReady(entry.port))
+                return entry;
+        }
+        if (Date.now() >= deadline)
+            break;
+        await sleep(250);
+    } while (true);
+    return null;
+}
 /**
  * 输出 ECWeb 状态。判定口径：
  *   1. 进程是否存活（instance/ 下的 pid 文件 + isProcessRunning）
@@ -2513,15 +2503,29 @@ function removeEcwebInstanceFiles(p) {
         catch { }
     }
 }
-/** 清理所有 codex app-server 孤儿进程，返回清理的进程数。 */
-function stopCodexAppServerOrphans() {
-    // 查找所有 codex app-server 进程（无论是 node 启动的还是原生二进制）
-    const codexProcs = platform.findProcesses('codex app-server');
+/** 清理 EvolCore 登记的 codex app-server 孤儿进程，返回清理的进程数。 */
+export function stopCodexAppServerOrphans() {
+    const codexProcs = new Set(platform.findProcesses('codex app-server'));
     let killed = 0;
-    for (const pid of codexProcs) {
+    for (const entry of listCodexAppServerProcesses()) {
+        const { pid, startedAt } = entry.record;
+        if (!platform.isProcessRunning(pid)) {
+            unregisterCodexAppServerProcess(entry.filePath);
+            continue;
+        }
+        // PID 复用时丢弃登记，不发送信号；命令行探测失败则保留登记，等待下次重试。
+        const actualStartedAt = getProcessStartTime(pid);
+        if (!startTimeMatches(startedAt, actualStartedAt)) {
+            unregisterCodexAppServerProcess(entry.filePath);
+            continue;
+        }
+        if (!codexProcs.has(pid))
+            continue;
         try {
-            platform.killProcess(pid, true);
-            killed++;
+            if (platform.killProcess(pid, true)) {
+                killed++;
+                unregisterCodexAppServerProcess(entry.filePath);
+            }
         }
         catch { }
     }
@@ -2633,10 +2637,21 @@ function ensureServiceProxyConfig(cfg, port) {
  * Kept public for restart-monitor, which launches the daemon directly and
  * therefore cannot rely on cmdStart's post-ready ECWeb startup path.
  */
-export async function startEcwebIfEnabled(p) {
+export async function startEcwebIfEnabled(p, options = {}) {
     const cfg = loadDaemonConfig();
     if (!cfg.ecweb?.enabled)
         return false;
+    // The daemon is the lifecycle owner.  CLI callers normally only need to
+    // ensure ECWeb is available, so adopt a healthy process instead of killing
+    // it.  `ec watch web` passes forceRestart explicitly for an intentional
+    // manual replacement.
+    if (!options.forceRestart) {
+        const existing = await waitForExistingEcweb(p);
+        if (existing) {
+            console.log(`✓ ECWeb 已在运行 (PID: ${existing.pid})  http://localhost:${existing.port}`);
+            return true;
+        }
+    }
     const installedPkg = resolveGlobalPkg(WEB_PACKAGE_NAME);
     if (!installedPkg) {
         console.log(`⚠ EC Web 未安装，跳过启动（运行 npm i -g ${WEB_PACKAGE_NAME}@latest 后可用）`);
@@ -2777,7 +2792,7 @@ async function cmdWatchWeb() {
         }
     }
     else {
-        // 已安装：检查并自动升级到最新版（参考 fastaun 自动升级机制）
+        // 已安装：检查并自动升级独立的 EC Web 全局包。
         const upgrade = await tryUpgradeGlobalPkg(() => resolveGlobalPkg(WEB_PACKAGE_NAME), WEB_PACKAGE_NAME);
         switch (upgrade.status) {
             case 'upgraded':
@@ -2795,7 +2810,7 @@ async function cmdWatchWeb() {
     saveDaemonConfig({ ...cfg, ecweb: { ...(cfg.ecweb ?? {}), enabled: true, port } });
     // 自动配置 serviceProxy（如果控制 AID 已配置）
     ensureServiceProxyConfigBeforeStart(p);
-    const ok = await startEcwebIfEnabled(p);
+    const ok = await startEcwebIfEnabled(p, { forceRestart: true });
     if (!ok)
         process.exit(1); // 失败原因已由 startEcwebIfEnabled 打印
     // 启动成功的访问信息已由 startEcwebIfEnabled 打印，无需 printEcwebAccess 重复输出

package/dist/cli/fs-command.js

@@ -3,6 +3,10 @@ import path from 'path';
 import { TextDecoder } from 'util';
 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';
 class FsCliError extends Error {
     code;
     suggestion;
@@ -130,6 +134,10 @@ export async function cmdFs(args) {
         console.log(HELP);
         return;
     }
+    if (process.env.EVOLCORE_SESSION_ID) {
+        await runManagedFs(args, opts.formatJson);
+        return;
+    }
     try {
         switch (sub) {
             case 'ls':
@@ -199,6 +207,74 @@ export async function cmdFs(args) {
         process.exit(1);
     }
 }
+async function runManagedFs(args, formatJson) {
+    const sessionId = process.env.EVOLCORE_SESSION_ID;
+    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    const fail = (code, message) => {
+        if (formatJson)
+            console.log(JSON.stringify({ ok: false, code, error: message }));
+        else
+            console.error(`❌ ${message}`);
+        process.exit(1);
+    };
+    if (!sessionId)
+        fail('NO_SESSION', 'EVOLCORE_SESSION_ID is not set');
+    if (!delegationToken)
+        fail('DELEGATION_REQUIRED', `${AGENT_DELEGATION_TOKEN_ENV} is not set for the active task`);
+    const response = await ipcQuery(resolvePaths().socket, {
+        type: 'fs.op',
+        argv: ['fs', ...args],
+        sessionId,
+        delegationToken,
+    }, 30_000);
+    if (!response)
+        return fail('DAEMON_UNAVAILABLE', 'Unable to connect to the evolcore daemon');
+    if (!response.ok || !response.result)
+        fail(String(response.code || 'FS_OPERATION_FAILED'), response.error || 'Filesystem operation failed');
+    const result = response.result;
+    if (formatJson) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    switch (result.command) {
+        case 'cat':
+            if (result.binary)
+                console.log(JSON.stringify({ path: result.path, size: result.size, binary: true, head: result.head }, null, 2));
+            else
+                process.stdout.write(String(result.text ?? '').endsWith('\n') ? result.text : `${result.text ?? ''}\n`);
+            return;
+        case 'df': {
+            const usage = result.usage ?? {};
+            console.log(`Filesystem: ${result.path}`);
+            console.log(JSON.stringify(usage, null, 2));
+            return;
+        }
+        case 'stat':
+        case 'lstat':
+            console.log(JSON.stringify(result.node ?? {}, null, 2));
+            return;
+        case 'ls':
+        case 'find':
+            for (const item of result.items ?? [])
+                console.log(JSON.stringify(item));
+            return;
+        case 'mkdir':
+            console.log(`✓ 已创建目录: ${result.path}`);
+            return;
+        case 'upload':
+            console.log(`✓ 已上传: ${result.localPath} -> ${result.path}`);
+            return;
+        case 'copy':
+            console.log(`✓ 已复制: ${result.src} -> ${result.path}`);
+            return;
+        case 'move':
+            console.log(`✓ 已移动: ${result.src} -> ${result.path}`);
+            return;
+        case 'remove':
+            console.log(`✓ 已删除: ${result.path}`);
+            return;
+    }
+}
 function parseCommonOptions(args) {
     const maxCatBytesRaw = getArgValue(args, '--max-bytes');
     const maxCatBytes = maxCatBytesRaw === undefined ? 1024 * 1024 : Number(maxCatBytesRaw);
@@ -325,8 +401,9 @@ async function fsCat(args, opts) {
         if (route.backend === 'group') {
             statInfo = await client.group.fs.stat(remoteRef(target));
             const size = numberFrom(statInfo, ['size', 'size_bytes', 'bytes']);
-            const downloaded = await client.group.fs.cp(remoteRef(target), { kind: 'blob' }, { verifyHash: true });
-            bytes = bytesFromDownload(downloaded);
+            const downloaded = await downloadGroupFsBytes(client, remoteRef(target));
+            bytes = downloaded.bytes;
+            statInfo = { ...statInfo, ...downloaded.ticket };
             statInfo = { ...statInfo, size: bytes.byteLength };
             if (size !== undefined && size > opts.maxCatBytes) {
                 binaryHeadOnly = true;
@@ -1360,14 +1437,6 @@ function contentTypeFrom(value) {
     const raw = value?.contentType ?? value?.content_type ?? value?.mime ?? value?.mime_type;
     return raw ? String(raw).toLowerCase() : undefined;
 }
-function bytesFromDownload(value) {
-    const data = value?.data;
-    if (data instanceof Uint8Array)
-        return data;
-    if (data instanceof ArrayBuffer)
-        return new Uint8Array(data);
-    throw new FsCliError('BACKEND_ERROR', '下载接口未返回字节内容', undefined, value);
-}
 function looksBinary(bytes, contentType) {
     if (contentType) {
         if (contentType.startsWith('text/'))

package/dist/cli/handoff-command.js

@@ -203,6 +203,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],
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -234,6 +235,7 @@ Commands:
             state: parsed.state,
             filterSessionId: parsed.sessionId,
             limit: parsed.limit,
+            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -276,6 +278,7 @@ Commands:
             agent: parsed.agent,
             handoffId: parsed.handoffId,
             limit: parsed.limit,
+            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');

package/dist/cli/index.js

@@ -3,7 +3,9 @@
 process.env.AUN_LOG_INI_DISABLE = '1';
 import fs from 'fs';
 import path from 'path';
-import { getPackageRoot } from '../paths.js';
+import { getPackageRoot, resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { AGENT_DELEGATION_TOKEN_ENV } 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';
@@ -16,6 +18,7 @@ import { cmdQueue } from './queue-command.js';
 import { cmdStart, cmdStop, cmdRestart, cmdStatus, cmdLogs, cmdWatchCommand, cmdMv, cmdDiagnose } from './daemon-commands.js';
 import { logCliCommand } from './command-log.js';
 import { isInitCancelledError, printInitCancelHint } from './init-cancel.js';
+import { assertManagedTopLevelCommandAllowed, ManagedCommandNotAllowedError } from './managed-command-guard.js';
 const MAIN_HELP = `用法: ec <command> [选项]
 
 服务:
@@ -87,6 +90,16 @@ process.on('warning', (w) => { if (w.name === 'ExperimentalWarning')
     return; process.stderr.write((w.stack ?? String(w)) + '\n'); });
 export async function main(args) {
     const cmd = args[0] || 'start';
+    try {
+        assertManagedTopLevelCommandAllowed(cmd, args);
+    }
+    catch (error) {
+        if (!(error instanceof ManagedCommandNotAllowedError))
+            throw error;
+        console.error(`❌ [${error.code}] ${error.message}`);
+        process.exitCode = 1;
+        return;
+    }
     logCliCommand(cmd, args);
     if (cmd === '--version' || cmd === '-v' || cmd === '-V') {
         const pkg = JSON.parse(fs.readFileSync(path.join(getPackageRoot(), 'package.json'), 'utf-8'));
@@ -229,7 +242,22 @@ export async function main(args) {
                 printLifecycleHelp('status');
                 break;
             }
-            await cmdStatus();
+            if (process.env.EVOLCORE_SESSION_ID) {
+                const sessionId = process.env.EVOLCORE_SESSION_ID;
+                const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+                const result = await ipcQuery(resolvePaths().socket, {
+                    type: 'status.auth', sessionId, delegationToken,
+                });
+                if (!result?.ok) {
+                    console.error(`❌ ${result?.error || 'status is not allowed in this task'}`);
+                    process.exitCode = 1;
+                    break;
+                }
+                await cmdStatus();
+            }
+            else {
+                await cmdStatus();
+            }
             break;
         case 'logs':
             if (wantsHelp(args.slice(1))) {

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 { generateControlAid, resolveControlAidDomain } from '../aun/aid/control-aid.js';
-import { getCodexAppServerAvailability, isCodexAppServerAvailable } from '../agents/codex-runner.js';
+import { getCodexAppServerAvailability } from '../agents/codex-runner.js';
 import { resolveEcagentConfig } from '../agents/baseagent.js';
 import { defaultProjectsRoot } from '../utils/project-path.js';
 import { WEB_CLI_BIN, WEB_PACKAGE_LATEST } from '../product.js';
@@ -28,15 +28,44 @@ export function expandLeadingTildePath(value, homeDir = os.homedir()) {
 }
 const BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini', 'ecagent'];
 const AUTO_BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini'];
-function isBaseagentAvailable(baseagent) {
+function isBaseagentAvailable(baseagent, codexAvailability) {
     if (baseagent === 'codex')
-        return isCodexAppServerAvailable();
+        return (codexAvailability ?? getCodexAppServerAvailability()).available;
     if (baseagent === 'ecagent')
         return true;
     return commandExists(baseagent);
 }
-function detectAvailable() {
-    return BASEAGENT_CANDIDATES.filter(isBaseagentAvailable);
+function detectAvailable(codexAvailability = getCodexAppServerAvailability()) {
+    return BASEAGENT_CANDIDATES.filter(baseagent => isBaseagentAvailable(baseagent, codexAvailability));
+}
+/** Offer installation only when the probe positively identified an old CLI. */
+export async function maybeUpgradeCodexForInit(availability, dependencies) {
+    if (!availability.requiresUpgrade) {
+        return { availability, offered: false, accepted: false };
+    }
+    const accepted = await dependencies.confirm();
+    if (!accepted)
+        return { availability, offered: true, accepted: false };
+    try {
+        const install = dependencies.install ?? (async () => {
+            const { npmInstallGlobal } = await import('../utils/npm-ops.js');
+            await npmInstallGlobal('@openai/codex@latest');
+        });
+        await install();
+    }
+    catch (error) {
+        return {
+            availability,
+            offered: true,
+            accepted: true,
+            error: installErrorMessage(error),
+        };
+    }
+    return {
+        availability: (dependencies.probe ?? getCodexAppServerAvailability)(),
+        offered: true,
+        accepted: true,
+    };
 }
 function pickDefault(available) {
     return AUTO_BASEAGENT_CANDIDATES.find(candidate => available.includes(candidate));
@@ -192,7 +221,45 @@ export async function cmdInit(options) {
         return false;
     }
     // ── 2. 探测 baseagent ──
-    const available = detectAvailable();
+    let codexAvailability = getCodexAppServerAvailability();
+    if (!options?.nonInteractive && codexAvailability.version) {
+        console.log(`检测到 Codex CLI: ${codexAvailability.version}`);
+    }
+    if (!options?.nonInteractive && codexAvailability.requiresUpgrade) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        let result;
+        try {
+            result = await maybeUpgradeCodexForInit(codexAvailability, {
+                confirm: async () => {
+                    console.log(`⚠ ${codexAvailability.reason}`);
+                    const answer = (await ask(rl, '是否立即升级 Codex CLI？[Y/n] ')).trim().toLowerCase();
+                    return answer === '' || answer === 'y' || answer === 'yes';
+                },
+            });
+        }
+        finally {
+            try {
+                rl.close();
+            }
+            catch { /* ignore */ }
+        }
+        if (!result.accepted) {
+            console.log('  已跳过 Codex CLI 升级');
+        }
+        else if (result.error) {
+            console.log(`  ⚠ Codex CLI 升级失败: ${result.error}`);
+        }
+        else {
+            codexAvailability = result.availability;
+            if (codexAvailability.available) {
+                console.log(`  ✓ Codex CLI 已升级至 ${codexAvailability.version}`);
+            }
+            else {
+                console.log(`  ⚠ Codex CLI 升级后仍不可用: ${codexAvailability.reason ?? '未知原因'}`);
+            }
+        }
+    }
+    const available = detectAvailable(codexAvailability);
     if (available.length === 0 || (available.length === 1 && available[0] === 'ecagent' && ecagentUnavailableReason())) {
         console.log('❌ 未检测到可用 baseagent。请安装至少一款：');
         console.log('  - claude CLI');
@@ -202,8 +269,10 @@ export async function cmdInit(options) {
         return false;
     }
     console.log('检测到可用的 baseagent:');
-    for (const b of available)
-        console.log(`  ● ${b}`);
+    for (const b of available) {
+        const version = b === 'codex' ? codexAvailability.version : undefined;
+        console.log(`  ● ${b}${version ? ` (CLI ${version})` : ''}`);
+    }
     console.log('');
     const defaultsPath = p.defaultsConfig;
     const defaultsExisted = fs.existsSync(defaultsPath);

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

@@ -0,0 +1,41 @@
+import { wantsHelp } from './help.js';
+const MANAGED_TASK_COMMANDS = new Set([
+    'aid',
+    'agent',
+    'config',
+    'contact',
+    'ctl',
+    'fs',
+    'group',
+    'handoff',
+    'model',
+    'msg',
+    'queue',
+    'response',
+    'status',
+    'storage',
+    'trigger',
+    'version',
+    '-v',
+    '-V',
+    '--version',
+]);
+export class ManagedCommandNotAllowedError extends Error {
+    command;
+    code = 'NOT_ALLOWED';
+    constructor(command) {
+        super(`Command ${command} is not available in a managed Agent task`);
+        this.command = command;
+        this.name = 'ManagedCommandNotAllowedError';
+    }
+}
+/**
+ * Local maintenance commands do not have daemon authorization entrypoints.
+ * Keep them outside managed tasks so they cannot read or mutate host state.
+ */
+export function assertManagedTopLevelCommandAllowed(command, args, env = process.env) {
+    if (!env.EVOLCORE_SESSION_ID || wantsHelp(args.slice(1)) || command === '--help' || command === '-h')
+        return;
+    if (!MANAGED_TASK_COMMANDS.has(command))
+        throw new ManagedCommandNotAllowedError(command);
+}

package/dist/cli/model.js

@@ -46,10 +46,8 @@ function fail(formatJson, code, message, data) {
     process.exit(1);
 }
 function isManagedSessionEnv(args) {
-    return !!process.env.EVOLCORE_SESSION_ID
-        && !getArgValue(args, '--self')
-        && !getArgValue(args, '--peer')
-        && !getArgValue(args, '--role');
+    void args;
+    return !!process.env.EVOLCORE_SESSION_ID;
 }
 function isManagedTargetedWriteEnv(args) {
     return !!process.env.EVOLCORE_SESSION_ID
@@ -368,6 +366,11 @@ async function cmdInfo(args, formatJson) {
     const modelId = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
     if (!modelId)
         fail(formatJson, 'MISSING_MODEL_ID', 'info 需要 <model-id>');
+    if (isManagedSessionEnv(args)) {
+        const out = await runCtlCommand(`/model info ${modelId}`, formatJson);
+        printCtlResult(out, formatJson);
+        return;
+    }
     const sel = parseSelector(args, formatJson);
     const self = getArgValue(args, '--self');
     const info = await getModelInfo(modelId, self);
@@ -587,5 +590,9 @@ export async function cmdModel(args) {
         console.log(HELP);
         return;
     }
+    if (process.env.EVOLCORE_SESSION_ID
+        && (getArgValue(args, '--self') || getArgValue(args, '--peer') || getArgValue(args, '--role'))) {
+        fail(formatJson, 'NOT_ALLOWED', 'Managed model commands cannot select --self, --peer, or --role; they always use the authenticated current relation');
+    }
     await dispatch(sub, args, formatJson);
 }