qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,19 @@
+// ============================================================
+// 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

@@ -0,0 +1,62 @@
+/**
+ * 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

@@ -0,0 +1,85 @@
+/**
+ * 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

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

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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,43 @@
+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;