@fonz/tgcc 0.6.17 → 0.6.19

package/dist/bridge.js

@@ -6,13 +6,16 @@ import pino from 'pino';
 import { resolveUserConfig, resolveRepoPath, updateConfig, isValidRepoName, findRepoOwner } from './config.js';
 import { CCProcess, generateMcpConfig } from './cc-process.js';
 import { createTextMessage, createImageMessage, createDocumentMessage, } from './cc-protocol.js';
-import { StreamAccumulator, SubAgentTracker, escapeHtml } from './streaming.js';
+import { StreamAccumulator, SubAgentTracker, escapeHtml, formatSystemMessage } from './streaming.js';
 import { TelegramBot } from './telegram.js';
 import { InlineKeyboard } from 'grammy';
 import { McpBridgeServer } from './mcp-bridge.js';
 import { SessionStore, discoverCCSessions, } from './session.js';
 import { CtlServer, } from './ctl-server.js';
 import { ProcessRegistry } from './process-registry.js';
+import { EventBuffer } from './event-buffer.js';
+import { HighSignalDetector } from './high-signal.js';
+import { randomUUID } from 'node:crypto';
 // ── Message Batcher ──
 class MessageBatcher {
     pending = [];
@@ -100,11 +103,18 @@ export class Bridge extends EventEmitter {
     config;
     agents = new Map();
     processRegistry = new ProcessRegistry();
-    sessionModelOverrides = new Map(); // "agentId:userId" → model (from /model cmd, not persisted)
     mcpServer;
     ctlServer;
     sessionStore;
     logger;
+    // High-signal event detection
+    highSignalDetector;
+    // Supervisor protocol
+    supervisorWrite = null;
+    supervisorAgentId = null;
+    supervisorSubscriptions = new Set(); // "agentId:sessionId" or "agentId:*"
+    suppressExitForProcess = new Set(); // sessionIds where takeover suppresses exit event
+    supervisorPendingRequests = new Map();
     constructor(config, logger) {
         super();
         this.config = config;
@@ -112,6 +122,18 @@ export class Bridge extends EventEmitter {
         this.sessionStore = new SessionStore(config.global.stateFile, this.logger);
         this.mcpServer = new McpBridgeServer((req) => this.handleMcpToolRequest(req), this.logger);
         this.ctlServer = new CtlServer(this, this.logger);
+        this.highSignalDetector = new HighSignalDetector({
+            emitSupervisorEvent: (event) => {
+                if (this.isSupervisorSubscribed(event.agentId, this.agents.get(event.agentId)?.ccProcess?.sessionId ?? null)) {
+                    this.sendToSupervisor(event);
+                }
+            },
+            pushEventBuffer: (agentId, line) => {
+                const agent = this.agents.get(agentId);
+                if (agent)
+                    agent.eventBuffer.push(line);
+            },
+        });
     }
     // ── Startup ──
     async start() {
@@ -120,20 +142,37 @@ export class Bridge extends EventEmitter {
             await this.startAgent(agentId, agentConfig);
         }
         this.logger.info({ agents: Object.keys(this.config.agents) }, 'Bridge started');
+        // Emit bridge_started event to supervisor
+        this.sendToSupervisor({
+            type: 'event',
+            event: 'bridge_started',
+            agents: Object.keys(this.config.agents),
+            uptime: 0,
+        });
     }
     async startAgent(agentId, agentConfig) {
         this.logger.info({ agentId }, 'Starting agent');
         const tgBot = new TelegramBot(agentId, agentConfig, this.config.global.mediaDir, (msg) => this.handleTelegramMessage(agentId, msg), (cmd) => this.handleSlashCommand(agentId, cmd), this.logger, (query) => this.handleCallbackQuery(agentId, query));
+        // Resolve initial repo and model from config + persisted state
+        const agentState = this.sessionStore.getAgent(agentId);
+        const configDefaults = agentConfig.defaults;
         const instance = {
             id: agentId,
             config: agentConfig,
             tgBot,
-            processes: new Map(),
-            accumulators: new Map(),
-            subAgentTrackers: new Map(),
-            batchers: new Map(),
+            ephemeral: false,
+            repo: agentState.repo || configDefaults.repo,
+            model: agentState.model || configDefaults.model,
+            ccProcess: null,
+            accumulator: null,
+            subAgentTracker: null,
+            batcher: null,
             pendingPermissions: new Map(),
-            typingIntervals: new Map(),
+            typingInterval: null,
+            typingChatId: null,
+            pendingSessionId: null,
+            destroyTimer: null,
+            eventBuffer: new EventBuffer(),
         };
         this.agents.set(agentId, instance);
         await tgBot.start();
@@ -174,67 +213,62 @@ export class Bridge extends EventEmitter {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
-        this.logger.info({ agentId }, 'Stopping agent');
-        // Stop bot
-        await agent.tgBot.stop();
-        // Unsubscribe all clients for this agent from the registry
-        for (const [userId] of agent.processes) {
-            const chatId = Number(userId); // In TG, private chat ID === user ID
-            const clientRef = { agentId, userId, chatId };
-            this.processRegistry.unsubscribe(clientRef);
+        this.logger.info({ agentId, ephemeral: agent.ephemeral }, 'Stopping agent');
+        // Stop bot (persistent agents only)
+        if (agent.tgBot)
+            await agent.tgBot.stop();
+        // Clear auto-destroy timer (ephemeral agents)
+        if (agent.destroyTimer) {
+            clearTimeout(agent.destroyTimer);
+            agent.destroyTimer = null;
         }
-        // Kill all CC processes and wait for them to exit
-        const processExitPromises = [];
-        for (const [, proc] of agent.processes) {
-            // Create a promise that resolves when the process exits or times out
+        // Kill CC process if active
+        if (agent.ccProcess) {
+            const proc = agent.ccProcess;
             const exitPromise = new Promise((resolve) => {
                 const onExit = () => {
                     proc.off('exit', onExit);
                     resolve();
                 };
                 proc.on('exit', onExit);
-                // Timeout after 3 seconds if process doesn't exit
                 const timeoutId = setTimeout(() => {
                     proc.off('exit', onExit);
                     resolve();
                 }, 3000);
-                // Clear timeout if process exits before timeout
                 proc.on('exit', () => clearTimeout(timeoutId));
             });
-            processExitPromises.push(exitPromise);
             proc.destroy();
+            await exitPromise;
+            // Unsubscribe from registry
+            const clientRef = { agentId, userId: agentId, chatId: 0 };
+            this.processRegistry.unsubscribe(clientRef);
         }
-        // Wait for all processes to exit (or timeout)
-        await Promise.all(processExitPromises);
-        // Cancel batchers
-        for (const [, batcher] of agent.batchers) {
-            batcher.cancel();
-            batcher.destroy();
-        }
-        // Close MCP sockets
-        for (const userId of agent.processes.keys()) {
-            const socketPath = join(this.config.global.socketDir, `${agentId}-${userId}.sock`);
-            this.mcpServer.close(socketPath);
+        // Cancel batcher
+        if (agent.batcher) {
+            agent.batcher.cancel();
+            agent.batcher.destroy();
         }
-        // Clean up accumulators (clears edit timers)
-        for (const [, acc] of agent.accumulators) {
-            acc.finalize();
+        // Close MCP socket
+        const socketPath = join(this.config.global.socketDir, `${agentId}.sock`);
+        this.mcpServer.close(socketPath);
+        // Clean up accumulator
+        if (agent.accumulator) {
+            agent.accumulator.finalize();
+            agent.accumulator = null;
         }
-        agent.accumulators.clear();
-        // Clean up sub-agent trackers (stops mailbox watchers)
-        for (const [, tracker] of agent.subAgentTrackers) {
-            tracker.reset();
+        // Clean up sub-agent tracker
+        if (agent.subAgentTracker) {
+            agent.subAgentTracker.reset();
+            agent.subAgentTracker = null;
         }
-        agent.subAgentTrackers.clear();
-        // Clear remaining maps
-        // Clear typing indicators
-        for (const [, interval] of agent.typingIntervals) {
-            clearInterval(interval);
+        // Clear typing indicator
+        if (agent.typingInterval) {
+            clearInterval(agent.typingInterval);
+            agent.typingInterval = null;
         }
-        agent.typingIntervals.clear();
         agent.pendingPermissions.clear();
-        agent.processes.clear();
-        agent.batchers.clear();
+        agent.ccProcess = null;
+        agent.batcher = null;
         // Close control socket
         const ctlSocketPath = join('/tmp/tgcc/ctl', `${agentId}.sock`);
         this.ctlServer.close(ctlSocketPath);
@@ -246,19 +280,18 @@ export class Bridge extends EventEmitter {
         if (!agent)
             return;
         this.logger.debug({ agentId, userId: msg.userId, type: msg.type }, 'TG message received');
-        // Ensure batcher exists
-        if (!agent.batchers.has(msg.userId)) {
-            agent.batchers.set(msg.userId, new MessageBatcher(2000, (combined) => {
-                this.sendToCC(agentId, msg.userId, msg.chatId, combined);
-            }));
+        // Ensure batcher exists (one per agent, not per user)
+        if (!agent.batcher) {
+            agent.batcher = new MessageBatcher(2000, (combined) => {
+                this.sendToCC(agentId, combined, { chatId: msg.chatId, spawnSource: 'telegram' });
+            });
         }
         // Prepare text with reply context
         let text = msg.text;
         if (msg.replyToText) {
             text = `[Replying to: '${msg.replyToText}']\n\n${text}`;
         }
-        const batcher = agent.batchers.get(msg.userId);
-        batcher.add({
+        agent.batcher.add({
             text,
             imageBase64: msg.imageBase64,
             imageMediaType: msg.imageMediaType,
@@ -266,7 +299,7 @@ export class Bridge extends EventEmitter {
             fileName: msg.fileName,
         });
     }
-    sendToCC(agentId, userId, chatId, data) {
+    sendToCC(agentId, data, source) {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
@@ -281,378 +314,318 @@ export class Bridge extends EventEmitter {
         else {
             ccMsg = createTextMessage(data.text);
         }
-        const clientRef = { agentId, userId, chatId };
-        // Check if this client already has a process via the registry
-        let existingEntry = this.processRegistry.findByClient(clientRef);
-        let proc = existingEntry?.ccProcess;
+        let proc = agent.ccProcess;
         if (proc?.takenOver) {
             // Session was taken over externally — discard old process
-            const entry = this.processRegistry.findByClient(clientRef);
-            this.processRegistry.destroy(entry.repo, entry.sessionId);
-            agent.processes.delete(userId);
-            proc = undefined;
-            existingEntry = null;
-        }
-        // Staleness check: detect if session was modified by another client
-        // Skip if background sub-agents are running — their results grow the JSONL
-        // and would cause false-positive staleness detection
-        const accKey2 = `${userId}:${chatId}`;
-        const activeTracker = agent.subAgentTrackers.get(accKey2);
-        const hasBackgroundAgents = activeTracker?.hasDispatchedAgents ?? false;
-        if (proc && proc.state !== 'idle' && !hasBackgroundAgents) {
-            const staleInfo = this.checkSessionStaleness(agentId, userId);
-            if (staleInfo) {
-                // Session was modified externally — silently reconnect for roaming support
-                this.logger.info({ agentId, userId }, 'Session modified externally — reconnecting for roaming');
-                const entry = this.processRegistry.findByClient(clientRef);
-                this.processRegistry.unsubscribe(clientRef);
-                agent.processes.delete(userId);
-                proc = undefined;
-                existingEntry = null;
-            }
+            const entry = this.processRegistry.findByProcess(proc);
+            if (entry)
+                this.processRegistry.destroy(entry.repo, entry.sessionId);
+            agent.ccProcess = null;
+            proc = null;
         }
         if (!proc || proc.state === 'idle') {
-            // Warn if no repo is configured — CC would run in ~ which is likely not intended
-            const userState2 = this.sessionStore.getUser(agentId, userId);
-            const resolvedRepo = userState2.repo || resolveUserConfig(agent.config, userId).repo;
-            if (resolvedRepo === homedir()) {
-                agent.tgBot.sendText(chatId, '<blockquote>⚠️ No project selected. Use /repo to pick one, or CC will run in your home directory.</blockquote>', 'HTML').catch(err => this.logger.error({ err }, 'Failed to send no-repo warning'));
-            }
-            // Check if another client already has a process for this repo+session
-            const sessionId = userState2.currentSessionId;
-            if (sessionId && resolvedRepo) {
-                const sharedEntry = this.processRegistry.get(resolvedRepo, sessionId);
-                if (sharedEntry && sharedEntry.ccProcess.state !== 'idle') {
-                    // Attach to existing process as subscriber
-                    this.processRegistry.subscribe(resolvedRepo, sessionId, clientRef);
-                    proc = sharedEntry.ccProcess;
-                    agent.processes.set(userId, proc);
-                    // Notify the user they've attached
-                    agent.tgBot.sendText(chatId, '<blockquote>📎 Attached to existing session process.</blockquote>', 'HTML').catch(err => this.logger.error({ err }, 'Failed to send attach notification'));
-                    // Show typing indicator and forward message
-                    this.startTypingIndicator(agent, userId, chatId);
-                    proc.sendMessage(ccMsg);
-                    return;
+            // Warn if no repo is configured
+            if (agent.repo === homedir()) {
+                const chatId = source?.chatId;
+                if (chatId && agent.tgBot) {
+                    agent.tgBot.sendText(chatId, formatSystemMessage('status', 'No project selected. Use /repo to pick one, or CC will run in your home directory.'), 'HTML', true).catch(err => this.logger.error({ err }, 'Failed to send no-repo warning'));
                 }
             }
-            // Save first message text as pending session title
-            if (data.text) {
+            proc = this.spawnCCProcess(agentId);
+            agent.ccProcess = proc;
+            // Emit cc_spawned event to supervisor
+            const spawnSource = source?.spawnSource ?? 'telegram';
+            this.logger.info({ agentId, sessionId: proc.sessionId, source: spawnSource }, 'CC process spawned');
+            if (this.isSupervisorSubscribed(agentId, proc.sessionId)) {
+                this.sendToSupervisor({
+                    type: 'event',
+                    event: 'cc_spawned',
+                    agentId,
+                    sessionId: proc.sessionId,
+                    source: spawnSource,
+                });
             }
-            proc = this.spawnCCProcess(agentId, userId, chatId);
-            agent.processes.set(userId, proc);
         }
-        // Show typing indicator (repeated every 4s — TG typing expires after ~5s)
-        this.startTypingIndicator(agent, userId, chatId);
+        // Show typing indicator
+        if (source?.chatId) {
+            this.startTypingIndicator(agent, source.chatId);
+        }
+        // Log user message in event buffer
+        agent.eventBuffer.push({ ts: Date.now(), type: 'user', text: data.text });
         proc.sendMessage(ccMsg);
     }
-    /** Check if the session JSONL was modified externally since we last tracked it. */
-    checkSessionStaleness(_agentId, _userId) {
-        // With shared process registry, staleness is handled by the registry itself
-        return null;
-    }
     // ── Process cleanup helper ──
     /**
-     * Disconnect a client from its CC process.
-     * If other subscribers remain, the process stays alive.
-     * If this was the last subscriber, the process is destroyed.
+     * Kill the agent's CC process and clean up.
      */
-    disconnectClient(agentId, userId, chatId) {
+    killAgentProcess(agentId) {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
-        const clientRef = { agentId, userId, chatId };
-        const proc = agent.processes.get(userId);
-        const destroyed = this.processRegistry.unsubscribe(clientRef);
-        if (!destroyed && proc) {
-            // Other subscribers still attached — just remove from this agent's map
+        const proc = agent.ccProcess;
+        if (proc) {
+            const entry = this.processRegistry.findByProcess(proc);
+            if (entry) {
+                this.processRegistry.destroy(entry.repo, entry.sessionId);
+            }
+            else {
+                proc.destroy();
+            }
         }
-        else if (proc && !destroyed) {
-            // Not in registry but has a process — destroy directly (legacy path)
-            proc.destroy();
+        agent.ccProcess = null;
+        // Clean up accumulator & tracker
+        if (agent.accumulator) {
+            agent.accumulator.finalize();
+            agent.accumulator = null;
+        }
+        if (agent.subAgentTracker) {
+            agent.subAgentTracker.reset();
+            agent.subAgentTracker = null;
         }
-        agent.processes.delete(userId);
+        this.stopTypingIndicator(agent);
     }
     // ── Typing indicator management ──
-    startTypingIndicator(agent, userId, chatId) {
-        const key = `${userId}:${chatId}`;
+    /** Get the primary TG chat ID for an agent (first allowed user). */
+    getAgentChatId(agent) {
+        // If we have a typing chatId, use that (most recent active chat)
+        if (agent.typingChatId)
+            return agent.typingChatId;
+        // Fall back to first allowed user
+        const firstUser = agent.config.allowedUsers[0];
+        return firstUser ? Number(firstUser) : null;
+    }
+    startTypingIndicator(agent, chatId) {
         // Don't create duplicate intervals
-        if (agent.typingIntervals.has(key))
+        if (agent.typingInterval)
+            return;
+        if (!agent.tgBot)
             return;
+        agent.typingChatId = chatId;
         // Send immediately, then repeat every 4s (TG typing badge lasts ~5s)
         agent.tgBot.sendTyping(chatId);
         const interval = setInterval(() => {
-            agent.tgBot.sendTyping(chatId);
+            if (agent.typingChatId)
+                agent.tgBot?.sendTyping(agent.typingChatId);
         }, 4_000);
-        agent.typingIntervals.set(key, interval);
+        agent.typingInterval = interval;
     }
-    stopTypingIndicator(agent, userId, chatId) {
-        const key = `${userId}:${chatId}`;
-        const interval = agent.typingIntervals.get(key);
-        if (interval) {
-            clearInterval(interval);
-            agent.typingIntervals.delete(key);
+    stopTypingIndicator(agent) {
+        if (agent.typingInterval) {
+            clearInterval(agent.typingInterval);
+            agent.typingInterval = null;
+            agent.typingChatId = null;
         }
     }
-    spawnCCProcess(agentId, userId, chatId) {
+    spawnCCProcess(agentId) {
         const agent = this.agents.get(agentId);
-        const userConfig = resolveUserConfig(agent.config, userId);
-        // Check session store for repo/permission overrides
-        const userState = this.sessionStore.getUser(agentId, userId);
-        if (userState.repo)
-            userConfig.repo = userState.repo;
-        // Model priority: /model override > running process > session JSONL > agent config default
-        const modelOverride = this.sessionModelOverrides.get(`${agentId}:${userId}`);
-        if (modelOverride) {
-            userConfig.model = modelOverride;
-            // Don't delete yet — cleared when CC writes first assistant message
+        const agentState = this.sessionStore.getAgent(agentId);
+        // Build userConfig from agent-level state
+        const userConfig = resolveUserConfig(agent.config, agent.config.allowedUsers[0] || 'default');
+        userConfig.repo = agent.repo;
+        userConfig.model = agent.model;
+        if (agentState.permissionMode) {
+            userConfig.permissionMode = agentState.permissionMode;
         }
-        else {
-            const currentSessionId = userState.currentSessionId;
-            if (currentSessionId && userConfig.repo) {
-                const registryEntry = this.processRegistry.get(userConfig.repo, currentSessionId);
-                if (registryEntry?.model) {
-                    userConfig.model = registryEntry.model;
-                }
-                else {
-                    const sessions = discoverCCSessions(userConfig.repo, 20);
-                    const sessionInfo = sessions.find(s => s.id === currentSessionId);
-                    if (sessionInfo?.model) {
-                        userConfig.model = sessionInfo.model;
-                    }
-                }
-            }
-        }
-        if (userState.permissionMode) {
-            userConfig.permissionMode = userState.permissionMode;
-        }
-        // Generate MCP config
+        // Determine session ID: pending from /resume, or let CC create new
+        const sessionId = agent.pendingSessionId ?? undefined;
+        agent.pendingSessionId = null; // consumed
+        // Generate MCP config (use agentId as the "userId" for socket naming)
         const mcpServerPath = resolveMcpServerPath();
-        const mcpConfigPath = generateMcpConfig(agentId, userId, this.config.global.socketDir, mcpServerPath);
-        // Start MCP socket listener for this agent-user pair
-        const socketPath = join(this.config.global.socketDir, `${agentId}-${userId}.sock`);
+        const mcpConfigPath = generateMcpConfig(agentId, agentId, // single socket per agent
+        this.config.global.socketDir, mcpServerPath);
+        // Start MCP socket listener for this agent
+        const socketPath = join(this.config.global.socketDir, `${agentId}-${agentId}.sock`);
         this.mcpServer.listen(socketPath);
         const proc = new CCProcess({
             agentId,
-            userId,
+            userId: agentId, // agent is the sole "user"
             ccBinaryPath: this.config.global.ccBinaryPath,
             userConfig,
             mcpConfigPath,
-            sessionId: userState.currentSessionId ?? undefined,
-            continueSession: !!userState.currentSessionId,
+            sessionId,
+            continueSession: !!sessionId,
             logger: this.logger,
         });
         // Register in the process registry
-        const ownerRef = { agentId, userId, chatId };
-        // We'll register once we know the sessionId (on init), but we need a
-        // temporary entry for pre-init event routing. Use a placeholder sessionId
-        // that gets updated on init.
-        const tentativeSessionId = userState.currentSessionId ?? `pending-${Date.now()}`;
+        const ownerRef = { agentId, userId: agentId, chatId: 0 };
+        const tentativeSessionId = sessionId ?? `pending-${Date.now()}`;
         const registryEntry = this.processRegistry.register(userConfig.repo, tentativeSessionId, userConfig.model || 'default', proc, ownerRef);
         // ── Helper: get all subscribers for this process from the registry ──
         const getEntry = () => this.processRegistry.findByProcess(proc);
         // ── Wire up event handlers (broadcast to all subscribers) ──
         proc.on('init', (event) => {
-            this.sessionStore.setCurrentSession(agentId, userId, event.session_id);
+            this.sessionStore.updateLastActivity(agentId);
+            agent.eventBuffer.push({ ts: Date.now(), type: 'system', text: `Session initialized: ${event.session_id}` });
             // Update registry key if session ID changed from tentative
             if (event.session_id !== tentativeSessionId) {
-                // Re-register with the real session ID
                 const entry = getEntry();
                 if (entry) {
-                    // Save subscribers before removing
-                    const savedSubs = [...entry.subscribers.entries()];
                     this.processRegistry.remove(userConfig.repo, tentativeSessionId);
-                    const newEntry = this.processRegistry.register(userConfig.repo, event.session_id, userConfig.model || 'default', proc, ownerRef);
-                    // Restore additional subscribers
-                    for (const [, sub] of savedSubs) {
-                        if (sub.client.agentId !== agentId || sub.client.userId !== userId || sub.client.chatId !== chatId) {
-                            this.processRegistry.subscribe(userConfig.repo, event.session_id, sub.client);
-                            const newSub = this.processRegistry.getSubscriber(newEntry, sub.client);
-                            if (newSub) {
-                                newSub.accumulator = sub.accumulator;
-                                newSub.tracker = sub.tracker;
-                            }
-                        }
-                    }
+                    this.processRegistry.register(userConfig.repo, event.session_id, userConfig.model || 'default', proc, ownerRef);
                 }
             }
         });
         proc.on('stream_event', (event) => {
-            const entry = getEntry();
-            if (!entry) {
-                // Fallback: single subscriber mode (shouldn't happen)
-                this.handleStreamEvent(agentId, userId, chatId, event);
-                return;
-            }
-            for (const sub of this.processRegistry.subscribers(entry)) {
-                this.handleStreamEvent(sub.client.agentId, sub.client.userId, sub.client.chatId, event);
-            }
+            this.highSignalDetector.handleStreamEvent(agentId, event);
+            this.handleStreamEvent(agentId, event);
         });
         proc.on('tool_result', (event) => {
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                const accKey = `${sub.client.userId}:${sub.client.chatId}`;
-                // Resolve tool indicator message with success/failure status
-                const acc2 = subAgent.accumulators.get(accKey);
-                if (acc2 && event.tool_use_id) {
-                    const isError = event.is_error === true;
-                    const contentStr = typeof event.content === 'string' ? event.content : JSON.stringify(event.content);
-                    const errorMsg = isError ? contentStr : undefined;
-                    acc2.resolveToolMessage(event.tool_use_id, isError, errorMsg, contentStr, event.tool_use_result);
-                }
-                const tracker = subAgent.subAgentTrackers.get(accKey);
-                if (!tracker)
-                    continue;
-                const resultText = typeof event.content === 'string' ? event.content : JSON.stringify(event.content);
-                const meta = event.tool_use_result;
-                // Log warning if structured metadata is missing
-                if (!meta && /agent_id:\s*\S+@\S+/.test(resultText)) {
-                    this.logger.warn({ agentId: sub.client.agentId, toolUseId: event.tool_use_id }, 'Spawn detected in text but no structured tool_use_result metadata - skipping');
-                }
-                const spawnMeta = meta?.status === 'teammate_spawned' ? meta : undefined;
-                if (spawnMeta?.status === 'teammate_spawned' && spawnMeta.team_name) {
-                    if (!tracker.currentTeamName) {
-                        this.logger.info({ agentId: sub.client.agentId, teamName: spawnMeta.team_name, agentName: spawnMeta.name, agentType: spawnMeta.agent_type }, 'Spawn detected');
-                        tracker.setTeamName(spawnMeta.team_name);
-                        // Wire the "all agents reported" callback to send follow-up to CC
-                        tracker.setOnAllReported(() => {
-                            if (proc.state === 'active') {
-                                proc.sendMessage(createTextMessage('[System] All background agents have reported back. Please read their results from the mailbox/files and provide a synthesis to the user.'));
-                            }
-                        });
-                    }
-                    // Set agent metadata from structured data or text fallback
-                    if (event.tool_use_id && spawnMeta.name) {
-                        tracker.setAgentMetadata(event.tool_use_id, {
-                            agentName: spawnMeta.name,
-                            agentType: spawnMeta.agent_type,
-                            color: spawnMeta.color,
-                        });
-                    }
-                }
-                // Handle tool result (sets status, edits TG message)
-                if (event.tool_use_id) {
-                    tracker.handleToolResult(event.tool_use_id, resultText);
+            // Log to event buffer
+            const toolName = event.tool_use_result?.name ?? 'unknown';
+            const isToolErr = event.is_error === true;
+            const toolContent = typeof event.content === 'string' ? event.content : JSON.stringify(event.content);
+            const toolSummary = toolContent.length > 200 ? toolContent.slice(0, 200) + '…' : toolContent;
+            agent.eventBuffer.push({ ts: Date.now(), type: 'tool', text: `${isToolErr ? '❌' : '✅'} ${toolName}: ${toolSummary}` });
+            // High-signal detection
+            this.highSignalDetector.handleToolResult(agentId, event.tool_use_id, toolContent, isToolErr, toolName !== 'unknown' ? toolName : undefined);
+            // Resolve tool indicator message with success/failure status
+            const acc = agent.accumulator;
+            if (acc && event.tool_use_id) {
+                const isError = event.is_error === true;
+                const contentStr = typeof event.content === 'string' ? event.content : JSON.stringify(event.content);
+                const errorMsg = isError ? contentStr : undefined;
+                acc.resolveToolMessage(event.tool_use_id, isError, errorMsg, contentStr, event.tool_use_result);
+            }
+            const tracker = agent.subAgentTracker;
+            if (!tracker)
+                return;
+            const resultText = typeof event.content === 'string' ? event.content : JSON.stringify(event.content);
+            const meta = event.tool_use_result;
+            // Log warning if structured metadata is missing
+            if (!meta && /agent_id:\s*\S+@\S+/.test(resultText)) {
+                this.logger.warn({ agentId, toolUseId: event.tool_use_id }, 'Spawn detected in text but no structured tool_use_result metadata - skipping');
+            }
+            const spawnMeta = meta?.status === 'teammate_spawned' ? meta : undefined;
+            if (spawnMeta?.status === 'teammate_spawned' && spawnMeta.team_name) {
+                if (!tracker.currentTeamName) {
+                    this.logger.info({ agentId, teamName: spawnMeta.team_name, agentName: spawnMeta.name, agentType: spawnMeta.agent_type }, 'Spawn detected');
+                    tracker.setTeamName(spawnMeta.team_name);
+                    // Wire the "all agents reported" callback to send follow-up to CC
+                    tracker.setOnAllReported(() => {
+                        if (proc.state === 'active') {
+                            proc.sendMessage(createTextMessage('[System] All background agents have reported back. Please read their results from the mailbox/files and provide a synthesis to the user.'));
+                        }
+                    });
                 }
-                // Start mailbox watch AFTER handleToolResult has set agent names
-                if (tracker.currentTeamName && tracker.hasDispatchedAgents && !tracker.isMailboxWatching) {
-                    tracker.startMailboxWatch();
+                // Set agent metadata from structured data or text fallback
+                if (event.tool_use_id && spawnMeta.name) {
+                    tracker.setAgentMetadata(event.tool_use_id, {
+                        agentName: spawnMeta.name,
+                        agentType: spawnMeta.agent_type,
+                        color: spawnMeta.color,
+                    });
                 }
             }
+            // Handle tool result (sets status, edits TG message)
+            if (event.tool_use_id) {
+                tracker.handleToolResult(event.tool_use_id, resultText);
+            }
+            // Start mailbox watch AFTER handleToolResult has set agent names
+            if (tracker.currentTeamName && tracker.hasDispatchedAgents && !tracker.isMailboxWatching) {
+                tracker.startMailboxWatch();
+            }
         });
-        // System events for background task tracking — broadcast to all subscribers
+        // System events for background task tracking
         proc.on('task_started', (event) => {
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                const accKey = `${sub.client.userId}:${sub.client.chatId}`;
-                const tracker = subAgent.subAgentTrackers.get(accKey);
-                if (tracker) {
-                    tracker.handleTaskStarted(event.tool_use_id, event.description, event.task_type);
-                }
+            if (agent.subAgentTracker) {
+                agent.subAgentTracker.handleTaskStarted(event.tool_use_id, event.description, event.task_type);
+            }
+            // Update the in-turn sub-agent segment in the main bubble
+            if (agent.accumulator && event.tool_use_id) {
+                agent.accumulator.updateSubAgentSegment(event.tool_use_id, 'dispatched', event.description);
             }
         });
         proc.on('task_progress', (event) => {
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                const accKey = `${sub.client.userId}:${sub.client.chatId}`;
-                const tracker = subAgent.subAgentTrackers.get(accKey);
-                if (tracker) {
-                    tracker.handleTaskProgress(event.tool_use_id, event.description, event.last_tool_name);
-                }
+            if (agent.subAgentTracker) {
+                agent.subAgentTracker.handleTaskProgress(event.tool_use_id, event.description, event.last_tool_name);
+            }
+            // Update the in-turn sub-agent segment in the main bubble with progress
+            if (agent.accumulator && event.tool_use_id) {
+                agent.accumulator.appendSubAgentProgress(event.tool_use_id, event.description, event.last_tool_name);
             }
         });
         proc.on('task_completed', (event) => {
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                const accKey = `${sub.client.userId}:${sub.client.chatId}`;
-                const tracker = subAgent.subAgentTrackers.get(accKey);
-                if (tracker) {
-                    tracker.handleTaskCompleted(event.tool_use_id);
-                }
+            if (agent.subAgentTracker) {
+                agent.subAgentTracker.handleTaskCompleted(event.tool_use_id);
+            }
+            // Update the in-turn sub-agent segment in the main bubble
+            if (agent.accumulator && event.tool_use_id) {
+                agent.accumulator.updateSubAgentSegment(event.tool_use_id, 'completed');
             }
         });
-        // Media from tool results (images, PDFs, etc.) — broadcast to all subscribers
+        // Media from tool results (images, PDFs, etc.)
         proc.on('media', (media) => {
             const buf = Buffer.from(media.data, 'base64');
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                if (media.kind === 'image') {
-                    subAgent.tgBot.sendPhotoBuffer(sub.client.chatId, buf).catch(err => {
-                        this.logger.error({ err, agentId: sub.client.agentId, userId: sub.client.userId }, 'Failed to send tool_result image');
-                    });
-                }
-                else if (media.kind === 'document') {
-                    const ext = media.media_type === 'application/pdf' ? '.pdf' : '';
-                    subAgent.tgBot.sendDocumentBuffer(sub.client.chatId, buf, `document${ext}`).catch(err => {
-                        this.logger.error({ err, agentId: sub.client.agentId, userId: sub.client.userId }, 'Failed to send tool_result document');
-                    });
-                }
+            const chatId = this.getAgentChatId(agent);
+            if (!chatId || !agent.tgBot)
+                return;
+            if (media.kind === 'image') {
+                agent.tgBot.sendPhotoBuffer(chatId, buf).catch(err => {
+                    this.logger.error({ err, agentId }, 'Failed to send tool_result image');
+                });
+            }
+            else if (media.kind === 'document') {
+                const ext = media.media_type === 'application/pdf' ? '.pdf' : '';
+                agent.tgBot.sendDocumentBuffer(chatId, buf, `document${ext}`).catch(err => {
+                    this.logger.error({ err, agentId }, 'Failed to send tool_result document');
+                });
             }
         });
         proc.on('assistant', (event) => {
-            // Non-streaming fallback — only used if stream_events don't fire
-            // In practice, stream_events handle the display
+            // Log text and thinking blocks to event buffer
+            if (event.message?.content) {
+                for (const block of event.message.content) {
+                    if (block.type === 'thinking' && block.thinking) {
+                        const truncated = block.thinking.length > 300 ? block.thinking.slice(0, 300) + '…' : block.thinking;
+                        agent.eventBuffer.push({ ts: Date.now(), type: 'thinking', text: truncated });
+                    }
+                    else if (block.type === 'text' && block.text) {
+                        agent.eventBuffer.push({ ts: Date.now(), type: 'text', text: block.text });
+                    }
+                    else if (block.type === 'tool_use') {
+                        const toolBlock = block;
+                        this.highSignalDetector.handleAssistantToolUse(agentId, toolBlock.name, toolBlock.id, toolBlock.input);
+                    }
+                }
+            }
         });
         proc.on('result', (event) => {
-            // Model override consumed — CC has written to JSONL
-            this.sessionModelOverrides.delete(`${agentId}:${userId}`);
-            // Broadcast result to all subscribers
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                this.stopTypingIndicator(subAgent, sub.client.userId, sub.client.chatId);
-                this.handleResult(sub.client.agentId, sub.client.userId, sub.client.chatId, event);
+            this.stopTypingIndicator(agent);
+            agent.eventBuffer.push({ ts: Date.now(), type: 'system', text: `Turn complete${event.is_error ? ' (error)' : ''}${event.total_cost_usd ? ` · $${event.total_cost_usd.toFixed(4)}` : ''}` });
+            this.handleResult(agentId, event);
+            // Forward to supervisor
+            if (this.isSupervisorSubscribed(agentId, proc.sessionId)) {
+                const resultText = event.result ? String(event.result) : '';
+                this.sendToSupervisor({
+                    type: 'event',
+                    event: 'result',
+                    agentId,
+                    sessionId: proc.sessionId,
+                    text: resultText,
+                    is_error: event.is_error ?? false,
+                });
             }
         });
         proc.on('compact', (event) => {
-            // Notify all subscribers that compaction happened
             const trigger = event.compact_metadata?.trigger ?? 'manual';
             const preTokens = event.compact_metadata?.pre_tokens;
             const tokenInfo = preTokens ? ` (was ${Math.round(preTokens / 1000)}k tokens)` : '';
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                const label = trigger === 'auto' ? '🗜️ Auto-compacted' : '🗜️ Compacted';
-                subAgent.tgBot.sendText(sub.client.chatId, `<blockquote>${escapeHtml(label + tokenInfo)}</blockquote>`, 'HTML').catch((err) => this.logger.error({ err }, 'Failed to send compact notification'));
+            const label = trigger === 'auto' ? '🗜️ Auto-compacted' : '🗜️ Compacted';
+            agent.eventBuffer.push({ ts: Date.now(), type: 'system', text: label + tokenInfo });
+            const chatId = this.getAgentChatId(agent);
+            if (chatId && agent.tgBot) {
+                agent.tgBot.sendText(chatId, `<blockquote>${escapeHtml(label + tokenInfo)}</blockquote>`, 'HTML', true).catch((err) => this.logger.error({ err }, 'Failed to send compact notification'));
             }
         });
         proc.on('permission_request', (event) => {
-            // Send permission request only to the owner (first subscriber)
             const req = event.request;
             const requestId = event.request_id;
-            // Store pending permission on the owner's agent
             agent.pendingPermissions.set(requestId, {
                 requestId,
-                userId,
+                userId: agentId,
                 toolName: req.tool_name,
                 input: req.input,
             });
-            // Build description of what CC wants to do
             const toolName = escapeHtml(req.tool_name);
             const inputPreview = req.input
                 ? escapeHtml(JSON.stringify(req.input).slice(0, 200))
@@ -663,9 +636,24 @@ export class Bridge extends EventEmitter {
             const keyboard = new InlineKeyboard()
                 .text('✅ Allow', `perm_allow:${requestId}`)
                 .text('❌ Deny', `perm_deny:${requestId}`)
-                .text('✅ Allow All', `perm_allow_all:${userId}`);
-            agent.tgBot.sendTextWithKeyboard(chatId, text, keyboard, 'HTML')
-                .catch(err => this.logger.error({ err }, 'Failed to send permission request'));
+                .text('✅ Allow All', `perm_allow_all:${agentId}`);
+            const permChatId = this.getAgentChatId(agent);
+            if (permChatId && agent.tgBot) {
+                agent.tgBot.sendTextWithKeyboard(permChatId, text, keyboard, 'HTML')
+                    .catch(err => this.logger.error({ err }, 'Failed to send permission request'));
+            }
+            // Forward to supervisor so it can render approve/deny UI
+            if (this.isSupervisorSubscribed(agentId, proc.sessionId)) {
+                const description = req.decision_reason || `CC wants to use ${req.tool_name}`;
+                this.sendToSupervisor({
+                    type: 'event',
+                    event: 'permission_request',
+                    agentId,
+                    toolName: req.tool_name,
+                    requestId,
+                    description,
+                });
+            }
         });
         proc.on('api_error', (event) => {
             const errMsg = event.error?.message || 'Unknown API error';
@@ -674,195 +662,178 @@ export class Bridge extends EventEmitter {
             const retryInfo = event.retryAttempt != null && event.maxRetries != null
                 ? ` (retry ${event.retryAttempt}/${event.maxRetries})`
                 : '';
+            agent.eventBuffer.push({ ts: Date.now(), type: 'error', text: `${errMsg}${retryInfo}` });
             const text = isOverloaded
-                ? `<blockquote>⚠️ API overloaded, retrying...${retryInfo}</blockquote>`
-                : `<blockquote>⚠️ ${escapeHtml(errMsg)}${retryInfo}</blockquote>`;
-            // Broadcast API error to all subscribers
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                subAgent.tgBot.sendText(sub.client.chatId, text, 'HTML')
+                ? formatSystemMessage('error', `API overloaded, retrying...${retryInfo}`)
+                : formatSystemMessage('error', `${escapeHtml(errMsg)}${retryInfo}`);
+            const errChatId = this.getAgentChatId(agent);
+            if (errChatId && agent.tgBot) {
+                agent.tgBot.sendText(errChatId, text, 'HTML', true) // silent
                     .catch(err => this.logger.error({ err }, 'Failed to send API error notification'));
             }
         });
         proc.on('hang', () => {
-            // Broadcast hang notification to all subscribers
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                this.stopTypingIndicator(subAgent, sub.client.userId, sub.client.chatId);
-                subAgent.tgBot.sendText(sub.client.chatId, '<blockquote>⏸ Session paused. Send a message to continue.</blockquote>', 'HTML')
+            this.stopTypingIndicator(agent);
+            const hangChatId = this.getAgentChatId(agent);
+            if (hangChatId && agent.tgBot) {
+                agent.tgBot.sendText(hangChatId, '<blockquote>⏸ Session paused. Send a message to continue.</blockquote>', 'HTML', true) // silent
                     .catch(err => this.logger.error({ err }, 'Failed to send hang notification'));
             }
         });
         proc.on('takeover', () => {
-            this.logger.warn({ agentId, userId }, 'Session takeover detected — keeping session for roaming');
-            // Notify and clean up all subscribers
+            this.logger.warn({ agentId }, 'Session takeover detected — keeping session for roaming');
+            agent.eventBuffer.push({ ts: Date.now(), type: 'system', text: 'Session takeover detected' });
+            // Send TG system message for takeover
+            const takeoverChatId = this.getAgentChatId(agent);
+            if (takeoverChatId && agent.tgBot) {
+                agent.tgBot.sendText(takeoverChatId, '<blockquote>⚠️ Session taken over by another client</blockquote>', 'HTML', true)
+                    .catch(err => this.logger.error({ err, agentId }, 'Failed to send takeover notification'));
+            }
+            // Notify supervisor and suppress subsequent exit event
+            if (this.isSupervisorSubscribed(agentId, proc.sessionId)) {
+                this.sendToSupervisor({ type: 'event', event: 'session_takeover', agentId, sessionId: proc.sessionId });
+                this.suppressExitForProcess.add(proc.sessionId ?? '');
+            }
+            this.stopTypingIndicator(agent);
             const entry = getEntry();
             if (entry) {
-                for (const sub of this.processRegistry.subscribers(entry)) {
-                    const subAgent = this.agents.get(sub.client.agentId);
-                    if (!subAgent)
-                        continue;
-                    this.stopTypingIndicator(subAgent, sub.client.userId, sub.client.chatId);
-                    subAgent.processes.delete(sub.client.userId);
-                }
-                // Remove from registry without destroying (already handling exit)
                 this.processRegistry.remove(entry.repo, entry.sessionId);
             }
-            // Don't clear session — allow roaming between clients.
+            agent.ccProcess = null;
             proc.destroy();
         });
         proc.on('exit', () => {
-            // Clean up all subscribers
+            agent.eventBuffer.push({ ts: Date.now(), type: 'system', text: 'Process exited' });
+            this.highSignalDetector.cleanup(agentId);
+            // Forward to supervisor (unless suppressed by takeover)
+            if (this.suppressExitForProcess.has(proc.sessionId ?? '')) {
+                this.suppressExitForProcess.delete(proc.sessionId ?? '');
+            }
+            else if (this.isSupervisorSubscribed(agentId, proc.sessionId)) {
+                this.sendToSupervisor({ type: 'event', event: 'process_exit', agentId, sessionId: proc.sessionId, exitCode: null });
+            }
+            this.stopTypingIndicator(agent);
+            if (agent.accumulator) {
+                agent.accumulator.finalize();
+                agent.accumulator = null;
+            }
+            if (agent.subAgentTracker) {
+                agent.subAgentTracker.stopMailboxWatch();
+                agent.subAgentTracker = null;
+            }
             const entry = getEntry();
             if (entry) {
-                for (const sub of this.processRegistry.subscribers(entry)) {
-                    const subAgent = this.agents.get(sub.client.agentId);
-                    if (!subAgent)
-                        continue;
-                    this.stopTypingIndicator(subAgent, sub.client.userId, sub.client.chatId);
-                    const accKey = `${sub.client.userId}:${sub.client.chatId}`;
-                    const acc = subAgent.accumulators.get(accKey);
-                    if (acc) {
-                        acc.finalize();
-                        subAgent.accumulators.delete(accKey);
-                    }
-                    const exitTracker = subAgent.subAgentTrackers.get(accKey);
-                    if (exitTracker) {
-                        exitTracker.stopMailboxWatch();
-                    }
-                    subAgent.subAgentTrackers.delete(accKey);
-                }
-                // Remove from registry (process already exited)
                 this.processRegistry.remove(entry.repo, entry.sessionId);
             }
-            else {
-                // Fallback: clean up owner only
-                this.stopTypingIndicator(agent, userId, chatId);
-                const accKey = `${userId}:${chatId}`;
-                const acc = agent.accumulators.get(accKey);
-                if (acc) {
-                    acc.finalize();
-                    agent.accumulators.delete(accKey);
-                }
-                const exitTracker = agent.subAgentTrackers.get(accKey);
-                if (exitTracker) {
-                    exitTracker.stopMailboxWatch();
-                }
-                agent.subAgentTrackers.delete(accKey);
-            }
+            agent.ccProcess = null;
         });
         proc.on('error', (err) => {
-            // Broadcast error to all subscribers
-            const entry = getEntry();
-            const subscriberList = entry ? [...this.processRegistry.subscribers(entry)] : [{ client: ownerRef }];
-            for (const sub of subscriberList) {
-                const subAgent = this.agents.get(sub.client.agentId);
-                if (!subAgent)
-                    continue;
-                this.stopTypingIndicator(subAgent, sub.client.userId, sub.client.chatId);
-                subAgent.tgBot.sendText(sub.client.chatId, `<blockquote>⚠️ ${escapeHtml(String(err.message))}</blockquote>`, 'HTML')
+            agent.eventBuffer.push({ ts: Date.now(), type: 'error', text: err.message });
+            this.stopTypingIndicator(agent);
+            const errChatId = this.getAgentChatId(agent);
+            if (errChatId && agent.tgBot) {
+                agent.tgBot.sendText(errChatId, formatSystemMessage('error', escapeHtml(String(err.message))), 'HTML', true) // silent
                     .catch(err2 => this.logger.error({ err: err2 }, 'Failed to send process error notification'));
             }
         });
         return proc;
     }
     // ── Stream event handling ──
-    handleStreamEvent(agentId, userId, chatId, event) {
+    handleStreamEvent(agentId, event) {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
-        const accKey = `${userId}:${chatId}`;
-        let acc = agent.accumulators.get(accKey);
-        if (!acc) {
+        const chatId = this.getAgentChatId(agent);
+        if (!chatId)
+            return;
+        if (!agent.accumulator && agent.tgBot) {
+            const tgBot = agent.tgBot; // capture for closures (non-null here)
             const sender = {
-                sendMessage: (cid, text, parseMode) => agent.tgBot.sendText(cid, text, parseMode),
-                editMessage: (cid, msgId, text, parseMode) => agent.tgBot.editText(cid, msgId, text, parseMode),
-                deleteMessage: (cid, msgId) => agent.tgBot.deleteMessage(cid, msgId),
-                sendPhoto: (cid, buffer, caption) => agent.tgBot.sendPhotoBuffer(cid, buffer, caption),
+                sendMessage: (cid, text, parseMode) => {
+                    this.logger.info({ agentId, chatId: cid, textLen: text.length }, 'TG accumulator sendMessage');
+                    return tgBot.sendText(cid, text, parseMode, true); // silent — no push notification
+                },
+                editMessage: (cid, msgId, text, parseMode) => {
+                    this.logger.info({ agentId, chatId: cid, msgId, textLen: text.length }, 'TG accumulator editMessage');
+                    return tgBot.editText(cid, msgId, text, parseMode);
+                },
+                deleteMessage: (cid, msgId) => tgBot.deleteMessage(cid, msgId),
+                setReaction: (cid, msgId, emoji) => tgBot.setReaction(cid, msgId, emoji),
+                sendPhoto: (cid, buffer, caption) => tgBot.sendPhotoBuffer(cid, buffer, caption),
             };
             const onError = (err, context) => {
-                this.logger.error({ err, context, agentId, userId }, 'Stream accumulator error');
-                agent.tgBot.sendText(chatId, `<blockquote>⚠️ ${escapeHtml(context)}</blockquote>`, 'HTML').catch(() => { });
+                this.logger.error({ err, context, agentId }, 'Stream accumulator error');
+                tgBot.sendText(chatId, formatSystemMessage('error', escapeHtml(context)), 'HTML', true).catch(() => { }); // silent
             };
-            acc = new StreamAccumulator({ chatId, sender, logger: this.logger, onError });
-            agent.accumulators.set(accKey, acc);
+            agent.accumulator = new StreamAccumulator({ chatId, sender, logger: this.logger, onError });
         }
-        // Sub-agent tracker — create lazily alongside the accumulator
-        let tracker = agent.subAgentTrackers.get(accKey);
-        if (!tracker) {
+        if (!agent.subAgentTracker && agent.tgBot) {
+            const tgBot = agent.tgBot; // capture for closures (non-null here)
             const subAgentSender = {
-                sendMessage: (cid, text, parseMode) => agent.tgBot.sendText(cid, text, parseMode),
-                editMessage: (cid, msgId, text, parseMode) => agent.tgBot.editText(cid, msgId, text, parseMode),
-                setReaction: (cid, msgId, emoji) => agent.tgBot.setReaction(cid, msgId, emoji),
+                sendMessage: (cid, text, parseMode) => tgBot.sendText(cid, text, parseMode, true), // silent
+                editMessage: (cid, msgId, text, parseMode) => tgBot.editText(cid, msgId, text, parseMode),
+                setReaction: (cid, msgId, emoji) => tgBot.setReaction(cid, msgId, emoji),
             };
-            tracker = new SubAgentTracker({
+            agent.subAgentTracker = new SubAgentTracker({
                 chatId,
                 sender: subAgentSender,
             });
-            agent.subAgentTrackers.set(accKey, tracker);
         }
-        // On message_start: new CC turn — full reset for text accumulator.
-        // Tool indicator messages are independent and persist across turns.
+        // On message_start: only start a new bubble if the previous turn was sealed
+        // (i.e. a result event finalized it). CC sends message_start on every tool-use
+        // loop within the same turn — those must reuse the same bubble via softReset.
         if (event.type === 'message_start') {
-            acc.reset();
-            // Only reset tracker if no agents still dispatched
-            if (!tracker.hasDispatchedAgents) {
-                tracker.reset();
+            if (agent.accumulator?.sealed) {
+                // Previous turn is done (result event sealed it) → new bubble
+                agent.accumulator.reset();
+                if (agent.subAgentTracker && !agent.subAgentTracker.hasDispatchedAgents) {
+                    agent.subAgentTracker.reset();
+                }
+            }
+            else if (agent.accumulator) {
+                // Mid-turn tool-use loop → keep same bubble, clear transient state
+                agent.accumulator.softReset();
             }
         }
-        acc.handleEvent(event);
-        tracker.handleEvent(event);
+        agent.accumulator?.handleEvent(event);
+        agent.subAgentTracker?.handleEvent(event);
     }
-    handleResult(agentId, userId, chatId, event) {
+    handleResult(agentId, event) {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
+        const chatId = this.getAgentChatId(agent);
         // Set usage stats on the accumulator before finalizing
-        const accKey = `${userId}:${chatId}`;
-        const acc = agent.accumulators.get(accKey);
+        const acc = agent.accumulator;
         if (acc) {
-            // Extract usage from result event
             if (event.usage) {
+                const proc = agent.ccProcess;
+                const entry = proc ? this.processRegistry.findByProcess(proc) : null;
                 acc.setTurnUsage({
                     inputTokens: event.usage.input_tokens ?? 0,
                     outputTokens: event.usage.output_tokens ?? 0,
                     cacheReadTokens: event.usage.cache_read_input_tokens ?? 0,
                     cacheCreationTokens: event.usage.cache_creation_input_tokens ?? 0,
                     costUsd: event.total_cost_usd ?? null,
-                    model: event.model
-                        ?? this.processRegistry.findByClient({ agentId, userId, chatId })?.model,
+                    model: event.model ?? entry?.model,
                 });
             }
             acc.finalize();
-            // Don't delete — next turn will reset via message_start and create a new message
         }
-        // Update session store with cost
-        if (event.total_cost_usd) {
-        }
-        // Update JSONL tracking after our own CC turn completes
-        // This prevents false-positive staleness on our own writes
-        // Handle errors
-        if (event.is_error && event.result) {
-            agent.tgBot.sendText(chatId, `<blockquote>⚠️ ${escapeHtml(String(event.result))}</blockquote>`, 'HTML')
+        // Handle errors (only send to TG if bot available)
+        if (event.is_error && event.result && chatId && agent.tgBot) {
+            agent.tgBot.sendText(chatId, formatSystemMessage('error', escapeHtml(String(event.result))), 'HTML', true) // silent
                 .catch(err => this.logger.error({ err }, 'Failed to send result error notification'));
         }
         // If background sub-agents are still running, mailbox watcher handles them.
-        // Ensure mailbox watch is started if we have a team name and dispatched agents.
-        const tracker = agent.subAgentTrackers.get(accKey);
+        const tracker = agent.subAgentTracker;
         if (tracker?.hasDispatchedAgents && tracker.currentTeamName) {
             this.logger.info({ agentId }, 'Turn ended with background sub-agents still running');
-            // Clear idle timer — don't kill CC while background agents are working
-            const ccProcess = agent.processes.get(userId);
+            const ccProcess = agent.ccProcess;
             if (ccProcess)
                 ccProcess.clearIdleTimer();
+            // Create standalone post-turn status bubble (main bubble is now sealed)
+            tracker.startPostTurnTracking().catch(err => this.logger.error({ err, agentId }, 'Failed to start post-turn tracking'));
             // Start mailbox watcher (works for general-purpose agents that have SendMessage)
             tracker.startMailboxWatch();
             // Fallback: send ONE follow-up after 60s if mailbox hasn't resolved all agents
@@ -871,12 +842,11 @@ export class Bridge extends EventEmitter {
                 tracker.hasPendingFollowUp = true;
                 setTimeout(() => {
                     if (!tracker.hasDispatchedAgents)
-                        return; // already resolved via mailbox
-                    const proc = agent.processes.get(userId);
+                        return;
+                    const proc = agent.ccProcess;
                     if (!proc)
                         return;
                     this.logger.info({ agentId }, 'Mailbox timeout — sending single follow-up for remaining agents');
-                    // Mark all remaining dispatched agents as completed (CC already has the results)
                     for (const info of tracker.activeAgents) {
                         if (info.status === 'dispatched') {
                             tracker.markCompleted(info.toolUseId, '(results delivered in CC response)');
@@ -892,27 +862,14 @@ export class Bridge extends EventEmitter {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
+        if (!agent.tgBot)
+            return; // ephemeral agents don't have TG bots
         this.logger.debug({ agentId, command: cmd.command, args: cmd.args }, 'Slash command');
         switch (cmd.command) {
             case 'start': {
-                const userConf = resolveUserConfig(agent.config, cmd.userId);
-                const userState = this.sessionStore.getUser(agentId, cmd.userId);
-                const repo = userState.repo || userConf.repo;
-                const session = userState.currentSessionId;
-                // Model: running process > session JSONL > user default
-                let model = userConf.model;
-                if (session && repo) {
-                    const registryEntry = this.processRegistry.get(repo, session);
-                    if (registryEntry?.model) {
-                        model = registryEntry.model;
-                    }
-                    else {
-                        const sessions = discoverCCSessions(repo, 20);
-                        const sessionInfo = sessions.find(s => s.id === session);
-                        if (sessionInfo?.model)
-                            model = sessionInfo.model;
-                    }
-                }
+                const repo = agent.repo;
+                const model = agent.model;
+                const session = agent.ccProcess?.sessionId;
                 const lines = ['👋 <b>TGCC</b> — Telegram ↔ Claude Code bridge'];
                 if (repo)
                     lines.push(`📂 <code>${escapeHtml(shortenRepoPath(repo))}</code>`);
@@ -934,14 +891,12 @@ export class Bridge extends EventEmitter {
                 await agent.tgBot.sendText(cmd.chatId, HELP_TEXT, 'HTML');
                 break;
             case 'ping': {
-                const proc = agent.processes.get(cmd.userId);
-                const state = proc?.state ?? 'idle';
+                const state = agent.ccProcess?.state ?? 'idle';
                 await agent.tgBot.sendText(cmd.chatId, `pong — process: <b>${state.toUpperCase()}</b>`, 'HTML');
                 break;
             }
             case 'status': {
-                const proc = agent.processes.get(cmd.userId);
-                const userState = this.sessionStore.getUser(agentId, cmd.userId);
+                const proc = agent.ccProcess;
                 const uptime = proc?.spawnedAt
                     ? formatDuration(Date.now() - proc.spawnedAt.getTime())
                     : 'N/A';
@@ -949,77 +904,56 @@ export class Bridge extends EventEmitter {
                     `<b>Agent:</b> ${escapeHtml(agentId)}`,
                     `<b>Process:</b> ${(proc?.state ?? 'idle').toUpperCase()} (uptime: ${uptime})`,
                     `<b>Session:</b> <code>${escapeHtml(proc?.sessionId?.slice(0, 8) ?? 'none')}</code>`,
-                    `<b>Model:</b> ${escapeHtml(resolveUserConfig(agent.config, cmd.userId).model)}`,
-                    `<b>Repo:</b> ${escapeHtml(userState.repo || resolveUserConfig(agent.config, cmd.userId).repo)}`,
+                    `<b>Model:</b> ${escapeHtml(agent.model)}`,
+                    `<b>Repo:</b> ${escapeHtml(agent.repo)}`,
                     `<b>Cost:</b> $${(proc?.totalCostUsd ?? 0).toFixed(4)}`,
                 ].join('\n');
                 await agent.tgBot.sendText(cmd.chatId, status, 'HTML');
                 break;
             }
             case 'cost': {
-                const proc = agent.processes.get(cmd.userId);
-                await agent.tgBot.sendText(cmd.chatId, `<b>Session cost:</b> $${(proc?.totalCostUsd ?? 0).toFixed(4)}`, 'HTML');
+                await agent.tgBot.sendText(cmd.chatId, `<b>Session cost:</b> $${(agent.ccProcess?.totalCostUsd ?? 0).toFixed(4)}`, 'HTML');
                 break;
             }
             case 'new': {
-                this.disconnectClient(agentId, cmd.userId, cmd.chatId);
-                this.sessionStore.clearSession(agentId, cmd.userId);
-                const newConf = resolveUserConfig(agent.config, cmd.userId);
-                const newState = this.sessionStore.getUser(agentId, cmd.userId);
-                const newRepo = newState.repo || newConf.repo;
-                const newModel = newState.model || newConf.model;
+                this.killAgentProcess(agentId);
+                agent.pendingSessionId = null; // next message spawns fresh
                 const newLines = ['Session cleared. Next message starts fresh.'];
-                if (newRepo)
-                    newLines.push(`📂 <code>${escapeHtml(shortenRepoPath(newRepo))}</code>`);
-                if (newModel)
-                    newLines.push(`🤖 ${escapeHtml(newModel)}`);
+                if (agent.repo)
+                    newLines.push(`📂 <code>${escapeHtml(shortenRepoPath(agent.repo))}</code>`);
+                if (agent.model)
+                    newLines.push(`🤖 ${escapeHtml(agent.model)}`);
                 await agent.tgBot.sendText(cmd.chatId, `<blockquote>${newLines.join('\n')}</blockquote>`, 'HTML');
                 break;
             }
             case 'continue': {
-                this.disconnectClient(agentId, cmd.userId, cmd.chatId);
-                const contConf = resolveUserConfig(agent.config, cmd.userId);
-                const contState = this.sessionStore.getUser(agentId, cmd.userId);
-                const contRepo = contState.repo || contConf.repo;
-                let contSession = contState.currentSessionId;
-                // If no current session, auto-pick the most recent one
-                if (!contSession && contRepo) {
-                    const recent = discoverCCSessions(contRepo, 1);
+                // Remember the current session before killing
+                const contSession = agent.ccProcess?.sessionId;
+                this.killAgentProcess(agentId);
+                // If no session, auto-pick the most recent one
+                let sessionToResume = contSession;
+                if (!sessionToResume && agent.repo) {
+                    const recent = discoverCCSessions(agent.repo, 1);
                     if (recent.length > 0) {
-                        contSession = recent[0].id;
-                        this.sessionStore.setCurrentSession(agentId, cmd.userId, contSession);
+                        sessionToResume = recent[0].id;
                     }
                 }
-                // Model priority: running process registry > session JSONL > user default
-                let contModel = contConf.model;
-                if (contSession && contRepo) {
-                    // Check if a process is already running for this session
-                    const registryEntry = this.processRegistry.get(contRepo, contSession);
-                    if (registryEntry?.model) {
-                        contModel = registryEntry.model;
-                    }
-                    else {
-                        const sessions = discoverCCSessions(contRepo, 20);
-                        const sessionInfo = sessions.find(s => s.id === contSession);
-                        if (sessionInfo?.model)
-                            contModel = sessionInfo.model;
-                    }
+                if (sessionToResume) {
+                    agent.pendingSessionId = sessionToResume;
                 }
                 const contLines = ['Process respawned. Session kept.'];
-                if (contRepo)
-                    contLines.push(`📂 <code>${escapeHtml(shortenRepoPath(contRepo))}</code>`);
-                if (contModel)
-                    contLines.push(`🤖 ${escapeHtml(contModel)}`);
-                if (contSession)
-                    contLines.push(`📎 <code>${escapeHtml(contSession.slice(0, 8))}</code>`);
+                if (agent.repo)
+                    contLines.push(`📂 <code>${escapeHtml(shortenRepoPath(agent.repo))}</code>`);
+                if (agent.model)
+                    contLines.push(`🤖 ${escapeHtml(agent.model)}`);
+                if (sessionToResume)
+                    contLines.push(`📎 <code>${escapeHtml(sessionToResume.slice(0, 8))}</code>`);
                 await agent.tgBot.sendText(cmd.chatId, `<blockquote>${contLines.join('\n')}</blockquote>`, 'HTML');
                 break;
             }
             case 'sessions': {
-                const userConf = resolveUserConfig(agent.config, cmd.userId);
-                const userState = this.sessionStore.getUser(agentId, cmd.userId);
-                const repo = userState.repo || userConf.repo;
-                const currentSessionId = userState.currentSessionId;
+                const repo = agent.repo;
+                const currentSessionId = agent.ccProcess?.sessionId ?? null;
                 // Discover sessions from CC's session directory
                 const discovered = repo ? discoverCCSessions(repo, 5) : [];
                 const merged = discovered.map(d => {
@@ -1051,7 +985,7 @@ export class Bridge extends EventEmitter {
                     const kb = new InlineKeyboard();
                     if (s.isCurrent) {
                         const repoLine = repo ? `\n📂 <code>${escapeHtml(shortenRepoPath(repo))}</code>` : '';
-                        const sessModel = userConf.model;
+                        const sessModel = agent.model;
                         const modelLine = sessModel ? `\n🤖 ${escapeHtml(sessModel)}` : '';
                         const sessionLine = `\n📎 <code>${escapeHtml(s.id.slice(0, 8))}</code>`;
                         const text = `<blockquote><b>Current session:</b>\n${displayTitle}\n${s.detail} · ${s.age}${repoLine}${modelLine}${sessionLine}</blockquote>`;
@@ -1071,22 +1005,21 @@ export class Bridge extends EventEmitter {
                     await agent.tgBot.sendText(cmd.chatId, '<blockquote>Usage: /resume &lt;session-id&gt;</blockquote>', 'HTML');
                     break;
                 }
-                this.disconnectClient(agentId, cmd.userId, cmd.chatId);
-                this.sessionStore.setCurrentSession(agentId, cmd.userId, cmd.args.trim());
+                this.killAgentProcess(agentId);
+                agent.pendingSessionId = cmd.args.trim();
                 await agent.tgBot.sendText(cmd.chatId, `Will resume session <code>${escapeHtml(cmd.args.trim().slice(0, 8))}</code> on next message.`, 'HTML');
                 break;
             }
             case 'session': {
-                const userState = this.sessionStore.getUser(agentId, cmd.userId);
-                if (!userState.currentSessionId) {
+                const currentSessionId = agent.ccProcess?.sessionId;
+                if (!currentSessionId) {
                     await agent.tgBot.sendText(cmd.chatId, '<blockquote>No active session.</blockquote>', 'HTML');
                     break;
                 }
-                const sessRepo = userState.repo || resolveUserConfig(agent.config, cmd.userId).repo;
-                const discovered = sessRepo ? discoverCCSessions(sessRepo, 20) : [];
-                const info = discovered.find(d => d.id === userState.currentSessionId);
+                const discovered = agent.repo ? discoverCCSessions(agent.repo, 20) : [];
+                const info = discovered.find(d => d.id === currentSessionId);
                 if (!info) {
-                    await agent.tgBot.sendText(cmd.chatId, `<b>Session:</b> <code>${escapeHtml(userState.currentSessionId.slice(0, 8))}</code>`, 'HTML');
+                    await agent.tgBot.sendText(cmd.chatId, `<b>Session:</b> <code>${escapeHtml(currentSessionId.slice(0, 8))}</code>`, 'HTML');
                     break;
                 }
                 const ctxLine = info.contextPct !== null ? `\n<b>Context:</b> ${info.contextPct}%` : '';
@@ -1097,23 +1030,7 @@ export class Bridge extends EventEmitter {
             case 'model': {
                 const MODEL_OPTIONS = ['opus', 'sonnet', 'haiku'];
                 if (!cmd.args) {
-                    // Show model from: running process > JSONL > agent config
-                    const uState = this.sessionStore.getUser(agentId, cmd.userId);
-                    const uConf = resolveUserConfig(agent.config, cmd.userId);
-                    const uRepo = uState.repo || uConf.repo;
-                    const uSession = uState.currentSessionId;
-                    let current = uConf.model || 'default';
-                    if (uSession && uRepo) {
-                        const re = this.processRegistry.get(uRepo, uSession);
-                        if (re?.model)
-                            current = re.model;
-                        else {
-                            const ds = discoverCCSessions(uRepo, 20);
-                            const si = ds.find(s => s.id === uSession);
-                            if (si?.model)
-                                current = si.model;
-                        }
-                    }
+                    const current = agent.model || 'default';
                     const keyboard = new InlineKeyboard();
                     for (const m of MODEL_OPTIONS) {
                         const isCurrent = current.includes(m);
@@ -1124,11 +1041,13 @@ export class Bridge extends EventEmitter {
                     break;
                 }
                 const newModel = cmd.args.trim();
-                // Store as session-level override (not user default)
-                const curSession = this.sessionStore.getUser(agentId, cmd.userId).currentSessionId;
-                this.sessionModelOverrides.set(`${agentId}:${cmd.userId}`, newModel);
-                this.disconnectClient(agentId, cmd.userId, cmd.chatId);
+                const oldModel = agent.model;
+                agent.model = newModel;
+                this.sessionStore.setModel(agentId, newModel);
+                this.killAgentProcess(agentId);
                 await agent.tgBot.sendText(cmd.chatId, `<blockquote>Model set to <code>${escapeHtml(newModel)}</code>. Process respawned.</blockquote>`, 'HTML');
+                // Emit state_changed event
+                this.emitStateChanged(agentId, 'model', oldModel, newModel, 'telegram');
                 break;
             }
             case 'repo': {
@@ -1247,8 +1166,7 @@ export class Bridge extends EventEmitter {
                     break;
                 }
                 if (!cmd.args) {
-                    const current = this.sessionStore.getUser(agentId, cmd.userId).repo
-                        || resolveUserConfig(agent.config, cmd.userId).repo;
+                    const current = agent.repo;
                     // Show available repos as inline keyboard buttons
                     const repoEntries = Object.entries(this.config.repos);
                     if (repoEntries.length > 0) {
@@ -1271,17 +1189,19 @@ export class Bridge extends EventEmitter {
                     break;
                 }
                 // Kill current process (different CWD needs new process)
-                this.disconnectClient(agentId, cmd.userId, cmd.chatId);
-                this.sessionStore.setRepo(agentId, cmd.userId, repoPath);
-                // Always clear session when repo changes — sessions are project-specific
-                this.sessionStore.clearSession(agentId, cmd.userId);
+                const oldRepo = agent.repo;
+                this.killAgentProcess(agentId);
+                agent.repo = repoPath;
+                agent.pendingSessionId = null; // clear session when repo changes
+                this.sessionStore.setRepo(agentId, repoPath);
                 await agent.tgBot.sendText(cmd.chatId, `<blockquote>Repo set to <code>${escapeHtml(shortenRepoPath(repoPath))}</code>. Session cleared.</blockquote>`, 'HTML');
+                // Emit state_changed event
+                this.emitStateChanged(agentId, 'repo', oldRepo, repoPath, 'telegram');
                 break;
             }
             case 'cancel': {
-                const proc = agent.processes.get(cmd.userId);
-                if (proc && proc.state === 'active') {
-                    proc.cancel();
+                if (agent.ccProcess && agent.ccProcess.state === 'active') {
+                    agent.ccProcess.cancel();
                     await agent.tgBot.sendText(cmd.chatId, '<blockquote>Cancelled.</blockquote>', 'HTML');
                 }
                 else {
@@ -1290,18 +1210,15 @@ export class Bridge extends EventEmitter {
                 break;
             }
             case 'compact': {
-                // Trigger CC's built-in /compact slash command — like the Claude Code extension does
-                const proc = agent.processes.get(cmd.userId);
-                if (!proc || proc.state !== 'active') {
+                if (!agent.ccProcess || agent.ccProcess.state !== 'active') {
                     await agent.tgBot.sendText(cmd.chatId, '<blockquote>No active session to compact. Start one first.</blockquote>', 'HTML');
                     break;
                 }
-                // Build the compact message: "/compact [optional-instructions]"
                 const compactMsg = cmd.args?.trim()
                     ? `/compact ${cmd.args.trim()}`
                     : '/compact';
-                await agent.tgBot.sendText(cmd.chatId, '<blockquote>🗜️ Compacting…</blockquote>', 'HTML');
-                proc.sendMessage(createTextMessage(compactMsg));
+                await agent.tgBot.sendText(cmd.chatId, formatSystemMessage('status', 'Compacting…'), 'HTML');
+                agent.ccProcess.sendMessage(createTextMessage(compactMsg));
                 break;
             }
             case 'catchup': {
@@ -1311,24 +1228,22 @@ export class Bridge extends EventEmitter {
             }
             case 'permissions': {
                 const validModes = ['dangerously-skip', 'acceptEdits', 'default', 'plan'];
-                const userState = this.sessionStore.getUser(agentId, cmd.userId);
                 const agentDefault = agent.config.defaults.permissionMode;
-                const currentMode = userState.permissionMode || agentDefault;
+                const agentState = this.sessionStore.getAgent(agentId);
+                const currentMode = agentState.permissionMode || agentDefault;
                 if (cmd.args) {
                     const mode = cmd.args.trim();
                     if (!validModes.includes(mode)) {
                         await agent.tgBot.sendText(cmd.chatId, `<blockquote>Invalid mode. Valid: ${validModes.join(', ')}</blockquote>`, 'HTML');
                         break;
                     }
-                    this.sessionStore.setPermissionMode(agentId, cmd.userId, mode);
-                    // Kill current process so new mode takes effect on next spawn
-                    this.disconnectClient(agentId, cmd.userId, cmd.chatId);
+                    this.sessionStore.setPermissionMode(agentId, mode);
+                    this.killAgentProcess(agentId);
                     await agent.tgBot.sendText(cmd.chatId, `Permission mode set to <code>${escapeHtml(mode)}</code>. Takes effect on next message.`, 'HTML');
                     break;
                 }
-                // No args — show current mode + inline keyboard
                 const keyboard = new InlineKeyboard();
-                keyboard.text('🔓 Bypass', 'permissions:dangerously-skip').text('✏️ Accept Edits', 'permissions:acceptEdits').row();
+                keyboard.text('🔓 Bypass', 'permissions:dangerously-skip').text('🛂 Accept Edits', 'permissions:acceptEdits').row();
                 keyboard.text('🔒 Default', 'permissions:default').text('📋 Plan', 'permissions:plan').row();
                 await agent.tgBot.sendTextWithKeyboard(cmd.chatId, `Current: <code>${escapeHtml(currentMode)}</code>\nDefault: <code>${escapeHtml(agentDefault)}</code>\n\nSelect a mode for this session:`, keyboard, 'HTML');
                 break;
@@ -1340,22 +1255,23 @@ export class Bridge extends EventEmitter {
         const agent = this.agents.get(agentId);
         if (!agent)
             return;
+        if (!agent.tgBot)
+            return; // ephemeral agents don't have TG bots
         this.logger.debug({ agentId, action: query.action, data: query.data }, 'Callback query');
         switch (query.action) {
             case 'resume': {
                 const sessionId = query.data;
-                this.disconnectClient(agentId, query.userId, query.chatId);
-                this.sessionStore.setCurrentSession(agentId, query.userId, sessionId);
+                this.killAgentProcess(agentId);
+                agent.pendingSessionId = sessionId;
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Session set');
                 await agent.tgBot.sendText(query.chatId, `Will resume session <code>${escapeHtml(sessionId.slice(0, 8))}</code> on next message.`, 'HTML');
                 break;
             }
             case 'delete': {
                 const sessionId = query.data;
-                // Clear current session if it matches
-                const uState = this.sessionStore.getUser(agentId, query.userId);
-                if (uState.currentSessionId === sessionId) {
-                    this.sessionStore.setCurrentSession(agentId, query.userId, '');
+                // Kill process if it's running this session
+                if (agent.ccProcess?.sessionId === sessionId) {
+                    this.killAgentProcess(agentId);
                 }
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Session cleared');
                 await agent.tgBot.sendText(query.chatId, `Session <code>${escapeHtml(sessionId.slice(0, 8))}</code> cleared.`, 'HTML');
@@ -1368,13 +1284,15 @@ export class Bridge extends EventEmitter {
                     await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Path not found');
                     break;
                 }
-                // Kill current process (different CWD needs new process)
-                this.disconnectClient(agentId, query.userId, query.chatId);
-                this.sessionStore.setRepo(agentId, query.userId, repoPath);
-                // Always clear session when repo changes — sessions are project-specific
-                this.sessionStore.clearSession(agentId, query.userId);
+                const oldRepoCb = agent.repo;
+                this.killAgentProcess(agentId);
+                agent.repo = repoPath;
+                agent.pendingSessionId = null;
+                this.sessionStore.setRepo(agentId, repoPath);
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `Repo: ${repoName}`);
                 await agent.tgBot.sendText(query.chatId, `<blockquote>Repo set to <code>${escapeHtml(shortenRepoPath(repoPath))}</code>. Session cleared.</blockquote>`, 'HTML');
+                // Emit state_changed event
+                this.emitStateChanged(agentId, 'repo', oldRepoCb, repoPath, 'telegram');
                 break;
             }
             case 'repo_add': {
@@ -1389,10 +1307,14 @@ export class Bridge extends EventEmitter {
                     await agent.tgBot.sendText(query.chatId, 'Send: <code>/model &lt;model-name&gt;</code>', 'HTML');
                     break;
                 }
-                this.sessionModelOverrides.set(`${agentId}:${query.userId}`, model);
-                this.disconnectClient(agentId, query.userId, query.chatId);
+                const oldModelCb = agent.model;
+                agent.model = model;
+                this.sessionStore.setModel(agentId, model);
+                this.killAgentProcess(agentId);
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `Model: ${model}`);
                 await agent.tgBot.sendText(query.chatId, `<blockquote>Model set to <code>${escapeHtml(model)}</code>. Process respawned.</blockquote>`, 'HTML');
+                // Emit state_changed event
+                this.emitStateChanged(agentId, 'model', oldModelCb, model, 'telegram');
                 break;
             }
             case 'permissions': {
@@ -1402,9 +1324,8 @@ export class Bridge extends EventEmitter {
                     await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Invalid mode');
                     break;
                 }
-                this.sessionStore.setPermissionMode(agentId, query.userId, mode);
-                // Kill current process so new mode takes effect on next spawn
-                this.disconnectClient(agentId, query.userId, query.chatId);
+                this.sessionStore.setPermissionMode(agentId, mode);
+                this.killAgentProcess(agentId);
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `Mode: ${mode}`);
                 await agent.tgBot.sendText(query.chatId, `Permission mode set to <code>${escapeHtml(mode)}</code>. Takes effect on next message.`, 'HTML');
                 break;
@@ -1431,9 +1352,8 @@ export class Bridge extends EventEmitter {
                     await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Permission expired');
                     break;
                 }
-                const proc = agent.processes.get(pending.userId);
-                if (proc) {
-                    proc.respondToPermission(requestId, true);
+                if (agent.ccProcess) {
+                    agent.ccProcess.respondToPermission(requestId, true);
                 }
                 agent.pendingPermissions.delete(requestId);
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, '✅ Allowed');
@@ -1446,27 +1366,22 @@ export class Bridge extends EventEmitter {
                     await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Permission expired');
                     break;
                 }
-                const proc = agent.processes.get(pending.userId);
-                if (proc) {
-                    proc.respondToPermission(requestId, false);
+                if (agent.ccProcess) {
+                    agent.ccProcess.respondToPermission(requestId, false);
                 }
                 agent.pendingPermissions.delete(requestId);
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, '❌ Denied');
                 break;
             }
             case 'perm_allow_all': {
-                // Allow all pending permissions for this user
-                const targetUserId = query.data;
+                // Allow all pending permissions for this agent
                 const toAllow = [];
-                for (const [reqId, pending] of agent.pendingPermissions) {
-                    if (pending.userId === targetUserId) {
-                        toAllow.push(reqId);
-                    }
+                for (const [reqId] of agent.pendingPermissions) {
+                    toAllow.push(reqId);
                 }
-                const proc = agent.processes.get(targetUserId);
                 for (const reqId of toAllow) {
-                    if (proc)
-                        proc.respondToPermission(reqId, true);
+                    if (agent.ccProcess)
+                        agent.ccProcess.respondToPermission(reqId, true);
                     agent.pendingPermissions.delete(reqId);
                 }
                 await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `✅ Allowed ${toAllow.length} permission(s)`);
@@ -1480,24 +1395,18 @@ export class Bridge extends EventEmitter {
     handleCtlMessage(agentId, text, sessionId) {
         const agent = this.agents.get(agentId);
         if (!agent) {
-            // Return error via the CtlAckResponse shape won't work — but the ctl-server
-            // protocol handles errors separately. We'll throw and let it catch.
             throw new Error(`Unknown agent: ${agentId}`);
         }
-        // Use the first allowed user as the "CLI user" identity
-        const userId = agent.config.allowedUsers[0];
-        const chatId = Number(userId);
-        // If explicit session requested, set it
+        // If explicit session requested, set it as pending
         if (sessionId) {
-            this.sessionStore.setCurrentSession(agentId, userId, sessionId);
+            agent.pendingSessionId = sessionId;
         }
         // Route through the same sendToCC path as Telegram
-        this.sendToCC(agentId, userId, chatId, { text });
-        const proc = agent.processes.get(userId);
+        this.sendToCC(agentId, { text }, { spawnSource: 'cli' });
         return {
             type: 'ack',
-            sessionId: proc?.sessionId ?? this.sessionStore.getUser(agentId, userId).currentSessionId,
-            state: proc?.state ?? 'idle',
+            sessionId: agent.ccProcess?.sessionId ?? null,
+            state: agent.ccProcess?.state ?? 'idle',
         };
     }
     handleCtlStatus(agentId) {
@@ -1508,30 +1417,16 @@ export class Bridge extends EventEmitter {
             const agent = this.agents.get(id);
             if (!agent)
                 continue;
-            // Aggregate process state across users
-            let state = 'idle';
-            for (const [, proc] of agent.processes) {
-                if (proc.state === 'active') {
-                    state = 'active';
-                    break;
-                }
-                if (proc.state === 'spawning')
-                    state = 'spawning';
-            }
-            const userId = agent.config.allowedUsers[0];
-            const proc = agent.processes.get(userId);
-            const userConfig = resolveUserConfig(agent.config, userId);
+            const state = agent.ccProcess?.state ?? 'idle';
             agents.push({
                 id,
                 state,
-                sessionId: proc?.sessionId ?? null,
-                repo: this.sessionStore.getUser(id, userId).repo || userConfig.repo,
+                sessionId: agent.ccProcess?.sessionId ?? null,
+                repo: agent.repo,
             });
-            // List sessions for this agent from CC's session directory
-            const userState = this.sessionStore.getUser(id, userId);
-            const sessRepo = userState.repo || userConfig.repo;
-            if (sessRepo) {
-                for (const d of discoverCCSessions(sessRepo, 5)) {
+            // List sessions from CC's session directory
+            if (agent.repo) {
+                for (const d of discoverCCSessions(agent.repo, 5)) {
                     sessions.push({
                         id: d.id,
                         agentId: id,
@@ -1549,10 +1444,59 @@ export class Bridge extends EventEmitter {
         if (!agent) {
             return { id: request.id, success: false, error: `Unknown agent: ${request.agentId}` };
         }
-        // Find the chat ID for this user (from the most recent message)
-        // We use the userId to find which chat to send to
-        const chatId = Number(request.userId); // In TG, private chat ID === user ID
         try {
+            // Supervisor-routed tools (don't need TG chatId)
+            switch (request.tool) {
+                case 'notify_parent': {
+                    if (!this.supervisorWrite) {
+                        return { id: request.id, success: false, error: 'No supervisor connected' };
+                    }
+                    this.sendToSupervisor({
+                        type: 'event',
+                        event: 'cc_message',
+                        agentId: request.agentId,
+                        text: request.params.message,
+                        priority: request.params.priority || 'info',
+                    });
+                    return { id: request.id, success: true };
+                }
+                case 'supervisor_exec': {
+                    if (!this.supervisorWrite) {
+                        return { id: request.id, success: false, error: 'No supervisor connected' };
+                    }
+                    const timeoutMs = request.params.timeoutMs || 60000;
+                    const result = await this.sendSupervisorRequest({
+                        type: 'command',
+                        requestId: randomUUID(),
+                        action: 'exec',
+                        params: {
+                            command: request.params.command,
+                            agentId: request.agentId,
+                            timeoutMs,
+                        },
+                    }, timeoutMs);
+                    return { id: request.id, success: true, result };
+                }
+                case 'supervisor_notify': {
+                    if (!this.supervisorWrite) {
+                        return { id: request.id, success: false, error: 'No supervisor connected' };
+                    }
+                    this.sendToSupervisor({
+                        type: 'event',
+                        event: 'notification',
+                        agentId: request.agentId,
+                        title: request.params.title,
+                        body: request.params.body,
+                        priority: request.params.priority || 'active',
+                    });
+                    return { id: request.id, success: true };
+                }
+            }
+            // TG tools (need chatId and tgBot)
+            const chatId = this.getAgentChatId(agent);
+            if (!chatId || !agent.tgBot) {
+                return { id: request.id, success: false, error: `No chat ID for agent: ${request.agentId}` };
+            }
             switch (request.tool) {
                 case 'send_file':
                     await agent.tgBot.sendFile(chatId, request.params.path, request.params.caption);
@@ -1571,6 +1515,327 @@ export class Bridge extends EventEmitter {
             return { id: request.id, success: false, error: err instanceof Error ? err.message : 'Unknown error' };
         }
     }
+    // ── Supervisor protocol ──
+    isSupervisorSubscribed(agentId, sessionId) {
+        return this.supervisorSubscriptions.has(`${agentId}:*`) ||
+            (sessionId !== null && this.supervisorSubscriptions.has(`${agentId}:${sessionId}`));
+    }
+    registerSupervisor(agentId, capabilities, writeFn) {
+        this.supervisorAgentId = agentId;
+        this.supervisorWrite = writeFn;
+        this.supervisorSubscriptions.clear();
+        this.logger.info({ agentId, capabilities }, 'Supervisor registered');
+    }
+    handleSupervisorDetach() {
+        this.logger.info({ agentId: this.supervisorAgentId }, 'Supervisor detached');
+        this.supervisorSubscriptions.clear();
+        this.supervisorWrite = null;
+        this.supervisorAgentId = null;
+    }
+    handleSupervisorLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            this.sendToSupervisor({ type: 'error', message: 'Invalid JSON' });
+            return;
+        }
+        // Handle responses to commands we sent to the supervisor (e.g. exec results)
+        if (msg.type === 'response' && msg.requestId) {
+            const pending = this.supervisorPendingRequests.get(msg.requestId);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.supervisorPendingRequests.delete(msg.requestId);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+            return;
+        }
+        if (msg.type !== 'command' || !msg.action) {
+            this.sendToSupervisor({ type: 'error', message: 'Expected {type:"command", action:"..."}' });
+            return;
+        }
+        const requestId = msg.requestId;
+        const params = msg.params ?? {};
+        try {
+            const result = this.handleSupervisorCommand(msg.action, params);
+            this.sendToSupervisor({ type: 'response', requestId, result });
+        }
+        catch (err) {
+            this.sendToSupervisor({ type: 'response', requestId, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    handleSupervisorCommand(action, params) {
+        switch (action) {
+            case 'ping':
+                return { pong: true, uptime: process.uptime() };
+            // ── Phase 2: Ephemeral agents ──
+            case 'create_agent': {
+                const agentId = params.agentId || `oc-spawn-${randomUUID().slice(0, 8)}`;
+                const repo = params.repo;
+                if (!repo)
+                    throw new Error('Missing required param: repo');
+                if (this.agents.has(agentId)) {
+                    throw new Error(`Agent already exists: ${agentId}`);
+                }
+                // Map supervisor permissionMode to CC permissionMode
+                let permMode = 'default';
+                const reqPerm = params.permissionMode;
+                if (reqPerm === 'bypassPermissions' || reqPerm === 'dangerously-skip')
+                    permMode = 'dangerously-skip';
+                else if (reqPerm === 'acceptEdits')
+                    permMode = 'acceptEdits';
+                else if (reqPerm === 'plan')
+                    permMode = 'plan';
+                const ephemeralConfig = {
+                    botToken: '',
+                    allowedUsers: [],
+                    defaults: {
+                        model: params.model || 'sonnet',
+                        repo,
+                        maxTurns: 200,
+                        idleTimeoutMs: 300_000,
+                        hangTimeoutMs: 300_000,
+                        permissionMode: permMode,
+                    },
+                };
+                const instance = {
+                    id: agentId,
+                    config: ephemeralConfig,
+                    tgBot: null,
+                    ephemeral: true,
+                    repo,
+                    model: ephemeralConfig.defaults.model,
+                    ccProcess: null,
+                    accumulator: null,
+                    subAgentTracker: null,
+                    batcher: null,
+                    pendingPermissions: new Map(),
+                    typingInterval: null,
+                    typingChatId: null,
+                    pendingSessionId: null,
+                    destroyTimer: null,
+                    eventBuffer: new EventBuffer(),
+                };
+                // Auto-destroy timer
+                const timeoutMs = params.timeoutMs;
+                if (timeoutMs && timeoutMs > 0) {
+                    instance.destroyTimer = setTimeout(() => {
+                        this.logger.info({ agentId, timeoutMs }, 'Ephemeral agent timeout — auto-destroying');
+                        this.destroyEphemeralAgent(agentId);
+                    }, timeoutMs);
+                }
+                this.agents.set(agentId, instance);
+                this.logger.info({ agentId, repo, model: instance.model, ephemeral: true }, 'Ephemeral agent created');
+                // Emit agent_created event (always sent, not subscription-gated)
+                this.sendToSupervisor({ type: 'event', event: 'agent_created', agentId, agentType: 'ephemeral', repo });
+                return { agentId, state: 'idle' };
+            }
+            case 'destroy_agent': {
+                const agentId = params.agentId;
+                if (!agentId)
+                    throw new Error('Missing agentId');
+                const agent = this.agents.get(agentId);
+                if (!agent)
+                    throw new Error(`Unknown agent: ${agentId}`);
+                if (!agent.ephemeral)
+                    throw new Error(`Cannot destroy persistent agent: ${agentId}`);
+                this.destroyEphemeralAgent(agentId);
+                return { destroyed: true };
+            }
+            // ── Phase 1: Send + Subscribe ──
+            case 'send_message': {
+                const agentId = params.agentId;
+                const text = params.text;
+                if (!agentId || !text)
+                    throw new Error('Missing agentId or text');
+                const agent = this.agents.get(agentId);
+                if (!agent)
+                    throw new Error(`Unknown agent: ${agentId}`);
+                // Auto-subscribe supervisor
+                this.supervisorSubscriptions.add(`${agentId}:*`);
+                // For persistent agents: route supervisor message through the accumulator so it
+                // appears inline in the current bubble. Fall back to a standalone silent message
+                // if no accumulator is active or the previous turn is already sealed (agent idle).
+                if (agent.accumulator && !agent.accumulator.sealed) {
+                    agent.accumulator.addSupervisorMessage(text);
+                }
+                else {
+                    const tgChatId = this.getAgentChatId(agent);
+                    if (tgChatId && agent.tgBot) {
+                        const preview = text.length > 500 ? text.slice(0, 500) + '…' : text;
+                        agent.tgBot.sendText(tgChatId, `<blockquote>🦞 ${escapeHtml(preview)}</blockquote>`, 'HTML', true) // silent
+                            .catch(err => this.logger.error({ err, agentId }, 'Failed to send supervisor TG notification'));
+                    }
+                }
+                // Send to agent's single CC process
+                this.sendToCC(agentId, { text }, { spawnSource: 'supervisor' });
+                return {
+                    sessionId: agent.ccProcess?.sessionId ?? null,
+                    state: agent.ccProcess?.state ?? 'spawning',
+                    subscribed: true,
+                };
+            }
+            case 'send_to_cc': {
+                const agentId = params.agentId;
+                const text = params.text;
+                if (!agentId || !text)
+                    throw new Error('Missing agentId or text');
+                const agent = this.agents.get(agentId);
+                if (!agent)
+                    throw new Error(`Unknown agent: ${agentId}`);
+                if (!agent.ccProcess || agent.ccProcess.state === 'idle') {
+                    throw new Error(`No active CC process for agent ${agentId}`);
+                }
+                agent.ccProcess.sendMessage(createTextMessage(text));
+                return { sent: true };
+            }
+            case 'subscribe': {
+                const agentId = params.agentId;
+                const sessionId = params.sessionId;
+                if (!agentId)
+                    throw new Error('Missing agentId');
+                const key = sessionId ? `${agentId}:${sessionId}` : `${agentId}:*`;
+                this.supervisorSubscriptions.add(key);
+                return { subscribed: true, key };
+            }
+            case 'unsubscribe': {
+                const agentId = params.agentId;
+                if (!agentId)
+                    throw new Error('Missing agentId');
+                // Remove all subscriptions for this agent
+                for (const key of [...this.supervisorSubscriptions]) {
+                    if (key.startsWith(`${agentId}:`)) {
+                        this.supervisorSubscriptions.delete(key);
+                    }
+                }
+                return { unsubscribed: true };
+            }
+            case 'status': {
+                const filterAgentId = params.agentId;
+                const agents = [];
+                const agentIds = filterAgentId ? [filterAgentId] : [...this.agents.keys()];
+                for (const id of agentIds) {
+                    const agent = this.agents.get(id);
+                    if (!agent)
+                        continue;
+                    const state = agent.ccProcess?.state ?? 'idle';
+                    const sessionId = agent.ccProcess?.sessionId ?? null;
+                    agents.push({
+                        id,
+                        type: agent.ephemeral ? 'ephemeral' : 'persistent',
+                        state,
+                        repo: agent.repo,
+                        process: agent.ccProcess ? { sessionId, model: agent.model } : null,
+                        supervisorSubscribed: this.isSupervisorSubscribed(id, sessionId),
+                    });
+                }
+                return { agents };
+            }
+            case 'kill_cc': {
+                const agentId = params.agentId;
+                if (!agentId)
+                    throw new Error('Missing agentId');
+                const agent = this.agents.get(agentId);
+                if (!agent)
+                    throw new Error(`Unknown agent: ${agentId}`);
+                const killed = agent.ccProcess != null && agent.ccProcess.state !== 'idle';
+                if (killed) {
+                    this.killAgentProcess(agentId);
+                }
+                return { killed };
+            }
+            // ── Phase A: Observability ──
+            case 'get_log': {
+                const agentId = params.agentId;
+                if (!agentId)
+                    throw new Error('Missing agentId');
+                const agent = this.agents.get(agentId);
+                if (!agent)
+                    throw new Error(`Unknown agent: ${agentId}`);
+                return agent.eventBuffer.query({
+                    offset: params.offset,
+                    limit: params.limit,
+                    grep: params.grep,
+                    since: params.since,
+                    type: params.type,
+                });
+            }
+            case 'permission_response': {
+                const agentId = params.agentId;
+                const permissionRequestId = params.permissionRequestId;
+                const decision = params.decision;
+                if (!agentId || !permissionRequestId || !decision) {
+                    throw new Error('Missing agentId, permissionRequestId, or decision');
+                }
+                const agent = this.agents.get(agentId);
+                if (!agent)
+                    throw new Error(`Unknown agent: ${agentId}`);
+                const pending = agent.pendingPermissions.get(permissionRequestId);
+                if (!pending)
+                    throw new Error(`No pending permission with id: ${permissionRequestId}`);
+                const allow = decision === 'allow';
+                if (agent.ccProcess) {
+                    agent.ccProcess.respondToPermission(permissionRequestId, allow);
+                }
+                agent.pendingPermissions.delete(permissionRequestId);
+                return { responded: true, decision };
+            }
+            default:
+                throw new Error(`Unknown supervisor action: ${action}`);
+        }
+    }
+    emitStateChanged(agentId, field, oldValue, newValue, source) {
+        this.logger.info({ agentId, field, oldValue, newValue, source }, 'Agent state changed');
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.eventBuffer.push({ ts: Date.now(), type: 'system', text: `State changed: ${field} → ${newValue}` });
+        }
+        if (this.isSupervisorSubscribed(agentId, agent?.ccProcess?.sessionId ?? null)) {
+            this.sendToSupervisor({
+                type: 'event',
+                event: 'state_changed',
+                agentId,
+                field,
+                oldValue,
+                newValue,
+                source,
+            });
+        }
+    }
+    sendToSupervisor(msg) {
+        if (this.supervisorWrite) {
+            try {
+                this.supervisorWrite(JSON.stringify(msg) + '\n');
+            }
+            catch { }
+        }
+    }
+    sendSupervisorRequest(msg, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const requestId = msg.requestId ?? '';
+            const timer = setTimeout(() => {
+                this.supervisorPendingRequests.delete(requestId);
+                reject(new Error('Supervisor request timed out'));
+            }, timeoutMs);
+            this.supervisorPendingRequests.set(requestId, { resolve, reject, timer });
+            this.sendToSupervisor(msg);
+        });
+    }
+    destroyEphemeralAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent || !agent.ephemeral)
+            return;
+        this.killAgentProcess(agentId);
+        this.agents.delete(agentId);
+        this.logger.info({ agentId }, 'Ephemeral agent destroyed');
+        this.sendToSupervisor({ type: 'event', event: 'agent_destroyed', agentId });
+    }
     // ── Shutdown ──
     async stop() {
         this.logger.info('Stopping bridge');
@@ -1578,6 +1843,7 @@ export class Bridge extends EventEmitter {
             await this.stopAgent(agentId);
         }
         this.processRegistry.clear();
+        this.highSignalDetector.destroy();
         this.mcpServer.closeAll();
         this.ctlServer.closeAll();
         this.removeAllListeners();