verybot 0.1.3

package/dist/brain/agent.js

@@ -0,0 +1,680 @@
+import { loadConfig, injectSecretsIntoEnv } from "../config.js";
+import { INTEGRATIONS_DIR, MEMORY_DB_PATH } from "../paths.js";
+import { Session } from "./session.js";
+import { SessionStore } from "./session-store.js";
+import { MessageQueue } from "./queue.js";
+import { buildSystemPrompt } from "./context.js";
+import { runLoop } from "./loop.js";
+import { getModel } from "./providers.js";
+import { adaptTools } from "./mcp-adapter.js";
+import { resolveModelDef } from "../config/model-catalog.js";
+import { isContextOverflowError, estimateTokens, estimateStringTokens, compactSchedulerRuns, SCHEDULED_TASK_PREFIX } from "./compaction.js";
+import { DEFAULT_SAFE_BINS } from "../security/command-validator.js";
+import { IntegrationRegistry } from "../integrations/registry.js";
+import { ChannelStore } from "./channel-store.js";
+import { DelegationStore } from "./delegation-store.js";
+import { TeamRegistry, parseModel } from "./agent-registry.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+import { buildChannelSpecs } from "../channels/specs.js";
+import { logger } from "../logger.js";
+import { emit, on } from "../events.js";
+import { buildSessionKey, parseSessionKey, deriveMemoryTeamId } from "./session-key.js";
+import { setsEqual, friendlyError } from "./utils.js";
+import { SessionStateMap } from "./session-state.js";
+import { MemoryExtractor } from "./memory-extractor.js";
+import { WorkerCoordinator } from "./worker-coordinator.js";
+import { buildRunTools } from "./run-tools.js";
+/** Max compaction retries on context overflow before re-throwing. */
+const MAX_COMPACTION_RETRIES = 3;
+/** Skip compaction when estimated total tokens are below this fraction of the context window. */
+const COMPACTION_SKIP_THRESHOLD = 0.6;
+/** Session key suffix that identifies the team's shared scheduler session. */
+const SCHEDULER_SESSION_SUFFIX = ":scheduler:main";
+export class Agent {
+    sessions = new SessionStateMap();
+    sessionStore;
+    queue;
+    model;
+    modelId;
+    identity;
+    language;
+    tools;
+    modelDef;
+    memoryStore;
+    embeddingProvider;
+    memoryMaxResults;
+    config;
+    configStore;
+    sandbox;
+    skillManager;
+    integrationRegistry;
+    scheduleStore;
+    taskStore;
+    desktopAdapter;
+    browserManager;
+    teamRegistry = null;
+    delegationStore;
+    channelStore;
+    teamStore;
+    channelManager;
+    connectedChannels;
+    lastConfigMtime = null;
+    teamRegistryDirty = false;
+    newSessionPending = false;
+    unsubTeamChange = null;
+    memoryExtractor = null;
+    workerCoordinator;
+    /** Cleanup functions for HTTP MCP servers (keyed by session key). */
+    mcpCleanups = new Map();
+    constructor(deps) {
+        this.tools = deps.tools;
+        this.sessionStore = new SessionStore(deps.dataDir);
+        this.memoryStore = deps.memoryStore ?? null;
+        this.embeddingProvider = deps.embeddingProvider ?? null;
+        this.config = deps.config;
+        this.configStore = deps.configStore;
+        this.sandbox = deps.sandbox ?? null;
+        this.skillManager = deps.skillManager ?? { systemPrompt: "", readTool: null };
+        this.integrationRegistry = deps.integrationRegistry ?? new IntegrationRegistry();
+        this.scheduleStore = deps.scheduleStore ?? null;
+        this.taskStore = deps.taskStore ?? null;
+        this.desktopAdapter = deps.desktopAdapter ?? null;
+        this.browserManager = deps.browserManager ?? null;
+        this.delegationStore = deps.delegationStore ?? null;
+        this.channelStore = deps.channelStore ?? null;
+        this.teamStore = deps.teamStore ?? null;
+        this.channelManager = deps.channelManager ?? null;
+        this.connectedChannels = deps.connectedChannels ?? null;
+        // Apply config synchronously so fields are initialized immediately (no `!` assertions)
+        this.model = getModel(deps.config.model.provider, deps.config.model.id);
+        this.modelId = deps.config.model.id;
+        this.modelDef = resolveModelDef(deps.config.model.id, deps.config.model.contextWindow);
+        this.identity = deps.config.identity;
+        this.language = deps.config.language;
+        this.memoryMaxResults = deps.config.memory.maxResults;
+        if (this.memoryStore) {
+            this.memoryExtractor = new MemoryExtractor(this.model, this.memoryStore, this.embeddingProvider);
+        }
+        // Build team registry eagerly so getTeams() works before first message
+        this.rebuildTeamRegistry();
+        // Mark dirty when teams change so next main() call rebuilds the registry
+        this.unsubTeamChange = on("teamChange", () => { this.teamRegistryDirty = true; });
+        this.queue = new MessageQueue({
+            mode: "collect",
+            processMessage: (sessionKey, text, _signal) => this.main(sessionKey, text),
+        });
+        this.workerCoordinator = new WorkerCoordinator(this.sessions, this.queue);
+    }
+    /** Force an immediate config reload + channel reconciliation. */
+    async forceConfigReload() {
+        this.lastConfigMtime = null;
+        await this.reloadConfig();
+    }
+    getSession(key) {
+        return this.sessions.get(key)?.session;
+    }
+    getStore() {
+        return this.sessionStore;
+    }
+    /** Called from channels (Telegram, Discord, etc.) */
+    async handleMessage(msg, channel, agentId) {
+        const sessionKey = buildSessionKey(agentId
+            ? (this.teamRegistry?.resolveTeam(agentId)?.teamId ?? DEFAULT_TEAM_ID)
+            : (msg.teamId ?? DEFAULT_TEAM_ID), msg.channelType, msg.channelId);
+        try {
+            const teamId = agentId
+                ? (this.teamRegistry?.resolveTeam(agentId)?.teamId ?? DEFAULT_TEAM_ID)
+                : (msg.teamId ?? DEFAULT_TEAM_ID);
+            const text = msg.text ?? "";
+            // Eagerly create session so agentId + replyCallback are set before the queue runs
+            const state = await this.getOrCreateSession(sessionKey);
+            state.teamId = teamId;
+            state.channelType = msg.channelType;
+            state.channelId = msg.channelId;
+            this.applyAgentBinding(state, sessionKey, agentId);
+            if (!state.replyCallback) {
+                state.replyCallback = (reply) => this.deliverReply(msg, channel, reply);
+            }
+            const reply = await this.queue.enqueue(sessionKey, text);
+            if (reply)
+                await this.deliverReply(msg, channel, reply);
+        }
+        catch (err) {
+            logger.error(`Agent error [${this.sessionLabel(sessionKey)}]: ${err}`);
+            const userMsg = friendlyError(err);
+            emit("chat", {
+                sessionKey,
+                state: "final",
+                message: { role: "assistant", content: userMsg },
+            });
+            try {
+                await channel.send(msg.channelId, userMsg);
+            }
+            catch (sendErr) {
+                logger.error(`Failed to send error to user [${this.sessionLabel(sessionKey)}]: ${sendErr}`);
+            }
+        }
+    }
+    /** Deliver reply as text or voice based on TTS reply mode. */
+    async deliverReply(msg, channel, reply) {
+        const { replyMode } = this.config.tts;
+        const shouldVoice = this.config.tts.enabled &&
+            channel.sendVoice &&
+            (replyMode === "voice" || (replyMode === "inbound" && msg.isVoice));
+        if (shouldVoice) {
+            try {
+                const { synthesize } = await import("../tts/edge.js");
+                const audioPath = await synthesize(reply);
+                await channel.sendVoice(msg.channelId, audioPath);
+            }
+            catch (err) {
+                logger.error(`Voice reply failed, falling back to text: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        await channel.send(msg.channelId, reply);
+    }
+    /** Called from gateway RPC (WebSocket UI) */
+    async handleGatewayMessage(sessionKey, text, agentId) {
+        try {
+            const state = await this.getOrCreateSession(sessionKey);
+            // Team ID is encoded in the session key (teamId:gateway:random) — extract it
+            // directly instead of reverse-resolving from orchestrator ID (which can collide).
+            const colonIdx = sessionKey.indexOf(":");
+            const keyTeamId = colonIdx > 0 ? sessionKey.slice(0, colonIdx) : "";
+            state.teamId = keyTeamId || DEFAULT_TEAM_ID;
+            state.channelType = "gateway";
+            state.channelId = sessionKey;
+            this.applyAgentBinding(state, sessionKey, agentId);
+            return await this.queue.enqueue(sessionKey, text);
+        }
+        catch (err) {
+            logger.error(`Gateway error [${this.sessionLabel(sessionKey)}]: ${err}`);
+            const errorReply = friendlyError(err);
+            // Emit a "chat" final event so the WebSocket UI renders the error
+            // instead of hanging on a loading state.
+            emit("chat", {
+                sessionKey,
+                agentId,
+                state: "final",
+                message: { role: "assistant", content: errorReply },
+            });
+            return errorReply;
+        }
+    }
+    /** Validate and bind an agentId to an existing session state. */
+    applyAgentBinding(state, sessionKey, agentId) {
+        if (!agentId)
+            return;
+        // Validate using the team ID already set on the state (derived from session key),
+        // not via resolveTeam(agentId) which can collide across teams.
+        if (this.teamRegistry && state.teamId) {
+            const registry = this.teamRegistry.getTeamRegistry(state.teamId);
+            if (!registry) {
+                logger.warn(`[${this.sessionLabel(sessionKey)}] Unknown team "${this.teamLabel(state.teamId)}" — ignoring agentId`);
+                return;
+            }
+            // Verify agentId actually matches this team's orchestrator
+            if (registry.getOrchestrator().id !== agentId) {
+                logger.warn(`[${this.sessionLabel(sessionKey)}] agentId "${agentId}" does not match team "${this.teamLabel(state.teamId)}" orchestrator — ignoring`);
+                return;
+            }
+        }
+        if (state.agentId && state.agentId !== agentId) {
+            logger.warn(`[${this.sessionLabel(sessionKey)}] Ignoring agentId change from "${state.agentId}" to "${agentId}" — clear session first`);
+        }
+        else if (!state.agentId) {
+            state.agentId = agentId;
+        }
+    }
+    /** Return teams for the UI picker. Reads from TeamStore for immediate visibility. */
+    getTeams() {
+        const defaultTeam = {
+            id: DEFAULT_TEAM_ID,
+            name: "Default",
+            color: "",
+            orchestratorId: "main",
+            orchestratorIdentity: this.identity,
+            orchestratorModel: this.modelId,
+            workerCount: 0,
+        };
+        if (!this.teamStore)
+            return [defaultTeam];
+        const teamConfigs = this.teamStore.toTeamConfigs();
+        const dbTeams = teamConfigs.map((t) => ({
+            id: t.id,
+            name: t.name ?? t.id,
+            color: t.color ?? "",
+            orchestratorId: t.orchestrator.id,
+            orchestratorIdentity: t.orchestrator.identity,
+            orchestratorModel: parseModel(t.orchestrator.model).modelId,
+            workerCount: t.workers.length,
+        }));
+        return [defaultTeam, ...dbTeams];
+    }
+    /** Abort current run for a session. */
+    abortSession(sessionKey) {
+        return this.queue.abort(sessionKey);
+    }
+    /** Clear conversation history (memories are preserved across clears). */
+    async clearSession(sessionKey) {
+        logger.info(`Clearing session ${sessionKey}`);
+        // Extract any remaining facts in background — don't block the clear
+        const state = this.sessions.get(sessionKey);
+        if (this.memoryExtractor && state && state.messagesSinceExtraction > 0) {
+            const messages = state.session.getMessages();
+            this.memoryExtractor.extractAndSaveFacts(sessionKey, messages, deriveMemoryTeamId(sessionKey)).catch((err) => {
+                logger.warn(`Pre-clear extraction failed: ${err instanceof Error ? err.message : err}`);
+            });
+        }
+        this.sessions.delete(sessionKey);
+        this.queue.deleteLane(sessionKey);
+        await this.sessionStore.clear(sessionKey);
+        // Shut down any HTTP MCP server for this session
+        const cleanup = this.mcpCleanups.get(sessionKey);
+        if (cleanup) {
+            this.mcpCleanups.delete(sessionKey);
+            await cleanup();
+        }
+    }
+    /**
+     * Run a scheduled task in a persistent scheduler session. Returns the raw LLM reply.
+     * Serialized through the message queue to avoid races with human messages.
+     * The caller (Scheduler) handles [SKIP] detection and channel delivery.
+     */
+    async runScheduledTask(opts) {
+        const schedulerKey = `${opts.teamId}${SCHEDULER_SESSION_SUFFIX}`;
+        const state = await this.getOrCreateSession(schedulerKey);
+        state.teamId = opts.teamId;
+        state.channelType = "scheduler";
+        state.channelId = "main";
+        // Store integrations for this scheduled run so main() can pick them up
+        state.scheduledIntegrations = opts.integrations;
+        return this.queue.enqueue(schedulerKey, `${SCHEDULED_TASK_PREFIX} ${opts.prompt}`);
+    }
+    /**
+     * Handle a human message sent to the scheduler session.
+     * Serialized via the message queue to avoid overlap with scheduled task executions.
+     */
+    async handleSchedulerMessage(teamId, text, senderInfo) {
+        const schedulerKey = `${teamId}${SCHEDULER_SESSION_SUFFIX}`;
+        const state = await this.getOrCreateSession(schedulerKey);
+        state.teamId = teamId;
+        state.channelType = "scheduler";
+        state.channelId = "main";
+        const prefixed = senderInfo ? `[${senderInfo}] ${text}` : text;
+        return this.queue.enqueue(schedulerKey, prefixed);
+    }
+    /** Get the scheduler session for a team (for history display). */
+    getSchedulerSession(teamId) {
+        const schedulerKey = `${teamId}${SCHEDULER_SESSION_SUFFIX}`;
+        return this.sessions.get(schedulerKey)?.session;
+    }
+    /** Start initial channels based on current config. Called once at boot. */
+    async initChannels() {
+        await this.reconcileChannels(this.config);
+    }
+    /** Clean up sandbox containers. */
+    cleanupSandbox() {
+        this.sandbox?.cleanupAll();
+    }
+    /** Extract remaining facts from all active sessions (call before shutdown). */
+    async flushMemories() {
+        if (this.memoryExtractor) {
+            await this.memoryExtractor.flushAll(this.sessions);
+        }
+        this.workerCoordinator.clearAllTimers();
+        this.unsubTeamChange?.();
+        // Shut down all HTTP MCP servers
+        const cleanups = [...this.mcpCleanups.values()];
+        this.mcpCleanups.clear();
+        await Promise.allSettled(cleanups.map((fn) => fn()));
+    }
+    async getOrCreateSession(key) {
+        const existing = this.sessions.get(key);
+        if (existing)
+            return existing;
+        this.newSessionPending = true;
+        const session = await this.sessionStore.load(key) ?? new Session(key);
+        const state = this.sessions.getOrCreate(key, session);
+        // Seed token estimate from restored messages so compaction skip check is accurate
+        if (session.messageCount > 0) {
+            state.estimatedMsgTokens = estimateTokens(session.getMessages());
+        }
+        return state;
+    }
+    /** Build tools, adapt for MCP providers, and run the inference loop. */
+    async buildAdaptAndRun(opts) {
+        const label = this.sessionLabel(opts.sessionKey);
+        const deps = this.buildRunToolsDeps(opts.teamScopedRegistry, `${opts.runProvider}:${opts.runModelId}`);
+        let tools = buildRunTools(deps, opts.sessionKey, opts.activeIntegrations, opts.channelInfo, opts.effectiveAgentId, opts.taskTeamId, opts.scheduleTeamId, label);
+        // Clean up any previous MCP server, then adapt for MCP-based providers
+        const prevCleanup = this.mcpCleanups.get(opts.sessionKey);
+        if (prevCleanup) {
+            this.mcpCleanups.delete(opts.sessionKey);
+            await prevCleanup();
+        }
+        const adapted = await adaptTools(opts.runProvider, opts.runModelId, opts.runModel, tools, {
+            sandboxEnabled: !!this.sandbox,
+        });
+        if (adapted.cleanup)
+            this.mcpCleanups.set(opts.sessionKey, adapted.cleanup);
+        tools = adapted.tools;
+        return this.runLoopWithRetry(opts.session, opts.system, tools, opts.sessionKey, adapted.model, opts.contextWindow, opts.maxSteps);
+    }
+    /** Build the RunToolsDeps from current agent state (agentRegistry filled per-call). */
+    buildRunToolsDeps(agentRegistry, effectiveModel) {
+        return {
+            baseTools: this.tools,
+            config: this.config,
+            memoryStore: this.memoryStore,
+            embeddingProvider: this.embeddingProvider,
+            memoryMaxResults: this.memoryMaxResults,
+            sandbox: this.sandbox,
+            skillManager: this.skillManager,
+            integrationRegistry: this.integrationRegistry,
+            scheduleStore: this.scheduleStore,
+            taskStore: this.taskStore,
+            teamStore: this.teamStore,
+            desktopAdapter: this.desktopAdapter,
+            browserManager: this.browserManager,
+            effectiveModel: effectiveModel ?? `${this.config.model.provider}:${this.config.model.id}`,
+            agentRegistry,
+            delegationStore: this.delegationStore,
+            channelStore: this.channelStore,
+            channelManager: this.channelManager,
+            sessionStore: this.sessionStore,
+            modelId: this.modelId,
+            onWorkerComplete: this.workerCoordinator.onWorkerComplete.bind(this.workerCoordinator),
+        };
+    }
+    /** Return all tool names available in the current config (for UI discovery). */
+    getToolNames() {
+        const deps = this.buildRunToolsDeps(null);
+        const tools = buildRunTools(deps, "__discovery__", new Set());
+        return Object.keys(tools);
+    }
+    /** Run the loop with compaction retries on context overflow. */
+    async runLoopWithRetry(session, system, tools, sessionKey, model, contextWindow, maxSteps) {
+        const effectiveModel = model ?? this.model;
+        const effectiveContextWindow = contextWindow ?? this.modelDef.contextWindow;
+        const effectiveMaxSteps = maxSteps && maxSteps > 0 ? maxSteps : this.config.model.maxSteps;
+        for (let attempt = 1; attempt <= MAX_COMPACTION_RETRIES + 1; attempt++) {
+            try {
+                const { text } = await runLoop({
+                    model: effectiveModel,
+                    system,
+                    messages: session.getMessages(),
+                    tools,
+                    sessionKey,
+                    sessionLabel: this.sessionLabel(sessionKey),
+                    maxSteps: effectiveMaxSteps,
+                });
+                return text;
+            }
+            catch (err) {
+                if (!isContextOverflowError(err) || attempt > MAX_COMPACTION_RETRIES) {
+                    throw err;
+                }
+                logger.warn(`Context overflow on attempt ${attempt}/${MAX_COMPACTION_RETRIES}, forcing compaction`);
+                const compacted = await session.compact(effectiveModel, effectiveContextWindow, system);
+                if (!compacted) {
+                    logger.warn("Compaction had no effect, emergency truncating to last 10 messages");
+                    session.truncate(10);
+                }
+            }
+        }
+        throw new Error("Unreachable: all compaction retries exhausted");
+    }
+    /** (Re)build team registry from TeamStore (or skip if no store). */
+    rebuildTeamRegistry() {
+        if (!this.teamStore) {
+            this.teamRegistry = null;
+            return;
+        }
+        const teamConfigs = this.teamStore.toTeamConfigs();
+        if (teamConfigs.length === 0) {
+            this.teamRegistry = null;
+            return;
+        }
+        const hasMultipleTeams = teamConfigs.length > 1;
+        const hasWorkers = teamConfigs.some((t) => t.workers.length > 0);
+        if (hasMultipleTeams || hasWorkers) {
+            this.teamRegistry = new TeamRegistry(teamConfigs, {
+                memoryStore: this.memoryStore,
+                embeddingProvider: this.embeddingProvider,
+                baseTools: this.tools,
+                config: this.config,
+            });
+        }
+        else {
+            this.teamRegistry = null;
+        }
+    }
+    /** Reload config from disk so API key / model changes take effect immediately. */
+    async reloadConfig() {
+        // Skip reload if config file hasn't changed (stat is ~microseconds vs full parse + rebuild)
+        const mtime = this.configStore.mtime();
+        if (mtime !== null && mtime === this.lastConfigMtime)
+            return;
+        this.lastConfigMtime = mtime;
+        logger.info(`Reloading config`);
+        injectSecretsIntoEnv(this.configStore);
+        const fresh = loadConfig(this.configStore);
+        this.model = getModel(fresh.model.provider, fresh.model.id);
+        this.modelId = fresh.model.id;
+        this.modelDef = resolveModelDef(fresh.model.id, fresh.model.contextWindow);
+        this.identity = fresh.identity;
+        this.language = fresh.language;
+        this.memoryMaxResults = fresh.memory.maxResults;
+        this.config = fresh;
+        // Update memory extractor model
+        this.memoryExtractor?.setModel(this.model);
+        // Push browser config changes so next launch uses fresh values
+        await this.browserManager?.updateConfig({
+            headless: fresh.browserHeadless,
+            userAgent: fresh.browserUserAgent || undefined,
+        });
+        // Hot-reload channels in background (non-blocking)
+        this.reconcileChannels(fresh).catch((err) => {
+            logger.error(`Channel reconcile failed: ${err instanceof Error ? err.message : err}`);
+        });
+    }
+    /**
+     * Build channel specs from config and reconcile with ChannelManager.
+     * Handlers use dynamic orchestrator lookup (reads this.config at call time)
+     * so orchestrator-only changes don't require a channel restart.
+     */
+    async reconcileChannels(config) {
+        if (!this.channelManager)
+            return;
+        const specs = buildChannelSpecs(config, {
+            onMessage: (msg, ch) => this.handleMessage(msg, ch),
+            onClear: (channelType, channelId, teamId) => this.clearSession(buildSessionKey(teamId ?? DEFAULT_TEAM_ID, channelType, channelId)),
+            listTeams: () => this.getTeams().map((t) => ({ id: t.id, name: t.name })),
+            connectedChannels: this.connectedChannels,
+            getChannelTableConfig: (channel) => this.config.channels[channel]
+                ?.markdown?.tables,
+        });
+        await this.channelManager.reconcile(specs);
+    }
+    /** Resolve a human-readable team label for logs/console (name preferred, falls back to ID). */
+    teamLabel(teamId) {
+        const team = this.teamStore?.getTeamById(teamId);
+        return team?.name ?? teamId;
+    }
+    /** Build a human-readable session label for logs: replaces team UUID with team name. */
+    sessionLabel(sessionKey) {
+        const colonIdx = sessionKey.indexOf(":");
+        if (colonIdx <= 0)
+            return sessionKey;
+        const teamId = sessionKey.slice(0, colonIdx);
+        return this.teamLabel(teamId) + sessionKey.slice(colonIdx);
+    }
+    /** Enrich session index entry with team/agent name metadata for UI display. */
+    enrichSessionMetadata(sessionKey, teamId) {
+        const meta = { teamId };
+        if (this.teamStore) {
+            const team = this.teamStore.getTeamById(teamId);
+            if (team)
+                meta.teamName = team.name;
+            const parsed = parseSessionKey(sessionKey);
+            meta.channelType = parsed.channelType;
+            if (parsed.isWorker && parsed.agentName) {
+                meta.agentName = parsed.agentName;
+                const agent = this.teamStore.getAgentByName(teamId, parsed.agentName);
+                if (agent)
+                    meta.agentId = agent.id;
+            }
+        }
+        this.sessionStore.updateMetadata(sessionKey, meta);
+    }
+    async main(sessionKey, text) {
+        await this.reloadConfig();
+        // Rebuild team registry when teams were modified or a new session started
+        if (this.teamRegistryDirty || this.newSessionPending) {
+            this.teamRegistryDirty = false;
+            this.newSessionPending = false;
+            this.rebuildTeamRegistry();
+            if (this.teamRegistry) {
+                if (!this.delegationStore) {
+                    this.delegationStore = await DelegationStore.create(MEMORY_DB_PATH);
+                }
+                if (!this.channelStore) {
+                    this.channelStore = await ChannelStore.create(MEMORY_DB_PATH);
+                }
+            }
+        }
+        // Session is guaranteed to exist (created eagerly in handleMessage/handleGatewayMessage)
+        const state = this.sessions.get(sessionKey);
+        if (!state) {
+            logger.warn(`[${this.sessionLabel(sessionKey)}] Session was cleared mid-queue, skipping`);
+            return "";
+        }
+        const { session } = state;
+        // Resolve per-session orchestrator via team registry
+        const effectiveAgentId = state.agentId;
+        const effectiveTeamId = state.teamId ?? DEFAULT_TEAM_ID;
+        let runModel = this.model;
+        let runModelDef = this.modelDef;
+        let runIdentity = this.identity;
+        let runModelId = this.modelId;
+        let runProvider = this.config.model.provider;
+        let runMaxSteps = 0; // 0 = inherit global default
+        let teamScopedRegistry = null;
+        if (this.teamRegistry) {
+            // Resolve by team ID (source of truth from session key), not orchestrator ID
+            const registry = this.teamRegistry.getTeamRegistry(effectiveTeamId);
+            if (registry) {
+                teamScopedRegistry = registry;
+                const resolved = registry.resolveOrchestrator();
+                runModel = resolved.model;
+                runModelDef = resolved.modelDef;
+                runIdentity = resolved.agentConfig.identity;
+                const parsed = parseModel(resolved.agentConfig.model);
+                runModelId = parsed.modelId;
+                runProvider = parsed.provider;
+                runMaxSteps = resolved.agentConfig.maxSteps;
+                logger.info(`[${this.sessionLabel(sessionKey)}] Using team "${this.teamLabel(effectiveTeamId)}" orchestrator "${resolved.agentConfig.id}"`);
+            }
+        }
+        // Track delegation depth via worker coordinator
+        this.workerCoordinator.trackDelegationDepth(sessionKey, text);
+        // Detect scheduler session from key pattern
+        const isSchedulerSession = sessionKey.endsWith(SCHEDULER_SESSION_SUFFIX);
+        const isScheduledTask = text.startsWith(SCHEDULED_TASK_PREFIX);
+        // For scheduled tasks: compact previous runs before appending
+        if (isSchedulerSession && isScheduledTask) {
+            compactSchedulerRuns(session);
+        }
+        session.append({ role: "user", content: text });
+        state.estimatedMsgTokens += estimateStringTokens(text);
+        // Re-discover integrations at the start of each new session.
+        if (!state.integrations) {
+            await this.integrationRegistry.refresh(this.configStore, INTEGRATIONS_DIR);
+            state.integrations = new Set();
+        }
+        // For scheduled tasks, merge in the scheduled integrations then consume them
+        let activeIntegrations = state.integrations;
+        if (isScheduledTask && state.scheduledIntegrations) {
+            const merged = new Set(activeIntegrations);
+            for (const name of state.scheduledIntegrations) {
+                if (this.integrationRegistry.has(name))
+                    merged.add(name);
+            }
+            activeIntegrations = merged;
+            state.scheduledIntegrations = undefined;
+        }
+        // Build system prompt first so compaction can account for its token cost
+        const system = buildSystemPrompt({
+            identity: runIdentity,
+            modelId: runModelId,
+            language: this.language,
+            hasMemory: this.memoryStore !== null,
+            bashMode: this.config.bash.security,
+            bashSafeBins: [...DEFAULT_SAFE_BINS, ...this.config.bash.safeBins],
+            hasDesktop: this.config.desktop.enabled,
+            skillListing: this.skillManager.systemPrompt,
+            integrationListing: this.integrationRegistry.buildListing(activeIntegrations),
+            activeIntegrationPrompts: this.integrationRegistry.getPromptsFor(activeIntegrations),
+            hasScheduler: this.scheduleStore !== null,
+            scheduledTask: isScheduledTask,
+            schedulerSession: isSchedulerSession,
+            hasTTS: this.config.tts.enabled,
+            channelType: state.channelType,
+            delegationWorkers: teamScopedRegistry
+                ? teamScopedRegistry.delegatableWorkers().map((name) => {
+                    const w = teamScopedRegistry.getWorker(name);
+                    return { name, identity: w?.identity ?? "" };
+                })
+                : undefined,
+        });
+        // Skip compaction when clearly under budget (avoids O(n) token scan on every message)
+        const sysTokens = estimateStringTokens(system);
+        if (state.estimatedMsgTokens + sysTokens > runModelDef.contextWindow * COMPACTION_SKIP_THRESHOLD) {
+            const compacted = await session.compact(runModel, runModelDef.contextWindow, system);
+            if (compacted)
+                state.estimatedMsgTokens = estimateTokens(session.getMessages());
+        }
+        // Snapshot active integrations before the run to detect mid-run changes
+        const activeBefore = new Set(activeIntegrations);
+        // Build per-run tools, adapt for MCP providers, and execute the loop
+        // Task tools: default team sees all tasks; non-default teams are scoped to their own tasks
+        // Schedule tools: always pass effectiveTeamId so schedules work for all teams
+        const runOpts = {
+            session,
+            sessionKey,
+            system,
+            teamScopedRegistry,
+            activeIntegrations,
+            channelInfo: { channelType: state.channelType ?? "unknown", channelId: state.channelId ?? sessionKey },
+            effectiveAgentId,
+            taskTeamId: effectiveTeamId !== DEFAULT_TEAM_ID ? effectiveTeamId : undefined,
+            scheduleTeamId: effectiveTeamId,
+            runProvider,
+            runModelId,
+            runModel,
+            contextWindow: runModelDef.contextWindow,
+            maxSteps: runMaxSteps,
+        };
+        let reply = await this.buildAdaptAndRun(runOpts);
+        // If integrations were enabled/disabled during the run, re-run with updated tools
+        if (!setsEqual(activeIntegrations, activeBefore)) {
+            logger.info(`[${this.sessionLabel(sessionKey)}] Integrations changed mid-run, re-running with updated tools`);
+            reply = await this.buildAdaptAndRun(runOpts);
+        }
+        session.append({ role: "assistant", content: reply });
+        // Refresh running token estimate (used by compaction skip check on next message)
+        const msgTokens = estimateTokens(session.getMessages());
+        state.estimatedMsgTokens = msgTokens;
+        logger.info(`[${this.sessionLabel(sessionKey)}] Context: ~${msgTokens + sysTokens} tokens (system: ${sysTokens}, messages: ${msgTokens}, budget: ${runModelDef.contextWindow})`);
+        await this.sessionStore.save(session);
+        // Enrich session metadata with team/agent names for UI display
+        this.enrichSessionMetadata(sessionKey, effectiveTeamId);
+        // Track and maybe extract facts via memory extractor
+        if (this.memoryExtractor) {
+            const memoryTeamId = effectiveTeamId !== DEFAULT_TEAM_ID ? effectiveTeamId : undefined;
+            this.memoryExtractor.trackAndMaybeExtract(sessionKey, this.sessions, session.getMessages(), memoryTeamId);
+        }
+        return reply;
+    }
+}