leduo-patrol 2.2.1 → 2.2.4

package/dist/server/session-manager.js

@@ -4,35 +4,37 @@ import { mkdir, readFile, writeFile, access, readdir, open, stat } from "node:fs
 import { watch } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { ClaudeCliSession } from "./claude-cli-session.js";
+import { ClaudeAcpSession } from "./acp-session.js";
 import { ActivityMonitor, projectDirPath } from "./activity-monitor.js";
 export class SessionManager {
+    static INITIAL_TIMELINE_WINDOW = 120;
+    static HISTORY_PAGE_SIZE = 120;
+    static OUTPUT_BUFFER_MAX = 256 * 1024;
+    static DISCOVERY_POLL_MS = 1000;
+    static DISCOVERY_MAX_POLLS = 60;
+    static HISTORY_DEBOUNCE_MS = 200;
+    static HISTORY_POLL_MS = 3000;
     allowedRoots;
     claudeBin;
+    agentBinPath;
     allowSkipPermissions;
     stateFilePath;
     sessions = new Map();
     listeners = new Set();
     activityMonitor;
-    /** Reverse index: Claude sessionId → clientSessionId */
     sessionIdIndex = new Map();
-    /** Timers for discovering new session IDs after /clear */
+    askUserQuestionMap = new Map();
     discoveryTimers = new Map();
-    persistTimer = null;
-    /** Maximum bytes of PTY output to keep per session for replay on reconnect. */
-    static OUTPUT_BUFFER_MAX = 256 * 1024;
-    static DISCOVERY_POLL_MS = 1000;
-    static DISCOVERY_MAX_POLLS = 60; // ~1 minute
-    // history.jsonl monitoring for /clear detection
     historyFilePath;
     historyWatcher = null;
     historyPollTimer = null;
     historyDebounceTimer = null;
     lastHistorySize = 0;
-    static HISTORY_DEBOUNCE_MS = 200;
-    static HISTORY_POLL_MS = 3000;
+    persistTimer = null;
     constructor(options) {
         this.allowedRoots = options.allowedRoots;
         this.claudeBin = options.claudeBin;
+        this.agentBinPath = options.agentBinPath;
         this.allowSkipPermissions = options.allowSkipPermissions ?? false;
         this.stateFilePath = path.join(os.homedir(), ".leduo-patrol", "state.json");
         this.historyFilePath = path.join(process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude"), "history.jsonl");
@@ -44,12 +46,13 @@ export class SessionManager {
             if (!entry)
                 return;
             entry.snapshot.activityState = activityState;
+            entry.snapshot.updatedAt = new Date().toISOString();
+            this.schedulePersist();
             this.emit({
                 type: "session_activity",
                 payload: { clientSessionId, activityState },
             });
         });
-        // Set up plan session detection callback
         this.activityMonitor.onPlanSessionDetected = (newSessionId, promptId, workspacePath) => {
             this.handlePlanSessionDetected(newSessionId, promptId, workspacePath);
         };
@@ -60,7 +63,6 @@ export class SessionManager {
         for (const persisted of persistedState.sessions) {
             if (!(await this.isRestorableWorkspace(persisted.workspacePath))) {
                 skippedPersistedSessions = true;
-                console.warn(`[SessionManager] Skipping persisted session with unavailable workspace: ${persisted.workspacePath}`);
                 continue;
             }
             const snapshot = {
@@ -70,26 +72,38 @@ export class SessionManager {
                 connectionState: "connecting",
                 activityState: "idle",
                 sessionId: persisted.sessionId,
+                engine: persisted.engine === "acp" ? "acp" : "cli",
+                switchable: true,
                 updatedAt: persisted.updatedAt,
                 allowSkipPermissions: persisted.allowSkipPermissions,
+                acp: persisted.engine === "acp"
+                    ? createEmptyAcpState(persisted.acpDefaultModeId, persisted.acpCurrentModeId, normalizeQueuedPrompts(persisted.acpQueuedPrompts))
+                    : undefined,
             };
-            this.sessions.set(snapshot.clientSessionId, {
+            const entry = {
                 snapshot,
                 cliSession: null,
+                cliExitExpected: false,
+                acpSession: null,
+                acpFullTimeline: [],
                 outputBuffer: "",
-            });
-            this.sessionIdIndex.set(snapshot.sessionId, snapshot.clientSessionId);
-            this.activityMonitor.watch(snapshot.sessionId, snapshot.workspacePath);
+                switchInProgress: false,
+                acpQueueDrainActive: false,
+            };
+            this.sessions.set(snapshot.clientSessionId, entry);
+            if (snapshot.sessionId) {
+                this.sessionIdIndex.set(snapshot.sessionId, snapshot.clientSessionId);
+                this.activityMonitor.watch(snapshot.sessionId, snapshot.workspacePath);
+            }
         }
         if (skippedPersistedSessions) {
             await this.writePersistedState().catch(() => undefined);
         }
         for (const entry of this.sessions.values()) {
-            this.startCliSession(entry, true).catch((error) => {
+            this.startEngine(entry, Boolean(entry.snapshot.sessionId)).catch((error) => {
                 this.handleManagerError(entry.snapshot.clientSessionId, error);
             });
         }
-        // Start monitoring ~/.claude/history.jsonl for /clear commands
         await this.startHistoryMonitor();
     }
     subscribe(listener) {
@@ -101,29 +115,46 @@ export class SessionManager {
     getStateSnapshot() {
         return {
             sessions: [...this.sessions.values()]
-                .map((entry) => entry.snapshot)
+                .map((entry) => this.snapshotForEvent(entry))
                 .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
         };
     }
+    getAvailableEngines() {
+        return this.agentBinPath ? ["cli", "acp"] : ["cli"];
+    }
+    getSessionHistory(clientSessionId, before, limit = SessionManager.HISTORY_PAGE_SIZE) {
+        const entry = this.getEntry(clientSessionId);
+        if (!entry.snapshot.acp) {
+            throw new Error("Session history is only available for ACP sessions.");
+        }
+        const fullTimeline = this.ensureFullTimeline(entry);
+        const normalizedLimit = Number.isFinite(limit) ? limit : SessionManager.HISTORY_PAGE_SIZE;
+        const normalizedBefore = Number.isFinite(before) ? before : fullTimeline.length;
+        const safeLimit = Math.max(1, Math.min(normalizedLimit, SessionManager.HISTORY_PAGE_SIZE));
+        const safeBefore = Math.max(0, Math.min(normalizedBefore, fullTimeline.length));
+        const start = Math.max(0, safeBefore - safeLimit);
+        return {
+            items: fullTimeline.slice(start, safeBefore),
+            start,
+            total: fullTimeline.length,
+        };
+    }
     getSessionWorkspacePath(clientSessionId) {
         return this.getEntry(clientSessionId).snapshot.workspacePath;
     }
-    async createSession(requestedWorkspacePath, requestedTitle, allowSkipPermissions) {
+    async createSession(requestedWorkspacePath, requestedTitle, allowSkipPermissions, engine = "cli") {
+        if (engine === "acp" && !this.agentBinPath) {
+            throw new Error("ACP engine is unavailable. Check LEDUO_PATROL_AGENT_BIN or bundled claude-code-acp.");
+        }
         const resolvedWorkspacePath = await this.resolveRequestedWorkspace(requestedWorkspacePath);
         const existingEntry = [...this.sessions.values()].find((entry) => entry.snapshot.workspacePath === resolvedWorkspacePath);
         if (existingEntry) {
             this.emit({
                 type: "session_registered",
-                payload: {
-                    clientSessionId: existingEntry.snapshot.clientSessionId,
-                    title: existingEntry.snapshot.title,
-                    workspacePath: existingEntry.snapshot.workspacePath,
-                    sessionId: existingEntry.snapshot.sessionId,
-                },
+                payload: this.snapshotForEvent(existingEntry),
             });
             return existingEntry.snapshot;
         }
-        const sessionId = randomUUID();
         const effectiveAllowSkipPermissions = allowSkipPermissions ?? this.allowSkipPermissions;
         const snapshot = {
             clientSessionId: randomUUID(),
@@ -131,51 +162,230 @@ export class SessionManager {
             workspacePath: resolvedWorkspacePath,
             connectionState: "connecting",
             activityState: "idle",
-            sessionId,
+            sessionId: engine === "cli" ? randomUUID() : "",
+            engine,
+            switchable: true,
             updatedAt: new Date().toISOString(),
             allowSkipPermissions: effectiveAllowSkipPermissions,
+            acp: engine === "acp" ? createEmptyAcpState() : undefined,
         };
         const entry = {
             snapshot,
             cliSession: null,
+            cliExitExpected: false,
+            acpSession: null,
+            acpFullTimeline: [],
             outputBuffer: "",
+            switchInProgress: false,
+            acpQueueDrainActive: false,
         };
         this.sessions.set(snapshot.clientSessionId, entry);
-        this.sessionIdIndex.set(sessionId, snapshot.clientSessionId);
-        this.activityMonitor.watch(sessionId, resolvedWorkspacePath);
+        if (snapshot.sessionId) {
+            this.sessionIdIndex.set(snapshot.sessionId, snapshot.clientSessionId);
+            this.activityMonitor.watch(snapshot.sessionId, resolvedWorkspacePath);
+        }
         this.schedulePersist();
         this.emit({
             type: "session_registered",
-            payload: {
-                clientSessionId: snapshot.clientSessionId,
-                title: snapshot.title,
-                workspacePath: snapshot.workspacePath,
-                sessionId: snapshot.sessionId,
-            },
+            payload: this.snapshotForEvent(entry),
+        });
+        try {
+            await this.startEngine(entry, false);
+        }
+        catch (error) {
+            entry.snapshot.updatedAt = new Date().toISOString();
+            this.schedulePersist();
+            this.emit({
+                type: "session_updated",
+                payload: this.snapshotForEvent(entry),
+            });
+            throw error;
+        }
+        this.emit({
+            type: "session_updated",
+            payload: this.snapshotForEvent(entry),
         });
-        await this.startCliSession(entry, false);
         return snapshot;
     }
+    async switchEngine(clientSessionId, engine) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine === engine) {
+            return entry.snapshot;
+        }
+        if (engine === "acp" && !this.agentBinPath) {
+            throw new Error("ACP engine is unavailable. Check LEDUO_PATROL_AGENT_BIN or bundled claude-code-acp.");
+        }
+        const blockedReason = this.getSwitchBlockedReason(entry);
+        if (blockedReason) {
+            throw new Error(`Session is not switchable: ${blockedReason}`);
+        }
+        const previousEngine = entry.snapshot.engine;
+        entry.switchInProgress = true;
+        try {
+            await this.stopEngine(entry, "switch");
+            entry.snapshot.engine = engine;
+            if (engine === "acp" && !entry.snapshot.acp) {
+                entry.snapshot.acp = createEmptyAcpState();
+            }
+            entry.snapshot.connectionState = "connecting";
+            entry.snapshot.updatedAt = new Date().toISOString();
+            this.schedulePersist();
+            await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
+            entry.switchInProgress = false;
+            this.emit({
+                type: "session_updated",
+                payload: this.snapshotForEvent(entry),
+            });
+            return entry.snapshot;
+        }
+        catch (error) {
+            entry.snapshot.engine = previousEngine;
+            entry.snapshot.connectionState = "connecting";
+            try {
+                await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
+            }
+            catch (rollbackError) {
+                entry.switchInProgress = false;
+                this.handleManagerError(clientSessionId, rollbackError);
+                throw error;
+            }
+            entry.switchInProgress = false;
+            this.emit({
+                type: "session_updated",
+                payload: this.snapshotForEvent(entry),
+            });
+            throw error;
+        }
+    }
     writeToSession(clientSessionId, data) {
         const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "cli") {
+            throw new Error("CLI input is only available for CLI sessions.");
+        }
         entry.cliSession?.write(data);
     }
     resizeCliSession(clientSessionId, cols, rows) {
         const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "cli") {
+            return;
+        }
         entry.cliSession?.resize(cols, rows);
     }
-    /** Return buffered PTY output so a reconnecting client can replay history. */
     getSessionOutputBuffer(clientSessionId) {
         const entry = this.getEntry(clientSessionId);
         return entry.outputBuffer;
     }
+    async prompt(clientSessionId, text, modeId, images) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            throw new Error("Prompting is only available in ACP mode.");
+        }
+        if (!entry.acpSession) {
+            await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
+        }
+        const acpState = this.ensureAcpState(entry);
+        const effectiveModeId = modeId || acpState.currentModeId || acpState.defaultModeId || "default";
+        const nextImages = images ?? [];
+        if (this.shouldQueueAcpPrompt(entry)) {
+            this.enqueueAcpPrompt(entry, text, nextImages, effectiveModeId);
+            void this.drainAcpPromptQueue(entry);
+            return;
+        }
+        await this.sendAcpPrompt(entry, {
+            id: randomUUID(),
+            text,
+            images: nextImages,
+            modeId: effectiveModeId,
+            createdAt: new Date().toISOString(),
+            status: "sending",
+        });
+    }
+    async setSessionMode(clientSessionId, modeId) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            throw new Error("Session modes are only available in ACP mode.");
+        }
+        if (!modeId) {
+            return;
+        }
+        if (!entry.acpSession) {
+            await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
+        }
+        const acpState = this.ensureAcpState(entry);
+        await entry.acpSession?.setMode(modeId);
+        acpState.defaultModeId = modeId;
+        acpState.currentModeId = modeId;
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        this.emit({
+            type: "session_mode_changed",
+            payload: {
+                clientSessionId,
+                defaultModeId: acpState.defaultModeId,
+                currentModeId: acpState.currentModeId,
+            },
+        });
+    }
+    async cancel(clientSessionId) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            return;
+        }
+        await entry.acpSession?.cancel();
+    }
+    async resolvePermission(clientSessionId, requestId, optionId, note) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            throw new Error("Permissions are only available in ACP mode.");
+        }
+        await entry.acpSession?.resolvePermission(requestId, optionId, note);
+    }
+    async answerQuestion(clientSessionId, questionId, answer) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            throw new Error("Questions are only available in ACP mode.");
+        }
+        const mappedPermission = this.askUserQuestionMap.get(questionId);
+        if (mappedPermission) {
+            const siblingIds = [];
+            for (const [qId, mapping] of this.askUserQuestionMap.entries()) {
+                if (mapping.requestId === mappedPermission.requestId) {
+                    siblingIds.push(qId);
+                }
+            }
+            for (const qId of siblingIds) {
+                this.askUserQuestionMap.delete(qId);
+            }
+            await entry.acpSession?.resolvePermission(mappedPermission.requestId, "deny", answer);
+            return;
+        }
+        await entry.acpSession?.answerQuestion(questionId, answer);
+    }
+    async removeQueuedPrompt(clientSessionId, promptId) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            throw new Error("Queued prompts are only available in ACP mode.");
+        }
+        const acpState = this.ensureAcpState(entry);
+        const prompt = acpState.queuedPrompts.find((item) => item.id === promptId);
+        if (!prompt) {
+            return;
+        }
+        if (prompt.status === "sending") {
+            throw new Error("Queued prompt is currently sending and cannot be removed.");
+        }
+        acpState.queuedPrompts = acpState.queuedPrompts.filter((item) => item.id !== promptId);
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        this.emitSessionUpdated(entry);
+    }
     async closeSession(clientSessionId) {
         const entry = this.sessions.get(clientSessionId);
         if (!entry) {
             return;
         }
         this.clearDiscoveryTimer(clientSessionId);
-        entry.cliSession?.kill();
+        await this.stopEngine(entry, "close");
         this.activityMonitor.unwatch(entry.snapshot.sessionId);
         this.sessionIdIndex.delete(entry.snapshot.sessionId);
         this.sessions.delete(clientSessionId);
@@ -185,8 +395,143 @@ export class SessionManager {
             payload: { clientSessionId },
         });
     }
+    shouldQueueAcpPrompt(entry) {
+        const acpState = this.ensureAcpState(entry);
+        return (entry.acpQueueDrainActive
+            || acpState.queuedPrompts.length > 0
+            || acpState.permissions.length > 0
+            || acpState.questions.length > 0
+            || this.isAcpBusy(acpState));
+    }
+    enqueueAcpPrompt(entry, text, images, modeId) {
+        const acpState = this.ensureAcpState(entry);
+        acpState.queuedPrompts.push({
+            id: randomUUID(),
+            text,
+            images,
+            modeId,
+            createdAt: new Date().toISOString(),
+            status: "queued",
+        });
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        this.emitSessionUpdated(entry);
+    }
+    async sendAcpPrompt(entry, prompt) {
+        if (!entry.acpSession) {
+            await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
+        }
+        const acpState = this.ensureAcpState(entry);
+        if (prompt.modeId) {
+            await entry.acpSession?.setMode(prompt.modeId);
+            acpState.currentModeId = prompt.modeId;
+        }
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        await entry.acpSession?.prompt(prompt.text, prompt.images);
+    }
+    canDrainAcpPromptQueue(entry) {
+        if (entry.snapshot.engine !== "acp" || entry.snapshot.connectionState !== "connected") {
+            return false;
+        }
+        if (!entry.acpSession || entry.acpQueueDrainActive) {
+            return false;
+        }
+        const acpState = this.ensureAcpState(entry);
+        return (acpState.permissions.length === 0
+            && acpState.questions.length === 0
+            && !this.isAcpBusy(acpState)
+            && acpState.queuedPrompts.length > 0);
+    }
+    async drainAcpPromptQueue(entry) {
+        if (!this.canDrainAcpPromptQueue(entry)) {
+            return;
+        }
+        const acpState = this.ensureAcpState(entry);
+        const nextPrompt = acpState.queuedPrompts[0];
+        if (!nextPrompt) {
+            return;
+        }
+        const drainingPromptId = nextPrompt.id;
+        entry.acpQueueDrainActive = true;
+        try {
+            if (nextPrompt.status !== "sending") {
+                nextPrompt.status = "sending";
+                entry.snapshot.updatedAt = new Date().toISOString();
+                this.schedulePersist();
+                this.emitSessionUpdated(entry);
+            }
+            await this.sendAcpPrompt(entry, nextPrompt);
+        }
+        catch (error) {
+            if (!isAcpPromptBusyError(error)) {
+                this.handleManagerError(entry.snapshot.clientSessionId, error);
+            }
+        }
+        finally {
+            entry.acpQueueDrainActive = false;
+            if (this.canDrainAcpPromptQueue(entry) && this.ensureAcpState(entry).queuedPrompts[0]?.id !== drainingPromptId) {
+                void this.drainAcpPromptQueue(entry);
+            }
+        }
+    }
+    recoverSendingQueuedPrompts(entry) {
+        const acpState = this.ensureAcpState(entry);
+        if (acpState.queuedPrompts.length === 0) {
+            return false;
+        }
+        let changed = false;
+        const canResumeQueueHead = acpState.permissions.length === 0
+            && acpState.questions.length === 0
+            && !this.isAcpBusy(acpState);
+        acpState.queuedPrompts = acpState.queuedPrompts.map((prompt, index) => {
+            if (prompt.status !== "sending") {
+                return prompt;
+            }
+            if (index === 0 && canResumeQueueHead) {
+                changed = true;
+                return { ...prompt, status: "queued" };
+            }
+            return prompt;
+        });
+        if (changed) {
+            entry.snapshot.updatedAt = new Date().toISOString();
+            this.schedulePersist();
+            this.emitSessionUpdated(entry);
+        }
+        return changed;
+    }
+    async startEngine(entry, resume) {
+        entry.snapshot.connectionState = "connecting";
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        if (entry.snapshot.engine === "cli") {
+            await this.startCliSession(entry, resume);
+            return;
+        }
+        await this.startAcpSession(entry, resume);
+    }
+    async stopEngine(entry, reason) {
+        entry.acpQueueDrainActive = false;
+        if (reason === "switch") {
+            entry.outputBuffer = "";
+        }
+        if (entry.cliSession) {
+            entry.cliExitExpected = true;
+            entry.cliSession.kill();
+            entry.cliSession = null;
+        }
+        if (entry.acpSession) {
+            await entry.acpSession.dispose();
+            entry.acpSession = null;
+        }
+    }
     async startCliSession(entry, resume) {
         const { snapshot } = entry;
+        if (!snapshot.sessionId) {
+            snapshot.sessionId = randomUUID();
+            this.bindSessionId(snapshot.clientSessionId, "", snapshot.sessionId, snapshot.workspacePath, false);
+        }
         try {
             const cliSession = new ClaudeCliSession({
                 workspacePath: snapshot.workspacePath,
@@ -196,8 +541,8 @@ export class SessionManager {
                 allowSkipPermissions: snapshot.allowSkipPermissions,
             });
             entry.cliSession = cliSession;
+            entry.cliExitExpected = false;
             cliSession.on("output", (data) => {
-                // Append to ring buffer so reconnecting clients can replay history
                 entry.outputBuffer += data;
                 if (entry.outputBuffer.length > SessionManager.OUTPUT_BUFFER_MAX) {
                     entry.outputBuffer = entry.outputBuffer.slice(-SessionManager.OUTPUT_BUFFER_MAX);
@@ -208,6 +553,12 @@ export class SessionManager {
                 });
             });
             cliSession.on("exit", (exitCode) => {
+                const expected = entry.cliExitExpected;
+                entry.cliExitExpected = false;
+                entry.cliSession = null;
+                if (expected) {
+                    return;
+                }
                 this.clearDiscoveryTimer(snapshot.clientSessionId);
                 snapshot.connectionState = "error";
                 snapshot.updatedAt = new Date().toISOString();
@@ -226,11 +577,572 @@ export class SessionManager {
             throw error;
         }
     }
+    async startAcpSession(entry, resume) {
+        if (!this.agentBinPath) {
+            throw new Error("ACP engine is unavailable.");
+        }
+        const acpSession = new ClaudeAcpSession({
+            workspacePath: entry.snapshot.workspacePath,
+            agentBinPath: this.agentBinPath,
+            claudeBin: this.claudeBin,
+            onEvent: (event) => this.handleAcpSessionEvent(entry.snapshot.clientSessionId, event),
+        });
+        entry.acpSession = acpSession;
+        await acpSession.connect();
+        if (resume && entry.snapshot.sessionId) {
+            entry.acpFullTimeline = [];
+            this.syncVisibleTimeline(entry);
+            const restorableSessionId = await acpSession.findRestorableSession(entry.snapshot.sessionId);
+            if (restorableSessionId) {
+                if (restorableSessionId !== entry.snapshot.sessionId) {
+                    this.bindSessionId(entry.snapshot.clientSessionId, entry.snapshot.sessionId, restorableSessionId, entry.snapshot.workspacePath, true);
+                }
+                await acpSession.loadSession(restorableSessionId);
+            }
+            else {
+                await acpSession.ensureSession();
+            }
+        }
+        else {
+            await acpSession.ensureSession();
+        }
+        const acpState = this.ensureAcpState(entry);
+        if (acpState.defaultModeId && acpState.currentModeId !== acpState.defaultModeId) {
+            await acpSession.setMode(acpState.defaultModeId);
+            acpState.currentModeId = acpState.defaultModeId;
+        }
+        entry.snapshot.connectionState = "connected";
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        this.recoverSendingQueuedPrompts(entry);
+        void this.drainAcpPromptQueue(entry);
+    }
+    handleAcpSessionEvent(clientSessionId, event) {
+        const entry = this.sessions.get(clientSessionId);
+        if (!entry) {
+            return;
+        }
+        const acpState = this.ensureAcpState(entry);
+        let shouldEmitFullSnapshot = false;
+        switch (event.type) {
+            case "ready":
+                entry.snapshot.connectionState = "connected";
+                entry.snapshot.workspacePath = event.payload.workspacePath;
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "system",
+                    title: "Claude ACP 已连接",
+                    body: event.payload.workspacePath,
+                });
+                shouldEmitFullSnapshot = true;
+                break;
+            case "session_created":
+                this.bindSessionId(clientSessionId, entry.snapshot.sessionId, event.payload.sessionId, entry.snapshot.workspacePath, false);
+                entry.snapshot.connectionState = "connected";
+                acpState.modes = event.payload.modes;
+                acpState.currentModeId = acpState.currentModeId || acpState.defaultModeId || "default";
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "system",
+                    title: "会话已创建",
+                    body: event.payload.sessionId,
+                    meta: labelForMode(acpState.currentModeId || acpState.defaultModeId),
+                });
+                shouldEmitFullSnapshot = true;
+                break;
+            case "session_restored":
+                this.bindSessionId(clientSessionId, entry.snapshot.sessionId, event.payload.sessionId, entry.snapshot.workspacePath, false);
+                entry.snapshot.connectionState = "connected";
+                acpState.modes = event.payload.modes;
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "system",
+                    title: "会话已恢复",
+                    body: event.payload.sessionId,
+                    meta: labelForMode(acpState.currentModeId || acpState.defaultModeId),
+                });
+                shouldEmitFullSnapshot = true;
+                break;
+            case "prompt_started":
+                acpState.busy = true;
+                this.appendTimeline(entry, {
+                    id: event.payload.promptId,
+                    kind: "user",
+                    title: "你",
+                    body: event.payload.text,
+                    images: event.payload.images,
+                });
+                break;
+            case "prompt_finished":
+                acpState.busy = shouldKeepAcpSessionRunningAfterPromptFinished(event.payload.stopReason);
+                if (acpState.queuedPrompts[0]?.status === "sending") {
+                    acpState.queuedPrompts.shift();
+                    shouldEmitFullSnapshot = true;
+                }
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "system",
+                    title: acpState.busy ? "等待待处理中" : "本轮完成",
+                    body: event.payload.stopReason,
+                });
+                break;
+            case "session_update":
+                this.consumeSessionUpdate(entry, event.payload);
+                break;
+            case "permission_requested": {
+                const normalizedTitle = normalizeAcpToolTitle(event.payload.toolCall.title) || undefined;
+                if (isAskUserQuestionTitle(normalizedTitle)) {
+                    const rawInput = asRecord(event.payload.toolCall.rawInput);
+                    const rawQuestions = Array.isArray(rawInput?.questions) ? rawInput.questions : [];
+                    const parsedQuestions = [];
+                    if (rawQuestions.length > 0) {
+                        for (const rawQ of rawQuestions) {
+                            const q = asRecord(rawQ);
+                            if (!q)
+                                continue;
+                            const questionStr = typeof q.question === "string" ? q.question : "";
+                            const headerStr = typeof q.header === "string" ? q.header : undefined;
+                            const rawOpts = Array.isArray(q.options) ? q.options : [];
+                            const options = rawOpts
+                                .map((opt) => {
+                                const o = asRecord(opt);
+                                if (!o)
+                                    return null;
+                                const label = typeof o.label === "string" ? o.label : "";
+                                const description = typeof o.description === "string" ? o.description : undefined;
+                                return label ? { id: label, label, description } : null;
+                            })
+                                .filter((o) => o !== null);
+                            parsedQuestions.push({
+                                question: questionStr,
+                                header: headerStr,
+                                options,
+                                allowCustomAnswer: true,
+                            });
+                        }
+                    }
+                    else {
+                        const questionText = typeof rawInput?.question === "string" ? rawInput.question : "";
+                        parsedQuestions.push({
+                            question: questionText,
+                            header: undefined,
+                            options: [],
+                            allowCustomAnswer: true,
+                        });
+                    }
+                    const groupId = randomUUID();
+                    const questionIds = [];
+                    for (const pq of parsedQuestions) {
+                        const questionId = randomUUID();
+                        questionIds.push(questionId);
+                        const questionSnapshot = {
+                            clientSessionId,
+                            questionId,
+                            groupId,
+                            question: pq.question,
+                            header: pq.header,
+                            options: pq.options,
+                            allowCustomAnswer: true,
+                        };
+                        acpState.questions.push(questionSnapshot);
+                        this.appendTimeline(entry, {
+                            id: questionId,
+                            kind: "system",
+                            title: "提问",
+                            body: pq.header ? `【${pq.header}】${pq.question}` : pq.question,
+                            meta: "pending",
+                        });
+                        this.askUserQuestionMap.set(questionId, {
+                            clientSessionId,
+                            requestId: event.payload.requestId,
+                        });
+                    }
+                    entry.snapshot.updatedAt = new Date().toISOString();
+                    this.schedulePersist();
+                    for (let i = 0; i < parsedQuestions.length; i += 1) {
+                        const pq = parsedQuestions[i];
+                        this.emit({
+                            type: "question_requested",
+                            payload: {
+                                clientSessionId,
+                                questionId: questionIds[i],
+                                groupId,
+                                question: pq.question,
+                                header: pq.header,
+                                options: pq.options,
+                                allowCustomAnswer: true,
+                            },
+                        });
+                    }
+                    return;
+                }
+                const permission = {
+                    clientSessionId,
+                    requestId: event.payload.requestId,
+                    toolCall: {
+                        toolCallId: event.payload.toolCall.toolCallId,
+                        title: normalizedTitle,
+                        status: event.payload.toolCall.status ?? undefined,
+                        rawInput: event.payload.toolCall.rawInput,
+                    },
+                    options: event.payload.options.map((option) => ({
+                        optionId: option.optionId,
+                        name: option.name,
+                        kind: option.kind,
+                    })),
+                };
+                acpState.permissions.push(permission);
+                this.appendTimeline(entry, {
+                    id: event.payload.requestId,
+                    kind: "tool",
+                    title: summarizeToolTitle(normalizedTitle, event.payload.toolCall.rawInput, event.payload.toolCall.toolCallId),
+                    body: formatToolDetails({
+                        toolCallId: event.payload.toolCall.toolCallId,
+                        title: normalizedTitle,
+                        status: event.payload.toolCall.status,
+                        rawInput: event.payload.toolCall.rawInput,
+                    }),
+                    meta: event.payload.toolCall.status ?? "pending",
+                });
+                break;
+            }
+            case "permission_resolved":
+                acpState.permissions = acpState.permissions.filter((permission) => permission.requestId !== event.payload.requestId);
+                entry.snapshot.acp = { ...acpState };
+                break;
+            case "question_requested": {
+                const questionSnapshot = {
+                    clientSessionId,
+                    questionId: event.payload.questionId,
+                    question: event.payload.question,
+                    options: event.payload.options.map((opt) => ({
+                        id: opt.id,
+                        label: opt.label,
+                    })),
+                    allowCustomAnswer: event.payload.allowCustomAnswer,
+                };
+                acpState.questions.push(questionSnapshot);
+                this.appendTimeline(entry, {
+                    id: event.payload.questionId,
+                    kind: "system",
+                    title: "提问",
+                    body: event.payload.question,
+                    meta: "pending",
+                });
+                break;
+            }
+            case "question_answered":
+                acpState.questions = acpState.questions.filter((question) => question.questionId !== event.payload.questionId);
+                entry.snapshot.acp = { ...acpState };
+                break;
+            case "error": {
+                const editChangeMessage = formatEditToolChangeMessage(event.payload.message);
+                if (editChangeMessage) {
+                    this.appendTimeline(entry, {
+                        id: randomUUID(),
+                        kind: "tool",
+                        title: editChangeMessage.title,
+                        body: editChangeMessage.body,
+                        meta: "completed",
+                    });
+                    break;
+                }
+                if (event.payload.fatal) {
+                    acpState.busy = false;
+                    entry.snapshot.connectionState = "error";
+                    shouldEmitFullSnapshot = true;
+                }
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "error",
+                    title: event.payload.fatal ? "错误" : "警告",
+                    body: event.payload.message,
+                });
+                break;
+            }
+        }
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        if (shouldEmitFullSnapshot) {
+            this.emitSessionUpdated(entry);
+        }
+        switch (event.type) {
+            case "prompt_started":
+                this.emit({
+                    type: "prompt_started",
+                    payload: {
+                        clientSessionId,
+                        promptId: event.payload.promptId,
+                        text: event.payload.text,
+                        images: event.payload.images,
+                    },
+                });
+                break;
+            case "prompt_finished":
+                this.emit({
+                    type: "prompt_finished",
+                    payload: {
+                        clientSessionId,
+                        promptId: event.payload.promptId,
+                        stopReason: event.payload.stopReason,
+                    },
+                });
+                break;
+            case "session_update":
+                this.emit({
+                    type: "session_update",
+                    payload: {
+                        clientSessionId,
+                        ...event.payload,
+                        sessionUpdate: event.payload.sessionUpdate,
+                    },
+                });
+                break;
+            case "permission_requested":
+                this.emit({
+                    type: "permission_requested",
+                    payload: {
+                        clientSessionId,
+                        requestId: event.payload.requestId,
+                        toolCall: {
+                            toolCallId: event.payload.toolCall.toolCallId,
+                            title: event.payload.toolCall.title ?? undefined,
+                            status: event.payload.toolCall.status ?? undefined,
+                            rawInput: event.payload.toolCall.rawInput,
+                        },
+                        options: event.payload.options.map((option) => ({
+                            optionId: option.optionId,
+                            name: option.name,
+                            kind: option.kind,
+                        })),
+                    },
+                });
+                break;
+            case "permission_resolved":
+                this.emit({
+                    type: "permission_resolved",
+                    payload: {
+                        clientSessionId,
+                        requestId: event.payload.requestId,
+                        optionId: event.payload.optionId,
+                    },
+                });
+                break;
+            case "question_requested":
+                this.emit({
+                    type: "question_requested",
+                    payload: {
+                        clientSessionId,
+                        questionId: event.payload.questionId,
+                        question: event.payload.question,
+                        options: event.payload.options.map((option) => ({
+                            id: option.id,
+                            label: option.label,
+                        })),
+                        allowCustomAnswer: event.payload.allowCustomAnswer,
+                    },
+                });
+                break;
+            case "question_answered":
+                this.emit({
+                    type: "question_answered",
+                    payload: {
+                        clientSessionId,
+                        questionId: event.payload.questionId,
+                        answer: event.payload.answer,
+                    },
+                });
+                break;
+            case "error":
+                this.emit({
+                    type: "error",
+                    payload: {
+                        clientSessionId,
+                        message: event.payload.message,
+                        fatal: event.payload.fatal,
+                    },
+                });
+                break;
+            default:
+                break;
+        }
+        if (event.type === "prompt_finished" || event.type === "permission_resolved" || event.type === "question_answered") {
+            void this.drainAcpPromptQueue(entry);
+        }
+    }
+    consumeSessionUpdate(entry, update) {
+        const acpState = this.ensureAcpState(entry);
+        switch (update.sessionUpdate) {
+            case "available_commands_update":
+                acpState.availableCommands = normalizeAvailableCommandsSnapshot(update.availableCommands ?? update.supportedCommands ?? update.commands);
+                entry.snapshot.acp = { ...acpState };
+                break;
+            case "agent_message_chunk": {
+                const chunkText = extractChunkText(update.content);
+                if (chunkText) {
+                    const parentId = extractParentToolCallId(update);
+                    this.appendTextChunk(entry, "agent", "Claude", chunkText, parentId);
+                }
+                break;
+            }
+            case "agent_thought_chunk": {
+                const chunkText = extractChunkText(update.content);
+                if (chunkText) {
+                    const parentId = extractParentToolCallId(update);
+                    this.appendTextChunk(entry, "thought", "思路", chunkText, parentId);
+                }
+                break;
+            }
+            case "tool_call":
+            case "tool_call_update": {
+                const claudeCodeMeta = asRecord(asRecord(update._meta)?.claudeCode);
+                const metaToolName = typeof claudeCodeMeta?.toolName === "string" ? claudeCodeMeta.toolName : undefined;
+                const normalizedTitle = normalizeAcpToolTitle(update.title) || normalizeAcpToolTitle(metaToolName) || undefined;
+                const parentToolCallId = extractParentToolCallId(update);
+                const effectiveStatus = isAskUserQuestionTitle(normalizedTitle) && update.status === "failed"
+                    ? "completed"
+                    : update.status;
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "tool",
+                    title: summarizeToolTitle(normalizedTitle, update.rawInput, update.toolCallId),
+                    body: formatToolDetails({
+                        toolCallId: update.toolCallId,
+                        title: normalizedTitle,
+                        status: effectiveStatus,
+                        rawInput: update.rawInput,
+                        rawOutput: update.rawOutput,
+                        parentToolCallId,
+                    }),
+                    meta: String(effectiveStatus ?? update.sessionUpdate),
+                });
+                break;
+            }
+            case "plan": {
+                const parentToolCallId = extractParentToolCallId(update);
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "system",
+                    title: "执行计划",
+                    body: stringifyMaybe(update.entries ?? update),
+                    parentToolCallId,
+                });
+                break;
+            }
+            case "current_mode_update":
+                acpState.currentModeId = String(update.currentModeId ?? acpState.currentModeId ?? "default");
+                this.appendTimeline(entry, {
+                    id: randomUUID(),
+                    kind: "system",
+                    title: "模式切换",
+                    body: String(update.currentModeId ?? "unknown"),
+                });
+                break;
+            default:
+                break;
+        }
+    }
+    ensureAcpState(entry) {
+        if (!entry.snapshot.acp) {
+            entry.snapshot.acp = createEmptyAcpState();
+        }
+        return entry.snapshot.acp;
+    }
+    appendTextChunk(entry, kind, title, text, parentToolCallId) {
+        const fullTimeline = this.ensureFullTimeline(entry);
+        const lastItem = fullTimeline.at(-1);
+        if (lastItem &&
+            lastItem.kind === kind &&
+            lastItem.title === title &&
+            !lastItem.meta &&
+            (lastItem.parentToolCallId ?? undefined) === parentToolCallId) {
+            lastItem.body += text;
+            this.syncVisibleTimeline(entry);
+            return;
+        }
+        this.appendTimeline(entry, {
+            id: randomUUID(),
+            kind,
+            title,
+            body: text,
+            parentToolCallId,
+        });
+    }
+    appendTimeline(entry, item) {
+        this.ensureFullTimeline(entry).push(item);
+        this.syncVisibleTimeline(entry);
+    }
+    syncVisibleTimeline(entry) {
+        const acpState = this.ensureAcpState(entry);
+        const fullTimeline = this.ensureFullTimeline(entry);
+        const total = fullTimeline.length;
+        const start = Math.max(0, total - SessionManager.INITIAL_TIMELINE_WINDOW);
+        acpState.timeline = fullTimeline.slice(start);
+        acpState.historyTotal = total;
+        acpState.historyStart = start;
+    }
+    ensureFullTimeline(entry) {
+        if (!Array.isArray(entry.acpFullTimeline)) {
+            entry.acpFullTimeline = [];
+        }
+        return entry.acpFullTimeline;
+    }
     emit(event) {
         for (const listener of this.listeners) {
             listener(event);
         }
     }
+    emitSessionUpdated(entry) {
+        this.emit({
+            type: "session_updated",
+            payload: this.snapshotForEvent(entry),
+        });
+    }
+    snapshotForEvent(entry) {
+        const blockedReason = this.getSwitchBlockedReason(entry);
+        const snapshot = structuredClone(entry.snapshot);
+        snapshot.switchable = !blockedReason;
+        snapshot.switchBlockedReason = blockedReason ?? undefined;
+        return snapshot;
+    }
+    getSwitchBlockedReason(entry) {
+        if (entry.switchInProgress) {
+            return "切换中";
+        }
+        if (entry.snapshot.connectionState === "connecting") {
+            return "连接中";
+        }
+        if (entry.snapshot.engine === "cli") {
+            if (entry.snapshot.activityState === "running")
+                return "运行中";
+            if (entry.snapshot.activityState === "pending")
+                return "待处理";
+            return null;
+        }
+        const acpState = entry.snapshot.acp;
+        if (!acpState) {
+            return null;
+        }
+        if (acpState.permissions.length > 0)
+            return "待审批";
+        if (acpState.questions.length > 0)
+            return "待提问";
+        if (this.isAcpBusy(acpState))
+            return "运行中";
+        if (acpState.queuedPrompts.length > 0)
+            return "队列未清空";
+        return null;
+    }
+    isAcpBusy(acpState) {
+        if (!acpState.busy) {
+            return false;
+        }
+        const latestItem = acpState.timeline.at(-1);
+        if (latestItem?.kind === "system" && latestItem.title === "本轮完成") {
+            return false;
+        }
+        return true;
+    }
     schedulePersist() {
         if (this.persistTimer) {
             clearTimeout(this.persistTimer);
@@ -246,8 +1158,12 @@ export class SessionManager {
             title: session.title,
             workspacePath: session.workspacePath,
             sessionId: session.sessionId,
+            engine: session.engine,
             updatedAt: session.updatedAt,
             allowSkipPermissions: session.allowSkipPermissions,
+            acpDefaultModeId: session.acp?.defaultModeId,
+            acpCurrentModeId: session.acp?.currentModeId,
+            acpQueuedPrompts: session.acp?.queuedPrompts ?? [],
         }));
         await mkdir(path.dirname(this.stateFilePath), { recursive: true });
         await writeFile(this.stateFilePath, JSON.stringify({ sessions: persistedSessions }, null, 2), "utf8");
@@ -297,43 +1213,59 @@ export class SessionManager {
             return false;
         }
     }
-    // ---------------------------------------------------------------------------
-    // /clear detection → session ID discovery
-    // ---------------------------------------------------------------------------
+    bindSessionId(clientSessionId, oldSessionId, newSessionId, workspacePath, emitChangeEvent) {
+        if (!newSessionId || oldSessionId === newSessionId) {
+            if (newSessionId) {
+                this.sessionIdIndex.set(newSessionId, clientSessionId);
+            }
+            return;
+        }
+        if (oldSessionId) {
+            this.sessionIdIndex.delete(oldSessionId);
+            this.activityMonitor.switchWatch(oldSessionId, newSessionId, workspacePath);
+        }
+        else {
+            this.activityMonitor.watch(newSessionId, workspacePath);
+        }
+        this.sessionIdIndex.set(newSessionId, clientSessionId);
+        const entry = this.sessions.get(clientSessionId);
+        if (entry) {
+            entry.snapshot.sessionId = newSessionId;
+            entry.snapshot.updatedAt = new Date().toISOString();
+            this.schedulePersist();
+        }
+        if (emitChangeEvent) {
+            this.emit({
+                type: "session_id_updated",
+                payload: { clientSessionId, newSessionId },
+            });
+        }
+    }
     handlePlanSessionDetected(newSessionId, promptId, workspacePath) {
         const oldSessionId = this.activityMonitor.getSessionIdByPromptId(promptId);
         if (!oldSessionId) {
-            console.log(`[SessionManager] handlePlanSessionDetected: no oldSessionId found for promptId ${promptId}`);
             return;
         }
         const clientSessionId = this.sessionIdIndex.get(oldSessionId);
         if (!clientSessionId) {
-            console.log(`[SessionManager] handlePlanSessionDetected: no clientSessionId found for oldSessionId ${oldSessionId}`);
             return;
         }
-        console.log(`[SessionManager] Plan session detected: ${oldSessionId} → ${newSessionId} (promptId=${promptId})`);
         this.completeSessionSwitch(clientSessionId, oldSessionId, newSessionId, workspacePath);
     }
     handleSessionClear(oldSessionId, workspacePath) {
         const clientSessionId = this.sessionIdIndex.get(oldSessionId);
         if (!clientSessionId) {
-            console.log(`[SessionManager] handleSessionClear: no clientSessionId found for ${oldSessionId}`);
             return;
         }
         const entry = this.sessions.get(clientSessionId);
         if (!entry) {
-            console.log(`[SessionManager] handleSessionClear: no entry found for clientSessionId ${clientSessionId}`);
             return;
         }
-        console.log(`[SessionManager] handleSessionClear: oldSessionId=${oldSessionId}, clientSessionId=${clientSessionId}, workspace=${workspacePath}`);
-        // Immediately mark as idle — the old session is done
         entry.snapshot.activityState = "idle";
         this.emit({
             type: "session_activity",
             payload: { clientSessionId, activityState: "idle" },
         });
-        // Delay 500ms before starting discovery — the new session file is created
-        // almost simultaneously with /clear in history.jsonl.
         const delayTimer = setTimeout(() => {
             this.startNewSessionDiscovery(clientSessionId, oldSessionId, workspacePath);
         }, 500);
@@ -342,44 +1274,40 @@ export class SessionManager {
     startNewSessionDiscovery(clientSessionId, oldSessionId, workspacePath) {
         const dirPath = projectDirPath(workspacePath);
         let pollCount = 0;
-        console.log(`[SessionManager] startNewSessionDiscovery: dir=${dirPath}, oldSession=${oldSessionId}`);
         const tryFind = async () => {
             try {
-                const files = (await readdir(dirPath)).filter((f) => f.endsWith(".jsonl"));
-                // Stat each file (except old session) to find the most recently modified ones
+                const files = (await readdir(dirPath)).filter((file) => file.endsWith(".jsonl"));
                 const candidates = [];
-                for (const f of files) {
-                    const sid = f.replace(/\.jsonl$/, "");
+                for (const file of files) {
+                    const sid = file.replace(/\.jsonl$/, "");
                     if (sid === oldSessionId)
                         continue;
                     try {
-                        const s = await stat(path.join(dirPath, f));
-                        candidates.push({ name: f, mtimeMs: s.mtimeMs });
+                        const fileStat = await stat(path.join(dirPath, file));
+                        candidates.push({ name: file, mtimeMs: fileStat.mtimeMs });
                     }
                     catch {
-                        // skip unreadable
+                        // ignore unreadable candidate
                     }
                 }
-                candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-                // Check the top 3 newest files for /clear content
+                candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
                 for (const candidate of candidates.slice(0, 3)) {
                     const filePath = path.join(dirPath, candidate.name);
                     let fd;
                     try {
                         fd = await open(filePath, "r");
-                        const buf = Buffer.alloc(4096);
-                        const { bytesRead } = await fd.read(buf, 0, 4096, 0);
-                        const head = buf.toString("utf8", 0, bytesRead);
+                        const buffer = Buffer.alloc(4096);
+                        const { bytesRead } = await fd.read(buffer, 0, 4096, 0);
+                        const head = buffer.toString("utf8", 0, bytesRead);
                         if (head.includes("<command-name>/clear</command-name>")) {
                             const newSessionId = candidate.name.replace(/\.jsonl$/, "");
-                            console.log(`[SessionManager] discovery confirmed new session: ${candidate.name} (contains /clear)`);
                             this.clearDiscoveryTimer(clientSessionId);
                             this.completeSessionSwitch(clientSessionId, oldSessionId, newSessionId, workspacePath);
                             return true;
                         }
                     }
                     catch {
-                        // skip
+                        // ignore
                     }
                     finally {
                         await fd?.close();
@@ -387,18 +1315,16 @@ export class SessionManager {
                 }
             }
             catch {
-                // Directory may not exist yet
+                // ignore
             }
             return false;
         };
-        // Immediate first attempt, then retry every 1s up to ~1 minute
         tryFind().then((found) => {
             if (found)
                 return;
             const timer = setInterval(async () => {
-                pollCount++;
+                pollCount += 1;
                 if (pollCount > SessionManager.DISCOVERY_MAX_POLLS) {
-                    console.log(`[SessionManager] discovery timed out for ${oldSessionId}`);
                     this.clearDiscoveryTimer(clientSessionId);
                     return;
                 }
@@ -411,22 +1337,9 @@ export class SessionManager {
         const entry = this.sessions.get(clientSessionId);
         if (!entry)
             return;
-        console.log(`[SessionManager] completeSessionSwitch: ${oldSessionId} → ${newSessionId} (client=${clientSessionId})`);
-        // Update reverse index
-        this.sessionIdIndex.delete(oldSessionId);
-        this.sessionIdIndex.set(newSessionId, clientSessionId);
-        // Update snapshot
-        entry.snapshot.sessionId = newSessionId;
+        this.bindSessionId(clientSessionId, oldSessionId, newSessionId, workspacePath, true);
         entry.snapshot.updatedAt = new Date().toISOString();
-        // Switch activity monitor to watch the new JSONL file
-        this.activityMonitor.switchWatch(oldSessionId, newSessionId, workspacePath);
-        // Persist so --resume uses the new session ID
         this.schedulePersist();
-        // Notify frontend
-        this.emit({
-            type: "session_id_updated",
-            payload: { clientSessionId, newSessionId },
-        });
     }
     clearDiscoveryTimer(clientSessionId) {
         const timer = this.discoveryTimers.get(clientSessionId);
@@ -435,25 +1348,19 @@ export class SessionManager {
             this.discoveryTimers.delete(clientSessionId);
         }
     }
-    // ---------------------------------------------------------------------------
-    // history.jsonl monitoring — detect /clear commands globally
-    // ---------------------------------------------------------------------------
     async startHistoryMonitor() {
-        // Get initial file size so we only process new lines
         try {
-            const stats = await stat(this.historyFilePath);
-            this.lastHistorySize = stats.size;
+            const historyStats = await stat(this.historyFilePath);
+            this.lastHistorySize = historyStats.size;
         }
         catch {
             this.lastHistorySize = 0;
         }
-        console.log(`[SessionManager] Watching ${this.historyFilePath} for /clear commands (initial size=${this.lastHistorySize})`);
         try {
             this.historyWatcher = watch(this.historyFilePath, () => {
                 this.scheduleHistoryCheck();
             });
             this.historyWatcher.on("error", () => {
-                // Fall back to polling if the watcher fails
                 this.historyWatcher?.close();
                 this.historyWatcher = null;
                 if (!this.historyPollTimer) {
@@ -464,7 +1371,6 @@ export class SessionManager {
             });
         }
         catch {
-            // Watcher unavailable — use polling
             this.historyPollTimer = setInterval(() => {
                 this.checkHistoryUpdates().catch(() => undefined);
             }, SessionManager.HISTORY_POLL_MS);
@@ -481,68 +1387,54 @@ export class SessionManager {
     async checkHistoryUpdates() {
         let fd;
         try {
-            const stats = await stat(this.historyFilePath);
-            // File was truncated or rotated — reset
-            if (stats.size < this.lastHistorySize) {
-                this.lastHistorySize = stats.size;
+            const historyStats = await stat(this.historyFilePath);
+            if (historyStats.size < this.lastHistorySize) {
+                this.lastHistorySize = historyStats.size;
                 return;
             }
-            // No new content
-            if (stats.size === this.lastHistorySize)
+            if (historyStats.size === this.lastHistorySize)
                 return;
-            const readSize = stats.size - this.lastHistorySize;
+            const readSize = historyStats.size - this.lastHistorySize;
             fd = await open(this.historyFilePath, "r");
             const buffer = Buffer.alloc(readSize);
             await fd.read(buffer, 0, readSize, this.lastHistorySize);
-            this.lastHistorySize = stats.size;
+            this.lastHistorySize = historyStats.size;
             const newText = buffer.toString("utf8");
-            const lines = newText.split("\n").filter((l) => l.trim().length > 0);
+            const lines = newText.split("\n").filter((line) => line.trim().length > 0);
             for (const line of lines) {
                 try {
                     const entry = JSON.parse(line);
                     if (entry.display === "/clear" && entry.sessionId) {
-                        // Check if we're tracking this session
                         const clientSessionId = this.sessionIdIndex.get(entry.sessionId);
                         if (clientSessionId) {
                             const managed = this.sessions.get(clientSessionId);
                             if (managed) {
-                                console.log(`[SessionManager] /clear detected in history.jsonl for session ${entry.sessionId} (client=${clientSessionId})`);
                                 this.handleSessionClear(entry.sessionId, managed.snapshot.workspacePath);
                             }
                         }
                     }
                 }
                 catch {
-                    // Skip malformed lines
+                    // ignore malformed line
                 }
             }
         }
         catch {
-            // File doesn't exist or unreadable — will retry on next trigger
+            // ignore
         }
         finally {
             await fd?.close();
         }
     }
-    stopHistoryMonitor() {
-        if (this.historyWatcher) {
-            this.historyWatcher.close();
-            this.historyWatcher = null;
-        }
-        if (this.historyPollTimer) {
-            clearInterval(this.historyPollTimer);
-            this.historyPollTimer = null;
-        }
-        if (this.historyDebounceTimer) {
-            clearTimeout(this.historyDebounceTimer);
-            this.historyDebounceTimer = null;
-        }
-    }
     handleManagerError(clientSessionId, error) {
         const entry = this.sessions.get(clientSessionId);
         if (!entry) {
             return;
         }
+        const acpState = entry.snapshot.acp;
+        if (acpState) {
+            acpState.busy = false;
+        }
         entry.snapshot.connectionState = "error";
         entry.snapshot.updatedAt = new Date().toISOString();
         this.schedulePersist();
@@ -556,6 +1448,205 @@ export class SessionManager {
         });
     }
 }
+function createEmptyAcpState(defaultModeId = "default", currentModeId = defaultModeId, queuedPrompts = []) {
+    return {
+        modes: [],
+        defaultModeId,
+        currentModeId,
+        busy: false,
+        timeline: [],
+        historyTotal: 0,
+        historyStart: 0,
+        permissions: [],
+        questions: [],
+        availableCommands: [],
+        queuedPrompts,
+    };
+}
+function normalizeQueuedPrompts(rawQueuedPrompts) {
+    if (!Array.isArray(rawQueuedPrompts)) {
+        return [];
+    }
+    return rawQueuedPrompts.flatMap((rawPrompt) => {
+        const record = asRecord(rawPrompt);
+        if (!record) {
+            return [];
+        }
+        const id = typeof record.id === "string" && record.id.trim() ? record.id : randomUUID();
+        const text = typeof record.text === "string" ? record.text : "";
+        const images = Array.isArray(record.images)
+            ? record.images.flatMap((rawImage) => {
+                const image = asRecord(rawImage);
+                if (!image || typeof image.data !== "string" || typeof image.mimeType !== "string") {
+                    return [];
+                }
+                return [{ data: image.data, mimeType: image.mimeType }];
+            })
+            : [];
+        const modeId = typeof record.modeId === "string" && record.modeId.trim() ? record.modeId : "default";
+        const createdAt = typeof record.createdAt === "string" && record.createdAt.trim()
+            ? record.createdAt
+            : new Date().toISOString();
+        const status = record.status === "sending" ? "sending" : "queued";
+        return [{ id, text, images, modeId, createdAt, status }];
+    });
+}
+function shouldKeepAcpSessionRunningAfterPromptFinished(stopReason) {
+    const normalized = stopReason.trim().toLowerCase();
+    return normalized === "pause_turn" || normalized === "pause-turn" || normalized.includes("permission");
+}
+function isAcpPromptBusyError(error) {
+    return error instanceof Error && error.message.includes("Another Claude prompt is still running.");
+}
+function stringifyMaybe(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value, null, 2);
+}
+function formatToolDetails(details) {
+    return stringifyMaybe({
+        toolCallId: details.toolCallId,
+        title: details.title,
+        status: details.status,
+        rawInput: details.rawInput,
+        rawOutput: details.rawOutput,
+        ...(details.parentToolCallId ? { parentToolCallId: details.parentToolCallId } : undefined),
+    });
+}
+function normalizeAcpToolTitle(rawTitle) {
+    if (typeof rawTitle !== "string")
+        return "";
+    return rawTitle.replace(/^mcp__acp__/i, "");
+}
+function summarizeToolTitle(rawTitle, rawInput, rawToolCallId) {
+    const title = normalizeAcpToolTitle(rawTitle).trim();
+    const record = asRecord(rawInput) ?? asRecord(tryParseJson(rawInput));
+    const normalizedTitle = title.toLowerCase();
+    const isSubagent = normalizedTitle.includes("subagent") || normalizedTitle === "task" || normalizedTitle.includes(" task");
+    if (isSubagent) {
+        const summary = readSubagentSummary(record);
+        if (summary) {
+            return `${title || "Task"} · ${summary}`;
+        }
+    }
+    if (title && !/^工具\s+tool_/.test(title) && !/^tool_/.test(title)) {
+        return title;
+    }
+    const command = typeof record?.command === "string"
+        ? record.command
+        : Array.isArray(record?.cmd)
+            ? record.cmd.filter((part) => typeof part === "string").join(" ")
+            : null;
+    const pathValue = typeof record?.path === "string"
+        ? record.path
+        : typeof record?.filePath === "string"
+            ? record.filePath
+            : typeof record?.cwd === "string"
+                ? record.cwd
+                : null;
+    const description = typeof record?.description === "string" ? record.description : null;
+    const args = Array.isArray(record?.args) ? record.args.filter((part) => typeof part === "string").join(" ") : null;
+    const summary = [command, pathValue, description, args].filter(Boolean).join(" · ");
+    if (summary) {
+        return summary;
+    }
+    if (title) {
+        return title;
+    }
+    return typeof rawToolCallId === "string" ? `工具 ${rawToolCallId}` : "工具调用";
+}
+function readSubagentSummary(record) {
+    if (!record) {
+        return null;
+    }
+    for (const key of ["title", "description"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    for (const key of ["rawInput", "input", "args", "payload", "params"]) {
+        if (!(key in record)) {
+            continue;
+        }
+        const nestedRecord = asRecord(record[key]) ?? asRecord(tryParseJson(record[key]));
+        const nested = readSubagentSummary(nestedRecord);
+        if (nested) {
+            return nested;
+        }
+    }
+    return null;
+}
+function tryParseJson(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return null;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function extractParentToolCallId(update) {
+    const meta = asRecord(update._meta);
+    const claudeCode = asRecord(meta?.claudeCode);
+    const parentId = claudeCode?.parentToolUseId;
+    return typeof parentId === "string" && parentId ? parentId : undefined;
+}
+function formatEditToolChangeMessage(message) {
+    const parsed = tryParseJson(message);
+    if (!Array.isArray(parsed) || parsed.length === 0) {
+        return null;
+    }
+    const files = parsed
+        .map((entry) => asRecord(entry))
+        .filter((entry) => Boolean(entry))
+        .map((entry) => {
+        const filePath = typeof entry.newFileName === "string"
+            ? entry.newFileName
+            : typeof entry.oldFileName === "string"
+                ? entry.oldFileName
+                : typeof entry.index === "string"
+                    ? entry.index
+                    : "";
+        const hunks = Array.isArray(entry.hunks) ? entry.hunks.length : 0;
+        return { filePath, hunks };
+    })
+        .filter((entry) => entry.filePath);
+    if (files.length === 0) {
+        return null;
+    }
+    const lines = files.map((entry) => `- ${entry.filePath}${entry.hunks > 0 ? `（${entry.hunks} 处修改）` : ""}`);
+    return {
+        title: `Edit 已修改 ${files.length} 个文件`,
+        body: `Edit 工具已更新以下文件：\n${lines.join("\n")}`,
+    };
+}
+function labelForMode(modeId) {
+    switch (modeId) {
+        case "default":
+            return "Default";
+        case "acceptEdits":
+            return "Accept Edits";
+        case "plan":
+            return "Plan";
+        case "dontAsk":
+            return "Don't Ask";
+        case "bypassPermissions":
+            return "Bypass Permissions";
+        default:
+            return modeId || "默认模式";
+    }
+}
 function formatError(error) {
     if (error instanceof Error) {
         return error.message;
@@ -567,6 +1658,95 @@ function formatError(error) {
         return String(error);
     }
 }
+function extractChunkText(content) {
+    if (!content) {
+        return null;
+    }
+    if (Array.isArray(content)) {
+        const joined = content.map((item) => extractChunkText(item)).filter((item) => Boolean(item)).join("\n");
+        return joined || null;
+    }
+    const record = asRecord(content);
+    if (!record) {
+        return null;
+    }
+    if (typeof record.text === "string" && record.text.trim()) {
+        return record.text;
+    }
+    if (record.type === "resource") {
+        const resource = asRecord(record.resource);
+        if (typeof resource?.text === "string" && resource.text.trim()) {
+            return resource.text;
+        }
+    }
+    if (record.type === "resource_link") {
+        const uri = typeof record.uri === "string" ? record.uri : "";
+        return uri ? `[resource] ${uri}` : "[resource]";
+    }
+    return null;
+}
+function normalizeAvailableCommandsSnapshot(rawValue) {
+    if (!Array.isArray(rawValue)) {
+        return [];
+    }
+    const seen = new Set();
+    const normalized = [];
+    for (const item of rawValue) {
+        if (typeof item === "string") {
+            const name = normalizeCommandName(item);
+            if (!name || seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            normalized.push({ name, description: "", inputType: "unstructured" });
+            continue;
+        }
+        const record = asRecord(item);
+        const rawName = typeof record?.name === "string"
+            ? record.name
+            : typeof record?.command === "string"
+                ? record.command
+                : "";
+        const name = normalizeCommandName(rawName);
+        if (!name || seen.has(name)) {
+            continue;
+        }
+        seen.add(name);
+        normalized.push({
+            name,
+            description: typeof record?.description === "string"
+                ? record.description.trim()
+                : typeof record?.title === "string"
+                    ? record.title.trim()
+                    : "",
+            inputType: "unstructured",
+        });
+    }
+    return normalized.sort((left, right) => left.name.localeCompare(right.name, "zh-Hans-CN"));
+}
+function normalizeCommandName(rawName) {
+    const trimmed = rawName.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function isAskUserQuestionTitle(title) {
+    if (!title)
+        return false;
+    const lower = title.toLowerCase();
+    return lower === "askuserquestion" || lower.startsWith("askuserquestion ");
+}
 export const sessionManagerTestables = {
+    stringifyMaybe,
+    formatToolDetails,
+    summarizeToolTitle,
+    normalizeAcpToolTitle,
+    isAskUserQuestionTitle,
+    asRecord,
+    extractChunkText,
+    normalizeAvailableCommandsSnapshot,
+    formatEditToolChangeMessage,
+    labelForMode,
     formatError,
 };