c0de-agent 1.10.0 → 1.11.0

package/dist/server/auth-manager.js

@@ -0,0 +1,270 @@
+// src/server/auth-manager.ts
+// P2-16：认证 token 轮换 + 新设备配对审批。
+//
+// 安全模型（基于用户决策：URL token / shell history 不可视为安全）：
+//   - bootstrap token（auth-token 文件 / security.token / C0DE_AUTH_TOKEN）只用于
+//     「首次设备注册」：首个设备凭 bootstrap 换发设备 token 后，bootstrap 立即轮换失效。
+//   - 所有 API/WS 请求只认设备 token（sha256 哈希存储）。
+//   - 新设备无有效 token 时走配对流程：请求配对码 → 已授权设备审批 → 下发设备 token。
+//   - 显式配置 security.token 时为静态模式：不轮换、不配对（CI/脚本场景）。
+//   - authEnabled=false 时不启用。
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+const DEVICES_FILENAME = 'devices.json';
+function hashToken(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+function safeEqual(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ba.length !== bb.length)
+        return false;
+    return timingSafeEqual(ba, bb);
+}
+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 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 {
+            if (!existsSync(path))
+                return undefined;
+            const t = readFileSync(path, 'utf-8').trim();
+            return t.length > 0 ? t : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function loadDevices() {
+        devices.clear();
+        try {
+            if (!existsSync(devicesPath))
+                return;
+            const raw = JSON.parse(readFileSync(devicesPath, 'utf-8'));
+            for (const d of raw.devices ?? []) {
+                if (d && typeof d.id === 'string' && typeof d.tokenHash === 'string') {
+                    devices.set(d.id, d);
+                }
+            }
+        }
+        catch {
+            // 注册表损坏：视为空（设备需重新配对/注册）
+        }
+    }
+    // 热重载：CLI `c0de auth revoke/reset` 或手工编辑 devices.json 后立即生效。
+    // 监听目录而非文件——文件可能尚不存在（首启），persist/revoke 会创建它。
+    // 自身 persist 写入也会触发一次无伤重载。
+    let watcher;
+    try {
+        watcher = watch(dirname(devicesPath), (_event, filename) => {
+            if (filename === basename(devicesPath))
+                loadDevices();
+        });
+        // 不让 watcher 独占事件循环（测试/短生命周期进程可正常退出）
+        watcher.unref();
+    }
+    catch {
+        // 目录不可 watch（极端环境）：降级为仅启动时加载
+    }
+    function persist() {
+        try {
+            if (!existsSync(dataDir))
+                mkdirSync(dataDir, { recursive: true });
+            const file = {
+                version: 1,
+                devices: Array.from(devices.values()),
+            };
+            writeFileSync(devicesPath, JSON.stringify(file, null, 2), 'utf-8');
+        }
+        catch {
+            // 持久化失败不致命（内存态继续有效，重启后需重新注册）
+        }
+    }
+    /** 轮换 bootstrap：写入新 token 文件并保留历史（handoff 用）。 */
+    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;
+        try {
+            if (!existsSync(dataDir))
+                mkdirSync(dataDir, { recursive: true });
+            writeFileSync(tokenPath, next, 'utf-8');
+        }
+        catch {
+            // 写文件失败：内存 token 仍已轮换，进程内一致
+        }
+    }
+    function verifyDeviceToken(token) {
+        const h = hashToken(token);
+        for (const d of devices.values()) {
+            if (safeEqual(d.tokenHash, h))
+                return true;
+        }
+        return false;
+    }
+    function verifyBootstrap(token) {
+        if (!token || !bootstrap)
+            return false;
+        return safeEqual(token, bootstrap);
+    }
+    function cleanExpiredPairings() {
+        const cutoff = now() - pairingTtlMs;
+        for (const [id, p] of pending) {
+            if (p.status === 'pending' && p.createdAt <= cutoff) {
+                pending.delete(id);
+            }
+        }
+    }
+    return {
+        get bootstrap() {
+            return bootstrap;
+        },
+        verify(token) {
+            if (!token)
+                return false;
+            if (staticToken && staticToken.length > 0)
+                return safeEqual(token, staticToken);
+            return verifyDeviceToken(token);
+        },
+        verifyHandoff(token) {
+            if (!token)
+                return false;
+            if (verifyDeviceToken(token))
+                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 已失效，不得再凭它注册（需配对审批）
+            if (devices.size > 0)
+                return null;
+            const deviceToken = randomBytes(32).toString('hex');
+            const record = {
+                id: randomBytes(16).toString('hex'),
+                name: deviceName || '设备',
+                tokenHash: hashToken(deviceToken),
+                createdAt: now(),
+            };
+            devices.set(record.id, record);
+            persist();
+            rotateBootstrap(); // 注册成功即轮换，旧 bootstrap（URL/shell history 中）立即失效
+            return deviceToken;
+        },
+        requestPairing(deviceName) {
+            if (staticToken && staticToken.length > 0)
+                return null;
+            cleanExpiredPairings();
+            // 限流：最多 10 个待审批
+            const pendingCount = Array.from(pending.values()).filter((p) => p.status === 'pending').length;
+            if (pendingCount >= 10)
+                return null;
+            const pairingId = randomBytes(16).toString('hex');
+            const code = String(100000 + Math.floor(Math.random() * 900000)); // 6 位数字
+            pending.set(pairingId, {
+                pairingId,
+                deviceName: deviceName || '新设备',
+                code,
+                createdAt: now(),
+                status: 'pending',
+            });
+            return { pairingId, code };
+        },
+        pairingStatus(pairingId) {
+            const p = pending.get(pairingId);
+            if (!p)
+                return { status: 'not_found' };
+            if (p.status === 'approved')
+                return { status: 'approved', deviceToken: p.deviceToken ?? '' };
+            if (p.status === 'denied')
+                return { status: 'denied' };
+            if (p.createdAt <= now() - pairingTtlMs) {
+                pending.delete(pairingId);
+                return { status: 'not_found' };
+            }
+            return { status: 'pending' };
+        },
+        listPairings() {
+            cleanExpiredPairings();
+            return Array.from(pending.values())
+                .filter((p) => p.status === 'pending')
+                .map((p) => ({
+                pairingId: p.pairingId,
+                deviceName: p.deviceName,
+                code: p.code,
+                createdAt: p.createdAt,
+            }));
+        },
+        approvePairing(pairingId) {
+            const p = pending.get(pairingId);
+            if (!p || p.status !== 'pending')
+                return false;
+            if (p.createdAt <= now() - pairingTtlMs) {
+                pending.delete(pairingId);
+                return false;
+            }
+            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;
+        },
+        denyPairing(pairingId) {
+            const p = pending.get(pairingId);
+            if (!p || p.status !== 'pending')
+                return false;
+            p.status = 'denied';
+            return true;
+        },
+        listDevices() {
+            return Array.from(devices.values()).map((d) => ({
+                id: d.id,
+                name: d.name,
+                createdAt: d.createdAt,
+            }));
+        },
+        revokeDevice(id) {
+            const ok = devices.delete(id);
+            if (ok)
+                persist();
+            return ok;
+        },
+        dispose() {
+            watcher?.close();
+            watcher = undefined;
+        },
+        persist,
+    };
+}

package/dist/server/context.js

@@ -35,6 +35,7 @@ function createServerContext(opts) {
         agentManager: createAgentManager(),
         permissionStore: createPermissionStore(),
         permissionMode: config.permission.defaultMode,
+        sessionPermissionModes: new Map(),
         // 测试工厂不解析/生成 token（不触碰用户全局数据目录）。
         authToken: undefined,
         agentRegistry,

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

@@ -2,14 +2,15 @@ import type { MiddlewareHandler } from 'hono';
 export type AuthOptions = {
     /** 不需认证的路径（默认放行 /api/health 探活）。 */
     publicPaths?: string[];
+    /** P2-16：自定义校验函数（authManager.verify）。提供时忽略 token 字符串比较。 */
+    verify?: (token: string | undefined) => boolean;
 };
 /**
  * Bearer token 认证中间件（spec §24.2「认证」）。
  *
  * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
- * - publicPaths 中的路径始终放行（如健康检查）。
- *
- * 生产或远程访问场景应在 config.security.token 配置随机 token。
+ * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
+ * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。
  */
 export declare function createAuthMiddleware(token: string | undefined, opts?: AuthOptions): MiddlewareHandler;

package/dist/server/middleware/auth.js

@@ -4,15 +4,14 @@ import { apiError } from './error.js';
  *
  * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
- * - publicPaths 中的路径始终放行（如健康检查）。
- *
- * 生产或远程访问场景应在 config.security.token 配置随机 token。
+ * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
+ * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。
  */
 export function createAuthMiddleware(token, opts = {}) {
     const expected = token && token.length > 0 ? `Bearer ${token}` : '';
     const publicPaths = new Set(opts.publicPaths ?? ['/api/health']);
     return async (c, next) => {
-        if (!expected) {
+        if (!expected && !opts.verify) {
             await next();
             return;
         }
@@ -21,7 +20,8 @@ export function createAuthMiddleware(token, opts = {}) {
             return;
         }
         const auth = c.req.header('Authorization') ?? '';
-        if (auth !== expected) {
+        const ok = opts.verify ? opts.verify(auth.replace(/^Bearer\s+/i, '')) : auth === expected;
+        if (!ok) {
             return apiError(c, 401, 'UNAUTHORIZED', 'Missing or invalid bearer token');
         }
         await next();

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

@@ -11,6 +11,8 @@ type InteractivePermissionCheckerOptions = {
     getMode?: () => PermissionMode;
     /** 遇到 ask 权限时调用（用于通知前端）。 */
     onPermissionRequired?: (request: PermissionRequest) => void | Promise<void>;
+    /** 权限确认超时被自动拒绝时调用（P1-6：SSE 通知前端）。 */
+    onPermissionTimeout?: (request: PermissionRequest) => void;
 };
 /** 阻塞式权限检查器：ask 权限会阻塞等待用户确认。
  *  pending 存在全局 PermissionStore 中，独立于 agent run 生命周期。 */

package/dist/server/permission/interactive.js

@@ -26,7 +26,11 @@ function createInteractivePermissionChecker(store, opts = {}) {
                 // pending 注册到全局 store，confirm 端点按 toolCallId 直接寻址，
                 // 不依赖当前 agent run 是否仍在 agentManager 中注册。
                 // store 内置超时：到期自动 deny 并清理条目（防永久挂起 + Map 泄漏）。
-                store.register(toolCallId, { request, resolve });
+                store.register(toolCallId, {
+                    request,
+                    resolve,
+                    ...(opts.onPermissionTimeout ? { onTimeout: opts.onPermissionTimeout } : {}),
+                });
             });
             await opts.onPermissionRequired?.(request);
             // agent abort 联动：abort 时主动 deny 并清理 store 条目，

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

@@ -12,11 +12,15 @@ type PermissionRequest = {
 type PendingPermission = {
     request: PermissionRequest;
     resolve: (result: PermissionResult) => void;
+    /** 该请求超时自动拒绝时的回调（P1-6：按请求绑定 SSE 流）。 */
+    onTimeout?: (request: PermissionRequest) => void;
 };
 /** createPermissionStore 的配置。 */
 type PermissionStoreOptions = {
     /** pending 超时毫秒数；省略时取 DEFAULT_PERMISSION_TIMEOUT_MS（5 分钟）。 */
     timeoutMs?: number;
+    /** 超时自动拒绝时回调（P1-6：通知前端「确认超时已拒绝」，提供重新询问入口）。 */
+    onTimeout?: (request: PermissionRequest) => void;
 };
 /** 全局权限确认 store：注册/解析 pending permission。 */
 type PermissionStore = {

package/dist/server/permission/store.js

@@ -30,6 +30,7 @@ function createPermissionStore(opts = {}) {
                 clearTimeout(existing.timer);
             const timer = setTimeout(() => {
                 settle(toolCallId, { _tag: 'deny', reason: 'Permission request timed out' });
+                entry.onTimeout?.(entry.request);
             }, timeoutMs);
             pending.set(toolCallId, { ...entry, timer });
         },

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

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+declare function createAuthRoute(ctx: ServerContext): Hono;
+export { createAuthRoute };

package/dist/server/routes/auth.js

@@ -0,0 +1,94 @@
+// src/server/routes/auth.ts
+// P2-16：认证引导 + 设备配对审批端点。
+//
+// 公开端点（未认证，中间件 publicPaths 放行）：
+//   POST /api/auth/register          首设备注册：凭 bootstrap token 换发设备 token
+//   POST /api/auth/pairing/request   新设备发起配对：返回 pairingId + 6 位配对码
+//   GET  /api/auth/pairing/status?pairingId=xxx  新设备轮询审批结果
+//
+// 需认证端点（已授权设备调用）：
+//   GET  /api/auth/pairing           列出待审批配对
+//   POST /api/auth/pairing/approve   审批通过（签发设备 token）
+//   POST /api/auth/pairing/deny      拒绝配对
+import { Hono } from 'hono';
+import { apiError } from '../middleware/error.js';
+function createAuthRoute(ctx) {
+    const app = new Hono();
+    // 首设备注册：凭 bootstrap token（URL ?token=）换发设备 token，bootstrap 随即轮换失效。
+    app.post('/register', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.token) {
+            return apiError(c, 400, 'BAD_REQUEST', 'token is required');
+        }
+        const deviceToken = await ctx.authManager.registerFirstDevice(body.token, body.deviceName ?? '设备');
+        if (!deviceToken) {
+            // bootstrap 已失效/已注册过设备 → 引导走配对审批
+            return apiError(c, 403, 'BOOTSTRAP_CONSUMED', 'bootstrap token 已失效（已有设备注册）。请在新设备发起配对，由已授权设备审批。');
+        }
+        return c.json({ deviceToken });
+    });
+    // 新设备发起配对请求（公开）。
+    app.post('/pairing/request', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        const result = ctx.authManager.requestPairing(body.deviceName ?? '新设备');
+        if (!result) {
+            return apiError(c, 429, 'PAIRING_LIMIT', '待审批的配对请求过多，请稍后再试');
+        }
+        return c.json(result);
+    });
+    // 新设备轮询配对审批结果（公开）。
+    app.get('/pairing/status', (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const pairingId = c.req.query('pairingId') ?? '';
+        if (!pairingId)
+            return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
+        const status = ctx.authManager.pairingStatus(pairingId);
+        if (status.status === 'not_found') {
+            return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        }
+        return c.json(status);
+    });
+    // 列出待审批配对（需认证）。
+    app.get('/pairing', (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        return c.json({ pairings: ctx.authManager.listPairings() });
+    });
+    // 审批通过（需认证）。
+    app.post('/pairing/approve', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.pairingId)
+            return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
+        const ok = ctx.authManager.approvePairing(body.pairingId);
+        if (!ok)
+            return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        return c.json({ ok: true });
+    });
+    // 拒绝配对（需认证）。
+    app.post('/pairing/deny', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.pairingId)
+            return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
+        const ok = ctx.authManager.denyPairing(body.pairingId);
+        if (!ok)
+            return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        return c.json({ ok: true });
+    });
+    return app;
+}
+export { createAuthRoute };

package/dist/server/routes/chat.d.ts

@@ -1,8 +1,13 @@
 import { Hono } from 'hono';
 import type { ServerContext } from '../types.js';
-/** 按 session.projectId 解析 agent 工作目录；无项目回退 ctx.cwd。 */
+/** 按 session.projectId / worktreePath 解析 agent 工作目录：
+ *  - 有 projectId → 项目 worktree（缺失/目录失效时抛错，由上层转 409）。
+ *  - 无 projectId（项目已删除后从回收站恢复的会话）→ 用 worktreePath 兜底：
+ *    目录失效同样抛错，绝不静默回退 serve cwd 导致 agent 在错误目录执行工具。
+ *  - 两者皆无（从未绑定项目的会话，如 CLI print）→ 回退 ctx.cwd。 */
 export declare function resolveAgentCwd(ctx: ServerContext, session: {
     projectId: string | null;
+    worktreePath?: string | null;
 }): Promise<string>;
 declare function createChatRoute(ctx: ServerContext): Hono;
 export { createChatRoute };

package/dist/server/routes/chat.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
@@ -6,6 +7,7 @@ import { compactContext } from '../../core/loop.js';
 import { createSlashRegistry, parseSlashInput } from '../../core/slash.js';
 import { injectSteering } from '../../core/steering.js';
 import { buildWorkflowNotice, containsWorkflow } from '../../core/workflow.js';
+import { resolveRoute } from '../../llm/registry.js';
 import { getProject } from '../../project/project.js';
 import { getLLMSegments, getSession, updateSessionLastRun } from '../../session/session.js';
 import { upsertFileSnapshot } from '../../session/snapshot.js';
@@ -14,12 +16,28 @@ import { autoAllowChecker } from '../../tools/permission.js';
 import { apiError } from '../middleware/error.js';
 import { createInteractivePermissionChecker } from '../permission/interactive.js';
 import { safeResolve } from '../util/safe-path.js';
-/** 按 session.projectId 解析 agent 工作目录；无项目回退 ctx.cwd。 */
+/** 按 session.projectId / worktreePath 解析 agent 工作目录：
+ *  - 有 projectId → 项目 worktree（缺失/目录失效时抛错，由上层转 409）。
+ *  - 无 projectId（项目已删除后从回收站恢复的会话）→ 用 worktreePath 兜底：
+ *    目录失效同样抛错，绝不静默回退 serve cwd 导致 agent 在错误目录执行工具。
+ *  - 两者皆无（从未绑定项目的会话，如 CLI print）→ 回退 ctx.cwd。 */
 export async function resolveAgentCwd(ctx, session) {
-    if (!session.projectId)
-        return ctx.cwd;
+    if (!session.projectId) {
+        if (!session.worktreePath)
+            return ctx.cwd;
+        if (!existsSync(session.worktreePath)) {
+            throw new Error(`WORKTREE_MISSING: 会话工作目录已失效（${session.worktreePath}）。请检查目录是否被移动或删除`);
+        }
+        return session.worktreePath;
+    }
     const project = await getProject(ctx.db, session.projectId);
-    return project?.worktree ?? ctx.cwd;
+    if (!project) {
+        throw new Error(`PROJECT_MISSING: 会话所属项目已不存在（projectId=${session.projectId}）`);
+    }
+    if (!existsSync(project.worktree)) {
+        throw new Error(`WORKTREE_MISSING: 项目工作目录已失效（${project.worktree}）。请检查目录是否被移动或删除`);
+    }
+    return project.worktree;
 }
 function createChatRoute(ctx) {
     const app = new Hono();
@@ -42,16 +60,48 @@ function createChatRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
         // 提前解析 cwd（slash 拦截与 agent 路径都需使用）
-        const cwd = await resolveAgentCwd(ctx, session);
+        // P1-9：worktree 失效/项目缺失 → 明确 409，不静默回退服务端 cwd。
+        let cwd;
+        try {
+            cwd = await resolveAgentCwd(ctx, session);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.startsWith('PROJECT_MISSING')) {
+                return apiError(c, 409, 'PROJECT_MISSING', msg.replace('PROJECT_MISSING: ', ''));
+            }
+            if (msg.startsWith('WORKTREE_MISSING')) {
+                return apiError(c, 409, 'WORKTREE_MISSING', msg.replace('WORKTREE_MISSING: ', ''));
+            }
+            return apiError(c, 500, 'CWD_RESOLVE_FAILED', msg);
+        }
         // 斜杠命令拦截
         const parsed = parseSlashInput(message);
         if (parsed) {
             const registry = createSlashRegistry();
             const cmd = registry.get(parsed.name);
             if (cmd) {
+                // P2-4：执行 config.slashCommands.enabled 过滤（此前该配置无任何消费方）。
+                // enabled 为空 = 全部启用（与 tools.enabled 语义一致）；名称兼容带/不带前缀斜杠。
+                const enabledList = ctx.config.slashCommands?.enabled ?? [];
+                const enabledSet = new Set(enabledList.map((n) => (n.startsWith('/') ? n.slice(1) : n)));
+                if (enabledSet.size > 0 && !enabledSet.has(parsed.name)) {
+                    return streamSSE(c, async (stream) => {
+                        await stream.writeSSE({
+                            event: 'text_delta',
+                            data: JSON.stringify({
+                                _tag: 'text_delta',
+                                text: `斜杠命令 /${parsed.name} 未启用（config.slashCommands.enabled）`,
+                            }),
+                        });
+                        await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                    });
+                }
                 const commandCtx = {
                     cwd,
                     config: ctx.config,
+                    // 当前会话 id：/clear /fork 等命令默认作用于当前会话（P2-4）。
+                    sessionId,
                     // 内置斜杠命令（/clear、/fork、/config）仅需 db + config；
                     // 但 /workflow run 会走 executeWorkflow → buildWorkflowContext → runSubAgent，
                     // 该路径需要 agentRegistry 来派生子 agent，因此必须注入。
@@ -184,6 +234,25 @@ function createChatRoute(ctx) {
         }
         const provider = body.provider ?? ctx.config.defaultProvider;
         const model = body.model ?? ctx.config.defaultModel;
+        // P0-1 首次运行引导：provider 未配置/未注册时立即返回可操作错误，
+        // 不让错误延迟到 SSE 流内以英文 NoRoute 冒出。前端据此引导用户去设置页。
+        // 注：测试注入 ctx.chatStream 时跳过——测试 registry 空壳不代表生产未配置。
+        if (!ctx.chatStream) {
+            try {
+                resolveRoute(ctx.llmRegistry, provider, model);
+            }
+            catch {
+                const configured = ctx.config.providers
+                    .map((p) => p.name)
+                    .filter(Boolean)
+                    .join(', ');
+                return apiError(c, 400, 'NO_PROVIDER_CONFIGURED', `未配置可用的 AI 服务（provider: ${provider}）。请前往「设置 → Provider」添加 API 服务并测试连接`, {
+                    provider,
+                    configuredProviders: ctx.config.providers.map((p) => p.name).filter(Boolean),
+                    ...(configured ? { hint: `已配置：${configured}` } : {}),
+                });
+            }
+        }
         // 并发守卫（P0-4）：同步原子占位 tryAcquire（Map has+set 一气呵成、无 await）。
         // 旧实现先 get 检查、真正 register 在 SSE 回调内，两者之间隔多个 await
         // （getLLMSegments、createAgent 等）：双发 POST 在窗口内均通过守卫，后注册
@@ -241,15 +310,25 @@ function createChatRoute(ctx) {
                 let doneSent = false;
                 let runStartedAt;
                 try {
-                    // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认
+                    // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认。
+                    // P1-5：模式按会话隔离（sessionPermissionModes 覆盖优先）。
                     const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
-                        getMode: () => ctx.permissionMode,
+                        getMode: () => ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode,
                         onPermissionRequired: async (req) => {
                             await stream.writeSSE({
                                 event: 'permission_required',
                                 data: JSON.stringify({ _tag: 'permission_required', ...req }),
                             });
                         },
+                        // P1-6：确认超时（5 分钟）被自动拒绝时通知前端，避免用户误以为已执行
+                        onPermissionTimeout: (req) => {
+                            stream
+                                .writeSSE({
+                                event: 'permission_timeout',
+                                data: JSON.stringify({ _tag: 'permission_timeout', ...req }),
+                            })
+                                .catch(() => { });
+                        },
                     });
                     // cwd 已在斜杠拦截前解析，此处直接复用
                     // 构建 agent 依赖（注入测试用 chatStream）
@@ -284,6 +363,7 @@ function createChatRoute(ctx) {
                         model: resolvedModel,
                         startedAt: runStartedAt,
                     });
+                    state.lastRunStartedAt = runStartedAt;
                     // 填充 tryAcquire 留下的占位（原 register 语义：按 sessionId 覆盖写入）
                     ctx.agentManager.register({ sessionId, state, deps });
                     // workflowz 关键词检测：用户消息包含独立关键词时注入工作流通知（steering），