c0de-agent 0.0.0 → 1.0.0

package/dist/tools/websearch/types.js

@@ -0,0 +1,18 @@
+/**
+ * websearch 工具的统一类型、常量与工具函数。
+ *
+ * 来源：oh-my-pi（packages/coding-agent/src/web/search/）多后端 strategy 架构，
+ * 裁剪适配 c0de-agent 的 data+functions 范式（无 class）。
+ * 详见 docs/superpowers/specs/2026-06-30-websearch-tool-design.md §2-3。
+ */
+/** 工具参数校验常量。 */
+const DEFAULT_NUM_RESULTS = 8;
+const MAX_NUM_RESULTS = 20;
+const MIN_NUM_RESULTS = 1;
+/** clamp 结果数到 [MIN, MAX]；undefined/NaN 回退到 fallback。 */
+function clampNumResults(n, fallback = DEFAULT_NUM_RESULTS) {
+    if (n === undefined || Number.isNaN(n))
+        return fallback;
+    return Math.min(MAX_NUM_RESULTS, Math.max(MIN_NUM_RESULTS, Math.trunc(n)));
+}
+export { clampNumResults, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS, MIN_NUM_RESULTS };

package/dist/tools/websearch/websearch.d.ts

@@ -0,0 +1,10 @@
+import type { WebSearchConfig } from '../../shared/types/config.js';
+import type { ToolDef } from '../../shared/types/tool.js';
+import { setFetchOverride } from './index.js';
+export { setFetchOverride };
+/**
+ * websearch 工具工厂。config 由工厂闭包捕获（对齐 runSubAgent/debugSpawn 依赖反转模式）。
+ * permission: auto（只读网络搜索，不改本地状态）。timeout 30s。
+ * 详见 docs/superpowers/specs/2026-06-30-websearch-tool-design.md §5。
+ */
+export declare function createWebSearchTool(config: WebSearchConfig): ToolDef;

package/dist/tools/websearch/websearch.js

@@ -0,0 +1,48 @@
+import { formatForLLM, runWebSearch, setFetchOverride } from './index.js';
+export { setFetchOverride };
+const NO_RESULTS = 'No search results found. Try a different query.';
+/**
+ * websearch 工具工厂。config 由工厂闭包捕获（对齐 runSubAgent/debugSpawn 依赖反转模式）。
+ * permission: auto（只读网络搜索，不改本地状态）。timeout 30s。
+ * 详见 docs/superpowers/specs/2026-06-30-websearch-tool-design.md §5。
+ */
+export function createWebSearchTool(config) {
+    return {
+        name: 'websearch',
+        description: 'Search the web for up-to-date information beyond knowledge cutoff. ' +
+            'Returns titled sources with snippets (and a synthesized answer when the ' +
+            'backend supports it). Use for current events, recent releases, and docs. ' +
+            `The current year is ${new Date().getFullYear()}.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                numResults: {
+                    type: 'number',
+                    description: 'Number of results (default 8, max 20)',
+                },
+                recency: {
+                    type: 'string',
+                    enum: ['day', 'week', 'month', 'year'],
+                    description: 'Time filter for results',
+                },
+            },
+            required: ['query'],
+        },
+        permission: 'auto',
+        timeout: 30_000,
+        execute: async (input, ctx) => {
+            const { query, numResults, recency } = input;
+            try {
+                const response = await runWebSearch({ query, numResults, recency }, config, ctx.abort);
+                if (!response.answer && response.sources.length === 0) {
+                    return { _tag: 'success', output: NO_RESULTS };
+                }
+                return { _tag: 'success', output: formatForLLM(response) };
+            }
+            catch (err) {
+                return { _tag: 'error', error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/update/index.d.ts

@@ -0,0 +1,10 @@
+export type { HandoffServer } from './ipc.js';
+export { createHandoffServer, requestHandoff } from './ipc.js';
+export type { UpdateScheduler, UpdateSchedulerOptions } from './scheduler.js';
+export { createUpdateScheduler } from './scheduler.js';
+export type { SerializedEntry, SerializedSession, SessionSnapshot } from './snapshot.js';
+export { orderSessionsByParent, restoreSessions, serializeSessions } from './snapshot.js';
+export type { HotUpdateOptions, HotUpdateResult, SpawnFn } from './updater.js';
+export { cleanupSnapshot, performHotUpdate } from './updater.js';
+export type { UpdateCheckResult } from './version.js';
+export { checkForUpdate, compareSemver } from './version.js';

package/dist/update/index.js

@@ -0,0 +1,6 @@
+// 热更新 + 会话迁移包（spec §18）。
+export { createHandoffServer, requestHandoff } from './ipc.js';
+export { createUpdateScheduler } from './scheduler.js';
+export { orderSessionsByParent, restoreSessions, serializeSessions } from './snapshot.js';
+export { cleanupSnapshot, performHotUpdate } from './updater.js';
+export { checkForUpdate, compareSemver } from './version.js';

package/dist/update/ipc.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 端口接管 IPC（spec §18.3）：新实例检测到端口被旧实例占用时，通过 HTTP
+ * `/handoff` 端点请求旧实例 graceful shutdown（序列化状态后退出），从而
+ * 接管端口。用普通 HTTP 而非 unix socket，便于跨平台。
+ */
+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 };
+export { createHandoffServer, requestHandoff };

package/dist/update/ipc.js

@@ -0,0 +1,41 @@
+import { createServer } from 'node:http';
+/** 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff（序列化 + 退出）。 */
+function createHandoffServer(onHandoff) {
+    return new Promise((resolve, reject) => {
+        const handler = async (req, res) => {
+            if (req.method === 'POST' && req.url === '/handoff') {
+                try {
+                    await onHandoff();
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch (error) {
+                    res.writeHead(500, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: String(error) }));
+                }
+                return;
+            }
+            res.writeHead(404);
+            res.end();
+        };
+        const server = createServer(handler);
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            const port = typeof addr === 'object' && addr ? addr.port : 0;
+            resolve({
+                port,
+                close: () => new Promise((res) => {
+                    server.close(() => res());
+                }),
+            });
+        });
+    });
+}
+/** 新实例请求旧实例让出端口（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}`);
+}
+export { createHandoffServer, requestHandoff };

package/dist/update/scheduler.d.ts

@@ -0,0 +1,34 @@
+import type { UpdateCheckResult } from './version.js';
+/**
+ * 后台版本检查调度器（spec §18.1 步骤 1）。
+ *
+ * 启动时延迟 initialDelayMs 后执行首次 checkForUpdate，之后按 intervalMs
+ * 周期性检查。结果缓存到内存，供 /api/update 路由读取（避免每次请求都打
+ * npm registry）。发现新版本通过 onUpdate 回调通知上层（server.ts 转发到
+ * 前端 SSE 或前端轮询读取）。
+ *
+ * checkFn 抛错时不传播，缓存降级为 hasUpdate:false（与 checkForUpdate 自身
+ * 的容错语义一致）。
+ */
+type UpdateSchedulerOptions = {
+    checkFn: () => Promise<UpdateCheckResult>;
+    /** 周期检查间隔（毫秒），默认 1 小时。 */
+    intervalMs?: number;
+    /** 首次检查延迟（毫秒），默认 10 秒。 */
+    initialDelayMs?: number;
+    /** 每次成功检查后回调（含 hasUpdate:false）；异常路径不调用。 */
+    onUpdate?: (result: UpdateCheckResult) => void;
+};
+type UpdateScheduler = {
+    /** 启动调度（首次延迟 + 周期检查）。重复 start 是 no-op。 */
+    start(): void;
+    /** 停止调度；已缓存的 lastResult 保留。 */
+    stop(): void;
+    /** 立即触发一次检查并更新缓存；异常降级为 hasUpdate:false。 */
+    checkNow(): Promise<UpdateCheckResult>;
+    /** 当前缓存结果；未检查过返回 null。 */
+    getLastResult(): UpdateCheckResult | null;
+};
+declare function createUpdateScheduler(opts: UpdateSchedulerOptions): UpdateScheduler;
+export type { UpdateScheduler, UpdateSchedulerOptions };
+export { createUpdateScheduler };

package/dist/update/scheduler.js

@@ -0,0 +1,57 @@
+const DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
+const DEFAULT_INITIAL_DELAY_MS = 10_000;
+function createUpdateScheduler(opts) {
+    const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+    const initialDelayMs = opts.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+    // 直接引用全局 timer；vitest useFakeTimers() 会替换全局，start() 时读取即拿到 mock。
+    let intervalId = null;
+    let initialId = null;
+    let lastResult = null;
+    let started = false;
+    async function runOnce() {
+        let r;
+        try {
+            r = await opts.checkFn();
+        }
+        catch {
+            // 异常降级：缓存 hasUpdate:false，但不触发 onUpdate（避免误报）。
+            lastResult = { hasUpdate: false, currentVersion: '0.0.0', latestVersion: '0.0.0' };
+            return lastResult;
+        }
+        lastResult = r;
+        if (opts.onUpdate)
+            opts.onUpdate(r);
+        return r;
+    }
+    return {
+        start() {
+            if (started)
+                return;
+            started = true;
+            // 首次延迟：到达后执行 runOnce，再挂周期 interval。
+            // 不能直接 setInterval——initialDelayMs 与 intervalMs 通常不同。
+            initialId = setTimeout(() => {
+                void runOnce();
+                intervalId = setInterval(() => void runOnce(), intervalMs);
+            }, initialDelayMs);
+        },
+        stop() {
+            if (initialId !== null) {
+                clearTimeout(initialId);
+                initialId = null;
+            }
+            if (intervalId !== null) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+            started = false;
+        },
+        checkNow() {
+            return runOnce();
+        },
+        getLastResult() {
+            return lastResult;
+        },
+    };
+}
+export { createUpdateScheduler };

package/dist/update/snapshot.d.ts

@@ -0,0 +1,39 @@
+import type { DB } from '../db/client.js';
+/** 序列化后的会话行（Date → epoch ms，纯 JSON 安全）。 */
+type SerializedSession = {
+    id: string;
+    title: string;
+    parentId: string | null;
+    projectId: string | null;
+    branchPoint: number | null;
+    metadata: unknown;
+    createdAt: number;
+    updatedAt: number;
+};
+/** 序列化后的会话条目行（Date → epoch ms）。 */
+type SerializedEntry = {
+    id: string;
+    sessionId: string;
+    tag: string;
+    role: string | null;
+    content: unknown;
+    toolName: string | null;
+    tokenCount: number;
+    createdAt: number;
+};
+/** 热更新迁移快照（spec §18.2）。 */
+type SessionSnapshot = {
+    version: string;
+    sessions: SerializedSession[];
+    entries: SerializedEntry[];
+    config: unknown;
+    timestamp: number;
+};
+/** 按 parentId 拓扑序排列 sessions，使父会话先于子会话插入（满足自引用 FK）。 */
+declare function orderSessionsByParent(list: SerializedSession[]): SerializedSession[];
+/** 从 DB 导出所有会话与条目为可序列化快照。 */
+declare function serializeSessions(handle: DB, config?: unknown): Promise<SessionSnapshot>;
+/** 把快照导入 DB（保留原始 id 与时间戳；父会话先插入以满足 FK）。 */
+declare function restoreSessions(handle: DB, snapshot: SessionSnapshot): Promise<void>;
+export type { SerializedEntry, SerializedSession, SessionSnapshot };
+export { orderSessionsByParent, restoreSessions, serializeSessions };

package/dist/update/snapshot.js

@@ -0,0 +1,99 @@
+import { sessionEntries, sessions } from '../db/schema.js';
+const CURRENT_SNAPSHOT_VERSION = '0.1.0';
+function toDateMs(v) {
+    if (v instanceof Date)
+        return v.getTime();
+    if (typeof v === 'string' || typeof v === 'number')
+        return new Date(v).getTime();
+    return Date.now();
+}
+function toSerializedSession(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        parentId: row.parentId,
+        projectId: row.projectId,
+        branchPoint: row.branchPoint,
+        metadata: row.metadata,
+        createdAt: toDateMs(row.createdAt),
+        updatedAt: toDateMs(row.updatedAt),
+    };
+}
+function toSerializedEntry(row) {
+    return {
+        id: row.id,
+        sessionId: row.sessionId,
+        tag: row.tag,
+        role: row.role,
+        content: row.content,
+        toolName: row.toolName,
+        tokenCount: row.tokenCount ?? 0,
+        createdAt: toDateMs(row.createdAt),
+    };
+}
+/** 按 parentId 拓扑序排列 sessions，使父会话先于子会话插入（满足自引用 FK）。 */
+function orderSessionsByParent(list) {
+    const byId = new Map(list.map((s) => [s.id, s]));
+    const ordered = [];
+    const seen = new Set();
+    const visit = (s) => {
+        if (seen.has(s.id))
+            return;
+        const parent = s.parentId ? byId.get(s.parentId) : undefined;
+        if (parent && !seen.has(parent.id))
+            visit(parent);
+        seen.add(s.id);
+        ordered.push(s);
+    };
+    for (const s of list)
+        visit(s);
+    return ordered;
+}
+/** 从 DB 导出所有会话与条目为可序列化快照。 */
+async function serializeSessions(handle, config) {
+    const [sRows, eRows] = await Promise.all([
+        handle.db.select().from(sessions),
+        handle.db.select().from(sessionEntries),
+    ]);
+    return {
+        version: CURRENT_SNAPSHOT_VERSION,
+        sessions: sRows.map(toSerializedSession),
+        entries: eRows.map(toSerializedEntry),
+        config: config ?? null,
+        timestamp: Date.now(),
+    };
+}
+/** 把快照导入 DB（保留原始 id 与时间戳；父会话先插入以满足 FK）。 */
+async function restoreSessions(handle, snapshot) {
+    for (const s of orderSessionsByParent(snapshot.sessions)) {
+        await handle.db
+            .insert(sessions)
+            .values({
+            id: s.id,
+            title: s.title,
+            parentId: s.parentId,
+            projectId: s.projectId,
+            branchPoint: s.branchPoint,
+            metadata: s.metadata,
+            createdAt: new Date(s.createdAt),
+            updatedAt: new Date(s.updatedAt),
+        })
+            .onConflictDoNothing();
+    }
+    for (const e of snapshot.entries) {
+        await handle.db
+            .insert(sessionEntries)
+            .values({
+            id: e.id,
+            sessionId: e.sessionId,
+            tag: e.tag,
+            role: e.role,
+            content: e.content,
+            toolName: e.toolName,
+            tokenCount: e.tokenCount,
+            createdAt: new Date(e.createdAt),
+        })
+            .onConflictDoNothing();
+    }
+}
+export { orderSessionsByParent, restoreSessions, serializeSessions };

package/dist/update/updater.d.ts

@@ -0,0 +1,48 @@
+import type { SessionSnapshot } from './snapshot.js';
+/** 热更新执行结果（spec §18）。 */
+type HotUpdateResult = {
+    _tag: 'success';
+    snapshotPath: string;
+} | {
+    _tag: 'install_failed';
+    error: string;
+    snapshotPath: string;
+} | {
+    _tag: 'spawn_failed';
+    error: string;
+    snapshotPath: string;
+};
+/**
+ * 启动新实例的函数签名。
+ * @param snapshotPath 快照文件路径（旧实例已写入）
+ * @param argv          传给新进程的完整参数（含 restore flag + 可选 handoff flag）
+ */
+type SpawnFn = (snapshotPath: string, argv: string[]) => Promise<void>;
+type HotUpdateOptions = {
+    /** 自更新安装函数；默认 `npm install -g <pkg>`。 */
+    installFn?: (pkg: string) => Promise<void>;
+    /** 启动新实例的函数；默认 detached spawn 当前进程入口。 */
+    spawnNewInstanceFn?: SpawnFn;
+    packageName?: string;
+    /** 快照写入路径；默认临时目录。 */
+    snapshotPath?: string;
+    /** 新实例接收快照的参数前缀（默认 --restore）。 */
+    restoreFlag?: string;
+    /** 旧实例 handoff 端口；提供时新实例启动后请求旧实例 graceful shutdown。 */
+    handoffPort?: number;
+};
+/**
+ * 执行热更新（spec §18.1-18.2 流程）：
+ *   1. 序列化当前会话状态到快照文件
+ *   2. 全局自更新（npm install -g）
+ *   3. detached 启动新版本实例，传入快照路径（新实例 restore + 端口接管）
+ *
+ * 注：旧实例的 graceful shutdown / 端口让渡由新实例启动后通过 IPC 协调
+ * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。若提供 handoffPort，
+ * argv 会带上 --handoff-port，新实例据此 requestHandoff 通知旧实例退出。
+ */
+declare function performHotUpdate(snapshot: SessionSnapshot, opts?: HotUpdateOptions): Promise<HotUpdateResult>;
+/** 清理快照临时目录（热更新完成或放弃后调用）。 */
+declare function cleanupSnapshot(snapshotPath: string): Promise<void>;
+export type { HotUpdateOptions, HotUpdateResult, SpawnFn };
+export { cleanupSnapshot, performHotUpdate };

package/dist/update/updater.js

@@ -0,0 +1,83 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const DEFAULT_PACKAGE = 'c0de-agent';
+/** 默认自更新：npm install -g <pkg>。 */
+function defaultInstall(pkg) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('npm', ['install', '-g', pkg], { 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}`));
+        });
+    });
+}
+/** 默认启动新实例：detached spawn，argv 全部透传给新进程。 */
+function defaultSpawn(_snapshotPath, argv) {
+    return new Promise((resolve, reject) => {
+        try {
+            const child = spawn(process.argv0, [process.argv[1] ?? '', ...argv], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            resolve();
+        }
+        catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
+/**
+ * 执行热更新（spec §18.1-18.2 流程）：
+ *   1. 序列化当前会话状态到快照文件
+ *   2. 全局自更新（npm install -g）
+ *   3. detached 启动新版本实例，传入快照路径（新实例 restore + 端口接管）
+ *
+ * 注：旧实例的 graceful shutdown / 端口让渡由新实例启动后通过 IPC 协调
+ * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。若提供 handoffPort，
+ * argv 会带上 --handoff-port，新实例据此 requestHandoff 通知旧实例退出。
+ */
+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;
+    try {
+        await install(pkg);
+    }
+    catch (error) {
+        return {
+            _tag: 'install_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));
+    }
+    const spawnNew = opts.spawnNewInstanceFn ?? defaultSpawn;
+    try {
+        await spawnNew(snapshotPath, argv);
+    }
+    catch (error) {
+        return {
+            _tag: 'spawn_failed',
+            error: error instanceof Error ? error.message : String(error),
+            snapshotPath,
+        };
+    }
+    return { _tag: 'success', snapshotPath };
+}
+/** 清理快照临时目录（热更新完成或放弃后调用）。 */
+async function cleanupSnapshot(snapshotPath) {
+    await rm(join(snapshotPath, '..'), { recursive: true, force: true }).catch(() => { });
+}
+export { cleanupSnapshot, performHotUpdate };

package/dist/update/version.d.ts

@@ -0,0 +1,18 @@
+type UpdateCheckResult = {
+    hasUpdate: boolean;
+    currentVersion: string;
+    latestVersion: string;
+    releaseNotes?: string;
+};
+type CheckOptions = {
+    fetchImpl?: typeof fetch;
+    packageName?: string;
+    currentVersion?: string;
+    registryUrl?: 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 };

package/dist/update/version.js

@@ -0,0 +1,49 @@
+// 版本检查（spec §18.1）：查询 npm registry 比对当前版本。
+const DEFAULT_PACKAGE = 'c0de-agent';
+const DEFAULT_VERSION = '0.1.0';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+/** 取 semver 的数值核心（去前导 v 与 prerelease）。 */
+function semverCore(v) {
+    return (v.replace(/^v/, '').split('-')[0] ?? '').split('.').map(Number);
+}
+/** 语义化版本比较：a < b → -1，a == b → 0，a > b → 1。忽略前导 v 和 prerelease。 */
+function compareSemver(a, b) {
+    const pa = semverCore(a);
+    const pb = semverCore(b);
+    for (let i = 0; i < 3; i++) {
+        const x = pa[i] ?? 0;
+        const y = pb[i] ?? 0;
+        if (x < y)
+            return -1;
+        if (x > y)
+            return 1;
+    }
+    return 0;
+}
+/** 查询 npm registry 判断是否有新版本。网络/解析失败时返回 hasUpdate:false，绝不抛错。 */
+async function checkForUpdate(opts = {}) {
+    const pkg = opts.packageName ?? DEFAULT_PACKAGE;
+    const current = opts.currentVersion ?? DEFAULT_VERSION;
+    const registry = opts.registryUrl ?? DEFAULT_REGISTRY;
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const result = {
+        hasUpdate: false,
+        currentVersion: current,
+        latestVersion: current,
+    };
+    try {
+        const res = await fetchImpl(`${registry}/${pkg}/latest`);
+        if (!res.ok)
+            return result;
+        const data = (await res.json());
+        if (!data.version)
+            return result;
+        result.latestVersion = data.version;
+        result.hasUpdate = compareSemver(current, data.version) < 0;
+    }
+    catch {
+        // 离线/网络错误：保守地报告无更新
+    }
+    return result;
+}
+export { checkForUpdate, compareSemver };

package/drizzle/0000_magical_nightshade.sql

@@ -0,0 +1,55 @@
+CREATE TABLE "compaction_archives" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"session_id" uuid NOT NULL,
+	"compaction_id" uuid NOT NULL,
+	"archive_type" text NOT NULL,
+	"original_entries" jsonb NOT NULL,
+	"file_snapshots" jsonb DEFAULT '[]'::jsonb,
+	"summary" text NOT NULL,
+	"token_count" integer,
+	"searchable_text" text,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "file_snapshots" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"session_id" uuid NOT NULL,
+	"entry_id" uuid,
+	"file_path" text NOT NULL,
+	"content" text NOT NULL,
+	"content_hash" text NOT NULL,
+	"token_count" integer DEFAULT 0,
+	"version" integer DEFAULT 1,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "session_entries" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"session_id" uuid NOT NULL,
+	"tag" text NOT NULL,
+	"role" text,
+	"content" jsonb NOT NULL,
+	"tool_name" text,
+	"token_count" integer DEFAULT 0,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "sessions" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"title" text NOT NULL,
+	"parent_id" uuid,
+	"branch_point" integer,
+	"metadata" jsonb DEFAULT '{}'::jsonb NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "compaction_archives" ADD CONSTRAINT "compaction_archives_session_id_sessions_id_fk" FOREIGN KEY ("session_id") REFERENCES "public"."sessions"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "file_snapshots" ADD CONSTRAINT "file_snapshots_session_id_sessions_id_fk" FOREIGN KEY ("session_id") REFERENCES "public"."sessions"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "session_entries" ADD CONSTRAINT "session_entries_session_id_sessions_id_fk" FOREIGN KEY ("session_id") REFERENCES "public"."sessions"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "sessions" ADD CONSTRAINT "sessions_parent_id_sessions_id_fk" FOREIGN KEY ("parent_id") REFERENCES "public"."sessions"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_archives_session" ON "compaction_archives" USING btree ("session_id");--> statement-breakpoint
+CREATE INDEX "idx_snapshots_session_path" ON "file_snapshots" USING btree ("session_id","file_path");--> statement-breakpoint
+CREATE UNIQUE INDEX "idx_snapshots_latest" ON "file_snapshots" USING btree ("session_id","file_path","version");--> statement-breakpoint
+CREATE INDEX "idx_entries_session" ON "session_entries" USING btree ("session_id","created_at");--> statement-breakpoint
+CREATE INDEX "idx_sessions_parent" ON "sessions" USING btree ("parent_id");

package/drizzle/0001_chemical_doctor_faustus.sql

@@ -0,0 +1,13 @@
+CREATE TABLE "projects" (
+	"id" text PRIMARY KEY NOT NULL,
+	"worktree" text NOT NULL,
+	"vcs" text,
+	"name" text,
+	"git_remote" text,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "sessions" ADD COLUMN "project_id" text;--> statement-breakpoint
+ALTER TABLE "sessions" ADD CONSTRAINT "sessions_project_id_projects_id_fk" FOREIGN KEY ("project_id") REFERENCES "public"."projects"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_sessions_project" ON "sessions" USING btree ("project_id");