c0de-agent 1.11.0 → 1.12.0

package/dist/llm/retry.d.ts

@@ -4,9 +4,10 @@ declare const RETRY_MAX_DELAY_NO_HEADERS = 30000;
 declare const RETRY_MAX_DELAY = 2147483647;
 /**
  * Compute the delay before the next retry attempt (ms).
- * Honors retry-after / retry-after-ms headers when present, else exponential backoff.
+ * Honors retry-after / retry-after-ms headers when present, else exponential backoff
+ * from the given base delay (defaults to RETRY_INITIAL_DELAY).
  */
-declare const delay: (attempt: number, error?: unknown) => number;
+declare const delay: (attempt: number, error?: unknown, initialDelayMs?: number) => number;
 /** A normalized, retryable error descriptor for the session layer. */
 type Retryable = {
     message: string;
@@ -29,6 +30,8 @@ type RetryOptions = {
         delayMs: number;
         error: unknown;
     }) => void;
+    /** Base delay for exponential backoff (default RETRY_INITIAL_DELAY). */
+    initialDelayMs?: number;
 };
 /**
  * Run an async operation with retry. Retries only on retryable LLM errors.

package/dist/llm/retry.js

@@ -17,9 +17,10 @@ const errorHeaders = (error) => {
 const capDelay = (ms) => Math.min(ms, RETRY_MAX_DELAY);
 /**
  * Compute the delay before the next retry attempt (ms).
- * Honors retry-after / retry-after-ms headers when present, else exponential backoff.
+ * Honors retry-after / retry-after-ms headers when present, else exponential backoff
+ * from the given base delay (defaults to RETRY_INITIAL_DELAY).
  */
-const delay = (attempt, error) => {
+const delay = (attempt, error, initialDelayMs = RETRY_INITIAL_DELAY) => {
     const headers = errorHeaders(error);
     if (headers) {
         const retryAfterMs = headers['retry-after-ms'];
@@ -37,9 +38,9 @@ const delay = (attempt, error) => {
             if (!Number.isNaN(parsed) && parsed > 0)
                 return capDelay(Math.ceil(parsed));
         }
-        return capDelay(RETRY_INITIAL_DELAY * RETRY_BACKOFF_FACTOR ** (attempt - 1));
+        return capDelay(initialDelayMs * RETRY_BACKOFF_FACTOR ** (attempt - 1));
     }
-    return capDelay(Math.min(RETRY_INITIAL_DELAY * RETRY_BACKOFF_FACTOR ** (attempt - 1), RETRY_MAX_DELAY_NO_HEADERS));
+    return capDelay(Math.min(initialDelayMs * RETRY_BACKOFF_FACTOR ** (attempt - 1), RETRY_MAX_DELAY_NO_HEADERS));
 };
 /**
  * Decide whether a thrown error is retryable. Returns undefined when not retryable
@@ -74,7 +75,7 @@ const withRetry = async (fn, options) => {
             const fallbackReason = isLLMError(error)
                 ? error.reason
                 : { _tag: 'InvalidRequest', message: '' };
-            const delayMs = Math.min(reasonRetryAfterMs(fallbackReason) ?? delay(attempt, error), canRetry.policy.maxDelay);
+            const delayMs = Math.min(reasonRetryAfterMs(fallbackReason) ?? delay(attempt, error, options.initialDelayMs), canRetry.policy.maxDelay);
             options.onRetry?.({ attempt, delayMs, error });
             await sleep(delayMs);
         }

package/dist/llm/routing.d.ts

@@ -32,5 +32,28 @@ declare const runWithFallback: <T>(registry: Registry, chain: FallbackChain, run
  * errors propagate without trying fallbacks.
  */
 declare const shouldFallOver: (error: unknown) => boolean;
+/** 回退目标所需的最小 provider 信息。 */
+type FallbackSourceProvider = {
+    name?: string;
+    _tag?: string;
+    /** 声明了模型清单的 provider 只对清单内的模型回退；未声明视为不支持（保守）。 */
+    models?: Record<string, unknown>;
+};
+/**
+ * 从 config.fallback 构建回退链（主 chat 循环/压缩/标题等 LLM 调用的接线点）。
+ * - enabled=false → undefined（保持内置默认：3 次重试、无跨 provider 回退）。
+ * - enabled=true → 按配置 maxRetries/retryDelay 重试，并对「声明了同一模型」的
+ *   其他 provider 依次回退。无合格回退目标时 fallbacks 为空——重试参数仍然生效。
+ * 回退只接受声明了该模型的 provider：对未声明的 provider 盲目回退会在其 API 处
+ * 得到 InvalidRequest 并中断整条链（shouldFallOver 不放过非回退错误）。
+ */
+declare function buildFallbackChain(config: {
+    providers: FallbackSourceProvider[];
+    fallback: {
+        enabled: boolean;
+        maxRetries: number;
+        retryDelay: number;
+    };
+}, provider: string, model: string): FallbackChain | undefined;
 export type { FallbackChain };
-export { runWithFallback, shouldFallOver };
+export { buildFallbackChain, runWithFallback, shouldFallOver };

package/dist/llm/routing.js

@@ -20,6 +20,7 @@ const runWithFallback = async (registry, chain, run) => {
             const result = await withRetry(() => run(target.provider, target.model), {
                 maxRetries: chain.maxRetries,
                 sleep: chain.sleep,
+                initialDelayMs: chain.retryDelay,
             });
             return { result, provider: target.provider, model: target.model };
         }
@@ -50,4 +51,31 @@ const shouldFallOver = (error) => {
         return true;
     return false;
 };
-export { runWithFallback, shouldFallOver };
+/**
+ * 从 config.fallback 构建回退链（主 chat 循环/压缩/标题等 LLM 调用的接线点）。
+ * - enabled=false → undefined（保持内置默认：3 次重试、无跨 provider 回退）。
+ * - enabled=true → 按配置 maxRetries/retryDelay 重试，并对「声明了同一模型」的
+ *   其他 provider 依次回退。无合格回退目标时 fallbacks 为空——重试参数仍然生效。
+ * 回退只接受声明了该模型的 provider：对未声明的 provider 盲目回退会在其 API 处
+ * 得到 InvalidRequest 并中断整条链（shouldFallOver 不放过非回退错误）。
+ */
+function buildFallbackChain(config, provider, model) {
+    const fb = config.fallback;
+    if (!fb.enabled)
+        return undefined;
+    const fallbacks = config.providers
+        .filter((p) => {
+        const name = p.name || p._tag;
+        if (!name || name === provider)
+            return false;
+        return p.models !== undefined && model in p.models;
+    })
+        .map((p) => ({ provider: (p.name || p._tag), model }));
+    return {
+        primary: { provider, model },
+        fallbacks,
+        maxRetries: fb.maxRetries,
+        retryDelay: fb.retryDelay,
+    };
+}
+export { buildFallbackChain, runWithFallback, shouldFallOver };

package/dist/project/index.d.ts

@@ -1,4 +1,4 @@
 export type { Project } from './project.js';
-export { fromDirectory, getByDirectory, getProject, listProjects, updateProjectName, } from './project.js';
+export { fromDirectory, getByDirectory, getProject, listProjects, relocateProject, updateProjectName, } from './project.js';
 export type { ResolvedProject } from './resolve.js';
 export { resolveProject } from './resolve.js';

package/dist/project/index.js

@@ -1,2 +1,2 @@
-export { fromDirectory, getByDirectory, getProject, listProjects, updateProjectName, } from './project.js';
+export { fromDirectory, getByDirectory, getProject, listProjects, relocateProject, updateProjectName, } from './project.js';
 export { resolveProject } from './resolve.js';

package/dist/project/project.d.ts

@@ -21,3 +21,17 @@ export declare function listProjects(handle: DB): Promise<Project[]>;
 export declare function getProject(handle: DB, id: string): Promise<Project | null>;
 export declare function getByDirectory(handle: DB, directory: string): Promise<Project | null>;
 export declare function updateProjectName(handle: DB, id: string, name: string): Promise<Project | null>;
+/**
+ * 项目重新定位（A1：目录被移动/重命名后的恢复通道）。
+ *
+ * 项目身份 = sha256(worktree)，目录移动后旧项目记录的 worktree 失效且不可改 id。
+ * 此前唯一恢复路径是「删除项目」：会话打散进孤儿回收站逐条恢复，看板永久丢失。
+ * 本函数在单事务内把项目整体迁移到新目录身份（新 id），保住看板与会话归属：
+ *   1. 以新目录解析出的 id upsert 项目行（沿用旧名称）；
+ *   2. 会话 projectId/worktreePath 迁移到新身份；
+ *   3. 看板 projectId 迁移（目标为新身份，唯一约束无冲突）；
+ *   4. 删除旧项目行。
+ * 同一 id（如 git 仓库根未变、仅路径符号变化）→ 仅更新 worktree，不换身份。
+ * 目标目录已注册为另一项目时抛 TARGET_OCCUPIED（调用方转 409），绝不静默合并。
+ */
+export declare function relocateProject(handle: DB, id: string, directory: string): Promise<Project>;

package/dist/project/project.js

@@ -1,6 +1,6 @@
 import { basename } from 'node:path';
 import { eq } from 'drizzle-orm';
-import { projects, sessions } from '../db/schema.js';
+import { kanbanBoards, projects, sessions } from '../db/schema.js';
 import { resolveProject } from './resolve.js';
 function rowToProject(row) {
     return {
@@ -85,3 +85,79 @@ export async function updateProjectName(handle, id, name) {
         .returning();
     return row ? rowToProject(row) : null;
 }
+/**
+ * 项目重新定位（A1：目录被移动/重命名后的恢复通道）。
+ *
+ * 项目身份 = sha256(worktree)，目录移动后旧项目记录的 worktree 失效且不可改 id。
+ * 此前唯一恢复路径是「删除项目」：会话打散进孤儿回收站逐条恢复，看板永久丢失。
+ * 本函数在单事务内把项目整体迁移到新目录身份（新 id），保住看板与会话归属：
+ *   1. 以新目录解析出的 id upsert 项目行（沿用旧名称）；
+ *   2. 会话 projectId/worktreePath 迁移到新身份；
+ *   3. 看板 projectId 迁移（目标为新身份，唯一约束无冲突）；
+ *   4. 删除旧项目行。
+ * 同一 id（如 git 仓库根未变、仅路径符号变化）→ 仅更新 worktree，不换身份。
+ * 目标目录已注册为另一项目时抛 TARGET_OCCUPIED（调用方转 409），绝不静默合并。
+ */
+export async function relocateProject(handle, id, directory) {
+    const current = await getProject(handle, id);
+    if (!current)
+        throw new Error('PROJECT_NOT_FOUND');
+    const resolved = resolveProject(directory);
+    if (resolved.id === id) {
+        // 身份不变：仅刷新 worktree 与 git 元数据；会话 worktreePath 同步。
+        await handle.db.transaction(async (tx) => {
+            await tx
+                .update(projects)
+                .set({
+                worktree: resolved.worktree,
+                vcs: resolved.vcs,
+                gitRemote: resolved.gitRemote,
+                updatedAt: new Date(),
+            })
+                .where(eq(projects.id, id));
+            await tx
+                .update(sessions)
+                .set({ worktreePath: resolved.worktree })
+                .where(eq(sessions.projectId, id));
+        });
+    }
+    else {
+        const occupied = await getProject(handle, resolved.id);
+        if (occupied) {
+            throw new Error(`TARGET_OCCUPIED: 目标目录已注册为项目「${occupied.name ?? '未命名项目'}」`);
+        }
+        await handle.db.transaction(async (tx) => {
+            await tx
+                .insert(projects)
+                .values({
+                id: resolved.id,
+                worktree: resolved.worktree,
+                vcs: resolved.vcs,
+                name: current.name ?? basename(resolved.worktree),
+                gitRemote: resolved.gitRemote,
+            })
+                .onConflictDoUpdate({
+                target: projects.id,
+                set: {
+                    worktree: resolved.worktree,
+                    vcs: resolved.vcs,
+                    gitRemote: resolved.gitRemote,
+                    updatedAt: new Date(),
+                },
+            });
+            await tx
+                .update(sessions)
+                .set({ projectId: resolved.id, worktreePath: resolved.worktree })
+                .where(eq(sessions.projectId, id));
+            await tx
+                .update(kanbanBoards)
+                .set({ projectId: resolved.id })
+                .where(eq(kanbanBoards.projectId, id));
+            await tx.delete(projects).where(eq(projects.id, id));
+        });
+    }
+    const result = await getProject(handle, resolved.id);
+    if (!result)
+        throw new Error(`Relocate failed for ${directory}`);
+    return result;
+}

package/dist/server/agent-manager.d.ts

@@ -36,16 +36,25 @@ type AgentManager = {
     abort(sessionId: string): boolean;
     pause(sessionId: string): boolean;
     resume(sessionId: string): boolean;
-    /** 暂停全部活跃 run 并等待到达安全点；超时强制中止（热更新前调用）。 */
+    /** 暂停全部活跃 run 并等待到达安全点；超时强制中止（热更新前调用）。
+     *  返回 pausedIds：成功暂停的会话 id 列表——调用方在后续步骤（spawn 等）
+     *  失败时必须对其逐个 resume 回滚，避免更新失败连带冻结用户对话。 */
     pauseAll(timeoutMs?: number): Promise<{
         paused: number;
         forcedAbort: number;
+        pausedIds: string[];
     }>;
     steer(sessionId: string, message: string): boolean;
     /** 查询某 session 的所有子 agent run（恢复/展示用）。 */
     children(parentSessionId: string): ActiveRun[];
     /** 查询所有后台任务（jobId 非空的 run）。 */
     backgroundJobs(): ActiveRun[];
+    /** 列出全部活跃 run（含子 agent）——热更新影响面展示用。 */
+    listActive(): Array<{
+        sessionId: string;
+        agentType?: string;
+        parentSessionId?: string;
+    }>;
     /** 中止所有活跃 run 并清空（dev 热重载重建前调用）。 */
     dispose(): void;
 };

package/dist/server/agent-manager.js

@@ -80,7 +80,10 @@ function createAgentManager() {
                     forcedAbort += 1;
                 }
             }
-            return { paused: active.length - forcedAbort, forcedAbort };
+            const pausedIds = active
+                .filter((r) => r.state.status._tag === 'paused')
+                .map((r) => r.sessionId);
+            return { paused: active.length - forcedAbort, forcedAbort, pausedIds };
         },
         steer(sessionId, message) {
             const run = slotRun(runs.get(sessionId));
@@ -99,6 +102,16 @@ function createAgentManager() {
                 .map((slot) => slotRun(slot))
                 .filter((r) => r?.jobId !== undefined);
         },
+        listActive() {
+            return Array.from(runs.values())
+                .map((slot) => slotRun(slot))
+                .filter((r) => r !== undefined)
+                .map((r) => ({
+                sessionId: r.sessionId,
+                agentType: r.agentType,
+                parentSessionId: r.parentSessionId,
+            }));
+        },
         dispose() {
             // dev 热重载重建前调用：中止所有活跃 run（loop 在 turn/流边界检测 signal
             // → unwind → 调用方 finally 持久化 + unregister），然后清空 Map。

package/dist/server/auth-manager.d.ts

@@ -10,6 +10,8 @@ type PendingPairing = {
     code: string;
     createdAt: number;
     status: 'pending' | 'approved' | 'denied';
+    /** 请求来源（尽力而为：x-forwarded-for 首跳，本地回环时为 local）。仅展示 + 软限流，不作身份断言。 */
+    source: string;
     deviceToken?: string;
 };
 type AuthManagerOptions = {
@@ -20,8 +22,9 @@ type AuthManagerOptions = {
     tokenFilePath?: string;
     /** 配对码有效期（ms），默认 10 分钟。 */
     pairingTtlMs?: number;
-    /** 轮换后仍接受为 handoff 凭据的旧 bootstrap 数量，默认 3。 */
-    handoffTokenRetention?: number;
+    /** 首设备 bootstrap TTL（ms）：>0 时，bootstrap 超过此时长即拒绝首设备注册
+     *  （需重启 serve 重新生成）。0=不限制。用于缩短「URL 泄漏后被抢先注册」的窗口。 */
+    firstDeviceTtlMs?: number;
     now?: () => number;
 };
 export type AuthManager = {
@@ -29,14 +32,16 @@ export type AuthManager = {
     readonly bootstrap: string | undefined;
     /** API/WS 请求校验：仅设备 token 有效（静态模式下 staticToken 有效）。 */
     verify(token: string | undefined): boolean;
-    /** handoff 端点校验：设备 token + 当前/历史 bootstrap。 */
+    /** handoff 端点校验：设备 token + 当前 bootstrap（历史 bootstrap 不接受，
+     *  否则已泄漏的旧 URL token 仍可借 handoff 强杀本地服务）。 */
     verifyHandoff(token: string | undefined): boolean;
     /** 首次设备注册：校验 bootstrap 后换发设备 token 并轮换 bootstrap。
      *  无设备时首个凭 bootstrap 的请求即视为首设备（免审批），后续请求需配对审批。
      *  返回新设备 token；bootstrap 已失效/已注册过 → 返回 null。 */
     registerFirstDevice(bootstrapToken: string, deviceName: string): Promise<string | null>;
-    /** 发起配对请求（未认证）：返回 { pairingId, code }；静态模式/未启用返回 null。 */
-    requestPairing(deviceName: string): {
+    /** 发起配对请求（未认证）：返回 { pairingId, code }；静态模式/未启用返回 null。
+     *  source 为请求来源（IP 等，尽力而为），用于审批展示与按来源限流。 */
+    requestPairing(deviceName: string, source?: string): {
         pairingId: string;
         code: string;
     } | null;
@@ -57,6 +62,7 @@ export type AuthManager = {
         deviceName: string;
         code: string;
         createdAt: number;
+        source: string;
     }>;
     /** 审批配对（需已认证设备调用）：通过后为请求设备签发 token。 */
     approvePairing(pairingId: string): boolean;

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,6 +119,17 @@ 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) {
@@ -150,10 +156,6 @@ 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) {
@@ -164,6 +166,12 @@ export function createAuthManager(opts) {
             // 已有设备 → bootstrap 已失效，不得再凭它注册（需配对审批）
             if (devices.size > 0)
                 return null;
+            // 首设备注册窗口：bootstrap 超过 firstDeviceTtlMs 后拒绝（缩短先到先得竞态窗口）。
+            if (firstDeviceTtlMs > 0) {
+                const age = bootstrapAge();
+                if (age != null && age > firstDeviceTtlMs)
+                    return null;
+            }
             const deviceToken = randomBytes(32).toString('hex');
             const record = {
                 id: randomBytes(16).toString('hex'),
@@ -176,14 +184,19 @@ export function createAuthManager(opts) {
             rotateBootstrap(); // 注册成功即轮换，旧 bootstrap（URL/shell history 中）立即失效
             return 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 +205,7 @@ export function createAuthManager(opts) {
                 code,
                 createdAt: now(),
                 status: 'pending',
+                source: src,
             });
             return { pairingId, code };
         },
@@ -218,11 +232,14 @@ export function createAuthManager(opts) {
                 deviceName: p.deviceName,
                 code: p.code,
                 createdAt: p.createdAt,
+                source: p.source,
             }));
         },
         approvePairing(pairingId) {
             const p = pending.get(pairingId);
-            if (!p || p.status !== 'pending')
+            if (!p)
+                return false;
+            if (p.status !== 'pending')
                 return false;
             if (p.createdAt <= now() - pairingTtlMs) {
                 pending.delete(pairingId);
@@ -243,7 +260,9 @@ export function createAuthManager(opts) {
         },
         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

@@ -36,6 +36,9 @@ function createServerContext(opts) {
         permissionStore: createPermissionStore(),
         permissionMode: config.permission.defaultMode,
         sessionPermissionModes: new Map(),
+        sessionAlwaysAllow: new Map(),
+        // P1-1：项目级 LLM 注册表缓存（按项目合并配置构建，chat 路由按需创建）。
+        projectRegistries: new Map(),
         // 测试工厂不解析/生成 token（不触碰用户全局数据目录）。
         authToken: undefined,
         agentRegistry,

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

@@ -3,16 +3,19 @@ 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;
 };
 /** 阻塞式权限检查器：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,23 @@ function createInteractivePermissionChecker(store, opts = {}) {
             }
             // 交互式确认
             const toolCallId = randomUUID();
-            const request = { toolCallId, tool: tool.name, input };
+            const request = {
+                toolCallId,
+                tool: tool.name,
+                input,
+                // P1：绑定会话 id——挂起期间用户切换页面后，前端经
+                // GET /api/permissions/:sessionId/pending 重挂确认弹窗。
+                ...(ctx.session?.id ? { sessionId: ctx.session.id } : {}),
+            };
             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,11 @@ type PermissionStore = {
     resolve(toolCallId: string, approved: boolean): boolean;
     has(toolCallId: string): boolean;
     size(): number;
+    /** 查询某会话当前挂起的权限请求（P1：前端重挂弹窗；无则 null）。 */
+    pendingForSession(sessionId: string): PermissionRequest | null;
     /** 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 };