tide-commander 1.40.2 → 1.40.4

package/dist/assets/{web-DAqM9uoZ.js → web-1BwWjkKM.js}

@@ -1 +1 @@
-import{bx as s}from"./main-DULfVodw.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class f extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{f as LocalNotificationsWeb};
+import{bx as s}from"./main-BSyGZK2z.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class f extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{f as LocalNotificationsWeb};

package/dist/assets/{web-DQ10iSod.js → web-BXQj42md.js}

@@ -1 +1 @@
-import{bx as a}from"./main-DULfVodw.js";import{ImpactStyle as i,NotificationType as r}from"./index-BxbFh16W.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class u extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{u as HapticsWeb};
+import{bx as a}from"./main-BSyGZK2z.js";import{ImpactStyle as i,NotificationType as r}from"./index-DBpmD8r7.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class u extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{u as HapticsWeb};

package/dist/index.html

@@ -22,11 +22,11 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-DULfVodw.js"></script>
+    <script type="module" crossorigin src="/assets/main-BSyGZK2z.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/modulepreload-polyfill-B5Qt9EMX.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-CUx2B9bn.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-BFSqr5mR.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/locales/en/config.json

@@ -25,6 +25,7 @@
     "showFPS": "Show FPS",
     "fpsLimit": "FPS Limit",
     "powerSaving": "Power Saving",
+    "tmuxMode": "Tmux Process Persistence",
     "tts": "Text-to-Speech",
     "stt": "Speech-to-Text",
     "externalEditor": "External Editor",

package/dist/src/packages/server/claude/backend.js

@@ -284,6 +284,15 @@ export class ClaudeBackend {
         if (event.subtype === 'task_started' && event.task_id) {
             log.log(`parseSystemEvent: task_started - task_id=${event.task_id}, tool_use_id=${event.tool_use_id}`);
         }
+        // Context compaction status
+        if (event.subtype === 'status' && event.status === 'compacting') {
+            log.log(`parseSystemEvent: compacting status received, session_id=${event.session_id}`);
+            return {
+                type: 'compacting',
+                sessionId: event.session_id,
+                uuid: event.uuid,
+            };
+        }
         return null;
     }
     parseAssistantEvent(event) {

package/dist/src/packages/server/claude/runner/process-lifecycle.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { StringDecoder } from 'string_decoder';
 import { createLogger } from '../../utils/logger.js';
+import { isTmuxEnabled, checkTmuxAvailability, spawnInTmux, killTmuxSession, interruptTmuxSession, } from './tmux-helper.js';
 const log = createLogger('Runner');
 export class RunnerProcessLifecycle {
     backend;
@@ -44,15 +45,71 @@ export class RunnerProcessLifecycle {
         log.log(`🚀 Spawning: ${executable} ${args.join(' ')}`);
         const isWindows = process.platform === 'win32';
         const extraEnv = this.backend.getExtraEnv?.() ?? {};
+        const env = {
+            ...process.env,
+            LANG: 'en_US.UTF-8',
+            LC_ALL: 'en_US.UTF-8',
+            TIDE_SERVER: `http://localhost:${process.env.TIDE_PORT || process.env.PORT || 5174}`,
+            ...extraEnv,
+        };
+        // ---- tmux mode ----
+        checkTmuxAvailability();
+        const useTmux = !isWindows && isTmuxEnabled();
+        if (useTmux) {
+            // For backends that need stdin input (e.g. claude --print --input-format stream-json),
+            // pass the initial prompt directly into the shell command so it's available on stdin
+            // immediately at process start — avoids the race where the CLI checks stdin before
+            // tmux send-keys can deliver the prompt.
+            let initialStdin;
+            if (this.backend.requiresStdinInput()) {
+                initialStdin = this.backend.formatStdinInput(prompt);
+                log.log(`📤 [TMUX-STDIN] Passing initial prompt (${initialStdin.length} chars) via shell pipe for agent ${agentId}`);
+            }
+            const tmuxResult = spawnInTmux(executable, args, {
+                agentId,
+                cwd: workingDir,
+                env,
+                initialStdin,
+                closeStdinAfterPrompt: this.backend.shouldCloseStdinAfterPrompt?.() ?? false,
+            });
+            const activeProcess = {
+                agentId,
+                sessionId,
+                startTime: Date.now(),
+                process: tmuxResult.launcherProcess,
+                lastRequest: request,
+                restartCount: 0,
+                turnState: 'processing',
+                tmuxSession: tmuxResult.sessionName,
+                tmuxLogFile: tmuxResult.logFile,
+            };
+            this.activeProcesses.set(agentId, activeProcess);
+            // Use file-tailing stdout pipeline for tmux mode
+            const tailer = this.stdoutPipeline.handleTmuxLog(agentId, tmuxResult.logFile);
+            activeProcess.tmuxTailer = tailer;
+            // The tmux launcher process exits quickly — we don't listen to its close
+            // as the real process lives inside the tmux session.
+            tmuxResult.launcherProcess.on('error', (err) => {
+                this.bus.emit({
+                    type: 'runner.process_spawn_error',
+                    agentId,
+                    error: err,
+                });
+            });
+            // Emit spawned event after a short delay (tmux session takes a moment)
+            setTimeout(() => {
+                this.bus.emit({
+                    type: 'runner.process_spawned',
+                    agentId,
+                    pid: tmuxResult.launcherProcess.pid,
+                });
+            }, 600);
+            return;
+        }
+        // ---- normal pipe mode ----
         const childProcess = spawn(executable, args, {
             cwd: workingDir,
-            env: {
-                ...process.env,
-                LANG: 'en_US.UTF-8',
-                LC_ALL: 'en_US.UTF-8',
-                TIDE_SERVER: `http://localhost:${process.env.TIDE_PORT || process.env.PORT || 5174}`,
-                ...extraEnv,
-            },
+            env,
             shell: isWindows ? true : false,
             detached: isWindows ? false : true,
         });
@@ -126,6 +183,10 @@ export class RunnerProcessLifecycle {
         if (!activeProcess) {
             return false;
         }
+        // tmux mode: send C-c via tmux
+        if (activeProcess.tmuxSession) {
+            return interruptTmuxSession(agentId);
+        }
         const pid = activeProcess.process.pid;
         if (!pid) {
             return false;
@@ -146,8 +207,19 @@ export class RunnerProcessLifecycle {
         }
         const pid = activeProcess.process.pid;
         log.log(`🛑 Stopping agent ${agentId} (pid ${pid})`);
+        // Stop tmux tailer if active
+        if (activeProcess.tmuxTailer) {
+            activeProcess.tmuxTailer.stop();
+        }
         this.activeProcesses.delete(agentId);
         this.activityCallbacks.delete(agentId);
+        // tmux mode: kill the tmux session and clean up
+        if (activeProcess.tmuxSession) {
+            killTmuxSession(agentId);
+            this.callbacks.onComplete(agentId, false);
+            return;
+        }
+        // Normal pipe mode
         if (pid) {
             try {
                 process.kill(-pid, 'SIGINT');

package/dist/src/packages/server/claude/runner/recovery-store.js

@@ -1,38 +1,51 @@
 import { saveRunningProcesses, loadRunningProcesses, isProcessRunning, clearRunningProcesses, } from '../../data/index.js';
 import * as agentService from '../../services/agent-service.js';
 import { createLogger } from '../../utils/logger.js';
+import { hasTmuxSession, isTmuxEnabled, tmuxLogPath } from './tmux-helper.js';
 const log = createLogger('Runner');
 export class RunnerRecoveryStore {
     backend;
     activeProcesses;
     run;
+    reconnectTmux;
     constructor(deps) {
         this.backend = deps.backend;
         this.activeProcesses = deps.activeProcesses;
         this.run = deps.run;
+        this.reconnectTmux = deps.reconnectTmux;
     }
     persistRunningProcesses() {
-        const processes = [];
+        const myProcesses = [];
         for (const [agentId, activeProcess] of this.activeProcesses) {
-            if (activeProcess.process.pid) {
+            const hasPid = !!activeProcess.process.pid;
+            const hasTmux = !!activeProcess.tmuxSession;
+            if (hasPid || hasTmux) {
                 const agent = agentService.getAgent(agentId);
-                processes.push({
+                myProcesses.push({
                     agentId,
-                    pid: activeProcess.process.pid,
+                    pid: activeProcess.process.pid ?? 0,
                     sessionId: activeProcess.sessionId,
                     startTime: activeProcess.startTime,
                     outputFile: activeProcess.outputFile,
                     stderrFile: activeProcess.stderrFile,
                     lastRequest: activeProcess.lastRequest,
                     agentStatus: agent?.status,
+                    tmuxSession: activeProcess.tmuxSession,
+                    tmuxLogOffset: activeProcess.tmuxTailer?.getOffset(),
+                    provider: this.backend.name,
                 });
             }
         }
-        if (processes.length > 0) {
-            saveRunningProcesses(processes);
-            return;
+        // Multiple runners (claude, codex, opencode) share the same persist file.
+        // Merge: keep entries from OTHER providers, replace entries from OUR provider.
+        const existing = loadRunningProcesses();
+        const otherProviders = existing.filter((p) => p.provider && p.provider !== this.backend.name);
+        const merged = [...otherProviders, ...myProcesses];
+        if (merged.length > 0) {
+            saveRunningProcesses(merged);
         }
-        clearRunningProcesses();
+        // NOTE: Do NOT call clearRunningProcesses() when the merged list is empty.
+        // The file is cleaned up by recoverOrphanedProcesses() on startup instead.
     }
     clearPersistedProcesses() {
         clearRunningProcesses();
@@ -42,9 +55,32 @@ export class RunnerRecoveryStore {
         if (savedProcesses.length === 0) {
             return;
         }
-        log.log(`🔍 Checking ${savedProcesses.length} processes from previous commander instance...`);
+        log.log(`🔍 [${this.backend.name}] Checking ${savedProcesses.length} processes from previous commander instance...`);
         const toResume = [];
+        const toReconnectTmux = [];
         for (const savedProcess of savedProcesses) {
+            // Only recover processes that belong to this runner's provider.
+            // Each provider (claude, codex, opencode) has its own runner and event parser.
+            // If provider is missing (old persist format / stale .bak), look up the agent's actual provider.
+            const effectiveProvider = savedProcess.provider ?? agentService.getAgent(savedProcess.agentId)?.provider ?? 'claude';
+            if (effectiveProvider !== this.backend.name) {
+                continue;
+            }
+            // Skip agents already tracked (another runner may have recovered them)
+            if (this.activeProcesses.has(savedProcess.agentId)) {
+                continue;
+            }
+            // tmux mode: check if the tmux session is still alive
+            if (savedProcess.tmuxSession && isTmuxEnabled()) {
+                if (hasTmuxSession(savedProcess.agentId)) {
+                    log.log(`✅ [TMUX] Found live tmux session for agent ${savedProcess.agentId} (${savedProcess.tmuxSession}) - will reconnect`);
+                    toReconnectTmux.push(savedProcess);
+                }
+                else {
+                    log.log(`❌ [TMUX] tmux session ${savedProcess.tmuxSession} for agent ${savedProcess.agentId} no longer exists`);
+                }
+                continue;
+            }
             if (isProcessRunning(savedProcess.pid)) {
                 log.log(`✅ Found orphaned process for agent ${savedProcess.agentId} (PID ${savedProcess.pid}) - still running`);
                 continue;
@@ -61,7 +97,34 @@ export class RunnerRecoveryStore {
                 toResume.push(savedProcess);
             }
         }
-        clearRunningProcesses();
+        // Only clear THIS provider's entries from the persist file, not the whole file.
+        // Other runners haven't recovered yet and still need their entries.
+        const remaining = savedProcesses.filter((p) => {
+            const prov = p.provider ?? agentService.getAgent(p.agentId)?.provider ?? 'claude';
+            return prov !== this.backend.name;
+        });
+        if (remaining.length > 0) {
+            saveRunningProcesses(remaining);
+        }
+        else {
+            clearRunningProcesses();
+        }
+        // Reconnect to live tmux sessions (just resume log tailing)
+        if (toReconnectTmux.length > 0 && this.reconnectTmux) {
+            setTimeout(() => {
+                for (const saved of toReconnectTmux) {
+                    const agent = agentService.getAgent(saved.agentId);
+                    if (!agent) {
+                        log.log(`🔄 [TMUX] Skipping reconnect for agent ${saved.agentId} - agent no longer exists`);
+                        continue;
+                    }
+                    const logFile = tmuxLogPath(saved.agentId);
+                    const offset = saved.tmuxLogOffset ?? 0;
+                    log.log(`🔄 [TMUX] Reconnecting to tmux session for agent ${saved.agentId} at offset ${offset}`);
+                    this.reconnectTmux(saved.agentId, logFile, offset, saved);
+                }
+            }, 1000);
+        }
         if (toResume.length === 0) {
             return;
         }

package/dist/src/packages/server/claude/runner/restart-policy.js

@@ -38,6 +38,15 @@ export class RunnerRestartPolicy {
             log.log(`🔄 [AUTO-RESTART] Process ${agentId} was stopped intentionally (${signal}), not restarting`);
             return;
         }
+        // If the process had completed its turn and was waiting for new input,
+        // its exit is a normal completion — not a crash.  This is especially
+        // important for backends like Codex that exit after each task rather
+        // than staying resident for stdin-based follow-ups.
+        if (activeProcess.turnState === 'waiting_for_input') {
+            log.log(`🔄 [AUTO-RESTART] Process ${agentId} exited after completing its turn (turnState=waiting_for_input), not restarting`);
+            this.callbacks.onComplete(agentId, true);
+            return;
+        }
         const restartCount = activeProcess.restartCount || 0;
         const lastRestartTime = activeProcess.lastRestartTime || 0;
         const timeSinceLastRestart = Date.now() - lastRestartTime;

package/dist/src/packages/server/claude/runner/stdout-pipeline.js

@@ -1,5 +1,6 @@
 import { StringDecoder } from 'string_decoder';
 import { createLogger } from '../../utils/logger.js';
+import { createFileTailer } from './tmux-helper.js';
 const log = createLogger('Runner');
 export class RunnerStdoutPipeline {
     backend;
@@ -53,6 +54,20 @@ export class RunnerStdoutPipeline {
             });
         });
     }
+    /**
+     * tmux mode: tail a log file instead of reading process.stdout.
+     * Lines are processed identically to the pipe-based path.
+     */
+    handleTmuxLog(agentId, logFile, startOffset) {
+        const tailer = createFileTailer(logFile, (line) => {
+            this.processLine(agentId, line);
+        });
+        if (startOffset !== undefined) {
+            tailer.setOffset(startOffset);
+        }
+        tailer.start();
+        return tailer;
+    }
     processLine(agentId, line) {
         try {
             const rawEvent = JSON.parse(line);
@@ -86,12 +101,17 @@ export class RunnerStdoutPipeline {
         }
     }
     handleEvent(agentId, event) {
-        // After notification is sent, suppress ALL further events from the agentic loop.
+        // After notification is sent, suppress output-producing events from the agentic loop.
         // This prevents status flickering (working → idle → working) caused by OpenCode
         // giving the model additional turns after the completion notification.
-        // Only 'init' events (new user message) can reset this gate.
-        if (this.notificationSent.has(agentId) && event.type !== 'init') {
-            return;
+        // Allow through: init (resets gate), step_complete (needed for idle transition),
+        // usage_snapshot (context tracking), error (always important).
+        if (this.notificationSent.has(agentId)) {
+            const passthrough = event.type === 'init' || event.type === 'step_complete'
+                || event.type === 'usage_snapshot' || event.type === 'error' || event.type === 'compacting';
+            if (!passthrough) {
+                return;
+            }
         }
         const now = Date.now();
         this.bus.emit({ type: 'runner.activity', agentId, timestamp: now });
@@ -194,6 +214,10 @@ export class RunnerStdoutPipeline {
                     this.callbacks.onOutput(agentId, event.contextStatsRaw, false, undefined, event.uuid);
                 }
                 break;
+            case 'compacting':
+                // Emit as output so runtime-listeners can broadcast it to clients
+                this.callbacks.onOutput(agentId, '[System] Compacting context...', false, undefined, event.uuid);
+                break;
             default:
                 break;
         }

package/dist/src/packages/server/claude/runner/tmux-helper.js

@@ -0,0 +1,264 @@
+/**
+ * tmux-based process persistence for CLI agent processes.
+ *
+ * When TIDE_USE_TMUX=1 (or "true"), agent CLI processes are spawned inside
+ * tmux sessions so that stdin/stdout survive server restarts.  The tmux
+ * server keeps the process alive; we reconnect by tailing a per-agent log
+ * file rather than relying on Node.js pipe file descriptors.
+ *
+ * Default: OFF — the existing pipe-based behaviour is unchanged.
+ */
+import { execSync, spawn } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { createLogger } from '../../utils/logger.js';
+import { isTmuxModeEnabled } from '../../services/system-prompt-service.js';
+const log = createLogger('Tmux');
+// ---------------------------------------------------------------------------
+// Public helpers
+// ---------------------------------------------------------------------------
+/** Returns true when the user opted in (via Settings) AND tmux is available. */
+export function isTmuxEnabled() {
+    if (!isTmuxModeEnabled()) {
+        return false;
+    }
+    return isTmuxInstalled();
+}
+/** Warn once at startup if the setting is on but tmux is missing. */
+let warnedMissing = false;
+export function checkTmuxAvailability() {
+    if (!isTmuxModeEnabled()) {
+        return;
+    }
+    if (!isTmuxInstalled() && !warnedMissing) {
+        warnedMissing = true;
+        log.error('Tmux mode is enabled in settings but tmux is not installed — falling back to pipe-based mode');
+    }
+}
+/** Canonical tmux session name for an agent. */
+export function tmuxSessionName(agentId) {
+    return `tc-${agentId}`;
+}
+/** Canonical log-file path for an agent's stdout. */
+export function tmuxLogPath(agentId) {
+    return path.join(os.tmpdir(), `tc-agent-${agentId}.log`);
+}
+/**
+ * Spawn a CLI executable inside a tmux session.
+ *
+ * Stdout is redirected to a log file **inside the shell command** so we get
+ * clean, raw JSON output (no terminal escape codes or line wrapping).
+ * Stdin still comes from the tmux pane (via send-keys / paste-buffer).
+ *
+ * Returns a short-lived ChildProcess (the tmux launcher), the session name,
+ * and the log file path.
+ */
+export function spawnInTmux(executable, args, options) {
+    const sessionName = tmuxSessionName(options.agentId);
+    const logFile = tmuxLogPath(options.agentId);
+    const stderrFile = `${logFile}.stderr`;
+    // Ensure the log file exists (truncate if leftover from a previous run)
+    fs.writeFileSync(logFile, '');
+    fs.writeFileSync(stderrFile, '');
+    // Kill any stale session with the same name (ignore errors)
+    try {
+        execSync(`tmux kill-session -t ${sessionName} 2>/dev/null`, { stdio: 'ignore' });
+    }
+    catch {
+        // no existing session — that's fine
+    }
+    // Build the full command string for tmux to run.
+    // Redirect stdout to the log file so we get clean JSON (no ANSI escapes).
+    // Stderr goes to its own file for debugging.
+    // Stdin remains connected to the tmux pane for send-keys input.
+    const escapedArgs = args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+    let fullCmd;
+    if (options.initialStdin) {
+        const initialStdinFile = path.join(os.tmpdir(), `tc-initial-${options.agentId}.tmp`);
+        fs.writeFileSync(initialStdinFile, options.initialStdin + '\n');
+        if (options.closeStdinAfterPrompt) {
+            // Pipe the prompt then close stdin (EOF).  For one-shot backends
+            // like opencode that need EOF to start processing.
+            fullCmd = `cat '${initialStdinFile}' | ${executable} ${escapedArgs} > '${logFile}' 2> '${stderrFile}'`;
+        }
+        else {
+            // Pipe the prompt then keep stdin open via the tmux pane pty.
+            // The second `cat` reads from the pane so sendToTmux() still works.
+            fullCmd = `(cat '${initialStdinFile}'; cat) | ${executable} ${escapedArgs} > '${logFile}' 2> '${stderrFile}'`;
+        }
+    }
+    else {
+        fullCmd = `${executable} ${escapedArgs} > '${logFile}' 2> '${stderrFile}'`;
+    }
+    // Spawn the tmux session
+    const launcherProcess = spawn('tmux', [
+        'new-session',
+        '-d', // detached
+        '-s', sessionName, // session name
+        '-x', '200', // width
+        '-y', '50', // height
+        '--', 'sh', '-c', fullCmd,
+    ], {
+        cwd: options.cwd,
+        env: options.env,
+        detached: true,
+        stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    launcherProcess.unref();
+    log.log(`Spawned tmux session ${sessionName}: ${executable} ${escapedArgs} (stdout -> ${logFile})`);
+    return { launcherProcess, sessionName, logFile };
+}
+// ---------------------------------------------------------------------------
+// Sending input
+// ---------------------------------------------------------------------------
+/**
+ * Send text to a tmux session's active pane via `send-keys`.
+ * Returns true on success.
+ */
+export function sendToTmux(agentId, text) {
+    const sessionName = tmuxSessionName(agentId);
+    try {
+        // Write the text to a temp file and use load-buffer + paste-buffer
+        // to avoid shell escaping issues with send-keys
+        const tmpFile = path.join(os.tmpdir(), `tc-stdin-${agentId}.tmp`);
+        fs.writeFileSync(tmpFile, text + '\n');
+        execSync(`tmux load-buffer -b tc-input ${tmpFile} && tmux paste-buffer -b tc-input -t ${sessionName} -d`, { stdio: 'ignore', timeout: 5000 });
+        fs.unlinkSync(tmpFile);
+        return true;
+    }
+    catch (err) {
+        log.error(`Failed to send input to tmux session ${sessionName}:`, err);
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Session management
+// ---------------------------------------------------------------------------
+/** Check whether a tmux session exists. */
+export function hasTmuxSession(agentId) {
+    const sessionName = tmuxSessionName(agentId);
+    try {
+        execSync(`tmux has-session -t ${sessionName} 2>/dev/null`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Kill a tmux session and clean up its log files. */
+export function killTmuxSession(agentId) {
+    const sessionName = tmuxSessionName(agentId);
+    const logFile = tmuxLogPath(agentId);
+    const stderrFile = `${logFile}.stderr`;
+    try {
+        execSync(`tmux kill-session -t ${sessionName} 2>/dev/null`, { stdio: 'ignore' });
+        log.log(`Killed tmux session ${sessionName}`);
+    }
+    catch {
+        // already gone
+    }
+    for (const f of [logFile, stderrFile]) {
+        try {
+            if (fs.existsSync(f)) {
+                fs.unlinkSync(f);
+            }
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+}
+/** Send SIGINT to the process inside a tmux session. */
+export function interruptTmuxSession(agentId) {
+    const sessionName = tmuxSessionName(agentId);
+    try {
+        execSync(`tmux send-keys -t ${sessionName} C-c`, { stdio: 'ignore', timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a file tailer that reads new lines appended to a log file.
+ * Uses `fs.watchFile` (polling) for reliability with pipe-pane output.
+ */
+export function createFileTailer(logFile, onLine) {
+    let offset = 0;
+    let watching = false;
+    let pollInterval = null;
+    function readNewData() {
+        try {
+            const stat = fs.statSync(logFile);
+            if (stat.size <= offset)
+                return;
+            const fd = fs.openSync(logFile, 'r');
+            const buf = Buffer.alloc(stat.size - offset);
+            fs.readSync(fd, buf, 0, buf.length, offset);
+            fs.closeSync(fd);
+            offset = stat.size;
+            const text = buf.toString('utf8');
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.trim()) {
+                    onLine(line);
+                }
+            }
+        }
+        catch {
+            // file may not exist yet or be temporarily unavailable
+        }
+    }
+    return {
+        start() {
+            if (watching)
+                return;
+            watching = true;
+            // Initial read for anything already in the file
+            readNewData();
+            // Poll every 100ms for new data
+            pollInterval = setInterval(readNewData, 100);
+        },
+        stop() {
+            watching = false;
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+        },
+        getOffset() {
+            return offset;
+        },
+        setOffset(newOffset) {
+            offset = newOffset;
+        },
+    };
+}
+/**
+ * Get the PID of the process running inside a tmux session's active pane.
+ * Returns undefined if the session doesn't exist or the PID can't be determined.
+ */
+export function getTmuxPanePid(agentId) {
+    const sessionName = tmuxSessionName(agentId);
+    try {
+        const output = execSync(`tmux list-panes -t ${sessionName} -F '#{pane_pid}'`, { encoding: 'utf-8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        const pid = parseInt(output.split('\n')[0], 10);
+        return Number.isFinite(pid) ? pid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Internal
+// ---------------------------------------------------------------------------
+function isTmuxInstalled() {
+    try {
+        execSync('which tmux', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}