leduo-patrol 2.2.1 → 2.2.4

package/README.md

@@ -1,6 +1,10 @@
 # 乐多汪汪队 / leduo-patrol
 
-一个部署在服务器上的 Web 控制台，用来通过 ACP 驱动 Claude Code，并在浏览器里接收执行流、工具调用和权限确认。
+一个部署在服务器上的 Web 控制台，可在浏览器里用两种方式连接 Claude Code：
+- `CLI`：直接内嵌 Claude Code 终端
+- `ACP`：结构化时间线 / 权限 / 提问 / 图片输入视图
+
+两种引擎可在同一会话内切换，并共用同一个 Claude `sessionId`。
 
 ## Showcase
 
@@ -83,7 +87,10 @@
 - **目录浏览**：创建会话时可在允许根目录范围内浏览子目录，安全限制越权访问
 
 ### 工具与集成
-- **内置终端**：下方可展开终端抽屉，通过 xterm.js 提供完整 PTY 终端体验；服务端默认开启，可通过 `LEDUO_ENABLE_SHELL=false` 显式关闭
+- **双引擎会话**：同一 workspace 会话可在 `CLI` 和 `ACP` 之间切换；切换时复用 Claude `sessionId`
+- **CLI 终端**：主视图可直接运行 Claude Code 原生终端
+- **ACP 结构化视图**：支持时间线、权限确认、AskUserQuestion、多模态图片输入
+- **内置 Shell**：下方可展开终端抽屉，通过 xterm.js 提供完整 PTY shell；服务端默认开启，可通过 `LEDUO_ENABLE_SHELL=false` 显式关闭
 
 ### 界面与可访问性
 - **访问 Key 认证**：所有请求（HTTP / WebSocket）均需携带 key；浏览器检测到无效 key 时展示输入页
@@ -151,6 +158,7 @@ LEDUO_PATROL_APP_NAME=乐多汪汪队
 LEDUO_PATROL_WORKSPACE_PATH=/absolute/workspace/path
 LEDUO_PATROL_ALLOWED_ROOTS=/absolute/workspace/path,/another/allowed/root
 LEDUO_PATROL_CLAUDE_BIN=/absolute/path/to/claude
+LEDUO_PATROL_AGENT_BIN=/absolute/path/to/claude-code-acp
 LEDUO_PATROL_SHELL=/absolute/path/to/zsh
 ANTHROPIC_API_KEY=sk-...
 LEDUO_PATROL_ACCESS_KEY=your-fixed-key
@@ -161,6 +169,7 @@ LEDUO_ENABLE_SHELL=false
 如果未设置 `LEDUO_PATROL_WORKSPACE_PATH`，默认工作目录为启动命令所在目录（`process.cwd()`），并在启动日志中提示如何通过环境变量修改。
 如果未设置 `LEDUO_PATROL_ALLOWED_ROOTS`，默认允许根目录同样为启动命令所在目录，并会在启动日志中提示可配置项。
 如果发布安装后的内嵌终端无法启动，可通过 `LEDUO_PATROL_SHELL` 显式指定 shell 路径；例如 macOS 上常见的 `/bin/zsh`。
+如果 ACP agent 不在默认安装位置，可通过 `LEDUO_PATROL_AGENT_BIN` 显式指定 `claude-code-acp` 可执行文件。
 
 ## 状态持久化
 

package/dist/server/__tests__/acp-session.test.js

@@ -0,0 +1,115 @@
+import test, { mock } from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { ClaudeAcpSession, acpSessionTestables } from "../acp-session.js";
+function makeSession() {
+    return new ClaudeAcpSession({
+        workspacePath: "/tmp/workspace",
+        agentBinPath: "claude-code-acp",
+        claudeBin: "/tmp/custom-claude",
+        onEvent: () => undefined,
+    });
+}
+test("ClaudeAcpSession.resolveWorkspacePath allows path within workspace", () => {
+    const session = makeSession();
+    const resolved = session.resolveWorkspacePath("a/b.txt");
+    assert.equal(resolved, "/tmp/workspace/a/b.txt");
+});
+test("ClaudeAcpSession.resolveWorkspacePath rejects traversal", () => {
+    const session = makeSession();
+    assert.throws(() => session.resolveWorkspacePath("../etc/passwd"), /outside workspace/);
+});
+test("ClaudeAcpSession.resolvePermission rejects unknown request", async () => {
+    const session = makeSession();
+    await assert.rejects(() => session.resolvePermission("missing", "allow"), /not found|already resolved/);
+});
+test("ClaudeAcpSession.answerQuestion resolves pending question", async () => {
+    const session = makeSession();
+    const calls = [];
+    session.pendingQuestions.set("q-1", {
+        resolve: (value) => calls.push(value),
+        reject: () => undefined,
+    });
+    await session.answerQuestion("q-1", "好的");
+    assert.deepEqual(calls[0], { answer: "好的" });
+    assert.equal(session.pendingQuestions.size, 0);
+});
+test("ClaudeAcpSession.handleExtMethod routes leduo/ask_question", async () => {
+    const events = [];
+    const session = new ClaudeAcpSession({
+        workspacePath: "/tmp/workspace",
+        agentBinPath: "claude-code-acp",
+        onEvent: (event) => events.push(event),
+    });
+    const resultPromise = session.handleExtMethod("leduo/ask_question", {
+        question: "选择颜色",
+        options: [{ id: "red", label: "红色" }],
+        allowCustomAnswer: true,
+    });
+    const event = events[0];
+    assert.equal(event.type, "question_requested");
+    await session.answerQuestion(event.payload.questionId, "红色");
+    const result = await resultPromise;
+    assert.deepEqual(result, { answer: "红色" });
+});
+test("ClaudeAcpSession.findRestorableSession requires exact match when preferred id is provided", async () => {
+    const session = makeSession();
+    session.connection = {
+        unstable_listSessions: async () => ({
+            sessions: [{ sessionId: "other-session-id" }],
+        }),
+    };
+    const result = await session.findRestorableSession("missing-session-id");
+    assert.equal(result, null);
+});
+test("ClaudeAcpSession.findRestorableSession falls back to the first session when no preferred id is provided", async () => {
+    const session = makeSession();
+    session.connection = {
+        unstable_listSessions: async () => ({
+            sessions: [{ sessionId: "restorable-session-id" }],
+        }),
+    };
+    const result = await session.findRestorableSession();
+    assert.equal(result, "restorable-session-id");
+});
+test("ClaudeAcpSession.prompt emits prompt_started with images", async () => {
+    const events = [];
+    const session = new ClaudeAcpSession({
+        workspacePath: "/tmp/workspace",
+        agentBinPath: "claude-code-acp",
+        onEvent: (event) => events.push(event),
+    });
+    let promptPayload = null;
+    session.connection = {
+        prompt: async (payload) => {
+            promptPayload = payload;
+            return { stopReason: "end_turn" };
+        },
+    };
+    session.sessionId = "session-1";
+    session.sessionPromise = Promise.resolve("session-1");
+    session.waitForDrain = async () => undefined;
+    await session.prompt("hello", [{ data: "abc", mimeType: "image/png" }]);
+    const started = events[0];
+    assert.equal(started.type, "prompt_started");
+    assert.deepEqual(started.payload.images, [{ data: "abc", mimeType: "image/png" }]);
+    assert.deepEqual(promptPayload.prompt.map((block) => block.type), ["image", "text"]);
+});
+test("ClaudeAcpSession.connect rejects gracefully when the ACP agent spawn emits EAGAIN", async (t) => {
+    const fakeChild = new EventEmitter();
+    fakeChild.stdin = new PassThrough();
+    fakeChild.stdout = new PassThrough();
+    fakeChild.stderr = new PassThrough();
+    fakeChild.kill = (() => true);
+    const spawnMock = mock.method(acpSessionTestables, "spawnAgent", () => {
+        queueMicrotask(() => {
+            const error = Object.assign(new Error("resource temporarily unavailable"), { code: "EAGAIN" });
+            fakeChild.emit("error", error);
+        });
+        return fakeChild;
+    });
+    t.after(() => spawnMock.mock.restore());
+    const session = makeSession();
+    await assert.rejects(() => session.connect(), /Failed to start Claude ACP agent.*EAGAIN/);
+});

package/dist/server/__tests__/activity-monitor.test.js

@@ -8,12 +8,24 @@ test("assistant with stop_reason null → running", () => {
         message: { stop_reason: null, content: [{ type: "thinking" }] },
     }), "running");
 });
-test("assistant with stop_reason undefined → running", () => {
+test("assistant with text content and stop_reason undefined → completed", () => {
     assert.equal(determineActivityState({
         type: "assistant",
         message: { content: [{ type: "text" }] },
+    }), "completed");
+});
+test("assistant with thinking content and stop_reason undefined → running", () => {
+    assert.equal(determineActivityState({
+        type: "assistant",
+        message: { content: [{ type: "thinking" }] },
     }), "running");
 });
+test("assistant with tool_use content and stop_reason undefined → pending", () => {
+    assert.equal(determineActivityState({
+        type: "assistant",
+        message: { content: [{ type: "tool_use" }] },
+    }), "pending");
+});
 test("assistant with no message field → running", () => {
     assert.equal(determineActivityState({ type: "assistant" }), "running");
 });

package/dist/server/__tests__/session-manager.test.js

@@ -1,7 +1,386 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { sessionManagerTestables } from "../session-manager.js";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { SessionManager, sessionManagerTestables } from "../session-manager.js";
+function makeSnapshot(overrides = {}) {
+    return {
+        clientSessionId: "s1",
+        title: "demo",
+        workspacePath: process.cwd(),
+        connectionState: "connected",
+        activityState: "idle",
+        sessionId: "shared-session-id",
+        engine: "cli",
+        switchable: true,
+        updatedAt: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeEntry(overrides = {}) {
+    return {
+        snapshot: makeSnapshot(overrides),
+        cliSession: null,
+        cliExitExpected: false,
+        acpSession: null,
+        acpFullTimeline: [],
+        outputBuffer: "",
+        switchInProgress: false,
+        acpQueueDrainActive: false,
+    };
+}
+function makeAcpState(overrides = {}) {
+    return {
+        modes: ["default"],
+        defaultModeId: "default",
+        currentModeId: "default",
+        busy: false,
+        timeline: [],
+        historyTotal: 0,
+        historyStart: 0,
+        permissions: [],
+        questions: [],
+        availableCommands: [],
+        queuedPrompts: [],
+        ...overrides,
+    };
+}
+function makeManager(options) {
+    const manager = new SessionManager(options);
+    manager.activityMonitor.watch = () => undefined;
+    manager.activityMonitor.unwatch = () => undefined;
+    return manager;
+}
 test("sessionManagerTestables.formatError handles Error and objects", () => {
     assert.equal(sessionManagerTestables.formatError(new Error("boom")), "boom");
     assert.match(sessionManagerTestables.formatError({ code: 1 }), /"code":1/);
 });
+test("SessionManager.getAvailableEngines exposes ACP only when agent path exists", () => {
+    const cliOnly = makeManager({ allowedRoots: [process.cwd()] });
+    const dual = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    assert.deepEqual(cliOnly.getAvailableEngines(), ["cli"]);
+    assert.deepEqual(dual.getAvailableEngines(), ["cli", "acp"]);
+});
+test("SessionManager.switchEngine keeps the same Claude sessionId", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const started = [];
+    const stopped = [];
+    const events = [];
+    manager.startEngine = async (entry, resume) => {
+        started.push({ engine: entry.snapshot.engine, resume, sessionId: entry.snapshot.sessionId });
+        entry.snapshot.connectionState = "connected";
+    };
+    manager.stopEngine = async (entry) => {
+        stopped.push(entry.snapshot.engine);
+    };
+    manager.subscribe((event) => events.push(event.type));
+    manager.sessions.set("s1", makeEntry());
+    await manager.switchEngine("s1", "acp");
+    const entry = manager.sessions.get("s1");
+    assert.equal(entry.snapshot.engine, "acp");
+    assert.equal(entry.snapshot.sessionId, "shared-session-id");
+    assert.deepEqual(stopped, ["cli"]);
+    assert.deepEqual(started, [{ engine: "acp", resume: true, sessionId: "shared-session-id" }]);
+    assert.equal(events.at(-1), "session_updated");
+});
+test("SessionManager.switchEngine clears buffered CLI output before starting the target engine", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    manager.sessions.set("s1", {
+        ...makeEntry({ engine: "acp" }),
+        outputBuffer: "old cli output",
+    });
+    manager.startEngine = async (entry, resume) => {
+        assert.equal(entry.outputBuffer, "");
+        assert.equal(resume, true);
+        entry.snapshot.connectionState = "connected";
+    };
+    manager.stopEngine = SessionManager.prototype["stopEngine"].bind(manager);
+    await manager.switchEngine("s1", "cli");
+    const entry = manager.sessions.get("s1");
+    assert.equal(entry.outputBuffer, "");
+});
+test("SessionManager.createSession starts fresh CLI sessions and emits a connected snapshot", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const started = [];
+    const events = [];
+    manager.resolveRequestedWorkspace = async (requestedWorkspacePath) => requestedWorkspacePath;
+    manager.startEngine = async (entry, resume) => {
+        started.push({ engine: entry.snapshot.engine, resume, sessionId: entry.snapshot.sessionId });
+        entry.snapshot.connectionState = "connected";
+    };
+    manager.subscribe((event) => {
+        if (event.type === "session_registered" || event.type === "session_updated") {
+            events.push(event);
+        }
+    });
+    const snapshot = await manager.createSession("/tmp/fresh-cli-workspace", "fresh-cli", false, "cli");
+    assert.equal(snapshot.engine, "cli");
+    assert.ok(snapshot.sessionId);
+    assert.deepEqual(started, [{ engine: "cli", resume: false, sessionId: snapshot.sessionId }]);
+    assert.deepEqual(events.map((event) => event.type), ["session_registered", "session_updated"]);
+    assert.equal(events[0]?.payload.connectionState, "connecting");
+    assert.equal(events[1]?.payload.connectionState, "connected");
+});
+test("SessionManager.createSession emits an error snapshot when startup fails", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()] });
+    const events = [];
+    manager.resolveRequestedWorkspace = async (requestedWorkspacePath) => requestedWorkspacePath;
+    manager.startEngine = async (entry) => {
+        entry.snapshot.connectionState = "error";
+        throw new Error("boom");
+    };
+    manager.subscribe((event) => {
+        if (event.type === "session_registered" || event.type === "session_updated") {
+            events.push(event);
+        }
+    });
+    await assert.rejects(() => manager.createSession("/tmp/broken-cli-workspace", "broken-cli", false, "cli"), /boom/);
+    assert.deepEqual(events.map((event) => event.type), ["session_registered", "session_updated"]);
+    assert.equal(events[0]?.payload.connectionState, "connecting");
+    assert.equal(events[1]?.payload.connectionState, "error");
+});
+test("SessionManager.switchEngine rejects busy sessions", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    manager.sessions.set("s1", makeEntry({ activityState: "running" }));
+    manager.startEngine = async () => undefined;
+    manager.stopEngine = async () => undefined;
+    await assert.rejects(() => manager.switchEngine("s1", "acp"), /Session is not switchable: 运行中/);
+});
+test("SessionManager.switchEngine rejects pending ACP approvals", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    manager.sessions.set("s1", makeEntry({
+        engine: "acp",
+        acp: {
+            modes: ["default"],
+            defaultModeId: "default",
+            currentModeId: "default",
+            busy: false,
+            timeline: [],
+            historyTotal: 0,
+            historyStart: 0,
+            permissions: [{
+                    clientSessionId: "s1",
+                    requestId: "req-1",
+                    toolCall: { toolCallId: "tool-1", title: "Write" },
+                    options: [{ optionId: "allow", name: "允许", kind: "allow" }],
+                }],
+            questions: [],
+            availableCommands: [],
+            queuedPrompts: [],
+        },
+    }));
+    manager.startEngine = async () => undefined;
+    manager.stopEngine = async () => undefined;
+    await assert.rejects(() => manager.switchEngine("s1", "cli"), /Session is not switchable: 待审批/);
+});
+test("SessionManager.switchEngine allows idle ACP sessions despite stale activityState", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const started = [];
+    const stopped = [];
+    manager.sessions.set("s1", makeEntry({
+        engine: "acp",
+        activityState: "running",
+        acp: {
+            modes: ["default"],
+            defaultModeId: "default",
+            currentModeId: "default",
+            busy: false,
+            timeline: [],
+            historyTotal: 0,
+            historyStart: 0,
+            permissions: [],
+            questions: [],
+            availableCommands: [],
+            queuedPrompts: [],
+        },
+    }));
+    manager.startEngine = async (entry, resume) => {
+        started.push({ engine: entry.snapshot.engine, resume });
+        entry.snapshot.connectionState = "connected";
+    };
+    manager.stopEngine = async (entry) => {
+        stopped.push(entry.snapshot.engine);
+    };
+    await manager.switchEngine("s1", "cli");
+    assert.deepEqual(stopped, ["acp"]);
+    assert.deepEqual(started, [{ engine: "cli", resume: true }]);
+});
+test("SessionManager.switchEngine allows ACP sessions after end_turn even if busy flag is stale", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const started = [];
+    const stopped = [];
+    manager.sessions.set("s1", makeEntry({
+        engine: "acp",
+        acp: {
+            modes: ["default"],
+            defaultModeId: "default",
+            currentModeId: "default",
+            busy: true,
+            timeline: [{
+                    id: "done-1",
+                    kind: "system",
+                    title: "本轮完成",
+                    body: "end_turn",
+                }],
+            historyTotal: 1,
+            historyStart: 0,
+            permissions: [],
+            questions: [],
+            availableCommands: [],
+            queuedPrompts: [],
+        },
+    }));
+    manager.startEngine = async (entry, resume) => {
+        started.push({ engine: entry.snapshot.engine, resume });
+        entry.snapshot.connectionState = "connected";
+    };
+    manager.stopEngine = async (entry) => {
+        stopped.push(entry.snapshot.engine);
+    };
+    await manager.switchEngine("s1", "cli");
+    assert.deepEqual(stopped, ["acp"]);
+    assert.deepEqual(started, [{ engine: "cli", resume: true }]);
+});
+test("SessionManager.prompt queues ACP prompts while busy", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const promptCalls = [];
+    manager.sessions.set("s1", {
+        ...makeEntry({
+            engine: "acp",
+            acp: makeAcpState({ busy: true }),
+        }),
+        acpSession: {
+            setMode: async () => undefined,
+            prompt: async () => {
+                promptCalls.push("prompt");
+            },
+        },
+    });
+    await manager.prompt("s1", "queued hello");
+    const entry = manager.sessions.get("s1");
+    assert.equal(promptCalls.length, 0);
+    assert.equal(entry.snapshot.acp?.queuedPrompts.length, 1);
+    assert.equal(entry.snapshot.acp?.queuedPrompts[0]?.text, "queued hello");
+    assert.equal(entry.snapshot.acp?.queuedPrompts[0]?.status, "queued");
+    assert.equal(entry.snapshot.acp?.queuedPrompts[0]?.modeId, "default");
+});
+test("SessionManager.prompt sends immediately when ACP session is idle", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const setModeCalls = [];
+    const promptCalls = [];
+    manager.sessions.set("s1", {
+        ...makeEntry({
+            engine: "acp",
+            acp: makeAcpState(),
+        }),
+        acpSession: {
+            setMode: async (modeId) => {
+                setModeCalls.push(modeId);
+            },
+            prompt: async (text, images) => {
+                promptCalls.push({ text, images });
+            },
+        },
+    });
+    await manager.prompt("s1", "ship it", "plan", [{ data: "base64", mimeType: "image/png" }]);
+    const entry = manager.sessions.get("s1");
+    assert.deepEqual(setModeCalls, ["plan"]);
+    assert.deepEqual(promptCalls, [{ text: "ship it", images: [{ data: "base64", mimeType: "image/png" }] }]);
+    assert.equal(entry.snapshot.acp?.queuedPrompts.length, 0);
+});
+test("SessionManager.prompt keeps strict FIFO when queued prompts already exist", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const promptCalls = [];
+    manager.sessions.set("s1", {
+        ...makeEntry({
+            engine: "acp",
+            acp: makeAcpState({
+                queuedPrompts: [{
+                        id: "queued-1",
+                        text: "first",
+                        images: [],
+                        modeId: "default",
+                        createdAt: new Date().toISOString(),
+                        status: "queued",
+                    }],
+            }),
+        }),
+        acpSession: {
+            setMode: async () => undefined,
+            prompt: async () => {
+                promptCalls.push("prompt");
+            },
+        },
+    });
+    await manager.prompt("s1", "second");
+    const queuedPrompts = manager.sessions.get("s1").snapshot.acp?.queuedPrompts ?? [];
+    assert.equal(promptCalls.length, 1);
+    assert.deepEqual(queuedPrompts.map((prompt) => prompt.text), ["first", "second"]);
+    assert.deepEqual(queuedPrompts.map((prompt) => prompt.status), ["sending", "queued"]);
+});
+test("SessionManager.switchEngine rejects ACP sessions with queued prompts", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    manager.sessions.set("s1", makeEntry({
+        engine: "acp",
+        acp: makeAcpState({
+            queuedPrompts: [{
+                    id: "queued-1",
+                    text: "first",
+                    images: [],
+                    modeId: "default",
+                    createdAt: new Date().toISOString(),
+                    status: "queued",
+                }],
+        }),
+    }));
+    await assert.rejects(() => manager.switchEngine("s1", "cli"), /Session is not switchable: 队列未清空/);
+});
+test("SessionManager recovers persisted ACP queues and drains them on initialize", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "leduo-patrol-session-manager-"));
+    const stateFilePath = path.join(tempDir, "state.json");
+    const promptCalls = [];
+    const setModeCalls = [];
+    await writeFile(stateFilePath, JSON.stringify({
+        sessions: [{
+                clientSessionId: "persisted-acp",
+                title: "persisted",
+                workspacePath: process.cwd(),
+                sessionId: "shared-session-id",
+                engine: "acp",
+                updatedAt: new Date().toISOString(),
+                acpDefaultModeId: "default",
+                acpCurrentModeId: "default",
+                acpQueuedPrompts: [{
+                        id: "queued-1",
+                        text: "resume me",
+                        images: [{ data: "abc", mimeType: "image/png" }],
+                        modeId: "plan",
+                        createdAt: new Date().toISOString(),
+                        status: "sending",
+                    }],
+            }],
+    }), "utf8");
+    manager.stateFilePath = stateFilePath;
+    manager.isRestorableWorkspace = async () => true;
+    manager.startHistoryMonitor = async () => undefined;
+    manager.startEngine = async (entry) => {
+        entry.snapshot.connectionState = "connected";
+        entry.acpSession = {
+            setMode: async (modeId) => {
+                setModeCalls.push(modeId);
+            },
+            prompt: async (text, images) => {
+                promptCalls.push({ text, images });
+            },
+        };
+        manager.recoverSendingQueuedPrompts(entry);
+        await manager.drainAcpPromptQueue(entry);
+    };
+    await manager.initialize();
+    const restoredEntry = manager.sessions.get("persisted-acp");
+    assert.deepEqual(setModeCalls, ["plan"]);
+    assert.deepEqual(promptCalls, [{ text: "resume me", images: [{ data: "abc", mimeType: "image/png" }] }]);
+    assert.equal(restoredEntry.snapshot.acp?.queuedPrompts[0]?.status, "sending");
+});