qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,48 @@
+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
+ * from the host's resolved-agent snapshot (stdio-server current*), which is
+ * derived state and gets invalidated on every ModelRegistry change. Pinned config
+ * must survive registry churn: a spawned team member is provisioned exactly this
+ * way, and a background catalog hydration firing between the pin and the first
+ * prompt must not wipe it (that wipe was the standalone NO_PROVIDER bug).
+ */
+export interface SessionLlmConfig {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface AcpSessionHost {
+    /** Gateway-supplied per-session context (_meta from session/new); inherited by every prompt. */
+    acpSessionMeta: AcpSessionMeta | null;
+    /** Host-pinned per-session LLM config; overlaid into every prompt's turn config. */
+    sessionLlmConfig: SessionLlmConfig;
+    currentHooks: HookRegistry | null;
+    currentSessionId: string;
+    memoryPrefetchState: ReturnType<typeof createMemoryPrefetchState>;
+    sessionHistory: Pick<SessionHistoryCoordinator, "saveResumedSession" | "withResumedHistory">;
+    sessionState: SessionState | null;
+    sessionTaskDomain: unknown;
+    cancelIdleDreamTimer(): void;
+    disposeSessionRuntime?(): void;
+    enableIdleDream(): void;
+    ensureDefaultProject(): void;
+    /**
+     * Ensure the model-registry catalog (this.models) is hydrated from the owner profile +
+     * built-in/llmrouter catalog. A spawned/headless qlogicagent only runs load() (bindings +
+     * enabled-overrides) — its catalog is empty, so getActiveModel() returns null and the turn fails
+     * "No LLM provider". Awaiting this before a turn resolves the model lets the agent self-resolve its
+     * own configured model (idempotent; the promise is cached).
+     */
+    ensureModelRegistryHydrated?(): Promise<void>;
+    getActiveProjectRoot(): string;
+    log(message: string): void;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    setActiveWorkdir(dir: string): void;
+}

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

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

package/dist/cli/agent-config-coordinator.d.ts

@@ -0,0 +1,16 @@
+import { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
+import type { AcpDetector } from "../runtime/infra/acp-detector.js";
+export interface AgentConfigCoordinatorDeps {
+    acpDetector: AcpDetector;
+    getActiveProjectRoot(): string;
+}
+export declare function resolveLlmrouterPublicOrigin(rawBaseUrl?: string): string | undefined;
+export declare function resolveLlmrouterProtocolBaseUrl(agentId: string, rawBaseUrl?: string): string | undefined;
+export declare class AgentConfigCoordinator {
+    private readonly deps;
+    private store;
+    constructor(deps: AgentConfigCoordinatorDeps);
+    get currentStore(): AgentConfigStore | null;
+    ensureStore(): Promise<AgentConfigStore>;
+    private syncKeySources;
+}

package/dist/cli/agent-config-coordinator.js

@@ -0,0 +1,56 @@
+import { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
+import { getModelRegistry } from "../runtime/infra/model-registry.js";
+const LLMROUTER_OPENAI_COMPAT_AGENTS = new Set(["codex"]);
+function getEnvValue(name) {
+    return process.env[name]?.trim() || undefined;
+}
+export function resolveLlmrouterPublicOrigin(rawBaseUrl) {
+    const trimmed = rawBaseUrl?.trim().replace(/\/+$/, "");
+    if (!trimmed)
+        return undefined;
+    return trimmed.replace(/\/(?:api|v1)$/i, "");
+}
+export function resolveLlmrouterProtocolBaseUrl(agentId, rawBaseUrl) {
+    const origin = resolveLlmrouterPublicOrigin(rawBaseUrl);
+    if (!origin)
+        return undefined;
+    return LLMROUTER_OPENAI_COMPAT_AGENTS.has(agentId) ? `${origin}/v1` : origin;
+}
+export class AgentConfigCoordinator {
+    deps;
+    store = null;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get currentStore() {
+        return this.store;
+    }
+    async ensureStore() {
+        if (!this.store) {
+            this.store = new AgentConfigStore(this.deps.getActiveProjectRoot());
+            await this.store.load();
+            this.deps.acpDetector.setConfigStore(this.store.getData());
+        }
+        this.syncKeySources();
+        return this.store;
+    }
+    syncKeySources() {
+        // Direct agents resolve provider keys lazily; passthrough agents need a fresh
+        // text-generation snapshot each time so they cannot inherit a stale host key.
+        const activeModel = getModelRegistry().getActiveModel("textGeneration");
+        const llmrouterBaseUrl = getEnvValue("QLOGIC_LLMROUTER_BASE_URL");
+        const llmrouterModel = getEnvValue("QLOGIC_LLMROUTER_TEXT_MODEL")
+            ?? (activeModel?.provider === "llmrouter" ? activeModel.model : undefined)
+            ?? "deepseek-v4-flash";
+        this.deps.acpDetector.setKeySources({
+            llmrouterKey: getEnvValue("QLOGIC_LLMROUTER_INFERENCE_KEY"),
+            getLlmrouterBaseUrl: (agentId) => resolveLlmrouterProtocolBaseUrl(agentId, llmrouterBaseUrl),
+            llmrouterModel,
+            getDirectKey: (providerId) => getModelRegistry().getKeyForProvider(providerId) ?? undefined,
+            passthroughModel: activeModel
+                ? { apiKey: activeModel.apiKey, baseUrl: activeModel.baseUrl, model: activeModel.model }
+                : undefined,
+        });
+        activeModel?.keyHandle.release({ success: true });
+    }
+}

package/dist/cli/agent-config-coordinator.test.d.ts

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

package/dist/cli/agent-config-coordinator.test.js

@@ -0,0 +1,51 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentConfigCoordinator, resolveLlmrouterProtocolBaseUrl, resolveLlmrouterPublicOrigin, } from "./agent-config-coordinator.js";
+describe("LLMRouter protocol base URL resolution", () => {
+    it("normalizes gateway API URLs to the public LLMRouter origin", () => {
+        expect(resolveLlmrouterPublicOrigin("https://www.qlogicagent.com/api")).toBe("https://www.qlogicagent.com");
+        expect(resolveLlmrouterPublicOrigin("https://www.qlogicagent.com/v1/")).toBe("https://www.qlogicagent.com");
+        expect(resolveLlmrouterPublicOrigin("https://www.qlogicagent.com/")).toBe("https://www.qlogicagent.com");
+    });
+    it("routes codex to OpenAI-compatible /v1 and claude to Anthropic root", () => {
+        expect(resolveLlmrouterProtocolBaseUrl("codex", "https://www.qlogicagent.com/api")).toBe("https://www.qlogicagent.com/v1");
+        expect(resolveLlmrouterProtocolBaseUrl("claude", "https://www.qlogicagent.com/api")).toBe("https://www.qlogicagent.com");
+    });
+});
+describe("AgentConfigCoordinator LLMRouter source wiring", () => {
+    const tempRoots = [];
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        for (const root of tempRoots.splice(0)) {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("passes gateway-injected LLMRouter key and protocol bases to the ACP detector", async () => {
+        const qlogicHome = mkdtempSync(join(tmpdir(), "qlogicagent-home-"));
+        const projectRoot = mkdtempSync(join(tmpdir(), "qlogicagent-project-"));
+        tempRoots.push(qlogicHome, projectRoot);
+        vi.stubEnv("QLOGICAGENT_HOME", qlogicHome);
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "sk-qllm-auto");
+        vi.stubEnv("QLOGIC_LLMROUTER_BASE_URL", "https://www.qlogicagent.com/api");
+        let capturedSources;
+        const detector = {
+            setConfigStore(data) {
+                expect(data.agents).toEqual({});
+            },
+            setKeySources(sources) {
+                capturedSources = sources;
+            },
+        };
+        const coordinator = new AgentConfigCoordinator({
+            acpDetector: detector,
+            getActiveProjectRoot: () => projectRoot,
+        });
+        await coordinator.ensureStore();
+        expect(capturedSources?.llmrouterKey).toBe("sk-qllm-auto");
+        expect(capturedSources?.llmrouterModel).toBe("deepseek-v4-flash");
+        expect(capturedSources?.getLlmrouterBaseUrl?.("codex", {})).toBe("https://www.qlogicagent.com/v1");
+        expect(capturedSources?.getLlmrouterBaseUrl?.("claude", {})).toBe("https://www.qlogicagent.com");
+    });
+});

package/dist/cli/agent-config-runtime.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
+import type { AcpDetector } from "../runtime/infra/acp-detector.js";
+export interface AgentConfigRuntime {
+    readonly currentStore: AgentConfigStore | null;
+    ensureStore(): Promise<AgentConfigStore>;
+}
+export interface AgentConfigRuntimeDeps {
+    acpDetector: AcpDetector;
+    getActiveProjectRoot(): string;
+}
+export declare function createAgentConfigRuntime(deps: AgentConfigRuntimeDeps): AgentConfigRuntime;

package/dist/cli/agent-config-runtime.js

@@ -0,0 +1,4 @@
+import { AgentConfigCoordinator } from "./agent-config-coordinator.js";
+export function createAgentConfigRuntime(deps) {
+    return new AgentConfigCoordinator(deps);
+}

package/dist/cli/agent-runner-factory.d.ts

@@ -0,0 +1,2 @@
+import type { ForkedAgentRunnerFactory } from "../runtime/ports/index.js";
+export declare const createCliForkedAgentRunner: ForkedAgentRunnerFactory;

package/dist/cli/agent-runner-factory.js

@@ -0,0 +1,11 @@
+import { Agent } from "../agent/agent.js";
+import { createCliAgentRuntimePorts } from "./agent-runtime-ports-adapter.js";
+export const createCliForkedAgentRunner = ({ transport, apiKey, toolInvoker, log, hooks, maxRounds, }) => new Agent({
+    llmTransport: transport,
+    apiKey,
+    toolInvoker: toolInvoker,
+    log: log,
+    hooks,
+    maxRounds,
+    runtimePorts: createCliAgentRuntimePorts(),
+});

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

@@ -0,0 +1,67 @@
+import type { AgentLogger, 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 { CliAgentClient } from "./cli-agent-builder.js";
+import { type CliCoreToolHostDeps } from "./core-tool-coordinator.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+import { type FileWatcher } from "./runtime-watcher-bootstrap.js";
+import { configureSkillMetaToolBootstrap } from "./skill-meta-tool-bootstrap.js";
+export type { FileWatcher };
+export interface AgentRuntimeBootstrapDeps {
+    config: Record<string, unknown>;
+    log: AgentLogger;
+    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;
+    agentClient: CliAgentClient;
+    toolCatalog: ToolCatalog;
+    currentMcpManager: McpManager | null;
+    setMcpManager(manager: McpManager | null): void;
+    setMcpReady(ready: Promise<void>): void;
+    setPluginLoader(loader: PluginLoader): void;
+    getPluginSkills(): ReturnType<PluginLoader["getPluginSkills"]>;
+    getAgent(): Parameters<typeof configureSkillMetaToolBootstrap>[0]["getAgent"] extends () => infer T ? T : never;
+    getAcpPermissionSession(): {
+        sessionId: string;
+        requestPermission(params: AcpPermissionRequestParams): Promise<{
+            optionId?: string;
+        }>;
+    } | undefined;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+    isPetActive(): boolean;
+    currentPermissionUnregister?: (() => void) | null;
+    coreToolHost: CliCoreToolHostDeps;
+    toolInvoker: ToolInvoker;
+    currentFileWatcher: FileWatcher | null;
+    setFileWatcher(watcher: FileWatcher | null): void;
+}
+export interface AgentRuntimeBootstrapResult {
+    hooks: HookRegistry;
+    memoryHandlerProvider: MemoryHandlerProvider | null;
+    memoryDreamProvider: MemoryDreamRuntimeProvider | null;
+    memoryUserId: string;
+    permissionChecker: PermissionMetadataResolver;
+    permissionUnregister: () => void;
+    ruleEngine: PermissionRuleEnginePort;
+}
+export declare function configureAgentRuntimeBootstrap(deps: AgentRuntimeBootstrapDeps): AgentRuntimeBootstrapResult;

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

@@ -0,0 +1,104 @@
+import { configureCliCoreTools } from "./core-tool-coordinator.js";
+import { configureDevToolBootstrap } from "./dev-tool-bootstrap.js";
+import { configureMcpBootstrap } from "./mcp-bootstrap.js";
+import { configurePluginBootstrap } from "./plugin-bootstrap.js";
+import { configurePermissionBootstrap } from "./permission-bootstrap.js";
+import { configureRuntimeHookBootstrap } from "./runtime-hook-bootstrap.js";
+import { configureRuntimeWatchers } from "./runtime-watcher-bootstrap.js";
+import { configureSkillMetaToolBootstrap } from "./skill-meta-tool-bootstrap.js";
+export function configureAgentRuntimeBootstrap(deps) {
+    const runtimeHooks = configureRuntimeHookBootstrap({
+        log: deps.log,
+        taskStore: deps.taskStore,
+        backgroundTasks: deps.backgroundTasks,
+        sessionId: deps.sessionId,
+        projectRoot: deps.projectRoot,
+        memdir: deps.memdir,
+        toolCatalog: deps.toolCatalog,
+        currentUserId: deps.currentUserId,
+        prefetchState: deps.memoryPrefetchState,
+        getLastUserMessage: deps.getLastUserMessage,
+        getLastAssistantMessage: deps.getLastAssistantMessage,
+        resolveSmallModelClient: deps.resolveSmallModelClient,
+        compressionClient: {
+            transport: deps.agentClient.transport,
+            apiKey: deps.agentClient.apiKey,
+        },
+        sendNotification: (method, params) => deps.sendNotification(method, params),
+    });
+    const hooks = runtimeHooks.hooks;
+    configureMcpBootstrap({
+        config: deps.config,
+        projectRoot: deps.projectRoot,
+        pathService: deps.pathService,
+        log: deps.log,
+        toolCatalog: deps.toolCatalog,
+        currentManager: deps.currentMcpManager,
+        setManager: deps.setMcpManager,
+        setReady: deps.setMcpReady,
+    });
+    configurePluginBootstrap({
+        config: deps.config,
+        hooks,
+        log: deps.log,
+        pathService: deps.pathService,
+        toolCatalog: deps.toolCatalog,
+        setPluginLoader: deps.setPluginLoader,
+    });
+    const permissionBootstrap = configurePermissionBootstrap({
+        config: deps.config,
+        toolCatalog: deps.toolCatalog,
+        hooks,
+        log: deps.log,
+        sessionId: deps.sessionId,
+        getTurnId: deps.getTurnId,
+        getActiveProjectRoot: () => deps.projectRoot,
+        // Live tool workdir for cross-workspace classification (changes per turn via
+        // setActiveWorkdir). deps.projectRoot stays a snapshot for memory/sessions.
+        getActiveWorkdir: () => deps.pathService.getActiveWorkdir(),
+        getAcpPermissionSession: deps.getAcpPermissionSession,
+        sendNotification: deps.sendNotification,
+        isPetActive: deps.isPetActive,
+        currentUnregister: deps.currentPermissionUnregister,
+    });
+    configureSkillMetaToolBootstrap({
+        getActiveProjectRoot: () => deps.projectRoot,
+        getPluginSkills: deps.getPluginSkills,
+        getAgent: deps.getAgent,
+        getCurrentSessionId: () => deps.sessionId,
+        getCurrentHooks: () => hooks,
+        sendNotification: deps.sendNotification,
+        getMemoryLearningSink: () => runtimeHooks.memoryLearningSink,
+        getMemoryUserId: () => runtimeHooks.memoryUserId,
+    }, { config: deps.config, pathService: deps.pathService, toolCatalog: deps.toolCatalog });
+    configureCliCoreTools({
+        config: deps.config,
+        host: deps.coreToolHost,
+        hooks,
+        log: deps.log,
+        toolCatalog: deps.toolCatalog,
+        toolInvoker: deps.toolInvoker,
+    });
+    configureDevToolBootstrap({ config: deps.config, pathService: deps.pathService, toolCatalog: deps.toolCatalog });
+    if (deps.sessionId) {
+        hooks.invoke("session.created", { sessionId: deps.sessionId }).catch(() => { });
+    }
+    configureRuntimeWatchers({
+        config: deps.config,
+        hooks,
+        ruleEngine: permissionBootstrap.ruleEngine,
+        sessionId: deps.sessionId,
+        currentFileWatcher: deps.currentFileWatcher,
+        log: deps.log,
+        setFileWatcher: deps.setFileWatcher,
+    });
+    return {
+        hooks,
+        memoryHandlerProvider: runtimeHooks.memoryHandlerProvider,
+        memoryDreamProvider: runtimeHooks.memoryDreamProvider,
+        memoryUserId: runtimeHooks.memoryUserId,
+        permissionChecker: permissionBootstrap.permissionChecker,
+        permissionUnregister: permissionBootstrap.permissionUnregister,
+        ruleEngine: permissionBootstrap.ruleEngine,
+    };
+}

package/dist/cli/agent-runtime-ports-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { AgentRuntimePorts } from "../runtime/ports/index.js";
+export declare function createCliAgentRuntimePorts(): AgentRuntimePorts;

package/dist/cli/agent-runtime-ports-adapter.js

@@ -0,0 +1,22 @@
+import { detectRecallCategories } from "../runtime/memory/recall-category-filter.js";
+import { getModelRegistry } from "../runtime/infra/model-registry.js";
+import { StreamingToolExecutor } from "../runtime/execution/streaming-tool-executor.js";
+import { compressMessages, getContextEngineRegistry } from "../runtime/hooks/context-compression.js";
+import { getBudgetContinuationMessage } from "../runtime/infra/token-budget.js";
+import { createContentReplacementState, enforceToolResultBudget, } from "../runtime/execution/tool-result-storage.js";
+import { resolveToolEligibility } from "../runtime/execution/tool-eligibility.js";
+export function createCliAgentRuntimePorts() {
+    return {
+        detectRecallCategories,
+        resolveModelForPurpose: (purpose) => getModelRegistry().resolveModelForPurpose(purpose),
+        toolLoop: {
+            createContentReplacementState,
+            enforceToolResultBudget,
+            getActiveContextCompressionEngine: () => getContextEngineRegistry().getActive() ?? null,
+            compressMessages,
+            getBudgetContinuationMessage,
+            createStreamingToolExecutor: (config) => new StreamingToolExecutor(config),
+            resolveToolEligibility: (tools, context) => resolveToolEligibility(tools, context),
+        },
+    };
+}

package/dist/cli/agent-runtime-session-state.d.ts

@@ -0,0 +1,24 @@
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PermissionMetadataResolver } 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 { AgentRuntimeBootstrapResult, FileWatcher } from "./agent-runtime-bootstrap.js";
+export declare class AgentRuntimeSessionState {
+    currentHooks: HookRegistry | null;
+    mcpManager: McpManager | null;
+    mcpReady: Promise<void>;
+    pluginLoader: PluginLoader | null;
+    permissionChecker: PermissionMetadataResolver | null;
+    permissionUnregister: (() => void) | null;
+    fileWatcher: FileWatcher | null;
+    memoryProvider: MemoryHandlerProvider | null;
+    memoryDreamProvider: MemoryDreamRuntimeProvider | null;
+    memoryUserId: string;
+    getPluginSkills(): ReturnType<PluginLoader["getPluginSkills"]>;
+    applyBootstrap(result: AgentRuntimeBootstrapResult): void;
+    resetAfterSessionDispose(): void;
+    stopFileWatcher(): void;
+    disconnectMcp(): Promise<void>;
+    unregisterPermissions(): void;
+    resetMemoryProviders(): void;
+}

package/dist/cli/agent-runtime-session-state.js

@@ -0,0 +1,51 @@
+export class AgentRuntimeSessionState {
+    currentHooks = null;
+    mcpManager = null;
+    mcpReady = Promise.resolve();
+    pluginLoader = null;
+    permissionChecker = null;
+    permissionUnregister = null;
+    fileWatcher = null;
+    memoryProvider = null;
+    memoryDreamProvider = null;
+    memoryUserId = "";
+    getPluginSkills() {
+        return this.pluginLoader?.getPluginSkills() ?? [];
+    }
+    applyBootstrap(result) {
+        this.currentHooks = result.hooks;
+        this.memoryProvider = result.memoryHandlerProvider;
+        this.memoryDreamProvider = result.memoryDreamProvider;
+        this.memoryUserId = result.memoryUserId;
+        this.permissionChecker = result.permissionChecker;
+        this.permissionUnregister = result.permissionUnregister;
+    }
+    resetAfterSessionDispose() {
+        this.currentHooks = null;
+        this.memoryProvider = null;
+        this.memoryDreamProvider = null;
+    }
+    stopFileWatcher() {
+        if (!this.fileWatcher)
+            return;
+        this.fileWatcher.stop();
+        this.fileWatcher = null;
+    }
+    async disconnectMcp() {
+        if (!this.mcpManager)
+            return;
+        const manager = this.mcpManager;
+        this.mcpManager = null;
+        await manager.disconnectAll();
+    }
+    unregisterPermissions() {
+        if (!this.permissionUnregister)
+            return;
+        this.permissionUnregister();
+        this.permissionUnregister = null;
+    }
+    resetMemoryProviders() {
+        this.memoryProvider = null;
+        this.memoryDreamProvider = null;
+    }
+}

package/dist/cli/agent-status-notifier.d.ts

@@ -0,0 +1,11 @@
+import type { AgentsStatusNotification } from "../protocol/notifications.js";
+export interface AgentStatusExtra {
+    missedBeats?: number;
+    lastActivityAt?: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+}
+export declare function createAgentStatusNotification(agentId: string, state: string, extra?: AgentStatusExtra): AgentsStatusNotification;

package/dist/cli/agent-status-notifier.js

@@ -0,0 +1,26 @@
+const STATE_TO_STATUS = {
+    starting: "spawning",
+    ready: "available",
+    running: "running",
+    completed: "available",
+    failed: "failed",
+    killed: "unavailable",
+};
+export function createAgentStatusNotification(agentId, state, extra) {
+    const notification = {
+        agentId,
+        status: STATE_TO_STATUS[state] ?? "unavailable",
+    };
+    if (extra?.missedBeats !== undefined || extra?.lastActivityAt !== undefined) {
+        notification.health = {
+            missedBeats: extra.missedBeats ?? 0,
+            lastActiveAt: extra.lastActivityAt
+                ? new Date(extra.lastActivityAt).toISOString()
+                : new Date().toISOString(),
+        };
+    }
+    if (extra?.usage) {
+        notification.usage = extra.usage;
+    }
+    return notification;
+}

package/dist/cli/agent-status-notifier.test.d.ts

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

package/dist/cli/agent-status-notifier.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { createAgentStatusNotification } from "./agent-status-notifier.js";
+describe("agent status notifier", () => {
+    it("maps process states to agent status notifications", () => {
+        expect(createAgentStatusNotification("agent-a", "starting")).toEqual({
+            agentId: "agent-a",
+            status: "spawning",
+        });
+        expect(createAgentStatusNotification("agent-a", "ready")).toEqual({
+            agentId: "agent-a",
+            status: "available",
+        });
+        expect(createAgentStatusNotification("agent-a", "unknown")).toEqual({
+            agentId: "agent-a",
+            status: "unavailable",
+        });
+    });
+    it("preserves heartbeat health and usage metadata", () => {
+        expect(createAgentStatusNotification("agent-b", "running", {
+            missedBeats: 2,
+            lastActivityAt: Date.UTC(2026, 0, 1),
+            usage: { inputTokens: 3, outputTokens: 5, totalTokens: 8 },
+        })).toEqual({
+            agentId: "agent-b",
+            status: "running",
+            health: {
+                missedBeats: 2,
+                lastActiveAt: "2026-01-01T00:00:00.000Z",
+            },
+            usage: { inputTokens: 3, outputTokens: 5, totalTokens: 8 },
+        });
+    });
+});

package/dist/cli/base-tool-bootstrap.d.ts

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

package/dist/cli/base-tool-bootstrap.js

@@ -0,0 +1,20 @@
+export function configureBaseToolBootstrap(deps) {
+    deps.toolBootstrap.getAllBaseTools({
+        resolveClientForPurpose: deps.resolveClientForPurpose,
+        log: {
+            info: (message) => deps.log(message),
+            warn: (message) => deps.log(`[warn] ${message}`),
+            error: (message) => deps.log(`[error] ${message}`),
+            debug: (message) => { if (deps.verbose)
+                deps.log(`[debug] ${message}`); },
+        },
+        onExecProgress: (progress) => {
+            deps.sendNotification("turn.exec_progress", {
+                output: progress.output,
+                elapsedTimeSeconds: progress.elapsedTimeSeconds,
+                totalLines: progress.totalLines,
+                totalBytes: progress.totalBytes,
+            });
+        },
+    });
+}

package/dist/cli/cli-acp-request-handler.d.ts

@@ -0,0 +1,11 @@
+import type { AcpRequestHandler } from "../transport/acp-server.js";
+import type { PermissionApprovalResolver } from "../runtime/ports/index.js";
+import * as acpExtended from "./acp-extended-handlers.js";
+import * as acpSession from "./acp-session-handlers.js";
+export interface CliAcpRequestHandlerHost extends acpSession.AcpSessionHost {
+    activeTurn: AbortController | null;
+    /** Id of the turn currently running; used to key cancel requests. */
+    currentTurnId?: string;
+    permissionChecker?: PermissionApprovalResolver | null;
+}
+export declare function createCliAcpRequestHandler(host: CliAcpRequestHandlerHost, packageVersion: string, extendedHost?: acpExtended.AcpExtendedHost): AcpRequestHandler;