@0xmaxma/claude-gateway 2.0.3 → 2.0.5

package/dist/agent/runner.js

@@ -35,6 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRunner = exports.CHANNEL_COALESCE_WINDOW_MS = exports.WHATSAPP_CLOUD_WINDOW_NOTE = exports.DEFAULT_MODELS = exports.MAX_IMAGE_SIZE_BYTES = void 0;
 exports.toRelMediaFiles = toRelMediaFiles;
+const response_errors_1 = require("../orchestration/response-errors");
+const channel_media_error_1 = require("../orchestration/channel-media-error");
+const store_1 = require("../orchestration/store");
+const config_1 = require("../orchestration/config");
 const channel_input_media_1 = require("../orchestration/channel-input-media");
 const chunks_1 = require("../telegram/chunks");
 const file_delivery_1 = require("../orchestration/file-delivery");
@@ -53,8 +57,8 @@ const path = __importStar(require("path"));
 const config_write_lock_1 = require("../config/config-write-lock");
 const logger_1 = require("../logger");
 const process_1 = require("../session/process");
-const store_1 = require("../session/store");
-const compactor_1 = require("../session/compactor");
+const store_2 = require("../session/store");
+const native_compact_1 = require("../orchestration/native-compact");
 const receiver_1 = require("../telegram/receiver");
 const receiver_2 = require("../discord/receiver");
 const line_reply_manager_1 = require("./line-reply-manager");
@@ -71,7 +75,7 @@ const skills_1 = require("../skills");
 const builtin_commands_1 = require("./builtin-commands");
 const model_catalog_1 = require("./model-catalog");
 const safe_mode_1 = require("./safe-mode");
-const config_1 = require("./skill-learning/config");
+const config_2 = require("./skill-learning/config");
 const turn_stream_1 = require("./turn-stream");
 const recovery_executor_1 = require("./recovery-executor");
 const recovery_policy_1 = require("./recovery-policy");
@@ -346,9 +350,21 @@ class AgentRunner extends events_1.EventEmitter {
     async subscribeResponseText(sessionId, principalId, receive) {
         return (await this.getOrchestration()).subscribeText(sessionId, principalId, receive);
     }
+    async setBrowserVoice(sessionId, principalId, enabled) {
+        return (await this.getOrchestration()).setBrowserVoice(sessionId, principalId, enabled);
+    }
+    async pendingVoiceSpeech(sessionId, principalId, claimed = []) {
+        return (await this.getOrchestration()).pendingVoiceSpeech(sessionId, principalId, claimed);
+    }
     async voiceReplay(sessionId, principalId, responseId) {
         return (await this.getOrchestration()).voiceAudio(sessionId, principalId, responseId);
     }
+    async replayableVoiceResponses(sessionId, principalId) {
+        return (await this.getOrchestration()).replayableVoiceResponses(sessionId, principalId);
+    }
+    async voiceReplaySpeech(sessionId, principalId, responseId) {
+        return (await this.getOrchestration()).voiceReplaySpeech(sessionId, principalId, responseId);
+    }
     saveVoiceReplay(sessionId, principalId, responseId, audio) {
         this.orchestration?.saveVoiceAudio(sessionId, principalId, responseId, audio);
     }
@@ -640,6 +656,7 @@ class AgentRunner extends events_1.EventEmitter {
                 }
             });
         };
+        this.compactingSessions = new Set();
         this.telegramCommandConfig = '';
         this.agentConfig = (0, gateway_config_1.applyGatewayOrchestration)(agentConfig, gatewayConfig);
         this.gatewayConfig = gatewayConfig;
@@ -650,7 +667,7 @@ class AgentRunner extends events_1.EventEmitter {
         // agentDir is workspace/.. — used for HistoryDB so DB is at <agentDir>/history.db
         // This avoids requiring workspace to be nested at exactly <base>/<agentId>/workspace.
         this.agentDir = path.resolve(agentConfig.workspace, '..');
-        this.sessionStore = new store_1.SessionStore(agentsBaseDir);
+        this.sessionStore = new store_2.SessionStore(agentsBaseDir);
         // config.json lives 3 levels above workspace: <base>/<agentId>/workspace -> <base>/config.json
         this.configPath = path.resolve(agentConfig.workspace, '..', '..', '..', 'config.json');
         this.historyDb = db_1.HistoryDB.forDir(this.agentDir, agentConfig.id);
@@ -746,6 +763,47 @@ class AgentRunner extends events_1.EventEmitter {
                     const channelSource = ((0, types_1.isChatChannel)(meta['source']) ? meta['source'] : 'telegram');
                     this.channelSourceMap.set(chatId, channelSource);
                     const channelOrchestration = this.orchestration?.ownsChannel(channelSource, chatId) || (this.agentConfig.orchestration?.enabled && (this.agentConfig.orchestration.channels ?? ['api']).includes(channelSource));
+                    // Resolve a receiver receipt before fetching media again: an ACK may have
+                    // been lost after the original file was admitted or staging was removed.
+                    let ingress;
+                    if (channelOrchestration || meta.ingress_recovery_batch) {
+                        const sessionId = await this.sessionStore.getActiveSessionId(this.agentConfig.id, chatId, channelSource);
+                        const runtime = await this.getOrchestration();
+                        const senderId = meta.user_id ?? meta.user ?? chatId;
+                        const scope = { agentId: this.agentConfig.id, agentSessionId: sessionId, source: channelSource,
+                            accountId: this.agentConfig.id, chatId, threadKey: channelSource === 'whatsapp' && meta.account_id ? `whatsapp-account:${meta.account_id}` : meta.thread_ts ?? meta.message_thread_id ?? '', principalId: `${channelSource}:${senderId}` };
+                        const { ingress_recovery_batch, ...originalMeta } = meta;
+                        let recoveryBatch = ingress_recovery_batch, recoveryKey = meta.message_id;
+                        const fingerprint = (0, store_1.payloadHash)({ content, meta: originalMeta });
+                        const platformMessageIds = meta.message_ids_json ? JSON.parse(meta.message_ids_json) : undefined;
+                        ingress = { runtime, scope, fingerprint, platformMessageIds };
+                        const prior = runtime.store.channelReceipt(scope, meta.message_id, fingerprint, platformMessageIds);
+                        if (prior && !prior.envelopeConflict) {
+                            res.writeHead(200);
+                            res.end('ok');
+                            return;
+                        }
+                        if (prior?.envelopeConflict) {
+                            // Keep changed/legacy album envelopes without repeating accepted work.
+                            recoveryKey = `channel-recovery:${fingerprint}`;
+                            recoveryBatch = `conflict:${(0, store_1.payloadHash)(meta.message_id)}`;
+                            const recovered = runtime.store.channelReceipt(scope, recoveryKey, fingerprint);
+                            if (recovered && !recovered.envelopeConflict) {
+                                res.writeHead(200);
+                                res.end('recovered');
+                                return;
+                            }
+                        }
+                        if (recoveryBatch) {
+                            runtime.recoverChannelInput({ scope, text: `[Recovered queued message; not executed. A fresh request is required.]\n${content}`,
+                                ingressKey: recoveryKey, trustedChannelMember: true,
+                                metadata: { channelIngressFingerprint: fingerprint, recoveryBatch, recoveredChannelInput: { content, meta: originalMeta },
+                                    platformMessageId: meta.message_id, senderId, senderName: meta.sender_name } });
+                            res.writeHead(200);
+                            res.end('recovered');
+                            return;
+                        }
+                    }
                     if (channelSource !== 'telegram' && this.agentConfig.orchestration?.enabled && (this.agentConfig.orchestration.channels ?? ['api']).includes(channelSource) && /^\/sessions?(?:\s|$)/.test(content.trim())) {
                         const index = await this.sessionStore.listSessions(this.agentConfig.id, chatId, channelSource);
                         const current = index.sessions.find(session => session.id === index.activeSessionId);
@@ -805,16 +863,18 @@ class AgentRunner extends events_1.EventEmitter {
                         }
                     }
                     if (channelOrchestration && !(0, builtin_commands_1.isBuiltinCommand)(content.trim(), channelSource)) {
-                        const sessionId = await this.sessionStore.getActiveSessionId(this.agentConfig.id, chatId, channelSource);
-                        const orchestration = await this.getOrchestration();
-                        const { media, quoted, details } = await (0, channel_input_media_1.channelInputMedia)(this.agentConfig, this.agentsBaseDir, channelSource, chatId, meta, AgentRunner.discardEphemeralStaging);
+                        const orchestration = ingress.runtime;
+                        const cleanup = [];
+                        const { media, quoted, details, unavailable, primaryDirectMedia } = await (0, channel_input_media_1.channelInputMedia)(this.agentConfig, this.agentsBaseDir, channelSource, chatId, meta, path => cleanup.push(path));
                         const senderId = meta.user_id ?? meta.user ?? chatId;
-                        const accepted = orchestration.submitInput({ scope: { agentId: this.agentConfig.id, agentSessionId: sessionId, source: channelSource,
-                                accountId: this.agentConfig.id, chatId, threadKey: channelSource === 'whatsapp' && meta.account_id ? `whatsapp-account:${meta.account_id}` : meta.thread_ts ?? meta.message_thread_id ?? '', principalId: `${channelSource}:${senderId}` },
-                            text: content || '[Attachment inspection requested]', attachmentIds: media, trustedChannelMember: true,
-                            modality: ['voice', 'audio'].includes(meta.media_type ?? meta.attachment_kind) ? 'voice_note' : 'text',
-                            ingressKey: meta.message_id, metadata: { senderId, senderName: meta.sender_name, platformMessageId: meta.message_id, platformMessageIds: meta.message_ids_json ? JSON.parse(meta.message_ids_json) : undefined, mediaGroupId: meta.media_group_id,
+                        const voiceNote = Boolean(primaryDirectMedia && ['voice', 'audio'].includes(meta.media_type ?? meta.attachment_kind));
+                        const accepted = orchestration.submitInput({ scope: ingress.scope,
+                            text: content || '[Attachment inspection requested]', attachmentIds: voiceNote ? [primaryDirectMedia, ...media.filter(ref => ref !== primaryDirectMedia)] : media, trustedChannelMember: true,
+                            modality: voiceNote ? 'voice_note' : 'text',
+                            ingressKey: meta.message_id, metadata: { channelIngressFingerprint: ingress.fingerprint, unavailableAttachments: unavailable, senderId, senderName: meta.sender_name, platformMessageId: meta.message_id, platformMessageIds: ingress.platformMessageIds, mediaGroupId: meta.media_group_id,
                                 attachmentName: meta.attachment_name, mediaType: meta.media_type ?? meta.attachment_kind, repliedText: meta.replied_text, repliedMessageId: meta.replied_message_id, repliedSender: meta.replied_user, repliedAttachmentIds: quoted, attachmentDetails: details, attachmentError: meta.attachment_error } }, { execute: this.agentConfig.allow_tools !== false, writeMemory: this.agentConfig.allow_tools !== false });
+                        for (const path of cleanup)
+                            AgentRunner.discardEphemeralStaging(path);
                         // The durable receipt precedes receiver acknowledgment and inference.
                         res.writeHead(200);
                         res.end('ok');
@@ -862,6 +922,7 @@ class AgentRunner extends events_1.EventEmitter {
                             .then(() => this.writeTypingDone(chatId))
                             .catch((err) => {
                             this.logger.error('Session command failed', { error: err.message });
+                            this.writeAutoForward(chatId, 'Command failed: ' + err.message);
                             this.writeTypingDone(chatId);
                         });
                         return;
@@ -894,13 +955,15 @@ class AgentRunner extends events_1.EventEmitter {
                     return;
                 }
                 catch (err) {
+                    const mediaError = err instanceof channel_media_error_1.ChannelMediaError ? err : undefined;
+                    const code = mediaError?.code ?? (err instanceof SyntaxError ? 'INVALID_CALLBACK_JSON' : 'CHANNEL_ADMISSION_FAILED');
                     if (!res.headersSent) {
-                        res.writeHead(503);
-                        res.end('Channel input was not accepted');
+                        if (mediaError?.retryAfterMs !== undefined)
+                            res.setHeader('Retry-After', String(Math.ceil(mediaError.retryAfterMs / 1000)));
+                        res.writeHead(err instanceof SyntaxError ? 400 : mediaError?.status === 429 ? 429 : 503);
+                        res.end(JSON.stringify({ accepted: false, code, retryable: !(err instanceof SyntaxError) }));
                     }
-                    this.logger.warn('Failed to parse channel callback body', {
-                        error: err.message,
-                    });
+                    this.logger.warn('Channel callback admission failed', { code, retryable: !(err instanceof SyntaxError), inputHash: (0, store_1.payloadHash)(raw).slice(0, 16) });
                 }
             });
         });
@@ -1328,7 +1391,7 @@ class AgentRunner extends events_1.EventEmitter {
                 return;
             }
             const restarted = await this.restartChannelSessions();
-            respond({ success: true, model: newModel, restarted });
+            respond({ success: true, model: newModel, restarted, appliesNextTurn: !restarted });
             return;
         }
         if (command === 'restart') {
@@ -2142,6 +2205,7 @@ class AgentRunner extends events_1.EventEmitter {
         // size when the cap has been lowered.
         const recoveryCount = this.tooLargeRecoveries.get(mapKey) ?? 0;
         proc.historyLimit = this.spawnHistoryLimit(configuredMax, recoveryCount);
+        proc.historyRecoveryActive = recoveryCount > 0;
         if (recoveryCount > 0) {
             this.logger.info('Spawning with reduced history after request_too_large', {
                 mapKey, recoveryCount, historyLimit: proc.historyLimit,
@@ -2753,6 +2817,7 @@ class AgentRunner extends events_1.EventEmitter {
         }
         else if (content.startsWith('/clear')) {
             await this.handleCommandClear(agentId, chatId);
+            this.writeAutoForward(chatId, 'Claude Code context reset. Chat history is unchanged. The next message loads the latest 50 messages.');
         }
         else if (content.startsWith('/compact')) {
             await this.handleCommandCompact(agentId, chatId);
@@ -2822,7 +2887,7 @@ class AgentRunner extends events_1.EventEmitter {
         }
         if (!this.isDirectChat(meta)) {
             this.writeAutoForward(chatId, 'Switching models is only available in a direct message with the bot — '
-                + 'it changes the model for every chat of this agent and restarts them. '
+                + 'it changes the model for every chat of this agent. '
                 + 'Use /models here to see the list.');
             return;
         }
@@ -2838,10 +2903,10 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         await this.setModel(match.id);
-        // Same restart the Telegram picker's set_model does — the running session
-        // was spawned with the old model and would otherwise keep using it.
+        // Legacy sessions need respawning; managed decisions pick up the new model
+        // on their next spawn without terminating the response in progress.
         const restarted = await this.restartChannelSessions();
-        this.writeAutoForward(chatId, `Model set to ${match.label} (${match.id}).${restarted ? ' Restarting the session…' : ''}`);
+        this.writeAutoForward(chatId, `Model set to ${match.label} (${match.id}).${restarted ? ' Restarting the session…' : ' Applies to the next response; current work continues.'}`);
     }
     /**
      * /sessions — list all sessions for this chat.
@@ -2958,87 +3023,76 @@ class AgentRunner extends events_1.EventEmitter {
         const stopped = interrupted || hadActive || hadQueued || !!buffered;
         this.writeAutoForward(chatId, stopped ? 'Stopped.' : 'No turn in progress.');
     }
-    /**
-     * /clear — clear history of the current session and restart the process.
-     * Also clears the permanent history DB and media files for this chat.
-     */
+    /** /clear rotates model context while preserving history, media and tasks. */
+    async clearContext(sessionId) {
+        if (this.compactingSessions.has(sessionId))
+            throw new Error('Context maintenance is already running for this session.');
+        this.compactingSessions.add(sessionId);
+        try {
+            const runtime = this.orchestration ?? (this.agentConfig.orchestration?.enabled ? await this.getOrchestration() : undefined);
+            if (runtime?.isBusy(sessionId))
+                throw new Error('The agent is responding. Try /clear after the current response finishes.');
+            const sessions = [...this.sessions.entries()].filter(([, process]) => process.sessionId === sessionId);
+            if (sessions.some(([, process]) => process.isProcessing))
+                throw new Error('The agent is responding. Try /clear after the current response finishes.');
+            for (const [key, process] of sessions) {
+                await process.stop();
+                if (this.sessions.get(key) === process)
+                    this.sessions.delete(key);
+            }
+            // No await between persisting the seed window and dropping the resume mapping.
+            // The marker survives gateway restarts until a successful turn consumes it.
+            if (runtime?.isBusy(sessionId))
+                throw new Error('The agent is responding. Try /clear after the current response finishes.');
+            this.sessionStore.requestContextReset(this.agentConfig.id, sessionId);
+            if (runtime?.ownsSession(sessionId))
+                runtime.resetSessionContext(sessionId);
+            for (const key of [sessionId, ...sessions.map(([key]) => key)]) {
+                this.tooLargeRecoveries.delete(key);
+                this.tooLargeExhausted.delete(key);
+            }
+        }
+        finally {
+            this.compactingSessions.delete(sessionId);
+        }
+    }
     async handleCommandClear(agentId, chatId) {
-        const ch = this.channelFor(chatId);
-        const sessionId = await this.sessionStore.getActiveSessionId(agentId, chatId, ch);
-        // Clear messages and reset all metadata in-place (preserves session ID and name)
-        await this.sessionStore.clearTelegramSessionHistory(agentId, chatId, sessionId, ch);
-        await this.sessionStore.updateSessionMeta(agentId, chatId, sessionId, {
-            totalTokensUsed: 0,
-            lastInputTokens: 0,
-            archivedCount: 0,
-            loadedAtSpawn: undefined,
-            messageCountAtSpawn: undefined,
-        }, ch);
-        // Clear permanent history DB for this chat
-        const historyChatId = `${ch}-${chatId}`;
-        this.historyDb.clearChat(historyChatId);
-        // Delete persisted media files for this chat
-        media_store_1.MediaStore.clearChatMedia(this.agentsBaseDir, agentId, historyChatId);
-        // Reset any request_too_large escalation — the context is now empty, so the
-        // next spawn should start fresh at the top of the history ladder.
-        this.tooLargeRecoveries.delete(chatId);
-        this.tooLargeExhausted.delete(chatId);
-        // Kill old process so next message spawns fresh
-        this.restartProcess(chatId).catch(() => { });
+        const sessionId = await this.sessionStore.getActiveSessionId(agentId, chatId, this.channelFor(chatId));
+        await this.clearContext(sessionId);
+    }
+    /** Native CLI compaction leaves canonical chat history intact. */
+    async compactContext(sessionId, model) {
+        if (this.compactingSessions.has(sessionId))
+            throw new Error('Context compaction is already running for this session.');
+        this.compactingSessions.add(sessionId);
+        try {
+            const runtime = this.orchestration ?? (this.agentConfig.orchestration?.enabled ? await this.getOrchestration() : undefined);
+            if (runtime?.ownsSession(sessionId))
+                return await runtime.compactSession(sessionId, model);
+            const process = [...this.sessions.values()].find(p => p.sessionId === sessionId && p.isRunning());
+            if (!process)
+                throw new Error('No active Claude Code context to compact. Send a message first; chat history was not changed.');
+            if (process.isProcessing)
+                throw new Error('The agent is responding. Try /compact after the current response finishes.');
+            if (this.gatewayConfig.gateway.headless === false)
+                throw new Error('Native /compact currently requires the headless Claude Code backend. Chat history was not changed.');
+            await (0, native_compact_1.startNativeCompact)(process, true).result;
+        }
+        finally {
+            this.compactingSessions.delete(sessionId);
+        }
     }
-    /**
-     * /compact — summarise old history and keep only recent messages.
-     */
     async handleCommandCompact(agentId, chatId) {
         const ch = this.channelFor(chatId);
         const sessionId = await this.sessionStore.getActiveSessionId(agentId, chatId, ch);
-        const index = await this.sessionStore.listSessions(agentId, chatId, ch);
-        const meta = index.sessions.find(s => s.id === sessionId);
-        const name = meta?.name ?? 'Session';
-        const compactModel = this.agentConfig.claude.model;
-        const contextWindow = await this.contextWindowFor(compactModel);
-        this.writeAutoForward(chatId, `⏳ Compacting session "${name}"...`);
+        this.writeAutoForward(chatId, '⏳ Compacting Claude Code context…');
         try {
-            const compactor = new compactor_1.SessionCompactor(this.sessionStore);
-            // Large sessions summarize in many chunks (see compactor.ts); post a status
-            // update at each ~25% step so the channel doesn't look dead mid-compact.
-            // Throttled (not per-chunk) to avoid spamming the chat on a 16+ chunk job.
-            let lastReportedPct = -1;
-            const onProgress = (done, total) => {
-                if (total <= 1)
-                    return;
-                const pct = Math.floor((done / total) * 100);
-                if (pct - lastReportedPct >= 25) {
-                    lastReportedPct = pct;
-                    this.writeAutoForward(chatId, `⏳ Compacting session "${name}"... ${done}/${total} parts summarized`);
-                }
-            };
-            const result = await compactor.compact(agentId, chatId, sessionId, compactModel, contextWindow, ch, onProgress);
-            await this.sessionStore.updateSessionMeta(agentId, chatId, sessionId, {
-                loadedAtSpawn: undefined,
-                archivedCount: undefined,
-                messageCountAtSpawn: undefined,
-            }, ch);
-            await this.restartProcess(chatId);
-            const summary = [
-                `✅ Session compacted`,
-                '',
-                `Before: ${result.beforeMessages} messages (~${result.beforeTokens.toLocaleString()} tokens)  →  ${result.contextPctBefore}% of context`,
-                `After:  ${result.afterMessages} messages (~${result.afterTokens.toLocaleString()} tokens)   →  ${result.contextPctAfter}% of context`,
-                `Reduced by: ${result.reductionPct}%`,
-                '',
-                'Summary preserved. Full history before compaction is archived.',
-            ].join('\n');
-            this.writeAutoForward(chatId, summary);
+            await this.compactContext(sessionId);
+            this.writeAutoForward(chatId, '✅ Claude Code context compacted. Chat history is unchanged.');
         }
         catch (err) {
-            if (err.name === 'NotEnoughMessagesError') {
-                this.writeAutoForward(chatId, `⚠️ ${err.message}`);
-            }
-            else {
-                this.logger.error('Compact failed', { error: err.message });
-                this.writeAutoForward(chatId, `❌ Compact failed: ${err.message}\n\nYour session history is unchanged.`);
-            }
+            this.logger.error('Compact failed', { error: err.message });
+            this.writeAutoForward(chatId, 'Context compaction failed: ' + err.message + '\nChat history is unchanged.');
         }
     }
     /**
@@ -4114,9 +4168,9 @@ class AgentRunner extends events_1.EventEmitter {
         // Each precedence level is validated in turn — an invalid-but-present
         // cleanupTimezone does not count as "set" and falls through to gw.timezone
         // rather than jumping straight to UTC (issue #462 review).
-        const cleanupTimezone = (0, config_1.isValidTimezone)(gw.history?.cleanupTimezone)
+        const cleanupTimezone = (0, config_2.isValidTimezone)(gw.history?.cleanupTimezone)
             ? gw.history.cleanupTimezone
-            : (0, config_1.isValidTimezone)(gw.timezone)
+            : (0, config_2.isValidTimezone)(gw.timezone)
                 ? gw.timezone
                 : 'UTC';
         const agentMediaRoot = media_store_1.MediaStore.agentMediaRoot(this.agentsBaseDir, this.agentConfig.id);
@@ -4138,6 +4192,23 @@ class AgentRunner extends events_1.EventEmitter {
     isRunning() {
         return this.receiver?.isRunning() ?? false;
     }
+    getDashboardSource() {
+        return { workspace: this.agentConfig.type === 'app-agent' ? undefined : this.agentConfig.workspace, filename: path.join(this.agentDir, 'orchestration.db'), historyFilename: path.join(this.agentDir, 'history.db'),
+            enabled: Boolean(this.orchestration || this.agentConfig.orchestration?.enabled),
+            workspaceMode: this.agentConfig.type === 'app-agent' ? 'container' : this.agentConfig.orchestration?.tasks?.workspaceMode ?? 'host',
+            maxWorkers: this.agentConfig.orchestration?.tasks?.maxConcurrentPerAgent ?? config_1.ORCHESTRATION_DEFAULTS.tasks.maxConcurrentPerAgent,
+            idleTtlMs: this.agentConfig.orchestration?.tasks?.workerIdleTtlMs ?? config_1.ORCHESTRATION_DEFAULTS.tasks.workerIdleTtlMs };
+    }
+    async dashboardContextWindow(model) {
+        const models = await this.availableModels();
+        return models.find(m => m.id === model)?.contextWindow
+            ?? (this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).find(m => m.id === model)?.contextWindow
+            ?? null;
+    }
+    getTokenReport(sessionId) {
+        const report = this.orchestration?.tokenReport(sessionId);
+        return report ? { ...report, backgroundReviews: this.historyDb.listReviewRuns().filter(run => run.sessionId === sessionId) } : undefined;
+    }
     getOrchestrationSummary() {
         if (!this.agentConfig.orchestration?.enabled && !this.orchestration)
             return undefined;
@@ -4177,6 +4248,29 @@ class AgentRunner extends events_1.EventEmitter {
         }
         return out;
     }
+    /**
+     * Session IDs currently alive in the in-memory session map. Display-only
+     * liveness signal for the dashboard: a session removed by the idle cleaner
+     * (kept-alive window elapsed) or released is no longer present here.
+     */
+    liveSessionIds() {
+        return [...this.sessions.values()].filter(p => p.isRunning()).map(p => p.sessionId);
+    }
+    /**
+     * Live status of one agent session derived from the in-memory session map:
+     * - 'running' → alive and processing a turn right now
+     * - 'idle'    → alive and kept warm, not currently processing
+     * - 'stopped' → gone from the map (idle-timeout kill or otherwise released)
+     * Display-only; does not touch token accounting.
+     */
+    isSessionCompacting(sessionId) { return this.orchestration?.isCompacting(sessionId) ?? false; }
+    agentSessionLiveStatus(sessionId) {
+        for (const p of this.sessions.values()) {
+            if (p.sessionId === sessionId && p.isRunning())
+                return p.isProcessing ? 'running' : 'idle';
+        }
+        return 'stopped';
+    }
     /**
      * Send a message to an API session and wait for the response.
      *
@@ -4479,7 +4573,10 @@ class AgentRunner extends events_1.EventEmitter {
             void this.sendOrchestratedApi(sessionId, chatId, message, { ...opts, requestId: turn.requestId }, text => turn.emit({ type: 'text_delta', text }), event => { if (event.type === 'tool_use')
                 turn.emit({ ...event, type: 'tool_use' }); })
                 .then(result => this.turnStreams.complete(turn, (0, turn_stream_1.resultEvent)(result.text, result.attachments)))
-                .catch(error => this.turnStreams.complete(turn, (0, turn_stream_1.errorEvent)(error), error));
+                .catch(error => {
+                const publicError = (0, response_errors_1.presentedResponseError)(error);
+                this.turnStreams.complete(turn, (0, turn_stream_1.errorEvent)(publicError), publicError);
+            });
             return () => turn.detach(sink);
         }
         if (this.pendingApiSessions.has(sessionId)) {
@@ -4975,10 +5072,7 @@ class AgentRunner extends events_1.EventEmitter {
             this.historyDb.insertMessage({ chatId: dbChatId, sessionId, source: 'api', role, content, ts: Date.now() });
         };
         // Persist the full user command before executing so it appears in history.
-        // Skip for /clear — clearSession() below wipes the table anyway; only the response survives.
-        if (cmd !== '/clear') {
-            persist('user', opts?.displayCommand ?? command);
-        }
+        persist('user', opts?.displayCommand ?? command);
         let result;
         let responseText;
         let forcePersist = false;
@@ -5083,36 +5177,14 @@ class AgentRunner extends events_1.EventEmitter {
                 }
             }
             else if (cmd === '/clear') {
-                const ch = 'api';
-                await this.sessionStore.clearTelegramSessionHistory(agentId, storeChatId, sessionId, ch);
-                await this.sessionStore.updateSessionMeta(agentId, storeChatId, sessionId, {
-                    totalTokensUsed: 0,
-                    lastInputTokens: 0,
-                    archivedCount: 0,
-                    loadedAtSpawn: undefined,
-                    messageCountAtSpawn: undefined,
-                }, ch);
-                const mediaPaths = this.historyDb.clearSession(dbChatId, sessionId);
-                media_store_1.MediaStore.deleteMediaFiles(this.agentsBaseDir, agentId, mediaPaths);
-                this.restartProcess(sessionId).catch(() => { });
-                result = { success: true };
-                responseText = 'Session cleared.';
+                await this.clearContext(sessionId);
+                result = { success: true, historyUnchanged: true, historyLimit: 50 };
+                responseText = 'Claude Code context reset. Chat history is unchanged. Your next message starts a new context with the latest 50 messages.';
             }
             else if (cmd === '/compact') {
-                const ch = 'api';
-                const activeSession = this.sessions.get(sessionId);
-                const compactEffectiveModel = opts?.model ?? activeSession?.modelOverride ?? this.agentConfig.claude.model;
-                const contextWindow = await this.contextWindowFor(compactEffectiveModel);
-                const compactor = new compactor_1.SessionCompactor(this.sessionStore);
-                const compactResult = await compactor.compact(agentId, storeChatId, sessionId, compactEffectiveModel, contextWindow, ch);
-                await this.sessionStore.updateSessionMeta(agentId, storeChatId, sessionId, {
-                    loadedAtSpawn: undefined,
-                    archivedCount: undefined,
-                    messageCountAtSpawn: undefined,
-                }, ch);
-                await this.restartProcess(sessionId);
-                result = { success: true, keptMessages: compactResult.afterMessages, archivedMessages: compactResult.beforeMessages - compactResult.afterMessages };
-                responseText = `Session compacted. Kept ${compactResult.afterMessages} messages, archived ${compactResult.beforeMessages - compactResult.afterMessages}.`;
+                await this.compactContext(sessionId, opts?.model);
+                result = { success: true, native: true, historyUnchanged: true };
+                responseText = 'Claude Code context compacted. Chat history is unchanged.';
             }
             else {
                 // Passed the gate but has no dispatch branch — BUILTIN_COMMANDS drifted from this
@@ -5158,17 +5230,20 @@ class AgentRunner extends events_1.EventEmitter {
         return kind === 'direct' || kind === 'user';
     }
     /**
-     * Restart every non-api session so a model change actually takes effect.
+     * Restart legacy non-api sessions so a model change actually takes effect.
      *
      * `setModel` only rewrites config — a session process was spawned with the
      * old model on its command line and keeps using it until it is restarted.
      * Reporting "model set" without this is a false success: the next turn still
-     * runs on the previous model. Returns whether anything was restarted.
+     * runs on the previous model. Managed decisions already spawn per turn and
+     * must finish with the model they started with. Returns whether anything restarted.
      */
     async restartChannelSessions() {
         const restartPromises = [];
         for (const [key, session] of this.sessions) {
-            if (session.source !== 'api')
+            // Managed decisions spawn a new process on every turn. Killing the current
+            // one here bypasses orchestration cancellation and reports PROCESS_EXITED.
+            if (session.source !== 'api' && !session.runtimeProfile)
                 restartPromises.push(this.restartProcess(key));
         }
         await Promise.all(restartPromises);
@@ -5298,7 +5373,7 @@ class AgentRunner extends events_1.EventEmitter {
     async deleteApiSession(chatId, sessionId) {
         await this.sessionStore.deleteTelegramSession(this.agentConfig.id, chatId, sessionId, 'api').catch((err) => {
             // Legacy sessions (stored only in SQLite, no file index entry) are treated as already deleted
-            if (err instanceof store_1.SessionNotInIndexError)
+            if (err instanceof store_2.SessionNotInIndexError)
                 return;
             throw err;
         });
@@ -5374,7 +5449,8 @@ class AgentRunner extends events_1.EventEmitter {
                 drain();
             }
             catch { /* Preserve the original stream/provider failure. */ }
-            this.turnStreams.completeAndRelease(turn, (0, turn_stream_1.errorEvent)(error), error);
+            const publicError = (0, response_errors_1.presentedResponseError)(error);
+            this.turnStreams.completeAndRelease(turn, (0, turn_stream_1.errorEvent)(publicError), publicError);
             close();
         };
         void (async () => {