@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/router/dist/orchestrator.js

@@ -0,0 +1,290 @@
+import path from "node:path";
+import { appendJsonl } from "@codebridge/core";
+import { RunnerClient, } from "@codebridge/runner-client";
+import { SessionRouter } from "./session-router.js";
+export class RunOrchestrator {
+    options;
+    router;
+    client;
+    activeChatRuns = new Map();
+    constructor(options) {
+        this.options = options;
+        this.router = new SessionRouter(options.dataDir);
+        this.router.initFromConfig(options.config);
+        this.client = new RunnerClient({
+            baseUrl: options.config.runner.url,
+            token: options.config.runner.token,
+        });
+    }
+    updateConfig(config) {
+        this.options.config = config;
+        this.router.initFromConfig(config);
+    }
+    chatRunKey(chatId, topicId) {
+        return `${chatId}|${topicId ?? ""}`;
+    }
+    hasActiveRun(chatId, topicId) {
+        return this.activeChatRuns.has(this.chatRunKey(chatId, topicId));
+    }
+    /** 活跃任务已运行的毫秒数；无活跃任务时返回 undefined */
+    activeRunElapsedMs(chatId, topicId) {
+        const active = this.activeChatRuns.get(this.chatRunKey(chatId, topicId));
+        return active ? Date.now() - active.startedAt : undefined;
+    }
+    activeRunStatus(chatId, topicId) {
+        const active = this.activeChatRuns.get(this.chatRunKey(chatId, topicId));
+        if (!active)
+            return undefined;
+        return {
+            runId: active.runId,
+            startedAt: active.startedAt,
+            lastActivityAt: active.lastActivityAt,
+            currentPhase: active.currentPhase,
+            ...(active.lastCheckpoint
+                ? { lastCheckpoint: active.lastCheckpoint }
+                : {}),
+        };
+    }
+    async cancelActiveForChat(chatId, topicId) {
+        const key = this.chatRunKey(chatId, topicId);
+        const active = this.activeChatRuns.get(key);
+        if (!active)
+            return false;
+        active.controller.abort();
+        await this.client.cancel(active.runId).catch(() => { });
+        await active.finished;
+        return true;
+    }
+    async steerActiveForChat(chatId, topicId, prompt) {
+        const active = this.activeChatRuns.get(this.chatRunKey(chatId, topicId));
+        if (!active)
+            return { ok: false, error: "当前没有正在运行的任务" };
+        return this.client.steer(active.runId, prompt);
+    }
+    async *runAgent(chatId, topicId, prompt, attachments) {
+        await this.cancelActiveForChat(chatId, topicId);
+        const sessionKey = this.router.buildSessionKey(chatId, topicId);
+        const runOpts = this.router.resolveRunOptions(chatId, topicId, this.options.config);
+        // 不再从 sessions.json 读取续聊 session（Task 12）。
+        const resumeSessionId = undefined;
+        const runId = this.router.newRunId();
+        const chatKey = this.chatRunKey(chatId, topicId);
+        const controller = new AbortController();
+        let resolveFinished;
+        const finished = new Promise((resolve) => {
+            resolveFinished = resolve;
+        });
+        const startedAt = Date.now();
+        this.activeChatRuns.set(chatKey, {
+            runId,
+            controller,
+            startedAt,
+            lastActivityAt: startedAt,
+            currentPhase: "任务启动",
+            finished,
+        });
+        const logPath = path.join(this.options.dataDir, "logs", `${new Date().toISOString().slice(0, 10)}.jsonl`);
+        appendJsonl(logPath, {
+            event: "intake",
+            runId,
+            chatId,
+            topicId,
+            prompt: prompt.slice(0, 200),
+            ts: new Date().toISOString(),
+        });
+        const request = {
+            runId,
+            sessionKey,
+            prompt,
+            attachments,
+            resumeSessionId,
+            model: runOpts.model,
+            effort: runOpts.effort,
+            mode: runOpts.mode,
+            claudePermissionMode: runOpts.claudePermissionMode,
+            additionalDirectories: runOpts.additionalDirectories,
+            acpConfig: runOpts.acpConfig,
+        };
+        let sessionId;
+        let stopped = false;
+        let loggedDone = false;
+        const logDone = () => {
+            if (loggedDone)
+                return;
+            loggedDone = true;
+            appendJsonl(logPath, {
+                event: "done",
+                runId,
+                sessionId,
+                stopped: controller.signal.aborted || stopped,
+                ts: new Date().toISOString(),
+            });
+        };
+        const persistSession = (id) => {
+            if (!id)
+                return;
+            sessionId = id;
+        };
+        try {
+            try {
+                for await (const event of this.client.run(request, {
+                    signal: controller.signal,
+                })) {
+                    if (controller.signal.aborted) {
+                        stopped = true;
+                        break;
+                    }
+                    this.options.onEvent?.(runId, event);
+                    const active = this.activeChatRuns.get(chatKey);
+                    if (active?.runId === runId) {
+                        let phase;
+                        switch (event.type) {
+                            case "text_delta":
+                                phase =
+                                    event.phase === "commentary" ? "任务检查点" : "生成回复";
+                                if (event.phase === "commentary") {
+                                    const sameMessage = Boolean(event.messageId) &&
+                                        active.checkpointMessageId === event.messageId;
+                                    active.checkpointText = sameMessage
+                                        ? `${active.checkpointText ?? ""}${event.text}`
+                                        : event.text;
+                                    active.checkpointMessageId = event.messageId;
+                                    const checkpoint = active.checkpointText
+                                        .replace(/\s+/g, " ")
+                                        .trim();
+                                    if (checkpoint) {
+                                        active.lastCheckpoint =
+                                            checkpoint.length > 240
+                                                ? `${checkpoint.slice(0, 239)}…`
+                                                : checkpoint;
+                                    }
+                                }
+                                break;
+                            case "thought_delta":
+                                phase = "分析任务";
+                                break;
+                            case "tool_start":
+                                phase = `工具执行：${event.name}`;
+                                break;
+                            case "tool_update":
+                                phase = event.name
+                                    ? `工具执行：${event.name}`
+                                    : active.currentPhase;
+                                break;
+                            case "tool_end":
+                                phase = event.name ? `工具完成：${event.name}` : "工具完成";
+                                break;
+                            case "plan":
+                            case "plan_update":
+                            case "plan_removed":
+                                phase = "更新计划";
+                                break;
+                            case "permission_request":
+                                phase = "等待权限确认";
+                                break;
+                            default:
+                                break;
+                        }
+                        if (phase) {
+                            active.lastActivityAt = Date.now();
+                            active.currentPhase = phase;
+                        }
+                    }
+                    if (event.type === "session") {
+                        persistSession(event.sessionId);
+                    }
+                    yield event;
+                    if (event.type === "done")
+                        break;
+                }
+            }
+            catch (err) {
+                if (controller.signal.aborted) {
+                    stopped = true;
+                }
+                else {
+                    const message = err instanceof Error ? err.message : String(err);
+                    yield { type: "error", message, fatal: true };
+                    yield { type: "done", exitCode: 1 };
+                }
+            }
+            // 不再写 sessions.json（Task 12）；session 绑定由 Catalog 权威。
+            if (stopped) {
+                yield { type: "error", message: "任务已停止", fatal: false };
+                yield { type: "done", exitCode: 130 };
+            }
+        }
+        finally {
+            if (this.activeChatRuns.get(chatKey)?.runId === runId) {
+                this.activeChatRuns.delete(chatKey);
+            }
+            logDone();
+            resolveFinished();
+        }
+    }
+    async doctor() {
+        return this.client.doctor();
+    }
+    async health() {
+        return this.client.health();
+    }
+    async authorizeDirectory(directory) {
+        return this.client.authorizeDirectory(directory);
+    }
+    async listSessions(chatId, topicId, options) {
+        const key = this.router.buildSessionKey(chatId, topicId);
+        const result = await this.client.listSessions(key.backendId, key.cwd, options);
+        if (result.error) {
+            throw new Error(result.error);
+        }
+        return result.sessions;
+    }
+    /** prompt_feishu：把 /approve /deny 转给当前 run 挂起的权限请求 */
+    async resolveActivePermission(chatId, topicId, approve) {
+        const active = this.activeChatRuns.get(this.chatRunKey(chatId, topicId));
+        if (!active)
+            return false;
+        return this.client.resolvePermission(active.runId, approve);
+    }
+    async listConfigOptions(chatId, topicId) {
+        const key = this.router.buildSessionKey(chatId, topicId);
+        const result = await this.client.listConfigOptions(key.backendId, key.cwd);
+        if (result.error)
+            throw new Error(result.error);
+        return result.options;
+    }
+    async closeSession(chatId, topicId, sessionId) {
+        return this.manageSession("close", chatId, topicId, sessionId);
+    }
+    async deleteSession(chatId, topicId, sessionId) {
+        return this.manageSession("delete", chatId, topicId, sessionId);
+    }
+    async manageSession(action, chatId, topicId, sessionId) {
+        const key = this.router.buildSessionKey(chatId, topicId);
+        // 不再用 sessions.json 判断「当前槽位 session 是否运行中」（Task 12）；
+        // 运行中保护由 provider lease + runner 侧处理。
+        const result = action === "close"
+            ? await this.client.closeSession(key.backendId, key.cwd, sessionId)
+            : await this.client.deleteSession(key.backendId, key.cwd, sessionId);
+        return result;
+    }
+}
+export function agentEventToMarkdown(event) {
+    switch (event.type) {
+        case "text_delta":
+            return event.text;
+        case "tool_start":
+            return `\n🔧 \`${event.name}\` …\n`;
+        case "tool_update":
+            return `\n↳ \`${event.name ?? "tool"}\`${event.status ? ` (${event.status})` : ""}\n`;
+        case "tool_end":
+            return `\n✓ \`${event.name ?? "tool"}\`\n`;
+        case "error":
+            return `\n❌ ${event.message}\n`;
+        case "done":
+            return event.exitCode === 0 ? "" : `\n（退出码 ${event.exitCode}）\n`;
+        default:
+            return "";
+    }
+}
+//# sourceMappingURL=orchestrator.js.map

package/node_modules/@codebridge/router/dist/session-list-format.d.ts

@@ -0,0 +1,19 @@
+import type { CliSessionSummary } from "@codebridge/runner-client";
+export declare function isNoisePreview(text: string): boolean;
+export declare function cleanSessionPreview(preview: string, max?: number): string;
+/** 列表里显示项目名：优先最后 1–2 段有意义路径 */
+export declare function compactProjectPath(cwd: string): string;
+export declare function formatElapsed(ms: number): string;
+export declare function formatWhenShort(iso: string): string;
+export interface SessionListFormatOptions {
+    backendId: string;
+    scopeCwd: string;
+    listAll: boolean;
+    total: number;
+    showCwd: boolean;
+    displayLimit?: number;
+}
+export declare function formatSessionListHeader(options: SessionListFormatOptions): string;
+export declare function formatSessionLine(session: CliSessionSummary, index: number, showCwd: boolean): string;
+export declare function formatSessionListFooter(boundSessionId?: string): string;
+//# sourceMappingURL=session-list-format.d.ts.map

package/node_modules/@codebridge/router/dist/session-list-format.js

@@ -0,0 +1,97 @@
+import path from "node:path";
+export function isNoisePreview(text) {
+    const t = text.trim();
+    if (!t || t === "(no preview)")
+        return true;
+    if (/^\d+$/.test(t))
+        return true;
+    if (t.startsWith("Caveat: The messages below"))
+        return true;
+    if (t.startsWith("<local-command"))
+        return true;
+    return false;
+}
+export function cleanSessionPreview(preview, max = 64) {
+    const one = preview.replace(/\s+/g, " ").trim();
+    if (isNoisePreview(one))
+        return "（无有效预览）";
+    return one.length <= max ? one : `${one.slice(0, max)}…`;
+}
+/** 列表里显示项目名：优先最后 1–2 段有意义路径 */
+export function compactProjectPath(cwd) {
+    const parts = path.resolve(cwd).split(path.sep).filter(Boolean);
+    if (parts.length === 0)
+        return cwd;
+    if (parts.length <= 2)
+        return parts.join(path.sep);
+    const last = parts[parts.length - 1];
+    const prev = parts[parts.length - 2];
+    if (prev === "com" || prev.includes(".")) {
+        return last;
+    }
+    return `${prev}${path.sep}${last}`;
+}
+export function formatElapsed(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours} 小时 ${minutes} 分`;
+    if (minutes > 0)
+        return `${minutes} 分 ${seconds} 秒`;
+    return `${seconds} 秒`;
+}
+export function formatWhenShort(iso) {
+    try {
+        const d = new Date(iso);
+        const month = d.getMonth() + 1;
+        const day = d.getDate();
+        const hour = String(d.getHours()).padStart(2, "0");
+        const minute = String(d.getMinutes()).padStart(2, "0");
+        return `${month}/${day} ${hour}:${minute}`;
+    }
+    catch {
+        return iso;
+    }
+}
+export function formatSessionListHeader(options) {
+    const scope = compactProjectPath(options.scopeCwd);
+    const scopeLabel = options.listAll
+        ? "全部目录"
+        : `\`${scope}\` 及子目录`;
+    const countNote = options.total > (options.displayLimit ?? options.total)
+        ? `（显示最近 ${options.displayLimit} / 共 ${options.total} 条）`
+        : `（共 ${options.total} 条）`;
+    return [
+        `**${options.backendId}** 本地 session ${countNote}`,
+        `范围：${scopeLabel}`,
+    ].join("\n");
+}
+export function formatSessionLine(session, index, showCwd) {
+    const id = session.id.slice(0, 8);
+    const when = formatWhenShort(session.updatedAt);
+    const preview = cleanSessionPreview(session.preview);
+    if (!showCwd) {
+        return [
+            `**${index + 1}.** \`${id}\` · ${when}${session.additionalDirectories?.length ? ` · roots +${session.additionalDirectories.length}` : ""}`,
+            `　${preview}`,
+        ].join("\n");
+    }
+    const project = compactProjectPath(session.cwd);
+    return [
+        `**${index + 1}.** \`${id}\` · ${when} · ${project}${session.additionalDirectories?.length ? ` · roots +${session.additionalDirectories.length}` : ""}`,
+        `　${preview}`,
+    ].join("\n");
+}
+export function formatSessionListFooter(boundSessionId) {
+    const lines = [
+        "---",
+        "回复 `/resume <序号>` 绑定 · `/resume last` 选最近一条",
+    ];
+    if (boundSessionId) {
+        lines.push(`当前已绑定：\`${boundSessionId.slice(0, 8)}…\``);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=session-list-format.js.map

package/node_modules/@codebridge/router/dist/session-rotation.d.ts

@@ -0,0 +1,9 @@
+import type { ChannelCommandContext, SessionAutoRotateConfig } from "@codebridge/core";
+/**
+ * Decide whether the next channel message should start a fresh provider session
+ * instead of resuming the bound one. Returns a user-facing reason, or undefined.
+ * Never rotates a busy session: queued turns would be left paused on the old one.
+ */
+export declare function sessionRotationReason(context: ChannelCommandContext, policy: SessionAutoRotateConfig | undefined, now: number): string | undefined;
+export declare function sessionRotationNotice(reason: string): string;
+//# sourceMappingURL=session-rotation.d.ts.map

package/node_modules/@codebridge/router/dist/session-rotation.js

@@ -0,0 +1,31 @@
+const DEFAULT_IDLE_HOURS = 12;
+const DEFAULT_MAX_CONTEXT_RATIO = 0.5;
+/**
+ * Decide whether the next channel message should start a fresh provider session
+ * instead of resuming the bound one. Returns a user-facing reason, or undefined.
+ * Never rotates a busy session: queued turns would be left paused on the old one.
+ */
+export function sessionRotationReason(context, policy, now) {
+    if (policy?.enabled === false || !context.sessionId)
+        return undefined;
+    if (context.activeRunId || (context.queuedTurns ?? 0) > 0)
+        return undefined;
+    const ratio = policy?.maxContextRatio ?? DEFAULT_MAX_CONTEXT_RATIO;
+    const { contextUsed: used, contextSize: size, contextFirstUsed: first } = context;
+    // Only rotate a session that grew past the limit itself. One that started above it was
+    // resumed on purpose (/resume) or carries a huge base prompt; rotating it would loop.
+    const grewPastLimit = first === null || first === undefined || first / (size || 1) < ratio;
+    if (used && size && used / size >= ratio && grewPastLimit) {
+        return `上一会话上下文已用 ${Math.round((used / size) * 100)}%（${Math.round(used / 1000)}k / ${Math.round(size / 1000)}k tokens）`;
+    }
+    const idleMs = (policy?.idleHours ?? DEFAULT_IDLE_HOURS) * 3_600_000;
+    const last = context.lastActivityAt ? Date.parse(context.lastActivityAt) : Number.NaN;
+    if (idleMs > 0 && Number.isFinite(last) && now - last >= idleMs) {
+        return `上一会话已闲置 ${Math.floor((now - last) / 3_600_000)} 小时`;
+    }
+    return undefined;
+}
+export function sessionRotationNotice(reason) {
+    return `🆕 ${reason}，已自动开启新会话，本条消息不带之前的上下文。需要接着旧会话可发 /resume。`;
+}
+//# sourceMappingURL=session-rotation.js.map

package/node_modules/@codebridge/router/dist/session-router.d.ts

@@ -0,0 +1,59 @@
+import { type AppConfig, type ClaudePermissionMode, type SessionKey } from "@codebridge/core";
+export interface ChatBinding {
+    backendId: string;
+    cwd: string;
+    topicId?: string;
+    model?: string;
+    effort?: string;
+    mode?: string;
+    claudePermissionMode?: ClaudePermissionMode;
+    additionalDirectories?: string[];
+    acpConfig?: Record<string, string | boolean>;
+    /** 卡片是否展示思考/工具过程；缺省=true（显示）。纯展示偏好，切 backend 不清除 */
+    showThinking?: boolean;
+}
+export interface ResolvedRunOptions {
+    model?: string;
+    effort?: string;
+    mode?: string;
+    claudePermissionMode?: ClaudePermissionMode;
+    additionalDirectories?: string[];
+    acpConfig?: Record<string, string | boolean>;
+}
+export declare class SessionRouter {
+    private readonly workspaces;
+    private readonly bindings;
+    private readonly generations;
+    constructor(dataDir: string);
+    private bindingKey;
+    private slotKey;
+    /** 当前槽位（backend+cwd）指向第几代 Session，默认 0。 */
+    getSlotGeneration(chatId: string, topicId?: string): number;
+    /** /new 对当前槽位 +1，返回新 generation。 */
+    incrementSlotGeneration(chatId: string, topicId?: string): number;
+    /** 供 bridge 组装 ingress 消息的槽位描述（agent/cwd 已规范化）。 */
+    buildSlot(chatId: string, topicId?: string): {
+        agentId: string;
+        workspaceKey: string;
+        generation: number;
+    };
+    getBinding(chatId: string, topicId?: string): ChatBinding;
+    setBinding(chatId: string, binding: Partial<ChatBinding>, topicId?: string): void;
+    clearModel(chatId: string, topicId?: string): void;
+    clearEffort(chatId: string, topicId?: string): void;
+    clearClaudePermissionMode(chatId: string, topicId?: string): void;
+    clearMode(chatId: string, topicId?: string): void;
+    clearAcpConfig(chatId: string, topicId?: string): void;
+    /** 切换 backend 时清除 model/effort/permission 会话覆盖 */
+    clearRunOverrides(chatId: string, topicId?: string): void;
+    resolveRunOptions(chatId: string, topicId: string | undefined, config: AppConfig): ResolvedRunOptions;
+    private defaultCwd;
+    private config;
+    initFromConfig(config: AppConfig): void;
+    buildSessionKey(chatId: string, topicId?: string): SessionKey;
+    listWorkspaceNames(): Record<string, string>;
+    saveWorkspace(name: string, cwd: string): void;
+    removeWorkspace(name: string): void;
+    newRunId(): string;
+}
+//# sourceMappingURL=session-router.d.ts.map

package/node_modules/@codebridge/router/dist/session-router.js

@@ -0,0 +1,182 @@
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { JsonMapStore, canonicalWorkspaceKey, resolveDefaultAgentId, serializeSessionKey, } from "@codebridge/core";
+export class SessionRouter {
+    workspaces;
+    bindings;
+    generations;
+    constructor(dataDir) {
+        this.workspaces = new JsonMapStore(path.join(dataDir, "workspaces.json"));
+        this.bindings = new JsonMapStore(path.join(dataDir, "chat-bindings.json"));
+        this.generations = new JsonMapStore(path.join(dataDir, "slot-generations.json"));
+    }
+    bindingKey(chatId, topicId) {
+        return `${chatId}|${topicId ?? ""}`;
+    }
+    slotKey(chatId, topicId) {
+        const binding = this.getBinding(chatId, topicId);
+        return serializeSessionKey({
+            chatId,
+            topicId,
+            backendId: binding.backendId,
+            cwd: canonicalWorkspaceKey(binding.cwd).key,
+        });
+    }
+    /** 当前槽位（backend+cwd）指向第几代 Session，默认 0。 */
+    getSlotGeneration(chatId, topicId) {
+        return this.generations.read()[this.slotKey(chatId, topicId)] ?? 0;
+    }
+    /** /new 对当前槽位 +1，返回新 generation。 */
+    incrementSlotGeneration(chatId, topicId) {
+        const key = this.slotKey(chatId, topicId);
+        const next = (this.generations.read()[key] ?? 0) + 1;
+        this.generations.update((all) => ({ ...all, [key]: next }));
+        return next;
+    }
+    /** 供 bridge 组装 ingress 消息的槽位描述（agent/cwd 已规范化）。 */
+    buildSlot(chatId, topicId) {
+        const binding = this.getBinding(chatId, topicId);
+        return {
+            agentId: binding.backendId,
+            workspaceKey: canonicalWorkspaceKey(binding.cwd).key,
+            generation: this.getSlotGeneration(chatId, topicId),
+        };
+    }
+    getBinding(chatId, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        const stored = this.bindings.read()[key];
+        if (stored)
+            return { ...stored };
+        // 话题级绑定缺省时继承所在会话的绑定（backend/cwd/model 等）；
+        // 不落盘，话题内显式 setBinding 时才写入话题级覆盖
+        if (topicId)
+            return this.getBinding(chatId);
+        const config = {
+            backendId: this.config
+                ? resolveDefaultAgentId(this.config)
+                : "cursor",
+            cwd: this.defaultCwd,
+        };
+        this.bindings.update((all) => ({ ...all, [key]: config }));
+        return { ...config };
+    }
+    setBinding(chatId, binding, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        const current = this.getBinding(chatId, topicId);
+        const next = { ...current, ...binding };
+        this.bindings.update((all) => ({ ...all, [key]: next }));
+    }
+    clearModel(chatId, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        this.bindings.update((all) => {
+            const current = all[key];
+            if (!current)
+                return all;
+            const next = { ...current };
+            delete next.model;
+            return { ...all, [key]: next };
+        });
+    }
+    clearEffort(chatId, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        this.bindings.update((all) => {
+            const current = all[key];
+            if (!current)
+                return all;
+            const next = { ...current };
+            delete next.effort;
+            return { ...all, [key]: next };
+        });
+    }
+    clearClaudePermissionMode(chatId, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        this.bindings.update((all) => {
+            const current = all[key];
+            if (!current)
+                return all;
+            const next = { ...current };
+            delete next.claudePermissionMode;
+            return { ...all, [key]: next };
+        });
+    }
+    clearMode(chatId, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        this.bindings.update((all) => {
+            const current = all[key];
+            if (!current)
+                return all;
+            const next = { ...current };
+            delete next.mode;
+            return { ...all, [key]: next };
+        });
+    }
+    clearAcpConfig(chatId, topicId) {
+        const key = this.bindingKey(chatId, topicId);
+        this.bindings.update((all) => {
+            const current = all[key];
+            if (!current)
+                return all;
+            const next = { ...current };
+            delete next.acpConfig;
+            return { ...all, [key]: next };
+        });
+    }
+    /** 切换 backend 时清除 model/effort/permission 会话覆盖 */
+    clearRunOverrides(chatId, topicId) {
+        this.clearModel(chatId, topicId);
+        this.clearEffort(chatId, topicId);
+        this.clearMode(chatId, topicId);
+        this.clearClaudePermissionMode(chatId, topicId);
+        this.clearAcpConfig(chatId, topicId);
+    }
+    resolveRunOptions(chatId, topicId, config) {
+        const binding = this.getBinding(chatId, topicId);
+        const profile = config.backends[binding.backendId];
+        const rawModel = binding.model ?? profile?.model;
+        const rawEffort = binding.effort ?? profile?.effort;
+        const rawPermission = binding.claudePermissionMode ?? profile?.claudePermissionMode;
+        return {
+            model: rawModel,
+            effort: rawEffort,
+            mode: binding.mode ?? rawPermission,
+            claudePermissionMode: rawPermission,
+            additionalDirectories: binding.additionalDirectories,
+            acpConfig: binding.acpConfig,
+        };
+    }
+    defaultCwd = process.cwd();
+    config;
+    initFromConfig(config) {
+        const cwd = config.workspaces?.default ??
+            config.workspaces?.root ??
+            process.cwd();
+        this.defaultCwd = cwd;
+        this.config = config;
+    }
+    buildSessionKey(chatId, topicId) {
+        const b = this.getBinding(chatId, topicId);
+        return {
+            chatId,
+            topicId,
+            backendId: b.backendId,
+            cwd: b.cwd,
+        };
+    }
+    listWorkspaceNames() {
+        return this.workspaces.read();
+    }
+    saveWorkspace(name, cwd) {
+        this.workspaces.update((all) => ({ ...all, [name]: cwd }));
+    }
+    removeWorkspace(name) {
+        this.workspaces.update((all) => {
+            const next = { ...all };
+            delete next[name];
+            return next;
+        });
+    }
+    newRunId() {
+        return randomUUID();
+    }
+}
+//# sourceMappingURL=session-router.js.map