qlogicagent 2.13.5 → 2.13.6

package/dist/cli/stdio-acp-request-host.js

@@ -1,82 +0,0 @@
-/** Host members the shared turn pipeline reads/writes — keep in sync with
- * `grep -oE "this\.[a-zA-Z]+" src/cli/handlers/turn-handler.ts | sort -u`. */
-export const TURN_PIPELINE_HOST_MEMBERS = [
-    "activeTurn",
-    "configureTurnMedia",
-    "currentHooks",
-    "currentModel",
-    "currentTurnId",
-    "drainPendingTaskNotifications",
-    "getActiveProjectRoot",
-    "lastAssistantMessageForExtract",
-    "lastUserMessageForAutoExtract",
-    "log",
-    "mcpReady",
-    "memdir",
-    "pendingAskUser",
-    "permissionChecker",
-    "petRuntime",
-    "projectMemoryStoreFactory",
-    "resolveAgent",
-    "resolveClientForPurpose",
-    "sendNotification",
-    "sendResponse",
-    "sessionHistory",
-    "sessionState",
-    "sessionTaskDomain",
-    "setActiveWorkdir",
-    "toolCatalog",
-];
-export function createStdioAcpRequestHandlerHost(host) {
-    return {
-        get activeTurn() { return host.activeTurn; },
-        set activeTurn(value) { host.activeTurn = value; },
-        get acpSessionMeta() { return host.acpSessionMeta; },
-        set acpSessionMeta(value) { host.acpSessionMeta = value; },
-        get currentHooks() { return host.currentHooks; },
-        get currentModel() { return host.currentModel; },
-        get currentSessionId() { return host.currentSessionId; },
-        set currentSessionId(value) { host.currentSessionId = value; },
-        get currentTurnId() { return host.currentTurnId; },
-        set currentTurnId(value) { host.currentTurnId = value; },
-        get lastAssistantMessageForExtract() { return host.lastAssistantMessageForExtract; },
-        set lastAssistantMessageForExtract(value) { host.lastAssistantMessageForExtract = value; },
-        get lastUserMessageForAutoExtract() { return host.lastUserMessageForAutoExtract; },
-        set lastUserMessageForAutoExtract(value) { host.lastUserMessageForAutoExtract = value; },
-        get mcpReady() { return host.mcpReady; },
-        // turn-handler RE-ASSIGNS memdir when effectiveCwd ≠ the current memdir root (cross-project
-        // re-sync). Getter-only here made every ACP turn outside the active project throw
-        // "Cannot set property memdir … only a getter" — e.g. workflow agent nodes running in an
-        // automation project's cwd (multi-root, D21).
-        get memdir() { return host.memdir; },
-        set memdir(value) { host.memdir = value; },
-        get pendingAskUser() { return host.pendingAskUser; },
-        get petRuntime() { return host.petRuntime; },
-        get memoryPrefetchState() { return host.memoryPrefetchState; },
-        set memoryPrefetchState(value) { host.memoryPrefetchState = value; },
-        get permissionChecker() { return host.permissionChecker; },
-        get projectMemoryStoreFactory() { return host.projectMemoryStoreFactory; },
-        get sessionHistory() { return host.sessionHistory; },
-        get sessionLlmConfig() { return host.sessionLlmConfig; },
-        set sessionLlmConfig(value) { host.sessionLlmConfig = value; },
-        get sessionState() { return host.sessionState; },
-        set sessionState(value) { host.sessionState = value; },
-        get sessionTaskDomain() { return host.sessionTaskDomain; },
-        set sessionTaskDomain(value) { host.sessionTaskDomain = value; },
-        get toolCatalog() { return host.toolCatalog; },
-        cancelIdleDreamTimer() { host.cancelIdleDreamTimer(); },
-        configureTurnMedia(config, turnId) { host.configureTurnMedia(config, turnId); },
-        disposeSessionRuntime() { host.disposeSessionRuntime?.(); },
-        drainPendingTaskNotifications() { return host.drainPendingTaskNotifications(); },
-        enableIdleDream() { host.enableIdleDream(); },
-        ensureDefaultProject() { host.ensureDefaultProject(); },
-        ensureModelRegistryHydrated() { return host.ensureModelRegistryHydrated?.() ?? Promise.resolve(); },
-        getActiveProjectRoot() { return host.getActiveProjectRoot(); },
-        log(message) { host.log(message); },
-        resolveAgent(config) { return host.resolveAgent(config); },
-        resolveClientForPurpose(purpose) { return host.resolveClientForPurpose(purpose); },
-        sendNotification(method, params) { host.sendNotification(method, params); },
-        sendResponse(id, result, error) { host.sendResponse(id, result, error); },
-        setActiveWorkdir(dir) { host.setActiveWorkdir(dir); },
-    };
-}

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

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

package/dist/cli/stdio-acp-request-host.test.js

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createStdioAcpRequestHandlerHost, TURN_PIPELINE_HOST_MEMBERS } from "./stdio-acp-request-host.js";
-/**
- * Regression: ui-next chat runs through ACP session/prompt → runTurnPipeline,
- * whose host contract is implicit (`this: any`). A previous allowlist refactor
- * dropped turn-pipeline members from this adapter, so every prompt failed with
- * "this.resolveAgent is not a function". Pin the full member list.
- */
-describe("stdio ACP request host adapter", () => {
-    it("forwards every member the shared turn pipeline touches", () => {
-        const source = {
-            activeTurn: null,
-            acpSessionMeta: undefined,
-            currentHooks: undefined,
-            currentModel: "model-x",
-            currentSessionId: "s1",
-            currentTurnId: undefined,
-            lastAssistantMessageForExtract: undefined,
-            lastUserMessageForAutoExtract: undefined,
-            mcpReady: Promise.resolve(),
-            memdir: { kind: "memdir" },
-            memoryPrefetchState: {},
-            pendingAskUser: new Map(),
-            permissionChecker: null,
-            petRuntime: { kind: "pet" },
-            projectMemoryStoreFactory: { kind: "factory" },
-            sessionHistory: { kind: "history" },
-            sessionLlmConfig: undefined,
-            sessionState: undefined,
-            sessionTaskDomain: undefined,
-            toolCatalog: { kind: "catalog" },
-            cancelIdleDreamTimer() { },
-            configureTurnMedia() { },
-            disposeSessionRuntime() { },
-            drainPendingTaskNotifications() { return []; },
-            enableIdleDream() { },
-            ensureDefaultProject() { },
-            ensureModelRegistryHydrated() { return Promise.resolve(); },
-            getActiveProjectRoot() { return "/tmp"; },
-            log() { },
-            resolveAgent() { return { ok: true }; },
-            resolveClientForPurpose() { return { ok: true }; },
-            sendNotification() { },
-            sendResponse() { },
-            setActiveWorkdir() { },
-        };
-        const adapted = createStdioAcpRequestHandlerHost(source);
-        for (const member of TURN_PIPELINE_HOST_MEMBERS) {
-            // Presence (getter or method) is the contract; values like currentHooks
-            // may legitimately be undefined at rest.
-            expect(member in adapted, `adapter is missing turn-pipeline member "${member}"`).toBe(true);
-        }
-        // Methods must dispatch to the source, not throw.
-        expect(typeof adapted.resolveAgent).toBe("function");
-        expect(adapted.resolveAgent({})).toEqual({ ok: true });
-        expect(typeof adapted.configureTurnMedia).toBe("function");
-        // Writable turn state must round-trip to the source object.
-        adapted.lastUserMessageForAutoExtract = "hello";
-        expect(source.lastUserMessageForAutoExtract).toBe("hello");
-    });
-});

package/dist/cli/stdio-agent-session-bootstrap.d.ts

@@ -1,80 +0,0 @@
-import type { Agent } from "../agent/agent.js";
-import type { ToolInvoker } from "../agent/types.js";
-import type { HookRegistry } from "../contracts/hooks.js";
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { AcpPermissionRequestParams } from "../protocol/wire/index.js";
-import type { MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
-import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
-import type { TaskStore } from "../runtime/infra/task-runtime.js";
-import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PermissionMetadataResolver, PermissionRuleEnginePort, PathService, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
-import type { McpManager } from "../skills/mcp/mcp-manager.js";
-import type { PluginLoader } from "../skills/plugins/plugin-loader.js";
-import type { CliCoreToolHostDeps } from "./core-tool-coordinator.js";
-import { type CliAgentClient } from "./cli-agent-builder.js";
-import type { ResolvedTextGenerationConfig } from "./model-client-resolver.js";
-import type { LLMTransport, ProviderRegistry } from "./provider-core-facade.js";
-import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
-import type { FileWatcher } from "./agent-runtime-bootstrap.js";
-export interface StdioAgentSessionBootstrapDeps {
-    config: Record<string, unknown> & {
-        maxRounds?: number;
-    };
-    resolvedTextConfig: ResolvedTextGenerationConfig;
-    verbose: boolean;
-    taskStore: TaskStore;
-    backgroundTasks: BackgroundTaskManager;
-    sessionId: string;
-    getTurnId(): string;
-    projectRoot: string;
-    pathService: PathService;
-    memdir: ProjectMemoryStore;
-    currentUserId: string;
-    memoryPrefetchState: MemoryPrefetchState;
-    getLastUserMessage(): string | undefined;
-    getLastAssistantMessage(): string | undefined;
-    resolveSmallModelClient(): {
-        transport: LLMTransport;
-        apiKey: string;
-        model: string;
-    } | null;
-    providerRegistry: ProviderRegistry;
-    mediaPersistence: MediaPersistence;
-    toolCatalog: ToolCatalog;
-    runtimeSession: {
-        mcpManager: McpManager | null;
-        permissionUnregister: (() => void) | null;
-        fileWatcher: FileWatcher | null;
-        getPluginSkills(): ReturnType<PluginLoader["getPluginSkills"]>;
-        applyBootstrap(result: {
-            hooks: HookRegistry;
-            memoryHandlerProvider: MemoryHandlerProvider | null;
-            memoryDreamProvider: MemoryDreamRuntimeProvider | null;
-            memoryUserId: string;
-            permissionChecker: PermissionMetadataResolver;
-            permissionUnregister: () => void;
-            ruleEngine: PermissionRuleEnginePort;
-        }): void;
-    };
-    setMcpManager(manager: McpManager | null): void;
-    setMcpReady(ready: Promise<void>): void;
-    setPluginLoader(loader: PluginLoader): void;
-    setFileWatcher(watcher: FileWatcher | null): void;
-    getAgent(): Agent | null;
-    getAcpPermissionSession(): {
-        sessionId: string;
-        requestPermission(params: AcpPermissionRequestParams): Promise<{
-            optionId?: string;
-        }>;
-    } | undefined;
-    isPetActive(): boolean;
-    coreToolHost: CliCoreToolHostDeps;
-    log(message: string): void;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-}
-export interface StdioAgentSessionBootstrapResult {
-    agent: Agent;
-    agentClient: CliAgentClient;
-    toolInvoker: ToolInvoker;
-    hooks: HookRegistry;
-}
-export declare function bootstrapStdioAgentSession(deps: StdioAgentSessionBootstrapDeps): StdioAgentSessionBootstrapResult;

package/dist/cli/stdio-agent-session-bootstrap.js

@@ -1,74 +0,0 @@
-import { configureAgentRuntimeBootstrap } from "./agent-runtime-bootstrap.js";
-import { buildCliAgent, createCliAgentClient } from "./cli-agent-builder.js";
-import { createLocalToolInvoker } from "./tool-invoker-factory.js";
-export function bootstrapStdioAgentSession(deps) {
-    const log = {
-        info: (m) => deps.log(m),
-        warn: (m) => deps.log(`[warn] ${m}`),
-        error: (m) => deps.log(`[error] ${m}`),
-        debug: (m) => {
-            if (deps.verbose)
-                deps.log(`[debug] ${m}`);
-        },
-    };
-    const toolInvoker = createLocalToolInvoker({
-        mediaPersistence: deps.mediaPersistence,
-        toolCatalog: deps.toolCatalog,
-        getSessionId: () => deps.sessionId,
-        log: (message) => deps.log(message),
-        sendNotification: deps.sendNotification,
-    });
-    const agentClient = createCliAgentClient({
-        resolvedConfig: deps.resolvedTextConfig,
-        providerRegistry: deps.providerRegistry,
-        sessionId: deps.sessionId,
-    });
-    const runtimeBootstrap = configureAgentRuntimeBootstrap({
-        config: deps.config,
-        log,
-        taskStore: deps.taskStore,
-        backgroundTasks: deps.backgroundTasks,
-        sessionId: deps.sessionId,
-        getTurnId: deps.getTurnId,
-        projectRoot: deps.projectRoot,
-        pathService: deps.pathService,
-        memdir: deps.memdir,
-        currentUserId: deps.currentUserId,
-        memoryPrefetchState: deps.memoryPrefetchState,
-        getLastUserMessage: deps.getLastUserMessage,
-        getLastAssistantMessage: deps.getLastAssistantMessage,
-        resolveSmallModelClient: deps.resolveSmallModelClient,
-        agentClient,
-        toolCatalog: deps.toolCatalog,
-        currentMcpManager: deps.runtimeSession.mcpManager,
-        setMcpManager: deps.setMcpManager,
-        setMcpReady: deps.setMcpReady,
-        setPluginLoader: deps.setPluginLoader,
-        getPluginSkills: () => deps.runtimeSession.getPluginSkills(),
-        getAgent: deps.getAgent,
-        getAcpPermissionSession: deps.getAcpPermissionSession,
-        sendNotification: deps.sendNotification,
-        isPetActive: deps.isPetActive,
-        currentPermissionUnregister: deps.runtimeSession.permissionUnregister,
-        coreToolHost: deps.coreToolHost,
-        toolInvoker,
-        currentFileWatcher: deps.runtimeSession.fileWatcher,
-        setFileWatcher: deps.setFileWatcher,
-    });
-    deps.runtimeSession.applyBootstrap(runtimeBootstrap);
-    const builtAgent = buildCliAgent({
-        client: agentClient,
-        toolInvoker,
-        log,
-        hooks: runtimeBootstrap.hooks,
-        maxRounds: deps.config.maxRounds,
-        verbose: deps.verbose,
-        projectRoot: deps.projectRoot,
-    });
-    return {
-        agent: builtAgent.agent,
-        agentClient,
-        toolInvoker,
-        hooks: runtimeBootstrap.hooks,
-    };
-}

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

@@ -1,50 +0,0 @@
-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 {};

package/dist/cli/stdio-rpc-handler-hosts.js

@@ -1,135 +0,0 @@
-function createSessionHost(host) {
-    return {
-        get currentSessionId() { return host.currentSessionId; },
-        set currentSessionId(value) { host.currentSessionId = value ?? ""; },
-        get currentModel() { return host.currentModel; },
-        get sessionState() { return host.sessionState; },
-        set sessionState(value) { host.sessionState = value ?? null; },
-        get sessionTaskDomain() { return host.sessionTaskDomain; },
-        set sessionTaskDomain(value) { host.sessionTaskDomain = value; },
-        get memoryPrefetchState() { return host.memoryPrefetchState; },
-        set memoryPrefetchState(value) {
-            if (value)
-                host.memoryPrefetchState = value;
-        },
-        get sessionHistory() { return host.sessionHistory; },
-        log(message) { host.log(message); },
-        setActiveWorkdir(dir) { host.setActiveWorkdir(dir); },
-        getActiveProjectRoot() { return host.getActiveProjectRoot(); },
-        enableIdleDream() { host.enableIdleDream(); },
-        sendNotification(method, params) { host.sendNotification(method, params); },
-        sendResponse(id, result, error) { host.sendResponse(id, result, error); },
-        sendError(id, code, message, data) {
-            host.sendError(id, code, message, data);
-        },
-    };
-}
-function createMemoryLlmClient(host, purpose) {
-    const client = host.resolveClientForPurpose(purpose);
-    if (!client)
-        return null;
-    return {
-        apiKey: client.apiKey,
-        model: client.model,
-        transport: {
-            stream(request, apiKey) {
-                return client.transport.stream(toLlmRequest(request), apiKey);
-            },
-        },
-    };
-}
-function toLlmRequest(request) {
-    return {
-        model: typeof request.model === "string" ? request.model : "",
-        messages: Array.isArray(request.messages) ? request.messages : [],
-        tools: Array.isArray(request.tools) ? request.tools : undefined,
-        toolChoice: request.toolChoice,
-        temperature: typeof request.temperature === "number" ? request.temperature : undefined,
-        topP: typeof request.topP === "number" ? request.topP : undefined,
-        maxTokens: typeof request.maxTokens === "number" ? request.maxTokens : undefined,
-    };
-}
-function createMemoryHost(host) {
-    return {
-        get memdir() { return host.memdir; },
-        set memdir(value) { host.memdir = value; },
-        get memoryProvider() { return host.memoryProvider; },
-        set memoryProvider(value) { host.memoryProvider = value ?? null; },
-        get memoryUserId() { return host.memoryUserId; },
-        set memoryUserId(value) { host.memoryUserId = value ?? ""; },
-        get projectMemoryStoreFactory() { return host.projectMemoryStoreFactory; },
-        ensureMemoryProvider() { host.ensureMemoryProvider(); },
-        getActiveProjectRoot() { return host.getActiveProjectRoot(); },
-        resolveClientForPurpose(purpose) { return createMemoryLlmClient(host, purpose); },
-        sendNotification(method, params) { host.sendNotification(method, params); },
-        sendResponse(id, result, error) { host.sendResponse(id, result, error); },
-    };
-}
-function createMediaHost(host) {
-    return {
-        get mediaClient() { return host.mediaClient; },
-        sendResponse(id, result, error) { host.sendResponse(id, result, error); },
-    };
-}
-function createTurnHost(host) {
-    return {
-        get activeTurn() { return host.activeTurn; },
-        set activeTurn(value) { host.activeTurn = value ?? null; },
-        get permissionChecker() { return host.permissionChecker; },
-        get toolCatalog() { return host.toolCatalog; },
-        get pendingAskUser() { return host.pendingAskUser; },
-        configureTurnMedia(config, turnId) { host.configureTurnMedia(config, turnId); },
-        log(message) { host.log(message); },
-        sendResponse(id, result) { host.sendResponse(id, result); },
-    };
-}
-function createPetMemoryProvider(host) {
-    const provider = host.memoryProvider;
-    if (!provider?.getActivitySummary)
-        return null;
-    return {
-        getActivitySummary(userId, days) {
-            return provider.getActivitySummary?.(userId, days);
-        },
-    };
-}
-function createPetHost(host) {
-    return {
-        get sessionState() { return host.sessionState; },
-        get memoryProvider() { return createPetMemoryProvider(host); },
-        get memoryUserId() { return host.memoryUserId; },
-        get petRuntime() { return host.petRuntime; },
-        getActiveProjectRoot() { return host.getActiveProjectRoot(); },
-        sendNotification(method, params) { host.sendNotification(method, params); },
-        sendResponse(id, result, error) { host.sendResponse(id, result, error); },
-        ensureModelRegistryHydrated() { return host.ensureModelRegistryHydrated(); },
-        configureTurnMedia(config, turnId) { host.configureTurnMedia(config, turnId); },
-    };
-}
-/**
- * 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 function createStdioRpcHandlerHosts(host) {
-    return {
-        config: host,
-        control: host,
-        files: host,
-        skills: host,
-        project: host,
-        community: host,
-        settings: host,
-        petConfirm: host,
-        session: createSessionHost(host),
-        memory: createMemoryHost(host),
-        media: createMediaHost(host),
-        turn: createTurnHost(host),
-        pet: createPetHost(host),
-        dream: host.createDreamHandlerHost(),
-        get multiAgent() { return host.multiAgentHandlerHost; },
-        get workflow() { return host.workflowHandlerHost; },
-    };
-}

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

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

package/dist/cli/stdio-rpc-handler-hosts.test.js

@@ -1,10 +0,0 @@
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-describe("stdio RPC handler hosts architecture", () => {
-    it("does not use domain-level unknown casts to satisfy RpcHandlerHosts", () => {
-        const sourcePath = fileURLToPath(new URL("./stdio-rpc-handler-hosts.ts", import.meta.url));
-        const source = readFileSync(sourcePath, "utf8");
-        expect(source).not.toMatch(/as unknown as RpcHandlerHosts\[/);
-    });
-});

package/dist/cli/stdio-runtime-bootstrap.d.ts

@@ -1,16 +0,0 @@
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { ModelPurpose } from "../runtime/infra/model-registry.js";
-import type { LLMTransport } from "./provider-core-facade.js";
-import { type StdioRuntimeServices } from "./stdio-runtime-services.js";
-export interface StdioRuntimeBootstrapDeps {
-    verbose: boolean;
-    getActiveProjectRoot(): string;
-    resolveClientForPurpose(purpose: ModelPurpose): {
-        transport: LLMTransport;
-        apiKey: string;
-        model: string;
-    } | null;
-    log(message: string): void;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-}
-export declare function bootstrapStdioRuntimeServices(deps: StdioRuntimeBootstrapDeps): StdioRuntimeServices;

package/dist/cli/stdio-runtime-bootstrap.js

@@ -1,17 +0,0 @@
-import { configureBaseToolBootstrap } from "./base-tool-bootstrap.js";
-import { createStdioRuntimeServices } from "./stdio-runtime-services.js";
-export function bootstrapStdioRuntimeServices(deps) {
-    const runtimeServices = createStdioRuntimeServices({
-        getActiveProjectRoot: deps.getActiveProjectRoot,
-        resolveClientForPurpose: deps.resolveClientForPurpose,
-        sendNotification: deps.sendNotification,
-    });
-    configureBaseToolBootstrap({
-        resolveClientForPurpose: deps.resolveClientForPurpose,
-        verbose: deps.verbose,
-        toolBootstrap: runtimeServices.toolBootstrap,
-        log: deps.log,
-        sendNotification: deps.sendNotification,
-    });
-    return runtimeServices;
-}

package/dist/cli/stdio-runtime-services.d.ts

@@ -1,36 +0,0 @@
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PathService, ToolBootstrap, ToolCatalog } from "../runtime/ports/index.js";
-import { MediaPersistence } from "../runtime/infra/media-persistence.js";
-import { MediaClient, ProviderRegistry, type LLMTransport } from "./provider-core-facade.js";
-import { type MemoryProviderState } from "./memory-coordinator.js";
-import { type PetRuntime } from "./pet-runtime.js";
-import { type TurnMediaSetupHost } from "./turn-media-setup.js";
-export interface StdioRuntimeServicesDeps {
-    getActiveProjectRoot(): string;
-    resolveClientForPurpose(purpose: import("../runtime/infra/model-registry.js").ModelPurpose): {
-        transport: LLMTransport;
-        apiKey: string;
-        model: string;
-    } | null;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-}
-export interface StdioRuntimeServices {
-    providerRegistry: ProviderRegistry;
-    mediaClient: MediaClient;
-    mediaPersistence: MediaPersistence;
-    pathService: PathService;
-    toolCatalog: ToolCatalog;
-    toolBootstrap: ToolBootstrap;
-    petRuntime: PetRuntime;
-    configureTurnMedia(params: {
-        host: Omit<TurnMediaSetupHost, "mediaClient">;
-        config?: Record<string, unknown>;
-        turnId: string;
-    }): void;
-    ensureMemoryProvider(currentUserId: string): MemoryProviderState;
-    closeMemoryProviders(state: {
-        memoryProvider: MemoryHandlerProvider | null;
-        memoryDreamProvider: MemoryDreamRuntimeProvider | null;
-    }): void;
-}
-export declare function createStdioRuntimeServices(deps: StdioRuntimeServicesDeps): StdioRuntimeServices;

package/dist/cli/stdio-runtime-services.js

@@ -1,53 +0,0 @@
-import { MediaPersistence } from "../runtime/infra/media-persistence.js";
-import { MediaClient, ProviderRegistry } from "./provider-core-facade.js";
-import { CliPathService } from "./session-coordinator.js";
-import { ensureLocalMemoryProvider } from "./memory-coordinator.js";
-import { createCliToolBootstrap, createCliToolCatalog } from "./tool-catalog.js";
-import { createPetRuntime } from "./pet-runtime.js";
-import { configureTurnMedia } from "./turn-media-setup.js";
-export function createStdioRuntimeServices(deps) {
-    const providerRegistry = new ProviderRegistry();
-    const mediaClient = new MediaClient({ registry: providerRegistry });
-    const mediaPersistence = new MediaPersistence();
-    const toolCatalog = createCliToolCatalog();
-    const toolBootstrap = createCliToolBootstrap(toolCatalog);
-    const pathService = new CliPathService(mediaPersistence, toolBootstrap);
-    const petRuntime = createPetRuntime({
-        getActiveProjectRoot: deps.getActiveProjectRoot,
-        resolveClientForPurpose: deps.resolveClientForPurpose,
-        sendNotification: deps.sendNotification,
-    });
-    return {
-        providerRegistry,
-        mediaClient,
-        mediaPersistence,
-        pathService,
-        toolCatalog,
-        toolBootstrap,
-        petRuntime,
-        configureTurnMedia: (params) => configureTurnMedia({
-            ...params,
-            host: {
-                ...params.host,
-                mediaClient,
-            },
-        }),
-        ensureMemoryProvider: (currentUserId) => ensureLocalMemoryProvider(currentUserId),
-        closeMemoryProviders,
-    };
-}
-function closeMemoryProviders(state) {
-    const seen = new Set();
-    for (const provider of [state.memoryProvider, state.memoryDreamProvider]) {
-        if (!provider || seen.has(provider))
-            continue;
-        seen.add(provider);
-        const close = provider.close;
-        if (typeof close === "function") {
-            try {
-                close.call(provider);
-            }
-            catch { /* best-effort cleanup */ }
-        }
-    }
-}

package/dist/cli/stdio-server.architecture.test.d.ts

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

package/dist/cli/stdio-server.architecture.test.js

@@ -1,18 +0,0 @@
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-describe("StdioServer architecture", () => {
-    const sourcePath = fileURLToPath(new URL("./stdio-server.ts", import.meta.url));
-    function source() {
-        return readFileSync(sourcePath, "utf8");
-    }
-    it("does not directly own the ACP server lifecycle", () => {
-        expect(source()).not.toMatch(/private acpServer: AcpServer \| null = null/);
-    });
-    it("does not cast itself into the ACP request handler host", () => {
-        expect(source()).not.toMatch(/this as unknown as CliAcpRequestHandlerHost/);
-    });
-    it("does not keep memory-provider close logic inline", () => {
-        expect(source()).not.toMatch(/private closeMemoryProviders\(\): void/);
-    });
-});

package/dist/cli/stdio-server.contract.test.d.ts

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