qlogicagent 2.12.8 → 2.12.10

package/dist/types/cli/acp-session-host.d.ts

@@ -2,6 +2,7 @@ import type { HookRegistry } from "../contracts/hooks.js";
 import type { AcpSessionMeta } from "../protocol/wire/index.js";
 import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
 import type { SessionState } from "../runtime/session/session-state.js";
+import type { SessionHistoryCoordinator } from "./session-history-coordinator.js";
 /**
  * LLM config pinned on the session by the host (session/set_config_option /
  * session/set_model / the /model command). This is host-supplied INPUT — distinct
@@ -25,6 +26,7 @@ export interface AcpSessionHost {
     currentHooks: HookRegistry | null;
     currentSessionId: string;
     memoryPrefetchState: ReturnType<typeof createMemoryPrefetchState>;
+    sessionHistory: Pick<SessionHistoryCoordinator, "saveResumedSession" | "withResumedHistory">;
     sessionState: SessionState | null;
     sessionTaskDomain: unknown;
     cancelIdleDreamTimer(): void;
@@ -41,5 +43,6 @@ export interface AcpSessionHost {
     ensureModelRegistryHydrated?(): Promise<void>;
     getActiveProjectRoot(): string;
     log(message: string): void;
+    sendNotification(method: string, params: Record<string, unknown>): void;
     setActiveWorkdir(dir: string): void;
 }

package/dist/types/cli/cli-agent-builder.d.ts

@@ -2,7 +2,7 @@ import { Agent } from "../agent/agent.js";
 import type { AgentLogger, ToolInvoker } from "../agent/types.js";
 import type { HookRegistry } from "../contracts/hooks.js";
 import { type LLMTransport, type ProviderRegistry } from "./provider-core-facade.js";
-import type { ResolvedTextGenerationConfig } from "./model-client-resolver.js";
+import { type ResolvedTextGenerationConfig } from "./model-client-resolver.js";
 export interface BuildCliAgentDeps {
     client: CliAgentClient;
     toolInvoker: ToolInvoker;

package/dist/types/cli/core-tools/config-tool-bootstrap.d.ts

@@ -1,9 +1,5 @@
 import type { ToolCatalog } from "../../runtime/ports/index.js";
 export interface ConfigToolRegistrationDeps {
     toolCatalog: ToolCatalog;
-    host: {
-        readonly currentModel: string;
-        readonly verbose: boolean;
-    };
 }
-export declare function registerConfigTool({ host, toolCatalog }: ConfigToolRegistrationDeps): void;
+export declare function registerConfigTool({ toolCatalog }: ConfigToolRegistrationDeps): void;

package/dist/types/cli/core-tools/config-tool-service.d.ts

@@ -1,7 +1,11 @@
-import { type ConfigToolDeps } from "../../skills/tools/config-tool.js";
+/**
+ * Config tool service — backs the `config` tool onto the REAL tunables system
+ * (settings.tunables.*), the same store the UI settings page manages via the
+ * config.updateTunable RPC. ModelRegistry.getTunable() re-reads settings.json
+ * per call, so every write here is hot — no restart needed.
+ */
+import type { ConfigToolDeps } from "../../skills/tools/config-tool.js";
 export interface ConfigToolServiceOptions {
-    currentModel: string;
-    verbose: boolean;
-    configFilePath?: string;
+    settingsPath?: string;
 }
-export declare function createConfigToolService(options: ConfigToolServiceOptions): ConfigToolDeps;
+export declare function createConfigToolService(options?: ConfigToolServiceOptions): ConfigToolDeps;

package/dist/types/cli/core-tools/registry.d.ts

@@ -4,6 +4,5 @@ import { type ConfigToolRegistrationDeps } from "./config-tool-bootstrap.js";
 import { type CronToolRegistrationDeps } from "./cron-tool-bootstrap.js";
 import { type MonitorToolRegistrationDeps } from "./monitor-tool-bootstrap.js";
 import { type TeamToolRegistrationDeps } from "./team-tool-bootstrap.js";
-import { type UtilityToolRegistrationDeps } from "./utility-tool-bootstrap.js";
-export type CoreToolSetRegistrationDeps = AgentToolRegistrationDeps & CheckpointToolRegistrationDeps & ConfigToolRegistrationDeps & CronToolRegistrationDeps & MonitorToolRegistrationDeps & Omit<TeamToolRegistrationDeps, "teamRegistry"> & Omit<UtilityToolRegistrationDeps, "teamRegistry">;
+export type CoreToolSetRegistrationDeps = AgentToolRegistrationDeps & CheckpointToolRegistrationDeps & ConfigToolRegistrationDeps & CronToolRegistrationDeps & MonitorToolRegistrationDeps & Omit<TeamToolRegistrationDeps, "teamRegistry">;
 export declare function registerCoreToolSet(deps: CoreToolSetRegistrationDeps): void;

package/dist/types/cli/core-tools/session-tool-manifest.d.ts

@@ -0,0 +1,12 @@
+import type { CapabilityCategory } from "../../skills/portable-tool.js";
+export interface SessionToolManifestEntry {
+    name: string;
+    label: string;
+    description: string;
+    category: CapabilityCategory;
+    /** Registered per-session by the runtime bootstrap, not in the static catalog. */
+    sessionScoped: true;
+    /** The live registration is deferred (loaded on demand via tool_search). */
+    deferred?: true;
+}
+export declare const SESSION_TOOL_MANIFEST: SessionToolManifestEntry[];

package/dist/types/cli/core-tools/team-registry.d.ts

@@ -1,14 +1,14 @@
 /**
- * TeamRegistry — session-scoped roster shared by the team tool (producer)
- * and the send_message tool (consumer).
+ * TeamRegistry — session-scoped roster for the team tool: create registers
+ * members (producer), the send action routes messages to them (consumer).
  *
  * The team tool spawns each member as a real subprocess agent
- * (AgentProcessManager) and registers a delivery closure here. send_message
- * looks the target up by name or full member id and routes the message into
- * the member's process via that closure, returning the member's reply.
+ * (AgentProcessManager) and registers a delivery closure here. The send
+ * action looks the target up by name or full member id and routes the message
+ * into the member's process via that closure, returning the member's reply.
  *
- * This is the ONLY bridge between the two tools — send_message has no other
- * way to reach team members, so an unregistered/dead target fails loud.
+ * This registry is the ONLY routing path to team members, so an
+ * unregistered/dead target fails loud.
  */
 export interface TeamRegistryMember {
     /** Full member id, e.g. "team-research-coder". */
@@ -48,7 +48,7 @@ export declare class TeamRegistry {
     /** Live roster (alive flag reflects the underlying process). */
     list(): TeamRegistryListEntry[];
     /**
-     * Resolve a send_message `to` token to concrete members.
+     * Resolve a send `to` token to concrete members.
      * Accepts a member name ("coder"), a full member id ("team-x-coder"),
      * or "*" for broadcast to all alive members.
      * Returns [] when nothing matches (caller fails loud).

package/dist/types/cli/dev-tools/dev-tool-registry.d.ts

@@ -1,7 +1,6 @@
 import { createLspTool } from "../../skills/tools/lsp-tool.js";
-import { createReplTool } from "../../skills/tools/repl-tool.js";
 export interface DevToolRegistryOptions {
     workdir: string;
 }
-export type DevTool = ReturnType<typeof createReplTool> | ReturnType<typeof createLspTool>;
+export type DevTool = ReturnType<typeof createLspTool>;
 export declare function buildDevTools(options: DevToolRegistryOptions): DevTool[];

package/dist/types/cli/gateway-rpc-connection.d.ts

@@ -0,0 +1,50 @@
+/**
+ * GatewayRpcConnection — the JSON-RPC request lifecycle for the gateway contract.
+ *
+ * Owns the per-request bookkeeping: the gateway contract (dedup/settle/expire), the
+ * in-flight request ledger (id → meta), and the deadline timers; plus the wire-side
+ * response builders. Extracted from StdioServer to separate its "protocol routing"
+ * concern from its "runtime state container" concern — StdioServer keeps the
+ * transport, message dispatch, and ACP routing, and delegates the request-lifecycle
+ * mechanics here through thin sendResponse/sendError methods.
+ *
+ * It does NOT own the transport: the raw frame writer is injected via `write`, so the
+ * server stays in charge of transport ownership / start / close / ACP routing.
+ *
+ * Covered by stdio-server.contract.test.ts (contract gate, dedup, deadline expiry,
+ * late-response drop).
+ */
+import { GatewayRpcContract, type AgentRpcError, type AgentRpcRequest } from "../protocol/wire/index.js";
+export interface GatewayRpcConnectionDeps {
+    /** Raw transport send — writes one JSON-RPC frame to the wire. */
+    write: (msg: unknown) => void;
+    log: (message: string) => void;
+}
+export declare class GatewayRpcConnection {
+    private readonly contract;
+    private readonly inflight;
+    private readonly deadlineTimers;
+    private readonly write;
+    private readonly log;
+    constructor(deps: GatewayRpcConnectionDeps);
+    /** The gateway contract — exposed for control-handler metrics/cancel. */
+    get rpcContract(): GatewayRpcContract;
+    /** True while a request id is in flight (no response settled yet). */
+    hasInFlight(id: string | number): boolean;
+    /**
+     * Run the gateway contract gate for an inbound request (caller guarantees the
+     * id is present and the method is not meta-optional). Returns true if the caller
+     * should dispatch; false if the request was rejected/deduped — in which case a
+     * response has already been written.
+     */
+    begin(id: string | number, msg: AgentRpcRequest): boolean;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+    /** Convenience over sendResponse for handlers that build the error inline. */
+    sendError(id: string | number, code: AgentRpcError["code"], message: string, data?: unknown): void;
+    /** Clear the in-flight ledger + deadline timers (server shutdown). */
+    dispose(): void;
+    private clearLifecycle;
+    private sendContractError;
+    private sendContractErrorOrResult;
+    private scheduleDeadline;
+}

package/dist/types/cli/handlers/session-handler.d.ts

@@ -14,11 +14,12 @@ import { SessionState } from "../../runtime/session/session-state.js";
 import { createMemoryPrefetchState } from "../../runtime/hooks/memory-hooks.js";
 import { type AgentRpcError, type AgentRpcErrorCode, type AgentRpcRequest } from "../../protocol/wire/index.js";
 import type { SessionHistoryCoordinator } from "../session-history-coordinator.js";
+import type { TaskDomain } from "../../runtime/prompt/task-domain.js";
 export interface SessionHandlerHost {
     currentSessionId?: string;
     currentModel?: string;
     sessionState?: SessionState | null;
-    sessionTaskDomain?: unknown;
+    sessionTaskDomain?: TaskDomain;
     memoryPrefetchState?: ReturnType<typeof createMemoryPrefetchState>;
     sessionHistory: Pick<SessionHistoryCoordinator, "saveResumedSession">;
     log(message: string): void;

package/dist/types/cli/handlers/workflow-handler.d.ts

@@ -11,6 +11,7 @@ import type { AcpDetector } from "../../runtime/infra/acp-detector.js";
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
 import { WorkflowController } from "../../orchestration/workflow/workflow-controller.js";
 import { WorkflowStore } from "../../orchestration/workflow/workflow-store.js";
+import { WorkflowRunHistoryStore } from "../../orchestration/workflow/run-history-store.js";
 import { WorkflowScheduler } from "../../orchestration/workflow/workflow-scheduler.js";
 import type { ToolCatalog } from "../../runtime/ports/index.js";
 export interface WorkflowCoordinatorHost {
@@ -23,6 +24,7 @@ export interface WorkflowCoordinatorHost {
     workflowStore: WorkflowStore | null;
     workflowProcessManager: AgentProcessManager | null;
     workflowScheduler: WorkflowScheduler | null;
+    workflowRunHistory: WorkflowRunHistoryStore | null;
 }
 export interface WorkflowHandlerHost extends WorkflowCoordinatorHost {
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
@@ -39,3 +41,11 @@ export declare function handleWorkflowList(this: WorkflowHandlerHost, msg: Agent
 export declare function handleWorkflowDelete(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleWorkflowOnImMessage(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleWorkflowOnWebhook(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/** `workflow.revisions` — newest-first def-revision summaries for the undo/history UI. */
+export declare function handleWorkflowRevisions(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/** `workflow.revert` — re-apply a stored revision as a NEW rev (git-revert semantics). */
+export declare function handleWorkflowRevert(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/** `workflow.runs` — newest-first run summaries (status/trigger/timing; outputs stay behind runDetail). */
+export declare function handleWorkflowRuns(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/** `workflow.runDetail` — one run incl. per-node output previews (画布点节点看产出). */
+export declare function handleWorkflowRunDetail(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/cli/model-client-resolver.d.ts

@@ -1,3 +1,4 @@
+import type { KeyHandle } from "../runtime/infra/key-pool.js";
 import type { ModelPurpose } from "../runtime/infra/model-registry.js";
 import type { TurnConfig } from "../agent/types.js";
 import { type LLMTransport, type ProviderRegistry } from "./provider-core-facade.js";
@@ -13,10 +14,18 @@ export interface ResolvedTextGenerationConfig {
     baseUrl?: string;
     configKey: string;
 }
-export declare function resolveTextGenerationConfig(config: TurnConfig, log?: (message: string) => void): ResolvedTextGenerationConfig | null;
-export declare function resolveModelClientForPurpose(deps: {
+export type KeyHandleProvider = () => KeyHandle | null | undefined;
+type ModelClientResolverDeps = {
     purpose: ModelPurpose;
     providerRegistry: ProviderRegistry;
     currentProvider: string;
     currentTransport: LLMTransport | null;
-}): ResolvedModelClient | null;
+};
+export declare function wrapTransportWithKeyHandleProvider(transport: LLMTransport, acquireKeyHandle: KeyHandleProvider): LLMTransport;
+export declare function wrapTransportWithKeyHandle(transport: LLMTransport, keyHandle?: KeyHandle): LLMTransport;
+export declare function takeTextGenerationKeyHandleProvider(config: ResolvedTextGenerationConfig): KeyHandleProvider;
+export declare function releaseUnusedTextGenerationKeyHandle(config: ResolvedTextGenerationConfig): void;
+export declare function resolveTextGenerationConfig(config: TurnConfig, log?: (message: string) => void): ResolvedTextGenerationConfig | null;
+export declare function resolveModelClientForPurpose(deps: ModelClientResolverDeps): ResolvedModelClient | null;
+export declare function withResolvedModelClient<T>(deps: ModelClientResolverDeps, fn: (client: ResolvedModelClient) => T | Promise<T>): Promise<T | null>;
+export {};

package/dist/types/cli/resolved-agent-cache.d.ts

@@ -0,0 +1,47 @@
+/**
+ * ResolvedAgentCache — the DERIVED resolved-agent state for a turn.
+ *
+ * Holds the Agent plus the LLM client snapshot (transport + apiKey/model/provider/
+ * baseUrl) that resolveAgent() produced for the current textGeneration config,
+ * keyed by the resolved config key. Extracted from StdioServer to localize the
+ * one subtle invariant the god-object carried inline:
+ *
+ *   - invalidate(): wipe EVERYTHING. Called on a ModelRegistry change — the resolved
+ *     LLM client is now stale, so the next turn must re-resolve from scratch.
+ *   - forgetAgent(): drop only the Agent + its config key, forcing a re-resolve on
+ *     the next turn while leaving the last client snapshot readable. Called on
+ *     session dispose (matches the prior `agent = null; lastLlmConfigKey = ""`).
+ *
+ * This is DERIVED state ONLY. Host-pinned per-session LLM config (sessionLlmConfig)
+ * lives on the server and is NEVER touched here — a background catalog hydration
+ * finishing between a member's set_config pin and its first prompt must not strip
+ * its provider.
+ */
+import type { Agent } from "../agent/agent.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface ResolvedAgentSnapshot {
+    agent: Agent;
+    transport: LLMTransport;
+    apiKey: string;
+    model: string;
+    provider: string;
+    baseUrl: string;
+    configKey: string;
+}
+export declare class ResolvedAgentCache {
+    agent: Agent | null;
+    transport: LLMTransport | null;
+    apiKey: string;
+    model: string;
+    provider: string;
+    baseUrl: string;
+    private configKey;
+    /** True when a cached Agent matches the given resolved config key. */
+    matches(configKey: string): boolean;
+    /** Store the freshly resolved Agent + LLM client snapshot. */
+    store(snapshot: ResolvedAgentSnapshot): void;
+    /** Drop only the Agent + config key — force re-resolve, keep the last snapshot. */
+    forgetAgent(): void;
+    /** Wipe ALL derived state — the resolved client is stale (registry change). */
+    invalidate(): void;
+}

package/dist/types/cli/rpc-registry.d.ts

@@ -1,8 +1,62 @@
 import type { AgentRpcRequest } from "../protocol/wire/index.js";
+import { type CommunityHandlerHost } from "./handlers/community-handler.js";
+import { type ConfigHandlerHost } from "./handlers/config-handler.js";
+import { type ControlHandlerHost } from "./handlers/control-handler.js";
+import { type FilesHandlerHost } from "./handlers/files-handler.js";
+import { type MediaHandlerHost } from "./handlers/media-handler.js";
+import { type MemoryHandlerHost } from "./handlers/memory-handler.js";
+import { type PetConfirmHandlerHost } from "./handlers/pet-confirm-handler.js";
+import { type PetHandlerHost } from "./handlers/pet-handler.js";
+import { type WorkflowHandlerHost } from "./handlers/workflow-handler.js";
+import { type ProjectHandlerHost } from "./handlers/project-handler.js";
+import { type SessionHandlerHost } from "./handlers/session-handler.js";
+import { type SettingsHandlerHost } from "./handlers/settings-handler.js";
+import { type SkillsHandlerHost } from "./handlers/skills-handler.js";
+import { type TurnControlHandlerHost } from "./handlers/turn-handler.js";
+import { type DreamHandlerHost } from "./handlers/dream-handler.js";
 import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
 export type RpcMethodHandler = (msg: AgentRpcRequest) => void;
-type RpcRegistryHost = Record<string, unknown> & {
-    multiAgentHandlerHost?: MultiAgentHandlerHost;
-};
-export declare function createRpcMethodRegistry(host: RpcRegistryHost): ReadonlyMap<string, RpcMethodHandler>;
-export {};
+/**
+ * Per-domain host adapters the RPC registry binds handlers to. Each field is
+ * typed to exactly ONE handler's narrow contract, so the host (StdioServer)
+ * builds the bundle under COMPILER CHECK: for every domain it passes `this`
+ * directly, tsc verifies StdioServer satisfies that interface — if a member a
+ * handler needs ever disappears, the build breaks at the bundle literal instead
+ * of failing at runtime.
+ *
+ * A few domains' contracts are deliberately divergent views of shared state
+ * (e.g. `memoryProvider` is `MemoryHandlerProvider` for memory but
+ * `PetMemoryProviderLike` for pet; `sessionState` differs likewise). Those can't
+ * be one structural type, so the host supplies them via a localized cast at the
+ * bundle literal — the cast surface is one member-domain, not the whole host.
+ *
+ * The pattern mirrors the existing createDreamHandlerHost / createMultiAgentHandlerHost
+ * adapters, just applied uniformly across every RPC domain.
+ */
+export interface RpcHandlerHosts {
+    config: ConfigHandlerHost;
+    control: ControlHandlerHost;
+    session: SessionHandlerHost;
+    memory: MemoryHandlerHost;
+    files: FilesHandlerHost;
+    media: MediaHandlerHost;
+    skills: SkillsHandlerHost;
+    pet: PetHandlerHost;
+    petConfirm: PetConfirmHandlerHost;
+    project: ProjectHandlerHost;
+    community: CommunityHandlerHost;
+    settings: SettingsHandlerHost;
+    dream: DreamHandlerHost;
+    turn: TurnControlHandlerHost;
+    /** agents/solo/product are served by the multi-agent sub-host. */
+    multiAgent: MultiAgentHandlerHost;
+    /**
+     * workflow.* binds to its own host: it needs `toolCatalog` plus the lazy engine slots
+     * (controller/store/scheduler/processManager) that the multi-agent sub-host lacks. The host
+     * (StdioServer) supplies a dedicated WorkflowHostAdapter that sources acpDetector from the
+     * multi-agent sub-host and toolCatalog from the runtime — so this binding is compiler-checked
+     * like every other domain, with no cast.
+     */
+    workflow: WorkflowHandlerHost;
+}
+export declare function createRpcMethodRegistry(host: RpcHandlerHosts): ReadonlyMap<string, RpcMethodHandler>;

package/dist/types/cli/session-context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SessionContext — the active session/turn identity + lifecycle state.
+ *
+ * The "who/what is running right now" the server tracks across the current session
+ * and turn: the session id, the in-flight turn id, the session cost/state snapshot,
+ * sticky task domain, host-pinned LLM config, and the ACP session _meta supplement.
+ *
+ * Extracted from StdioServer so its runtime-state-container concern is one named
+ * holder rather than six loose fields on the god-object. It is a plain mutable
+ * holder (no invariant beyond field cohesion); the server exposes same-named
+ * get/set accessors that delegate here, so every existing reader AND writer —
+ * including handlers bound via the RPC host cast (session.create, thread.turn,
+ * set_config) — keeps working unchanged.
+ */
+import type { SessionState } from "../runtime/session/session-state.js";
+import type { SessionLlmConfig } from "./acp-session-host.js";
+import type { TaskDomain } from "../runtime/prompt/task-domain.js";
+export declare class SessionContext {
+    /** Active session id (chatId for desktop; group key pattern for groups). */
+    sessionId: string;
+    /** In-flight turn id. */
+    turnId: string;
+    /** Session cost/state snapshot (null until a session is resolved). */
+    state: SessionState | null;
+    /** Session-level task domain stickiness — survives across turns within a session. */
+    taskDomain: TaskDomain | undefined;
+    /** Host-pinned per-session LLM config (session/set_config_option · set_model · /model).
+     *  NEVER wiped by ModelRegistry churn — distinct from the DERIVED ResolvedAgentCache. */
+    llmConfig: SessionLlmConfig;
+    /** ACP session-level context supplement (_meta from session/new), inherited by every prompt. */
+    acpMeta: Record<string, unknown> | null;
+}

package/dist/types/cli/skill-meta-tool-bootstrap.d.ts

@@ -25,3 +25,10 @@ export interface SkillMetaToolRegistrationContext extends SkillMetaToolBootstrap
 }
 export declare const skillMetaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<SkillMetaToolRegistrationContext>;
 export declare function configureSkillMetaToolBootstrap(host: SkillMetaToolHost, deps: SkillMetaToolBootstrapDeps): void;
+/**
+ * Resolve a supporting-file path inside a skill folder.
+ * Returns the absolute target, or null when the path escapes the skill dir
+ * or targets SKILL.md itself (SKILL.md must go through the validated
+ * content path, never the raw supporting-file write).
+ */
+export declare function resolveSupportingFilePath(skillDir: string, filePath: string): string | null;

package/dist/types/cli/stdio-acp-protocol-coordinator.d.ts

@@ -0,0 +1,18 @@
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import { AcpServer, type AcpRequestHandler } from "../transport/acp-server.js";
+import type { Transport } from "./transport.js";
+export declare class StdioAcpProtocolCoordinator {
+    private server;
+    get active(): boolean;
+    init(transport: Transport, handler: AcpRequestHandler, options: {
+        verbose: boolean;
+    }): void;
+    getServer(): AcpServer | null;
+    dispatchMessage(message: unknown): void;
+    hasSession(sessionId: string): boolean;
+    getPermissionSession(sessionId: string): {
+        sessionId: string;
+        requestPermission: AcpServer["requestPermission"];
+    } | undefined;
+    emitUpdate<M extends NotificationMethod>(sessionId: string, method: M, params: NotificationMethodMap[M]): boolean;
+}

package/dist/types/cli/stdio-acp-request-host.d.ts

@@ -0,0 +1,3 @@
+import type { CliAcpRequestHandlerHost } from "./cli-acp-request-handler.js";
+export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTurn" | "acpSessionMeta" | "currentHooks" | "currentSessionId" | "currentTurnId" | "memoryPrefetchState" | "permissionChecker" | "sessionHistory" | "sessionLlmConfig" | "sessionState" | "sessionTaskDomain" | "cancelIdleDreamTimer" | "disposeSessionRuntime" | "enableIdleDream" | "ensureDefaultProject" | "ensureModelRegistryHydrated" | "getActiveProjectRoot" | "log" | "sendNotification" | "setActiveWorkdir">;
+export declare function createStdioAcpRequestHandlerHost(host: StdioAcpRequestHostSource): CliAcpRequestHandlerHost;

package/dist/types/cli/stdio-rpc-handler-hosts.d.ts

@@ -0,0 +1,50 @@
+import type { LLMRequest } from "../agent/types.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { RpcHandlerHosts } from "./rpc-registry.js";
+type DirectStdioRpcHost = RpcHandlerHosts["config"] & RpcHandlerHosts["control"] & RpcHandlerHosts["files"] & RpcHandlerHosts["skills"] & RpcHandlerHosts["project"] & RpcHandlerHosts["community"] & RpcHandlerHosts["settings"] & RpcHandlerHosts["petConfirm"] & {
+    readonly multiAgentHandlerHost: RpcHandlerHosts["multiAgent"];
+    readonly workflowHandlerHost: RpcHandlerHosts["workflow"];
+};
+type StdioRpcAdapterSource = DirectStdioRpcHost & {
+    activeTurn: RpcHandlerHosts["turn"]["activeTurn"];
+    currentSessionId: NonNullable<RpcHandlerHosts["session"]["currentSessionId"]>;
+    currentModel: NonNullable<RpcHandlerHosts["session"]["currentModel"]>;
+    sessionState: RpcHandlerHosts["session"]["sessionState"];
+    sessionTaskDomain: RpcHandlerHosts["session"]["sessionTaskDomain"];
+    memoryPrefetchState: NonNullable<RpcHandlerHosts["session"]["memoryPrefetchState"]>;
+    sessionHistory: RpcHandlerHosts["session"]["sessionHistory"];
+    currentHooks: RpcHandlerHosts["dream"]["currentHooks"];
+    permissionChecker: RpcHandlerHosts["turn"]["permissionChecker"];
+    mediaClient: RpcHandlerHosts["media"]["mediaClient"];
+    memoryProvider: RpcHandlerHosts["memory"]["memoryProvider"];
+    memoryDreamProvider: RpcHandlerHosts["dream"]["memoryProvider"];
+    memoryUserId: NonNullable<RpcHandlerHosts["memory"]["memoryUserId"]>;
+    pendingAskUser: RpcHandlerHosts["turn"]["pendingAskUser"];
+    petRuntime: RpcHandlerHosts["pet"]["petRuntime"];
+    verbose: NonNullable<RpcHandlerHosts["dream"]["verbose"]>;
+    resolveClientForPurpose(purpose: ModelPurpose): {
+        transport: {
+            stream(request: LLMRequest, apiKey: string): AsyncIterable<{
+                type: string;
+                text?: string;
+            }>;
+        };
+        apiKey: string;
+        model: string;
+    } | null;
+    ensureMemoryProvider: NonNullable<RpcHandlerHosts["memory"]["ensureMemoryProvider"]>;
+    ensureModelRegistryHydrated: NonNullable<RpcHandlerHosts["pet"]["ensureModelRegistryHydrated"]>;
+    enableIdleDream: NonNullable<RpcHandlerHosts["session"]["enableIdleDream"]>;
+    configureTurnMedia: NonNullable<RpcHandlerHosts["pet"]["configureTurnMedia"]>;
+    sendError: NonNullable<RpcHandlerHosts["session"]["sendError"]>;
+    createDreamHandlerHost(): RpcHandlerHosts["dream"];
+};
+/**
+ * Build the per-domain handler-host bundle the RPC registry binds to.
+ *
+ * Domains whose contracts StdioServer satisfies directly stay compiler-checked
+ * through DirectStdioRpcHost. Stateful domains receive explicit adapters so
+ * handler contracts stay narrow without domain-level casts.
+ */
+export declare function createStdioRpcHandlerHosts<Host extends StdioRpcAdapterSource>(host: Host): RpcHandlerHosts;
+export {};