verybot 0.1.3

package/dist/brain/channel-store.d.ts

@@ -0,0 +1,27 @@
+export interface ChannelMessage {
+    id: number;
+    channelId: string;
+    sender: string;
+    role: "task" | "result" | "error";
+    content: string;
+    createdAt: number;
+}
+/**
+ * SQLite-backed ordered message log for inter-agent communication.
+ * Each channel is a linear log that any agent (orchestrator or worker) can read/post to.
+ */
+export declare class ChannelStore {
+    private db;
+    private constructor();
+    static create(dbPath: string): Promise<ChannelStore>;
+    private createSchema;
+    /** Create a new channel, returns its UUID. */
+    createChannel(): string;
+    /** Post a message to a channel. Returns the message ID. */
+    post(channelId: string, sender: string, role: ChannelMessage["role"], content: string): number;
+    /** Read all messages in a channel, ordered by ID. */
+    read(channelId: string): ChannelMessage[];
+    /** Clean up old channel messages older than maxAge ms. */
+    cleanup(maxAgeMs: number): number;
+    close(): void;
+}

package/dist/brain/channel-store.js

@@ -0,0 +1,78 @@
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+/**
+ * SQLite-backed ordered message log for inter-agent communication.
+ * Each channel is a linear log that any agent (orchestrator or worker) can read/post to.
+ */
+export class ChannelStore {
+    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 ChannelStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS channel_messages (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        channel_id  TEXT NOT NULL,
+        sender      TEXT NOT NULL,
+        role        TEXT NOT NULL,
+        content     TEXT NOT NULL,
+        created_at  INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_channel_messages_channel
+        ON channel_messages(channel_id, id);
+    `);
+    }
+    /** Create a new channel, returns its UUID. */
+    createChannel() {
+        return randomUUID().slice(0, 12);
+    }
+    /** Post a message to a channel. Returns the message ID. */
+    post(channelId, sender, role, content) {
+        const info = this.db
+            .prepare(`INSERT INTO channel_messages (channel_id, sender, role, content, created_at)
+         VALUES (?, ?, ?, ?, ?)`)
+            .run(channelId, sender, role, content, Date.now());
+        return Number(info.lastInsertRowid);
+    }
+    /** Read all messages in a channel, ordered by ID. */
+    read(channelId) {
+        const rows = this.db
+            .prepare("SELECT * FROM channel_messages WHERE channel_id = ? ORDER BY id")
+            .all(channelId);
+        return rows.map(toMessage);
+    }
+    /** Clean up old channel messages older than maxAge ms. */
+    cleanup(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        const info = this.db
+            .prepare("DELETE FROM channel_messages WHERE created_at < ?")
+            .run(cutoff);
+        return info.changes;
+    }
+    close() {
+        this.db.close();
+        logger.info("Channel store closed");
+    }
+}
+function toMessage(row) {
+    return {
+        id: row.id,
+        channelId: row.channel_id,
+        sender: row.sender,
+        role: row.role,
+        content: row.content,
+        createdAt: row.created_at,
+    };
+}

package/dist/brain/compaction.d.ts

@@ -0,0 +1,37 @@
+import { type LanguageModel, type ModelMessage } from "ai";
+import type { Session } from "./session.js";
+/** Prefix injected into user messages for automated scheduled task runs. */
+export declare const SCHEDULED_TASK_PREFIX = "[Scheduled Task]";
+/** Prefix for compacted scheduler results in session history. */
+export declare const SCHEDULER_RESULT_PREFIX = "[Scheduler Result |";
+/** Estimate token count from a plain string. */
+export declare function estimateStringTokens(text: string): number;
+/** Estimate token count from message content. */
+export declare function estimateTokens(messages: ModelMessage[]): number;
+/**
+ * Compact conversation if estimated tokens exceed the context budget.
+ *
+ * Budget = contextWindow - systemPromptTokens - outputReserve
+ *
+ * Returns the (possibly compacted) messages and whether compaction occurred.
+ */
+export declare function compactMessages(model: LanguageModel, messages: ModelMessage[], contextWindow: number, systemPrompt: string): Promise<{
+    messages: ModelMessage[];
+    compacted: boolean;
+    summary?: string;
+}>;
+/**
+ * Programmatic compaction for scheduler sessions.
+ *
+ * 1. Collapses each [Scheduled Task] user msg + its assistant reply into a
+ *    single "[Scheduler Result | ...]" one-liner. Human messages interleaved
+ *    in the session are left untouched — only messages starting with
+ *    SCHEDULED_TASK_PREFIX are candidates.
+ * 2. Prunes old compacted results, keeping only the most recent MAX_SCHEDULER_RESULTS.
+ *
+ * No LLM cost — pure string manipulation.
+ * Call before appending a new scheduled task so all existing runs become "previous".
+ */
+export declare function compactSchedulerRuns(session: Session): void;
+/** Detect context overflow errors from various providers. */
+export declare function isContextOverflowError(error: unknown): boolean;

package/dist/brain/compaction.js

@@ -0,0 +1,214 @@
+import { generateText } from "ai";
+import { logger } from "../logger.js";
+const CHARS_PER_TOKEN = 4;
+const SAFETY_MARGIN = 1.2;
+// ── Scheduler compaction constants ──────────────────────────────────────────
+/** Prefix injected into user messages for automated scheduled task runs. */
+export const SCHEDULED_TASK_PREFIX = "[Scheduled Task]";
+/** Prefix for compacted scheduler results in session history. */
+export const SCHEDULER_RESULT_PREFIX = "[Scheduler Result |";
+/** Max characters kept from the assistant response in a compacted line. */
+const SCHEDULER_SUMMARY_MAX_LEN = 200;
+/** Max characters kept from the task prompt in a compacted line. */
+const SCHEDULER_PROMPT_MAX_LEN = 40;
+/** Maximum number of compacted scheduler results retained in the session. */
+const MAX_SCHEDULER_RESULTS = 100;
+/** Keep the most recent N messages intact (not summarized). */
+const KEEP_RECENT = 2;
+/** Reserve tokens for model output (max response length). */
+const OUTPUT_RESERVE = 8_192;
+/** Estimate token count from a plain string. */
+export function estimateStringTokens(text) {
+    return Math.ceil(Math.max(0, text.length) / CHARS_PER_TOKEN);
+}
+/** Estimate token count from message content. */
+export function estimateTokens(messages) {
+    let chars = 0;
+    for (const msg of messages) {
+        if (typeof msg.content === "string") {
+            chars += msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if ("text" in part && typeof part.text === "string") {
+                    chars += part.text.length;
+                }
+            }
+        }
+    }
+    return Math.ceil(Math.max(0, chars) / CHARS_PER_TOKEN);
+}
+/**
+ * Compact conversation if estimated tokens exceed the context budget.
+ *
+ * Budget = contextWindow - systemPromptTokens - outputReserve
+ *
+ * Returns the (possibly compacted) messages and whether compaction occurred.
+ */
+export async function compactMessages(model, messages, contextWindow, systemPrompt) {
+    const systemTokens = estimateStringTokens(systemPrompt);
+    // Cap output reserve to 10% of context window so small windows aren't swamped
+    const outputReserve = Math.min(OUTPUT_RESERVE, Math.floor(contextWindow * 0.1));
+    const messageBudget = contextWindow - systemTokens - outputReserve;
+    const estimated = estimateTokens(messages);
+    if (estimated * SAFETY_MARGIN <= messageBudget) {
+        return { messages, compacted: false };
+    }
+    logger.info(`Compaction triggered: ~${estimated} msg tokens * ${SAFETY_MARGIN} = ~${Math.ceil(estimated * SAFETY_MARGIN)} ` +
+        `> budget ${messageBudget} (context ${contextWindow} - system ${systemTokens} - output ${outputReserve})`);
+    // Not enough messages for LLM summarization — fall back to dropping oldest
+    if (messages.length <= KEEP_RECENT) {
+        logger.info("Too few messages for summarization, falling back to truncation");
+        return { messages: fallbackTruncate(messages, messageBudget), compacted: true };
+    }
+    // Dynamically adjust how many recent messages to keep based on budget
+    const keepRecent = Math.max(2, Math.min(KEEP_RECENT, messages.length - 2));
+    const recent = messages.slice(-keepRecent);
+    const old = messages.slice(0, -keepRecent);
+    // Extract readable text from old messages (skip tool parts)
+    const transcript = buildTranscript(old);
+    if (!transcript) {
+        logger.info("No text content in old messages, skipping compaction");
+        return { messages, compacted: false };
+    }
+    try {
+        const summary = await summarize(model, transcript);
+        const compacted = [
+            { role: "user", content: `[Prior conversation summary]\n${summary}` },
+            ...recent,
+        ];
+        const afterTokens = estimateTokens(compacted);
+        logger.info(`Compaction complete: ${estimated} -> ${afterTokens} tokens (${messages.length} -> ${compacted.length} messages)`);
+        return { messages: compacted, compacted: true, summary };
+    }
+    catch (err) {
+        logger.warn(`Compaction LLM call failed: ${err instanceof Error ? err.message : err}`);
+        // Fallback: drop oldest messages until under budget (no summary available)
+        return { messages: fallbackTruncate(messages, messageBudget), compacted: true };
+    }
+}
+/** Build a readable transcript from messages, skipping tool-use/tool-result parts. */
+function buildTranscript(messages) {
+    const lines = [];
+    for (const msg of messages) {
+        const role = msg.role === "user" ? "User" : "Assistant";
+        if (typeof msg.content === "string") {
+            lines.push(`${role}: ${msg.content}`);
+        }
+        else if (Array.isArray(msg.content)) {
+            const textParts = [];
+            for (const part of msg.content) {
+                if ("text" in part && typeof part.text === "string") {
+                    textParts.push(part.text);
+                }
+            }
+            if (textParts.length > 0) {
+                lines.push(`${role}: ${textParts.join(" ")}`);
+            }
+        }
+    }
+    return lines.length > 0 ? lines.join("\n") : null;
+}
+/** Call LLM to summarize the conversation transcript. */
+async function summarize(model, transcript) {
+    const { text } = await generateText({
+        model,
+        system: "You are a conversation summarizer. Produce a concise summary that preserves: " +
+            "key facts about the user (name, preferences, location, etc.), " +
+            "important decisions or agreements, " +
+            "context needed to continue the conversation naturally. " +
+            "Use bullet points. Be brief but complete.",
+        messages: [
+            {
+                role: "user",
+                content: `Summarize this conversation:\n\n${transcript}`,
+            },
+        ],
+    });
+    return text;
+}
+/** Fallback: drop oldest messages until estimated tokens fit within budget. Keep at least 2. */
+function fallbackTruncate(messages, messageBudget) {
+    let totalTokens = estimateTokens(messages);
+    // Walk forward, subtracting each dropped message's tokens until under budget
+    for (let i = 0; i < messages.length - 2; i++) {
+        if (totalTokens * SAFETY_MARGIN <= messageBudget) {
+            return messages.slice(i);
+        }
+        totalTokens -= estimateTokens([messages[i]]);
+    }
+    // Nothing fits — return the last 2 messages
+    return messages.slice(-2);
+}
+/**
+ * Programmatic compaction for scheduler sessions.
+ *
+ * 1. Collapses each [Scheduled Task] user msg + its assistant reply into a
+ *    single "[Scheduler Result | ...]" one-liner. Human messages interleaved
+ *    in the session are left untouched — only messages starting with
+ *    SCHEDULED_TASK_PREFIX are candidates.
+ * 2. Prunes old compacted results, keeping only the most recent MAX_SCHEDULER_RESULTS.
+ *
+ * No LLM cost — pure string manipulation.
+ * Call before appending a new scheduled task so all existing runs become "previous".
+ */
+export function compactSchedulerRuns(session) {
+    const messages = session.getMessages();
+    let changed = 0;
+    // Single backwards pass: compact uncompacted task runs and collect compacted indices.
+    // Backwards iteration keeps splice indices stable for the compaction step.
+    const compactedIndices = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "user" || typeof msg.content !== "string")
+            continue;
+        // Already compacted — track index for pruning
+        if (msg.content.startsWith(SCHEDULER_RESULT_PREFIX)) {
+            compactedIndices.push(i);
+            continue;
+        }
+        // Uncompacted scheduled task — compact if followed by assistant reply
+        if (!msg.content.startsWith(SCHEDULED_TASK_PREFIX))
+            continue;
+        const next = messages[i + 1];
+        if (!next || next.role !== "assistant")
+            continue;
+        const prompt = msg.content.slice(SCHEDULED_TASK_PREFIX.length).trim().slice(0, SCHEDULER_PROMPT_MAX_LEN);
+        const response = typeof next.content === "string"
+            ? next.content.slice(0, SCHEDULER_SUMMARY_MAX_LEN)
+            : "completed";
+        const timestamp = new Date().toISOString().slice(0, 16).replace("T", " ");
+        messages.splice(i, 2, { role: "user", content: `${SCHEDULER_RESULT_PREFIX} ${timestamp} | ${prompt}] ${response}` });
+        compactedIndices.push(i);
+        changed++;
+    }
+    // compactedIndices is in descending order from the backwards pass — reverse for pruning
+    compactedIndices.reverse();
+    // Prune oldest compacted results beyond the cap
+    const pruneCount = compactedIndices.length - MAX_SCHEDULER_RESULTS;
+    if (pruneCount > 0) {
+        // Remove oldest (lowest-index) entries; splice backwards to keep indices stable
+        for (let i = pruneCount - 1; i >= 0; i--) {
+            messages.splice(compactedIndices[i], 1);
+        }
+        changed += pruneCount;
+        logger.info(`[scheduler] Pruned ${pruneCount} old result(s), keeping ${MAX_SCHEDULER_RESULTS}`);
+    }
+    if (changed > 0) {
+        session.replaceMessages(messages);
+        logger.info(`[scheduler] Compacted/pruned ${changed} scheduler message(s)`);
+    }
+}
+/** Detect context overflow errors from various providers. */
+export function isContextOverflowError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const lower = msg.toLowerCase();
+    return (lower.includes("request_too_large") ||
+        lower.includes("context length exceeded") ||
+        lower.includes("maximum context length") ||
+        lower.includes("prompt is too long") ||
+        lower.includes("exceeds model context window") ||
+        lower.includes("request exceeds the maximum size") ||
+        (lower.includes("request size exceeds") && lower.includes("context window")) ||
+        (lower.includes("413") && lower.includes("too large")));
+}

package/dist/brain/context.d.ts

@@ -0,0 +1,33 @@
+import type { BashSecurityMode } from "../config.js";
+export interface ContextInput {
+    identity: string;
+    /** Model identifier shown to the model so it can self-identify (e.g. "claude-3.5-sonnet"). */
+    modelId?: string;
+    language?: string;
+    skillPrompts?: string[];
+    skillListing?: string;
+    /** Compact listing of all available integrations (always shown). */
+    integrationListing?: string;
+    /** System prompts for currently active integrations only. */
+    activeIntegrationPrompts?: string[];
+    hasMemory?: boolean;
+    bashMode?: BashSecurityMode;
+    bashSafeBins?: string[];
+    hasDesktop?: boolean;
+    /** Whether schedule tools are available. */
+    hasScheduler?: boolean;
+    /** Whether this is a scheduled task execution (not a user conversation). */
+    scheduledTask?: boolean;
+    /** Whether this session is the team's shared scheduler session. */
+    schedulerSession?: boolean;
+    /** Whether TTS speak tool is available. */
+    hasTTS?: boolean;
+    /** Channel type for this session (e.g. "telegram", "gateway"). */
+    channelType?: string;
+    /** Workers the orchestrator can delegate to. */
+    delegationWorkers?: Array<{
+        name: string;
+        identity: string;
+    }>;
+}
+export declare function buildSystemPrompt(input: ContextInput): string;

package/dist/brain/context.js

@@ -0,0 +1,77 @@
+export function buildSystemPrompt(input) {
+    const parts = [];
+    // Language directive
+    if (input.language === "auto" || !input.language) {
+        parts.push(`Reply in the user's language (default: English). Internal reasoning in English.`);
+    }
+    else if (input.language !== "English") {
+        parts.push(`Reply in ${input.language}. Internal reasoning in English.`);
+    }
+    parts.push(input.identity);
+    if (input.modelId) {
+        parts.push(`You are powered by the ${input.modelId} model.`);
+    }
+    parts.push(`Current time: ${new Date().toISOString()}`);
+    // Compact tool strategy — only cross-tool orchestration that can't live in individual tool descriptions
+    const strategy = [];
+    strategy.push(`Web: try web_fetch first → browser tools if blocked/JS-heavy. Never give up without trying browser.`);
+    if (input.hasTTS) {
+        const isLocal = !input.channelType || input.channelType === "gateway";
+        if (isLocal) {
+            strategy.push(`Voice: prefer speak for short replies in this local session.`);
+        }
+        else {
+            strategy.push(`Voice: only use speak if user explicitly asks (remote ${input.channelType} session).`);
+        }
+    }
+    if (input.hasDesktop) {
+        strategy.push(`Desktop: screenshot → act → screenshot → verify.`);
+    }
+    parts.push(`## Tools\n${strategy.map((s) => `- ${s}`).join("\n")}`);
+    // Bash — only allowlist mode needs extra context (safe bins list)
+    if (input.bashMode === "allowlist") {
+        const bins = input.bashSafeBins?.join(", ") ?? "";
+        parts.push(`## Bash\nAllowlist mode. Safe commands: ${bins}. If blocked, suggest an allowed alternative.`);
+    }
+    if (input.skillPrompts?.length) {
+        for (const prompt of input.skillPrompts) {
+            parts.push(prompt);
+        }
+    }
+    if (input.skillListing) {
+        parts.push(input.skillListing);
+    }
+    if (input.integrationListing) {
+        parts.push(input.integrationListing);
+    }
+    if (input.activeIntegrationPrompts?.length) {
+        for (const prompt of input.activeIntegrationPrompts) {
+            parts.push(prompt);
+        }
+    }
+    // Delegation — keep because it's multi-tool orchestration
+    if (input.delegationWorkers?.length) {
+        const workerList = input.delegationWorkers
+            .map((w) => `- **${w.name}**: ${w.identity}`)
+            .join("\n");
+        parts.push(`## Delegation
+Workers run in background. Available:
+${workerList}
+Delegate → get channel ID → notified on completion → read_channel for results.
+Workers have no conversation context — include everything they need in the task.`);
+    }
+    // Scheduler session guidance
+    if (input.schedulerSession) {
+        parts.push(`## Scheduler Session
+Shared session. [Scheduled Task] = automated. [User via ...] = human. [Scheduler Result | ...] = compacted history.`);
+    }
+    // Scheduled task execution mode (non-interactive)
+    if (input.scheduledTask) {
+        parts.push(`## Scheduled Task Mode
+Automated task — execute immediately, do not ask questions.
+Reminders: deliver directly. Data tasks: fetch and present.
+Conditional: reply with [SKIP] + reason if nothing noteworthy.
+Keep replies concise — this is a notification.`);
+    }
+    return parts.join("\n\n");
+}

package/dist/brain/delegation-store.d.ts

@@ -0,0 +1,33 @@
+export type DelegationStatus = "running" | "completed" | "failed";
+export interface DelegationRecord {
+    id: string;
+    agentId: string;
+    sessionKey: string;
+    task: string;
+    channelId: string | null;
+    status: DelegationStatus;
+    result: string | null;
+    error: string | null;
+    createdAt: number;
+    completedAt: number | null;
+}
+/**
+ * SQLite-backed persistence for delegation tasks.
+ * Shares the same DB file as MemoryStore and ScheduleStore.
+ */
+export declare class DelegationStore {
+    private db;
+    private constructor();
+    static create(dbPath: string): Promise<DelegationStore>;
+    private createSchema;
+    insert(record: Omit<DelegationRecord, "result" | "error" | "completedAt"> & {
+        status: "running";
+    }): void;
+    markCompleted(id: string, result: string): void;
+    markFailed(id: string, error: string): void;
+    getById(id: string): DelegationRecord | null;
+    listBySession(sessionKey: string, status?: DelegationStatus): DelegationRecord[];
+    /** Clean up old completed/failed delegations older than maxAge ms. */
+    cleanup(maxAgeMs: number): number;
+    close(): void;
+}

package/dist/brain/delegation-store.js

@@ -0,0 +1,106 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+/**
+ * SQLite-backed persistence for delegation tasks.
+ * Shares the same DB file as MemoryStore and ScheduleStore.
+ */
+export class DelegationStore {
+    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 DelegationStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS delegations (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        session_key TEXT NOT NULL,
+        task TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'running',
+        result TEXT,
+        error TEXT,
+        created_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_delegations_session ON delegations(session_key);
+      CREATE INDEX IF NOT EXISTS idx_delegations_status ON delegations(status);
+    `);
+        // Migration: add channel_id column if missing (graceful for existing DBs)
+        try {
+            this.db.exec("ALTER TABLE delegations ADD COLUMN channel_id TEXT");
+        }
+        catch {
+            // Column already exists — ignore
+        }
+    }
+    insert(record) {
+        this.db
+            .prepare(`INSERT INTO delegations (id, agent_id, session_key, task, channel_id, status, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(record.id, record.agentId, record.sessionKey, record.task, record.channelId ?? null, record.status, record.createdAt);
+    }
+    markCompleted(id, result) {
+        this.db
+            .prepare(`UPDATE delegations SET status = 'completed', result = ?, completed_at = ? WHERE id = ?`)
+            .run(result, Date.now(), id);
+    }
+    markFailed(id, error) {
+        this.db
+            .prepare(`UPDATE delegations SET status = 'failed', error = ?, completed_at = ? WHERE id = ?`)
+            .run(error, Date.now(), id);
+    }
+    getById(id) {
+        const row = this.db
+            .prepare("SELECT * FROM delegations WHERE id = ?")
+            .get(id);
+        return row ? toRecord(row) : null;
+    }
+    listBySession(sessionKey, status) {
+        if (status) {
+            const rows = this.db
+                .prepare("SELECT * FROM delegations WHERE session_key = ? AND status = ? ORDER BY created_at DESC")
+                .all(sessionKey, status);
+            return rows.map(toRecord);
+        }
+        const rows = this.db
+            .prepare("SELECT * FROM delegations WHERE session_key = ? ORDER BY created_at DESC")
+            .all(sessionKey);
+        return rows.map(toRecord);
+    }
+    /** Clean up old completed/failed delegations older than maxAge ms. */
+    cleanup(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        const info = this.db
+            .prepare("DELETE FROM delegations WHERE status != 'running' AND completed_at <= ?")
+            .run(cutoff);
+        return info.changes;
+    }
+    close() {
+        this.db.close();
+        logger.info("Delegation store closed");
+    }
+}
+function toRecord(row) {
+    return {
+        id: row.id,
+        agentId: row.agent_id,
+        sessionKey: row.session_key,
+        task: row.task,
+        channelId: row.channel_id ?? null,
+        status: row.status,
+        result: row.result ?? null,
+        error: row.error ?? null,
+        createdAt: row.created_at,
+        completedAt: row.completed_at ?? null,
+    };
+}

package/dist/brain/loop.d.ts

@@ -0,0 +1,21 @@
+import { type LanguageModel, type ModelMessage, type ToolSet } from "ai";
+export interface RunLoopResult {
+    /** The final text reply. */
+    text: string;
+    /** All response messages (assistant + tool) generated during the run. */
+    responseMessages: ModelMessage[];
+}
+export declare function runLoop(opts: {
+    model: LanguageModel;
+    system: string;
+    messages: ModelMessage[];
+    tools: ToolSet;
+    sessionKey: string;
+    maxSteps?: number;
+    /** Worker agent ID (e.g. "researcher"). Undefined for the orchestrator. */
+    agentId?: string;
+    /** Suppress all WebSocket broadcasts (used for background workers). */
+    silent?: boolean;
+    /** Human-readable label for logs (e.g. team name instead of UUID). Falls back to sessionKey. */
+    sessionLabel?: string;
+}): Promise<RunLoopResult>;