qlogicagent 2.13.5 → 2.13.6

package/dist/cli/memory-multimodal.test.js

@@ -1,137 +0,0 @@
-/**
- * P2 multimodal understanding: buildMemoryCandidates must, for an image/audio/video
- * attachment, call the matching model and fold the understood text into the
- * candidate — and when no such model is configured, degrade gracefully (素材 still
- * summarized, no throw). Uses a real in-memory pipeline with a test-double LLM
- * transport (allowed in unit tests).
- */
-import { describe, it, expect, vi } from "vitest";
-import { buildMemoryCandidates } from "./memory-candidate-service.js";
-function imageParams() {
-    return {
-        text: "",
-        autoExtract: false, // deterministic path → no LLM extractor needed, just folds attachment text
-        attachments: [{ type: "image", kind: "image", filename: "galaxy.png", mimeType: "image/png", id: "att_img_1" }],
-    };
-}
-describe("P2 multimodal understanding", () => {
-    it("understands an image with the vision model and folds the text into the candidate", async () => {
-        const saved = {};
-        let sawImageUrls = false;
-        const host = {
-            memoryProvider: {
-                search: async () => [],
-                readAttachmentBytes: async (id) => (id === "att_img_1" ? { bytes: Buffer.from("PNGBYTES"), mimeType: "image/png" } : null),
-                setAttachmentText: (id, text) => { saved[id] = text; },
-            },
-            resolveClientForPurpose: (purpose) => purpose !== "imageUnderstanding" ? null : {
-                model: "vision-x",
-                apiKey: "k",
-                transport: {
-                    async *stream(req) {
-                        const msg = req.messages[0];
-                        sawImageUrls = Array.isArray(msg.imageUrls) && msg.imageUrls[0].startsWith("data:image/png;base64,");
-                        yield { type: "delta", text: "A spiral galaxy " };
-                        yield { type: "delta", text: "of bright stars over dark space." };
-                    },
-                },
-            },
-        };
-        const result = await buildMemoryCandidates(host, imageParams(), "user-1");
-        const blob = result.candidates.map((c) => c.text).join(" ");
-        expect(sawImageUrls).toBe(true); // image was sent as a data URL on imageUrls
-        expect(blob).toMatch(/spiral galaxy/i); // understood text folded into the candidate
-        expect(saved["att_img_1"]).toMatch(/spiral galaxy/i); // persisted on the attachment row
-    });
-    it("degrades to B when no vision model is configured (no throw, 素材 still summarized)", async () => {
-        const host = {
-            memoryProvider: {
-                search: async () => [],
-                readAttachmentBytes: async () => ({ bytes: Buffer.from("x"), mimeType: "image/png" }),
-                setAttachmentText: vi.fn(),
-            },
-            resolveClientForPurpose: () => null, // no model for any purpose
-        };
-        const result = await buildMemoryCandidates(host, imageParams(), "user-1");
-        expect(result.candidates.length).toBeGreaterThan(0); // still produced a candidate
-        const blob = result.candidates.map((c) => c.text).join(" ");
-        expect(blob).not.toMatch(/spiral galaxy/i); // no understanding happened
-        expect(blob).toMatch(/galaxy\.png/); // but the素材 (filename) is still captured
-    });
-    it("does not call a model for an image that already carries extracted text", async () => {
-        const resolve = vi.fn(() => null);
-        const host = {
-            memoryProvider: { search: async () => [], readAttachmentBytes: vi.fn(), setAttachmentText: vi.fn() },
-            resolveClientForPurpose: resolve,
-        };
-        const params = { text: "", autoExtract: false, attachments: [{ type: "image", kind: "image", filename: "g.png", mimeType: "image/png", id: "x", text: "pre-existing caption" }] };
-        await buildMemoryCandidates(host, params, "u");
-        expect(resolve).not.toHaveBeenCalled();
-    });
-});
-describe("memory candidate related-memory hygiene", () => {
-    it("does not attach unrelated search hits to deterministic memory candidates", async () => {
-        const host = {
-            memoryProvider: {
-                search: async () => [
-                    {
-                        blockId: "time-bucket-demo",
-                        text: "demo long-memory note: Long Memory System item 'time-bucket' joined the seed data.",
-                        score: 0.18,
-                        metadata: { category: "fact" },
-                    },
-                ],
-            },
-            resolveClientForPurpose: () => null,
-        };
-        const result = await buildMemoryCandidates(host, {
-            text: "The user likes Han Li from A Record of a Mortal's Journey to Immortality.",
-            autoExtract: false,
-        }, "user-1");
-        expect(result.related).toEqual([]);
-        expect(result.candidates[0]?.relatedMemoryIds).toEqual([]);
-    });
-    it("keeps only vetted related ids from LLM extractor output", async () => {
-        const host = {
-            memoryProvider: {
-                search: async () => [
-                    {
-                        blockId: "han-li-preference",
-                        text: "The user likes Han Li and grounded cultivation story arcs.",
-                        score: 0.42,
-                        metadata: { category: "preference" },
-                    },
-                    {
-                        blockId: "time-bucket-demo",
-                        text: "demo long-memory note: Long Memory System item 'time-bucket' joined the seed data.",
-                        score: 0.18,
-                        metadata: { category: "fact" },
-                    },
-                ],
-            },
-            resolveClientForPurpose: () => ({
-                model: "small",
-                apiKey: "k",
-                transport: {
-                    async *stream() {
-                        yield {
-                            type: "delta",
-                            text: JSON.stringify({
-                                memories: [{
-                                        text: "The user likes Han Li and grounded cultivation stories.",
-                                        category: "preference",
-                                        relatedMemoryIds: ["han-li-preference", "time-bucket-demo", "invented"],
-                                    }],
-                            }),
-                        };
-                    },
-                },
-            }),
-        };
-        const result = await buildMemoryCandidates(host, {
-            text: "Remember that I like Han Li from A Record of a Mortal's Journey to Immortality.",
-        }, "user-1");
-        expect(result.related.map((item) => item.id)).toEqual(["han-li-preference"]);
-        expect(result.candidates[0]?.relatedMemoryIds).toEqual(["han-li-preference"]);
-    });
-});

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

@@ -1,31 +0,0 @@
-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";
-export interface ResolvedModelClient {
-    transport: LLMTransport;
-    apiKey: string;
-    model: string;
-}
-export interface ResolvedTextGenerationConfig {
-    provider: string;
-    model: string;
-    apiKey: string;
-    baseUrl?: string;
-    configKey: string;
-}
-export type KeyHandleProvider = () => KeyHandle | null | undefined;
-type ModelClientResolverDeps = {
-    purpose: ModelPurpose;
-    providerRegistry: ProviderRegistry;
-    currentProvider: string;
-    currentTransport: LLMTransport | 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/cli/model-client-resolver.js

@@ -1,173 +0,0 @@
-import { getModelRegistry } from "../runtime/infra/model-registry.js";
-import { createLLMClient, } from "./provider-core-facade.js";
-const textGenerationKeyState = new WeakMap();
-export function wrapTransportWithKeyHandleProvider(transport, acquireKeyHandle) {
-    return {
-        ...transport,
-        stream: async function* (request, apiKey, signal) {
-            const keyHandle = acquireKeyHandle();
-            const requestApiKey = keyHandle?.apiKey ?? apiKey;
-            let tokens = 0;
-            let success = true;
-            try {
-                for await (const chunk of transport.stream(request, requestApiKey, signal)) {
-                    if (chunk.type === "usage") {
-                        tokens += chunk.promptTokens + chunk.completionTokens + (chunk.reasoningTokens ?? 0);
-                    }
-                    else if (chunk.type === "error") {
-                        success = false;
-                    }
-                    yield chunk;
-                }
-                keyHandle?.release({ success, tokens: tokens || undefined });
-            }
-            catch (error) {
-                keyHandle?.release({ success: false });
-                throw error;
-            }
-        },
-        complete: transport.complete
-            ? async function* (request, apiKey, signal) {
-                const keyHandle = acquireKeyHandle();
-                const requestApiKey = keyHandle?.apiKey ?? apiKey;
-                try {
-                    for await (const chunk of transport.complete(request, requestApiKey, signal)) {
-                        yield chunk;
-                    }
-                    keyHandle?.release({ success: true });
-                }
-                catch (error) {
-                    keyHandle?.release({ success: false });
-                    throw error;
-                }
-            }
-            : undefined,
-    };
-}
-export function wrapTransportWithKeyHandle(transport, keyHandle) {
-    let pending = keyHandle;
-    return wrapTransportWithKeyHandleProvider(transport, () => {
-        const handle = pending;
-        pending = undefined;
-        return handle;
-    });
-}
-export function takeTextGenerationKeyHandleProvider(config) {
-    const state = textGenerationKeyState.get(config);
-    return () => {
-        if (!state)
-            return null;
-        const initial = state.initial;
-        if (initial) {
-            state.initial = undefined;
-            return initial;
-        }
-        return state.acquire?.() ?? null;
-    };
-}
-export function releaseUnusedTextGenerationKeyHandle(config) {
-    const state = textGenerationKeyState.get(config);
-    if (!state?.initial)
-        return;
-    state.initial.release({ success: true });
-    state.initial = undefined;
-}
-export function resolveTextGenerationConfig(config, log) {
-    let provider = config.provider;
-    let model = config.model;
-    let apiKey = config.apiKey;
-    let baseUrl = config.baseUrl;
-    if (!provider || !apiKey) {
-        const registry = getModelRegistry();
-        const resolved = registry.getActiveModel("textGeneration");
-        if (resolved) {
-            provider = provider ?? resolved.provider;
-            model = model ?? resolved.model;
-            apiKey = apiKey ?? resolved.apiKey;
-            baseUrl = baseUrl ?? resolved.baseUrl;
-            log?.(`[resolveAgent] from ModelRegistry: ${provider}/${model} baseUrl=${baseUrl ?? "(none)"} keyLen=${apiKey?.length ?? 0}`);
-            const out = {
-                provider,
-                model: model ?? getModelRegistry().getProviderDefaultModel(provider) ?? "",
-                apiKey,
-                baseUrl,
-                configKey: `${provider}:${(model ?? "")}:${apiKey.slice(0, 8)}:${baseUrl ?? ""}`,
-            };
-            textGenerationKeyState.set(out, {
-                initial: resolved.keyHandle,
-                acquire: () => {
-                    const next = getModelRegistry().getActiveModel("textGeneration");
-                    if (!next)
-                        return null;
-                    if (next.provider !== provider || next.model !== (model ?? next.model) || (next.baseUrl ?? "") !== (baseUrl ?? "")) {
-                        next.keyHandle.release({ success: true });
-                        return null;
-                    }
-                    return next.keyHandle;
-                },
-            });
-            return out;
-        }
-    }
-    if (!provider || !apiKey) {
-        return null;
-    }
-    model = model ?? getModelRegistry().getProviderDefaultModel(provider) ?? "";
-    return {
-        provider,
-        model,
-        apiKey,
-        baseUrl,
-        configKey: `${provider}:${model}:${apiKey.slice(0, 8)}:${baseUrl ?? ""}`,
-    };
-}
-function resolveManagedModelClientForPurpose(deps) {
-    const registry = getModelRegistry();
-    const resolved = registry.getActiveModel(deps.purpose);
-    if (!resolved)
-        return null;
-    const { provider, model, apiKey, baseUrl, keyHandle } = resolved;
-    let pending = keyHandle;
-    const wrap = (transport) => wrapTransportWithKeyHandleProvider(transport, () => {
-        const handle = pending;
-        pending = undefined;
-        return handle;
-    });
-    const releaseUnused = () => {
-        if (!pending)
-            return;
-        pending.release({ success: true });
-        pending = undefined;
-    };
-    if (provider === deps.currentProvider && deps.currentTransport) {
-        return { transport: wrap(deps.currentTransport), apiKey, model, releaseUnused };
-    }
-    const client = createLLMClient({ provider, model, apiKey, baseUrl }, deps.providerRegistry);
-    return { transport: wrap(client.transport), apiKey, model, releaseUnused };
-}
-export function resolveModelClientForPurpose(deps) {
-    const managed = resolveManagedModelClientForPurpose(deps);
-    if (!managed)
-        return null;
-    return {
-        transport: managed.transport,
-        apiKey: managed.apiKey,
-        model: managed.model,
-    };
-}
-export async function withResolvedModelClient(deps, fn) {
-    const managed = resolveManagedModelClientForPurpose(deps);
-    if (!managed)
-        return null;
-    const client = {
-        transport: managed.transport,
-        apiKey: managed.apiKey,
-        model: managed.model,
-    };
-    try {
-        return await fn(client);
-    }
-    finally {
-        managed.releaseUnused();
-    }
-}

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

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

package/dist/cli/model-client-resolver.test.js

@@ -1,105 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { getModelRegistry, resetModelRegistry } from "../runtime/infra/model-registry.js";
-import { releaseUnusedTextGenerationKeyHandle, resolveModelClientForPurpose, resolveTextGenerationConfig, withResolvedModelClient } from "./model-client-resolver.js";
-afterEach(() => {
-    resetModelRegistry();
-});
-function bindModel(purpose) {
-    const registry = getModelRegistry();
-    registry.addProvider("provider");
-    registry.addKey("provider", "secret");
-    registry.addModel({
-        id: `provider:${purpose}`,
-        provider: "provider",
-        model: purpose,
-        displayName: purpose,
-        purposes: [purpose],
-        enabled: true,
-    });
-    registry.setBinding(purpose, `provider:${purpose}`);
-}
-describe("model-client resolver key handles", () => {
-    it("hides side-operation key handles from direct callers", async () => {
-        bindModel("smallModel");
-        const transport = { stream: async function* () { } };
-        const resolved = resolveModelClientForPurpose({
-            purpose: "smallModel",
-            providerRegistry: {},
-            currentProvider: "provider",
-            currentTransport: transport,
-        });
-        expect(getModelRegistry().getProviderStatus("provider")?.keys[0]?.inFlight).toBe(1);
-        expect(resolved && "keyHandle" in resolved).toBe(false);
-        for await (const _chunk of resolved.transport.stream({
-            model: resolved.model,
-            messages: [],
-            tools: [],
-        }, resolved.apiKey)) {
-            // drain
-        }
-        expect(getModelRegistry().getProviderStatus("provider")?.keys[0]?.inFlight).toBe(0);
-    });
-    it("releases side-operation key handles after the wrapped stream completes", async () => {
-        bindModel("smallModel");
-        const transport = {
-            stream: async function* () {
-                yield { type: "usage", promptTokens: 7, completionTokens: 5 };
-                yield { type: "done", finishReason: "stop" };
-            },
-        };
-        const resolved = resolveModelClientForPurpose({
-            purpose: "smallModel",
-            providerRegistry: {},
-            currentProvider: "provider",
-            currentTransport: transport,
-        });
-        for await (const _chunk of resolved.transport.stream({
-            model: resolved.model,
-            messages: [],
-            tools: [],
-        }, resolved.apiKey)) {
-            // drain
-        }
-        const status = getModelRegistry().getProviderStatus("provider")?.keys[0];
-        expect(status?.inFlight).toBe(0);
-        expect(status?.totalTokens).toBe(12);
-    });
-    it("scopes resolved model clients without exposing a key handle", async () => {
-        bindModel("smallModel");
-        const transport = {
-            stream: async function* () {
-                yield { type: "usage", promptTokens: 3, completionTokens: 4 };
-                yield { type: "done", finishReason: "stop" };
-            },
-        };
-        const result = await withResolvedModelClient({
-            purpose: "smallModel",
-            providerRegistry: {},
-            currentProvider: "provider",
-            currentTransport: transport,
-        }, async (client) => {
-            expect("keyHandle" in client).toBe(false);
-            for await (const _chunk of client.transport.stream({
-                model: client.model,
-                messages: [],
-                tools: [],
-            }, client.apiKey)) {
-                // drain
-            }
-            return "ok";
-        });
-        const status = getModelRegistry().getProviderStatus("provider")?.keys[0];
-        expect(result).toBe("ok");
-        expect(status?.inFlight).toBe(0);
-        expect(status?.totalTokens).toBe(7);
-    });
-    it("keeps text-generation key handles in flight until the agent transport releases them", () => {
-        bindModel("textGeneration");
-        const resolved = resolveTextGenerationConfig({});
-        expect(getModelRegistry().getProviderStatus("provider")?.keys[0]?.inFlight).toBe(1);
-        expect(resolved && "keyHandle" in resolved).toBe(false);
-        if (resolved)
-            releaseUnusedTextGenerationKeyHandle(resolved);
-        expect(getModelRegistry().getProviderStatus("provider")?.keys[0]?.inFlight).toBe(0);
-    });
-});

package/dist/cli/multi-agent-handler-host.d.ts

@@ -1,27 +0,0 @@
-import type { AgentRpcError } from "../protocol/wire/index.js";
-import type { AgentConfigRuntime, AgentConfigRuntimeDeps } from "./agent-config-runtime.js";
-import type { AgentsHandlerHost } from "./handlers/agents-handler.js";
-import type { ProductHandlerHost } from "./handlers/product-handler.js";
-import type { SoloHandlerHost } from "./handlers/solo-handler.js";
-type AgentStatusExtra = {
-    missedBeats?: number;
-    lastActivityAt?: number;
-    usage?: {
-        inputTokens: number;
-        outputTokens: number;
-        totalTokens: number;
-    };
-};
-export type MultiAgentHandlerHost = AgentsHandlerHost & SoloHandlerHost & ProductHandlerHost;
-export interface MultiAgentHandlerHostDeps {
-    acpDetector?: AgentsHandlerHost["acpDetector"];
-    createAgentConfigRuntime?: (deps: AgentConfigRuntimeDeps) => AgentConfigRuntime;
-    getActiveProjectRoot(): string;
-    emitAgentStatus(agentId: string, state: string, extra?: AgentStatusExtra): void;
-    handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    log(message: string): void;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function createMultiAgentHandlerHost(deps: MultiAgentHandlerHostDeps): MultiAgentHandlerHost;
-export {};

package/dist/cli/multi-agent-handler-host.js

@@ -1,55 +0,0 @@
-import { AcpDetector } from "../runtime/infra/acp-detector.js";
-import { createAgentConfigRuntime as createDefaultAgentConfigRuntime } from "./agent-config-runtime.js";
-import { MultiAgentStateCoordinator } from "./multi-agent-state-coordinator.js";
-export function createMultiAgentHandlerHost(deps) {
-    const acpDetector = deps.acpDetector ?? new AcpDetector();
-    const state = new MultiAgentStateCoordinator();
-    const createRuntime = deps.createAgentConfigRuntime ?? createDefaultAgentConfigRuntime;
-    const agentConfigRuntime = createRuntime({
-        acpDetector,
-        getActiveProjectRoot: deps.getActiveProjectRoot,
-    });
-    return {
-        acpDetector,
-        get agentConfigStore() {
-            return agentConfigRuntime.currentStore;
-        },
-        ensureAgentConfigStore: () => agentConfigRuntime.ensureStore(),
-        get soloEvaluator() {
-            return state.soloEvaluator;
-        },
-        set soloEvaluator(value) {
-            state.soloEvaluator = value;
-        },
-        get productOrchestrator() {
-            return state.productOrchestrator;
-        },
-        set productOrchestrator(value) {
-            state.productOrchestrator = value;
-        },
-        get productPlanner() {
-            return state.productPlanner;
-        },
-        set productPlanner(value) {
-            state.productPlanner = value;
-        },
-        get soloProcessManager() {
-            return state.soloProcessManager;
-        },
-        set soloProcessManager(value) {
-            state.soloProcessManager = value;
-        },
-        get productProcessManager() {
-            return state.productProcessManager;
-        },
-        set productProcessManager(value) {
-            state.productProcessManager = value;
-        },
-        getActiveProjectRoot: deps.getActiveProjectRoot,
-        emitAgentStatus: deps.emitAgentStatus,
-        handleMcpToolCall: deps.handleMcpToolCall,
-        log: deps.log,
-        sendNotification: deps.sendNotification,
-        sendResponse: deps.sendResponse,
-    };
-}

package/dist/cli/multi-agent-handler-host.test.d.ts

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

package/dist/cli/multi-agent-handler-host.test.js

@@ -1,63 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createMultiAgentHandlerHost } from "./multi-agent-handler-host.js";
-describe("createMultiAgentHandlerHost", () => {
-    it("owns multi-agent state while delegating host services", async () => {
-        const store = { marker: "store" };
-        const runtime = {
-            currentStore: null,
-            ensureStore: vi.fn(async () => {
-                runtime.currentStore = store;
-                return store;
-            }),
-        };
-        const acpDetector = { kind: "detector" };
-        const notifications = [];
-        const responses = [];
-        const statuses = [];
-        const toolCalls = [];
-        const host = createMultiAgentHandlerHost({
-            acpDetector: acpDetector,
-            createAgentConfigRuntime: ({ acpDetector: detector, getActiveProjectRoot }) => {
-                expect(detector).toBe(acpDetector);
-                expect(getActiveProjectRoot()).toBe("F:\\workspace");
-                return runtime;
-            },
-            getActiveProjectRoot: () => "F:\\workspace",
-            emitAgentStatus: (agentId, state) => statuses.push({ agentId, state }),
-            handleMcpToolCall: async (memberId, toolName, args) => {
-                toolCalls.push({ memberId, toolName, args });
-                return "tool-result";
-            },
-            log: vi.fn(),
-            sendNotification: (method, params) => notifications.push({ method, params }),
-            sendResponse: (id, result, error) => responses.push({ id, result, error }),
-        });
-        expect(host.acpDetector).toBe(acpDetector);
-        expect(host.agentConfigStore).toBeNull();
-        await expect(host.ensureAgentConfigStore()).resolves.toBe(store);
-        expect(host.agentConfigStore).toBe(store);
-        const soloEvaluator = { id: "solo" };
-        const productOrchestrator = { id: "product" };
-        const productPlanner = { id: "planner" };
-        const soloProcessManager = { id: "solo-pm" };
-        const productProcessManager = { id: "product-pm" };
-        host.soloEvaluator = soloEvaluator;
-        host.productOrchestrator = productOrchestrator;
-        host.productPlanner = productPlanner;
-        host.soloProcessManager = soloProcessManager;
-        host.productProcessManager = productProcessManager;
-        expect(host.soloEvaluator).toBe(soloEvaluator);
-        expect(host.productOrchestrator).toBe(productOrchestrator);
-        expect(host.productPlanner).toBe(productPlanner);
-        expect(host.soloProcessManager).toBe(soloProcessManager);
-        expect(host.productProcessManager).toBe(productProcessManager);
-        host.sendNotification("agents.status", { ok: true });
-        host.sendResponse("rpc-1", { ok: true });
-        host.emitAgentStatus("agent-1", "running");
-        await expect(host.handleMcpToolCall("member-1", "read", { path: "README.md" })).resolves.toBe("tool-result");
-        expect(notifications).toEqual([{ method: "agents.status", params: { ok: true } }]);
-        expect(responses).toEqual([{ id: "rpc-1", result: { ok: true }, error: undefined }]);
-        expect(statuses).toEqual([{ agentId: "agent-1", state: "running" }]);
-        expect(toolCalls).toEqual([{ memberId: "member-1", toolName: "read", args: { path: "README.md" } }]);
-    });
-});

package/dist/cli/multi-agent-state-coordinator.d.ts

@@ -1,11 +0,0 @@
-import type { ProductOrchestrator } from "../orchestration/agent-instance.js";
-import type { ProductPlanner } from "../orchestration/product-planner.js";
-import type { SoloEvaluator } from "../orchestration/solo-evaluator.js";
-import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
-export declare class MultiAgentStateCoordinator {
-    soloEvaluator: SoloEvaluator | null;
-    productOrchestrator: ProductOrchestrator | null;
-    productPlanner: ProductPlanner | null;
-    soloProcessManager: AgentProcessManager | null;
-    productProcessManager: AgentProcessManager | null;
-}

package/dist/cli/multi-agent-state-coordinator.js

@@ -1,7 +0,0 @@
-export class MultiAgentStateCoordinator {
-    soloEvaluator = null;
-    productOrchestrator = null;
-    productPlanner = null;
-    soloProcessManager = null;
-    productProcessManager = null;
-}

package/dist/cli/permission-approval-bridge.d.ts

@@ -1,15 +0,0 @@
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { AcpPermissionRequestParams } from "../protocol/wire/index.js";
-import type { ApprovalRequest, ApprovalResponse } from "../runtime/ports/index.js";
-export interface PermissionApprovalBridgeDeps {
-    getAcpPermissionSession(): {
-        sessionId: string;
-        requestPermission(params: AcpPermissionRequestParams): Promise<{
-            optionId?: string;
-        }>;
-    } | undefined;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-    isPetActive(): boolean;
-}
-export declare function requestPermissionApproval(request: ApprovalRequest, deps: PermissionApprovalBridgeDeps): Promise<ApprovalResponse>;
-export declare function createApprovalResponseFromAcpOption(request: ApprovalRequest, optionId: string | undefined): ApprovalResponse;