qlogicagent 2.13.5 → 2.13.7

package/dist/cli/core-tool-coordinator.d.ts

@@ -1,41 +0,0 @@
-import type { AgentLogger, ChatMessage, ToolInvoker } from "../agent/types.js";
-import type { HookRegistry } from "../contracts/hooks.js";
-import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
-import type { ToolCatalog } from "../runtime/ports/index.js";
-import type { LLMTransport } from "./provider-core-facade.js";
-export interface CliCoreToolHostDeps {
-    getAgent(): unknown | null;
-    getCurrentTransport(): LLMTransport | null;
-    getCurrentProvider(): string;
-    getCurrentApiKey(): string;
-    getCurrentModel(): string;
-    getCurrentBaseUrl(): string;
-    getCurrentSessionId(): string;
-    getActiveProjectRoot(): string;
-    getVerbose(): boolean;
-    getBackgroundTasks(): BackgroundTaskManager | null;
-    getConversationHistory(): readonly ChatMessage[] | null;
-    isGroupContext(): boolean;
-    getMemoryIndex(): string | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    emitAgentStatus(agentId: string, state: string, extra?: {
-        missedBeats?: number;
-        lastActivityAt?: number;
-        usage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-        };
-    }): void;
-    handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
-}
-export interface CliCoreToolCoordinatorDeps {
-    config: Record<string, unknown>;
-    host: CliCoreToolHostDeps;
-    hooks: HookRegistry;
-    log: AgentLogger;
-    toolCatalog: ToolCatalog;
-    toolInvoker: ToolInvoker;
-}
-export declare const coreToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<CliCoreToolCoordinatorDeps>;
-export declare function configureCliCoreTools(deps: CliCoreToolCoordinatorDeps): void;

package/dist/cli/core-tool-coordinator.js

@@ -1,55 +0,0 @@
-import { defineToolRegistrationModule } from "../runtime/ports/index.js";
-import { registerCoreToolSet } from "./core-tools/registry.js";
-export const coreToolRegistrationModule = defineToolRegistrationModule({
-    id: "cli-core-tools",
-    kind: "core",
-    register: configureCliCoreToolsInternal,
-});
-export function configureCliCoreTools(deps) {
-    coreToolRegistrationModule.register(deps);
-}
-function configureCliCoreToolsInternal(deps) {
-    const host = {
-        get agent() { return deps.host.getAgent(); },
-        get currentTransport() { return deps.host.getCurrentTransport(); },
-        get currentApiKey() { return deps.host.getCurrentApiKey(); },
-        get currentModel() { return deps.host.getCurrentModel(); },
-        get currentBaseUrl() { return deps.host.getCurrentBaseUrl(); },
-        get currentSessionId() { return deps.host.getCurrentSessionId(); },
-        getActiveProjectRoot: () => deps.host.getActiveProjectRoot(),
-        get verbose() { return deps.host.getVerbose(); },
-        getBackgroundTasks: () => deps.host.getBackgroundTasks(),
-        getConversationHistory: () => deps.host.getConversationHistory(),
-        isGroupContext: () => deps.host.isGroupContext(),
-        getMemoryIndex: () => deps.host.getMemoryIndex(),
-        getLlmConfig: () => {
-            // provider+apiKey are what the member's turn resolution requires
-            // (resolveTextGenerationConfig); model must be explicit too — a
-            // standalone member has no registry to default it from.
-            const provider = deps.host.getCurrentProvider();
-            const model = deps.host.getCurrentModel();
-            const apiKey = deps.host.getCurrentApiKey();
-            if (!provider || !model || !apiKey)
-                return null;
-            return { provider, model, apiKey, baseUrl: deps.host.getCurrentBaseUrl() || undefined };
-        },
-        sendNotification(method, params) {
-            deps.host.sendNotification(method, params);
-        },
-        emitAgentStatus(agentId, state, extra) {
-            deps.host.emitAgentStatus(agentId, state, extra);
-        },
-        handleMcpToolCall(memberId, toolName, args) {
-            return deps.host.handleMcpToolCall(memberId, toolName, args);
-        },
-    };
-    const registrationDeps = {
-        config: deps.config,
-        host,
-        hooks: deps.hooks,
-        log: deps.log,
-        toolCatalog: deps.toolCatalog,
-        toolInvoker: deps.toolInvoker,
-    };
-    registerCoreToolSet(registrationDeps);
-}

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

@@ -1,12 +0,0 @@
-import type { AgentLogger, ToolInvoker } from "../../agent/types.js";
-import type { HookRegistry } from "../../contracts/hooks.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-import { type AgentToolServiceHost } from "./agent-tool-service.js";
-export interface AgentToolRegistrationDeps {
-    host: AgentToolServiceHost;
-    hooks: HookRegistry;
-    log: AgentLogger;
-    toolCatalog: ToolCatalog;
-    toolInvoker: ToolInvoker;
-}
-export declare function registerAgentTool({ host, hooks, log, toolCatalog, toolInvoker }: AgentToolRegistrationDeps): void;

package/dist/cli/core-tools/agent-tool-bootstrap.js

@@ -1,5 +0,0 @@
-import { createAgentTool } from "../../skills/tools/agent-tool.js";
-import { createAgentToolService } from "./agent-tool-service.js";
-export function registerAgentTool({ host, hooks, log, toolCatalog, toolInvoker }) {
-    toolCatalog.addTool(createAgentTool(createAgentToolService({ host, hooks, log, toolCatalog, toolInvoker })));
-}

package/dist/cli/core-tools/agent-tool-service.background.test.d.ts

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

package/dist/cli/core-tools/agent-tool-service.background.test.js

@@ -1,212 +0,0 @@
-/**
- * Real-chain integration for agent(background=true):
- * agent-tool-service → BackgroundTaskManager → runForkedAgent → REAL Agent
- * tool loop (createCliForkedAgentRunner) — only the LLM transport is scripted.
- * Verifies: immediate task id, lifecycle in the shared TaskStore, output
- * capture, and the settled notification used for next-turn injection.
- */
-import { describe, expect, it, vi } from "vitest";
-import { createHookRegistry } from "../../runtime/hooks/hook-registry.js";
-import { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
-import { TaskStore, buildTaskNotification } from "../../runtime/infra/task-runtime.js";
-import { createToolCatalogFixture } from "../test-support/tool-catalog-fixture.js";
-import { createAgentToolService } from "./agent-tool-service.js";
-class ScriptedTransport {
-    rounds;
-    requests = [];
-    constructor(rounds) {
-        this.rounds = rounds;
-    }
-    async *stream(request) {
-        this.requests.push(request);
-        const round = this.rounds.shift();
-        if (!round)
-            throw new Error("unexpected LLM round");
-        for (const chunk of round)
-            yield chunk;
-    }
-}
-const log = {
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-};
-function waitFor(predicate, timeoutMs = 5_000) {
-    return new Promise((resolve, reject) => {
-        const start = Date.now();
-        const tick = () => {
-            if (predicate())
-                return resolve();
-            if (Date.now() - start > timeoutMs)
-                return reject(new Error("waitFor timeout"));
-            setTimeout(tick, 10);
-        };
-        tick();
-    });
-}
-describe("agent(background=true) real chain", () => {
-    it("returns a task id immediately, runs the fork to completion, and queues the settled notification", async () => {
-        const store = new TaskStore();
-        const manager = new BackgroundTaskManager(store);
-        const notifications = [];
-        manager.onTaskSettled((task) => {
-            notifications.push(buildTaskNotification(task, task.output ?? task.error ?? ""));
-        });
-        const transport = new ScriptedTransport([
-            [
-                { type: "delta", text: "Background research finished: 42." },
-                { type: "usage", promptTokens: 12, completionTokens: 8 },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const toolInvoker = { invoke: vi.fn(async () => ({ result: "" })) };
-        const deps = createAgentToolService({
-            host: {
-                agent: {},
-                currentTransport: transport,
-                currentApiKey: "test-key",
-                currentModel: "test-model",
-                sendNotification: vi.fn(),
-                getBackgroundTasks: () => manager,
-                getConversationHistory: () => null,
-                isGroupContext: () => false,
-                getActiveProjectRoot: () => process.cwd(),
-                getMemoryIndex: () => null,
-            },
-            hooks: createHookRegistry(log),
-            log,
-            toolCatalog: createToolCatalogFixture(),
-            toolInvoker,
-        });
-        const result = await deps.forkAgent({
-            agent: "general",
-            prompt: "Research the answer to everything and report back.",
-            background: true,
-        });
-        // Immediate: real task id, status running, task visible in the store
-        expect(result.status).toBe("running");
-        expect(result.agentId).toMatch(/^a[a-z0-9]{8}$/);
-        expect(store.getTask(result.agentId)?.lifecycle).toBe("running");
-        // The fork completes through the REAL agent loop against the scripted LLM
-        await waitFor(() => store.getTask(result.agentId)?.lifecycle === "completed");
-        const task = store.getTask(result.agentId);
-        expect(task.output).toContain("Background research finished: 42.");
-        // The settled notification is ready for next-turn injection
-        expect(notifications).toHaveLength(1);
-        expect(notifications[0]).toContain(result.agentId);
-        expect(notifications[0]).toContain("completed successfully");
-        expect(notifications[0]).toContain("Background research finished: 42.");
-        // The scripted LLM actually received the fork request
-        expect(transport.requests.length).toBe(1);
-    });
-    it("fails loud when background is requested but no registry exists", async () => {
-        const transport = new ScriptedTransport([]);
-        const deps = createAgentToolService({
-            host: {
-                agent: {},
-                currentTransport: transport,
-                currentApiKey: "test-key",
-                currentModel: "test-model",
-                sendNotification: vi.fn(),
-                getBackgroundTasks: () => null,
-                getConversationHistory: () => null,
-                isGroupContext: () => false,
-                getActiveProjectRoot: () => process.cwd(),
-                getMemoryIndex: () => null,
-            },
-            hooks: createHookRegistry(log),
-            log,
-            toolCatalog: createToolCatalogFixture(),
-            toolInvoker: { invoke: vi.fn(async () => ({ result: "" })) },
-        });
-        const result = await deps.forkAgent({
-            agent: "general",
-            prompt: "This should not silently pretend to run.",
-            background: true,
-        });
-        expect(result.status).toBe("failed");
-        expect(result.error).toContain("Background execution is not available");
-    });
-    it("inheritContext=true (foreground) prepends the trimmed parent conversation to the fork", async () => {
-        const transport = new ScriptedTransport([
-            [
-                { type: "delta", text: "ack" },
-                { type: "usage", promptTokens: 5, completionTokens: 1 },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const deps = createAgentToolService({
-            host: {
-                agent: {},
-                currentTransport: transport,
-                currentApiKey: "test-key",
-                currentModel: "test-model",
-                sendNotification: vi.fn(),
-                getBackgroundTasks: () => null,
-                getConversationHistory: () => [
-                    { role: "user", content: "the project codename is BLUEJAY" },
-                    { role: "assistant", content: "noted, BLUEJAY" },
-                ],
-                isGroupContext: () => false,
-                getActiveProjectRoot: () => process.cwd(),
-                getMemoryIndex: () => null,
-            },
-            hooks: createHookRegistry(log),
-            log,
-            toolCatalog: createToolCatalogFixture(),
-            toolInvoker: { invoke: vi.fn(async () => ({ result: "" })) },
-        });
-        await deps.forkAgent({ agent: "general", prompt: "what is the codename?", inheritContext: true });
-        // The fork request carries the parent prefix + the task prompt as the final user msg.
-        const msgs = transport.requests[0].messages;
-        const joined = msgs.map((m) => `${m.role}:${m.content}`).join("\n");
-        expect(joined).toContain("BLUEJAY");
-        expect(msgs[msgs.length - 1].content).toContain("what is the codename?");
-    });
-    it("inheritContext is ignored for background forks (always fresh)", async () => {
-        const store = new TaskStore();
-        const manager = new BackgroundTaskManager(store);
-        const transport = new ScriptedTransport([
-            [
-                { type: "delta", text: "done" },
-                { type: "usage", promptTokens: 5, completionTokens: 1 },
-                { type: "done", finishReason: "stop" },
-            ],
-        ]);
-        const deps = createAgentToolService({
-            host: {
-                agent: {},
-                currentTransport: transport,
-                currentApiKey: "test-key",
-                currentModel: "test-model",
-                sendNotification: vi.fn(),
-                getBackgroundTasks: () => manager,
-                getConversationHistory: () => [{ role: "user", content: "the codename is BLUEJAY" }],
-                isGroupContext: () => false,
-                getActiveProjectRoot: () => process.cwd(),
-                getMemoryIndex: () => null,
-            },
-            hooks: createHookRegistry(log),
-            log,
-            toolCatalog: createToolCatalogFixture(),
-            toolInvoker: { invoke: vi.fn(async () => ({ result: "" })) },
-        });
-        const result = await deps.forkAgent({
-            agent: "general",
-            prompt: "do the thing",
-            background: true,
-            inheritContext: true,
-        });
-        expect(result.status).toBe("running");
-        await waitFor(() => store.getTask(result.agentId)?.lifecycle === "completed");
-        // Background fork started fresh — no parent conversation leaked in.
-        // (A persona/rules system prompt may be present as a separate message; what
-        // matters is that the parent CONVERSATION wasn't inherited.)
-        const msgs = transport.requests[0].messages;
-        const userMsgs = msgs.filter((m) => m.role === "user");
-        expect(userMsgs).toHaveLength(1);
-        expect(userMsgs[0].content).toBe("do the thing");
-        expect(msgs.some((m) => String(m.content).includes("BLUEJAY"))).toBe(false);
-    });
-});

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

@@ -1,36 +0,0 @@
-import type { AgentLogger, ToolInvoker } from "../../agent/types.js";
-import type { HookRegistry } from "../../contracts/hooks.js";
-import type { ChatMessage } from "../../agent/types.js";
-import type { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-import type { AgentToolDeps } from "../../skills/tools/agent-tool.js";
-import type { LLMTransport } from "../provider-core-facade.js";
-export interface AgentToolServiceHost {
-    readonly agent: unknown | null;
-    readonly currentTransport: LLMTransport | null;
-    readonly currentApiKey: string;
-    readonly currentModel: string;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    /** Unified background execution registry. Required for background=true forks. */
-    getBackgroundTasks(): BackgroundTaskManager | null;
-    /**
-     * Parent conversation history for inheritContext=true forks (foreground only).
-     * Returns the raw prior turns; the service trims/strips/budget-caps them.
-     * Null/empty → the sub-agent starts fresh.
-     */
-    getConversationHistory(): readonly ChatMessage[] | null;
-    /** Whether the current turn is group-chat / untrusted (drives context redaction). */
-    isGroupContext(): boolean;
-    /** Active project root — for loading the subagent's project rules / AGENTS. */
-    getActiveProjectRoot(): string;
-    /** Lightweight memory INDEX block injected into the subagent system prompt. */
-    getMemoryIndex(): string | null;
-}
-export interface AgentToolServiceOptions {
-    host: AgentToolServiceHost;
-    hooks: HookRegistry;
-    log: AgentLogger;
-    toolCatalog: ToolCatalog;
-    toolInvoker: ToolInvoker;
-}
-export declare function createAgentToolService({ host, hooks, log, toolCatalog, toolInvoker }: AgentToolServiceOptions): AgentToolDeps;

package/dist/cli/core-tools/agent-tool-service.js

@@ -1,152 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { runtimeVars } from "../../agent/runtime-vars.js";
-import { getBuiltInAgent } from "../../orchestration/subagent/agent-registry.js";
-import { resolveForkChildTools } from "../../orchestration/subagent/fork-subagent.js";
-import { getCurrentForkDepth } from "../../runtime/execution/fork-context.js";
-import { runForkedAgent } from "../../runtime/execution/forked-agent.js";
-import { filterToolsForAgent } from "../../skills/tool-access.js";
-import { buildConversationContextSlice } from "../conversation-context.js";
-import { buildSubagentSystemPrompt, personaForAgentDefinition } from "./fork-system-prompt.js";
-import { createCliForkedAgentRunner } from "../agent-runner-factory.js";
-/** Token budget for an inherited parent-conversation prefix (inheritContext=true). */
-const CONTEXT_INHERIT_BUDGET = 32_000;
-function extractForkOutput(result) {
-    return result.events
-        .filter(event => event.type === "end" && "content" in event)
-        .map(event => event.content ?? "")
-        .join("") || result.events
-        .filter(event => event.type === "delta" && "text" in event)
-        .map(event => event.text)
-        .join("");
-}
-export function createAgentToolService({ host, hooks, log, toolCatalog, toolInvoker }) {
-    return {
-        abortSignal: undefined,
-        // Live ALS read: inside a forked agent this reports the real nesting depth,
-        // so the MAX_FORK_DEPTH guard in the agent tool operates on actual values.
-        get currentForkDepth() { return getCurrentForkDepth(); },
-        forkAgent: async (forkParams) => {
-            const agentDef = getBuiltInAgent(forkParams.agent);
-            if (!agentDef) {
-                return { agentId: "", status: "failed", error: `Unknown agent type: ${forkParams.agent}` };
-            }
-            if (!host.agent || !host.currentTransport || !host.currentApiKey || !host.currentModel) {
-                return { agentId: "", status: "failed", error: "No LLM provider configured" };
-            }
-            const parentToolNames = toolCatalog.getToolNames();
-            const childToolNames = resolveForkChildTools(parentToolNames, agentDef);
-            const allToolDefs = toolCatalog.getToolManifest(true);
-            const childToolDefs = allToolDefs.filter(tool => childToolNames.includes(tool.function.name));
-            const filteredChildDefs = filterToolsForAgent(childToolDefs, true);
-            const maxTurns = forkParams.maxTurns ?? agentDef.maxTurns ?? 200;
-            const depth = getCurrentForkDepth();
-            // Build the child's initial messages. Default: fresh (single prompt).
-            // inheritContext (foreground only): prepend a trimmed parent-conversation slice.
-            const buildPromptMessages = () => {
-                if (forkParams.inheritContext && !forkParams.background) {
-                    const slice = buildConversationContextSlice(host.getConversationHistory(), {
-                        maxTokens: CONTEXT_INHERIT_BUDGET,
-                        redactSensitive: host.isGroupContext(),
-                    });
-                    if (slice) {
-                        const lead = slice.truncated ? "[Earlier context was truncated to fit budget.]\n\n" : "";
-                        return [
-                            ...slice.messages,
-                            { role: "user", content: lead + forkParams.prompt },
-                        ];
-                    }
-                }
-                return [{ role: "user", content: forkParams.prompt }];
-            };
-            if (runtimeVars.isTeamBudgetExceeded()) {
-                return {
-                    agentId: `fork-${forkParams.agent}-budget-exceeded`,
-                    status: "failed",
-                    output: undefined,
-                    error: runtimeVars.teamBudgetExceededError(),
-                    tokensUsed: 0,
-                };
-            }
-            // Snapshot LLM config at launch time: background tasks outlive the turn
-            // and must not be affected by later provider switches.
-            const transport = host.currentTransport;
-            const apiKey = host.currentApiKey;
-            const model = host.currentModel;
-            const promptMessages = buildPromptMessages();
-            // Inject the subagent's standing context (persona + project rules + memory)
-            // so a fresh fork still knows who it is and the project's conventions.
-            const systemPrompt = await buildSubagentSystemPrompt({
-                persona: personaForAgentDefinition(agentDef),
-                cwd: host.getActiveProjectRoot(),
-                hooks,
-                memoryIndex: host.getMemoryIndex(),
-            });
-            const runFork = async (parentSignal, streamDeltas) => runForkedAgent({
-                promptMessages,
-                systemPrompt,
-                tools: filteredChildDefs,
-                transport,
-                toolInvoker,
-                createAgentRunner: createCliForkedAgentRunner,
-                apiKey,
-                model,
-                log,
-                hooks,
-                forkLabel: `agent-${forkParams.agent}`,
-                maxTurns,
-                parentSignal,
-                parentDepth: depth,
-                onEvent: (event) => {
-                    if (streamDeltas && event.type === "delta" && event.text) {
-                        host.sendNotification("turn.subagent_delta", {
-                            agentType: forkParams.agent,
-                            text: event.text,
-                        });
-                    }
-                },
-            });
-            // ── Background: register in the unified task registry, return immediately ──
-            if (forkParams.background) {
-                const backgroundTasks = host.getBackgroundTasks();
-                if (!backgroundTasks) {
-                    return {
-                        agentId: "",
-                        status: "failed",
-                        error: "Background execution is not available in this host (no task registry).",
-                    };
-                }
-                const task = backgroundTasks.startAgentTask({
-                    agentName: forkParams.agent,
-                    label: forkParams.description ?? forkParams.prompt.slice(0, 80),
-                    depth: depth + 1,
-                    maxTurns,
-                    run: async (taskSignal) => {
-                        // Deliberately NOT linked to the turn signal: background work
-                        // survives the launching turn. Cancellation goes through the registry.
-                        const result = await runFork(taskSignal, false);
-                        const tokens = result.totalUsage.inputTokens + result.totalUsage.outputTokens;
-                        runtimeVars.recordForkTokens(tokens);
-                        return {
-                            ok: result.ok,
-                            output: extractForkOutput(result) || undefined,
-                            error: result.error,
-                        };
-                    },
-                });
-                return { agentId: task.taskId, status: "running" };
-            }
-            // ── Foreground: blocking run, abort propagates from the turn signal ──
-            const result = await runFork(forkParams.abortSignal, true);
-            const output = extractForkOutput(result);
-            const forkTokens = result.totalUsage.inputTokens + result.totalUsage.outputTokens;
-            runtimeVars.recordForkTokens(forkTokens);
-            return {
-                agentId: `fork-${forkParams.agent}-${randomUUID().slice(0, 8)}`,
-                status: result.ok ? "completed" : "failed",
-                output: output || undefined,
-                error: result.error,
-                tokensUsed: forkTokens,
-            };
-        },
-    };
-}

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

@@ -1,9 +0,0 @@
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface CheckpointToolRegistrationDeps {
-    config: Record<string, unknown>;
-    toolCatalog: ToolCatalog;
-    host: {
-        readonly currentSessionId: string;
-    };
-}
-export declare function registerCheckpointTool({ config, host, toolCatalog }: CheckpointToolRegistrationDeps): void;

package/dist/cli/core-tools/checkpoint-tool-bootstrap.js

@@ -1,8 +0,0 @@
-import { createCheckpointTool } from "../../skills/tools/checkpoint-tool.js";
-import { createCheckpointToolService } from "./checkpoint-tool-service.js";
-export function registerCheckpointTool({ config, host, toolCatalog }) {
-    toolCatalog.addTool(createCheckpointTool(createCheckpointToolService({
-        config,
-        sessionId: host.currentSessionId,
-    })));
-}

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

@@ -1,7 +0,0 @@
-import type { CheckpointBackend } from "../../runtime/ports/index.js";
-export interface CheckpointToolServiceOptions {
-    config: Record<string, unknown>;
-    sessionId: string;
-    cwd?: string;
-}
-export declare function createCheckpointToolService(options: CheckpointToolServiceOptions): CheckpointBackend;

package/dist/cli/core-tools/checkpoint-tool-service.js

@@ -1,5 +0,0 @@
-import { createLocalCheckpointBackend } from "../../runtime/infra/checkpoint-backend.js";
-export function createCheckpointToolService(options) {
-    const projectRoot = typeof options.config.workdir === "string" ? options.config.workdir : options.cwd ?? process.cwd();
-    return createLocalCheckpointBackend(projectRoot, options.sessionId || "default");
-}

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

@@ -1,5 +0,0 @@
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface ConfigToolRegistrationDeps {
-    toolCatalog: ToolCatalog;
-}
-export declare function registerConfigTool({ toolCatalog }: ConfigToolRegistrationDeps): void;

package/dist/cli/core-tools/config-tool-bootstrap.js

@@ -1,5 +0,0 @@
-import { createConfigTool } from "../../skills/tools/config-tool.js";
-import { createConfigToolService } from "./config-tool-service.js";
-export function registerConfigTool({ toolCatalog }) {
-    toolCatalog.addTool(createConfigTool(createConfigToolService()));
-}

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

@@ -1,11 +0,0 @@
-/**
- * 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 {
-    settingsPath?: string;
-}
-export declare function createConfigToolService(options?: ConfigToolServiceOptions): ConfigToolDeps;