verybot 0.1.3

package/dist/teams/store.js

@@ -0,0 +1,420 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+import { DEFAULT_TEAM_ID, DEFAULT_WORKER_TIMEOUT_S, FALLBACK_ORCHESTRATOR } from "../config/agent-config.js";
+/** Max allowed length for team/agent names. */
+export const MAX_NAME_LENGTH = 128;
+/** Max allowed length for agent identity strings. */
+export const MAX_IDENTITY_LENGTH = 10_000;
+/** Max allowed length for model strings. */
+export const MAX_MODEL_LENGTH = 256;
+/** Max allowed length for caller-provided ids. */
+const MAX_ID_LENGTH = 128;
+/** Hex color pattern: #RRGGBB */
+export const HEX_COLOR_RE = /^#[0-9a-fA-F]{6}$/;
+/** Validate a caller-provided id string. */
+function validateId(id) {
+    if (typeof id !== "string" || id.trim().length === 0) {
+        throw new Error("id must be a non-empty string");
+    }
+    if (id.length > MAX_ID_LENGTH) {
+        throw new Error(`id exceeds maximum length of ${MAX_ID_LENGTH}`);
+    }
+}
+/** Max allowed length for workspace paths. */
+const MAX_WORKSPACE_LENGTH = 1024;
+/** Max number of user-defined variables per team. */
+const MAX_VARIABLES_COUNT = 50;
+/** Max allowed length for a single variable value. */
+const MAX_VARIABLE_VALUE_LENGTH = 10_000;
+/** Variable key pattern: alphanumeric + underscore. */
+const VARIABLE_KEY_RE = /^\w+$/;
+/**
+ * SQLite-backed persistence for teams and agents.
+ * Shares the same DB file as MemoryStore, TaskStore, etc.
+ */
+export class TeamStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new TeamStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        // Enable foreign key enforcement before creating tables
+        this.db.pragma("foreign_keys = ON");
+        // Ensure prompt_templates table exists (may already be created by PromptTemplateStore)
+        // Needed for agents.template_id FK and toTeamConfigs() JOIN.
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_templates (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT NOT NULL DEFAULT '',
+        role TEXT NOT NULL,
+        content TEXT NOT NULL DEFAULT '',
+        builtin INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS teams (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        team_id TEXT NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        role TEXT NOT NULL,
+        model TEXT NOT NULL,
+        context_window INTEGER DEFAULT 0,
+        max_steps INTEGER DEFAULT 0,
+        identity TEXT NOT NULL DEFAULT '',
+        tools TEXT DEFAULT '[]',
+        timeout INTEGER DEFAULT ${DEFAULT_WORKER_TIMEOUT_S},
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(team_id, name)
+      );
+      CREATE INDEX IF NOT EXISTS idx_agents_team ON agents(team_id);
+    `);
+        // Add color column to existing tables (idempotent — SQLite errors if column exists)
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN color TEXT NOT NULL DEFAULT ''");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add template_id FK column to agents (idempotent)
+        try {
+            this.db.exec("ALTER TABLE agents ADD COLUMN template_id TEXT REFERENCES prompt_templates(id) ON DELETE SET NULL");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add workspace column to teams (idempotent)
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN workspace TEXT NOT NULL DEFAULT ''");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add variables column to teams (JSON-encoded Record<string, string>)
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN variables TEXT NOT NULL DEFAULT '{}'");
+        }
+        catch {
+            // Column already exists
+        }
+    }
+    // --- Team CRUD ---
+    /** Run a function inside a SQLite transaction (all-or-nothing). */
+    transaction(fn) {
+        return this.db.transaction(fn)();
+    }
+    createTeam(input) {
+        const { name, color = "", workspace = "", variables = {} } = input;
+        if (input.id !== undefined)
+            validateId(input.id);
+        if (name.length > MAX_NAME_LENGTH)
+            throw new Error(`Team name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        if (color !== "" && !HEX_COLOR_RE.test(color))
+            throw new Error("color must be a valid hex color (e.g. #ef4444)");
+        if (workspace.length > MAX_WORKSPACE_LENGTH)
+            throw new Error(`workspace exceeds maximum length of ${MAX_WORKSPACE_LENGTH}`);
+        validateVariables(variables);
+        const now = Date.now();
+        const id = input.id ?? randomUUID();
+        try {
+            this.db.prepare("INSERT INTO teams (id, name, color, workspace, variables, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, name, color, workspace, JSON.stringify(variables), now, now);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`A team named "${name}" already exists`);
+            }
+            throw err;
+        }
+        return { id, name, color, workspace, createdAt: now, updatedAt: now };
+    }
+    updateTeam(id, input) {
+        const existing = this.getTeamById(id);
+        if (!existing)
+            return null;
+        const name = input.name ?? existing.name;
+        const color = input.color ?? existing.color;
+        const workspace = input.workspace ?? existing.workspace;
+        if (color !== "" && !HEX_COLOR_RE.test(color))
+            throw new Error("color must be a valid hex color (e.g. #ef4444)");
+        if (workspace.length > MAX_WORKSPACE_LENGTH)
+            throw new Error(`workspace exceeds maximum length of ${MAX_WORKSPACE_LENGTH}`);
+        // Variables: replace entirely if provided, otherwise keep existing
+        let variables;
+        if (input.variables !== undefined) {
+            validateVariables(input.variables);
+            variables = input.variables;
+        }
+        const varsJson = variables !== undefined ? JSON.stringify(variables) : undefined;
+        const now = Date.now();
+        if (varsJson !== undefined) {
+            this.db.prepare("UPDATE teams SET name = ?, color = ?, workspace = ?, variables = ?, updated_at = ? WHERE id = ?").run(name, color, workspace, varsJson, now, id);
+        }
+        else {
+            this.db.prepare("UPDATE teams SET name = ?, color = ?, workspace = ?, updated_at = ? WHERE id = ?").run(name, color, workspace, now, id);
+        }
+        return { ...existing, name, color, workspace, updatedAt: now };
+    }
+    deleteTeam(id) {
+        if (id === DEFAULT_TEAM_ID)
+            throw new Error("Cannot delete the default team");
+        const info = this.db.prepare("DELETE FROM teams WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getTeamById(id) {
+        const row = this.db.prepare("SELECT * FROM teams WHERE id = ?").get(id);
+        return row ? toTeam(row) : null;
+    }
+    getTeamByName(name) {
+        const row = this.db.prepare("SELECT * FROM teams WHERE name = ?").get(name);
+        return row ? toTeam(row) : null;
+    }
+    listTeams() {
+        const rows = this.db.prepare("SELECT * FROM teams ORDER BY created_at ASC").all();
+        return rows.map(toTeam);
+    }
+    // --- Agent CRUD ---
+    createAgent(teamId, input) {
+        if (input.id !== undefined)
+            validateId(input.id);
+        if (input.name.length > MAX_NAME_LENGTH)
+            throw new Error(`Agent name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        if (input.model.length > MAX_MODEL_LENGTH)
+            throw new Error(`Model string exceeds maximum length of ${MAX_MODEL_LENGTH}`);
+        if (input.identity && input.identity.length > MAX_IDENTITY_LENGTH)
+            throw new Error(`Identity exceeds maximum length of ${MAX_IDENTITY_LENGTH}`);
+        // Verify team exists (friendly error instead of FK violation)
+        if (!this.getTeamById(teamId))
+            throw new Error(`Team not found: ${teamId}`);
+        // Prevent multiple orchestrators per team
+        if (input.role === "orchestrator") {
+            const existing = this.db.prepare("SELECT id FROM agents WHERE team_id = ? AND role = 'orchestrator'").get(teamId);
+            if (existing)
+                throw new Error("Team already has an orchestrator — update the existing one instead");
+        }
+        const now = Date.now();
+        const id = input.id ?? randomUUID();
+        try {
+            this.db.prepare(`INSERT INTO agents (id, team_id, name, role, model, context_window, max_steps, identity, tools, timeout, template_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, teamId, input.name, input.role, input.model, input.contextWindow ?? 0, input.maxSteps ?? 0, input.identity ?? "", JSON.stringify(input.tools ?? []), input.timeout ?? DEFAULT_WORKER_TIMEOUT_S, input.templateId ?? null, now, now);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`Agent "${input.name}" already exists in this team`);
+            }
+            throw err;
+        }
+        return {
+            id, teamId, name: input.name, role: input.role, model: input.model,
+            contextWindow: input.contextWindow ?? 0, maxSteps: input.maxSteps ?? 0,
+            identity: input.identity ?? "", tools: input.tools ?? [],
+            timeout: input.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+            templateId: input.templateId ?? null,
+            createdAt: now, updatedAt: now,
+        };
+    }
+    updateAgent(id, input) {
+        if (input.name !== undefined && input.name.length > MAX_NAME_LENGTH)
+            throw new Error(`Agent name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        if (input.model !== undefined && input.model.length > MAX_MODEL_LENGTH)
+            throw new Error(`Model string exceeds maximum length of ${MAX_MODEL_LENGTH}`);
+        if (input.identity !== undefined && input.identity.length > MAX_IDENTITY_LENGTH)
+            throw new Error(`Identity exceeds maximum length of ${MAX_IDENTITY_LENGTH}`);
+        const existing = this.getAgentById(id);
+        if (!existing)
+            return null;
+        const now = Date.now();
+        const updated = {
+            ...existing,
+            ...(input.name !== undefined && { name: input.name }),
+            ...(input.role !== undefined && { role: input.role }),
+            ...(input.model !== undefined && { model: input.model }),
+            ...(input.contextWindow !== undefined && { contextWindow: input.contextWindow }),
+            ...(input.maxSteps !== undefined && { maxSteps: input.maxSteps }),
+            ...(input.identity !== undefined && { identity: input.identity }),
+            ...(input.tools !== undefined && { tools: input.tools }),
+            ...(input.timeout !== undefined && { timeout: input.timeout }),
+            ...(input.templateId !== undefined && { templateId: input.templateId }),
+            updatedAt: now,
+        };
+        this.db.prepare(`UPDATE agents SET name = ?, role = ?, model = ?, context_window = ?, max_steps = ?,
+       identity = ?, tools = ?, timeout = ?, template_id = ?, updated_at = ? WHERE id = ?`).run(updated.name, updated.role, updated.model, updated.contextWindow, updated.maxSteps, updated.identity, JSON.stringify(updated.tools), updated.timeout, updated.templateId ?? null, now, id);
+        return updated;
+    }
+    deleteAgent(id) {
+        // Prevent deleting a team's only orchestrator
+        const agent = this.getAgentById(id);
+        if (agent?.role === "orchestrator") {
+            throw new Error("Cannot delete a team's orchestrator agent");
+        }
+        const info = this.db.prepare("DELETE FROM agents WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getAgentById(id) {
+        const row = this.db.prepare("SELECT * FROM agents WHERE id = ?").get(id);
+        return row ? toAgentRow(row) : null;
+    }
+    listAgentsByTeam(teamId) {
+        const rows = this.db.prepare("SELECT * FROM agents WHERE team_id = ? ORDER BY role ASC, created_at ASC").all(teamId);
+        return rows.map(toAgentRow);
+    }
+    getAgentByName(teamId, name) {
+        const row = this.db.prepare("SELECT * FROM agents WHERE team_id = ? AND name = ?").get(teamId, name);
+        return row ? toAgentRow(row) : null;
+    }
+    /**
+     * Convert DB rows to the existing TeamConfig[] format so TeamRegistry
+     * constructor is unchanged. Uses a single JOIN query instead of N+1.
+     */
+    toTeamConfigs() {
+        const rows = this.db.prepare(`SELECT t.id AS tid, t.name AS tname, t.color AS tcolor,
+              t.workspace AS tworkspace, t.variables AS tvariables,
+              a.id, a.name, a.role, a.model, a.context_window, a.max_steps,
+              a.identity, a.tools, a.timeout, a.template_id,
+              pt.content AS template_content
+       FROM teams t LEFT JOIN agents a ON a.team_id = t.id
+       LEFT JOIN prompt_templates pt ON a.template_id = pt.id
+       ORDER BY t.created_at ASC, a.role ASC, a.created_at ASC`).all();
+        const teamMap = new Map();
+        for (const row of rows) {
+            const tid = row.tid;
+            if (!teamMap.has(tid)) {
+                let variables = {};
+                try {
+                    variables = JSON.parse(row.tvariables || "{}");
+                }
+                catch { /* ignore */ }
+                teamMap.set(tid, {
+                    id: tid,
+                    name: row.tname,
+                    color: row.tcolor ?? "",
+                    workspace: row.tworkspace ?? "",
+                    variables,
+                    orchestrator: { ...FALLBACK_ORCHESTRATOR },
+                    workers: [],
+                });
+            }
+            // LEFT JOIN may produce a row with no agent columns
+            if (!row.id)
+                continue;
+            const team = teamMap.get(tid);
+            const agent = toAgentConfig(row, team.variables);
+            if (row.role === "orchestrator") {
+                team.orchestrator = agent;
+            }
+            else {
+                team.workers.push(agent);
+            }
+        }
+        return [...teamMap.values()];
+    }
+    close() {
+        this.db.close();
+        logger.info("Team store closed");
+    }
+}
+function toTeam(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        color: row.color ?? "",
+        workspace: row.workspace ?? "",
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function toAgentConfig(row, teamVariables) {
+    let tools = [];
+    try {
+        tools = JSON.parse(row.tools || "[]");
+    }
+    catch {
+        tools = [];
+    }
+    const templateId = row.template_id ?? null;
+    const templateContent = row.template_content ?? null;
+    // If a template is linked, resolve identity from the template content
+    const rawIdentity = row.identity ?? "";
+    let identity = templateId && templateContent != null ? templateContent : rawIdentity;
+    // Interpolate team variables into identity ({{varName}} placeholders)
+    if (identity && row.tname !== undefined) {
+        const vars = {
+            teamName: row.tname ?? "",
+            workspace: row.tworkspace ?? "",
+            ...(teamVariables ?? {}),
+        };
+        identity = identity.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        model: row.model,
+        contextWindow: row.context_window ?? 0,
+        maxSteps: row.max_steps ?? 0,
+        identity,
+        tools,
+        timeout: row.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+        templateId,
+    };
+}
+function validateVariables(variables) {
+    const keys = Object.keys(variables);
+    if (keys.length > MAX_VARIABLES_COUNT) {
+        throw new Error(`Too many variables (max ${MAX_VARIABLES_COUNT})`);
+    }
+    for (const key of keys) {
+        if (!VARIABLE_KEY_RE.test(key)) {
+            throw new Error(`Invalid variable key "${key}": only letters, numbers, and underscores allowed`);
+        }
+        if (typeof variables[key] !== "string") {
+            throw new Error(`Variable "${key}" must have a string value`);
+        }
+        if (variables[key].length > MAX_VARIABLE_VALUE_LENGTH) {
+            throw new Error(`Variable "${key}" value exceeds maximum length of ${MAX_VARIABLE_VALUE_LENGTH}`);
+        }
+    }
+}
+function toAgentRow(row) {
+    let tools = [];
+    try {
+        tools = JSON.parse(row.tools || "[]");
+    }
+    catch {
+        tools = [];
+    }
+    return {
+        id: row.id,
+        teamId: row.team_id,
+        name: row.name,
+        role: row.role,
+        model: row.model,
+        contextWindow: row.context_window ?? 0,
+        maxSteps: row.max_steps ?? 0,
+        identity: row.identity ?? "",
+        tools,
+        timeout: row.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+        templateId: row.template_id ?? null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}

package/dist/teams/types.d.ts

@@ -0,0 +1,23 @@
+export interface Team {
+    id: string;
+    name: string;
+    color: string;
+    workspace: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface AgentRow {
+    id: string;
+    teamId: string;
+    name: string;
+    role: "orchestrator" | "worker";
+    model: string;
+    contextWindow: number;
+    maxSteps: number;
+    identity: string;
+    tools: string[];
+    timeout: number;
+    templateId: string | null;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/teams/types.js

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

package/dist/tools/bash.d.ts

@@ -0,0 +1,16 @@
+import { type Tool } from "ai";
+import type { BashConfig } from "../config.js";
+import type { DockerSandbox } from "../security/docker-sandbox.js";
+/** Per-run context injected when creating the bash tool inside Agent.run(). */
+export interface BashToolContext {
+    sessionKey: string;
+    sandbox: DockerSandbox | null;
+}
+/**
+ * Create a bash tool with the given security config and optional per-run context.
+ * Returns null in "deny" mode (tool not registered at all).
+ *
+ * When `ctx.sandbox` is provided, commands execute inside a Docker container.
+ * Otherwise, commands execute on the host with sanitized environment.
+ */
+export declare function createBashTool(config: BashConfig, ctx?: BashToolContext): Tool | null;

package/dist/tools/bash.js

@@ -0,0 +1,62 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { execSync } from "child_process";
+import { validateCommand, isAllowed, DEFAULT_SAFE_BINS } from "../security/command-validator.js";
+import { sanitizeEnv } from "../security/env-filter.js";
+import { logger } from "../logger.js";
+const EXEC_TIMEOUT = 30_000;
+const MAX_OUTPUT = 10_000;
+const MAX_ERROR = 5_000;
+/**
+ * Create a bash tool with the given security config and optional per-run context.
+ * Returns null in "deny" mode (tool not registered at all).
+ *
+ * When `ctx.sandbox` is provided, commands execute inside a Docker container.
+ * Otherwise, commands execute on the host with sanitized environment.
+ */
+export function createBashTool(config, ctx) {
+    if (config.security === "deny")
+        return null;
+    // Merge user-provided safe bins with defaults
+    const safeBins = new Set([...DEFAULT_SAFE_BINS, ...config.safeBins]);
+    return tool({
+        description: "Execute a shell command. Confirm with user before destructive commands (rm, mv, chmod). " +
+            "Backticks, $(), redirects, and subshells are blocked.",
+        inputSchema: z.object({
+            command: z.string().describe("The shell command to execute"),
+        }),
+        execute: async ({ command }) => {
+            // 1. Always validate syntax (blocks dangerous tokens in all modes)
+            const validation = validateCommand(command);
+            if (!validation.ok) {
+                logger.warn(`Bash blocked (syntax): ${validation.reason} — ${command}`);
+                return `Blocked: ${validation.reason}`;
+            }
+            // 2. In allowlist mode, check executables against safe bins + allowlist
+            if (config.security === "allowlist") {
+                if (!isAllowed(command, safeBins, config.allowlist)) {
+                    logger.warn(`Bash blocked (allowlist): ${command}`);
+                    return `Blocked: command not in allowlist. Safe bins: ${[...safeBins].join(", ")}`;
+                }
+            }
+            // 3. Execute — sandbox if available, otherwise host
+            if (ctx?.sandbox) {
+                return ctx.sandbox.exec(ctx.sessionKey, command);
+            }
+            try {
+                const output = execSync(command, {
+                    encoding: "utf-8",
+                    timeout: EXEC_TIMEOUT,
+                    maxBuffer: 1024 * 1024,
+                    env: sanitizeEnv(),
+                });
+                return output.slice(0, MAX_OUTPUT);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                const stderr = err.stderr ?? "";
+                return `Error: ${msg}\n${stderr}`.slice(0, MAX_ERROR);
+            }
+        },
+    });
+}

package/dist/tools/channel-history.d.ts

@@ -0,0 +1,10 @@
+import { type Tool } from "ai";
+import type { ChannelManager } from "../channels/manager.js";
+/**
+ * Create a read_channel_history tool that lets the LLM fetch recent messages
+ * from the current messaging channel (Slack, etc.) on demand.
+ *
+ * The channelId is resolved fresh at execution time from a callback
+ * to avoid stale closures.
+ */
+export declare function createChannelHistoryTool(channelManager: ChannelManager, channelType: string, resolveChannelId: () => string): Tool | null;

package/dist/tools/channel-history.js

@@ -0,0 +1,43 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { logger } from "../logger.js";
+/** Default number of messages to fetch. */
+const DEFAULT_LIMIT = 20;
+/**
+ * Create a read_channel_history tool that lets the LLM fetch recent messages
+ * from the current messaging channel (Slack, etc.) on demand.
+ *
+ * The channelId is resolved fresh at execution time from a callback
+ * to avoid stale closures.
+ */
+export function createChannelHistoryTool(channelManager, channelType, resolveChannelId) {
+    const ch = channelManager.get(channelType);
+    if (!ch?.readHistory)
+        return null;
+    return tool({
+        description: "Read recent messages from the current chat channel or thread. " +
+            "Use this when the user references prior conversation, asks what was discussed, " +
+            "or needs context about the channel's recent messages. " +
+            "Returns messages in chronological order.",
+        inputSchema: z.object({
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .describe("Number of recent messages to fetch (default 20, max 50)"),
+        }),
+        execute: async ({ limit }) => {
+            const channelId = resolveChannelId();
+            logger.info(`[channel-history] Reading ${channelType}/${channelId} limit=${limit ?? DEFAULT_LIMIT}`);
+            const messages = await ch.readHistory(channelId, limit ?? DEFAULT_LIMIT);
+            if (messages.length === 0)
+                return `No messages found in channel ${channelId}.`;
+            const formatted = messages
+                .map((m) => `<@${m.user}>: ${m.text}`)
+                .join("\n");
+            return `[${channelType} channel ${channelId} — ${messages.length} messages]\n${formatted}`;
+        },
+    });
+}

package/dist/tools/delegate.d.ts

@@ -0,0 +1,16 @@
+import { type ToolSet } from "ai";
+import type { AgentRegistry } from "../brain/agent-registry.js";
+import type { ChannelStore } from "../brain/channel-store.js";
+import type { DelegationStore } from "../brain/delegation-store.js";
+import type { SessionStore } from "../brain/session-store.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import { type BrowserConfig } from "../computer/browser/manager.js";
+/**
+ * Creates delegation tools:
+ * - `delegate`      — fires a worker in background, returns channel ID immediately
+ * - `read_channel`  — reads all messages from a channel (available to orchestrator AND workers)
+ */
+export declare function createDelegationTools(registry: AgentRegistry, channelStore: ChannelStore, delegationStore: DelegationStore, sessionStore: SessionStore, orchestratorId: string, sessionKey: string, memoryStore: MemoryStore | null, embeddingProvider: EmbeddingProvider | null, memoryMaxResults: number, onWorkerComplete: (sessionKey: string, channelId: string) => void, browserConfig: BrowserConfig | null, 
+/** Human-readable session label for logs (team name instead of UUID). */
+sessionLabel?: string): ToolSet;