qlogicagent 2.13.5 → 2.13.7

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

@@ -1,304 +0,0 @@
-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

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

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

@@ -1,346 +0,0 @@
-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);
-    });
-});