@0xmaxma/claude-gateway 2.0.4 → 2.0.6

package/dist/agent/runner.js

@@ -35,8 +35,13 @@ 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 session_compaction_scheduler_1 = require("./session-compaction-scheduler");
+const session_compaction_1 = require("../orchestration/session-compaction");
+const config_1 = require("./dreaming/config");
+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_2 = 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");
@@ -56,7 +61,7 @@ const config_write_lock_1 = require("../config/config-write-lock");
 const logger_1 = require("../logger");
 const process_1 = require("../session/process");
 const store_2 = require("../session/store");
-const compactor_1 = require("../session/compactor");
+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");
@@ -73,7 +78,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_3 = 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");
@@ -348,9 +353,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);
     }
@@ -642,6 +659,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;
@@ -691,6 +709,26 @@ class AgentRunner extends events_1.EventEmitter {
         if (result.state !== 'delivered')
             this.logger.warn('Skill notification delivery failed', { sessionId, code: result.code });
     }
+    sessionCompactionSettings() {
+        const config = (0, session_compaction_1.resolveSessionCompaction)(this.agentConfig.sessionCompaction, this.gatewayConfig.gateway.sessionCompaction);
+        if (!this.agentConfig.orchestration?.enabled)
+            config.enabled = false;
+        const dream = (0, config_1.resolveDreamingConfig)(this.agentConfig.dreaming, this.gatewayConfig.gateway.dreaming, this.gatewayConfig.gateway.timezone);
+        return { config, hour: dream.dreamHour, minute: dream.dreamMinute, timezone: dream.dreamTimezone, stagger: dream.staggerWindowMinutes };
+    }
+    startSessionCompaction() {
+        this.sessionCompactionScheduler ?? (this.sessionCompactionScheduler = new session_compaction_scheduler_1.SessionCompactionScheduler(this.agentConfig.id, () => this.sessionCompactionSettings(), async () => {
+            if (this.stopping)
+                return;
+            const runtime = await this.getOrchestration();
+            return runtime.runSessionCompaction(this.sessionCompactionSettings().config, model => this.contextWindowFor(model, true));
+        }, error => this.logger.warn('Nightly session compaction failed', { error: String(error) })));
+        this.sessionCompactionScheduler.start();
+    }
+    async sessionCompactionReport() {
+        const cfg = this.sessionCompactionSettings();
+        return { schedule: { ...cfg.config, nextRunAt: this.sessionCompactionScheduler?.nextRunAt ?? null, timezone: cfg.timezone } };
+    }
     setSkillLearning(manager) {
         this.skillLearning = manager;
     }
@@ -907,6 +945,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;
@@ -1375,7 +1414,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') {
@@ -1416,36 +1455,21 @@ class AgentRunner extends events_1.EventEmitter {
                 const index = await this.sessionStore.listSessions(this.agentConfig.id, chatId, this.channelFor(chatId));
                 const meta = index.sessions.find(s => s.id === index.activeSessionId);
                 if (!meta) {
-                    return respond({ success: true, text: 'No active session found.' });
-                }
-                const effectiveModel = this.agentConfig.claude.model;
-                const contextWindow = await this.contextWindowFor(effectiveModel);
-                const contextTokens = meta.lastInputTokens ?? 0;
-                const usedPct = Math.round((contextTokens / contextWindow) * 100);
-                let msgs;
-                if (meta.messageCount <= 0) {
-                    msgs = 'No messages yet';
-                }
-                else if ((meta.archivedCount ?? 0) > 0 && meta.loadedAtSpawn != null && meta.messageCountAtSpawn != null) {
-                    const newMessagesSinceSpawn = meta.messageCount - meta.messageCountAtSpawn;
-                    const inContext = meta.loadedAtSpawn + Math.max(0, newMessagesSinceSpawn);
-                    msgs = `${meta.messageCount} (${inContext} in context / ${meta.archivedCount} archived)`;
-                }
-                else {
-                    msgs = `${meta.messageCount}`;
+                    return respond({ success: true, sessionId: null, text: 'No active session found.' });
                 }
+                const context = await this.sessionContextInfo(meta.id, meta);
                 const lines = [
                     `📌 Current Session: ${meta.name}`,
                     `<code>${meta.id}</code>`,
                     '',
-                    `📥 Messages: ${msgs}`,
-                    `👉 Context: ${usedPct}%`,
+                    `👉 Context: ${context.text}`,
+                    `🤖 Model: ${String(this.agentConfig.claude.model).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}`,
                 ];
-                if (usedPct >= 80) {
+                if (context.contextUsedPct != null && context.contextUsedPct >= 80) {
                     lines.push('', '💡 Near limit — consider /compact');
                 }
                 lines.push('', 'Commands: /sessions /new /rename /clear /compact');
-                return respond({ success: true, text: lines.join('\n'), format: 'html' });
+                return respond({ success: true, sessionId: meta.id, text: lines.join('\n'), format: 'html' });
             }
             catch {
                 return respond({ success: false, text: 'Failed to get session info.' });
@@ -2189,6 +2213,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,
@@ -2800,6 +2825,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);
@@ -2869,7 +2895,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;
         }
@@ -2885,10 +2911,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.
@@ -2910,6 +2936,23 @@ class AgentRunner extends events_1.EventEmitter {
     /**
      * /session — show info about the current active session.
      */
+    async sessionContextInfo(sessionId, meta) {
+        let context = this.orchestration?.sessionContextWindow(sessionId);
+        // Legacy sessions do not write the orchestration ledger. Keep their measured
+        // usage, but never resurrect stale metadata for an orchestration-owned session.
+        if (!context && meta && !this.orchestration?.ownsSession(sessionId) &&
+            Number.isFinite(meta.lastInputTokens) && meta.lastInputTokens >= 0 &&
+            Number.isFinite(meta.lastActive) && Date.now() - meta.lastActive <= 3600000) {
+            context = { used: meta.lastInputTokens, total: null, model: meta.model ?? this.agentConfig.claude.model };
+        }
+        if (!context)
+            return { contextUsedPct: null, contextTokens: null, contextWindow: null, contextModel: null, text: '—' };
+        const total = context.model ? await this.dashboardContextWindow(context.model) : null;
+        const pct = total && total > 0 ? Math.round(context.used / total * 100) : null;
+        const format = (n) => n >= 1000000 ? `${Number((n / 1000000).toFixed(2))}M` : n >= 1000 ? `${Number((n / 1000).toFixed(2))}K` : String(n);
+        return { contextUsedPct: pct, contextTokens: context.used, contextWindow: total, contextModel: context.model,
+            text: `${format(context.used)} / ${total == null ? '—' : format(total)}${pct == null ? '' : ` · ${pct}%`}` };
+    }
     async handleCommandSessionInfo(agentId, chatId) {
         const index = await this.sessionStore.listSessions(agentId, chatId, this.channelFor(chatId));
         const meta = index.sessions.find(s => s.id === index.activeSessionId);
@@ -2917,31 +2960,15 @@ class AgentRunner extends events_1.EventEmitter {
             this.writeAutoForward(chatId, 'No active session found.');
             return;
         }
-        const effectiveModel = this.agentConfig.claude.model;
-        const contextWindow = await this.contextWindowFor(effectiveModel);
-        const contextTokens = meta.lastInputTokens ?? 0;
-        const usedPct = Math.round((contextTokens / contextWindow) * 100);
-        let msgs;
-        if (meta.messageCount <= 0) {
-            msgs = 'No messages yet';
-        }
-        else if ((meta.archivedCount ?? 0) > 0 && meta.loadedAtSpawn != null && meta.messageCountAtSpawn != null) {
-            const newMessagesSinceSpawn = meta.messageCount - meta.messageCountAtSpawn;
-            const inContext = meta.loadedAtSpawn + Math.max(0, newMessagesSinceSpawn);
-            msgs = `${meta.messageCount} (${inContext} in context / ${meta.archivedCount} archived)`;
-        }
-        else {
-            msgs = `${meta.messageCount}`;
-        }
-        const contextLine = `${usedPct}%`;
+        const context = await this.sessionContextInfo(meta.id, meta);
         const lines = [
             `📌 Current Session: ${meta.name}`,
             `<code>${index.activeSessionId}</code>`,
             '',
-            `📥 Messages: ${msgs}`,
-            `👉 Context: ${contextLine}`,
+            `👉 Context: ${context.text}`,
+            `🤖 Model: ${String(this.agentConfig.claude.model).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}`,
         ];
-        if (usedPct >= 80) {
+        if (context.contextUsedPct != null && context.contextUsedPct >= 80) {
             lines.push('', '💡 Near limit — consider /compact');
         }
         lines.push('', 'Commands: /sessions /new /rename /clear /compact');
@@ -3005,87 +3032,78 @@ 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)) {
+                await runtime.compactSession(sessionId, model);
+                return;
+            }
+            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.');
         }
     }
     /**
@@ -3644,6 +3662,7 @@ class AgentRunner extends events_1.EventEmitter {
         await this.wechat?.resumeIfLinked();
         this.startIdleCleaner();
         this._startCleanupScheduler();
+        this.startSessionCompaction();
         this.logger.info('AgentRunner started', { agentId: this.agentConfig.id });
     }
     /**
@@ -3712,6 +3731,7 @@ class AgentRunner extends events_1.EventEmitter {
         newConfig = (0, gateway_config_1.applyGatewayOrchestration)(newConfig, this.gatewayConfig);
         this.orchestration?.updateAgentConfig(newConfig);
         this.agentConfig = newConfig;
+        this.sessionCompactionScheduler?.start();
         this.refreshTelegramCommands();
         // Restart LineReplyManager if the LINE config changed so the live instance
         // picks up a new access token, threshold, or labels without a full restart.
@@ -4097,6 +4117,7 @@ class AgentRunner extends events_1.EventEmitter {
     }
     async stop() {
         this.stopping = true;
+        this.sessionCompactionScheduler?.stop();
         if (this.orchestrationStarting) {
             const orchestration = await this.orchestrationStarting.catch(() => undefined);
             await orchestration?.close();
@@ -4161,9 +4182,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_3.isValidTimezone)(gw.history?.cleanupTimezone)
             ? gw.history.cleanupTimezone
-            : (0, config_1.isValidTimezone)(gw.timezone)
+            : (0, config_3.isValidTimezone)(gw.timezone)
                 ? gw.timezone
                 : 'UTC';
         const agentMediaRoot = media_store_1.MediaStore.agentMediaRoot(this.agentsBaseDir, this.agentConfig.id);
@@ -4185,6 +4206,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_2.ORCHESTRATION_DEFAULTS.tasks.maxConcurrentPerAgent,
+            idleTtlMs: this.agentConfig.orchestration?.tasks?.workerIdleTtlMs ?? config_2.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;
@@ -4224,6 +4262,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.
      *
@@ -4526,7 +4587,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)) {
@@ -5022,10 +5086,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;
@@ -5087,21 +5148,13 @@ class AgentRunner extends events_1.EventEmitter {
                 // The api append path doesn't maintain the index messageCount, so count the flat store
                 // (the real conversation) directly rather than trusting meta.messageCount.
                 const messageCount = (await this.sessionStore.loadSession(agentId, sessionId).catch(() => [])).length;
-                if (!meta) {
-                    result = { sessionId, sessionName: null, messageCount, archivedCount: 0, contextUsedPct: 0, model: effectiveModel };
-                    responseText = `Session: (unnamed)\nMessages: ${messageCount}\nContext used: 0%\nModel: ${effectiveModel}`;
-                }
-                else {
-                    const contextWindow = await this.contextWindowFor(effectiveModel);
-                    const contextUsedPct = Math.round(((meta.lastInputTokens ?? 0) / contextWindow) * 100);
-                    result = { sessionId, sessionName: meta.name, messageCount, archivedCount: meta.archivedCount ?? 0, contextUsedPct, model: effectiveModel };
-                    responseText = [
-                        `Session: ${meta.name ?? '(unnamed)'}`,
-                        `Messages: ${messageCount}${(meta.archivedCount ?? 0) > 0 ? ` (${meta.archivedCount} archived)` : ''}`,
-                        `Context used: ${contextUsedPct}%`,
-                        `Model: ${effectiveModel}`,
-                    ].join('\n');
-                }
+                const context = await this.sessionContextInfo(sessionId, meta);
+                const { text: contextText, ...contextFields } = context;
+                result = { sessionId, sessionName: meta?.name ?? null, messageCount, archivedCount: meta?.archivedCount ?? 0,
+                    ...contextFields, model: effectiveModel };
+                responseText = [`📌 Current Session: ${meta?.name ?? '(unnamed)'}`, sessionId, '', `👉 Context: ${contextText}`, `🤖 Model: ${effectiveModel}`,
+                    ...(context.contextUsedPct != null && context.contextUsedPct >= 80 ? ['', '💡 Near limit — consider /compact'] : []),
+                    '', 'Commands: /sessions /new /rename /clear /compact'].join('\n');
             }
             else if (cmd === '/sessions') {
                 // Advertised for the api channel (BUILTIN_COMMANDS), so handle it here — mirrors the
@@ -5130,36 +5183,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
@@ -5205,17 +5236,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);
@@ -5237,7 +5271,7 @@ class AgentRunner extends events_1.EventEmitter {
      * honest for a model that exists only upstream — before, any such model fell
      * through to the 200k default no matter how large its real window.
      */
-    async contextWindowFor(modelId) {
+    async contextWindowFor(modelId, requireKnown = false) {
         const models = await this.availableModels();
         // Configured list second, not just as the catalog's fallback: the catalog
         // *replaces* the list rather than merging with it, so a configured model
@@ -5247,7 +5281,7 @@ class AgentRunner extends events_1.EventEmitter {
         // SessionCompactor a window small enough to compact far too early.
         return models.find((m) => m.id === modelId)?.contextWindow
             ?? (this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).find((m) => m.id === modelId)?.contextWindow
-            ?? model_catalog_1.DEFAULT_CONTEXT_WINDOW;
+            ?? (requireKnown ? 0 : model_catalog_1.DEFAULT_CONTEXT_WINDOW);
     }
     /**
      * Models `/model <arg>` may switch to: what the catalog offers, plus the
@@ -5320,16 +5354,14 @@ class AgentRunner extends events_1.EventEmitter {
         const meta = index?.sessions.find((s) => s.id === sessionId);
         if (!meta)
             return null;
-        const effectiveModel = this.agentConfig.claude.model;
-        const contextWindow = await this.contextWindowFor(effectiveModel);
-        const contextUsedPct = Math.round(((meta.lastInputTokens ?? 0) / contextWindow) * 100);
+        const { text: _contextText, ...context } = await this.sessionContextInfo(sessionId, meta);
         return {
             sessionId: meta.id,
             sessionName: meta.name,
             messageCount: meta.messageCount,
             archivedCount: meta.archivedCount ?? 0,
-            contextUsedPct,
-            model: effectiveModel,
+            ...context,
+            model: this.agentConfig.claude.model,
         };
     }
     async updateApiSession(chatId, sessionId, updates) {
@@ -5421,7 +5453,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 () => {