c0de-agent 1.8.0 → 1.10.0

package/dist/session/snapshot.js

@@ -13,10 +13,15 @@ function rowToSnapshot(row) {
         tokenCount: row.tokenCount ?? 0,
         version: row.version ?? 1,
         createdAt,
+        ...(row.mtimeMs != null ? { mtimeMs: Number(row.mtimeMs) } : {}),
     };
 }
-/** Create or update a file snapshot. Always creates a new version. Returns the snapshot id. */
-async function upsertFileSnapshot(handle, sessionId, filePath, content) {
+/** Create or update a file snapshot. Always creates a new version. Returns the snapshot id.
+ *  未传 mtimeMs 时从同文件已有最新行透传（而非置空）：compaction/squash 等从
+ *  工具结果重建快照的调用点拿不到磁盘 mtime，透传旧值可避免每次压缩后热文件
+ *  被误判过期而多一轮冗余重读（自愈无害但浪费；旧值 ≤ 内容实际新鲜度，
+ *  绝不会掩盖磁盘真实变更）。 */
+async function upsertFileSnapshot(handle, sessionId, filePath, content, mtimeMs) {
     const contentHash = createHash('sha256').update(content).digest('hex');
     const tokenCount = estimateTokens(content);
     const [existing] = await handle.db
@@ -26,9 +31,20 @@ async function upsertFileSnapshot(handle, sessionId, filePath, content) {
         .orderBy(desc(fileSnapshots.version))
         .limit(1);
     const version = (existing?.version ?? 0) + 1;
+    // mtimeMs 是浮点（stat 返回微秒精度），bigint 列不接受小数；取整存储。
+    // 调用方未显式提供时继承已有行的 mtimeMs（见函数头注释）。
+    const effectiveMtimeMs = mtimeMs ?? (existing?.mtimeMs != null ? Number(existing.mtimeMs) : null);
     const [row] = await handle.db
         .insert(fileSnapshots)
-        .values({ sessionId, filePath, content, contentHash, tokenCount, version })
+        .values({
+        sessionId,
+        filePath,
+        content,
+        contentHash,
+        tokenCount,
+        version,
+        ...(effectiveMtimeMs != null ? { mtimeMs: Math.round(effectiveMtimeMs) } : {}),
+    })
         .returning();
     if (!row)
         throw new Error('Failed to insert file snapshot');
@@ -57,4 +73,29 @@ async function checkFileSnapshot(handle, sessionId, filePath) {
     const snapshot = await getLatestFileSnapshot(handle, sessionId, filePath);
     return snapshot?.content ?? null;
 }
-export { checkFileSnapshot, getFileSnapshots, getLatestFileSnapshot, upsertFileSnapshot };
+/** 把源会话每个文件的最新快照复制到目标会话（fork 分支用，P1-4）。 */
+async function copyFileSnapshots(handle, fromSessionId, toSessionId) {
+    const rows = await handle.db
+        .select()
+        .from(fileSnapshots)
+        .where(eq(fileSnapshots.sessionId, fromSessionId));
+    const latest = new Map();
+    for (const r of rows) {
+        const prev = latest.get(r.filePath);
+        if (!prev || (r.version ?? 0) > (prev.version ?? 0))
+            latest.set(r.filePath, r);
+    }
+    for (const r of latest.values()) {
+        await handle.db.insert(fileSnapshots).values({
+            sessionId: toSessionId,
+            entryId: r.entryId,
+            filePath: r.filePath,
+            content: r.content,
+            contentHash: r.contentHash,
+            tokenCount: r.tokenCount,
+            version: r.version,
+            mtimeMs: r.mtimeMs,
+        });
+    }
+}
+export { checkFileSnapshot, copyFileSnapshots, getFileSnapshots, getLatestFileSnapshot, upsertFileSnapshot, };

package/dist/session/squash.js

@@ -50,31 +50,39 @@ async function squashRecent(handle, sessionId, count, summarizer, config) {
 ${history}`;
     const summary = await summarizer(prompt);
     const squashEntryId = generateId();
-    const archiveId = cfg.archiveOriginal
-        ? await archiveOriginalEntries(handle, sessionId, toSquash, 'squash', summary, squashEntryId)
-        : generateId();
-    const fileSnapshotIds = [];
-    if (cfg.preserveFileSnapshots) {
-        const hotFiles = extractHotFiles(toSquash);
-        for (const file of hotFiles) {
-            const id = await upsertFileSnapshot(handle, sessionId, file.path, file.content);
-            fileSnapshotIds.push(id);
+    // Atomic rewrite: archive originals → upsert snapshots → delete originals →
+    // insert summary. If any step throws, the whole transaction rolls back and
+    // the original message history is left intact. (Mirrors compactSession.)
+    const { archiveId, fileSnapshotIds } = await handle.db.transaction(async (tx) => {
+        const txHandle = { db: tx, close: handle.close };
+        const archiveId = cfg.archiveOriginal
+            ? await archiveOriginalEntries(txHandle, sessionId, toSquash, 'squash', summary, squashEntryId)
+            : generateId();
+        const fileSnapshotIds = [];
+        if (cfg.preserveFileSnapshots) {
+            const hotFiles = extractHotFiles(toSquash);
+            for (const file of hotFiles) {
+                // 不传 mtimeMs：由 upsertFileSnapshot 从已有行透传，压缩后热文件不误判过期。
+                const id = await upsertFileSnapshot(txHandle, sessionId, file.path, file.content);
+                fileSnapshotIds.push(id);
+            }
         }
-    }
-    await deleteEntriesByIds(handle, toSquash.map((m) => m.id));
-    await insertEntry(handle, {
-        id: squashEntryId,
-        sessionId,
-        tag: 'squash',
-        content: {
-            summary,
-            squashedEntryIds: toSquash.map((m) => m.id),
-            archiveId,
-        },
-        tokenCount: estimateTokens(summary),
-        // Position at the first squashed message's timestamp so it sorts between
-        // the prefix and the kept tail under createdAt-ascending order.
-        createdAt: toSquash[0] ? new Date(toSquash[0].createdAt) : new Date(),
+        await deleteEntriesByIds(txHandle, toSquash.map((m) => m.id));
+        await insertEntry(txHandle, {
+            id: squashEntryId,
+            sessionId,
+            tag: 'squash',
+            content: {
+                summary,
+                squashedEntryIds: toSquash.map((m) => m.id),
+                archiveId,
+            },
+            tokenCount: estimateTokens(summary),
+            // Position at the first squashed message's timestamp so it sorts between
+            // the prefix and the kept tail under createdAt-ascending order.
+            createdAt: toSquash[0] ? new Date(toSquash[0].createdAt) : new Date(),
+        });
+        return { archiveId, fileSnapshotIds };
     });
     return {
         compacted: true,

package/dist/session/types.d.ts

@@ -117,6 +117,8 @@ type FileSnapshot = {
     contentHash: string;
     tokenCount: number;
     version: number;
+    /** 快照创建时文件磁盘 mtime（毫秒）；旧行无此字段（迁移前写入） */
+    mtimeMs?: number;
     createdAt: number;
 };
 export type { ArchiveRef, BranchSummaryEntry, CompactionArchive, CompactionConfig, CompactionEntry, CompactionResult, FileSnapshot, HotFile, MessageInput, SessionEntry, SessionTreeNode, SquashConfig, SquashEntry, SteeringEntry, Summarizer, };

package/dist/shared/types/agent.d.ts

@@ -184,6 +184,17 @@ type AgentEvent = {
     archiveId?: string;
     compactedCount: number;
     keptCount: number;
+}
+/** Tag-based todo 操作成功后发射，前端据此刷新 TodoPanel。 */
+ | {
+    _tag: 'todo_update';
+    phases: {
+        name: string;
+        tasks: {
+            content: string;
+            status: string;
+        }[];
+    }[];
 } | {
     _tag: 'done';
 };

package/dist/shared/types/config.d.ts

@@ -64,16 +64,17 @@ type UpdateConfig = {
     intervalMs: number;
     /** 启动后首次检查的延迟（毫秒），默认 10 秒。 */
     initialDelayMs: number;
-    /** 发现新版本后自动应用（无感知），false 则仅前端提示手动确认（默认 false）。 */
-    autoApply: boolean;
 };
-/** Server security configuration (spec §24.2). */
+/** Server security configuration (spec §24.2)。 */
 type SecurityConfig = {
-    /** 启用 Bearer token 认证（远程访问场景）。本地开发默认关闭。 */
+    /**
+     * 是否启用 Bearer token 认证（默认 true）。
+     * 关闭为显式选择（可信网络/无人值守场景），会取消一切 API 鉴权。
+     */
     authEnabled: boolean;
-    /** Bearer token；authEnabled 为 true 时必填。 */
+    /** Bearer token；未提供时服务端自动生成并持久化到全局数据目录（跨重启/热更新稳定）。 */
     token?: string;
-    /** 额外允许的 CORS origin（本地回环始终允许）。 */
+    /** 额外允许的 CORS origin（本地回环始终允许；局域网/远程访问需显式添加）。 */
     allowedOrigins: string[];
 };
 /** Global application configuration. */

package/dist/shared/utils/path.d.ts

@@ -5,11 +5,10 @@
  * - `resolve(root, requestPath)` 解析后，若结果不在 root 子树内则返回 null。
  * - 判定逻辑：`relative(root, resolved)` 以 `..` 开头即越界；
  *   再用 `resolve(root, rel) === resolved` 兜底，防止相对段恰好名为 root 的边角情况。
+ * - symlink 防逃逸（P2-5）：root 与目标（或其最近已存在祖先）经 realpath 解析后，
+ *   目标必须仍落在 root 实路径内；否则返回 null。
  *
  * 返回解析后的绝对路径；越界返回 null。
- *
- * 注意：本函数基于 `relative`，不解析符号链接（symlink）。若 root 内存在指向
- * root 外的符号链接，本函数无法阻止经由该链接的逃逸——symlink 逃逸不在本次范围内。
  */
 declare function safeResolve(root: string, requestPath: string): string | null;
 export { safeResolve };

package/dist/shared/utils/path.js

@@ -1,4 +1,5 @@
-import { relative, resolve } from 'node:path';
+import { existsSync, realpathSync } from 'node:fs';
+import { dirname, relative, resolve, sep } from 'node:path';
 /**
  * 安全路径解析：确保 requestPath 解析后落在 root 内，防止路径穿越
  * （如 `../etc/passwd`、绝对路径 `/etc/passwd`）。
@@ -6,11 +7,10 @@ import { relative, resolve } from 'node:path';
  * - `resolve(root, requestPath)` 解析后，若结果不在 root 子树内则返回 null。
  * - 判定逻辑：`relative(root, resolved)` 以 `..` 开头即越界；
  *   再用 `resolve(root, rel) === resolved` 兜底，防止相对段恰好名为 root 的边角情况。
+ * - symlink 防逃逸（P2-5）：root 与目标（或其最近已存在祖先）经 realpath 解析后，
+ *   目标必须仍落在 root 实路径内；否则返回 null。
  *
  * 返回解析后的绝对路径；越界返回 null。
- *
- * 注意：本函数基于 `relative`，不解析符号链接（symlink）。若 root 内存在指向
- * root 外的符号链接，本函数无法阻止经由该链接的逃逸——symlink 逃逸不在本次范围内。
  */
 function safeResolve(root, requestPath) {
     const resolved = resolve(root, requestPath);
@@ -18,6 +18,22 @@ function safeResolve(root, requestPath) {
     if (rel.startsWith('..') || resolve(root, rel) !== resolved) {
         return null;
     }
+    try {
+        const rootReal = realpathSync(root);
+        let probe = resolved;
+        while (!existsSync(probe)) {
+            const parent = dirname(probe);
+            if (parent === probe)
+                break;
+            probe = parent;
+        }
+        const probeReal = realpathSync(probe);
+        if (probeReal !== rootReal && !probeReal.startsWith(rootReal + sep))
+            return null;
+    }
+    catch {
+        // realpath 失败（root 不存在等）：保持原有 relative 判定结果
+    }
     return resolved;
 }
 export { safeResolve };

package/dist/tools/builtin/todo.d.ts

@@ -47,6 +47,11 @@ export declare function nextActionableTask(phases: readonly TodoPhase[]): TodoIt
  *  `descriptions`. Normalize-then-equal first, with a substring fallback
  *  in either direction (≥6 char overlap on the contained side). */
 export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
+/** Apply a single todo op to existing phases. Returns new phases + errors. */
+declare function applyParams(phases: TodoPhase[], params: TodoInput): {
+    phases: TodoPhase[];
+    errors: string[];
+};
 /** Render todo phases as a Markdown checklist suitable for editing/copying. */
 export declare function phasesToMarkdown(phases: TodoPhase[]): string;
 /** Parse a Markdown checklist back into todo phases. */
@@ -54,6 +59,7 @@ export declare function markdownToPhases(md: string): {
     phases: TodoPhase[];
     errors: string[];
 };
+export declare function formatSummary(phases: TodoPhase[], errors: string[], readOnly?: boolean): string;
 /** Extract the latest todo phases from stored messages (tool results).
  *  Scans backwards for the most recent `todo` tool result with phases metadata. */
 export declare function getLatestTodoPhasesFromMessages(messages: {
@@ -65,3 +71,4 @@ export declare function getLatestTodoPhasesFromMessages(messages: {
  *  State is held in-memory via ctx.todoState hook (dependency-reversal). */
 export declare const todoTool: ToolDef;
 export type { TodoInput, TodoItem, TodoPhase, TodoStatus };
+export { applyParams };

package/dist/tools/builtin/todo.js

@@ -293,10 +293,9 @@ export function phasesToMarkdown(phases) {
     if (phases.length === 0)
         return '# Todos\n';
     const out = [];
-    for (let i = 0; i < phases.length; i++) {
+    for (const [i, phase] of phases.entries()) {
         if (i > 0)
             out.push('');
-        const phase = phases[i];
         out.push(`# ${phase.name}`);
         for (const task of phase.tasks) {
             out.push(`- [${STATUS_TO_MARKER[task.status]}] ${task.content}`);
@@ -320,14 +319,13 @@ export function markdownToPhases(md) {
     const phases = [];
     let currentPhase;
     const lines = md.split(/\r?\n/);
-    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-        const raw = lines[lineNum];
+    for (const [lineNum, raw] of lines.entries()) {
         const trimmed = raw.trim();
         if (!trimmed)
             continue;
         const headingMatch = /^#{1,6}\s+(.+?)\s*$/.exec(trimmed);
         if (headingMatch) {
-            currentPhase = { name: headingMatch[1].trim(), tasks: [] };
+            currentPhase = { name: (headingMatch[1] ?? '').trim(), tasks: [] };
             phases.push(currentPhase);
             continue;
         }
@@ -343,7 +341,7 @@ export function markdownToPhases(md) {
                 errors.push(`Line ${lineNum + 1}: unknown status marker "[${marker}]" (use [ ], [x], [/], [-])`);
                 continue;
             }
-            currentPhase.tasks.push({ content: taskMatch[2].trim(), status });
+            currentPhase.tasks.push({ content: (taskMatch[2] ?? '').trim(), status });
             continue;
         }
         errors.push(`Line ${lineNum + 1}: unrecognized syntax "${trimmed}"`);
@@ -354,7 +352,7 @@ export function markdownToPhases(md) {
 // =============================================================================
 // Summary formatter
 // =============================================================================
-function formatSummary(phases, errors, readOnly = false) {
+export function formatSummary(phases, errors, readOnly = false) {
     const tasks = phases.flatMap((phase) => phase.tasks);
     if (tasks.length === 0) {
         if (errors.length > 0)
@@ -362,16 +360,20 @@ function formatSummary(phases, errors, readOnly = false) {
         return readOnly ? 'Todo list is empty.' : 'Todo list cleared.';
     }
     const remainingByPhase = phases
-        .map((phase) => ({
+        .map((phase, pi) => ({
         name: phase.name,
-        tasks: phase.tasks.filter((task) => task.status === 'pending' || task.status === 'in_progress'),
+        tasks: phase.tasks
+            .map((task, ti) => ({ task, seq: `${pi + 1}-${ti + 1}` }))
+            .filter(({ task }) => task.status === 'pending' || task.status === 'in_progress'),
     }))
         .filter((phase) => phase.tasks.length > 0);
-    const remainingTasks = remainingByPhase.flatMap((phase) => phase.tasks.map((task) => ({ ...task, phase: phase.name })));
+    const remainingTasks = remainingByPhase.flatMap((phase) => phase.tasks.map(({ task, seq }) => ({ ...task, seq, phase: phase.name })));
     let currentIdx = phases.findIndex((phase) => phase.tasks.some((task) => task.status === 'pending' || task.status === 'in_progress'));
     if (currentIdx === -1)
         currentIdx = phases.length - 1;
     const current = phases[currentIdx];
+    if (!current)
+        return errors.length > 0 ? `Errors: ${errors.join('; ')}` : 'Todo list cleared.';
     const done = current.tasks.filter((task) => task.status === 'completed' || task.status === 'abandoned').length;
     const lines = [];
     if (errors.length > 0)
@@ -382,7 +384,7 @@ function formatSummary(phases, errors, readOnly = false) {
     else {
         lines.push(`Remaining items (${remainingTasks.length}):`);
         for (const task of remainingTasks) {
-            lines.push(`  - ${task.content} [${task.status}] (${task.phase})`);
+            lines.push(`  - ${task.seq}: ${task.content} [${task.status}] (${task.phase})`);
         }
     }
     const closedAll = tasks.filter((task) => task.status === 'completed' || task.status === 'abandoned').length;
@@ -392,16 +394,17 @@ function formatSummary(phases, errors, readOnly = false) {
     lines.push(`Active phase ${currentIdx + 1}/${phases.length} "${current.name}" (${done}/${current.tasks.length})${workedAhead
         ? ' — earliest phase with open tasks; the in-progress pointer auto-advances to the earliest open task on each completion, so it can sit behind out-of-order work (nothing was un-completed).'
         : '.'}`);
-    for (const phase of phases) {
+    for (const [pi, phase] of phases.entries()) {
         lines.push(`  ${phase.name}:`);
-        for (const task of phase.tasks) {
+        for (const [ti, task] of phase.tasks.entries()) {
+            const seq = `${pi + 1}-${ti + 1}`;
             const checkbox = task.status === 'completed' ? '[X]' : '[ ]';
             const tag = task.status === 'in_progress'
                 ? ' (in progress)'
                 : task.status === 'abandoned'
                     ? ' (dropped)'
                     : '';
-            lines.push(`    - ${checkbox} ${task.content}${tag}`);
+            lines.push(`    - ${checkbox} ${seq}: ${task.content}${tag}`);
         }
     }
     return lines.join('\n');
@@ -414,20 +417,21 @@ function formatSummary(phases, errors, readOnly = false) {
 export function getLatestTodoPhasesFromMessages(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
-        if (msg.role !== 'tool')
+        if (msg?.role !== 'tool')
             continue;
         for (let j = msg.content.length - 1; j >= 0; j--) {
             const part = msg.content[j];
-            if (!part || part._tag !== 'tool_result')
+            if (part?._tag !== 'tool_result')
                 continue;
             if (part.tool !== 'todo')
                 continue;
             const output = part.output;
-            if (!output || output._tag !== 'success')
+            if (output?._tag !== 'success')
                 continue;
             const metadata = output.metadata;
-            if (metadata && Array.isArray(metadata.phases)) {
-                return clonePhases(metadata.phases);
+            const phases = metadata?.phases;
+            if (Array.isArray(phases)) {
+                return clonePhases(phases);
             }
         }
     }
@@ -463,7 +467,10 @@ const todoParameters = {
             },
         },
         task: { type: 'string', description: 'Task content (for start/done/drop/rm)' },
-        phase: { type: 'string', description: 'Phase name (for done/drop/rm/append, or init flat mode)' },
+        phase: {
+            type: 'string',
+            description: 'Phase name (for done/drop/rm/append, or init flat mode)',
+        },
         items: {
             type: 'array',
             items: { type: 'string' },
@@ -515,3 +522,4 @@ export const todoTool = {
         return { _tag: 'success', output, metadata };
     },
 };
+export { applyParams };

package/dist/tools/index.d.ts

@@ -6,11 +6,11 @@ export { dapTools } from './builtin/dap.js';
 export { editTool } from './builtin/edit.js';
 export { globTool, globToRegex } from './builtin/glob.js';
 export { grepTool } from './builtin/grep.js';
+export { kanbanTool } from './builtin/kanban.js';
 export { readTool } from './builtin/read.js';
 export { createDefaultURLRegistry, createFileResolver, createSkillResolver, } from './builtin/resolvers.js';
-export { kanbanTool } from './builtin/kanban.js';
-export { todoTool } from './builtin/todo.js';
 export type { TodoInput, TodoItem, TodoPhase, TodoStatus } from './builtin/todo.js';
+export { todoTool } from './builtin/todo.js';
 export { writeTool } from './builtin/write.js';
 export { yieldTool } from './builtin/yield.js';
 export { executeTool } from './executor.js';
@@ -23,10 +23,21 @@ export { formatForLLM, resolveProvider, runWebSearch } from './websearch/index.j
 export type { WebSearchProvider, WebSearchProviderId, WebSearchResponse, WebSearchSource, } from './websearch/types.js';
 export { createWebSearchTool } from './websearch/websearch.js';
 import type { Config } from '../shared/types/config.js';
+import type { ToolRegistry } from './types.js';
 /**
  * Create a registry pre-loaded with all builtin tools:
  * read, write, edit, glob, grep, bash, task, websearch, and the debug_* set.
  *
+ * config.tools.disabled 中的工具**不注册**——registry 层过滤保证两个入口
+ * （CLI print / Web chat / /api/tools 列表）统一生效，禁用的工具对 agent 完全不可见。
  * @param config 可选配置；websearch 工具按 config.websearch 构造。省略时用 DEFAULT_CONFIG。
  */
-export declare function createDefaultRegistry(config?: Config): import("./types.js").ToolRegistry;
+export declare function createDefaultRegistry(config?: Config): ToolRegistry;
+/**
+ * 解析本轮启用的工具名列表（P1-1 修复：config.tools.enabled/disabled 双入口统一生效）。
+ *
+ * - explicit（前端显式选择）非 undefined → 以其为准，但过滤掉 disabled 与未注册名。
+ * - 否则 enabled 非空 → enabled ∩ registered；enabled 空 → 全部 registered（空=全部）。
+ * - disabled 恒过滤（registry 已排除，此处兜底）。
+ */
+export declare function resolveEnabledToolNames(registry: ToolRegistry, config: Pick<Config, 'tools'>, explicit?: string[]): string[];

package/dist/tools/index.js

@@ -4,10 +4,10 @@ export { dapTools } from './builtin/dap.js';
 export { editTool } from './builtin/edit.js';
 export { globTool, globToRegex } from './builtin/glob.js';
 export { grepTool } from './builtin/grep.js';
+export { kanbanTool } from './builtin/kanban.js';
 export { readTool } from './builtin/read.js';
 // ── Builtin tools ───────────────────────────────────────────
 export { createDefaultURLRegistry, createFileResolver, createSkillResolver, } from './builtin/resolvers.js';
-export { kanbanTool } from './builtin/kanban.js';
 export { todoTool } from './builtin/todo.js';
 export { writeTool } from './builtin/write.js';
 export { yieldTool } from './builtin/yield.js';
@@ -33,28 +33,50 @@ import { taskTool } from './builtin/task.js';
 import { todoTool } from './builtin/todo.js';
 import { writeTool } from './builtin/write.js';
 import { yieldTool } from './builtin/yield.js';
-import { createToolRegistry, registerTool } from './registry.js';
+import { createToolRegistry, listTools, registerTool } from './registry.js';
 import { createWebSearchTool } from './websearch/websearch.js';
 /**
  * Create a registry pre-loaded with all builtin tools:
  * read, write, edit, glob, grep, bash, task, websearch, and the debug_* set.
  *
+ * config.tools.disabled 中的工具**不注册**——registry 层过滤保证两个入口
+ * （CLI print / Web chat / /api/tools 列表）统一生效，禁用的工具对 agent 完全不可见。
  * @param config 可选配置；websearch 工具按 config.websearch 构造。省略时用 DEFAULT_CONFIG。
  */
 export function createDefaultRegistry(config = DEFAULT_CONFIG) {
     const reg = createToolRegistry();
-    registerTool(reg, readTool);
-    registerTool(reg, writeTool);
-    registerTool(reg, editTool);
-    registerTool(reg, globTool);
-    registerTool(reg, grepTool);
-    registerTool(reg, bashTool);
-    registerTool(reg, kanbanTool);
-    registerTool(reg, taskTool);
-    registerTool(reg, todoTool);
-    registerTool(reg, yieldTool);
-    registerTool(reg, createWebSearchTool(config.websearch));
+    const disabled = new Set(config.tools?.disabled ?? []);
+    const register = (tool) => {
+        if (!disabled.has(tool.name))
+            registerTool(reg, tool);
+    };
+    register(readTool);
+    register(writeTool);
+    register(editTool);
+    register(globTool);
+    register(grepTool);
+    register(bashTool);
+    register(kanbanTool);
+    register(taskTool);
+    register(todoTool);
+    register(yieldTool);
+    register(createWebSearchTool(config.websearch));
     for (const tool of dapTools)
-        registerTool(reg, tool);
+        register(tool);
     return reg;
 }
+/**
+ * 解析本轮启用的工具名列表（P1-1 修复：config.tools.enabled/disabled 双入口统一生效）。
+ *
+ * - explicit（前端显式选择）非 undefined → 以其为准，但过滤掉 disabled 与未注册名。
+ * - 否则 enabled 非空 → enabled ∩ registered；enabled 空 → 全部 registered（空=全部）。
+ * - disabled 恒过滤（registry 已排除，此处兜底）。
+ */
+export function resolveEnabledToolNames(registry, config, explicit) {
+    const all = listTools(registry).map((t) => t.name);
+    const disabled = new Set(config.tools?.disabled ?? []);
+    const base = explicit ?? (config.tools?.enabled && config.tools.enabled.length > 0
+        ? config.tools.enabled
+        : all);
+    return base.filter((n) => all.includes(n) && !disabled.has(n));
+}

package/dist/update/index.d.ts

@@ -7,4 +7,4 @@ export { orderSessionsByParent, restoreSessions, serializeSessions } from './sna
 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';
+export { checkForUpdate, compareSemver, getCurrentVersion } from './version.js';

package/dist/update/index.js

@@ -3,4 +3,4 @@ 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';
+export { checkForUpdate, compareSemver, getCurrentVersion } from './version.js';

package/dist/update/ipc.d.ts

@@ -7,9 +7,36 @@ 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;
+    /**
+     * 响应发出后退出进程（旧实例完整让渡：主服务与资源已在 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 };