verybot 0.1.8

package/dist/brain/memory-extractor.js

@@ -0,0 +1,82 @@
+import { randomUUID } from "crypto";
+import { extractFacts } from "../memory/extractor.js";
+import { deriveMemoryTeamId } from "./session-key.js";
+import { logger } from "../logger.js";
+/** Run fact extraction every N user messages (not every message). */
+const EXTRACT_EVERY_N = 5;
+/**
+ * Handles memory extraction from conversation sessions.
+ * Tracks per-session message counts and batches extraction.
+ */
+export class MemoryExtractor {
+    model;
+    memoryStore;
+    embeddingProvider;
+    constructor(model, memoryStore, embeddingProvider) {
+        this.model = model;
+        this.memoryStore = memoryStore;
+        this.embeddingProvider = embeddingProvider;
+    }
+    /** Update the model used for extraction (e.g. after config reload). */
+    setModel(model) {
+        this.model = model;
+    }
+    /**
+     * Increment extraction counter and trigger extraction if threshold reached.
+     * Non-blocking: extraction runs in background.
+     */
+    trackAndMaybeExtract(sessionKey, sessions, messages, teamId) {
+        const state = sessions.get(sessionKey);
+        if (!state)
+            return;
+        const count = state.messagesSinceExtraction + 1;
+        state.messagesSinceExtraction = count;
+        if (count >= EXTRACT_EVERY_N) {
+            state.messagesSinceExtraction = 0;
+            const recent = messages.slice(-EXTRACT_EVERY_N * 2);
+            this.extractAndSaveFacts(sessionKey, recent, teamId).catch((err) => {
+                logger.warn(`Fact extraction failed: ${err instanceof Error ? err.message : err}`);
+            });
+        }
+    }
+    /** Extract and save facts from messages to memory store. */
+    async extractAndSaveFacts(sessionKey, messages, teamId) {
+        const facts = await extractFacts(this.model, messages);
+        if (facts.length === 0)
+            return;
+        // Embed all facts in parallel when a provider is available
+        const embeddings = this.embeddingProvider
+            ? await Promise.all(facts.map((f) => this.embeddingProvider.embed(f)))
+            : facts.map(() => undefined);
+        let saved = 0;
+        for (let i = 0; i < facts.length; i++) {
+            const wasSaved = this.memoryStore.save({
+                id: randomUUID(),
+                fact: facts[i],
+                source: sessionKey,
+                timestamp: Date.now(),
+                embedding: embeddings[i],
+                teamId,
+            });
+            if (wasSaved)
+                saved++;
+        }
+        if (saved > 0) {
+            logger.info(`[${sessionKey}] Saved ${saved} new memories (${facts.length - saved} duplicates skipped)`);
+        }
+    }
+    /** Extract remaining facts from all active sessions (call before shutdown). */
+    async flushAll(sessions) {
+        for (const [sessionKey, state] of sessions.entries()) {
+            if (state.messagesSinceExtraction > 0) {
+                try {
+                    const flushTeamId = deriveMemoryTeamId(sessionKey);
+                    await this.extractAndSaveFacts(sessionKey, state.session.getMessages(), flushTeamId);
+                }
+                catch (err) {
+                    logger.warn(`Shutdown extraction failed for ${sessionKey}: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+        }
+    }
+}

package/dist/brain/providers.d.ts

@@ -0,0 +1,14 @@
+import type { LanguageModel } from "ai";
+import type { CodexReasoningEffort } from "../config/model-spec.js";
+/** Provider identifier for Claude Code (used for MCP adapter detection). */
+export declare const CLAUDE_CODE_PROVIDER = "claude-code";
+/** Provider identifier for Codex CLI (used for MCP adapter detection). */
+export declare const CODEX_CLI_PROVIDER = "codex-cli";
+/** Force subscription auth by clearing API key from the SDK environment. */
+export declare const CODEX_CLI_ENV: {
+    readonly OPENAI_API_KEY: "";
+};
+export interface GetModelOptions {
+    codexReasoningEffort?: CodexReasoningEffort;
+}
+export declare function getModel(provider: string, modelId: string, options?: GetModelOptions): LanguageModel;

package/dist/brain/providers.js

@@ -0,0 +1,85 @@
+import { anthropic } from "@ai-sdk/anthropic";
+import { createClaudeCode } from "ai-sdk-provider-claude-code";
+import { createCodexCli } from "ai-sdk-provider-codex-cli";
+import { openai } from "@ai-sdk/openai";
+import { google } from "@ai-sdk/google";
+import { xai } from "@ai-sdk/xai";
+import { mistral } from "@ai-sdk/mistral";
+import { groq } from "@ai-sdk/groq";
+import { togetherai } from "@ai-sdk/togetherai";
+import { deepseek } from "@ai-sdk/deepseek";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { minimax } from "vercel-minimax-ai-provider";
+import { zhipu } from "zhipu-ai-provider";
+/** Provider identifier for Claude Code (used for MCP adapter detection). */
+export const CLAUDE_CODE_PROVIDER = "claude-code";
+/** Provider identifier for Codex CLI (used for MCP adapter detection). */
+export const CODEX_CLI_PROVIDER = "codex-cli";
+/** Force subscription auth by clearing API key from the SDK environment. */
+export const CODEX_CLI_ENV = { OPENAI_API_KEY: "" };
+/**
+ * Create Claude Code provider lazily. Reads CLAUDE_CODE_OAUTH_TOKEN from
+ * process.env which is kept fresh by reloadConfig() → injectSecretsIntoEnv()
+ * on every request.
+ */
+function getClaudeCode() {
+    const token = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    return createClaudeCode({
+        defaultSettings: {
+            permissionMode: "bypassPermissions",
+            env: {
+                ANTHROPIC_API_KEY: undefined,
+                ...(token ? { CLAUDE_CODE_OAUTH_TOKEN: token } : {}),
+            },
+        },
+    });
+}
+/**
+ * Base Codex CLI provider (no tools). Tools are added per-session in mcp-adapter.ts.
+ * Explicitly bypass approvals and sandbox to match "bypass all permissions" behavior.
+ */
+const codexCliBase = createCodexCli({
+    defaultSettings: {
+        dangerouslyBypassApprovalsAndSandbox: true,
+        env: CODEX_CLI_ENV,
+    },
+});
+const providers = {
+    anthropic: (id) => anthropic(id),
+    [CLAUDE_CODE_PROVIDER]: (id) => getClaudeCode()(id, { streamingInput: "always" }),
+    [CODEX_CLI_PROVIDER]: (id, options) => codexCliBase(id, options?.codexReasoningEffort
+        ? { reasoningEffort: options.codexReasoningEffort }
+        : undefined),
+    openai: (id) => openai(id),
+    google: (id) => google(id),
+    xai: (id) => xai(id),
+    mistral: (id) => mistral(id),
+    groq: (id) => groq(id),
+    togetherai: (id) => togetherai(id),
+    deepseek: (id) => deepseek(id),
+    minimax: (id) => minimax(id),
+    zhipu: (id) => zhipu(id),
+    openrouter: (id) => {
+        const provider = createOpenAICompatible({
+            name: "openrouter",
+            baseURL: "https://openrouter.ai/api/v1",
+            apiKey: process.env.OPENROUTER_API_KEY,
+        });
+        return provider(id);
+    },
+    ollama: (id) => {
+        const provider = createOpenAICompatible({
+            name: "ollama",
+            baseURL: process.env.OLLAMA_BASE_URL ?? "http://localhost:11434/v1",
+            apiKey: "ollama",
+        });
+        return provider(id);
+    },
+};
+export function getModel(provider, modelId, options) {
+    const factory = providers[provider];
+    if (!factory) {
+        throw new Error(`Unknown provider: ${provider}. Available: ${Object.keys(providers).join(", ")}`);
+    }
+    return factory(modelId, options);
+}

package/dist/brain/queue.d.ts

@@ -0,0 +1,18 @@
+export type QueueMode = "sequential" | "collect";
+export declare class MessageQueue {
+    private lanes;
+    private mode;
+    private processMessage;
+    constructor(opts: {
+        mode?: QueueMode;
+        processMessage: (sessionKey: string, text: string, signal: AbortSignal, images?: string[]) => Promise<string>;
+    });
+    /** Enqueue a message. Returns a promise that resolves with the agent reply. */
+    enqueue(sessionKey: string, text: string, images?: string[]): Promise<string>;
+    /** Abort the current run for a session. */
+    abort(sessionKey: string): boolean;
+    /** Remove the lane for a cleared session. Aborts any in-flight run first. */
+    deleteLane(sessionKey: string): void;
+    private drain;
+    private getOrCreateLane;
+}

package/dist/brain/queue.js

@@ -0,0 +1,111 @@
+export class MessageQueue {
+    lanes = new Map();
+    mode;
+    processMessage;
+    constructor(opts) {
+        this.mode = opts.mode ?? "collect";
+        this.processMessage = opts.processMessage;
+    }
+    /** Enqueue a message. Returns a promise that resolves with the agent reply. */
+    enqueue(sessionKey, text, images) {
+        const lane = this.getOrCreateLane(sessionKey);
+        return new Promise((resolve, reject) => {
+            lane.queue.push({ text, images, resolve, reject });
+            // If idle, start draining
+            if (!lane.running) {
+                this.drain(sessionKey);
+            }
+        });
+    }
+    /** Abort the current run for a session. */
+    abort(sessionKey) {
+        const lane = this.lanes.get(sessionKey);
+        if (!lane)
+            return false;
+        let aborted = false;
+        if (lane.abort) {
+            lane.abort.abort();
+            aborted = true;
+        }
+        if (lane.queue.length > 0) {
+            const pending = lane.queue.splice(0);
+            for (const msg of pending)
+                msg.resolve("");
+            aborted = true;
+        }
+        return aborted;
+    }
+    /** Remove the lane for a cleared session. Aborts any in-flight run first. */
+    deleteLane(sessionKey) {
+        const lane = this.lanes.get(sessionKey);
+        if (lane?.abort)
+            lane.abort.abort();
+        this.lanes.delete(sessionKey);
+    }
+    async drain(sessionKey) {
+        const lane = this.lanes.get(sessionKey);
+        if (!lane || lane.running)
+            return;
+        lane.running = true;
+        while (lane.queue.length > 0) {
+            const batch = lane.queue.splice(0);
+            const controller = new AbortController();
+            lane.abort = controller;
+            try {
+                if (this.mode === "collect") {
+                    const combined = batch.map((m) => m.text).join("\n");
+                    // Collect images from all messages in the batch
+                    const allImages = batch.flatMap((m) => m.images ?? []);
+                    const images = allImages.length > 0 ? allImages : undefined;
+                    const reply = await this.processMessage(sessionKey, combined, controller.signal, images);
+                    // Only the last message gets the reply; earlier ones resolve empty (no Telegram send)
+                    for (let i = 0; i < batch.length - 1; i++)
+                        batch[i].resolve("");
+                    batch[batch.length - 1].resolve(reply);
+                }
+                else {
+                    for (const msg of batch) {
+                        if (controller.signal.aborted) {
+                            msg.resolve("");
+                            continue;
+                        }
+                        const reply = await this.processMessage(sessionKey, msg.text, controller.signal, msg.images);
+                        msg.resolve(reply);
+                    }
+                }
+            }
+            catch (err) {
+                if (controller.signal.aborted || isAbortLikeError(err)) {
+                    for (const msg of batch)
+                        msg.resolve("");
+                }
+                else {
+                    for (const msg of batch)
+                        msg.reject(err);
+                }
+            }
+            lane.abort = null;
+            // Loop continues if new messages arrived during processing
+        }
+        lane.running = false;
+        // Remove idle lane to prevent unbounded growth
+        if (lane.queue.length === 0)
+            this.lanes.delete(sessionKey);
+    }
+    getOrCreateLane(sessionKey) {
+        let lane = this.lanes.get(sessionKey);
+        if (!lane) {
+            lane = { queue: [], running: false, abort: null };
+            this.lanes.set(sessionKey, lane);
+        }
+        return lane;
+    }
+}
+function isAbortLikeError(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (err.name === "AbortError")
+        return true;
+    const msg = err.message.toLowerCase();
+    return msg.includes("aborted") || msg.includes("abort");
+}

package/dist/brain/run-tools.d.ts

@@ -0,0 +1,50 @@
+import type { ToolSet } from "ai";
+import type { Config } from "../config.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import type { DockerSandbox } from "../security/docker-sandbox.js";
+import type { SkillManager } from "../skills/loader.js";
+import type { IntegrationRegistry } from "../integrations/registry.js";
+import type { ScheduleStore } from "../scheduler/store.js";
+import type { DesktopAdapter } from "../computer/desktop/adapter.js";
+import type { BrowserManager } from "../computer/browser/manager.js";
+import type { AgentRegistry } from "./agent-registry.js";
+import type { ChannelStore } from "./channel-store.js";
+import type { DelegationStore } from "./delegation-store.js";
+import type { SessionStore } from "./session-store.js";
+import type { TaskStore } from "../tasks/store.js";
+import type { TeamStore } from "../teams/store.js";
+import type { PromptTemplateStore } from "../prompt-templates/store.js";
+import type { ChannelManager } from "../channels/manager.js";
+export type RunAgentRole = "orchestrator" | "worker";
+/** All dependencies needed to build per-run tools. */
+export interface RunToolsDeps {
+    baseTools: ToolSet;
+    config: Config;
+    memoryStore: MemoryStore | null;
+    embeddingProvider: EmbeddingProvider | null;
+    memoryMaxResults: number;
+    sandbox: DockerSandbox | null;
+    skillManager: SkillManager;
+    integrationRegistry: IntegrationRegistry;
+    scheduleStore: ScheduleStore | null;
+    taskStore: TaskStore | null;
+    teamStore: TeamStore | null;
+    promptTemplateStore: PromptTemplateStore | null;
+    desktopAdapter: DesktopAdapter | null;
+    browserManager: BrowserManager | null;
+    /** Effective model string ("provider:id") for the current run — may differ from global config when inside a team. */
+    effectiveModel: string;
+    agentRegistry: AgentRegistry | null;
+    delegationStore: DelegationStore | null;
+    channelStore: ChannelStore | null;
+    channelManager: ChannelManager | null;
+    sessionStore: SessionStore;
+    modelId: string;
+    onWorkerComplete: (sessionKey: string, channelId: string) => void;
+}
+/** Build the per-run tool set based on current session state. */
+export declare function buildRunTools(deps: RunToolsDeps, sessionKey: string, activeIntegrations: Set<string>, channelInfo?: {
+    channelType: string;
+    channelId: string;
+}, agentId?: string, agentRole?: RunAgentRole, teamId?: string, scheduleTeamId?: string, sessionLabel?: string, workspaceCwd?: string, agentToolAllowlist?: string[]): ToolSet;

package/dist/brain/run-tools.js

@@ -0,0 +1,136 @@
+import { createBashTool } from "../tools/bash.js";
+import { createMemorySearchTool, createMemorySaveTool } from "../tools/memory.js";
+import { createDesktopTool } from "../computer/desktop/tools.js";
+import { createBrowserTools } from "../computer/browser/tools.js";
+import { createSpeakTools } from "../tools/speak.js";
+import { createDelegationTools } from "../tools/delegate.js";
+import { createIntegrationToggleTools } from "../tools/integration-toggle.js";
+import { createScheduleTools } from "../tools/schedule.js";
+import { createTaskTools } from "../tools/tasks.js";
+import { createScopedWorkerManagementTools, createTeamManagementTools } from "../tools/teams.js";
+import { createPromptTemplateTools } from "../tools/prompt-templates.js";
+import { createChannelHistoryTool } from "../tools/channel-history.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+import { logger } from "../logger.js";
+/** Build the per-run tool set based on current session state. */
+export function buildRunTools(deps, sessionKey, activeIntegrations, channelInfo, agentId, agentRole, teamId, scheduleTeamId, sessionLabel, workspaceCwd, agentToolAllowlist) {
+    const enforceWorkerAllowlist = agentRole === "worker" &&
+        Array.isArray(agentToolAllowlist) &&
+        agentToolAllowlist.length > 0;
+    const allowedToolNames = new Set(agentToolAllowlist ?? []);
+    const isAllowed = (toolName) => !enforceWorkerAllowlist || allowedToolNames.has(toolName);
+    const mergeAllowedTools = (extraTools) => {
+        for (const [toolName, toolDef] of Object.entries(extraTools)) {
+            if (!isAllowed(toolName))
+                continue;
+            tools[toolName] = toolDef;
+        }
+    };
+    const tools = { ...deps.baseTools };
+    // Rebuild browser tools per run so browser actions are bound to the current session key.
+    if (deps.browserManager) {
+        const browserSessionKey = deps.config.browserMode === "per-tab-per-session" ? sessionKey : undefined;
+        mergeAllowedTools(createBrowserTools(deps.browserManager, browserSessionKey));
+        if (browserSessionKey) {
+            logger.debug(`[${sessionLabel}] Browser tools bound to session key: ${browserSessionKey}`);
+        }
+    }
+    // Session-scoped bash tool (needs sessionKey for sandbox container routing)
+    const bashTool = createBashTool(deps.config.bash, {
+        sessionKey,
+        sandbox: deps.sandbox,
+        cwd: workspaceCwd,
+    });
+    if (bashTool && isAllowed("bash"))
+        tools.bash = bashTool;
+    // When sandbox is enabled, remove fs tools — bash inside the container covers these
+    if (deps.sandbox) {
+        for (const name of ["read", "write", "edit", "grep", "find", "ls"]) {
+            delete tools[name];
+        }
+    }
+    if (deps.memoryStore) {
+        // Scope memory to team when talking to a non-default team
+        const memoryTeamId = teamId && teamId !== DEFAULT_TEAM_ID ? teamId : undefined;
+        if (isAllowed("memory_search")) {
+            tools.memory_search = createMemorySearchTool(deps.memoryStore, deps.embeddingProvider, deps.memoryMaxResults, memoryTeamId);
+        }
+        if (isAllowed("memory_save")) {
+            tools.memory_save = createMemorySaveTool(deps.memoryStore, deps.embeddingProvider, sessionKey, memoryTeamId);
+        }
+    }
+    // Desktop tool — rebuilt per-run to track model/config changes
+    if (deps.config.desktop.enabled && deps.desktopAdapter) {
+        if (isAllowed("computer")) {
+            tools.computer = createDesktopTool(deps.desktopAdapter, deps.modelId);
+        }
+    }
+    // TTS tools — rebuilt per-run so enabling/disabling takes effect immediately
+    const ttsTools = createSpeakTools(deps.config.tts);
+    if (ttsTools)
+        mergeAllowedTools(ttsTools);
+    // Dynamic read_skill tool (reflects latest SkillManager state after hot-reload)
+    const readSkill = deps.skillManager.readTool;
+    if (readSkill && isAllowed("read_skill"))
+        tools.read_skill = readSkill;
+    // Integration tools (only for active integrations)
+    mergeAllowedTools(deps.integrationRegistry.getToolsFor(activeIntegrations));
+    // Enable/disable integration tools (always present if integrations exist)
+    if (deps.integrationRegistry.names.length > 0) {
+        mergeAllowedTools(createIntegrationToggleTools(deps.integrationRegistry, activeIntegrations));
+    }
+    // Delegation tools (only for orchestrators with workers)
+    if (agentRole === "orchestrator" && agentId && deps.agentRegistry && deps.delegationStore && deps.channelStore) {
+        const workers = deps.agentRegistry.delegatableWorkers();
+        if (workers.length > 0) {
+            Object.assign(tools, createDelegationTools(deps.agentRegistry, deps.channelStore, deps.delegationStore, deps.sessionStore, agentId, sessionKey, deps.memoryStore, deps.embeddingProvider, deps.memoryMaxResults, deps.onWorkerComplete, deps.browserManager
+                ? {
+                    headless: deps.config.browserHeadless,
+                    userAgent: deps.config.browserUserAgent || undefined,
+                    mode: deps.config.browserMode,
+                    modeOptions: deps.config.browserModeOptions,
+                }
+                : null, sessionLabel, !!deps.sandbox));
+        }
+    }
+    // Task tools — scoped to team when talking to a specific team, with team's custom statuses
+    if (deps.taskStore) {
+        const teamStatuses = teamId && deps.teamStore
+            ? deps.teamStore.getTeamById(teamId)?.statuses ?? undefined
+            : undefined;
+        mergeAllowedTools(createTaskTools(deps.taskStore, teamId, teamStatuses, {
+            updatedBy: agentId ?? "assistant",
+        }));
+    }
+    // Team management tools:
+    // - default runtime: full team management
+    // - non-default orchestrator: worker CRUD scoped to its own team
+    const isDefaultRuntimeTeam = !teamId || teamId === DEFAULT_TEAM_ID;
+    if (deps.teamStore) {
+        if (isDefaultRuntimeTeam) {
+            mergeAllowedTools(createTeamManagementTools(deps.teamStore, DEFAULT_TEAM_ID, deps.promptTemplateStore ?? undefined));
+        }
+        else if (agentRole === "orchestrator") {
+            mergeAllowedTools(createScopedWorkerManagementTools(deps.teamStore, teamId, deps.promptTemplateStore ?? undefined));
+        }
+    }
+    // Prompt template tools stay on the default runtime only.
+    if (isDefaultRuntimeTeam && deps.promptTemplateStore) {
+        mergeAllowedTools(createPromptTemplateTools(deps.promptTemplateStore));
+    }
+    // Schedule management tools (team-scoped — uses separate scheduleTeamId to avoid default-team regression)
+    const effectiveScheduleTeamId = scheduleTeamId ?? teamId;
+    if (deps.scheduleStore && effectiveScheduleTeamId) {
+        mergeAllowedTools(createScheduleTools(deps.scheduleStore, effectiveScheduleTeamId, deps.integrationRegistry.names));
+    }
+    // Channel history tool — lets the LLM read recent messages on demand.
+    // Uses a resolver callback so the channelId is read fresh at execution time,
+    // not captured in a stale closure at tool creation time.
+    if (channelInfo && deps.channelManager) {
+        const { channelType, channelId } = channelInfo;
+        const historyTool = createChannelHistoryTool(deps.channelManager, channelType, () => channelId);
+        if (historyTool && isAllowed("read_channel_history"))
+            tools.read_channel_history = historyTool;
+    }
+    return tools;
+}

package/dist/brain/session-key.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Build a session key: `{teamId}:{channelType}:{channelId}`.
+ */
+export declare function buildSessionKey(teamId: string, channelType: string, channelId: string): string;
+/**
+ * Extract a non-default teamId from a session key for memory scoping.
+ * Returns undefined for the default team (global memory).
+ */
+export declare function deriveMemoryTeamId(sessionKey: string): string | undefined;
+export interface ParsedSessionKey {
+    teamId?: string;
+    channelType?: string;
+    /** Agent name (for worker sessions only, extracted from key). */
+    agentName?: string;
+    isWorker: boolean;
+}
+/**
+ * Parse a session key into its components.
+ *
+ * Standard key: `{teamId}:{channelType}:{channelId}`
+ * Worker  key: `{teamId}:{parentChannel}:{channelId}:{agentName}:{timestamp}`
+ */
+export declare function parseSessionKey(key: string): ParsedSessionKey;

package/dist/brain/session-key.js

@@ -0,0 +1,41 @@
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+/**
+ * Build a session key: `{teamId}:{channelType}:{channelId}`.
+ */
+export function buildSessionKey(teamId, channelType, channelId) {
+    return `${teamId}:${channelType}:${channelId}`;
+}
+/**
+ * Extract a non-default teamId from a session key for memory scoping.
+ * Returns undefined for the default team (global memory).
+ */
+export function deriveMemoryTeamId(sessionKey) {
+    const { teamId } = parseSessionKey(sessionKey);
+    return teamId && teamId !== DEFAULT_TEAM_ID ? teamId : undefined;
+}
+/**
+ * Parse a session key into its components.
+ *
+ * Standard key: `{teamId}:{channelType}:{channelId}`
+ * Worker  key: `{teamId}:{parentChannel}:{channelId}:{agentName}:{timestamp}`
+ */
+export function parseSessionKey(key) {
+    const parts = key.split(":");
+    // Worker keys have 5+ parts with a numeric timestamp at the end
+    if (parts.length >= 5 && /^\d+$/.test(parts[parts.length - 1])) {
+        return {
+            isWorker: true,
+            teamId: parts[0],
+            channelType: "worker",
+            agentName: parts[parts.length - 2],
+        };
+    }
+    if (parts.length >= 3) {
+        return {
+            isWorker: false,
+            teamId: parts[0],
+            channelType: parts[1],
+        };
+    }
+    return { isWorker: false };
+}

package/dist/brain/session-state.d.ts

@@ -0,0 +1,36 @@
+import type { Session } from "./session.js";
+/** Consolidated per-session state (replaces 8 separate Maps). */
+export interface SessionState {
+    session: Session;
+    agentId?: string;
+    teamId?: string;
+    channelType?: string;
+    channelId?: string;
+    integrations?: Set<string>;
+    messagesSinceExtraction: number;
+    delegationDepth: number;
+    /** Running estimate of message tokens (chars / 4). Updated on append, reset on compaction. */
+    estimatedMsgTokens: number;
+    replyCallback?: (reply: string) => Promise<void>;
+    workerTriggerTimer?: ReturnType<typeof setTimeout>;
+    workerPendingChannels?: Set<string>;
+    /** Integrations for the next scheduled task run (consumed once by main()). */
+    scheduledIntegrations?: string[];
+}
+/**
+ * Type-safe wrapper around a Map<string, SessionState>.
+ * Provides convenient accessors and cleanup helpers.
+ */
+export declare class SessionStateMap {
+    private map;
+    get(key: string): SessionState | undefined;
+    /** Get existing state or create a new entry with the given session. */
+    getOrCreate(key: string, session: Session): SessionState;
+    /** Set a session state (used when loading from store). */
+    set(key: string, state: SessionState): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    entries(): IterableIterator<[string, SessionState]>;
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers(): void;
+}

package/dist/brain/session-state.js

@@ -0,0 +1,51 @@
+/**
+ * Type-safe wrapper around a Map<string, SessionState>.
+ * Provides convenient accessors and cleanup helpers.
+ */
+export class SessionStateMap {
+    map = new Map();
+    get(key) {
+        return this.map.get(key);
+    }
+    /** Get existing state or create a new entry with the given session. */
+    getOrCreate(key, session) {
+        let state = this.map.get(key);
+        if (!state) {
+            state = {
+                session,
+                messagesSinceExtraction: 0,
+                delegationDepth: 0,
+                estimatedMsgTokens: 0,
+            };
+            this.map.set(key, state);
+        }
+        return state;
+    }
+    /** Set a session state (used when loading from store). */
+    set(key, state) {
+        this.map.set(key, state);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(key) {
+        const state = this.map.get(key);
+        if (state?.workerTriggerTimer) {
+            clearTimeout(state.workerTriggerTimer);
+        }
+        this.map.delete(key);
+    }
+    entries() {
+        return this.map.entries();
+    }
+    /** Cancel all pending debounce timers (e.g. on shutdown). */
+    clearAllTimers() {
+        for (const state of this.map.values()) {
+            if (state.workerTriggerTimer) {
+                clearTimeout(state.workerTriggerTimer);
+                state.workerTriggerTimer = undefined;
+            }
+            state.workerPendingChannels = undefined;
+        }
+    }
+}