tide-commander 1.134.2 → 1.136.0

package/dist/assets/{web-CHTqiViU.js → web-C4yrL2Hp.js}

@@ -1 +1 @@
-import{cO as a}from"./main-DhXGHPKx.js";import{ImpactStyle as i,NotificationType as r}from"./index-7EfWB7v9.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{cO as a}from"./main-CHE4wC7P.js";import{ImpactStyle as i,NotificationType as r}from"./index-CLmNQzTF.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/assets/{web-g3yRdGTs.js → web-D1Ur_Mtd.js}

@@ -1 +1 @@
-import{cO as t}from"./main-DhXGHPKx.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{cO as t}from"./main-CHE4wC7P.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-CDTjrhUg.js → web-dmnfXY_q.js}

@@ -1 +1 @@
-import{cO as s}from"./main-DhXGHPKx.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{cO as s}from"./main-CHE4wC7P.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/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-DhXGHPKx.js"></script>
+    <script type="module" crossorigin src="/assets/main-CHE4wC7P.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-rrlO1Py8.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-DM0iS4EN.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/locales/en/terminal.json

@@ -1,4 +1,17 @@
 {
+  "search": {
+    "tabContent": "Content",
+    "tabFiles": "Files",
+    "typeToSearch": "Type at least 2 characters to search",
+    "indexing": "Indexing conversation…",
+    "noContent": "No matching messages",
+    "noFiles": "No referenced files match",
+    "opRead": "Read",
+    "opEdit": "Edited",
+    "opWrite": "Written",
+    "openFile": "Open file in a modal",
+    "goToMessage": "Go to the message in chat"
+  },
   "header": {
     "openSidebar": "Open sidebar",
     "closeSidebar": "Close sidebar",

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

@@ -128,6 +128,14 @@ export class InteractiveClaudeRunner {
             lastRequest: entry.lastRequest,
         };
         this.processes.set(entry.agentId, proc);
+        // loadAgentsFromDisk() flattens every agent to 'idle' on server start, so
+        // restore 'working' from the status captured at persist time. Must happen
+        // BEFORE watcher.start(): its synchronous replay delivers any end-of-turn
+        // events from the downtime, flipping the agent back to idle if the turn
+        // actually finished while we were down.
+        if (entry.agentStatus === 'working' && agentService.getAgent(entry.agentId)) {
+            agentService.updateAgent(entry.agentId, { status: 'working' });
+        }
         // start() synchronously reads from the saved offset to EOF, emitting any
         // events that landed while we were down (incl. a trailing end_turn →
         // step_complete → idle), then continues live-tailing.

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

@@ -1,8 +1,58 @@
+import * as fs from 'fs';
 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, killTmuxSession, listAgentTmuxSessions, tmuxLogPath } from './tmux-helper.js';
+import { hasTmuxSession, isTmuxEnabled, killTmuxSession, listAgentTmuxSessions, tmuxLogPath, tmuxSessionName } from './tmux-helper.js';
 const log = createLogger('Runner');
+const TAIL_SCAN_BYTES = 64 * 1024;
+/**
+ * Derive whether the CLI inside a live tmux session is mid-turn by scanning
+ * the tail of its log for the last complete stream-json event: claude emits
+ * `{type:'result'}` at end of turn, so a trailing result means the agent is
+ * waiting for input; any other trailing event means a turn is in flight.
+ * Used for sessions recovered WITHOUT a persist entry, where the persisted
+ * agentStatus is unavailable.
+ */
+function scanLogTailForStatus(logFile) {
+    let fd;
+    try {
+        const stat = fs.statSync(logFile);
+        if (stat.size === 0)
+            return 'idle';
+        const readLen = Math.min(stat.size, TAIL_SCAN_BYTES);
+        const buf = Buffer.alloc(readLen);
+        fd = fs.openSync(logFile, 'r');
+        fs.readSync(fd, buf, 0, readLen, stat.size - readLen);
+        fs.closeSync(fd);
+        fd = undefined;
+        // Walk complete lines from the end; the first parseable JSON event wins.
+        // Partial trailing writes and the (possibly truncated) chunk head fail
+        // JSON.parse and are skipped naturally.
+        const lines = buf.toString('utf8').split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event && typeof event.type === 'string') {
+                    return event.type === 'result' ? 'idle' : 'working';
+                }
+            }
+            catch { /* partial/truncated line — keep walking back */ }
+        }
+        return 'idle';
+    }
+    catch {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+        }
+        return 'idle';
+    }
+}
 export class RunnerRecoveryStore {
     backend;
     activeProcesses;
@@ -131,14 +181,56 @@ export class RunnerRecoveryStore {
                 toResume.push(savedProcess);
             }
         }
-        // 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) => {
+        // Persist-file entries can be lost (a restart landing before the
+        // post-reconnect persist below, or a hard crash), but the tmux sessions
+        // themselves survive. Treat live `tc-*` sessions as the source of truth:
+        // any session whose agent belongs to this provider and has no persist
+        // entry gets a synthesized reconnect entry tailing from the log's current
+        // end, with status derived from the last event in the log.
+        if (isTmuxEnabled()) {
+            const pending = new Set(toReconnectTmux.map((p) => p.agentId));
+            for (const agentId of listAgentTmuxSessions()) {
+                if (this.activeProcesses.has(agentId) || pending.has(agentId))
+                    continue;
+                const agent = agentService.getAgent(agentId);
+                if (!agent)
+                    continue; // killUnknownTmuxSessions() already handles these
+                if ((agent.provider ?? 'claude') !== this.backend.name)
+                    continue;
+                const logFile = tmuxLogPath(agentId);
+                let offset = 0;
+                try {
+                    offset = fs.statSync(logFile).size;
+                }
+                catch { /* no log yet — reconnect from 0 */ }
+                // Stdin-closed backends (codex/opencode) exit at end of turn, so a
+                // live session is mid-turn by definition.
+                const closesStdin = this.backend.shouldCloseStdinAfterPrompt?.() === true;
+                const agentStatus = closesStdin ? 'working' : scanLogTailForStatus(logFile);
+                log.log(`✅ [TMUX] Live session ${tmuxSessionName(agentId)} has no persist entry — reconnecting at EOF (offset=${offset}, derived status=${agentStatus})`);
+                toReconnectTmux.push({
+                    agentId,
+                    pid: 0,
+                    sessionId: agent.sessionId,
+                    startTime: Date.now(),
+                    agentStatus,
+                    tmuxSession: tmuxSessionName(agentId),
+                    tmuxLogOffset: offset,
+                    provider: this.backend.name,
+                });
+            }
+        }
+        // Rewrite the persist file: other providers' entries stay untouched, and
+        // our to-reconnect tmux entries are KEPT (not consumed) — if the server
+        // dies again before the reconnect below re-persists, the next boot can
+        // still find them. Everything else of ours is consumed.
+        const otherProviders = savedProcesses.filter((p) => {
             const prov = p.provider ?? agentService.getAgent(p.agentId)?.provider ?? 'claude';
             return prov !== this.backend.name;
         });
-        if (remaining.length > 0) {
-            saveRunningProcesses(remaining);
+        const preserved = [...otherProviders, ...toReconnectTmux];
+        if (preserved.length > 0) {
+            saveRunningProcesses(preserved);
         }
         else {
             clearRunningProcesses();
@@ -157,6 +249,10 @@ export class RunnerRecoveryStore {
                     log.log(`🔄 [TMUX] Reconnecting to tmux session for agent ${saved.agentId} at offset ${offset}`);
                     this.reconnectTmux(saved.agentId, logFile, offset, saved);
                 }
+                // Re-persist immediately so the freshly tracked processes survive
+                // another quick restart (the periodic persist is up to 10s away, and
+                // tsx-watch dev restarts land inside that window all the time).
+                this.persistRunningProcesses();
             }, 1000);
         }
         if (toResume.length === 0) {

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

@@ -547,32 +547,52 @@ export class ClaudeRunner {
         // Create a dummy child process (we don't own the real one — tmux does)
         const dummyProcess = spawn('true', [], { stdio: 'ignore' });
         dummyProcess.unref();
+        // loadAgentsFromDisk() flattens every agent to 'idle' on server start, so
+        // the in-memory status can't tell us whether this agent was mid-task —
+        // use the status captured in the persist file (refreshed every 10s and on
+        // graceful shutdown) instead.
+        const agent = agentService.getAgent(agentId);
+        const wasWorking = agent?.status === 'working' || savedProcess?.agentStatus === 'working';
+        const lastRequest = savedProcess?.lastRequest;
         const activeProcess = {
             agentId,
             sessionId: savedProcess?.sessionId,
             startTime: savedProcess?.startTime ?? Date.now(),
             process: dummyProcess,
-            lastRequest: savedProcess?.lastRequest,
+            lastRequest,
             restartCount: 0,
-            turnState: 'waiting_for_input',
+            turnState: wasWorking ? 'processing' : 'waiting_for_input',
+            // Fresh baseline: with the saved startTime as fallback, the watchdog's
+            // idle-timeout would see hours of "inactivity" and kill the live
+            // session on its first tick after a restart.
+            lastActivityTime: Date.now(),
             tmuxSession: sessionName,
             tmuxLogFile: logFile,
             isReconnected: true,
         };
         this.activeProcesses.set(agentId, activeProcess);
-        // Resume tailing the log file from where we left off
-        const tailer = this.stdoutPipeline.handleTmuxLog(agentId, logFile, offset);
-        activeProcess.tmuxTailer = tailer;
-        // Ensure the agent status reflects that we're connected
-        const agent = agentService.getAgent(agentId);
-        if (agent && agent.status === 'working') {
-            // Keep it as working — it was mid-task when the server restarted
+        if (agent && wasWorking) {
+            // Mid-task when the previous instance went down — re-assert 'working'
+            // so the UI doesn't show idle and the watchdog's idle-timeout doesn't
+            // kill the live session.
+            agentService.updateAgent(agentId, {
+                status: 'working',
+                ...(typeof lastRequest?.prompt === 'string' && lastRequest.prompt.length > 0
+                    ? { currentTask: lastRequest.prompt.substring(0, 100) }
+                    : {}),
+            });
         }
         else if (agent) {
             // Set to idle — the tmux session is alive but waiting for input
             agentService.updateAgent(agentId, { status: 'idle' });
         }
-        log.log(`✅ [TMUX] Reconnected to tmux session ${sessionName} for agent ${agentId}`);
+        // Resume tailing the log file from where we left off. start() replays any
+        // events that landed during the downtime synchronously, so this must run
+        // AFTER the status restore above: if the turn actually ended while we were
+        // down, the replayed end-of-turn events flip the agent back to idle.
+        const tailer = this.stdoutPipeline.handleTmuxLog(agentId, logFile, offset);
+        activeProcess.tmuxTailer = tailer;
+        log.log(`✅ [TMUX] Reconnected to tmux session ${sessionName} for agent ${agentId} (status=${wasWorking ? 'working' : 'idle'})`);
     }
     interrupt(agentId) {
         return withAgentContext(agentId, () => this.lifecycle.interrupt(agentId));

package/dist/src/packages/server/data/index.js

@@ -147,6 +147,7 @@ function toStoredAgents(agents) {
         autoCollapse: agent.autoCollapse,
         autoCollapseCron: agent.autoCollapseCron,
         autoCollapseTz: agent.autoCollapseTz,
+        autoCollapsePrompt: agent.autoCollapsePrompt,
         isBoss: agent.isBoss,
         subordinateIds: agent.subordinateIds,
         bossId: agent.bossId,

package/dist/src/packages/server/services/auto-collapse-service.js

@@ -66,8 +66,14 @@ function armJob(agentId, config) {
 }
 async function runCollapse(agentId, expression, timezone) {
     try {
-        const result = await collapseAgentContext(agentId, { waitForIdle: true });
-        log.log(`Auto-collapse fired for agent ${agentId} ('${expression}' ${timezone}): ${result.status}`);
+        // Read the prompt at fire time (not arm time) so edits to it apply on the
+        // next collapse without re-arming the cron job.
+        const afterPrompt = (agentService.getAgent(agentId)?.autoCollapsePrompt ?? '').trim() || undefined;
+        const result = await collapseAgentContext(agentId, {
+            waitForIdle: true,
+            ...(afterPrompt ? { afterPrompt } : {}),
+        });
+        log.log(`Auto-collapse fired for agent ${agentId} ('${expression}' ${timezone}): ${result.status}${afterPrompt ? ' [post-collapse prompt armed]' : ''}`);
     }
     catch (err) {
         log.error(`Auto-collapse failed for agent ${agentId}:`, err);

package/dist/src/packages/server/services/collapse-context.js

@@ -2,9 +2,10 @@
  * Collapse-Context Service
  *
  * Owns the small queue of pending `/compact` requests that need to fire as
- * soon as their agent transitions back to idle. Two callers use it: the REST
- * endpoint `POST /api/agents/:id/collapse-context` and the WS
- * `collapse_context` handler.
+ * soon as their agent transitions back to idle. Callers: the REST endpoint
+ * `POST /api/agents/:id/collapse-context`, the WS `collapse_context` handler,
+ * and the auto-collapse cron (which may also pass an `afterPrompt` — a command
+ * dispatched to the agent once its compact turn finishes).
  *
  * Why a separate module: the queue + idle-drain logic is the only piece of
  * state we want to unit-test in isolation, and `runtime-service` is heavy with
@@ -13,43 +14,80 @@
  * up the real agent service.
  */
 export function createCollapseContextService(deps) {
-    const pending = new Set();
+    const pending = new Map();
+    // Prompts armed AFTER their `/compact` was dispatched — sent on the agent's
+    // next idle transition (i.e. when the compact turn finishes).
+    const afterPrompts = new Map();
     let unsubscribe = null;
     // Lazy subscription — we only attach the listener once a real queue exists.
-    // Stays attached for the process lifetime; the pending set is the gate that
-    // decides whether the listener does anything on each event.
+    // Stays attached for the process lifetime; the pending/afterPrompts maps are
+    // the gate that decides whether the listener does anything on each event.
     function ensureSubscribed() {
         if (unsubscribe)
             return;
         unsubscribe = deps.subscribe((event, data) => {
+            if (event === 'deleted' && typeof data === 'string') {
+                pending.delete(data);
+                afterPrompts.delete(data);
+                return;
+            }
             if (event !== 'updated' || !data || typeof data === 'string')
                 return;
             const agent = data;
             if (agent.status !== 'idle')
                 return;
-            if (!pending.has(agent.id))
+            const queued = pending.get(agent.id);
+            if (queued) {
+                pending.delete(agent.id);
+                void drain(agent.id, queued.afterPrompt);
                 return;
-            pending.delete(agent.id);
-            void drain(agent.id);
+            }
+            const prompt = afterPrompts.get(agent.id);
+            if (prompt !== undefined) {
+                afterPrompts.delete(agent.id);
+                void sendAfterPrompt(agent.id, prompt);
+            }
         });
     }
-    async function drain(agentId) {
+    // Register the post-collapse prompt only after `/compact` was actually sent:
+    // sendCommand flips the agent to 'working' synchronously, so the idle event
+    // this arms against is the one that ends the compact turn.
+    function armAfterPrompt(agentId, prompt) {
+        ensureSubscribed();
+        afterPrompts.set(agentId, prompt);
+    }
+    async function drain(agentId, afterPrompt) {
         try {
             await deps.sendCommand(agentId, '/compact');
             deps.log?.info?.(`Drained queued collapse for ${agentId} after idle transition`);
+            if (afterPrompt)
+                armAfterPrompt(agentId, afterPrompt);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             deps.log?.error?.(`Failed to drain queued collapse for ${agentId}: ${msg}`);
         }
     }
+    async function sendAfterPrompt(agentId, prompt) {
+        try {
+            await deps.sendCommand(agentId, prompt);
+            deps.log?.info?.(`Sent post-collapse prompt to ${agentId}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            deps.log?.error?.(`Failed to send post-collapse prompt to ${agentId}: ${msg}`);
+        }
+    }
     async function collapse(agentId, opts = {}) {
         const agent = deps.getAgent(agentId);
         if (!agent)
             return { status: 'not-found' };
+        const afterPrompt = opts.afterPrompt?.trim() || undefined;
         if (agent.status === 'idle') {
             try {
                 await deps.sendCommand(agentId, '/compact');
+                if (afterPrompt)
+                    armAfterPrompt(agentId, afterPrompt);
                 return { status: 'collapse-initiated' };
             }
             catch (err) {
@@ -58,8 +96,9 @@ export function createCollapseContextService(deps) {
         }
         if (opts.waitForIdle) {
             ensureSubscribed();
-            // Set.add is idempotent — multiple `waitForIdle` calls coalesce into one drain.
-            pending.add(agentId);
+            // Map.set is idempotent per agent — multiple `waitForIdle` calls coalesce
+            // into one drain; the latest call's afterPrompt wins.
+            pending.set(agentId, { afterPrompt });
             return { status: 'queued' };
         }
         return { status: 'busy', currentStatus: agent.status };
@@ -68,5 +107,6 @@ export function createCollapseContextService(deps) {
         collapse,
         hasPending: (id) => pending.has(id),
         pendingCount: () => pending.size,
+        hasPendingPrompt: (id) => afterPrompts.has(id),
     };
 }