qlogicagent 2.13.4 → 2.13.5

package/dist/cli/stdio-server.js

@@ -0,0 +1,731 @@
+/**
+ * StdioServer — JSON-RPC 2.0 protocol handler.
+ *
+ * Receives JSON-RPC messages from a Transport, dispatches to handlers,
+ * writes JSON-RPC responses/notifications back through the Transport.
+ * All log output goes to stderr.
+ *
+ * Protocol: each message is a single JSON-RPC 2.0 object.
+ * The physical I/O layer is abstracted via the Transport interface.
+ */
+import { createRequire } from "node:module";
+import { StdioTransport } from "./transport.js";
+const _require = createRequire(import.meta.url);
+function loadPackageVersion() {
+    for (const packagePath of ["../package.json", "../../package.json"]) {
+        try {
+            return _require(packagePath).version;
+        }
+        catch {
+            // Source runs from src/cli, bundled npm runs from dist.
+        }
+    }
+    return "0.0.0";
+}
+const PKG_VERSION = loadPackageVersion();
+import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import { listSessions, } from "../runtime/session/session-persistence.js";
+import { TaskStore, buildTaskNotification } from "../runtime/infra/task-runtime.js";
+import { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
+import { isActiveProjectGroup } from "./project-context.js";
+import { runCleanupFunctions } from "../runtime/infra/cleanup-registry.js";
+import { getModelRegistry } from "../runtime/infra/model-registry.js";
+import { ensureLlmrouterDefaultBinding, refreshRegistryFromLlmrouterCatalog } from "../runtime/infra/llmrouter-catalog.js";
+import * as path from "node:path";
+import { AGENT_RPC_ERROR_CODES, } from "../protocol/wire/index.js";
+import { handleDream } from "./handlers/dream-handler.js";
+import { createRpcMethodRegistry } from "./rpc-registry.js";
+import { createCliAcpRequestHandler } from "./cli-acp-request-handler.js";
+import { AgentRuntimeSessionState } from "./agent-runtime-session-state.js";
+import { createMultiAgentHandlerHost } from "./multi-agent-handler-host.js";
+import { GatewayRpcConnection } from "./gateway-rpc-connection.js";
+import { ResolvedAgentCache } from "./resolved-agent-cache.js";
+import { classifyIncomingMessage } from "./acp-message-router.js";
+import { SessionContext } from "./session-context.js";
+import { createWorkflowHostAdapter } from "./workflow-host-adapter.js";
+import { SessionHistoryCoordinator } from "./session-history-coordinator.js";
+import { IdleDreamCoordinator } from "./idle-dream-coordinator.js";
+import { releaseUnusedTextGenerationKeyHandle, resolveModelClientForPurpose, resolveTextGenerationConfig } from "./model-client-resolver.js";
+import { handleMcpToolProxyCall } from "./mcp-tool-proxy.js";
+import { createAgentStatusNotification } from "./agent-status-notifier.js";
+import { createDreamHostAdapter } from "./dream-host-adapter.js";
+import { ensureDefaultProjectBootstrap } from "./default-project-bootstrap.js";
+import { PetConfirmCoordinator } from "./pet-confirm-coordinator.js";
+import { createAcpExtendedHostAdapter } from "./acp-extended-host-adapter.js";
+import { createCliProjectMemoryStoreFactory } from "./project-memory-store-factory.js";
+import { bootstrapStdioRuntimeServices } from "./stdio-runtime-bootstrap.js";
+import { bootstrapStdioAgentSession } from "./stdio-agent-session-bootstrap.js";
+import { createStdioRpcHandlerHosts } from "./stdio-rpc-handler-hosts.js";
+import { StdioAcpProtocolCoordinator } from "./stdio-acp-protocol-coordinator.js";
+import { createStdioAcpRequestHandlerHost } from "./stdio-acp-request-host.js";
+import { StdioSessionRuntimeCoordinator } from "./stdio-session-runtime-coordinator.js";
+// ── Cross-session continuation intent detection ──────────────────────────────
+/**
+ * Detect if a user's message implies they want to continue a conversation
+ * from another device/session (typically desktop).
+ *
+ * Matches common Chinese and English phrases indicating continuation intent.
+ * Deliberately conservative — only activates on clear continuation signals
+ * to avoid false positives that would inject irrelevant context.
+ */
+const CONTINUATION_PATTERNS = [
+    // Chinese
+    /继续(桌面|电脑|刚才|上次|之前)的/,
+    /接着(桌面|电脑|刚才|上次|之前)的/,
+    /刚才(那个|那件|说的|聊的|做的)/,
+    /上次(说到|聊到|做到|讲到)/,
+    /桌面(端|上)?(那个|那边|的任务|的对话|在做)/,
+    /电脑(端|上)?(那个|那边|的任务|的对话|在做)/,
+    /之前(那个|在做的|讨论的|说的)/,
+    /帮我继续/,
+    /接着(做|干|搞|写|改)/,
+    // English
+    /continue (from |where |the )?desktop/i,
+    /pick up where/i,
+    /what were we (doing|working on|talking about)/i,
+    /continue (the |our )?(last |previous )?(task|conversation|chat)/i,
+];
+const META_OPTIONAL_CONTROL_METHODS = new Set([
+    "thread.user_response",
+]);
+function detectContinuationIntent(text) {
+    if (!text || text.length < 3)
+        return false;
+    return CONTINUATION_PATTERNS.some(pattern => pattern.test(text));
+}
+export class StdioServer {
+    running = false;
+    startedAt = Date.now();
+    packageVersion = PKG_VERSION;
+    /** JSON-RPC request lifecycle: gateway contract, in-flight ledger, deadlines. */
+    rpc;
+    /** Gateway contract — exposed for control-handler metrics/cancel. */
+    get rpcContract() { return this.rpc.rpcContract; }
+    activeTurn = null;
+    /** Resolves when the active turn fully completes (including post-abort flush). */
+    turnDone = Promise.resolve();
+    verbose;
+    transport;
+    runtimeServices;
+    runtimeSession = new AgentRuntimeSessionState();
+    /**
+     * DERIVED resolved-agent cache (Agent + LLM client snapshot). The invalidation
+     * invariant (full wipe on registry change vs forget-agent on session dispose)
+     * is localized in ResolvedAgentCache. Host-pinned sessionLlmConfig is separate
+     * and never touched by it.
+     */
+    resolvedAgent = new ResolvedAgentCache();
+    /** Active session/turn identity + lifecycle (id/turn/state/taskDomain/llmConfig/acpMeta). */
+    session = new SessionContext();
+    currentMediaApiKeys = null;
+    taskStore = new TaskStore();
+    /** Unified background execution registry (agent forks + backgrounded shell commands). */
+    backgroundTasks = new BackgroundTaskManager(this.taskStore);
+    /** Settled-task notifications queued for injection into the next turn's context. */
+    pendingTaskNotifications = [];
+    /** Session-scoped memory prefetch state (LRU dedup + byte limit). */
+    memoryPrefetchState = createMemoryPrefetchState();
+    /** Last user message text for auto-extract hook (set at turn start, cleared at turn end).
+     * Public: the turn pipeline writes it through the ACP host adapter. */
+    lastUserMessageForAutoExtract;
+    /** Last assistant message text for implicit extraction hook (set at turn end).
+     * Public: the turn pipeline writes it through the ACP host adapter. */
+    lastAssistantMessageForExtract;
+    /** MEMDIR file-based memory (CC memdir parity). */
+    memdir = null;
+    projectMemoryStoreFactory = createCliProjectMemoryStoreFactory();
+    /** Memory write gate state (P2+P3: category gate + supersedes). */
+    /** Pending ask_user requests waiting for host response */
+    pendingAskUser = new Map();
+    /** Agents/solo/product handler facade. */
+    multiAgentHandlerHost;
+    /** Workflow handler host — carries toolCatalog + the lazy engine slots the multi-agent host lacks. */
+    workflowHandlerHost;
+    // Team budget state managed by runtimeVars singleton.
+    /** ACP protocol coordinator — owns AcpServer lifecycle and ACP event mapping. */
+    acp = new StdioAcpProtocolCoordinator();
+    sessionHistory = new SessionHistoryCoordinator();
+    idleDreamCoordinator;
+    sessionRuntime;
+    petConfirmCoordinator;
+    modelRegistryHydration = null;
+    get registry() {
+        return this.runtimeServices.providerRegistry;
+    }
+    get mediaClient() {
+        return this.runtimeServices.mediaClient;
+    }
+    get mediaPersistence() {
+        return this.runtimeServices.mediaPersistence;
+    }
+    get pathService() {
+        return this.runtimeServices.pathService;
+    }
+    get toolCatalog() {
+        return this.runtimeServices.toolCatalog;
+    }
+    /** Turn pipeline awaits this before tool dispatch (MCP servers connected). */
+    get mcpReady() {
+        return this.runtimeSession.mcpReady;
+    }
+    get petRuntime() {
+        return this.runtimeServices.petRuntime;
+    }
+    // Resolved-agent snapshot accessors — delegate to resolvedAgent. Kept as host
+    // members so the dream handler binding + coreToolHost read them unchanged.
+    get agent() { return this.resolvedAgent.agent; }
+    /** Cached LLM transport for sub-agent forks (dream). */
+    get currentTransport() { return this.resolvedAgent.transport; }
+    get currentApiKey() { return this.resolvedAgent.apiKey; }
+    get currentModel() { return this.resolvedAgent.model; }
+    get currentProvider() { return this.resolvedAgent.provider; }
+    get currentBaseUrl() { return this.resolvedAgent.baseUrl; }
+    // Session/turn identity + lifecycle — delegate to the session context so every
+    // reader AND writer (incl. handlers bound via the RPC host cast: session.create,
+    // thread.turn, set_config) passes through unchanged.
+    get currentSessionId() { return this.session.sessionId; }
+    set currentSessionId(v) { this.session.sessionId = v; }
+    get currentTurnId() { return this.session.turnId; }
+    set currentTurnId(v) { this.session.turnId = v; }
+    get sessionState() { return this.session.state; }
+    set sessionState(v) { this.session.state = v; }
+    get sessionTaskDomain() { return this.session.taskDomain; }
+    set sessionTaskDomain(v) { this.session.taskDomain = v; }
+    get sessionLlmConfig() { return this.session.llmConfig; }
+    set sessionLlmConfig(v) { this.session.llmConfig = v; }
+    get acpSessionMeta() { return this.session.acpMeta; }
+    set acpSessionMeta(v) { this.session.acpMeta = v; }
+    get currentHooks() {
+        return this.runtimeSession.currentHooks;
+    }
+    get permissionChecker() {
+        return this.runtimeSession.permissionChecker;
+    }
+    set permissionChecker(value) {
+        this.runtimeSession.permissionChecker = value;
+    }
+    set mcpManager(value) {
+        this.runtimeSession.mcpManager = value;
+    }
+    get memoryProvider() {
+        return this.runtimeSession.memoryProvider;
+    }
+    set memoryProvider(value) {
+        this.runtimeSession.memoryProvider = value;
+    }
+    get memoryDreamProvider() {
+        return this.runtimeSession.memoryDreamProvider;
+    }
+    set memoryDreamProvider(value) {
+        this.runtimeSession.memoryDreamProvider = value;
+    }
+    get memoryUserId() {
+        return this.runtimeSession.memoryUserId;
+    }
+    set memoryUserId(value) {
+        this.runtimeSession.memoryUserId = value;
+    }
+    constructor(config) {
+        this.verbose = config.verbose;
+        this.runtimeServices = bootstrapStdioRuntimeServices({
+            verbose: config.verbose,
+            getActiveProjectRoot: () => this.getActiveProjectRoot(),
+            resolveClientForPurpose: (purpose) => this.resolveClientForPurpose(purpose),
+            log: (message) => this.log(message),
+            sendNotification: (method, params) => this.sendNotification(method, params),
+        });
+        this.sessionRuntime = new StdioSessionRuntimeCoordinator({
+            runtimeSession: this.runtimeSession,
+            runtimeServices: this.runtimeServices,
+            resolvedAgent: this.resolvedAgent,
+            getMemoryProvider: () => this.memoryProvider,
+            getMemoryDreamProvider: () => this.memoryDreamProvider,
+            setMemoryPrefetchState: (state) => { this.memoryPrefetchState = state; },
+        });
+        this.petConfirmCoordinator = new PetConfirmCoordinator({
+            getPermissionResolver: () => this.permissionChecker,
+            sendNotification: (method, params) => this.sendNotification(method, params),
+        });
+        this.multiAgentHandlerHost = createMultiAgentHandlerHost({
+            getActiveProjectRoot: () => this.getActiveProjectRoot(),
+            emitAgentStatus: (agentId, state, extra) => this.emitAgentStatus(agentId, state, extra),
+            handleMcpToolCall: (memberId, toolName, args) => this.handleMcpToolCall(memberId, toolName, args),
+            log: (message) => this.log(message),
+            sendNotification: (method, params) => this.sendNotification(method, params),
+            sendResponse: (id, result, error) => this.sendResponse(id, result, error),
+        });
+        this.workflowHandlerHost = createWorkflowHostAdapter({
+            multiAgentHost: this.multiAgentHandlerHost,
+            getActiveProjectRoot: () => this.getActiveProjectRoot(),
+            getToolCatalog: () => this.toolCatalog,
+            handleMcpToolCall: (memberId, toolName, args) => this.handleMcpToolCall(memberId, toolName, args),
+            sendNotification: (method, params) => this.sendNotification(method, params),
+            sendResponse: (id, result, error) => this.sendResponse(id, result, error),
+        });
+        this.idleDreamCoordinator = new IdleDreamCoordinator({
+            log: (message) => this.log(message),
+            sendNotification: (method, params) => this.sendNotification(method, params),
+            getCurrentSessionId: () => this.currentSessionId,
+            getCurrentTurnCount: () => this.sessionState?.turnCount ?? 0,
+            getActiveTurn: () => this.activeTurn,
+            resolveDreamClient: () => this.resolveClientForPurpose("textGeneration"),
+            resolveMemoryRoot: () => path.join(this.pathService.getProjectAgentDir(this.getActiveProjectRoot()), "memory"),
+            resolveTranscriptDir: () => this.pathService.getProjectSessionsRoot(this.getActiveProjectRoot()),
+            listRecentSessions: () => listSessions(20, this.getActiveProjectRoot()),
+            runDream: (msg) => handleDream.call(this.createDreamHandlerHost(), msg),
+        });
+        // Subscribe to ModelRegistry changes → invalidate the resolved-agent cache so the
+        // next turn re-resolves. This clears DERIVED state only; the host-pinned
+        // sessionLlmConfig survives (a background catalog hydration finishing between a
+        // member's set_config pin and its first prompt must not strip its provider).
+        getModelRegistry().onChange(() => {
+            this.invalidateResolvedLlmCache();
+        });
+        void this.ensureModelRegistryHydrated().catch(() => undefined);
+        this.idleDreamCoordinator.applyEnvOverrides(process.env);
+        // Use injected transport or create a default StdioTransport
+        this.transport = config.transport ?? new StdioTransport({ verbose: config.verbose });
+        this.rpc = new GatewayRpcConnection({
+            write: (msg) => this.transport.send(msg),
+            log: (message) => this.log(message),
+        });
+        // Forward task state changes to host via JSON-RPC notification
+        this.taskStore.onTaskChange((taskId, task) => {
+            if (task) {
+                this.sendNotification("task.updated", {
+                    taskId,
+                    type: task.type,
+                    lifecycle: task.lifecycle,
+                    label: task.label,
+                });
+            }
+        });
+        // Queue settled background tasks as <task_notification> blocks for the
+        // next turn — the LLM learns about completion without polling.
+        // (Registry binding into tool-bootstrap happens in runtime-hook-bootstrap.)
+        this.backgroundTasks.onTaskSettled((task) => {
+            this.pendingTaskNotifications.push(buildTaskNotification(task, task.output ?? task.error ?? ""));
+        });
+        // MEMDIR initialization deferred to ensureDefaultProject (needs projectRoot)
+    }
+    /**
+     * Get the active project workspace directory.
+     * Reads from projectStore (single source of truth).
+     */
+    getActiveProjectRoot() {
+        return this.pathService.getActiveProjectRoot();
+    }
+    /**
+     * Drain queued background-task completion notifications.
+     * Called by the turn pipeline at turn start — settled tasks are injected
+     * into the model's context as <task_notification> blocks.
+     */
+    drainPendingTaskNotifications() {
+        if (this.pendingTaskNotifications.length === 0)
+            return [];
+        const drained = this.pendingTaskNotifications;
+        this.pendingTaskNotifications = [];
+        return drained;
+    }
+    async ensureModelRegistryHydrated() {
+        if (!this.modelRegistryHydration) {
+            this.modelRegistryHydration = (async () => {
+                const registry = getModelRegistry();
+                registry.load();
+                await refreshRegistryFromLlmrouterCatalog(registry);
+                // 零配置:全新安装(无默认文本模型)且网关注入了设备账号推理 key → 默认 DeepSeek@llmrouter。
+                ensureLlmrouterDefaultBinding(registry);
+                registry.save();
+            })().catch((err) => {
+                this.modelRegistryHydration = null;
+                const message = err instanceof Error ? err.message : String(err);
+                this.log(`[model-registry] failed to refresh llmrouter catalog: ${message}`);
+                throw err;
+            });
+        }
+        return this.modelRegistryHydration;
+    }
+    syncToolListMediaConfig() {
+        this.configureTurnMedia(undefined, this.currentTurnId || "tools-list");
+    }
+    configureTurnMedia(config, turnId) {
+        const thisServer = this;
+        this.runtimeServices.configureTurnMedia({
+            host: {
+                get currentMediaApiKeys() { return thisServer.currentMediaApiKeys; },
+                set currentMediaApiKeys(value) { thisServer.currentMediaApiKeys = value; },
+                get sessionState() { return thisServer.sessionState; },
+                sendNotification: (method, params) => this.sendNotification(method, params),
+            },
+            config,
+            turnId,
+        });
+    }
+    /**
+     * Single entry point for updating the active workdir.
+     * Centralizes all side-effects (bootstrap workdir, media persistence, etc.).
+     * Uses projectStore as the source of truth — no private field cache.
+     */
+    setActiveWorkdir(dir) {
+        this.pathService.setActiveWorkdir(dir);
+    }
+    start() {
+        this.running = true;
+        this.log("qlogicagent started, waiting for JSON-RPC messages...");
+        // Unified message dispatcher: ACP vs native gateway. Routing policy (which
+        // frames belong to ACP) lives in acp-message-router.ts.
+        this.transport.onMessage((parsed) => {
+            switch (classifyIncomingMessage(parsed, this.acp.active)) {
+                case "acp":
+                    this.acp.dispatchMessage(parsed);
+                    break;
+                case "legacy":
+                    this.handleMessage(parsed);
+                    break;
+                case "ignore":
+                    this.log(`[warn] ignoring non-request message`);
+                    break;
+            }
+        });
+        this.transport.onClose(() => {
+            this.log("transport closed, shutting down");
+            void this.stop();
+        });
+        this.transport.start();
+    }
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        // Cancel idle dream timer
+        this.cancelIdleDreamTimer();
+        this.rpc.dispose();
+        // Fire stop + session.ended for active session
+        if (this.currentSessionId && this.currentHooks) {
+            this.currentHooks.invoke("stop", {
+                sessionId: this.currentSessionId,
+                reason: "shutdown",
+            }).catch(() => { });
+            this.currentHooks.invoke("session.ended", { sessionId: this.currentSessionId }).catch(() => { });
+        }
+        try {
+            // Run registered cleanup functions (MCP, plugins, watchers, etc.)
+            await runCleanupFunctions();
+            this.runtimeSession.stopFileWatcher();
+            await this.runtimeSession.disconnectMcp();
+            this.runtimeSession.unregisterPermissions();
+            this.sessionRuntime.closeMemoryProviders();
+            // Abort active turn if any
+            if (this.activeTurn) {
+                this.activeTurn.abort();
+                this.activeTurn = null;
+            }
+            // Close transport
+            this.transport.close();
+        }
+        catch (err) {
+            // Fire stop.failed hook if cleanup throws
+            if (this.currentSessionId && this.currentHooks) {
+                this.currentHooks.invoke("stop.failed", {
+                    sessionId: this.currentSessionId,
+                    reason: "cleanup_error",
+                    error: err.message,
+                }).catch(() => { });
+            }
+        }
+        this.log("stopped");
+    }
+    // ── Method registry ──────────────────────────────────────────────────
+    methodHandlers = createRpcMethodRegistry(createStdioRpcHandlerHosts(this));
+    // ── Message dispatch ──────────────────────────────────────────────────
+    handleMessage(msg) {
+        if (msg.id !== undefined && !META_OPTIONAL_CONTROL_METHODS.has(msg.method)) {
+            // Gateway contract gate (meta validation + dedup + deadline). Returns false
+            // when the request was rejected/deduped and a response was already written.
+            if (!this.rpc.begin(msg.id, msg))
+                return;
+        }
+        const handler = this.methodHandlers.get(msg.method);
+        if (handler) {
+            // Handlers run concurrently (no await) so a long-running turn never blocks
+            // other RPCs. Guard against a handler that rejects/throws WITHOUT having sent
+            // a response: surface an INTERNAL_ERROR so the call terminates instead of
+            // hanging until its deadline. rpcIds is cleared once any response is sent
+            // (see sendResponse → clearRpcLifecycle), so this never double-responds.
+            const onHandlerError = (err) => {
+                if (msg.id !== undefined && this.rpc.hasInFlight(msg.id)) {
+                    this.sendResponse(msg.id, undefined, {
+                        code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                        message: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            };
+            try {
+                void Promise.resolve(handler(msg)).catch(onHandlerError);
+            }
+            catch (err) {
+                onHandlerError(err);
+            }
+        }
+        else if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+                message: `Unknown method: ${msg.method}`,
+            });
+        }
+    }
+    // ── Handlers ──────────────────────────────────────────────────────────
+    /**
+     * Ensure a default project exists on first start.
+     * Called from both legacy handleInitialize and ACP acpHandleInitialize.
+     */
+    ensureDefaultProject() {
+        this.memdir = ensureDefaultProjectBootstrap({
+            pathService: this.pathService,
+            projectMemoryStoreFactory: this.projectMemoryStoreFactory,
+            sendNotification: (method, params) => this.sendNotification(method, params),
+        });
+    }
+    // Side-operation model client helper.
+    /**
+     * Atomically resolve transport + model + apiKey for a given ModelPurpose.
+     * If the resolved provider matches `this.currentProvider`, reuses cached transport.
+     * Otherwise creates a one-shot client. Returns null if purpose is unresolvable.
+     * This ensures side-ops always use fresh model from registry.
+     */
+    resolveClientForPurpose(purpose) {
+        return resolveModelClientForPurpose({
+            purpose,
+            providerRegistry: this.registry,
+            currentProvider: this.currentProvider,
+            currentTransport: this.currentTransport,
+        });
+    }
+    // ── Dream handler — isolated sub-agent pipeline (CC forkedAgent parity) ──
+    // ── Memory provider (read-path lazy init) ────────────────────────────
+    /**
+     * Ensure the L2 SQLite memory provider exists for read-only RPCs
+     * (memory.atlas / memory.activity). These can be called before any turn has
+     * run, so they cannot rely on resolveAgent() having initialized the provider.
+     * Opening the DB is cheap and side-effect-free (list() does not embed).
+     */
+    ensureMemoryProvider() {
+        if (this.memoryProvider)
+            return;
+        const state = this.runtimeServices.ensureMemoryProvider(this.memoryUserId);
+        this.runtimeSession.memoryProvider = state.handlerProvider;
+        this.runtimeSession.memoryDreamProvider = state.dreamProvider;
+        this.runtimeSession.memoryUserId = state.userId;
+    }
+    // ── Agent resolution (lazy create / re-create on config change) ───────
+    resolveAgent(config) {
+        const resolvedTextConfig = resolveTextGenerationConfig(config, (message) => this.log(message));
+        if (!resolvedTextConfig) {
+            return null;
+        }
+        const { provider, model, apiKey, baseUrl, configKey } = resolvedTextConfig;
+        if (this.resolvedAgent.matches(configKey)) {
+            releaseUnusedTextGenerationKeyHandle(resolvedTextConfig);
+            // Cache hit: write back resolved values so callers see the final model/provider
+            config.model = model;
+            config.provider = provider;
+            config.apiKey = apiKey;
+            if (baseUrl)
+                config.baseUrl = baseUrl;
+            return this.agent;
+        }
+        // Write resolved values back so callers (agent.run) see the final model/provider/apiKey
+        config.model = model;
+        config.provider = provider;
+        config.apiKey = apiKey;
+        if (baseUrl)
+            config.baseUrl = baseUrl;
+        const bootstrapped = bootstrapStdioAgentSession({
+            config: config,
+            taskStore: this.taskStore,
+            backgroundTasks: this.backgroundTasks,
+            sessionId: this.currentSessionId ?? "",
+            getTurnId: () => this.currentTurnId,
+            projectRoot: this.getActiveProjectRoot(),
+            pathService: this.pathService,
+            memdir: this.memdir,
+            currentUserId: this.memoryUserId,
+            memoryPrefetchState: this.memoryPrefetchState,
+            getLastUserMessage: () => this.lastUserMessageForAutoExtract,
+            getLastAssistantMessage: () => this.lastAssistantMessageForExtract,
+            resolveSmallModelClient: () => this.resolveClientForPurpose("smallModel"),
+            resolvedTextConfig,
+            verbose: this.verbose,
+            providerRegistry: this.registry,
+            mediaPersistence: this.mediaPersistence,
+            toolCatalog: this.toolCatalog,
+            runtimeSession: this.runtimeSession,
+            setMcpManager: (manager) => { this.runtimeSession.mcpManager = manager; },
+            setMcpReady: (ready) => { this.runtimeSession.mcpReady = ready; },
+            setPluginLoader: (loader) => { this.runtimeSession.pluginLoader = loader; },
+            getAgent: () => this.agent,
+            getAcpPermissionSession: () => this.currentSessionId
+                ? this.acp.getPermissionSession(this.currentSessionId)
+                : undefined,
+            sendNotification: (method, params) => this.sendNotification(method, params),
+            isPetActive: () => this.petRuntime.isActive(),
+            coreToolHost: {
+                getAgent: () => this.agent,
+                getCurrentTransport: () => this.currentTransport,
+                getCurrentProvider: () => this.currentProvider,
+                getCurrentApiKey: () => this.currentApiKey,
+                getCurrentModel: () => this.currentModel,
+                getCurrentBaseUrl: () => this.currentBaseUrl,
+                getCurrentSessionId: () => this.currentSessionId,
+                getActiveProjectRoot: () => this.getActiveProjectRoot(),
+                getVerbose: () => this.verbose,
+                getBackgroundTasks: () => this.backgroundTasks,
+                getConversationHistory: () => this.currentSessionId ? this.sessionHistory.getResumedHistory(this.currentSessionId) : null,
+                isGroupContext: () => isActiveProjectGroup(),
+                getMemoryIndex: () => this.memdir?.getIndexForPrompt() || null,
+                sendNotification: (method, params) => this.sendNotification(method, params),
+                emitAgentStatus: (agentId, state, extra) => this.emitAgentStatus(agentId, state, extra),
+                handleMcpToolCall: (memberId, toolName, args) => this.handleMcpToolCall(memberId, toolName, args),
+            },
+            setFileWatcher: (watcher) => { this.runtimeSession.fileWatcher = watcher; },
+            log: (message) => this.log(message),
+        });
+        this.resolvedAgent.store({
+            agent: bootstrapped.agent,
+            transport: bootstrapped.agentClient.transport,
+            apiKey: bootstrapped.agentClient.apiKey,
+            model: bootstrapped.agentClient.model,
+            provider: bootstrapped.agentClient.provider,
+            baseUrl: bootstrapped.agentClient.baseUrl,
+            configKey,
+        });
+        this.log(`created Agent (provider: ${provider}, model: ${model})`);
+        return this.agent;
+    }
+    invalidateResolvedLlmCache() {
+        this.resolvedAgent.invalidate();
+        this.currentMediaApiKeys = null;
+    }
+    // ── Agent Status Notification Helper ──────────────────────────────
+    /** Emit an `agents.status` notification when a child process state changes. */
+    emitAgentStatus(agentId, state, extra) {
+        this.sendNotification("agents.status", createAgentStatusNotification(agentId, state, extra));
+    }
+    createDreamHandlerHost() {
+        return createDreamHostAdapter({
+            getActiveTurn: () => this.activeTurn,
+            setActiveTurn: (value) => { this.activeTurn = value; },
+            getCurrentTransport: () => this.currentTransport,
+            getCurrentApiKey: () => this.currentApiKey,
+            getCurrentModel: () => this.currentModel,
+            getCurrentHooks: () => this.currentHooks,
+            getMemoryProvider: () => this.memoryDreamProvider,
+            getMemoryUserId: () => this.memoryUserId,
+            getToolCatalog: () => this.runtimeServices.toolCatalog,
+            getTaskStore: () => this.taskStore,
+            getVerbose: () => this.verbose,
+            log: (message) => this.log(message),
+            resolveMemoryRoot: () => path.join(this.pathService.getProjectAgentDir(this.getActiveProjectRoot()), "memory"),
+            resolveTranscriptDir: () => this.pathService.getProjectSessionsRoot(this.getActiveProjectRoot()),
+            resolveAgent: (config) => this.resolveAgent(config),
+            sendNotification: (method, params) => this.sendNotification(method, params),
+            sendResponse: (id, result, error) => this.sendResponse(id, result, error),
+        });
+    }
+    createAcpExtendedHandlerHost() {
+        return createAcpExtendedHostAdapter({
+            dreamHost: this.createDreamHandlerHost(),
+            multiAgentHost: this.multiAgentHandlerHost,
+            getCurrentSessionId: () => this.currentSessionId,
+            getActiveProjectRoot: () => this.getActiveProjectRoot(),
+            log: (message) => this.log(message),
+            resolveAgent: (config) => this.resolveAgent(config),
+            sendNotification: (method, params) => this.sendNotification(method, params),
+            sendResponse: (id, result, error) => this.sendResponse(id, result, error),
+            emitAgentStatus: (agentId, state, extra) => this.emitAgentStatus(agentId, state, extra),
+            handleMcpToolCall: (memberId, toolName, args) => this.handleMcpToolCall(memberId, toolName, args),
+            resolveClientForPurpose: (purpose) => this.resolveClientForPurpose(purpose),
+            pendingAskUser: this.pendingAskUser,
+        });
+    }
+    /**
+     * Handle an MCP tool call proxied from an external ACP agent via the
+     * named-pipe bridge.  Dispatches the tool through the host's own tool
+     * system and returns the text result.
+     */
+    async handleMcpToolCall(memberId, toolName, args) {
+        return handleMcpToolProxyCall({
+            toolCatalog: this.toolCatalog,
+            memberId,
+            toolName,
+            args,
+        });
+    }
+    // ── I/O ───────────────────────────────────────────────────────────────
+    // Thin delegators to the gateway RPC connection (the request-lifecycle owner).
+    // Kept as methods so the dozens of handler/coordinator call sites stay unchanged.
+    sendResponse(id, result, error) {
+        this.rpc.sendResponse(id, result, error);
+    }
+    /**
+     * Send a JSON-RPC error response by (code, message, data) — convenience over
+     * sendResponse for handlers that build the error inline (e.g. session.moveToProject
+     * error paths call `this.sendError`).
+     */
+    sendError(id, code, message, data) {
+        this.rpc.sendError(id, code, message, data);
+    }
+    sendNotification(method, params) {
+        if (this.currentSessionId && this.acp.hasSession(this.currentSessionId)
+            && this.acp.emitUpdate(this.currentSessionId, method, params)) {
+            // Turn-scoped event mapped to an ACP session/update for this turn's session.
+        }
+        else {
+            // Raw JSON-RPC notification: legacy (no ACP session) OR a lifecycle/global event
+            // that ACP does not model (project.*, session.created, agents.status, …).
+            const msg = { jsonrpc: "2.0", method, params: params };
+            this.writeStdout(msg);
+        }
+        this.idleDreamCoordinator.handleTurnNotification(method);
+    }
+    writeStdout(msg) {
+        this.transport.send(msg);
+    }
+    log(message) {
+        if (this.verbose) {
+            process.stderr.write(`${JSON.stringify({
+                ts: new Date().toISOString(),
+                level: "info",
+                service: "qlogicagent",
+                message,
+            })}\n`);
+        }
+    }
+    // ── Idle Dream Scheduling ─────────────────────────────────────────────
+    /**
+     * Enable idle dream scheduling. Called after session setup when LLM config is available.
+     */
+    enableIdleDream(minutes) {
+        this.idleDreamCoordinator.enable(minutes);
+    }
+    cancelIdleDreamTimer() {
+        this.idleDreamCoordinator.cancelTimer();
+    }
+    disposeSessionRuntime() {
+        this.sessionRuntime.dispose();
+    }
+    // ── ACP Request Handler Implementation ────────────────────────────────
+    /**
+     * Initialize the ACP server alongside the legacy protocol.
+     * Called once when the host is an ACP-compliant client.
+     */
+    initAcpServer() {
+        const acpHost = createStdioAcpRequestHandlerHost(this);
+        const acpHandler = createCliAcpRequestHandler(acpHost, PKG_VERSION, this.createAcpExtendedHandlerHost());
+        this.acp.init(this.transport, acpHandler, { verbose: this.verbose });
+    }
+    /** Get the ACP server instance (for external wiring, e.g., main.ts). */
+    getAcpServer() {
+        return this.acp.getServer();
+    }
+}