tide-commander 1.8.2 → 1.8.3

package/dist/assets/{web-BSATmfpK.js → web-Cc07_VE8.js}

@@ -1 +1 @@
-import{W as a}from"./main-DscwhTSu.js";import{ImpactStyle as i,NotificationType as r}from"./index-rAvAlVdj.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react-uS-d4TUT.js";import"./vendor-three-DJ4p3FLF.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{W as a}from"./main-BkgbNnt9.js";import{ImpactStyle as i,NotificationType as r}from"./index-B6Hy-8p3.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react-uS-d4TUT.js";import"./vendor-three-DJ4p3FLF.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/assets/{web-mzT7C3OO.js → web-lhvbQgV6.js}

@@ -1 +1 @@
-import{W as s}from"./main-DscwhTSu.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react-uS-d4TUT.js";import"./vendor-three-DJ4p3FLF.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{W as s}from"./main-BkgbNnt9.js";import"./modulepreload-polyfill-B5Qt9EMX.js";import"./vendor-react-uS-d4TUT.js";import"./vendor-three-DJ4p3FLF.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/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-DscwhTSu.js"></script>
+    <script type="module" crossorigin src="/assets/main-BkgbNnt9.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/modulepreload-polyfill-B5Qt9EMX.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-uS-d4TUT.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-DJ4p3FLF.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-B8W4PG4C.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-CfLrhuQx.css">
   </head>
   <body>
     <div id="app"></div>

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

@@ -1,4 +1,5 @@
 import { saveRunningProcesses, loadRunningProcesses, isProcessRunning, clearRunningProcesses, } from '../../data/index.js';
+import * as agentService from '../../services/agent-service.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('Runner');
 export class RunnerRecoveryStore {
@@ -14,6 +15,7 @@ export class RunnerRecoveryStore {
         const processes = [];
         for (const [agentId, activeProcess] of this.activeProcesses) {
             if (activeProcess.process.pid) {
+                const agent = agentService.getAgent(agentId);
                 processes.push({
                     agentId,
                     pid: activeProcess.process.pid,
@@ -22,6 +24,7 @@ export class RunnerRecoveryStore {
                     outputFile: activeProcess.outputFile,
                     stderrFile: activeProcess.stderrFile,
                     lastRequest: activeProcess.lastRequest,
+                    agentStatus: agent?.status,
                 });
             }
         }
@@ -48,6 +51,12 @@ export class RunnerRecoveryStore {
             }
             log.log(`❌ Process for agent ${savedProcess.agentId} (PID ${savedProcess.pid}) is no longer running`);
             if (!this.backend.requiresStdinInput() && savedProcess.sessionId && savedProcess.lastRequest) {
+                // Only resume agents that were actively working when persisted.
+                // Idle agents with live processes (e.g. Codex waiting for stdin) should not be resumed.
+                if (savedProcess.agentStatus && savedProcess.agentStatus !== 'working') {
+                    log.log(`🔄 [RESUME] Skipping resume for agent ${savedProcess.agentId} - was ${savedProcess.agentStatus} (not working)`);
+                    continue;
+                }
                 toResume.push(savedProcess);
             }
         }
@@ -57,6 +66,12 @@ export class RunnerRecoveryStore {
         }
         setTimeout(() => {
             for (const saved of toResume) {
+                // Verify the agent still exists (it may have been deleted)
+                const agent = agentService.getAgent(saved.agentId);
+                if (!agent) {
+                    log.log(`🔄 [RESUME] Skipping resume for agent ${saved.agentId} - agent no longer exists`);
+                    continue;
+                }
                 const lastRequest = saved.lastRequest;
                 log.log(`🔄 [RESUME] Resuming codex session for agent ${saved.agentId} (session ${saved.sessionId})`);
                 this.run({

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

@@ -102,9 +102,17 @@ function parseResponsePayload(payload) {
     return {
         type: asString(payload.type),
         status: asString(payload.status),
+        text: asString(payload.text),
         action: parseAction(payload.action),
         item: parseItem(payload.item),
         usage: parseUsage(payload.usage),
+        info: isObject(payload.info)
+            ? {
+                model_context_window: asNumber(payload.info.model_context_window),
+                last_token_usage: parseUsage(payload.info.last_token_usage),
+            }
+            : undefined,
+        model_context_window: asNumber(payload.model_context_window),
         call_id: asString(payload.call_id),
         name: asString(payload.name),
         input: asString(payload.input),
@@ -119,6 +127,7 @@ function parseResponsePayload(payload) {
 export class CodexJsonEventParser {
     activeToolByItemId = new Map();
     lastAgentMessageText;
+    lastModelUsageSnapshot;
     enableFileDiffEnrichment;
     workingDirectory;
     gitRootCache = new Map();
@@ -148,7 +157,7 @@ export class CodexJsonEventParser {
         if (!event?.type)
             return [];
         if (event.type === 'event_msg') {
-            return this.parseEventMsg(rawEvent);
+            return this.parseEventMsg(event.payload);
         }
         if (event.type === 'response_item') {
             return this.parseResponseItem(event.payload);
@@ -172,15 +181,19 @@ export class CodexJsonEventParser {
         }
         return [this.buildUnknownEventFallback(`Unhandled Codex event type: ${event.type}`, rawEvent)];
     }
-    parseEventMsg(rawEvent) {
-        if (!isObject(rawEvent))
-            return [];
-        const payload = rawEvent.payload;
-        if (!isObject(payload))
+    parseEventMsg(payload) {
+        if (!payload)
             return [];
         const payloadType = asString(payload.type);
         // token_count: Silent. Token accounting is handled by turn.completed.
         if (payloadType === 'token_count') {
+            const usage = payload.info?.last_token_usage;
+            this.lastModelUsageSnapshot = {
+                contextWindow: payload.info?.model_context_window ?? this.lastModelUsageSnapshot?.contextWindow,
+                inputTokens: usage?.input_tokens,
+                outputTokens: usage?.output_tokens,
+                cacheReadInputTokens: usage?.cached_input_tokens,
+            };
             return [];
         }
         // agent_reasoning: Map to thinking event
@@ -196,6 +209,12 @@ export class CodexJsonEventParser {
         }
         // task_started: Silent. Envelope event with no user-facing content.
         if (payloadType === 'task_started') {
+            if (payload.model_context_window) {
+                this.lastModelUsageSnapshot = {
+                    ...this.lastModelUsageSnapshot,
+                    contextWindow: payload.model_context_window,
+                };
+            }
             return [];
         }
         // user_message / agent_message are handled via item.completed, skip if seen here
@@ -434,6 +453,18 @@ export class CodexJsonEventParser {
             event.resultText = this.lastAgentMessageText;
             this.lastAgentMessageText = undefined; // Reset for next turn
         }
+        if (this.lastModelUsageSnapshot && (this.lastModelUsageSnapshot.contextWindow
+            || this.lastModelUsageSnapshot.inputTokens !== undefined
+            || this.lastModelUsageSnapshot.outputTokens !== undefined
+            || this.lastModelUsageSnapshot.cacheReadInputTokens !== undefined)) {
+            event.modelUsage = {
+                contextWindow: this.lastModelUsageSnapshot.contextWindow,
+                inputTokens: this.lastModelUsageSnapshot.inputTokens ?? 0,
+                outputTokens: this.lastModelUsageSnapshot.outputTokens ?? 0,
+                cacheReadInputTokens: this.lastModelUsageSnapshot.cacheReadInputTokens ?? 0,
+            };
+            this.lastModelUsageSnapshot = undefined;
+        }
         return [event];
     }
     parseFileChange(item) {

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

@@ -3,12 +3,19 @@
  * Business logic for managing agents
  */
 import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import { loadAgents, saveAgents, saveAgentsAsync, getDataDir } from '../data/index.js';
 import { listSessions, getSessionSummary, loadSession, loadToolHistory, searchSession, } from '../claude/session-loader.js';
 import { loadSubagentHistory } from '../claude/subagent-history-loader.js';
 import { logger, generateId } from '../utils/index.js';
 const log = logger.agent;
 const CLAUDE_MODELS = new Set(['sonnet', 'opus', 'haiku']);
+const DEFAULT_CLAUDE_CONTEXT_LIMIT = 200000;
+const DEFAULT_CODEX_CONTEXT_LIMIT = 258400;
+function getDefaultContextLimit(provider) {
+    return provider === 'codex' ? DEFAULT_CODEX_CONTEXT_LIMIT : DEFAULT_CLAUDE_CONTEXT_LIMIT;
+}
 // In-memory agent storage
 const agents = new Map();
 const listeners = new Set();
@@ -29,6 +36,101 @@ export function sanitizeCodexModel(model) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+function findFileRecursively(rootDir, pattern) {
+    if (!fs.existsSync(rootDir))
+        return null;
+    const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = findFileRecursively(fullPath, pattern);
+            if (nested)
+                return nested;
+            continue;
+        }
+        if (entry.isFile() && entry.name.includes(pattern) && entry.name.endsWith('.jsonl')) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+function findCodexRolloutPath(sessionId) {
+    const codexHome = path.join(os.homedir(), '.codex');
+    return findFileRecursively(path.join(codexHome, 'sessions'), sessionId)
+        || findFileRecursively(path.join(codexHome, 'archived_sessions'), sessionId);
+}
+function getCodexLogPath() {
+    return path.join(os.homedir(), '.codex', 'log', 'codex-tui.log');
+}
+function parseCodexEstimatedContextSnapshot(sessionId, contextLimit) {
+    const logPath = getCodexLogPath();
+    if (!fs.existsSync(logPath))
+        return null;
+    const lines = fs.readFileSync(logPath, 'utf8').split('\n');
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (!line.includes(sessionId) || !line.includes('estimated_token_count=Some('))
+            continue;
+        const estimatedMatch = line.match(/estimated_token_count=Some\((\d+)\)/);
+        if (!estimatedMatch)
+            continue;
+        const estimatedTokens = Number(estimatedMatch[1]);
+        if (!Number.isFinite(estimatedTokens) || estimatedTokens < 0)
+            continue;
+        return {
+            contextUsed: Math.max(0, Math.round(estimatedTokens)),
+            contextLimit,
+        };
+    }
+    return null;
+}
+function parseCodexContextSnapshot(rolloutPath) {
+    if (!fs.existsSync(rolloutPath))
+        return null;
+    const lines = fs.readFileSync(rolloutPath, 'utf8').split('\n');
+    let contextLimit = DEFAULT_CODEX_CONTEXT_LIMIT;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index].trim();
+        if (!line)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const payload = parsed?.payload;
+            if (payload?.type === 'token_count' && payload.info) {
+                const modelContextWindow = Number(payload.info.model_context_window);
+                if (Number.isFinite(modelContextWindow) && modelContextWindow > 0) {
+                    contextLimit = modelContextWindow;
+                }
+                const inputTokens = Number(payload.info?.last_token_usage?.input_tokens);
+                if (Number.isFinite(inputTokens) && inputTokens >= 0) {
+                    return {
+                        contextUsed: Math.min(Math.round(inputTokens), contextLimit),
+                        contextLimit,
+                    };
+                }
+            }
+            if (payload?.type === 'task_started') {
+                const modelContextWindow = Number(payload.model_context_window);
+                if (Number.isFinite(modelContextWindow) && modelContextWindow > 0) {
+                    contextLimit = modelContextWindow;
+                }
+            }
+        }
+        catch {
+            // Ignore malformed lines and continue scanning older entries.
+        }
+    }
+    return null;
+}
+export function getCodexContextSnapshotFromSession(sessionId) {
+    if (!sessionId)
+        return null;
+    const rolloutPath = findCodexRolloutPath(sessionId);
+    const rolloutSnapshot = rolloutPath ? parseCodexContextSnapshot(rolloutPath) : null;
+    const contextLimit = rolloutSnapshot?.contextLimit ?? DEFAULT_CODEX_CONTEXT_LIMIT;
+    const estimatedSnapshot = parseCodexEstimatedContextSnapshot(sessionId, contextLimit);
+    return estimatedSnapshot ?? rolloutSnapshot;
+}
 // ============================================================================
 // Initialization
 // ============================================================================
@@ -36,16 +138,29 @@ export function initAgents() {
     try {
         const storedAgents = loadAgents();
         for (const stored of storedAgents) {
-            const contextLimit = stored.contextLimit ?? 200000;
+            const isCodexProvider = (stored.provider ?? 'claude') === 'codex';
+            const repairedCodexContext = isCodexProvider
+                ? getCodexContextSnapshotFromSession(stored.sessionId)
+                : null;
+            const defaultContextLimit = getDefaultContextLimit(stored.provider ?? 'claude');
+            const migratedPersistedContextLimit = isCodexProvider
+                && (stored.contextLimit === undefined || stored.contextLimit === DEFAULT_CLAUDE_CONTEXT_LIMIT)
+                ? defaultContextLimit
+                : stored.contextLimit;
+            const contextLimit = repairedCodexContext?.contextLimit ?? migratedPersistedContextLimit ?? defaultContextLimit;
             const tokensUsed = stored.tokensUsed ?? 0;
             // Preserve persisted context usage. Falling back to lifetime tokens can
             // inflate context on restart because tokensUsed is cumulative over time.
             const persistedContextUsed = typeof stored.contextUsed === 'number'
                 ? stored.contextUsed
                 : tokensUsed;
+            const baseContextUsed = repairedCodexContext?.contextUsed ?? persistedContextUsed;
             // Don't clamp to contextLimit - contextUsed can legitimately exceed the default
             // 200k limit for models with larger context windows (up to 1M).
-            const contextUsed = Math.max(0, persistedContextUsed);
+            const contextUsed = Math.max(0, baseContextUsed);
+            const clearStaleContextStats = isCodexProvider
+                && stored.contextStats
+                && (stored.contextStats.contextWindow !== contextLimit || stored.contextStats.totalTokens !== contextUsed);
             const agent = {
                 ...stored,
                 status: 'idle', // Ready to receive commands
@@ -56,6 +171,7 @@ export function initAgents() {
                 // Ensure context fields have defaults (migration for existing agents)
                 contextUsed,
                 contextLimit,
+                contextStats: clearStaleContextStats ? undefined : stored.contextStats,
                 taskCount: stored.taskCount ?? 0, // Migration for existing agents
                 permissionMode: stored.permissionMode ?? 'bypass', // Migration for existing agents
                 useChrome: stored.useChrome, // Restore Chrome flag
@@ -169,7 +285,7 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         codexConfig,
         tokensUsed: 0,
         contextUsed: 0,
-        contextLimit: 200000, // Claude's default context limit
+        contextLimit: getDefaultContextLimit(provider),
         taskCount: 0, // Initialize task counter
         createdAt: Date.now(),
         lastActivity: Date.now(),

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

@@ -1,5 +1,5 @@
 import * as agentService from './agent-service.js';
-import { clearPendingSilentContextRefresh, hasPendingSilentContextRefresh, markPendingSilentContextRefresh, startStdinWatchdog, } from './runtime-watchdog.js';
+import { clearPendingSilentContextRefresh, clearStdinWatchdog, hasPendingSilentContextRefresh, markPendingSilentContextRefresh, startStdinWatchdog, } from './runtime-watchdog.js';
 export function createRuntimeCommandExecution(deps) {
     const { log, getRunner, getRunnerForAgent, notifyCommandStarted, emitOutput, killDetachedProviderProcessInCwd, } = deps;
     async function executeCommand(agentId, command, systemPrompt, forceNewSession, customAgent, silent) {
@@ -139,6 +139,9 @@ export function createRuntimeCommandExecution(deps) {
         await executeCommand(agentId, command, undefined, undefined, undefined, true);
     }
     async function stopAgent(agentId) {
+        // Cancel any pending stdin watchdog timer to prevent it from respawning
+        // the process after we've stopped it
+        clearStdinWatchdog(agentId);
         const runner = getRunnerForAgent(agentId);
         if (runner) {
             await runner.stop(agentId);

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

@@ -3,7 +3,8 @@ import * as agentService from './agent-service.js';
 import * as supervisorService from './supervisor-service.js';
 import { clearPendingSilentContextRefresh, consumeStepCompleteReceived, markStepCompleteReceived, } from './runtime-watchdog.js';
 import { handleTaskToolResult, handleTaskToolStart } from './runtime-subagents.js';
-const DEFAULT_CODEX_CONTEXT_WINDOW = 200000;
+const DEFAULT_CLAUDE_CONTEXT_WINDOW = 200000;
+const DEFAULT_CODEX_CONTEXT_WINDOW = 258400;
 const CODEX_ROLLING_CONTEXT_TURNS = 40;
 const CODEX_PLAUSIBLE_USAGE_MULTIPLIER = 1.2;
 const CODEX_RECOVERABLE_RESUME_ERRORS = [
@@ -36,6 +37,9 @@ function estimateTokensFromText(text) {
         return 0;
     return Math.max(1, Math.ceil(normalized.length / 4));
 }
+function getDefaultContextWindow(provider) {
+    return provider === 'codex' ? DEFAULT_CODEX_CONTEXT_WINDOW : DEFAULT_CLAUDE_CONTEXT_WINDOW;
+}
 function updateCodexRollingContextEstimate(agentId, turnGrowth) {
     const history = codexContextGrowthHistory.get(agentId) || [];
     history.push(Math.max(0, Math.round(turnGrowth)));
@@ -65,7 +69,7 @@ function buildCodexRecoverySystemPrompt(sessionId, messages) {
     ].join('\n\n');
 }
 function buildEstimatedContextStats(totalTokens, contextWindow, model) {
-    const safeWindow = contextWindow > 0 ? contextWindow : DEFAULT_CODEX_CONTEXT_WINDOW;
+    const safeWindow = contextWindow > 0 ? contextWindow : DEFAULT_CLAUDE_CONTEXT_WINDOW;
     const usedPercent = Math.min(100, Math.max(0, Math.round((totalTokens / safeWindow) * 100)));
     const freeTokens = Math.max(0, safeWindow - totalTokens);
     const messagesPercent = Number(((totalTokens / safeWindow) * 100).toFixed(1));
@@ -179,7 +183,7 @@ export function createRuntimeEventHandlers(deps) {
                         // Output tokens are the model's response and don't count toward the limit.
                         const snapshotContextUsed = cacheRead + cacheCreation + inputTokens;
                         if (snapshotContextUsed > 0) {
-                            const effectiveLimit = agent.contextLimit || 200000;
+                            const effectiveLimit = agent.contextLimit || getDefaultContextWindow(agent.provider);
                             // Guard against cumulative session totals: if the sum exceeds the
                             // context window, it can't represent per-request context fill.
                             if (snapshotContextUsed > effectiveLimit) {
@@ -233,7 +237,7 @@ export function createRuntimeEventHandlers(deps) {
                 const lastTask = agent.lastAssignedTask?.trim() || '';
                 const isContextCommand = lastTask === '/context' || lastTask === '/cost' || lastTask === '/compact';
                 let contextUsed = agent.contextUsed || 0;
-                let contextLimit = agent.contextLimit || 200000;
+                let contextLimit = agent.contextLimit || getDefaultContextWindow(agent.provider);
                 // IMPORTANT: event.modelUsage is often {} (empty object) which is truthy.
                 // We must check that it has actual data before using it, otherwise we'd
                 // zero out contextUsed (since all fields would be undefined → 0).
@@ -262,12 +266,16 @@ export function createRuntimeEventHandlers(deps) {
                         contextLimit = event.modelUsage.contextWindow;
                     }
                     const turnGrowthEstimate = estimateTokensFromText(agent.lastAssignedTask) + outputTokens;
-                    const rollingEstimate = updateCodexRollingContextEstimate(agentId, turnGrowthEstimate);
+                    updateCodexRollingContextEstimate(agentId, turnGrowthEstimate);
                     const plausibleSnapshotLimit = contextLimit * CODEX_PLAUSIBLE_USAGE_MULTIPLIER;
-                    const hasPlausibleSnapshot = inputTokens > 0 && inputTokens <= plausibleSnapshotLimit;
-                    contextUsed = hasPlausibleSnapshot
-                        ? Math.max(rollingEstimate, inputTokens + outputTokens)
-                        : rollingEstimate;
+                    const hasAuthoritativeSnapshot = inputTokens > 0 && inputTokens <= plausibleSnapshotLimit;
+                    if (hasAuthoritativeSnapshot) {
+                        contextUsed = inputTokens;
+                    }
+                    else {
+                        const rollingEstimate = updateCodexRollingContextEstimate(agentId, 0);
+                        contextUsed = rollingEstimate;
+                    }
                     log.log(`[step_complete] Codex modelUsage for ${agentId}: input=${inputTokens}, contextWindow=${event.modelUsage.contextWindow || 'none'}`);
                 }
                 else if (event.tokens) {
@@ -292,12 +300,12 @@ export function createRuntimeEventHandlers(deps) {
                     const stats = agent.contextStats;
                     if (stats && stats.contextWindow > 0) {
                         contextUsed = Math.max(0, stats.totalTokens || 0);
-                        contextLimit = Math.max(1, stats.contextWindow || 200000);
+                        contextLimit = Math.max(1, stats.contextWindow || getDefaultContextWindow(agent.provider));
                         log.log(`[step_complete] Context command for ${agentId}; preserving context from context_stats ${contextUsed}/${contextLimit}`);
                     }
                     else {
                         contextUsed = agent.contextUsed || 0;
-                        contextLimit = agent.contextLimit || 200000;
+                        contextLimit = agent.contextLimit || getDefaultContextWindow(agent.provider);
                         log.log(`[step_complete] Context command for ${agentId}; preserving context values from tracked fields`);
                     }
                 }
@@ -380,12 +388,34 @@ export function createRuntimeEventHandlers(deps) {
     }
     function handleComplete(agentId, success) {
         const receivedStepComplete = consumeStepCompleteReceived(agentId);
-        agentService.updateAgent(agentId, {
+        const agent = agentService.getAgent(agentId);
+        const isCodexProvider = (agent?.provider ?? 'claude') === 'codex';
+        const finalCodexSnapshot = isCodexProvider
+            ? agentService.getCodexContextSnapshotFromSession(agent?.sessionId)
+            : null;
+        const completionUpdates = {
             status: 'idle',
             currentTask: undefined,
             currentTool: undefined,
             isDetached: false,
-        });
+        };
+        if (finalCodexSnapshot) {
+            completionUpdates.contextUsed = finalCodexSnapshot.contextUsed;
+            completionUpdates.contextLimit = finalCodexSnapshot.contextLimit;
+            // Build proper contextStats from the snapshot. Don't blindly copy
+            // finalCodexSnapshot.contextStats — CodexContextSnapshot doesn't have
+            // that field, so it would be `undefined` and wipe the valid stats
+            // set by step_complete.
+            const existingStats = agent?.contextStats;
+            if (existingStats && existingStats.lastUpdated) {
+                completionUpdates.contextStats = updateContextStatsTokens(existingStats, finalCodexSnapshot.contextUsed, finalCodexSnapshot.contextLimit);
+            }
+            else {
+                completionUpdates.contextStats = buildEstimatedContextStats(finalCodexSnapshot.contextUsed, finalCodexSnapshot.contextLimit, agent?.codexModel || agent?.model);
+            }
+            log.log(`[complete] Refreshed Codex context for ${agentId}: ${finalCodexSnapshot.contextUsed}/${finalCodexSnapshot.contextLimit}`);
+        }
+        agentService.updateAgent(agentId, completionUpdates);
         emitComplete(agentId, success);
         // Real-time context tracking via usage_snapshot events replaces automatic /context refresh.
         // The /context command is now only triggered manually via the UI refresh button.

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

@@ -238,9 +238,9 @@ function _checkForOrphanedProcess(agentId) {
         return false;
     }
 }
-export async function syncAgentStatus(agentId, isStartupSync = false) {
-    await statusSync.syncAgentStatus(agentId, isStartupSync);
+export async function syncAgentStatus(agentId) {
+    await statusSync.syncAgentStatus(agentId);
 }
-export async function syncAllAgentStatus(isStartupSync = false) {
-    await statusSync.syncAllAgentStatus(isStartupSync);
+export async function syncAllAgentStatus() {
+    await statusSync.syncAllAgentStatus();
 }

package/dist/src/packages/server/services/runtime-status-sync.js

@@ -36,15 +36,20 @@ export function createRuntimeStatusSync(deps) {
             }
         }
     }
-    async function syncAgentStatus(agentId, isStartupSync = false) {
+    async function syncAgentStatus(agentId) {
         const agent = agentService.getAgent(agentId);
         if (!agent)
             return;
+        // Only working agents need sync — idle agents stay idle.
+        // We intentionally do NOT promote idle agents to working based on
+        // orphaned processes or session activity. That caused agents to
+        // incorrectly resume after backend restarts/reconnects.
+        if (agent.status !== 'working')
+            return;
         const isTrackedProcess = getRunnerForAgent(agentId)?.isRunning(agentId) ?? false;
         if (isTrackedProcess)
             return;
         let isRecentlyActive = false;
-        let hasOrphanedProcess = false;
         if (agent.sessionId && agent.cwd) {
             try {
                 const activity = await getSessionActivityStatus(agent.cwd, agent.sessionId, 60);
@@ -55,20 +60,8 @@ export function createRuntimeStatusSync(deps) {
             catch {
                 // Session activity check failed, assume not active.
             }
-            if (agent.status === 'idle') {
-                try {
-                    const provider = agent.provider ?? 'claude';
-                    hasOrphanedProcess = await isProviderProcessRunningInCwd(provider, agent.cwd);
-                    if (hasOrphanedProcess) {
-                        log.log(`[syncAgentStatus] Agent ${agentId}: Found orphaned ${provider} process, isRecentlyActive=${isRecentlyActive}`);
-                    }
-                }
-                catch (err) {
-                    log.error(`[syncAgentStatus] Agent ${agentId}: Failed to check for orphaned process:`, err);
-                }
-            }
         }
-        if (agent.status === 'working' && !isRecentlyActive && !hasOrphanedProcess) {
+        if (!isRecentlyActive) {
             agentService.updateAgent(agentId, {
                 status: 'idle',
                 currentTask: undefined,
@@ -76,25 +69,10 @@ export function createRuntimeStatusSync(deps) {
                 isDetached: false,
             });
         }
-        else if (agent.status === 'idle' && hasOrphanedProcess && isRecentlyActive) {
-            const provider = agent.provider ?? 'claude';
-            log.log(`Agent ${agentId} has orphaned ${provider} process with recent activity - marking as working (detached)`);
-            agentService.updateAgent(agentId, {
-                status: 'working',
-                currentTask: 'Processing (detached)...',
-                isDetached: true,
-            });
-        }
-        else if (isStartupSync && agent.status === 'idle' && isRecentlyActive) {
-            agentService.updateAgent(agentId, {
-                status: 'working',
-                currentTask: 'Processing...',
-            });
-        }
     }
-    async function syncAllAgentStatus(isStartupSync = false) {
+    async function syncAllAgentStatus() {
         const agents = agentService.getAllAgents();
-        await Promise.all(agents.map((agent) => syncAgentStatus(agent.id, isStartupSync)));
+        await Promise.all(agents.map((agent) => syncAgentStatus(agent.id)));
     }
     return {
         pollOrphanedAgents,

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

@@ -1,3 +1,4 @@
+import * as agentService from './agent-service.js';
 import { logger } from '../utils/logger.js';
 const log = logger.claude;
 const pendingSilentContextRefresh = new Set();
@@ -32,6 +33,12 @@ export function startStdinWatchdog(options) {
     log.log(`[STDIN-WATCHDOG] Starting watchdog for ${agentId}, timeout=${STDIN_ACTIVITY_TIMEOUT_MS}ms`);
     const watchdogTimer = setTimeout(async () => {
         stdinWatchdogTimers.delete(agentId);
+        // Don't respawn if the agent was explicitly stopped (status is idle)
+        const agent = agentService.getAgent(agentId);
+        if (!agent || agent.status !== 'working') {
+            log.log(`[STDIN-WATCHDOG] Agent ${agentId}: Skipping respawn - agent is ${agent?.status ?? 'not found'}`);
+            return;
+        }
         if (runner && !runner.hasRecentActivity(agentId, STDIN_ACTIVITY_TIMEOUT_MS)) {
             log.warn(`[STDIN-WATCHDOG] Agent ${agentId}: No activity after stdin message, respawning process...`);
             await runner.stop(agentId);

package/dist/src/packages/server/websocket/handlers/agent-handler.js

@@ -440,7 +440,8 @@ function buildStatsFromTrackedData(agent) {
     // Do NOT prefer agent.contextStats here — those can become stale when previous
     // fallback calls save their (potentially wrong) output back to agent.contextStats
     // via broadcastContextStats, creating a self-reinforcing feedback loop.
-    const contextLimit = Math.max(1, Math.round(agent.contextLimit || 200000));
+    const defaultContextLimit = (agent.provider ?? 'claude') === 'codex' ? 258400 : 200000;
+    const contextLimit = Math.max(1, Math.round(agent.contextLimit || defaultContextLimit));
     const rawContextUsed = Math.max(0, Math.round(agent.contextUsed || 0));
     // Guard: contextUsed can never exceed contextLimit. Values above the limit are
     // cumulative session totals from result events, not per-request context fill.
@@ -511,6 +512,7 @@ export async function handleRequestContextStats(ctx, payload) {
         return;
     }
     const isClaudeProvider = (agent.provider ?? 'claude') === 'claude';
+    const isCodexProvider = (agent.provider ?? 'claude') === 'codex';
     // For Claude agents with an active session, fetch real context stats from the CLI
     if (isClaudeProvider && agent.sessionId) {
         log.log(`[contextStats] Fetching real context from CLI for ${agent.name} (session=${agent.sessionId})`);
@@ -543,6 +545,32 @@ export async function handleRequestContextStats(ctx, payload) {
             log.error(`[contextStats] In-session /context failed: ${err}`);
         }
     }
+    if (isCodexProvider && agent.sessionId) {
+        const codexSnapshot = agentService.getCodexContextSnapshotFromSession(agent.sessionId);
+        if (codexSnapshot) {
+            const contextLimit = Math.max(1, codexSnapshot.contextLimit);
+            const contextUsed = Math.max(0, Math.min(codexSnapshot.contextUsed, contextLimit));
+            const usedPercent = Math.min(100, Math.round((contextUsed / contextLimit) * 100));
+            const freeTokens = Math.max(0, contextLimit - contextUsed);
+            const stats = {
+                model: agent.codexModel || agent.model || 'codex',
+                contextWindow: contextLimit,
+                totalTokens: contextUsed,
+                usedPercent,
+                categories: {
+                    systemPrompt: { tokens: 0, percent: 0 },
+                    systemTools: { tokens: 0, percent: 0 },
+                    messages: { tokens: contextUsed, percent: Number(((contextUsed / contextLimit) * 100).toFixed(1)) },
+                    freeSpace: { tokens: freeTokens, percent: Number(((freeTokens / contextLimit) * 100).toFixed(1)) },
+                    autocompactBuffer: { tokens: 0, percent: 0 },
+                },
+                lastUpdated: Date.now(),
+            };
+            log.log(`[contextStats] Codex session snapshot for ${agent.name}: ${contextUsed}/${contextLimit}`);
+            broadcastContextStats(ctx, payload.agentId, stats, 'from Codex session');
+            return;
+        }
+    }
     // Fallback: generate from tracked data
     const latestAgent = agentService.getAgent(payload.agentId) || agent;
     const stats = buildStatsFromTrackedData(latestAgent);