tide-commander 1.162.0 → 1.164.0

package/dist/assets/{web-NCIGsXXA.js → web-DJKyfwYK.js}

@@ -1 +1 @@
-import{dh as t}from"./main-rX2ghMIV.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};
+import{dn as t}from"./main-B1w4ybci.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};

package/dist/assets/{web-ml-7D2g7.js → web-DRZHW7yx.js}

@@ -1 +1 @@
-import{dh as s}from"./main-rX2ghMIV.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l 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{l as LocalNotificationsWeb};
+import{dn as s}from"./main-B1w4ybci.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l 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{l as LocalNotificationsWeb};

package/dist/assets/{web-ClQyiX7L.js → web-yMkJObs8.js}

@@ -1 +1 @@
-import{dh as a}from"./main-rX2ghMIV.js";import{ImpactStyle as i,NotificationType as r}from"./index-CpQeaxZ7.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h 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{h as HapticsWeb};
+import{dn as a}from"./main-B1w4ybci.js";import{ImpactStyle as i,NotificationType as r}from"./index-D4o6bUBS.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h 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{h as HapticsWeb};

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.162.0"}
+{"version":"1.164.0"}

package/dist/index.html

@@ -22,10 +22,10 @@
     <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-rX2ghMIV.js"></script>
+    <script type="module" crossorigin src="/assets/main-B1w4ybci.js"></script>
     <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-B-jhtDyZ.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-D5J-fbZv.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/locales/en/config.json

@@ -596,6 +596,11 @@
     "stuckHint": "Taking longer than expected?",
     "reload": "Reload",
     "recheck": "Recheck",
+    "gitPullBtn": "Update (git pull)",
+    "gitPulling": "Running git pull…",
+    "gitPullSuccess": "Updated to v{{version}} via git pull",
+    "gitPullConflict": "git pull hit a conflict — resolve it manually in the checkout",
+    "gitPullFailed": "git pull failed",
     "updated": "Updated to v{{version}}",
     "viewChangelog": "View changelog",
     "changelogTitle": "What's new in v{{version}}",

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

@@ -537,6 +537,19 @@ export class ClaudeRunner {
             this.callbacks.onError(agentId, `Failed to deliver queued message: ${err}`);
         });
     }
+    getQueuedMessages(agentId) {
+        return [...(this.messageQueue.get(agentId) ?? [])];
+    }
+    removeQueuedMessage(agentId, index, expectedText) {
+        const queue = this.messageQueue.get(agentId);
+        if (!queue || index < 0 || index >= queue.length || queue[index] !== expectedText)
+            return false;
+        queue.splice(index, 1);
+        if (queue.length === 0)
+            this.messageQueue.delete(agentId);
+        log.log(`🗑️ [QUEUE] Agent ${agentId}: removed queued message at ${index} (${queue.length} remaining)`);
+        return true;
+    }
     /**
      * Reconnect to a live tmux session after a server restart.
      * Creates a minimal ActiveProcess and starts tailing the log file from the saved offset.

package/dist/src/packages/server/codex/app-server/app-server-event-adapter.js

@@ -85,7 +85,10 @@ export class CodexAppServerEventAdapter {
         switch (item.type) {
             case 'commandExecution': {
                 const command = item.command || '';
-                return [{ type: 'tool_start', toolName: 'Bash', toolInput: { command, status: item.status } }];
+                // item.id lets the client attach the eventual tool_result output to
+                // this card live (attachToolResult) instead of waiting for /history.
+                const ids = item.id ? { uuid: item.id, toolUseId: item.id } : {};
+                return [{ type: 'tool_start', toolName: 'Bash', toolInput: { command, status: item.status }, ...ids }];
             }
             case 'webSearch':
                 return [{ type: 'tool_start', toolName: 'web_search', toolInput: this.webSearchInput(item) }];
@@ -113,7 +116,10 @@ export class CodexAppServerEventAdapter {
             case 'commandExecution': {
                 const output = item.aggregatedOutput ??
                     (item.exitCode !== undefined ? `[exit ${item.exitCode}]` : item.status ? `Command status: ${item.status}` : '');
-                return [{ type: 'tool_result', toolName: 'Bash', toolOutput: output }];
+                // Same id as the matching tool_start so the client enriches that card
+                // in place (attachToolResult) instead of waiting for a /history reload.
+                const ids = item.id ? { uuid: item.id, toolUseId: item.id } : {};
+                return [{ type: 'tool_result', toolName: 'Bash', toolOutput: output, ...ids }];
             }
             case 'fileChange':
                 return this.handleFileChange(item);

package/dist/src/packages/server/codex/app-server/codex-app-server-runner.js

@@ -184,6 +184,18 @@ export class CodexAppServerRunner {
         if (event.type === 'text' || event.type === 'tool_start' || event.type === 'thinking' || event.type === 'init') {
             state.turnState = 'processing';
         }
+        // A user-requested interrupt ("Send now") can surface as an error event
+        // from the aborted turn. The 🛑 system line already tells the user what
+        // happened — keep the expected fallout quiet.
+        if (state.interruptRequested) {
+            if (event.type === 'error' && /interrupt|abort/i.test(event.errorMessage || '')) {
+                log.log(`Suppressing expected interrupt error for ${agentId.slice(0, 8)} (user interrupt)`);
+                return;
+            }
+            if (event.type === 'step_complete') {
+                state.interruptRequested = false;
+            }
+        }
         this.pipeline.emitStandardEvent(agentId, event);
         if (event.type === 'step_complete') {
             state.turnState = 'waiting_for_input';
@@ -371,6 +383,44 @@ export class CodexAppServerRunner {
             return true;
         });
     }
+    getQueuedMessages(agentId) {
+        return [...(this.agents.get(agentId)?.queue ?? [])];
+    }
+    removeQueuedMessage(agentId, index, expectedText) {
+        const queue = this.agents.get(agentId)?.queue;
+        if (!queue || index < 0 || index >= queue.length || queue[index] !== expectedText)
+            return false;
+        queue.splice(index, 1);
+        log.log(`🗑️ Removed queued message at ${index} for ${agentId.slice(0, 8)} (${queue.length} remaining)`);
+        return true;
+    }
+    async interruptTurn(agentId, clearQueue = true) {
+        return withAgentContext(agentId, async () => {
+            const state = this.agents.get(agentId);
+            if (!state)
+                return false;
+            const proc = this.process;
+            if (!proc || !proc.isAlive())
+                return false;
+            if (state.turnState === 'processing') {
+                state.interruptRequested = true;
+                try {
+                    await proc.request('turn/interrupt', { threadId: state.threadId });
+                }
+                catch (err) {
+                    state.interruptRequested = false;
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log.warn(`turn/interrupt failed for ${agentId.slice(0, 8)}: ${msg}`);
+                    return false;
+                }
+            }
+            // Clear only after a successful interrupt so a failed request never
+            // silently drops queued messages.
+            if (clearQueue)
+                state.queue.length = 0;
+            return true;
+        });
+    }
     async stop(agentId, _clearQueue = true) {
         await withAgentContext(agentId, async () => {
             const state = this.agents.get(agentId);

package/dist/src/packages/server/codex/json-event-parser.js

@@ -677,6 +677,9 @@ export class CodexJsonEventParser {
                     type: 'tool_start',
                     toolName,
                     toolInput: pureRead ?? this.buildCommandExecutionToolInput(item),
+                    // item.id lets the client attach the eventual tool_result output to
+                    // this card live (attachToolResult) instead of waiting for /history.
+                    ...(item.id ? { uuid: item.id, toolUseId: item.id } : {}),
                 },
             ];
         }
@@ -754,6 +757,9 @@ export class CodexJsonEventParser {
             if (item.id) {
                 this.activeToolByItemId.delete(item.id);
             }
+            // Same id as the matching tool_start so the client enriches that card
+            // in place (attachToolResult) instead of waiting for a /history reload.
+            const resultIds = item.id ? { uuid: item.id, toolUseId: item.id } : {};
             // Pure-read commands were mapped to a Read tool at item.started — emit a
             // single Read result and skip the inferred-tool/Bash duplication.
             if (toolName === 'Read') {
@@ -762,6 +768,7 @@ export class CodexJsonEventParser {
                         type: 'tool_result',
                         toolName: 'Read',
                         toolOutput: this.buildCommandExecutionToolOutput(item),
+                        ...resultIds,
                     },
                 ];
             }
@@ -772,6 +779,7 @@ export class CodexJsonEventParser {
                     type: 'tool_result',
                     toolName,
                     toolOutput: this.buildCommandExecutionToolOutput(item),
+                    ...resultIds,
                 },
             ];
         }

package/dist/src/packages/server/opencode/server/opencode-server-runner.js

@@ -154,6 +154,21 @@ export class OpencodeServerRunner {
         if (event.type === 'text' || event.type === 'tool_start' || event.type === 'thinking' || event.type === 'init') {
             state.turnState = 'processing';
         }
+        // A user-requested interrupt ("Send now") makes the abort look like a
+        // failure: session.error "Aborted" + an "(Empty response: …)" dump. The
+        // 🛑 system line already tells the user what happened — keep the rest quiet.
+        if (state.interruptRequested) {
+            if (event.type === 'error' && /abort/i.test(event.errorMessage || '')) {
+                log.log(`Suppressing expected abort error for ${agentId.slice(0, 8)} (user interrupt)`);
+                return;
+            }
+            if (event.type === 'step_complete') {
+                state.interruptRequested = false;
+                if (typeof event.resultText === 'string' && event.resultText.startsWith('(Empty response:')) {
+                    delete event.resultText;
+                }
+            }
+        }
         this.pipeline.emitStandardEvent(agentId, event);
         if (event.type === 'step_complete') {
             state.turnState = 'waiting_for_input';
@@ -292,6 +307,44 @@ export class OpencodeServerRunner {
             return true;
         });
     }
+    getQueuedMessages(agentId) {
+        return [...(this.agents.get(agentId)?.queue ?? [])];
+    }
+    removeQueuedMessage(agentId, index, expectedText) {
+        const queue = this.agents.get(agentId)?.queue;
+        if (!queue || index < 0 || index >= queue.length || queue[index] !== expectedText)
+            return false;
+        queue.splice(index, 1);
+        log.log(`🗑️ Removed queued message at ${index} for ${agentId.slice(0, 8)} (${queue.length} remaining)`);
+        return true;
+    }
+    async interruptTurn(agentId, clearQueue = true) {
+        return withAgentContext(agentId, async () => {
+            const state = this.agents.get(agentId);
+            if (!state)
+                return false;
+            const proc = this.process;
+            if (!proc || !proc.isAlive())
+                return false;
+            if (state.turnState === 'processing') {
+                state.interruptRequested = true;
+                try {
+                    await proc.abort(state.sessionId);
+                }
+                catch (err) {
+                    state.interruptRequested = false;
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log.warn(`abort failed for ${agentId.slice(0, 8)}: ${msg}`);
+                    return false;
+                }
+            }
+            // Clear only after a successful abort so a failed request never
+            // silently drops queued messages.
+            if (clearQueue)
+                state.queue.length = 0;
+            return true;
+        });
+    }
     async stop(agentId, _clearQueue = true) {
         await withAgentContext(agentId, async () => {
             const state = this.agents.get(agentId);

package/dist/src/packages/server/routes/agents.js

@@ -910,6 +910,41 @@ router.delete('/:id/memory', (req, res) => {
     log.log(`Agent ${updated.name} (${updated.id}): memory cleared`);
     res.json({ ok: true, id: updated.id });
 });
+// GET /api/agents/:id/queue - Snapshot of the server-side mid-run message
+// queue (messages awaiting delivery once the agent's current turn ends).
+// Positional: each entry's `index` is only valid against THIS snapshot.
+router.get('/:id/queue', (req, res) => {
+    const agent = agentService.getAgent(req.params.id);
+    if (!agent) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+    }
+    const messages = runtimeService.getQueuedMessagesForAgent(req.params.id);
+    res.json({ messages: messages.map((text, index) => ({ index, text })) });
+});
+// DELETE /api/agents/:id/queue/:index - Remove one queued message. Body:
+// { text } — must match the entry at `index` (guards against a queue that
+// drained/mutated since the caller's snapshot; on mismatch → 409, refetch).
+router.delete('/:id/queue/:index', (req, res) => {
+    const agent = agentService.getAgent(req.params.id);
+    if (!agent) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+    }
+    const index = Number.parseInt(req.params.index, 10);
+    const { text } = (req.body ?? {});
+    if (!Number.isInteger(index) || index < 0 || typeof text !== 'string') {
+        res.status(400).json({ error: 'index must be a non-negative integer and text a string' });
+        return;
+    }
+    const removed = runtimeService.removeQueuedMessageForAgent(req.params.id, index, text);
+    if (!removed) {
+        res.status(409).json({ error: 'Queue changed since snapshot — refetch', removed: false });
+        return;
+    }
+    log.log(`Agent ${agent.name} (${agent.id}): queued message ${index} removed via API`);
+    res.json({ removed: true });
+});
 // POST /api/agents/:id/terminal - Start (or reuse) a ttyd attached to the
 // agent's interactive-TUI tmux session (Classic TUI view). Returns the proxy URL.
 router.post('/:id/terminal', async (req, res) => {

package/dist/src/packages/server/routes/system.js

@@ -9,7 +9,7 @@ import * as path from 'path';
 import archiver from 'archiver';
 import { createLogger } from '../utils/logger.js';
 import { fetchLatestNpmVersion, getVersionRelation } from '../../shared/version.js';
-import { endUpdate, getInstallInfo, isAutoUpdateSupported, isUpdateInProgress, runNpmGlobalUpdate, schedulePostUpdateRestart, tryBeginUpdate, } from '../services/self-update-service.js';
+import { endUpdate, getInstallInfo, isAutoUpdateSupported, isUpdateInProgress, runGitPull, runNpmGlobalUpdate, schedulePostUpdateRestart, tryBeginUpdate, } from '../services/self-update-service.js';
 import { getAutoUpdateStatus, setAutoUpdateEnabled } from '../services/auto-update-service.js';
 import { isDevInstall, maybeTriggerWebBundleRebuild } from '../services/web-bundle-builder.js';
 import { deleteClaudeCredentialProfile, getClaudeCredentialProfilesUsage, listClaudeCredentialProfiles, renameClaudeCredentialProfile, saveActiveClaudeCredentialProfile, switchClaudeCredentialProfile, } from '../services/claude-credentials-service.js';
@@ -39,6 +39,7 @@ router.get('/install-info', async (_req, res) => {
             latestVersion,
             updateAvailable,
             autoUpdateSupported: isAutoUpdateSupported(info),
+            gitPullSupported: isDevInstall(info.installRoot),
             writable: info.writable,
             suggestedManualCommand: info.suggestedManualCommand,
             reason: info.reason,
@@ -403,6 +404,59 @@ router.post('/self-update', async (_req, res) => {
         endUpdate();
     }
 });
+/**
+ * POST /api/system/git-pull
+ *
+ * Dev checkouts only (install root has .git/): updates the running install by
+ * executing `git pull --ff-only` in the checkout. A conflict / diverged branch
+ * is a NORMAL outcome — git aborts without touching the tree and we return
+ * { success: false, conflict: true, error } for the UI to display; only
+ * unexpected server errors produce a 5xx. On success the dev tooling picks the
+ * new code up by itself (tsx watch restarts the server, the web bundle
+ * auto-rebuilds); the client just reloads.
+ */
+router.post('/git-pull', async (_req, res) => {
+    const info = getInstallInfo();
+    if (!info.installRoot || !isDevInstall(info.installRoot)) {
+        res.status(400).json({
+            error: 'git pull update is only available when running from a repo checkout (dev mode).',
+            reason: info.reason,
+        });
+        return;
+    }
+    if (!tryBeginUpdate()) {
+        res.status(409).json({ error: 'An update is already in progress.' });
+        return;
+    }
+    try {
+        const result = await runGitPull(info.installRoot);
+        const combined = `${result.stdout}\n${result.stderr}`.trim();
+        if (result.exitCode === 0) {
+            const upToDate = /already up.to.date/i.test(result.stdout);
+            // Re-read package.json — the pull may have bumped the version.
+            const newVersion = getInstallInfo().currentVersion;
+            log.log(`git pull succeeded${upToDate ? ' (already up to date)' : ''} — now at v${newVersion}`);
+            res.json({ success: true, upToDate, newVersion, output: combined });
+            return;
+        }
+        // Conflict-shaped failures: diverged history, overlapping local changes,
+        // or an unfinished merge. --ff-only aborted cleanly — just report it.
+        const conflict = /not possible to fast-forward|divergent branches|would be overwritten by|conflict|needs merge|unmerged/i.test(combined);
+        const error = result.timedOut
+            ? 'git pull timed out.'
+            : result.stderr.trim() || `git pull exited with code ${result.exitCode}.`;
+        log.warn(`git pull failed (conflict=${conflict}): ${error}`);
+        res.json({ success: false, conflict, error, output: combined });
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`git pull update failed: ${message}`);
+        res.status(500).json({ error: message });
+    }
+    finally {
+        endUpdate();
+    }
+});
 /**
  * GET /api/system/auto-update — unattended-update scheduler status.
  * POST /api/system/auto-update { enabled } — opt in/out (persisted).

package/dist/src/packages/server/runtime/claude-runner-router.js

@@ -97,6 +97,12 @@ export class ClaudeRunnerRouter {
     getTurnState(agentId) {
         return this.ownerRunner(agentId).getTurnState?.(agentId);
     }
+    getQueuedMessages(agentId) {
+        return this.ownerRunner(agentId).getQueuedMessages?.(agentId) ?? [];
+    }
+    removeQueuedMessage(agentId, index, expectedText) {
+        return this.ownerRunner(agentId).removeQueuedMessage?.(agentId, index, expectedText) ?? false;
+    }
     /** PID lookup used by runtime-service.getAgentRuntimeProcessInfo. */
     getActiveProcessesState() {
         const headlessState = this.headless.getActiveProcessesState().map((p) => ({ agentId: p.agentId, pid: p.pid }));

package/dist/src/packages/server/runtime/codex-runner-router.js

@@ -64,6 +64,18 @@ export class CodexRunnerRouter {
     sendMessage(agentId, message) {
         return this.ownerRunner(agentId).sendMessage(agentId, message);
     }
+    async interruptTurn(agentId, clearQueue) {
+        const owner = this.ownerRunner(agentId);
+        // Only the app-server runner can interrupt a turn in place; exec falls
+        // back to the caller's stop+respawn path.
+        return owner.interruptTurn ? owner.interruptTurn(agentId, clearQueue) : false;
+    }
+    getQueuedMessages(agentId) {
+        return this.ownerRunner(agentId).getQueuedMessages?.(agentId) ?? [];
+    }
+    removeQueuedMessage(agentId, index, expectedText) {
+        return this.ownerRunner(agentId).removeQueuedMessage?.(agentId, index, expectedText) ?? false;
+    }
     async stop(agentId, clearQueue) {
         await this.exec.stop(agentId, clearQueue);
         await this.appServer.stop(agentId, clearQueue);

package/dist/src/packages/server/runtime/opencode-runner-router.js

@@ -55,6 +55,18 @@ export class OpencodeRunnerRouter {
     sendMessage(agentId, message) {
         return this.ownerRunner(agentId).sendMessage(agentId, message);
     }
+    async interruptTurn(agentId, clearQueue) {
+        const owner = this.ownerRunner(agentId);
+        // Only the server runner can interrupt a turn in place; `opencode run`
+        // falls back to the caller's stop+respawn path.
+        return owner.interruptTurn ? owner.interruptTurn(agentId, clearQueue) : false;
+    }
+    getQueuedMessages(agentId) {
+        return this.ownerRunner(agentId).getQueuedMessages?.(agentId) ?? [];
+    }
+    removeQueuedMessage(agentId, index, expectedText) {
+        return this.ownerRunner(agentId).removeQueuedMessage?.(agentId, index, expectedText) ?? false;
+    }
     async stop(agentId, clearQueue) {
         await this.run_.stop(agentId, clearQueue);
         await this.server.stop(agentId, clearQueue);

package/dist/src/packages/server/services/claude-usage-service.js

@@ -291,6 +291,57 @@ function parseRateLimitWindow(value) {
         resetsAt: window.resets_at,
     };
 }
+// One entry of the endpoint's `limits` array, which carries `percent` where the
+// legacy top-level windows carry `utilization`.
+function parseLimitEntry(entry) {
+    if (typeof entry.percent !== 'number' || !Number.isFinite(entry.percent))
+        return null;
+    if (typeof entry.resets_at !== 'string' || entry.resets_at === '')
+        return null;
+    return { utilization: entry.percent, resetsAt: entry.resets_at };
+}
+// `scope.model.display_name` for a `weekly_scoped` entry ("Fable", "Opus", ...).
+// Its `id` is null, so the display name is the only model discriminator.
+function parseScopedModelName(entry) {
+    const scope = entry.scope;
+    const model = scope?.model;
+    const name = model?.display_name;
+    return typeof name === 'string' && name !== '' ? name.toLowerCase() : null;
+}
+/**
+ * Read the gauges out of the endpoint's `limits` array — its current shape, and
+ * the only one that still carries the per-model weekly allowances: the legacy
+ * top-level `seven_day_opus` / `seven_day_sonnet` keys now come back null even
+ * while those gauges are live in the CLI's `/usage` panel.
+ */
+function parseLimitsArray(body) {
+    const parsed = {};
+    if (!Array.isArray(body.limits))
+        return parsed;
+    for (const raw of body.limits) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const entry = raw;
+        const window = parseLimitEntry(entry);
+        if (!window)
+            continue;
+        if (entry.kind === 'session') {
+            parsed.fiveHour = window;
+        }
+        else if (entry.kind === 'weekly_all') {
+            parsed.sevenDay = window;
+        }
+        else if (entry.kind === 'weekly_scoped') {
+            // Substring match so a renamed "Claude Fable 5" still lands on its gauge.
+            const model = parseScopedModelName(entry);
+            if (model?.includes('fable'))
+                parsed.sevenDayFable = window;
+            else if (model?.includes('opus'))
+                parsed.sevenDayOpus = window;
+        }
+    }
+    return parsed;
+}
 // `Retry-After` is either delta-seconds or an HTTP date; return ms-from-now.
 function parseRetryAfterMs(headerValue) {
     if (!headerValue)
@@ -328,14 +379,15 @@ export async function fetchClaudeRateLimitsForToken(accessToken) {
             };
         }
         const body = await response.json();
-        // Claude Code 2.1.207 labels this allowance "Fable", although the live
-        // endpoint still exposes it under the legacy seven_day_sonnet key.
-        const sevenDayFable = parseRateLimitWindow(body.seven_day_fable ?? body.seven_day_sonnet);
+        // `limits[]` wins; the top-level windows are the fallback for older payloads.
+        const limits = parseLimitsArray(body);
+        const sevenDayFable = limits.sevenDayFable
+            ?? parseRateLimitWindow(body.seven_day_fable ?? body.seven_day_sonnet);
         return {
             rateLimits: {
-                fiveHour: parseRateLimitWindow(body.five_hour),
-                sevenDay: parseRateLimitWindow(body.seven_day),
-                sevenDayOpus: parseRateLimitWindow(body.seven_day_opus),
+                fiveHour: limits.fiveHour ?? parseRateLimitWindow(body.five_hour),
+                sevenDay: limits.sevenDay ?? parseRateLimitWindow(body.seven_day),
+                sevenDayOpus: limits.sevenDayOpus ?? parseRateLimitWindow(body.seven_day_opus),
                 sevenDayFable,
                 sevenDaySonnet: sevenDayFable,
             },

package/dist/src/packages/server/services/runtime-command-execution.js

@@ -111,8 +111,9 @@ export function createRuntimeCommandExecution(deps) {
             if (opts?.forceInterrupt) {
                 log.log(`[sendCommand] Agent ${agentId} (${agent.provider}): forceInterrupt mid-run (turnState=${turnState ?? 'unknown'}) — interrupting and restarting with new prompt`);
                 emitOutput(agentId, '🛑 [System] Interrupting current work to process new prompt…', false, undefined, 'system-interrupt-restart');
-                // clearQueue=true: user is replacing pending mid-run work with this command
-                await runner.stop(agentId, true);
+                // clearQueue=false: other queued mid-run messages survive the interrupt
+                // (visible as chips in the queue bar) and drain after the forced turn.
+                await runner.stop(agentId, false);
                 agentService.updateAgent(agentId, { taskCount: (agent.taskCount || 0) + 1 });
                 await executeCommand(agentId, command, systemPrompt, forceNewSession, customAgent);
                 return;
@@ -145,13 +146,70 @@ export function createRuntimeCommandExecution(deps) {
             await executeCommand(agentId, command, systemPrompt, forceNewSession, customAgent);
             return;
         }
+        // Persistent-stream backends (Codex app-server, OpenCode serve) keep one
+        // daemon alive across turns, so "Send now" cannot stop+respawn like the
+        // stdin-closed CLIs above — runner.stop() would abandon the live thread/
+        // session. Instead interrupt the in-flight turn in place (clearQueue=true:
+        // the user is replacing pending mid-run work) and hand the prompt to the
+        // runner queue; it is delivered the moment the aborted turn finalizes.
+        if (processRunning &&
+            !forceNewSession &&
+            opts?.forceInterrupt &&
+            runner.interruptTurn &&
+            runner.getTurnState?.(agentId) === 'processing') {
+            log.log(`[sendCommand] Agent ${agentId} (${agent.provider}): forceInterrupt mid-turn on persistent runner — interrupting turn in place`);
+            emitOutput(agentId, '🛑 [System] Interrupting current work to process new prompt…', false, undefined, 'system-interrupt-restart');
+            // Snapshot other queued messages so the forced prompt can jump the line
+            // without dropping them: clear, send the forced prompt (queue head),
+            // then re-append the siblings behind it.
+            const siblings = runner.getQueuedMessages?.(agentId) ?? [];
+            const interrupted = await runner.interruptTurn(agentId, true);
+            if (interrupted) {
+                const sentNow = runner.sendMessage(agentId, command);
+                for (const sibling of siblings) {
+                    if (!runner.sendMessage(agentId, sibling)) {
+                        log.warn(`[sendCommand] Agent ${agentId}: could not restore a queued message after interrupt (${sibling.length} chars dropped)`);
+                    }
+                }
+                if (sentNow) {
+                    notifyCommandStarted(agentId, command);
+                    const isSystemMessage = command.startsWith('[System:');
+                    const updateData = {
+                        status: 'working',
+                        taskCount: (agent.taskCount || 0) + 1,
+                    };
+                    if (!isSystemMessage) {
+                        updateData.lastAssignedTask = command;
+                        updateData.lastAssignedTaskTime = Date.now();
+                        updateData.taskLabel = undefined; // Clear for agent to regenerate via skill
+                    }
+                    agentService.updateAgent(agentId, updateData);
+                    return;
+                }
+            }
+            log.warn(`[sendCommand] Agent ${agentId}: in-place turn interrupt failed — falling through to default delivery`);
+        }
         if (processRunning && !forceNewSession) {
             if (runner.supportsStdin()) {
                 const turnState = runner.getTurnState?.(agentId) || 'unknown';
                 log.log(`[sendCommand] Agent ${agentId}: Process alive, reusing via stdin (turnState=${turnState}, cmd=${command.substring(0, 60)})`);
+                // Persistent-stream runners (codex app-server, opencode serve) queue
+                // mid-turn messages internally instead of writing them through. Detect
+                // that via the queue length so the client sees the same queued
+                // feedback (⏳ + queued command_started) as the stdin-closed path.
+                const queueLenBefore = runner.getQueuedMessages?.(agentId).length ?? 0;
                 const sent = runner.sendMessage(agentId, command);
+                const wasQueued = (runner.getQueuedMessages?.(agentId).length ?? 0) > queueLenBefore;
                 if (sent) {
-                    notifyCommandStarted(agentId, command);
+                    if (wasQueued) {
+                        notifyCommandStarted(agentId, command, { queued: true });
+                    }
+                    else {
+                        notifyCommandStarted(agentId, command);
+                    }
+                    if (wasQueued) {
+                        emitOutput(agentId, `⏳ [System] Mid-run message for ${providerDisplayName(agent.provider)} will be sent when the agent is free`, false, undefined, `system-midrun-queued-${Date.now()}`);
+                    }
                     const isSystemMessage = command.startsWith('[System:');
                     const updateData = {
                         status: 'working',

package/dist/src/packages/server/services/runtime-service.js

@@ -207,6 +207,16 @@ export async function sendCommand(agentId, command, systemPrompt, forceNewSessio
 export async function sendSilentCommand(agentId, command) {
     await commandExecution.sendSilentCommand(agentId, command);
 }
+/** Snapshot of the agent's server-side mid-run message queue (runner-owned). */
+export function getQueuedMessagesForAgent(agentId) {
+    const runner = getRunnerForAgent(agentId);
+    return runner?.getQueuedMessages?.(agentId) ?? [];
+}
+/** Remove one queued mid-run message by position (guarded by expectedText). */
+export function removeQueuedMessageForAgent(agentId, index, expectedText) {
+    const runner = getRunnerForAgent(agentId);
+    return runner?.removeQueuedMessage?.(agentId, index, expectedText) ?? false;
+}
 /**
  * Send Claude Code's `/compact` slash command to collapse an agent's context.
  * Only fires when the agent exists AND is idle — the CLI rejects slash commands