qlogicagent 2.13.5 → 2.13.6

package/dist/cli/stdio-server.js

@@ -1,731 +0,0 @@
-/**
- * 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();
-    }
-}