c0de-agent 1.11.0 → 1.13.0

package/dist/server/auth-manager.js

@@ -9,9 +9,12 @@
 //   - 显式配置 security.token 时为静态模式：不轮换、不配对（CI/脚本场景）。
 //   - authEnabled=false 时不启用。
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, watch, writeFileSync, } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 const DEVICES_FILENAME = 'devices.json';
+/** 首设备 bootstrap token 默认有效期：5 分钟。缩短「URL 泄漏后抢先注册」竞态窗口。
+ *  重新 `c0de serve` 会重新生成 bootstrap（无已注册设备时），刷新该窗口。 */
+const DEFAULT_FIRST_DEVICE_TTL_MS = 5 * 60 * 1000;
 function hashToken(token) {
     return createHash('sha256').update(token).digest('hex');
 }
@@ -25,15 +28,13 @@ function safeEqual(a, b) {
 export function createAuthManager(opts) {
     const { dataDir, staticToken, tokenFilePath, now = Date.now } = opts;
     const pairingTtlMs = opts.pairingTtlMs ?? 10 * 60 * 1000;
-    const handoffRetention = opts.handoffTokenRetention ?? 3;
+    const firstDeviceTtlMs = opts.firstDeviceTtlMs ?? DEFAULT_FIRST_DEVICE_TTL_MS;
     const tokenPath = tokenFilePath ?? join(dataDir, 'auth-token');
     const devicesPath = join(dataDir, DEVICES_FILENAME);
     // ── 状态加载 ──
     let bootstrap = staticToken && staticToken.length > 0 ? staticToken : readBootstrapToken(tokenPath);
     const devices = new Map();
     loadDevices();
-    // 轮换历史 bootstrap（仅 handoff 校验接受，API 不接受）
-    const previousBootstraps = [];
     const pending = new Map();
     function readBootstrapToken(path) {
         try {
@@ -95,17 +96,11 @@ export function createAuthManager(opts) {
     function rotateBootstrap() {
         if (staticToken && staticToken.length > 0)
             return; // 静态模式不轮换
-        const next = randomBytes(32).toString('hex');
-        if (bootstrap) {
-            previousBootstraps.push(bootstrap);
-            if (previousBootstraps.length > handoffRetention)
-                previousBootstraps.shift();
-        }
-        bootstrap = next;
+        bootstrap = randomBytes(32).toString('hex');
         try {
             if (!existsSync(dataDir))
                 mkdirSync(dataDir, { recursive: true });
-            writeFileSync(tokenPath, next, 'utf-8');
+            writeFileSync(tokenPath, bootstrap, 'utf-8');
         }
         catch {
             // 写文件失败：内存 token 仍已轮换，进程内一致
@@ -124,12 +119,24 @@ export function createAuthManager(opts) {
             return false;
         return safeEqual(token, bootstrap);
     }
+    /** bootstrap 自生成（token 文件 mtime）起的存活时长；静态模式或无法读取返回 null。 */
+    function bootstrapAge() {
+        if (staticToken && staticToken.length > 0)
+            return null;
+        try {
+            return now() - statSync(tokenPath).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
     function cleanExpiredPairings() {
         const cutoff = now() - pairingTtlMs;
         for (const [id, p] of pending) {
-            if (p.status === 'pending' && p.createdAt <= cutoff) {
+            // 不论状态一律过期清理：approved 但新设备始终未取走 token 的条目（客户端放弃轮询）
+            // 同样需要回收，否则长驻内存且其明文 token 无期限留存。
+            if (p.createdAt <= cutoff)
                 pending.delete(id);
-            }
         }
     }
     return {
@@ -150,20 +157,24 @@ export function createAuthManager(opts) {
                 return true;
             if (verifyBootstrap(token))
                 return true;
-            for (const prev of previousBootstraps) {
-                if (safeEqual(token, prev))
-                    return true;
-            }
             return false;
         },
         async registerFirstDevice(bootstrapToken, deviceName) {
             if (staticToken && staticToken.length > 0)
-                return null; // 静态模式无设备注册
-            if (!verifyBootstrap(bootstrapToken))
-                return null;
-            // 已有设备 → bootstrap 已失效，不得再凭它注册（需配对审批）
+                return { ok: false, reason: 'static_mode' };
+            // 已有设备 → bootstrap 已失效（注册即轮换），不得再凭它注册（需配对审批）。
+            // 先于 verifyBootstrap 判定：轮换后的旧 URL token 属「已消费」而非「无效」，
+            // 两者给用户的恢复指引不同（配对审批 vs 检查 token）。
             if (devices.size > 0)
-                return null;
+                return { ok: false, reason: 'devices_exist' };
+            if (!verifyBootstrap(bootstrapToken))
+                return { ok: false, reason: 'invalid_bootstrap' };
+            // 首设备注册窗口：bootstrap 超过 firstDeviceTtlMs 后拒绝（缩短先到先得竞态窗口）。
+            if (firstDeviceTtlMs > 0) {
+                const age = bootstrapAge();
+                if (age != null && age > firstDeviceTtlMs)
+                    return { ok: false, reason: 'ttl_expired' };
+            }
             const deviceToken = randomBytes(32).toString('hex');
             const record = {
                 id: randomBytes(16).toString('hex'),
@@ -174,16 +185,21 @@ export function createAuthManager(opts) {
             devices.set(record.id, record);
             persist();
             rotateBootstrap(); // 注册成功即轮换，旧 bootstrap（URL/shell history 中）立即失效
-            return deviceToken;
+            return { ok: true, deviceToken };
         },
-        requestPairing(deviceName) {
+        requestPairing(deviceName, source) {
             if (staticToken && staticToken.length > 0)
                 return null;
             cleanExpiredPairings();
-            // 限流：最多 10 个待审批
+            // 限流：最多 10 个待审批；同一来源最多 3 个（防本地/远程进程刷满队列，
+            // 使合法设备 10 分钟内无法配对）。source 尽力而为，缺省视为 'unknown'。
             const pendingCount = Array.from(pending.values()).filter((p) => p.status === 'pending').length;
             if (pendingCount >= 10)
                 return null;
+            const src = source ?? 'unknown';
+            const perSource = Array.from(pending.values()).filter((p) => p.status === 'pending' && p.source === src).length;
+            if (perSource >= 3)
+                return null;
             const pairingId = randomBytes(16).toString('hex');
             const code = String(100000 + Math.floor(Math.random() * 900000)); // 6 位数字
             pending.set(pairingId, {
@@ -192,6 +208,7 @@ export function createAuthManager(opts) {
                 code,
                 createdAt: now(),
                 status: 'pending',
+                source: src,
             });
             return { pairingId, code };
         },
@@ -199,8 +216,24 @@ export function createAuthManager(opts) {
             const p = pending.get(pairingId);
             if (!p)
                 return { status: 'not_found' };
-            if (p.status === 'approved')
-                return { status: 'approved', deviceToken: p.deviceToken ?? '' };
+            if (p.status === 'approved') {
+                // 交付点：把设备登记落盘与「新设备取走 token」原子化到同一时刻——
+                // 审批后、取 token 前服务重启时 pending 随内存清空（status=not_found），
+                // 不会留下拿不到 token 的僵尸设备条目；此后新设备重新发起配对即可。
+                const deviceToken = p.deviceToken ?? '';
+                if (deviceToken) {
+                    const record = {
+                        id: randomBytes(16).toString('hex'),
+                        name: p.deviceName,
+                        tokenHash: hashToken(deviceToken),
+                        createdAt: now(),
+                    };
+                    devices.set(record.id, record);
+                    persist();
+                    pending.delete(pairingId);
+                }
+                return { status: 'approved', deviceToken };
+            }
             if (p.status === 'denied')
                 return { status: 'denied' };
             if (p.createdAt <= now() - pairingTtlMs) {
@@ -218,32 +251,35 @@ export function createAuthManager(opts) {
                 deviceName: p.deviceName,
                 code: p.code,
                 createdAt: p.createdAt,
+                source: p.source,
             }));
         },
-        approvePairing(pairingId) {
+        approvePairing(pairingId, code) {
             const p = pending.get(pairingId);
-            if (!p || p.status !== 'pending')
-                return false;
+            if (!p)
+                return 'not_found';
+            if (p.status !== 'pending')
+                return 'already_handled';
             if (p.createdAt <= now() - pairingTtlMs) {
                 pending.delete(pairingId);
-                return false;
+                return 'expired';
             }
+            if (String(code ?? '').trim() !== p.code)
+                return 'code_mismatch';
+            // P：登记推迟到新设备真正取走 token 时（pairingStatus 消费）。此前审批即落盘，
+            // 若审批后、新设备轮询前服务重启，devices.json 里会出现一个永远拿不到 token
+            // 的僵尸条目（pending 不落盘、明文 token 只在内存）——「已授权设备」列表与
+            // 实际可登录设备自相矛盾，用户只能撤销后重新配对。
             const deviceToken = randomBytes(32).toString('hex');
-            const record = {
-                id: randomBytes(16).toString('hex'),
-                name: p.deviceName,
-                tokenHash: hashToken(deviceToken),
-                createdAt: now(),
-            };
-            devices.set(record.id, record);
             p.status = 'approved';
             p.deviceToken = deviceToken;
-            persist();
-            return true;
+            return 'approved';
         },
         denyPairing(pairingId) {
             const p = pending.get(pairingId);
-            if (!p || p.status !== 'pending')
+            if (!p)
+                return false;
+            if (p.status !== 'pending')
                 return false;
             p.status = 'denied';
             return true;

package/dist/server/context.js

@@ -33,9 +33,22 @@ function createServerContext(opts) {
         hookRunner,
         pluginRegistry: createPluginRegistry(hookRunner),
         agentManager: createAgentManager(),
-        permissionStore: createPermissionStore(),
+        // P3：与生产 buildServerContext 同口径——配置的确认超时/宽限期生效。
+        permissionStore: createPermissionStore({
+            ...(config.permission.timeoutMs !== undefined && config.permission.timeoutMs > 0
+                ? { timeoutMs: config.permission.timeoutMs }
+                : {}),
+            ...(config.permission.expireGraceMs !== undefined && config.permission.expireGraceMs > 0
+                ? { expireGraceMs: config.permission.expireGraceMs }
+                : {}),
+        }),
         permissionMode: config.permission.defaultMode,
         sessionPermissionModes: new Map(),
+        sessionAlwaysAllow: new Map(),
+        workflowBusyBySession: new Map(),
+        workflowBusyByScope: new Map(),
+        // P1-1：项目级 LLM 注册表缓存（按项目合并配置构建，chat 路由按需创建）。
+        projectRegistries: new Map(),
         // 测试工厂不解析/生成 token（不触碰用户全局数据目录）。
         authToken: undefined,
         agentRegistry,

package/dist/server/index.d.ts

@@ -7,5 +7,5 @@ export { apiError, errorHandler } from './middleware/error.js';
 export type { InteractivePermissionChecker, InteractivePermissionCheckerOptions, PermissionRequest, } from './permission/interactive.js';
 export { createInteractivePermissionChecker } from './permission/interactive.js';
 export type { RunningServer, StartServerOptions } from './server.js';
-export { startServer } from './server.js';
+export { DEFAULT_SERVE_PORT, startServer } from './server.js';
 export type { APIErrorBody, ChatRequest, ConfirmRequest, ControlRequest, ServerContext, SteerRequest, } from './types.js';

package/dist/server/index.js

@@ -4,4 +4,4 @@ export { createApp } from './app.js';
 export { createServerContext } from './context.js';
 export { apiError, errorHandler } from './middleware/error.js';
 export { createInteractivePermissionChecker } from './permission/interactive.js';
-export { startServer } from './server.js';
+export { DEFAULT_SERVE_PORT, startServer } from './server.js';

package/dist/server/middleware/auth.d.ts

@@ -4,11 +4,21 @@ export type AuthOptions = {
     publicPaths?: string[];
     /** P2-16：自定义校验函数（authManager.verify）。提供时忽略 token 字符串比较。 */
     verify?: (token: string | undefined) => boolean;
+    /** 认证未启用时的跨域写防线（盲 CSRF）：CORS 回显只拦「读」——恶意网页对本地
+     *  服务的 POST/DELETE 等请求副作用仍会执行，只是读不到响应。开启认证（token/verify
+     *  存在）时凭 token 校验已构成防线，此项不生效。 */
+    allowedOrigins?: string[];
+    /** 允许经 `?token=` 查询参数认证的路径判定（P1 媒体预览修复：浏览器
+     *  <img>/<audio>/<video>/<embed> 元素无法携带 Authorization 头，与终端
+     *  WebSocket 的 query token 同口径）。仅当 Authorization 头缺失/无效时才
+     *  检查 query token——头优先，不会因路径匹配而放行任意 query token。 */
+    queryTokenPath?: (path: string) => boolean;
 };
 /**
  * Bearer token 认证中间件（spec §24.2「认证」）。
  *
- * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
+ * - 未配置 token（undefined/空）→ 放行，适配本地开发场景；但对「写」请求校验
+ *   Origin（仅本地回环 + allowedOrigins），补上 authEnabled=false 时 CORS 不设防的盲写面。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
  * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
  * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。

package/dist/server/middleware/auth.js

@@ -1,8 +1,10 @@
+import { isAllowedOrigin } from './cors.js';
 import { apiError } from './error.js';
 /**
  * Bearer token 认证中间件（spec §24.2「认证」）。
  *
- * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
+ * - 未配置 token（undefined/空）→ 放行，适配本地开发场景；但对「写」请求校验
+ *   Origin（仅本地回环 + allowedOrigins），补上 authEnabled=false 时 CORS 不设防的盲写面。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
  * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
  * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。
@@ -10,8 +12,19 @@ import { apiError } from './error.js';
 export function createAuthMiddleware(token, opts = {}) {
     const expected = token && token.length > 0 ? `Bearer ${token}` : '';
     const publicPaths = new Set(opts.publicPaths ?? ['/api/health']);
+    const queryTokenPath = opts.queryTokenPath;
     return async (c, next) => {
         if (!expected && !opts.verify) {
+            // 认证关闭：无 token 可验证。带 Origin 的非安全方法（浏览器跨域写）需显式放行
+            // 本地/已配置 origin；无 Origin 的请求（curl/CLI/脚本/服务间调用）不受影响。
+            const method = c.req.method;
+            const stateChanging = method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS';
+            if (stateChanging) {
+                const origin = c.req.header('Origin') ?? '';
+                if (origin.length > 0 && !isAllowedOrigin(origin, opts.allowedOrigins)) {
+                    return apiError(c, 403, 'ORIGIN_FORBIDDEN', 'Cross-origin write rejected while authentication is disabled');
+                }
+            }
             await next();
             return;
         }
@@ -19,8 +32,17 @@ export function createAuthMiddleware(token, opts = {}) {
             await next();
             return;
         }
-        const auth = c.req.header('Authorization') ?? '';
-        const ok = opts.verify ? opts.verify(auth.replace(/^Bearer\s+/i, '')) : auth === expected;
+        const headerAuth = c.req.header('Authorization') ?? '';
+        let ok = opts.verify
+            ? opts.verify(headerAuth.replace(/^Bearer\s+/i, ''))
+            : headerAuth === expected;
+        // P1 媒体预览：浏览器媒体元素无 Authorization 头——对判定命中的路径尝试
+        // query token 认证。头已有效则不再检查（头优先）；路径不匹配时 query token
+        // 不参与判定，仅在白名单路径上接受 query 认证。
+        if (!ok && queryTokenPath?.(c.req.path)) {
+            const queryToken = c.req.query('token') ?? '';
+            ok = opts.verify ? opts.verify(queryToken) : `Bearer ${queryToken}` === expected;
+        }
         if (!ok) {
             return apiError(c, 401, 'UNAUTHORIZED', 'Missing or invalid bearer token');
         }

package/dist/server/permission/interactive.d.ts

@@ -3,16 +3,24 @@ import type { PermissionRequest, PermissionStore } from './store.js';
 export type { PermissionRequest };
 type PermissionMode = 'default' | 'auto';
 type InteractivePermissionCheckerOptions = {
-    /** 始终允许的工具名（覆盖 permission 字段）。 */
-    alwaysAllow?: string[];
+    /** 始终允许的工具名（覆盖 permission 字段）。可为 getter：会话级「始终允许」
+     *  白名单在 run 期间可被用户追加，getter 使每次 check 读取最新集合。 */
+    alwaysAllow?: string[] | (() => string[]);
     /** 始终拒绝的工具名（覆盖 permission 字段）。 */
     alwaysDeny?: string[];
     /** 读取当前授权模式：'auto' 时跳过 ask 交互确认（YOLO 自动授权）。 */
     getMode?: () => PermissionMode;
     /** 遇到 ask 权限时调用（用于通知前端）。 */
     onPermissionRequired?: (request: PermissionRequest) => void | Promise<void>;
-    /** 权限确认超时被自动拒绝时调用（P1-6：SSE 通知前端）。 */
+    /** 首层确认超时（仅提示，pending 保持）时调用（P1-6：SSE 通知前端）。 */
     onPermissionTimeout?: (request: PermissionRequest) => void;
+    /** 兜底过期（提示后仍无响应，自动拒绝）时调用（P0 双层超时：前端清理弹窗状态）。 */
+    onPermissionExpired?: (request: PermissionRequest) => void;
+    /** 权限请求「报告归属」的会话 id。缺省取 tool context 的会话——子 agent 的 ask
+     *  请求会挂在各自子会话上，用户所在的主/工作流会话按 sessionId 重挂 pending
+     *  弹窗时找不到。传入发起 run 的用户可见会话 id，使 GET /api/permissions/:id/pending
+     *  能从该会话恢复全部子 agent 的挂起请求。 */
+    reportSessionId?: string;
 };
 /** 阻塞式权限检查器：ask 权限会阻塞等待用户确认。
  *  pending 存在全局 PermissionStore 中，独立于 agent run 生命周期。 */

package/dist/server/permission/interactive.js

@@ -1,13 +1,21 @@
 import { randomUUID } from 'node:crypto';
 function createInteractivePermissionChecker(store, opts = {}) {
-    const allowSet = new Set(opts.alwaysAllow ?? []);
+    const allowSet = opts.alwaysAllow
+        ? Array.isArray(opts.alwaysAllow)
+            ? new Set(opts.alwaysAllow)
+            : null
+        : null;
     const denySet = new Set(opts.alwaysDeny ?? []);
     return {
         check: async (tool, input, ctx) => {
             if (denySet.has(tool.name)) {
                 return { _tag: 'deny', reason: `Tool "${tool.name}" is denied by configuration` };
             }
-            if (allowSet.has(tool.name) || tool.permission === 'auto') {
+            // 静态集合或动态 getter（会话级白名单可在 run 期间追加）
+            const dynamicAllowed = allowSet === null && typeof opts.alwaysAllow === 'function'
+                ? opts.alwaysAllow().includes(tool.name)
+                : allowSet?.has(tool.name);
+            if (dynamicAllowed || tool.permission === 'auto') {
                 return { _tag: 'allow' };
             }
             if (tool.permission === 'deny') {
@@ -21,15 +29,26 @@ function createInteractivePermissionChecker(store, opts = {}) {
             }
             // 交互式确认
             const toolCallId = randomUUID();
-            const request = { toolCallId, tool: tool.name, input };
+            const reportedSessionId = opts.reportSessionId ?? ctx.session?.id;
+            const request = {
+                toolCallId,
+                tool: tool.name,
+                input,
+                // P1：绑定会话 id——挂起期间用户切换页面后，前端经
+                // GET /api/permissions/:sessionId/pending 重挂确认弹窗。
+                // 子 agent 请求按 reportSessionId 归属到发起 run 的用户可见会话，
+                // 而不是各自的子会话（用户不会停留在子会话页面上等确认）。
+                ...(reportedSessionId ? { sessionId: reportedSessionId } : {}),
+            };
             const promise = new Promise((resolve) => {
                 // pending 注册到全局 store，confirm 端点按 toolCallId 直接寻址，
                 // 不依赖当前 agent run 是否仍在 agentManager 中注册。
-                // store 内置超时：到期自动 deny 并清理条目（防永久挂起 + Map 泄漏）。
+                // store 内置双层超时：首层提示（pending 保持），宽限期后兜底 deny。
                 store.register(toolCallId, {
                     request,
                     resolve,
                     ...(opts.onPermissionTimeout ? { onTimeout: opts.onPermissionTimeout } : {}),
+                    ...(opts.onPermissionExpired ? { onExpired: opts.onPermissionExpired } : {}),
                 });
             });
             await opts.onPermissionRequired?.(request);

package/dist/server/permission/store.d.ts

@@ -2,23 +2,31 @@ import type { PermissionResult } from '../../tools/types.js';
 /** 默认 pending 超时时长：5 分钟（300_000ms）。
  *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
 declare const DEFAULT_PERMISSION_TIMEOUT_MS: number;
+/** 首层超时（仅提示）后到兜底自动拒绝的宽限期：25 分钟。双层超时总窗口 30 分钟。 */
+declare const DEFAULT_PERMISSION_EXPIRE_GRACE_MS: number;
 /** 权限请求（需要用户确认）。 */
 type PermissionRequest = {
     toolCallId: string;
     tool: string;
     input: unknown;
+    /** 请求所属会话（P1：跨页面挂起恢复用；无会话上下文的调用方省略）。 */
+    sessionId?: string;
 };
 /** 待处理的权限确认。 */
 type PendingPermission = {
     request: PermissionRequest;
     resolve: (result: PermissionResult) => void;
-    /** 该请求超时自动拒绝时的回调（P1-6：按请求绑定 SSE 流）。 */
+    /** 首层超时回调（P1-6：按请求绑定 SSE 流，仅提示不终结）。 */
     onTimeout?: (request: PermissionRequest) => void;
+    /** 兜底过期回调（P0 双层超时：提示后仍无响应 → 自动拒绝，通知前端清理弹窗状态）。 */
+    onExpired?: (request: PermissionRequest) => void;
 };
 /** createPermissionStore 的配置。 */
 type PermissionStoreOptions = {
     /** pending 超时毫秒数；省略时取 DEFAULT_PERMISSION_TIMEOUT_MS（5 分钟）。 */
     timeoutMs?: number;
+    /** 首层超时后到兜底自动拒绝的宽限毫秒数；省略时 25 分钟。 */
+    expireGraceMs?: number;
     /** 超时自动拒绝时回调（P1-6：通知前端「确认超时已拒绝」，提供重新询问入口）。 */
     onTimeout?: (request: PermissionRequest) => void;
 };
@@ -28,9 +36,13 @@ type PermissionStore = {
     resolve(toolCallId: string, approved: boolean): boolean;
     has(toolCallId: string): boolean;
     size(): number;
+    /** 查询某会话当前挂起的权限请求（P1：前端重挂弹窗；无则 null）。 */
+    pendingForSession(sessionId: string): PermissionRequest | null;
+    /** P3：统计指定会话集合内的挂起请求数（update 影响面按受影响会话过滤用）。 */
+    countForSessions(sessionIds: ReadonlySet<string>): number;
     /** settle 所有 pending 为 deny 并清空（dev 热重载重建前调用）。 */
     dispose(): void;
 };
 declare function createPermissionStore(opts?: PermissionStoreOptions): PermissionStore;
 export type { PendingPermission, PermissionRequest, PermissionStore, PermissionStoreOptions };
-export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };
+export { createPermissionStore, DEFAULT_PERMISSION_EXPIRE_GRACE_MS, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/permission/store.js

@@ -7,8 +7,11 @@
 /** 默认 pending 超时时长：5 分钟（300_000ms）。
  *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
 const DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1000;
+/** 首层超时（仅提示）后到兜底自动拒绝的宽限期：25 分钟。双层超时总窗口 30 分钟。 */
+const DEFAULT_PERMISSION_EXPIRE_GRACE_MS = 25 * 60 * 1000;
 function createPermissionStore(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
+    const expireGraceMs = opts.expireGraceMs ?? DEFAULT_PERMISSION_EXPIRE_GRACE_MS;
     const pending = new Map();
     // 统一终结路径：clearTimeout → 删除条目 → resolve。
     // 三处调用（confirm、超时回调、abort 联动）都汇聚于此：
@@ -28,9 +31,27 @@ function createPermissionStore(opts = {}) {
             const existing = pending.get(toolCallId);
             if (existing)
                 clearTimeout(existing.timer);
+            // P0 双层超时：首层仅提示（pending 保持，用户可「重新询问」）；提示后仍无响应
+            // 则宽限期后兜底自动拒绝——否则用户离开页面后 run 被永久阻塞、会话 409 锁死。
+            // 无 onTimeout（非交互式 store）保留旧的单层自动拒绝语义。
             const timer = setTimeout(() => {
-                settle(toolCallId, { _tag: 'deny', reason: 'Permission request timed out' });
-                entry.onTimeout?.(entry.request);
+                if (!entry.onTimeout) {
+                    settle(toolCallId, { _tag: 'deny', reason: 'Permission request timed out' });
+                    return;
+                }
+                entry.onTimeout(entry.request);
+                // 首层提示后：重新挂宽限定时器（句柄回写 entry，settle 才能清理它）
+                const expireTimer = setTimeout(() => {
+                    const cur = pending.get(toolCallId);
+                    if (!cur)
+                        return;
+                    pending.set(toolCallId, { ...cur, timer: expireTimer });
+                    cur.onExpired?.(cur.request);
+                    settle(toolCallId, { _tag: 'deny', reason: 'Permission request expired' });
+                }, expireGraceMs);
+                const cur = pending.get(toolCallId);
+                if (cur)
+                    pending.set(toolCallId, { ...cur, timer: expireTimer });
             }, timeoutMs);
             pending.set(toolCallId, { ...entry, timer });
         },
@@ -43,6 +64,21 @@ function createPermissionStore(opts = {}) {
         size() {
             return pending.size;
         },
+        pendingForSession(sessionId) {
+            for (const p of pending.values()) {
+                if (p.request.sessionId === sessionId)
+                    return p.request;
+            }
+            return null;
+        },
+        countForSessions(sessionIds) {
+            let n = 0;
+            for (const p of pending.values()) {
+                if (p.request.sessionId && sessionIds.has(p.request.sessionId))
+                    n += 1;
+            }
+            return n;
+        },
         dispose() {
             // dev 热重载重建前调用：所有 pending settle 为 deny（避免悬空 Promise +
             // timer 泄漏），clearTimeout 后清空 Map。
@@ -54,4 +90,4 @@ function createPermissionStore(opts = {}) {
         },
     };
 }
-export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };
+export { createPermissionStore, DEFAULT_PERMISSION_EXPIRE_GRACE_MS, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/registry-config.d.ts

@@ -0,0 +1,14 @@
+import { type Registry } from '../llm/registry.js';
+import type { Config } from '../shared/types/config.js';
+import type { ProviderConfig } from '../shared/types/llm.js';
+/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
+declare function buildRegistryFromConfig(config: Config): Registry;
+declare function registerProviderFromConfig(registry: Registry, p: ProviderConfig): void;
+/**
+ * config 变更后原子地同步 registry：在隔离的 next registry 上重建全部路由，
+ * 完成后一次性替换 registry 内部 table 引用。运行中的 resolveRoute 任何时刻
+ * 看到的都是完整的旧表或完整的新表，不会读到「已清空但未注册完」的半状态，
+ * 因此不会把本可用的 provider 误判为 NoRoute。ServerContext 立即生效，无需重启。
+ */
+declare function syncRegistryFromConfig(registry: Registry, config: Config): void;
+export { buildRegistryFromConfig, registerProviderFromConfig, syncRegistryFromConfig };

package/dist/server/registry-config.js

@@ -0,0 +1,44 @@
+// src/server/registry-config.ts
+// config.providers ↔ LLM registry 的构建/同步逻辑（P1-1 从 server.ts 拆出，
+// 供 chat 路由按项目配置构建注册表，避免 routes → server.ts 循环依赖）。
+import { decryptSecret } from '../core/secret.js';
+import { createRegistry, overrideToCapabilities, rebuildRegistry, registerProvider, } from '../llm/registry.js';
+/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
+function buildRegistryFromConfig(config) {
+    const registry = createRegistry();
+    for (const p of config.providers) {
+        registerProviderFromConfig(registry, p);
+    }
+    return registry;
+}
+function registerProviderFromConfig(registry, p) {
+    // 兼容 config.json 中以 _tag 标识 provider 的格式（name 缺失时回退到 _tag）
+    const name = p.name || p._tag;
+    if (!name || !p.baseURL)
+        return;
+    // baseURL 已含 /v1 时用 /chat/completions，避免 /v1/v1 双重前缀
+    const path = p.baseURL.replace(/\/+$/, '').endsWith('/v1') ? '/chat/completions' : undefined;
+    registerProvider(registry, {
+        name,
+        baseURL: p.baseURL,
+        apiKey: p.apiKey ? decryptSecret(p.apiKey) : p.apiKey,
+        ...(path ? { path } : {}),
+        // 传递用户配置的 per-model capabilities（contextWindow 等），
+        // 否则 resolveRoute 回退到 DEFAULT_MODEL_CAPABILITIES，可能导致预算过小。
+        ...(p.models ? { models: overrideToCapabilities(p.models) } : {}),
+    });
+}
+/**
+ * config 变更后原子地同步 registry：在隔离的 next registry 上重建全部路由，
+ * 完成后一次性替换 registry 内部 table 引用。运行中的 resolveRoute 任何时刻
+ * 看到的都是完整的旧表或完整的新表，不会读到「已清空但未注册完」的半状态，
+ * 因此不会把本可用的 provider 误判为 NoRoute。ServerContext 立即生效，无需重启。
+ */
+function syncRegistryFromConfig(registry, config) {
+    rebuildRegistry(registry, (next) => {
+        for (const p of config.providers) {
+            registerProviderFromConfig(next, p);
+        }
+    });
+}
+export { buildRegistryFromConfig, registerProviderFromConfig, syncRegistryFromConfig };