qlogicagent 2.13.5 → 2.13.6

package/dist/cli/core-tools/fork-system-prompt.test.js

@@ -1,77 +0,0 @@
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { buildSubagentSystemPrompt, personaForAgentDefinition, personaForTeamMember } from "./fork-system-prompt.js";
-import { getBuiltInAgent } from "../../orchestration/subagent/agent-registry.js";
-const persona = (name) => personaForAgentDefinition(getBuiltInAgent(name));
-const tmpRoots = [];
-afterEach(() => { for (const r of tmpRoots.splice(0))
-    rmSync(r, { recursive: true, force: true }); });
-function workspace(withRules = false) {
-    const dir = mkdtempSync(join(tmpdir(), "qla-fork-sp-"));
-    tmpRoots.push(dir);
-    if (withRules) {
-        mkdirSync(join(dir, ".qlogicagent", "rules"), { recursive: true });
-        writeFileSync(join(dir, ".qlogicagent", "rules", "style.md"), "Always use 2-space indentation.\n");
-    }
-    return dir;
-}
-describe("buildSubagentSystemPrompt", () => {
-    it("builds a team-member persona (name + role + coordination note)", async () => {
-        const prompt = await buildSubagentSystemPrompt({
-            persona: personaForTeamMember("coder", "implements backend features"),
-            cwd: workspace(),
-            hooks: undefined,
-            memoryIndex: null,
-        });
-        expect(prompt).toContain('You are the "coder" team member');
-        expect(prompt).toContain("implements backend features");
-        expect(prompt).toContain("delivered back to the sender"); // coordination note
-    });
-    it("injects the agent persona including its systemPromptSuffix", async () => {
-        const explore = getBuiltInAgent("explore");
-        const prompt = await buildSubagentSystemPrompt({ persona: personaForAgentDefinition(explore), cwd: workspace(), hooks: undefined, memoryIndex: null });
-        expect(prompt).toBeDefined();
-        expect(prompt).toContain('You are the "explore" sub-agent');
-        expect(prompt).toContain("READ-ONLY"); // from systemPromptSuffix (now a live field)
-        expect(prompt).toContain("final answer"); // base delegation framing
-    });
-    it("injects project rules / AGENTS from the workspace", async () => {
-        const code = getBuiltInAgent("code");
-        const prompt = await buildSubagentSystemPrompt({ persona: personaForAgentDefinition(code), cwd: workspace(true), hooks: undefined, memoryIndex: null });
-        expect(prompt).toContain("2-space indentation"); // loaded from .qlogicagent/rules
-    });
-    it("injects the lightweight memory INDEX when present", async () => {
-        const general = getBuiltInAgent("general");
-        const prompt = await buildSubagentSystemPrompt({
-            persona: personaForAgentDefinition(general),
-            cwd: workspace(),
-            hooks: undefined,
-            memoryIndex: "- User prefers TypeScript strict mode.",
-        });
-        expect(prompt).toContain("Your Memory");
-        expect(prompt).toContain("User prefers TypeScript strict mode");
-    });
-    it("returns a persona even with no rules and no memory (never empty for a known agent)", async () => {
-        const general = getBuiltInAgent("general");
-        const prompt = await buildSubagentSystemPrompt({ persona: personaForAgentDefinition(general), cwd: workspace(), hooks: undefined, memoryIndex: null });
-        expect(prompt).toBeDefined();
-        expect(prompt).toContain('You are the "general" sub-agent');
-    });
-    it("composes all three sections in order: persona, rules, memory", async () => {
-        const code = getBuiltInAgent("code");
-        const prompt = await buildSubagentSystemPrompt({
-            persona: personaForAgentDefinition(code),
-            cwd: workspace(true),
-            hooks: undefined,
-            memoryIndex: "- marker-MEMIDX",
-        });
-        const personaPos = prompt.indexOf("code\" sub-agent");
-        const rulesPos = prompt.indexOf("2-space indentation");
-        const memPos = prompt.indexOf("marker-MEMIDX");
-        expect(personaPos).toBeGreaterThanOrEqual(0);
-        expect(rulesPos).toBeGreaterThan(personaPos);
-        expect(memPos).toBeGreaterThan(rulesPos);
-    });
-});

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

@@ -1,7 +0,0 @@
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-import type { AgentLogger } from "../../agent/types.js";
-export interface MonitorToolRegistrationDeps {
-    log: AgentLogger;
-    toolCatalog: ToolCatalog;
-}
-export declare function registerMonitorTool({ log, toolCatalog }: MonitorToolRegistrationDeps): void;

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

@@ -1,8 +0,0 @@
-import { registerCleanup } from "../../runtime/infra/cleanup-registry.js";
-import { createMonitorTool } from "../../skills/tools/monitor-tool.js";
-import { createMonitorToolService } from "./monitor-tool-service.js";
-export function registerMonitorTool({ log, toolCatalog }) {
-    const service = createMonitorToolService(log);
-    registerCleanup(async () => service.dispose());
-    toolCatalog.addTool(createMonitorTool(service));
-}

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

@@ -1,6 +0,0 @@
-import type { AgentLogger } from "../../agent/types.js";
-import type { MonitorToolDeps } from "../../skills/tools/monitor-tool.js";
-export interface MonitorToolService extends MonitorToolDeps {
-    dispose(): void;
-}
-export declare function createMonitorToolService(log: AgentLogger): MonitorToolService;

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

@@ -1,74 +0,0 @@
-import * as fs from "node:fs";
-export function createMonitorToolService(log) {
-    const activeMonitors = new Map();
-    return {
-        async startMonitor(params) {
-            if (activeMonitors.has(params.monitorId)) {
-                return { action: "start", success: false, error: `Monitor "${params.monitorId}" already exists.` };
-            }
-            const info = {
-                monitorId: params.monitorId,
-                source: params.source,
-                target: params.target,
-                conditions: params.conditions,
-                startedAt: Date.now(),
-                timeoutSeconds: params.timeoutSeconds,
-                eventCount: 0,
-            };
-            // Fail-loud on unsupported sources: only "file" actually watches anything.
-            // Returning success for process/task/custom created a dead monitor that
-            // never fired — silent no-op. Reject them explicitly instead.
-            if (params.source !== "file") {
-                return {
-                    action: "start",
-                    success: false,
-                    error: `Unsupported monitor source "${params.source}". Only "file" is supported. ` +
-                        `For background agents/commands use task(action="output", taskId=...).`,
-                };
-            }
-            let cleanup = () => { };
-            try {
-                const watcher = fs.watch(params.target, { persistent: false }, () => {
-                    info.eventCount++;
-                    log.info(`[monitor] file change detected: ${params.target}`);
-                });
-                cleanup = () => watcher.close();
-            }
-            catch {
-                return { action: "start", success: false, error: `Cannot watch: ${params.target}` };
-            }
-            if (params.timeoutSeconds > 0) {
-                const timer = setTimeout(() => {
-                    const monitor = activeMonitors.get(params.monitorId);
-                    if (monitor) {
-                        monitor.cleanup();
-                        activeMonitors.delete(params.monitorId);
-                    }
-                }, params.timeoutSeconds * 1000);
-                const previousCleanup = cleanup;
-                cleanup = () => {
-                    clearTimeout(timer);
-                    previousCleanup();
-                };
-            }
-            activeMonitors.set(params.monitorId, { info, cleanup });
-            return { action: "start", success: true, monitorId: params.monitorId };
-        },
-        async stopMonitor(monitorId) {
-            const monitor = activeMonitors.get(monitorId);
-            if (!monitor)
-                return { action: "stop", success: false, error: `Monitor "${monitorId}" not found.` };
-            monitor.cleanup();
-            activeMonitors.delete(monitorId);
-            return { action: "stop", success: true, monitorId };
-        },
-        async listMonitors() {
-            return [...activeMonitors.values()].map(monitor => monitor.info);
-        },
-        dispose() {
-            for (const monitor of activeMonitors.values())
-                monitor.cleanup();
-            activeMonitors.clear();
-        },
-    };
-}

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

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

package/dist/cli/core-tools/registry.js

@@ -1,60 +0,0 @@
-import { registerAgentTool } from "./agent-tool-bootstrap.js";
-import { registerCheckpointTool } from "./checkpoint-tool-bootstrap.js";
-import { registerConfigTool } from "./config-tool-bootstrap.js";
-import { registerCronTool } from "./cron-tool-bootstrap.js";
-import { registerMonitorTool } from "./monitor-tool-bootstrap.js";
-import { TeamRegistry } from "./team-registry.js";
-import { registerTeamTool } from "./team-tool-bootstrap.js";
-export function registerCoreToolSet(deps) {
-    // Session-scoped roster: the team tool both registers members (create)
-    // and routes messages to them (send).
-    const teamRegistry = new TeamRegistry();
-    registerAgentTool({
-        host: {
-            get agent() { return deps.host.agent; },
-            get currentTransport() { return deps.host.currentTransport; },
-            get currentApiKey() { return deps.host.currentApiKey; },
-            get currentModel() { return deps.host.currentModel; },
-            sendNotification: deps.host.sendNotification.bind(deps.host),
-            getBackgroundTasks: () => deps.host.getBackgroundTasks(),
-            getConversationHistory: () => deps.host.getConversationHistory(),
-            isGroupContext: () => deps.host.isGroupContext(),
-            getActiveProjectRoot: () => deps.host.getActiveProjectRoot(),
-            getMemoryIndex: () => deps.host.getMemoryIndex(),
-        },
-        hooks: deps.hooks,
-        log: deps.log,
-        toolCatalog: deps.toolCatalog,
-        toolInvoker: deps.toolInvoker,
-    });
-    registerConfigTool({ toolCatalog: deps.toolCatalog });
-    registerCronTool({
-        toolCatalog: deps.toolCatalog,
-        host: {
-            getActiveProjectRoot: () => deps.host.getActiveProjectRoot(),
-        },
-    });
-    registerMonitorTool({ log: deps.log, toolCatalog: deps.toolCatalog });
-    registerCheckpointTool({
-        config: deps.config,
-        toolCatalog: deps.toolCatalog,
-        host: {
-            currentSessionId: deps.host.currentSessionId,
-        },
-    });
-    registerTeamTool({
-        host: {
-            get currentSessionId() { return deps.host.currentSessionId; },
-            get verbose() { return deps.host.verbose; },
-            getLlmConfig: () => deps.host.getLlmConfig(),
-            getMemoryIndex: () => deps.host.getMemoryIndex(),
-            getBackgroundTasks: () => deps.host.getBackgroundTasks(),
-            sendNotification: deps.host.sendNotification.bind(deps.host),
-            emitAgentStatus: deps.host.emitAgentStatus.bind(deps.host),
-            handleMcpToolCall: deps.host.handleMcpToolCall.bind(deps.host),
-        },
-        log: deps.log,
-        toolCatalog: deps.toolCatalog,
-        teamRegistry,
-    });
-}

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

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

package/dist/cli/core-tools/session-tool-manifest.js

@@ -1,19 +0,0 @@
-// ============================================================
-// Session tool manifest — the orchestration suite that only exists
-// inside a live session (registered by the per-session bootstrap).
-//
-// tools.list merges this DECLARATIVE manifest so the capability page
-// can show the full tool surface even when no session has run yet;
-// once a session is live, the real registrations win (same names).
-// ============================================================
-export const SESSION_TOOL_MANIFEST = [
-    { name: "agent", label: "Agent", description: "Run a scoped sub-agent for delegated investigation, coding, research, or verification.", category: "orchestration", sessionScoped: true },
-    { name: "team", label: "Team", description: "Create, inspect, or message a coordinated team of session-scoped agents.", category: "orchestration", sessionScoped: true },
-    { name: "checkpoint", label: "Checkpoint", description: "Create, inspect, or restore workspace checkpoints during a session.", category: "developer", sessionScoped: true },
-    { name: "config", label: "Config", description: "Read or update session tunables such as model, provider, permissions, and tool settings.", category: "system", sessionScoped: true },
-    { name: "cron", label: "Cron", description: "Manage scheduled workflow-style tasks that can wake the agent later.", category: "automation", sessionScoped: true },
-    { name: "monitor", label: "Monitor", description: "Start, stop, or list file and event monitors that notify the session.", category: "automation", sessionScoped: true },
-    { name: "memory", label: "Memory", description: "Read, write, search, and maintain local project memory for the current session.", category: "memory", sessionScoped: true },
-    { name: "skill", label: "Skill", description: "Inspect, create, activate, deactivate, or promote reusable local skills.", category: "system", sessionScoped: true },
-    { name: "lsp", label: "LSP", description: "Query language-server code intelligence such as definitions, references, symbols, and diagnostics.", category: "developer", sessionScoped: true, deferred: true },
-];

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

@@ -1,62 +0,0 @@
-/**
- * TeamRegistry — session-scoped roster for the team tool: create registers
- * members (producer), the send action routes messages to them (consumer).
- *
- * The team tool spawns each member as a real subprocess agent
- * (AgentProcessManager) and registers a delivery closure here. The send
- * action looks the target up by name or full member id and routes the message
- * into the member's process via that closure, returning the member's reply.
- *
- * This registry is the ONLY routing path to team members, so an
- * unregistered/dead target fails loud.
- */
-export interface TeamRegistryMember {
-    /** Full member id, e.g. "team-research-coder". */
-    memberId: string;
-    /** Display name within the team, e.g. "coder". */
-    name: string;
-    /** Team this member belongs to. */
-    teamName: string;
-    /** Role description. */
-    role: string;
-    /** Deliver a message into the member's process and return its reply text. */
-    deliver: (message: string, fromId: string) => Promise<string>;
-    /** Whether the member's process is still alive. */
-    isAlive: () => boolean;
-}
-export interface TeamRegistryListEntry {
-    memberId: string;
-    name: string;
-    teamName: string;
-    role: string;
-    alive: boolean;
-}
-export interface DeliveryOutcome {
-    ok: boolean;
-    /** Per-recipient replies (broadcast may have several). */
-    replies?: Array<{
-        memberId: string;
-        name: string;
-        reply: string;
-    }>;
-    error?: string;
-}
-export declare class TeamRegistry {
-    private readonly members;
-    register(member: TeamRegistryMember): void;
-    unregister(memberId: string): void;
-    /** Live roster (alive flag reflects the underlying process). */
-    list(): TeamRegistryListEntry[];
-    /**
-     * Resolve a send `to` token to concrete members.
-     * Accepts a member name ("coder"), a full member id ("team-x-coder"),
-     * or "*" for broadcast to all alive members.
-     * Returns [] when nothing matches (caller fails loud).
-     */
-    private resolveTargets;
-    /**
-     * Deliver a message to the resolved target(s) and collect replies.
-     * Fail-loud: no target → ok:false; any delivery error → surfaced.
-     */
-    deliver(to: string, message: string, fromId: string): Promise<DeliveryOutcome>;
-}

package/dist/cli/core-tools/team-registry.js

@@ -1,85 +0,0 @@
-/**
- * TeamRegistry — session-scoped roster for the team tool: create registers
- * members (producer), the send action routes messages to them (consumer).
- *
- * The team tool spawns each member as a real subprocess agent
- * (AgentProcessManager) and registers a delivery closure here. The send
- * action looks the target up by name or full member id and routes the message
- * into the member's process via that closure, returning the member's reply.
- *
- * This registry is the ONLY routing path to team members, so an
- * unregistered/dead target fails loud.
- */
-export class TeamRegistry {
-    members = new Map();
-    register(member) {
-        this.members.set(member.memberId, member);
-    }
-    unregister(memberId) {
-        this.members.delete(memberId);
-    }
-    /** Live roster (alive flag reflects the underlying process). */
-    list() {
-        return [...this.members.values()].map((m) => ({
-            memberId: m.memberId,
-            name: m.name,
-            teamName: m.teamName,
-            role: m.role,
-            alive: m.isAlive(),
-        }));
-    }
-    /**
-     * Resolve a send `to` token to concrete members.
-     * Accepts a member name ("coder"), a full member id ("team-x-coder"),
-     * or "*" for broadcast to all alive members.
-     * Returns [] when nothing matches (caller fails loud).
-     */
-    resolveTargets(to) {
-        if (to === "*") {
-            return [...this.members.values()].filter((m) => m.isAlive());
-        }
-        const byId = this.members.get(to);
-        if (byId)
-            return [byId];
-        return [...this.members.values()].filter((m) => m.name === to);
-    }
-    /**
-     * Deliver a message to the resolved target(s) and collect replies.
-     * Fail-loud: no target → ok:false; any delivery error → surfaced.
-     */
-    async deliver(to, message, fromId) {
-        const targets = this.resolveTargets(to);
-        if (targets.length === 0) {
-            const available = this.list().filter((e) => e.alive).map((e) => e.name);
-            return {
-                ok: false,
-                error: available.length
-                    ? `no teammate matches "${to}". Available: ${available.join(", ")}`
-                    : `no teammate matches "${to}" (no live team members)`,
-            };
-        }
-        const replies = [];
-        const errors = [];
-        for (const target of targets) {
-            if (!target.isAlive()) {
-                errors.push(`${target.name} is not alive`);
-                continue;
-            }
-            try {
-                const reply = await target.deliver(message, fromId);
-                replies.push({ memberId: target.memberId, name: target.name, reply });
-            }
-            catch (err) {
-                errors.push(`${target.name}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        if (replies.length === 0) {
-            return { ok: false, error: errors.join("; ") || "delivery failed" };
-        }
-        // Partial failure on broadcast: still ok, but note the errors in the reply text.
-        if (errors.length > 0) {
-            replies.push({ memberId: "", name: "(errors)", reply: errors.join("; ") });
-        }
-        return { ok: true, replies };
-    }
-}

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

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

package/dist/cli/core-tools/team-registry.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { TeamRegistry } from "./team-registry.js";
-function member(over) {
-    return {
-        teamName: "t",
-        role: "worker",
-        deliver: async (m, f) => `${over.name} got "${m}" from ${f}`,
-        isAlive: () => true,
-        ...over,
-    };
-}
-describe("TeamRegistry", () => {
-    it("lists live members and reflects alive state", () => {
-        const reg = new TeamRegistry();
-        let coderAlive = true;
-        reg.register(member({ memberId: "team-x-coder", name: "coder", isAlive: () => coderAlive }));
-        reg.register(member({ memberId: "team-x-tester", name: "tester" }));
-        expect(reg.list().map((e) => e.name).sort()).toEqual(["coder", "tester"]);
-        coderAlive = false;
-        expect(reg.list().find((e) => e.name === "coder")?.alive).toBe(false);
-    });
-    it("delivers by member name and returns the reply", async () => {
-        const reg = new TeamRegistry();
-        reg.register(member({ memberId: "team-x-coder", name: "coder" }));
-        const outcome = await reg.deliver("coder", "build it", "lead");
-        expect(outcome.ok).toBe(true);
-        expect(outcome.replies).toHaveLength(1);
-        expect(outcome.replies[0]).toMatchObject({ name: "coder", reply: 'coder got "build it" from lead' });
-    });
-    it("delivers by full member id", async () => {
-        const reg = new TeamRegistry();
-        reg.register(member({ memberId: "team-x-coder", name: "coder" }));
-        const outcome = await reg.deliver("team-x-coder", "hi", "lead");
-        expect(outcome.ok).toBe(true);
-    });
-    it("fails loud when target does not exist", async () => {
-        const reg = new TeamRegistry();
-        reg.register(member({ memberId: "team-x-coder", name: "coder" }));
-        const outcome = await reg.deliver("ghost", "hi", "lead");
-        expect(outcome.ok).toBe(false);
-        expect(outcome.error).toContain("no teammate matches");
-        expect(outcome.error).toContain("coder"); // lists available
-    });
-    it("broadcast (*) delivers to all live members", async () => {
-        const reg = new TeamRegistry();
-        reg.register(member({ memberId: "team-x-a", name: "a" }));
-        reg.register(member({ memberId: "team-x-b", name: "b" }));
-        const outcome = await reg.deliver("*", "ping", "lead");
-        expect(outcome.ok).toBe(true);
-        expect(outcome.replies.map((r) => r.name).sort()).toEqual(["a", "b"]);
-    });
-    it("surfaces delivery errors fail-loud", async () => {
-        const reg = new TeamRegistry();
-        reg.register(member({
-            memberId: "team-x-coder",
-            name: "coder",
-            deliver: async () => { throw new Error("process died"); },
-        }));
-        const outcome = await reg.deliver("coder", "hi", "lead");
-        expect(outcome.ok).toBe(false);
-        expect(outcome.error).toContain("process died");
-    });
-    it("unregister removes the member from routing", async () => {
-        const reg = new TeamRegistry();
-        reg.register(member({ memberId: "team-x-coder", name: "coder" }));
-        reg.unregister("team-x-coder");
-        expect(reg.list()).toHaveLength(0);
-        const outcome = await reg.deliver("coder", "hi", "lead");
-        expect(outcome.ok).toBe(false);
-    });
-    it("does not deliver to a dead member", async () => {
-        const reg = new TeamRegistry();
-        const deliver = vi.fn(async () => "should not be called");
-        reg.register(member({ memberId: "team-x-coder", name: "coder", isAlive: () => false, deliver }));
-        const outcome = await reg.deliver("coder", "hi", "lead");
-        expect(outcome.ok).toBe(false);
-        expect(deliver).not.toHaveBeenCalled();
-    });
-});

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

@@ -1,11 +0,0 @@
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-import type { AgentLogger } from "../../agent/types.js";
-import { type TeamToolServiceHost } from "./team-tool-service.js";
-import type { TeamRegistry } from "./team-registry.js";
-export interface TeamToolRegistrationDeps {
-    host: TeamToolServiceHost;
-    log: AgentLogger;
-    toolCatalog: ToolCatalog;
-    teamRegistry: TeamRegistry;
-}
-export declare function registerTeamTool({ host, log, toolCatalog, teamRegistry }: TeamToolRegistrationDeps): void;

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

@@ -1,8 +0,0 @@
-import { registerCleanup } from "../../runtime/infra/cleanup-registry.js";
-import { createTeamTool } from "../../skills/tools/team-tool.js";
-import { createTeamToolService } from "./team-tool-service.js";
-export function registerTeamTool({ host, log, toolCatalog, teamRegistry }) {
-    const service = createTeamToolService(host, log, teamRegistry);
-    registerCleanup(async () => service.dispose());
-    toolCatalog.addTool(createTeamTool(service));
-}

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

@@ -1,43 +0,0 @@
-import type { AgentLogger } from "../../agent/types.js";
-import type { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
-import type { TeamToolDeps } from "../../skills/tools/team-tool.js";
-import type { TeamRegistry } from "./team-registry.js";
-export interface TeamToolService extends TeamToolDeps {
-    dispose(): void;
-}
-export interface TeamToolServiceHost {
-    readonly currentSessionId: string;
-    readonly verbose: boolean;
-    /**
-     * The leader's resolved LLM config, pushed to each spawned member as standing
-     * session config (session/set_config_option). Without it a standalone member
-     * (no llmrouter directory to hydrate a catalog from) cannot provision a
-     * provider, and its first reply turn fails with NO_PROVIDER. Returns null
-     * when the leader has no resolved provider yet.
-     */
-    getLlmConfig(): {
-        provider: string;
-        model: string;
-        apiKey: string;
-        baseUrl?: string;
-    } | null;
-    /** Lightweight memory INDEX injected into each member's system prompt (parent context). */
-    getMemoryIndex(): string | null;
-    /**
-     * Unified background-task registry. Team members register here as `team_member`
-     * tasks so the `task` tool's list/output/cancel reach them. Null when unbound.
-     */
-    getBackgroundTasks(): BackgroundTaskManager | 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 declare function createTeamToolService(host: TeamToolServiceHost, log: AgentLogger, registry: TeamRegistry): TeamToolService;