c0de-agent 1.9.0 → 1.11.0

package/dist/update/ipc.d.ts

@@ -7,9 +7,42 @@ type HandoffServer = {
     port: number;
     close: () => Promise<void>;
 };
-/** 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff（序列化 + 退出）。 */
-declare function createHandoffServer(onHandoff: () => Promise<void>): Promise<HandoffServer>;
-/** 新实例请求旧实例让出端口（graceful shutdown）。失败抛错。 */
-declare function requestHandoff(port: number, host?: string): Promise<void>;
-export type { HandoffServer };
+type HandoffOptions = {
+    /**
+     * 期望的 Bearer token。设置后 /handoff 必须携带匹配的 Authorization 头，
+     * 否则 401——防止任意本地进程用 POST /handoff 杀掉服务。
+     * 旧实例与新实例读同一 auth-token 文件（或同一 config token），天然匹配。
+     */
+    expectedToken?: string;
+    /**
+     * 自定义校验函数（P2-16：token 轮换后新旧实例 bootstrap 可能不同，
+     * 用 authManager.verifyHandoff 接受当前/历史 bootstrap 与设备 token）。
+     * 提供时优先于 expectedToken。
+     */
+    verify?: (token: string | undefined) => boolean;
+    /**
+     * 响应发出后退出进程（旧实例完整让渡：主服务与资源已在 onHandoff 中关闭）。
+     * 退出延迟 250ms 保证 HTTP 响应刷出；不设时仅响应不退出（测试用）。
+     */
+    exitAfterResponse?: boolean;
+};
+/**
+ * requestHandoff 抛出的可区分错误（调用方据此分流处理）：
+ * - kind='connect'：连接层失败（ECONNREFUSED 等）——旧实例未启 handoff 端点，
+ *   调用方应直接尝试绑端口；
+ * - kind='http'：收到 HTTP 响应但非 2xx（status 为状态码）——如 401 token
+ *   不匹配、500 onHandoff 失败，旧实例存在但拒绝/未能让渡。
+ */
+type HandoffError = Error & {
+    kind: 'connect' | 'http';
+    status?: number;
+};
+/**
+ * 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff
+ * （关闭主服务与资源），响应 200；exitAfterResponse 时随后退出进程。
+ */
+declare function createHandoffServer(onHandoff: () => Promise<void>, opts?: HandoffOptions): Promise<HandoffServer>;
+/** 新实例请求旧实例让出端口（graceful shutdown）。失败抛可区分的 HandoffError。 */
+declare function requestHandoff(port: number, host?: string, token?: string): Promise<void>;
+export type { HandoffError, HandoffOptions, HandoffServer };
 export { createHandoffServer, requestHandoff };

package/dist/update/ipc.js

@@ -1,17 +1,48 @@
+import { timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-/** 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff（序列化 + 退出）。 */
-function createHandoffServer(onHandoff) {
+/**
+ * 恒时比较 Authorization 头与期望值：字符串直接比较可被时序攻击逐字符探测。
+ * 长度不等直接 false——timingSafeEqual 要求等长 buffer，先比较长度本身
+ * 不泄露内容信息。
+ */
+function authHeaderMatches(actual, expected) {
+    if (typeof actual !== 'string' || actual.length !== expected.length)
+        return false;
+    return timingSafeEqual(Buffer.from(actual), Buffer.from(expected));
+}
+/**
+ * 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff
+ * （关闭主服务与资源），响应 200；exitAfterResponse 时随后退出进程。
+ */
+function createHandoffServer(onHandoff, opts = {}) {
     return new Promise((resolve, reject) => {
+        const expected = opts.expectedToken && opts.expectedToken.length > 0 ? `Bearer ${opts.expectedToken}` : '';
         const handler = async (req, res) => {
             if (req.method === 'POST' && req.url === '/handoff') {
+                const authorized = opts.verify
+                    ? opts.verify(req.headers.authorization?.replace(/^Bearer\s+/i, ''))
+                    : expected.length > 0
+                        ? authHeaderMatches(req.headers.authorization, expected)
+                        : true;
+                if (!authorized) {
+                    res.writeHead(401, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+                    return;
+                }
                 try {
                     await onHandoff();
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: true }));
+                    // 仅 200 才调度退出：500 时 exit(0) 会掩盖让渡失败——保留进程供
+                    // 诊断/重试，由下方错误日志暴露 onHandoff 失败原因。
+                    if (opts.exitAfterResponse) {
+                        setTimeout(() => process.exit(0), 250);
+                    }
                 }
                 catch (error) {
                     res.writeHead(500, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: String(error) }));
+                    console.error('[handoff] onHandoff failed, keeping process alive:', error);
                 }
                 return;
             }
@@ -32,10 +63,28 @@ function createHandoffServer(onHandoff) {
         });
     });
 }
-/** 新实例请求旧实例让出端口（graceful shutdown）。失败抛错。 */
-async function requestHandoff(port, host = '127.0.0.1') {
-    const res = await fetch(`http://${host}:${port}/handoff`, { method: 'POST' });
-    if (!res.ok)
-        throw new Error(`handoff failed: HTTP ${res.status}`);
+/** 新实例请求旧实例让出端口（graceful shutdown）。失败抛可区分的 HandoffError。 */
+async function requestHandoff(port, host = '127.0.0.1', token) {
+    let res;
+    try {
+        res = await fetch(`http://${host}:${port}/handoff`, {
+            method: 'POST',
+            ...(token ? { headers: { Authorization: `Bearer ${token}` } } : {}),
+        });
+    }
+    catch (err) {
+        // 连接层失败（ECONNREFUSED 等）：旧实例无 handoff 端点。抛 kind='connect'
+        // 让调用方（requestHandoffWithRetry）区分处理——直接尝试绑端口。
+        const error = new Error(`handoff connect failed: ${err instanceof Error ? err.message : String(err)}`);
+        error.kind = 'connect';
+        throw error;
+    }
+    if (!res.ok) {
+        // 收到 HTTP 响应但非 2xx（如 401 token 不匹配、500 onHandoff 失败）。
+        const error = new Error(`handoff failed: HTTP ${res.status}`);
+        error.kind = 'http';
+        error.status = res.status;
+        throw error;
+    }
 }
 export { createHandoffServer, requestHandoff };

package/dist/update/snapshot.d.ts

@@ -7,6 +7,10 @@ type SerializedSession = {
     projectId: string | null;
     branchPoint: number | null;
     metadata: unknown;
+    agentType: string | null;
+    worktreePath: string | null;
+    source: string | null;
+    deletedAt: number | null;
     createdAt: number;
     updatedAt: number;
 };

package/dist/update/snapshot.js

@@ -15,6 +15,10 @@ function toSerializedSession(row) {
         projectId: row.projectId,
         branchPoint: row.branchPoint,
         metadata: row.metadata,
+        agentType: row.agentType,
+        worktreePath: row.worktreePath,
+        source: row.source,
+        deletedAt: row.deletedAt ? toDateMs(row.deletedAt) : null,
         createdAt: toDateMs(row.createdAt),
         updatedAt: toDateMs(row.updatedAt),
     };
@@ -75,6 +79,10 @@ async function restoreSessions(handle, snapshot) {
             projectId: s.projectId,
             branchPoint: s.branchPoint,
             metadata: s.metadata,
+            agentType: s.agentType,
+            worktreePath: s.worktreePath,
+            source: s.source,
+            deletedAt: s.deletedAt != null ? new Date(s.deletedAt) : null,
             createdAt: new Date(s.createdAt),
             updatedAt: new Date(s.updatedAt),
         })

package/dist/update/updater.d.ts

@@ -3,6 +3,7 @@ import type { SessionSnapshot } from './snapshot.js';
 type HotUpdateResult = {
     _tag: 'success';
     snapshotPath: string;
+    installMethod: string;
 } | {
     _tag: 'install_failed';
     error: string;
@@ -11,16 +12,34 @@ type HotUpdateResult = {
     _tag: 'spawn_failed';
     error: string;
     snapshotPath: string;
+} | {
+    _tag: 'manual_install_required';
+    error: string;
+    snapshotPath: string;
+    command: string;
+};
+/** 仅安装结果（无活跃 serve 的 CLI `c0de update --apply` 使用；不 spawn 新实例）。 */
+type InstallOnlyResult = {
+    _tag: 'success';
+    installMethod: string;
+} | {
+    _tag: 'install_failed';
+    error: string;
+} | {
+    _tag: 'manual_install_required';
+    error: string;
+    command: string;
 };
 /**
  * 启动新实例的函数签名。
  * @param snapshotPath 快照文件路径（旧实例已写入）
  * @param argv          传给新进程的完整参数（含 restore flag + 可选 handoff flag）
+ * @param opts          热更新选项（authToken 等经环境变量传递给新实例）
  */
-type SpawnFn = (snapshotPath: string, argv: string[]) => Promise<void>;
+type SpawnFn = (snapshotPath: string, argv: string[], opts?: HotUpdateOptions) => Promise<void>;
 type HotUpdateOptions = {
-    /** 自更新安装函数；默认 `npm install -g <pkg>`。 */
-    installFn?: (pkg: string) => Promise<void>;
+    /** 自更新安装函数；默认按检测到的安装方式（npm/pnpm）执行。 */
+    installFn?: (pkg: string, method: InstallMethod) => Promise<void>;
     /** 启动新实例的函数；默认 detached spawn 当前进程入口。 */
     spawnNewInstanceFn?: SpawnFn;
     packageName?: string;
@@ -30,19 +49,51 @@ type HotUpdateOptions = {
     restoreFlag?: string;
     /** 旧实例 handoff 端口；提供时新实例启动后请求旧实例 graceful shutdown。 */
     handoffPort?: number;
+    /** 旧实例主服务端口；新实例 --port 复用（保证接管同一地址）。 */
+    port?: number;
+    /** 传给新实例的认证 token（经环境变量 C0DE_AUTH_TOKEN），保证新旧实例握手同 token。 */
+    authToken?: string;
+    /** 手动安装等待程序文件变更的超时（ms）；默认 10 分钟，超时放弃等待。 */
+    manualWaitTimeoutMs?: number;
+};
+/** 安装方式（P0-2：识别当前进程安装器；unknown = 不自动安装，提示手动更新）。 */
+type InstallMethod = {
+    kind: 'npm';
+} | {
+    kind: 'pnpm';
+} | {
+    kind: 'unknown';
+    hint: string;
 };
 /**
- * 执行热更新（spec §18.1-18.2 流程）：
+ * 识别当前进程的安装方式：
+ * - 入口脚本 realpath 含 node_modules/.pnpm → pnpm
+ * - 含 node_modules（非 .pnpm）→ npm
+ * - 否则 unknown（npx 缓存、源码 dev、其他）→ 不自动安装
+ * 检测不到时返回 unknown，由上层提示用户手动安装。
+ */
+declare function detectInstallMethod(): InstallMethod;
+/** 手动安装提示命令（unknown 安装方式时返回给前端展示）。 */
+declare function manualInstallCommand(pkg: string): string;
+/**
+ * 执行热更新（spec §18.1-18.2 + P0-2 修订流程）：
  *   1. 序列化当前会话状态到快照文件
- *   2. 全局自更新（npm install -g）
- *   3. detached 启动新版本实例，传入快照路径（新实例 restore + 端口接管）
+ *   2. 识别当前进程安装方式（npm/pnpm/unknown）
+ *   3. 已知方式 → 自动安装；unknown → 不安装，等待用户手动安装
+ *   4. watch 当前执行程序文件变更 → 触发滚动切换
+ *      （detached 启动新实例 + restore 快照 + handoff 端口接管）
  *
  * 注：旧实例的 graceful shutdown / 端口让渡由新实例启动后通过 IPC 协调
- * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。若提供 handoffPort，
- * argv 会带上 --handoff-port，新实例据此 requestHandoff 通知旧实例退出。
+ * （见 ipc.ts），本函数只负责"序列化 + 安装 + 等待程序变更 + 接力"。
  */
 declare function performHotUpdate(snapshot: SessionSnapshot, opts?: HotUpdateOptions): Promise<HotUpdateResult>;
+/**
+ * 仅安装新版本（P2-7：无活跃 serve 的 `c0de update --apply`）。
+ * 不序列化快照、不 spawn `serve`——此前独立 CLI 执行会拉起一个用户未请求的常驻服务。
+ * 运行中的 serve 由 `/api/update/apply` 走 performHotUpdate 热更新路径。
+ */
+declare function performInstall(opts?: HotUpdateOptions): Promise<InstallOnlyResult>;
 /** 清理快照临时目录（热更新完成或放弃后调用）。 */
 declare function cleanupSnapshot(snapshotPath: string): Promise<void>;
-export type { HotUpdateOptions, HotUpdateResult, SpawnFn };
-export { cleanupSnapshot, performHotUpdate };
+export type { HotUpdateOptions, HotUpdateResult, InstallMethod, InstallOnlyResult, SpawnFn };
+export { cleanupSnapshot, detectInstallMethod, manualInstallCommand, performHotUpdate, performInstall, };

package/dist/update/updater.js

@@ -1,28 +1,166 @@
 import { spawn } from 'node:child_process';
+import { realpathSync, statSync, watch } from 'node:fs';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 const DEFAULT_PACKAGE = 'c0de-agent';
-/** 默认自更新：npm install -g <pkg>。 */
-function defaultInstall(pkg) {
+const DEFAULT_MANUAL_WAIT_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * 识别当前进程的安装方式：
+ * - 入口脚本 realpath 含 node_modules/.pnpm → pnpm
+ * - 含 node_modules（非 .pnpm）→ npm
+ * - 否则 unknown（npx 缓存、源码 dev、其他）→ 不自动安装
+ * 检测不到时返回 unknown，由上层提示用户手动安装。
+ */
+function detectInstallMethod() {
+    const entry = process.argv[1];
+    if (!entry)
+        return { kind: 'unknown', hint: '无法确定入口脚本' };
+    let real = entry;
+    try {
+        real = realpathSync(entry);
+    }
+    catch {
+        // 入口不存在/不可解析：尝试保留原始路径判断
+    }
+    const p = real.replace(/\\/g, '/');
+    if (p.includes('/.pnpm/'))
+        return { kind: 'pnpm' };
+    if (p.includes('/node_modules/'))
+        return { kind: 'npm' };
+    if (p.includes('/_npx/')) {
+        return { kind: 'unknown', hint: '通过 npx 临时缓存运行，无法自动更新' };
+    }
+    return { kind: 'unknown', hint: `无法识别安装方式（入口：${basename(entry)}）` };
+}
+/** 默认自更新：按检测到的安装方式执行。unknown 时抛错（上层转 manual_install_required）。 */
+function defaultInstall(pkg, method) {
     return new Promise((resolve, reject) => {
-        const child = spawn('npm', ['install', '-g', pkg], { stdio: 'ignore' });
+        const cmd = method.kind === 'pnpm' ? 'pnpm' : 'npm';
+        const args = method.kind === 'pnpm' ? ['add', '-g', pkg] : ['install', '-g', pkg];
+        const child = spawn(cmd, args, { stdio: 'ignore' });
         child.on('error', reject);
         child.on('exit', (code) => {
             if (code === 0)
                 resolve();
             else
-                reject(new Error(`npm install -g ${pkg} exited with ${code}`));
+                reject(new Error(`${cmd} ${args.join(' ')} exited with ${code}`));
         });
     });
 }
-/** 默认启动新实例：detached spawn，argv 全部透传给新进程。 */
-function defaultSpawn(_snapshotPath, argv) {
+/** 手动安装提示命令（unknown 安装方式时返回给前端展示）。 */
+function manualInstallCommand(pkg) {
+    return `npm install -g ${pkg}   # 或 pnpm add -g ${pkg}`;
+}
+function statFingerprint(path) {
+    try {
+        const s = statSync(path);
+        return { size: s.size, mtimeMs: s.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/** 采集当前执行程序文件（argv[1] 及 realpath）的 stat 基线。 */
+function captureProgramBaseline() {
+    const entry = process.argv[1];
+    if (!entry)
+        return null;
+    const paths = new Set([entry]);
+    try {
+        paths.add(realpathSync(entry));
+    }
+    catch {
+        // 入口不存在时仅记录原始路径
+    }
+    const baseline = new Map();
+    for (const p of paths)
+        baseline.set(p, statFingerprint(p));
+    return baseline;
+}
+/**
+ * watch 当前执行程序文件（argv[1] 及其 realpath 所在目录）变更。
+ * 返回 Promise：文件内容变更（size/mtime 变化）后 resolve。
+ * 采用目录 fs.watch + 1s 轮询 stat 双保险（npm 原子替换文件时 watch 事件可能丢失）。
+ * baseline 由调用方在「变更发生前」采集（安装前），否则安装已改写文件导致永远等不到变化。
+ * 超时（timeoutMs）或可注入的 cancel 信号触发时 reject。
+ */
+function waitForProgramChange(timeoutMs, baseline, signal, pollMs = 1000) {
+    return new Promise((resolve, reject) => {
+        const entry = process.argv[1];
+        if (!entry) {
+            reject(new Error('无法确定程序入口文件'));
+            return;
+        }
+        const paths = new Set([entry]);
+        try {
+            paths.add(realpathSync(entry));
+        }
+        catch {
+            // 入口不存在时仅 watch 原始路径目录
+        }
+        let settled = false;
+        let timer = null;
+        let interval = null;
+        const watchers = [];
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            if (interval)
+                clearInterval(interval);
+            for (const w of watchers)
+                w.close();
+            fn();
+        };
+        const changed = () => {
+            for (const [p, before] of baseline) {
+                const after = statFingerprint(p);
+                if (before === null) {
+                    if (after !== null)
+                        return true;
+                    continue;
+                }
+                if (after === null || after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const onAbort = () => finish(() => reject(new Error('waiting aborted')));
+        signal?.addEventListener('abort', onAbort, { once: true });
+        timer = setTimeout(() => finish(() => reject(new Error('等待程序文件变更超时'))), timeoutMs);
+        interval = setInterval(() => {
+            if (changed())
+                finish(() => resolve());
+        }, pollMs);
+        for (const p of paths) {
+            try {
+                const dir = dirname(p);
+                watchers.push(watch(dir, () => {
+                    if (changed())
+                        finish(() => resolve());
+                }));
+            }
+            catch {
+                // 目录不可 watch：依赖轮询兜底
+            }
+        }
+    });
+}
+/** 默认启动新实例：detached spawn CLI bin，argv = serve <restore> <handoff>。
+ * 必须以 `serve` 子命令开头（CLI dispatch 按首参选命令）；
+ * --port 复用旧实例端口，--handoff-port 让新实例启动后请求旧实例退出。
+ * 认证 token 经环境变量传递（不落 argv，避免 ps 泄漏）。 */
+function defaultSpawn(_snapshotPath, argv, opts) {
     return new Promise((resolve, reject) => {
         try {
             const child = spawn(process.argv0, [process.argv[1] ?? '', ...argv], {
                 detached: true,
                 stdio: 'ignore',
+                ...(opts?.authToken ? { env: { ...process.env, C0DE_AUTH_TOKEN: opts.authToken } } : {}),
             });
             child.unref();
             resolve();
@@ -32,52 +170,125 @@ function defaultSpawn(_snapshotPath, argv) {
         }
     });
 }
+/** 组装新实例 argv（serve --restore <snapshot> [--port] [--handoff-port]）。 */
+function buildSpawnArgv(snapshotPath, opts) {
+    const restoreFlag = opts.restoreFlag ?? '--restore';
+    const argv = [
+        'serve',
+        restoreFlag,
+        snapshotPath,
+        ...(opts.port !== undefined ? ['--port', String(opts.port)] : []),
+    ];
+    if (opts.handoffPort !== undefined) {
+        argv.push('--handoff-port', String(opts.handoffPort));
+    }
+    return argv;
+}
 /**
- * 执行热更新（spec §18.1-18.2 流程）：
+ * 执行热更新（spec §18.1-18.2 + P0-2 修订流程）：
  *   1. 序列化当前会话状态到快照文件
- *   2. 全局自更新（npm install -g）
- *   3. detached 启动新版本实例，传入快照路径（新实例 restore + 端口接管）
+ *   2. 识别当前进程安装方式（npm/pnpm/unknown）
+ *   3. 已知方式 → 自动安装；unknown → 不安装，等待用户手动安装
+ *   4. watch 当前执行程序文件变更 → 触发滚动切换
+ *      （detached 启动新实例 + restore 快照 + handoff 端口接管）
  *
  * 注：旧实例的 graceful shutdown / 端口让渡由新实例启动后通过 IPC 协调
- * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。若提供 handoffPort，
- * argv 会带上 --handoff-port，新实例据此 requestHandoff 通知旧实例退出。
+ * （见 ipc.ts），本函数只负责"序列化 + 安装 + 等待程序变更 + 接力"。
  */
 async function performHotUpdate(snapshot, opts = {}) {
     const pkg = opts.packageName ?? DEFAULT_PACKAGE;
     const dir = await mkdtemp(join(tmpdir(), 'c0de-update-'));
     const snapshotPath = opts.snapshotPath ?? join(dir, 'snapshot.json');
     await writeFile(snapshotPath, JSON.stringify(snapshot), 'utf8');
-    const install = opts.installFn ?? defaultInstall;
+    // 识别安装方式
+    const method = detectInstallMethod();
+    // 安装前采集程序文件基线（watch 依赖此判断「变更已发生」）
+    const baseline = captureProgramBaseline();
+    // 已知安装方式：自动安装；unknown/安装失败 → 等用户手动安装。
+    let installReason = null;
+    if (method.kind !== 'unknown') {
+        const install = opts.installFn ?? defaultInstall;
+        try {
+            await install(pkg, method);
+        }
+        catch (error) {
+            // 已知安装方式安装失败：立即返回（不进入 10 分钟等待），快照已落盘可恢复。
+            // 用户可用 c0de update --apply 重试或手动安装后重启。
+            return {
+                _tag: 'install_failed',
+                error: error instanceof Error ? error.message : String(error),
+                snapshotPath,
+            };
+        }
+    }
+    else {
+        installReason = `${method.hint}，请手动执行 ${manualInstallCommand(pkg)} 完成更新`;
+    }
+    if (installReason !== null) {
+        if (!baseline) {
+            return {
+                _tag: 'manual_install_required',
+                error: '无法确定程序入口文件，无法监听更新',
+                snapshotPath,
+                command: manualInstallCommand(pkg),
+            };
+        }
+        try {
+            await waitForProgramChange(opts.manualWaitTimeoutMs ?? DEFAULT_MANUAL_WAIT_TIMEOUT_MS, baseline);
+        }
+        catch (error) {
+            return {
+                _tag: 'manual_install_required',
+                error: error instanceof Error ? error.message : String(error),
+                snapshotPath,
+                command: manualInstallCommand(pkg),
+            };
+        }
+    }
+    // 程序文件已变更（自动安装落盘或用户手动安装完成）→ 滚动切换
+    const spawnNew = opts.spawnNewInstanceFn ?? defaultSpawn;
+    const argv = buildSpawnArgv(snapshotPath, opts);
     try {
-        await install(pkg);
+        await spawnNew(snapshotPath, argv, opts);
     }
     catch (error) {
         return {
-            _tag: 'install_failed',
+            _tag: 'spawn_failed',
             error: error instanceof Error ? error.message : String(error),
             snapshotPath,
         };
     }
-    const restoreFlag = opts.restoreFlag ?? '--restore';
-    const argv = [restoreFlag, snapshotPath];
-    if (opts.handoffPort !== undefined) {
-        argv.push('--handoff-port', String(opts.handoffPort));
+    return { _tag: 'success', snapshotPath, installMethod: method.kind };
+}
+/**
+ * 仅安装新版本（P2-7：无活跃 serve 的 `c0de update --apply`）。
+ * 不序列化快照、不 spawn `serve`——此前独立 CLI 执行会拉起一个用户未请求的常驻服务。
+ * 运行中的 serve 由 `/api/update/apply` 走 performHotUpdate 热更新路径。
+ */
+async function performInstall(opts = {}) {
+    const pkg = opts.packageName ?? DEFAULT_PACKAGE;
+    const method = detectInstallMethod();
+    if (method.kind === 'unknown') {
+        return {
+            _tag: 'manual_install_required',
+            error: method.hint,
+            command: manualInstallCommand(pkg),
+        };
     }
-    const spawnNew = opts.spawnNewInstanceFn ?? defaultSpawn;
+    const install = opts.installFn ?? defaultInstall;
     try {
-        await spawnNew(snapshotPath, argv);
+        await install(pkg, method);
     }
     catch (error) {
         return {
-            _tag: 'spawn_failed',
+            _tag: 'install_failed',
             error: error instanceof Error ? error.message : String(error),
-            snapshotPath,
         };
     }
-    return { _tag: 'success', snapshotPath };
+    return { _tag: 'success', installMethod: method.kind };
 }
 /** 清理快照临时目录（热更新完成或放弃后调用）。 */
 async function cleanupSnapshot(snapshotPath) {
     await rm(join(snapshotPath, '..'), { recursive: true, force: true }).catch(() => { });
 }
-export { cleanupSnapshot, performHotUpdate };
+export { cleanupSnapshot, detectInstallMethod, manualInstallCommand, performHotUpdate, performInstall, };

package/dist/update/version.d.ts

@@ -10,9 +10,14 @@ type CheckOptions = {
     currentVersion?: string;
     registryUrl?: string;
 };
+/**
+ * 读取当前安装版本（package.json 的 version 字段）。
+ * src/dev 与 dist 两种布局下 `../../package.json` 都指向包根；读取失败回退常量。
+ */
+declare function getCurrentVersion(): string;
 /** 语义化版本比较：a < b → -1，a == b → 0，a > b → 1。忽略前导 v 和 prerelease。 */
 declare function compareSemver(a: string, b: string): number;
 /** 查询 npm registry 判断是否有新版本。网络/解析失败时返回 hasUpdate:false，绝不抛错。 */
 declare function checkForUpdate(opts?: CheckOptions): Promise<UpdateCheckResult>;
 export type { CheckOptions, UpdateCheckResult };
-export { checkForUpdate, compareSemver };
+export { checkForUpdate, compareSemver, getCurrentVersion };

package/dist/update/version.js

@@ -1,7 +1,22 @@
-// 版本检查（spec §18.1）：查询 npm registry 比对当前版本。
+import { readFileSync } from 'node:fs';
 const DEFAULT_PACKAGE = 'c0de-agent';
 const DEFAULT_VERSION = '0.1.0';
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+/**
+ * 读取当前安装版本（package.json 的 version 字段）。
+ * src/dev 与 dist 两种布局下 `../../package.json` 都指向包根；读取失败回退常量。
+ */
+function getCurrentVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+        if (typeof pkg.version === 'string' && pkg.version.length > 0)
+            return pkg.version;
+    }
+    catch {
+        // 打包布局异常：回退保守常量
+    }
+    return DEFAULT_VERSION;
+}
 /** 取 semver 的数值核心（去前导 v 与 prerelease）。 */
 function semverCore(v) {
     return (v.replace(/^v/, '').split('-')[0] ?? '').split('.').map(Number);
@@ -23,7 +38,7 @@ function compareSemver(a, b) {
 /** 查询 npm registry 判断是否有新版本。网络/解析失败时返回 hasUpdate:false，绝不抛错。 */
 async function checkForUpdate(opts = {}) {
     const pkg = opts.packageName ?? DEFAULT_PACKAGE;
-    const current = opts.currentVersion ?? DEFAULT_VERSION;
+    const current = opts.currentVersion ?? getCurrentVersion();
     const registry = opts.registryUrl ?? DEFAULT_REGISTRY;
     const fetchImpl = opts.fetchImpl ?? fetch;
     const result = {
@@ -46,4 +61,4 @@ async function checkForUpdate(opts = {}) {
     }
     return result;
 }
-export { checkForUpdate, compareSemver };
+export { checkForUpdate, compareSemver, getCurrentVersion };

package/drizzle/0005_snapshot_mtime.sql

@@ -0,0 +1 @@
+ALTER TABLE "file_snapshots" ADD COLUMN "mtime_ms" bigint;

package/drizzle/0006_sour_susan_delgado.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "sessions" ADD COLUMN "source" text;--> statement-breakpoint
+ALTER TABLE "sessions" ADD COLUMN "deleted_at" timestamp with time zone;

package/drizzle/0007_same_wilson_fisk.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "sessions" ALTER COLUMN "source" SET DEFAULT null;--> statement-breakpoint
+ALTER TABLE "sessions" ALTER COLUMN "deleted_at" SET DEFAULT null;