qlogicagent 2.13.3 → 2.13.5

package/dist/cli/acp-session-handlers.js

@@ -0,0 +1,304 @@
+import { randomUUID } from "node:crypto";
+import { runtimeVars } from "../agent/runtime-vars.js";
+import { runTurnPipeline } from "./handlers/turn-handler.js";
+import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import { SessionState } from "../runtime/session/session-state.js";
+import { loadSessionForResume } from "../runtime/session/session-persistence.js";
+import { PERMISSION_MODES } from "../runtime/ports/permission-contracts.js";
+import { dispatchSlashCommand } from "./acp-commands.js";
+import { ACP_PROTOCOL_VERSION, } from "../protocol/wire/index.js";
+/**
+ * The standard ACP permission modes advertised to hosts (session/new `modes`). These map 1:1 to
+ * the runtime PERMISSION_MODES; set_mode writes the chosen id onto acpSessionMeta.permissions.mode
+ * and the next turn's syncTurnPermissionConfig applies it via the rule engine (single track).
+ */
+const ACP_PERMISSION_MODES = [
+    { id: "default", name: "默认", description: "按规则与风险逐项询问" },
+    { id: "auto", name: "自动", description: "低风险自动放行,高风险询问" },
+    { id: "full_access", name: "完全访问", description: "绕过所有规则,全部放行" },
+];
+/** Resolve the host's current permission mode (falls back to "default" when unset/invalid). */
+function currentModeId(host) {
+    const m = host.acpSessionMeta?.permissions?.mode;
+    return PERMISSION_MODES.includes(m) ? m : "default";
+}
+export async function handleAcpInitialize(host, params, packageVersion) {
+    const hostName = params.clientInfo?.name ?? "unknown";
+    host.log(`[acp] initialize: host=${hostName}`);
+    const capabilities = {
+        // Standard ACP session/load: history replay implemented (handleAcpSessionLoad).
+        loadSession: true,
+        qlogicagent: {
+            version: 1,
+            events: true,
+            methods: true,
+            orchestration: true,
+            configOptions: [
+                { name: "model", type: "string", description: "LLM model identifier" },
+                { name: "provider", type: "string", description: "LLM provider identifier" },
+                { name: "maxRounds", type: "number", description: "Max tool loop rounds" },
+                { name: "temperature", type: "number", description: "Sampling temperature" },
+            ],
+        },
+    };
+    host.ensureDefaultProject();
+    return {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentInfo: { name: "qlogicagent", version: packageVersion },
+        agentCapabilities: capabilities,
+    };
+}
+export async function handleAcpSessionNew(host, params) {
+    const sessionId = params.sessionId ?? randomUUID();
+    host.log(`[acp] session/new: id=${sessionId}`);
+    host.currentSessionId = sessionId;
+    host.sessionState = new SessionState(sessionId);
+    host.sessionTaskDomain = undefined;
+    host.memoryPrefetchState = createMemoryPrefetchState();
+    // Carry gateway-supplied per-session context (_meta) so every session/prompt inherits
+    // projectId/sessionType/group/assistant/permissions/reasoning. These have no standard
+    // ACP home — _meta is the agreed supplement (mirrors the legacy thread.turn config).
+    host.acpSessionMeta = { ...(params._meta ?? {}) };
+    // Pinned LLM config is per-session: a fresh session starts unpinned (the host
+    // re-pins via session/set_config_option after session/new if it wants one).
+    host.sessionLlmConfig = {};
+    if (params.cwd && typeof params.cwd === "string") {
+        host.setActiveWorkdir(params.cwd);
+    }
+    host.enableIdleDream();
+    return {
+        sessionId,
+        modes: { currentModeId: currentModeId(host), availableModes: ACP_PERMISSION_MODES },
+    };
+}
+/**
+ * Standard ACP session/load: point the host at an existing session and return its persisted
+ * history as display-only chunks for the server to replay. The backend turn context is NOT
+ * rebuilt here — every session/prompt hydrates history from disk via the turn pipeline's
+ * withResumedHistory, so load only needs to (a) make this the active session and (b) hand back
+ * the transcript for the host to render. Returns data only; the server owns the send path.
+ */
+export async function handleAcpSessionLoad(host, params) {
+    host.log(`[acp] session/load: id=${params.sessionId}`);
+    if (params.cwd && typeof params.cwd === "string") {
+        host.setActiveWorkdir(params.cwd);
+    }
+    host.currentSessionId = params.sessionId;
+    host.sessionState = new SessionState(params.sessionId);
+    const projectRoot = host.getActiveProjectRoot();
+    const persisted = await loadSessionForResume(params.sessionId, projectRoot);
+    if (!persisted)
+        return { replay: [] };
+    const replay = [];
+    for (const m of persisted.messages) {
+        // Replay only user/assistant turns; skip system/tool and empty content.
+        if ((m.role !== "user" && m.role !== "assistant") || !m.content)
+            continue;
+        replay.push({
+            type: m.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+            content: m.content,
+        });
+    }
+    return { replay };
+}
+/**
+ * Pre-prompt slash-command interception (data only). Extracts the leading text from the prompt; if
+ * it starts with "/", routes it through the single-source command registry (dispatchSlashCommand)
+ * and returns its {handled, reply}. Otherwise returns {handled:false} so the caller runs a normal
+ * turn. This NEVER emits session/update or runs a turn — the acp-server orchestrates the single
+ * send path (agent_message_chunk + result) when handled, keeping handleAcpSessionPrompt untouched.
+ */
+export async function tryDispatchCommand(host, params) {
+    const text = params.prompt
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("")
+        .trim();
+    if (!text.startsWith("/"))
+        return { handled: false };
+    return dispatchSlashCommand(host, text, "");
+}
+export async function handleAcpSessionPrompt(host, params) {
+    const turnId = randomUUID();
+    const sessionId = params.sessionId;
+    const pinned = host.sessionLlmConfig;
+    const hasExplicitLlmConfig = !!(pinned.provider && pinned.model && pinned.apiKey);
+    // Ensure the model-registry catalog is hydrated before the turn resolves its model. A spawned
+    // qlogicagent (Solo/Product competitor) only ran load() — its catalog is empty, so getActiveModel
+    // returns null → "No LLM provider". Awaiting here (idempotent, cached) lets it self-resolve its
+    // own owner-profile model, with no host-side injection.
+    try {
+        await host.ensureModelRegistryHydrated?.();
+    }
+    catch (err) {
+        if (!hasExplicitLlmConfig)
+            throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        host.log(`[acp] model registry hydration failed; continuing with explicit session LLM config: ${message}`);
+    }
+    // Decode ACP content blocks into a multimodal ChatMessage (Seam 1: media).
+    // Text is concatenated; image/video/audio URLs and pre-uploaded file ids are forwarded
+    // to the model (images flow to vision models; video/audio stay model-gated downstream).
+    let text = "";
+    const imageUrls = [];
+    const videoUrls = [];
+    const audioUrls = [];
+    const fileIds = [];
+    for (const block of params.prompt) {
+        switch (block.type) {
+            case "text":
+                text += block.text;
+                break;
+            case "image":
+                imageUrls.push(block.url);
+                break;
+            case "video":
+                videoUrls.push(block.url);
+                break;
+            case "audio":
+                audioUrls.push(block.url);
+                break;
+            case "file":
+                fileIds.push({ id: block.fileId, mimeType: block.mimeType, size: block.size });
+                break;
+        }
+    }
+    const userMessage = { role: "user", content: text };
+    if (imageUrls.length)
+        userMessage.imageUrls = imageUrls;
+    if (videoUrls.length)
+        userMessage.videoUrls = videoUrls;
+    if (audioUrls.length)
+        userMessage.audioUrls = audioUrls;
+    if (fileIds.length)
+        userMessage.fileIds = fileIds;
+    // Build the turn config from the session-level _meta baseline (session/new), overlaid with
+    // this prompt's per-turn _meta (permissions/reasoning change per turn), plus the
+    // host-PINNED LLM config (session/set_config_option · session/set_model · /model). Only the
+    // pin is overlaid — never the host's resolved-agent snapshot, which is derived state; without
+    // a pin, model/provider/key stay agent-resolved (ModelRegistry) every turn.
+    const config = {
+        ...(host.acpSessionMeta ?? {}),
+        ...(params._meta ?? {}),
+        ...(pinned.model ? { model: pinned.model } : {}),
+        ...(pinned.provider ? { provider: pinned.provider } : {}),
+        ...(pinned.apiKey ? { apiKey: pinned.apiKey } : {}),
+        ...(pinned.baseUrl ? { baseUrl: pinned.baseUrl } : {}),
+    };
+    // Run the shared turn pipeline (disk-backed history, project routing, persistence,
+    // title/summary) so session/prompt has full parity with the legacy thread.turn path.
+    const result = await runTurnPipeline.call(host, {
+        turnId,
+        sessionId,
+        messages: [userMessage],
+        tools: [],
+        config,
+    });
+    const usage = result.usage
+        ? {
+            inputTokens: result.usage.inputTokens ?? 0,
+            outputTokens: result.usage.outputTokens ?? 0,
+            cacheReadTokens: result.usage.cacheRead,
+            cacheWriteTokens: result.usage.cacheWrite,
+        }
+        : undefined;
+    // Standard ACP contract: the prompt result carries only { stopReason, usage? }.
+    // - A cancel (ABORTED) maps to the `cancelled` stop reason (a normal turn outcome).
+    // - Any other root error (NO_PROVIDER / INTERNAL_ERROR) is a JSON-RPC error: throw
+    //   with the error code so the acp-server dispatch layer translates it into a
+    //   JSON-RPC error response. Turn content/errors already streamed via notifications.
+    if (result.error && result.error.code !== "ABORTED") {
+        throw Object.assign(new Error(result.error.message ?? "turn failed"), { code: result.error.code });
+    }
+    const stopReason = result.error?.code === "ABORTED" ? "cancelled" : "end_turn";
+    return {
+        stopReason,
+        ...(usage ? { usage } : {}),
+        ...(result.model ? { model: result.model } : {}),
+        ...(result.provider ? { provider: result.provider } : {}),
+    };
+}
+export async function handleAcpSessionClose(host, params) {
+    host.log(`[acp] session/close: id=${params.sessionId}`);
+    if (host.currentSessionId === params.sessionId) {
+        host.cancelIdleDreamTimer();
+        if (host.currentHooks) {
+            await host.currentHooks.invoke("session.ended", { sessionId: params.sessionId }).catch(() => { });
+        }
+        host.currentSessionId = "";
+        host.sessionState = null;
+        host.sessionLlmConfig = {};
+        // Reset per-session accumulators (fork/team token budget) so a long-lived
+        // server process doesn't carry one session's spend into the next.
+        runtimeVars.resetAccumulators();
+        host.disposeSessionRuntime?.();
+    }
+}
+export async function handleAcpSessionSetConfig(host, params) {
+    const configId = params.configId ?? params.option;
+    host.log(`[acp] session/set_config: ${configId}=${JSON.stringify(params.value)}`);
+    const value = params.value;
+    const v = typeof value === "string" ? value : "";
+    switch (configId) {
+        // LLM fields pin onto the session config (survives ModelRegistry churn;
+        // the registry-change invalidation only clears derived resolution state).
+        case "model":
+            host.sessionLlmConfig.model = v;
+            break;
+        case "provider":
+            host.sessionLlmConfig.provider = v;
+            break;
+        case "apiKey":
+            host.sessionLlmConfig.apiKey = v;
+            break;
+        case "baseUrl":
+            host.sessionLlmConfig.baseUrl = v;
+            break;
+        // Runtime turn-config tweaks ride on the session-level _meta bag so the next
+        // session/prompt inherits them (no separate per-turn config wire needed).
+        case "reasoning": {
+            const effort = typeof value === "string"
+                ? value
+                : (value && typeof value === "object" ? value.effort : undefined);
+            if (effort)
+                (host.acpSessionMeta ??= {}).reasoning = { effort };
+            break;
+        }
+        case "temperature": {
+            const n = typeof value === "number" ? value : Number(v);
+            if (Number.isFinite(n))
+                (host.acpSessionMeta ??= {}).temperature = n;
+            break;
+        }
+        case "maxRounds": {
+            const n = typeof value === "number" ? value : Number(v);
+            if (Number.isFinite(n))
+                (host.acpSessionMeta ??= {}).maxRounds = n;
+            break;
+        }
+    }
+}
+export async function handleAcpSessionSetModel(host, _sessionId, model) {
+    host.log(`[acp] session/set_model: ${model} (note: model is managed by ModelRegistry, this is a hint only)`);
+    if (model) {
+        host.sessionLlmConfig.model = model;
+    }
+}
+/**
+ * Standard ACP session/set_mode: validate the requested permission mode and record it on the
+ * session-level acpSessionMeta.permissions bag. The rule engine is NOT touched here — the next
+ * session/prompt's syncTurnPermissionConfig reads permissions.mode and applies it (single track).
+ * Returns the applied modeId; the server emits current_mode_update. An unknown mode throws a coded
+ * error which the acp-server dispatch translates into a JSON-RPC error.
+ */
+export async function handleAcpSessionSetMode(host, _sessionId, modeId) {
+    if (!PERMISSION_MODES.includes(modeId)) {
+        throw Object.assign(new Error(`unknown mode: ${modeId}`), { code: "UNKNOWN_MODE" });
+    }
+    host.acpSessionMeta = {
+        ...(host.acpSessionMeta ?? {}),
+        permissions: { ...(host.acpSessionMeta?.permissions ?? {}), mode: modeId },
+    };
+    host.log(`[acp] session/set_mode applied: ${modeId}`);
+    return modeId;
+}

package/dist/cli/acp-session-handlers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/acp-session-handlers.test.js

@@ -0,0 +1,346 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { handleAcpSessionClose, handleAcpSessionLoad, handleAcpSessionNew, handleAcpSessionPrompt, handleAcpSessionSetConfig, handleAcpSessionSetMode, tryDispatchCommand, } from "./acp-session-handlers.js";
+import { runTurnPipeline } from "./handlers/turn-handler.js";
+import { loadSessionForResume } from "../runtime/session/session-persistence.js";
+import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+// The session/prompt seams route through the shared turn pipeline; mock it so we can assert on
+// the decoded message + inherited config without standing up a full runtime host.
+vi.mock("./handlers/turn-handler.js", () => ({ runTurnPipeline: vi.fn() }));
+// session/load replays persisted history; mock the disk read so we assert on the mapping only.
+vi.mock("../runtime/session/session-persistence.js", () => ({ loadSessionForResume: vi.fn() }));
+beforeEach(() => {
+    vi.mocked(runTurnPipeline).mockReset();
+    vi.mocked(loadSessionForResume).mockReset();
+});
+describe("handleAcpSessionNew", () => {
+    it("stores gateway _meta context for inheritance by subsequent prompts", async () => {
+        const host = {
+            currentSessionId: "",
+            sessionState: null,
+            sessionTaskDomain: "stale",
+            memoryPrefetchState: createMemoryPrefetchState(),
+            acpSessionMeta: null,
+            log: vi.fn(),
+            setActiveWorkdir: vi.fn(),
+            enableIdleDream: vi.fn(),
+        };
+        await handleAcpSessionNew(host, {
+            sessionId: "s9",
+            _meta: { projectId: "p9", sessionType: "group", reasoning: { effort: "high" } },
+        });
+        expect(host.currentSessionId).toBe("s9");
+        expect(host.acpSessionMeta).toEqual({ projectId: "p9", sessionType: "group", reasoning: { effort: "high" } });
+    });
+    it("returns the standard permission modes (3 modes + currentModeId=default)", async () => {
+        const host = {
+            currentSessionId: "",
+            sessionState: null,
+            sessionTaskDomain: "stale",
+            memoryPrefetchState: createMemoryPrefetchState(),
+            acpSessionMeta: null,
+            log: vi.fn(),
+            setActiveWorkdir: vi.fn(),
+            enableIdleDream: vi.fn(),
+        };
+        const res = await handleAcpSessionNew(host, { sessionId: "s1" });
+        expect(res.modes?.availableModes.map((m) => m.id)).toEqual(["default", "auto", "full_access"]);
+        expect(res.modes?.currentModeId).toBe("default");
+    });
+    it("reflects a previously-applied permission mode in currentModeId", async () => {
+        const host = {
+            currentSessionId: "",
+            sessionState: null,
+            sessionTaskDomain: "stale",
+            memoryPrefetchState: createMemoryPrefetchState(),
+            acpSessionMeta: { permissions: { mode: "full_access" } },
+            log: vi.fn(),
+            setActiveWorkdir: vi.fn(),
+            enableIdleDream: vi.fn(),
+        };
+        const res = await handleAcpSessionNew(host, { sessionId: "s2", _meta: { permissions: { mode: "full_access" } } });
+        expect(res.modes?.currentModeId).toBe("full_access");
+    });
+});
+describe("handleAcpSessionSetMode", () => {
+    function modeHost() {
+        return {
+            acpSessionMeta: null,
+            log: vi.fn(),
+        };
+    }
+    it("applies the mode to acpSessionMeta.permissions and returns the modeId", async () => {
+        const host = modeHost();
+        const applied = await handleAcpSessionSetMode(host, "s1", "full_access");
+        expect(applied).toBe("full_access");
+        expect(host.acpSessionMeta?.permissions?.mode).toBe("full_access");
+    });
+    it("preserves other acpSessionMeta fields when applying a mode", async () => {
+        const host = { acpSessionMeta: { projectId: "p1", permissions: { extra: true } }, log: vi.fn() };
+        await handleAcpSessionSetMode(host, "s1", "auto");
+        expect(host.acpSessionMeta).toMatchObject({
+            projectId: "p1",
+            permissions: { extra: true, mode: "auto" },
+        });
+    });
+    it("rejects an unknown mode with a coded error", async () => {
+        const host = modeHost();
+        await expect(handleAcpSessionSetMode(host, "s1", "bogus")).rejects.toMatchObject({ code: "UNKNOWN_MODE" });
+        expect(host.acpSessionMeta).toBeNull();
+    });
+});
+describe("handleAcpSessionPrompt (Stage 3 seams)", () => {
+    function promptHost(overrides = {}) {
+        return {
+            acpSessionMeta: null,
+            sessionLlmConfig: {},
+            ...overrides,
+        };
+    }
+    it("decodes multimodal blocks and inherits _meta context into the turn config", async () => {
+        const calls = [];
+        vi.mocked(runTurnPipeline).mockImplementation(function (input) {
+            calls.push({ self: this, input });
+            return Promise.resolve({ content: "done", usage: { inputTokens: 1, outputTokens: 2 } });
+        });
+        const host = promptHost({
+            acpSessionMeta: { projectId: "proj-1", sessionType: "group", groupKey: "g1", assistantId: "a1" },
+        });
+        const result = await handleAcpSessionPrompt(host, {
+            sessionId: "s1",
+            prompt: [
+                { type: "text", text: "hello " },
+                { type: "text", text: "world" },
+                { type: "image", url: "http://img/1.png" },
+                { type: "video", url: "http://v/1.mp4" },
+                { type: "audio", url: "http://a/1.mp3" },
+                { type: "file", fileId: "file-123", mimeType: "application/pdf", size: 9 },
+            ],
+        });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].self).toBe(host);
+        const msg = calls[0].input.messages[0];
+        expect(msg.content).toBe("hello world");
+        expect(msg.imageUrls).toEqual(["http://img/1.png"]);
+        expect(msg.videoUrls).toEqual(["http://v/1.mp4"]);
+        expect(msg.audioUrls).toEqual(["http://a/1.mp3"]);
+        expect(msg.fileIds).toEqual([{ id: "file-123", mimeType: "application/pdf", size: 9 }]);
+        expect(calls[0].input.config).toMatchObject({ projectId: "proj-1", sessionType: "group", groupKey: "g1", assistantId: "a1" });
+        // Standard-only ACP result: { stopReason, usage? } — no content/projectId/model/provider/error.
+        expect(Object.keys(result).sort()).toEqual(["stopReason", "usage"]);
+        expect(result.stopReason).toBe("end_turn");
+        expect(result.usage).toEqual({ inputTokens: 1, outputTokens: 2, cacheReadTokens: undefined, cacheWriteTokens: undefined });
+    });
+    it("awaits ensureModelRegistryHydrated before the turn (so a spawned competitor self-hydrates its model)", async () => {
+        const order = [];
+        const ensureModelRegistryHydrated = vi.fn(async () => { order.push("hydrate"); });
+        vi.mocked(runTurnPipeline).mockImplementation(async () => { order.push("turn"); return { content: "ok" }; });
+        await handleAcpSessionPrompt(promptHost({ ensureModelRegistryHydrated }), { sessionId: "s1", prompt: [{ type: "text", text: "hi" }] });
+        expect(ensureModelRegistryHydrated).toHaveBeenCalledTimes(1);
+        expect(order).toEqual(["hydrate", "turn"]); // catalog hydrated before the turn resolves the model
+    });
+    it("continues with explicit session LLM config when catalog hydration is unavailable", async () => {
+        const calls = [];
+        const ensureModelRegistryHydrated = vi.fn(async () => {
+            throw new Error("catalog unavailable");
+        });
+        vi.mocked(runTurnPipeline).mockImplementation(async (input) => {
+            calls.push(input);
+            return { content: "ok" };
+        });
+        const host = promptHost({
+            sessionLlmConfig: {
+                provider: "deepseek",
+                model: "deepseek-chat",
+                apiKey: "sk-test",
+                baseUrl: "https://api.deepseek.com/anthropic",
+            },
+            ensureModelRegistryHydrated,
+            log: vi.fn(),
+        });
+        const result = await handleAcpSessionPrompt(host, {
+            sessionId: "s1",
+            prompt: [{ type: "text", text: "hi" }],
+        });
+        expect(result.stopReason).toBe("end_turn");
+        expect(ensureModelRegistryHydrated).toHaveBeenCalledTimes(1);
+        expect(calls[0].config).toMatchObject({
+            provider: "deepseek",
+            model: "deepseek-chat",
+            apiKey: "sk-test",
+            baseUrl: "https://api.deepseek.com/anthropic",
+        });
+        expect(host.log).toHaveBeenCalledWith(expect.stringContaining("continuing with explicit session LLM config"));
+    });
+    it("a pinned LLM config (set_config) flows into the prompt turn config", async () => {
+        // Regression: a spawned team member is provisioned via session/set_config_option
+        // right after session/new. The pin must reach the turn config — it lives in
+        // sessionLlmConfig, which ModelRegistry-change invalidation never touches (the
+        // old current* fields were wiped by a background catalog hydration finishing
+        // between the pin and the first prompt → NO_PROVIDER on the reply turn).
+        const calls = [];
+        vi.mocked(runTurnPipeline).mockImplementation(async (input) => {
+            calls.push(input);
+            return { content: "ok" };
+        });
+        const host = promptHost({ log: vi.fn() });
+        await handleAcpSessionSetConfig(host, { sessionId: "s1", option: "provider", value: "deepseek" });
+        await handleAcpSessionSetConfig(host, { sessionId: "s1", option: "model", value: "deepseek-v4-flash" });
+        await handleAcpSessionSetConfig(host, { sessionId: "s1", option: "apiKey", value: "sk-member" });
+        await handleAcpSessionPrompt(host, { sessionId: "s1", prompt: [{ type: "text", text: "hi" }] });
+        expect(calls[0].config).toMatchObject({
+            provider: "deepseek",
+            model: "deepseek-v4-flash",
+            apiKey: "sk-member",
+        });
+    });
+    it("returns a standard-only result with no usage key when the pipeline reports none", async () => {
+        vi.mocked(runTurnPipeline).mockResolvedValue({ content: "hi" });
+        const result = await handleAcpSessionPrompt(promptHost(), { sessionId: "s1", prompt: [{ type: "text", text: "hi" }] });
+        expect(Object.keys(result)).toEqual(["stopReason"]);
+        expect(result.stopReason).toBe("end_turn");
+    });
+    it("applies runtime model/provider overrides into the turn config", async () => {
+        const calls = [];
+        vi.mocked(runTurnPipeline).mockImplementation((input) => {
+            calls.push(input);
+            return Promise.resolve({ content: "ok" });
+        });
+        const host = promptHost({ acpSessionMeta: {}, sessionLlmConfig: { model: "deepseek-chat", provider: "deepseek" } });
+        await handleAcpSessionPrompt(host, { sessionId: "s1", prompt: [{ type: "text", text: "see" }] });
+        expect(calls[0].messages[0].content).toBe("see");
+        expect(calls[0].config).toMatchObject({ model: "deepseek-chat", provider: "deepseek" });
+    });
+    it("overlays per-turn _meta over the session baseline in the turn config", async () => {
+        const calls = [];
+        vi.mocked(runTurnPipeline).mockImplementation((input) => {
+            calls.push(input);
+            return Promise.resolve({ content: "ok" });
+        });
+        const host = promptHost({
+            acpSessionMeta: { projectId: "p", reasoning: { effort: "low" }, permissions: { mode: "default" } },
+        });
+        await handleAcpSessionPrompt(host, {
+            sessionId: "s1",
+            prompt: [{ type: "text", text: "hi" }],
+            _meta: { reasoning: { effort: "high" }, permissions: { mode: "full_access" } },
+        });
+        // session baseline projectId kept; per-turn reasoning/permissions override.
+        expect(calls[0].config).toMatchObject({
+            projectId: "p",
+            reasoning: { effort: "high" },
+            permissions: { mode: "full_access" },
+        });
+    });
+    it("maps an aborted turn to the cancelled stop reason (no in-band error field)", async () => {
+        vi.mocked(runTurnPipeline).mockResolvedValue({
+            content: "",
+            error: { message: "Turn aborted", code: "ABORTED", recoverable: true },
+        });
+        const result = await handleAcpSessionPrompt(promptHost(), { sessionId: "s1", prompt: [{ type: "text", text: "hi" }] });
+        expect(result.stopReason).toBe("cancelled");
+        expect(Object.keys(result)).toEqual(["stopReason"]);
+        expect("error" in result).toBe(false);
+    });
+    it("throws a JSON-RPC-able error (with code) on a root error like NO_PROVIDER", async () => {
+        vi.mocked(runTurnPipeline).mockResolvedValue({
+            content: "",
+            error: { message: "No LLM provider configured", code: "NO_PROVIDER", recoverable: false },
+        });
+        await expect(handleAcpSessionPrompt(promptHost(), { sessionId: "s1", prompt: [{ type: "text", text: "hi" }] })).rejects.toMatchObject({ message: "No LLM provider configured", code: "NO_PROVIDER" });
+    });
+});
+describe("handleAcpSessionSetConfig (runtime tweaks)", () => {
+    it("routes reasoning/temperature into the _meta bag and model into the session pin", async () => {
+        const host = { acpSessionMeta: {}, sessionLlmConfig: {}, log: vi.fn() };
+        await handleAcpSessionSetConfig(host, { sessionId: "s1", option: "model", value: "m1" });
+        await handleAcpSessionSetConfig(host, { sessionId: "s1", option: "reasoning", value: { effort: "high" } });
+        await handleAcpSessionSetConfig(host, { sessionId: "s1", option: "temperature", value: 0.7 });
+        expect(host.sessionLlmConfig.model).toBe("m1");
+        expect(host.acpSessionMeta).toMatchObject({ reasoning: { effort: "high" }, temperature: 0.7 });
+    });
+});
+describe("handleAcpSessionClose", () => {
+    it("disposes session runtime resources when ending the active ACP session", async () => {
+        const disposeSessionRuntime = vi.fn();
+        const hooks = { invoke: vi.fn().mockResolvedValue(undefined) };
+        const host = {
+            currentSessionId: "session-1",
+            currentHooks: hooks,
+            cancelIdleDreamTimer: vi.fn(),
+            disposeSessionRuntime,
+            log: vi.fn(),
+            sessionState: {},
+        };
+        await handleAcpSessionClose(host, { sessionId: "session-1" });
+        expect(disposeSessionRuntime).toHaveBeenCalledOnce();
+        expect(host.currentSessionId).toBe("");
+        expect(host.sessionState).toBeNull();
+    });
+});
+describe("handleAcpSessionLoad", () => {
+    function loadHost() {
+        return {
+            currentSessionId: "",
+            sessionState: null,
+            acpSessionMeta: null,
+            log: vi.fn(),
+            setActiveWorkdir: vi.fn(),
+            getActiveProjectRoot: () => "/proj",
+        };
+    }
+    it("replays persisted history as user/agent chunks, skipping system/tool/empty", async () => {
+        vi.mocked(loadSessionForResume).mockResolvedValue({
+            metadata: {},
+            messages: [
+                { role: "user", content: "hi" },
+                { role: "assistant", content: "hello" },
+                { role: "system", content: "x" },
+                { role: "tool", content: "tool output" },
+                { role: "assistant", content: null },
+            ],
+        });
+        const host = loadHost();
+        const { replay } = await handleAcpSessionLoad(host, { sessionId: "s1" });
+        expect(replay).toEqual([
+            { type: "user_message_chunk", content: "hi" },
+            { type: "agent_message_chunk", content: "hello" },
+        ]);
+        expect(host.currentSessionId).toBe("s1");
+    });
+    it("returns an empty replay when the session has no persisted transcript", async () => {
+        vi.mocked(loadSessionForResume).mockResolvedValue(null);
+        const host = loadHost();
+        const { replay } = await handleAcpSessionLoad(host, { sessionId: "s2" });
+        expect(replay).toEqual([]);
+        expect(host.currentSessionId).toBe("s2");
+    });
+});
+describe("tryDispatchCommand", () => {
+    function cmdHost() {
+        return {
+            currentSessionId: "s1",
+            sessionState: { totalInputTokens: 0, totalOutputTokens: 0 },
+            currentModel: "",
+            getActiveProjectRoot: () => process.cwd(),
+            log: vi.fn(),
+        };
+    }
+    it("handles a leading-text /help prompt and yields a reply listing commands", async () => {
+        const r = await tryDispatchCommand(cmdHost(), { sessionId: "s1", prompt: [{ type: "text", text: "/help" }] });
+        expect(r.handled).toBe(true);
+        expect(r.reply).toContain("/help");
+    });
+    it("passes through a normal (non-slash) prompt", async () => {
+        const r = await tryDispatchCommand(cmdHost(), { sessionId: "s1", prompt: [{ type: "text", text: "你好" }] });
+        expect(r.handled).toBe(false);
+        expect(r.reply).toBeUndefined();
+    });
+    it("passes through an unknown slash command", async () => {
+        const r = await tryDispatchCommand(cmdHost(), { sessionId: "s1", prompt: [{ type: "text", text: "/nope" }] });
+        expect(r.handled).toBe(false);
+    });
+    it("does not treat a prompt with no text blocks as a command", async () => {
+        const r = await tryDispatchCommand(cmdHost(), { sessionId: "s1", prompt: [{ type: "image", url: "http://i/1.png" }] });
+        expect(r.handled).toBe(false);
+    });
+});