npm - tide-commander - Versions diffs - 0.67.3 → 0.69.0 - Mend

tide-commander 0.67.3 → 0.69.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/index.html CHANGED Viewed

@@ -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-C0I0fw2M.js"></script>
+    <script type="module" crossorigin src="/assets/main-MxBRZvMh.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-flegxlsj.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-C8GYJbe5.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/src/packages/landing/index.html CHANGED Viewed

@@ -1,6 +1,16 @@
 <!DOCTYPE html>
 <html lang="en">
   <head>
+    <!-- Google tag (gtag.js) -->
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-5WBC1WJMYY"></script>
+    <script>
+      window.dataLayer = window.dataLayer || [];
+      function gtag(){dataLayer.push(arguments);}
+      gtag('js', new Date());
+      gtag('config', 'G-5WBC1WJMYY');
+    </script>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Tide Commander - Visual Multi-Agent Orchestrator for Claude Code & Codex</title>

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

@@ -123,6 +123,8 @@ export class ClaudeBackend {
                 log.log(`parseEvent: assistant message has ${toolUseBlocks.length} tool_use block(s): ${toolUseBlocks.map((b) => b.name).join(', ')}`);
             }
         }
+        // Capture parent_tool_use_id from the raw event for propagation
+        const parentToolUseId = event.parent_tool_use_id;
         let result = null;
         switch (event.type) {
             case 'system':
@@ -151,6 +153,19 @@ export class ClaudeBackend {
             // Log when we're dropping events (assistant events may return null for text-only content)
             log.log(`parseEvent: returned NULL for type=${event.type}, subtype=${event.subtype || 'none'}`);
         }
+        // Propagate parent_tool_use_id onto all returned events (links subagent internal events to parent)
+        if (result && parentToolUseId) {
+            if (Array.isArray(result)) {
+                for (const r of result) {
+                    if (!r.parentToolUseId)
+                        r.parentToolUseId = parentToolUseId;
+                }
+            }
+            else {
+                if (!result.parentToolUseId)
+                    result.parentToolUseId = parentToolUseId;
+            }
+        }
         return result;
     }
     parseUserEvent(event) {
@@ -177,12 +192,29 @@ export class ClaudeBackend {
                     // Look up the tool name from the tool_use_id mapping
                     const toolName = toolUseIdToName.get(block.tool_use_id) || 'unknown';
                     log.log(`parseUserEvent: Found tool_result for tool_use_id=${block.tool_use_id}, toolName=${toolName}, content length=${content?.length || 0}, hasToolUseResult=${!!event.tool_use_result}`);
-                    toolResults.push({
+                    const toolResult = {
                         type: 'tool_result',
                         toolName,
                         toolOutput: content,
                         toolUseId: block.tool_use_id, // Preserve for subagent correlation
-                    });
+                    };
+                    // Extract subagent stats from Task tool completion metadata
+                    if (toolName === 'Task' && event.tool_use_result) {
+                        const tur = event.tool_use_result;
+                        if (tur.totalDurationMs || tur.totalTokens || tur.totalToolUseCount) {
+                            toolResult.subagentStats = {
+                                durationMs: tur.totalDurationMs || 0,
+                                tokensUsed: tur.totalTokens || 0,
+                                toolUseCount: tur.totalToolUseCount || 0,
+                            };
+                            log.log(`parseUserEvent: Task tool stats - duration=${tur.totalDurationMs}ms, tokens=${tur.totalTokens}, tools=${tur.totalToolUseCount}`);
+                        }
+                    }
+                    // Propagate parent_tool_use_id if present
+                    if (event.parent_tool_use_id) {
+                        toolResult.parentToolUseId = event.parent_tool_use_id;
+                    }
+                    toolResults.push(toolResult);
                     // Clean up the mapping after use (tool_use_id is unique per invocation)
                     toolUseIdToName.delete(block.tool_use_id);
                 }
@@ -234,6 +266,10 @@ export class ClaudeBackend {
                 errorMessage: event.error,
             };
         }
+        // Capture task_started events (links task_id to tool_use_id)
+        if (event.subtype === 'task_started' && event.task_id) {
+            log.log(`parseSystemEvent: task_started - task_id=${event.task_id}, tool_use_id=${event.tool_use_id}`);
+        }
         return null;
     }
     parseAssistantEvent(event) {
@@ -243,6 +279,7 @@ export class ClaudeBackend {
             const events = [];
             // Use event UUID if available (unique identifier from Claude)
             const uuid = event.uuid;
+            const usage = event.message.usage;
             // Extract text blocks - emit as non-streaming final text
             // This ensures text is captured even if streaming deltas were missed
             const textBlocks = event.message.content.filter((b) => b.type === 'text');
@@ -272,6 +309,10 @@ export class ClaudeBackend {
                     toolUseId: block.id,
                     uuid: block.id, // tool_use block has unique ID for deduplication
                 };
+                // Propagate parent_tool_use_id if present (links subagent events to parent Task invocation)
+                if (event.parent_tool_use_id) {
+                    toolEvent.parentToolUseId = event.parent_tool_use_id;
+                }
                 // Extract subagent metadata from Task tool inputs
                 if (toolName === 'Task' && block.input) {
                     const input = block.input;
@@ -283,8 +324,23 @@ export class ClaudeBackend {
                 }
                 events.push(toolEvent);
             }
+            // Assistant messages include usage snapshots that reflect current context
+            // occupancy during the turn. Emit a lightweight event so runtime state can
+            // update in near real-time instead of waiting for step_complete or /context.
+            if (usage) {
+                events.push({
+                    type: 'usage_snapshot',
+                    tokens: {
+                        input: usage.input_tokens || 0,
+                        output: usage.output_tokens || 0,
+                        cacheCreation: usage.cache_creation_input_tokens || 0,
+                        cacheRead: usage.cache_read_input_tokens || 0,
+                    },
+                    uuid,
+                });
+            }
             if (events.length > 0) {
-                log.log(`parseAssistantEvent: extracted ${textBlocks.length} text block(s) and ${toolUseBlocks.length} tool_use block(s), uuid=${uuid}`);
+                log.log(`parseAssistantEvent: extracted ${textBlocks.length} text block(s), ${toolUseBlocks.length} tool_use block(s), usage=${usage ? 'yes' : 'no'}, uuid=${uuid}`);
                 return events.length === 1 ? events[0] : events;
             }
         }
@@ -495,16 +551,18 @@ export function parseContextOutput(content) {
         const modelMatch = content.match(/\*\*Model:\*\*\s*(.+)/);
         const model = modelMatch ? modelMatch[1].trim() : 'unknown';
         // Extract total tokens and context window
-        // Format: **Tokens:** 19.6k / 200.0k (10%)
-        const tokensMatch = content.match(/\*\*Tokens:\*\*\s*([\d.]+)k?\s*\/\s*([\d.]+)k?\s*\((\d+)%\)/);
+        // Format: **Tokens:** 19.6k / 200.0k (10%)  or  **Tokens:** 377.3k / 1000.0k (38%)
+        const tokensMatch = content.match(/\*\*Tokens:\*\*\s*([\d.]+k?)\s*\/\s*([\d.]+k?)\s*\((\d+)%\)/);
         if (!tokensMatch) {
             log.log('parseContextOutput: Could not parse tokens line');
             return null;
         }
         const parseTokens = (str) => {
-            const num = parseFloat(str);
-            // If original string had 'k' suffix, multiply by 1000
-            return str.includes('k') || num < 1000 ? num * 1000 : num;
+            // The k suffix is now included in the capture group
+            if (str.endsWith('k') || str.endsWith('K')) {
+                return parseFloat(str) * 1000;
+            }
+            return parseFloat(str);
         };
         const totalTokens = parseTokens(tokensMatch[1]);
         const contextWindow = parseTokens(tokensMatch[2]);
@@ -512,10 +570,12 @@ export function parseContextOutput(content) {
         // Parse category table
         const parseCategory = (name) => {
             // Match: | Category Name | 3.1k | 1.6% |
-            const regex = new RegExp(`\\|\\s*${name}\\s*\\|\\s*([\\d.]+)k?\\s*\\|\\s*([\\d.]+)%\\s*\\|`, 'i');
+            const regex = new RegExp(`\\|\\s*${name}\\s*\\|\\s*([\\d.]+k?)\\s*\\|\\s*([\\d.]+)%\\s*\\|`, 'i');
             const match = content.match(regex);
             if (match) {
-                const tokens = parseFloat(match[1]) * (match[1].includes('k') || parseFloat(match[1]) < 100 ? 1000 : 1);
+                const tokens = match[1].endsWith('k') || match[1].endsWith('K')
+                    ? parseFloat(match[1]) * 1000
+                    : parseFloat(match[1]);
                 return { tokens, percent: parseFloat(match[2]) };
             }
             return { tokens: 0, percent: 0 };

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

@@ -101,6 +101,10 @@ export class RunnerStdoutPipeline {
                 if (event.toolName === 'Task' && event.subagentName) {
                     this.activeSubagentName.set(agentId, event.subagentName);
                 }
+                // Skip output for subagent internal tools (shown in inline activity panel instead)
+                if (event.parentToolUseId) {
+                    break;
+                }
                 const toolStartSubName = event.subagentName || this.activeSubagentName.get(agentId);
                 this.callbacks.onOutput(agentId, `Using tool: ${event.toolName}`, false, toolStartSubName, event.uuid, {
                     toolName: event.toolName,
@@ -112,9 +116,12 @@ export class RunnerStdoutPipeline {
                 break;
             }
             case 'tool_result': {
-                const toolResultSubName = this.activeSubagentName.get(agentId);
-                if (event.toolName === 'Bash' && event.toolOutput) {
-                    this.callbacks.onOutput(agentId, `Bash output:\n${event.toolOutput}`, false, toolResultSubName, event.uuid);
+                // Skip output for subagent internal tools (shown in inline activity panel)
+                if (!event.parentToolUseId) {
+                    const toolResultSubName = this.activeSubagentName.get(agentId);
+                    if (event.toolName === 'Bash' && event.toolOutput) {
+                        this.callbacks.onOutput(agentId, `Bash output:\n${event.toolOutput}`, false, toolResultSubName, event.uuid);
+                    }
                 }
                 if (event.toolName === 'Task') {
                     this.activeSubagentName.delete(agentId);
@@ -141,6 +148,9 @@ export class RunnerStdoutPipeline {
             case 'error':
                 this.callbacks.onError(agentId, event.errorMessage || 'Unknown error');
                 break;
+            case 'usage_snapshot':
+                // Silently pass through to onEvent (already called above) - no output needed
+                break;
             case 'context_stats':
                 if (event.contextStatsRaw) {
                     this.callbacks.onOutput(agentId, event.contextStatsRaw, false, undefined, event.uuid);

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

@@ -46,7 +46,9 @@ export function initAgents() {
             const persistedContextUsed = typeof stored.contextUsed === 'number'
                 ? stored.contextUsed
                 : tokensUsed;
-            const contextUsed = Math.max(0, Math.min(persistedContextUsed, contextLimit));
+            // 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);
             // Track agents that were working before restart
             // Use lastAssignedTask (which persists) instead of currentTask (which gets cleared)
             // Only resume if task was assigned within the last 5 minutes

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

@@ -1,7 +1,7 @@
 import { loadSession } from '../claude/session-loader.js';
 import * as agentService from './agent-service.js';
 import * as supervisorService from './supervisor-service.js';
-import { clearPendingSilentContextRefresh, consumeStepCompleteReceived, hasPendingSilentContextRefresh, markStepCompleteReceived, } from './runtime-watchdog.js';
+import { clearPendingSilentContextRefresh, consumeStepCompleteReceived, markStepCompleteReceived, } from './runtime-watchdog.js';
 import { handleTaskToolResult, handleTaskToolStart } from './runtime-subagents.js';
 const DEFAULT_CODEX_CONTEXT_WINDOW = 200000;
 const CODEX_ROLLING_CONTEXT_TURNS = 40;
@@ -86,7 +86,7 @@ function buildEstimatedCodexContextStats(totalTokens, contextWindow, model) {
     };
 }
 export function createRuntimeEventHandlers(deps) {
-    const { log, emitEvent, emitOutput, emitComplete, emitError, parseUsageOutput, executeCommand, scheduleSilentContextRefresh, } = deps;
+    const { log, emitEvent, emitOutput, emitComplete, emitError, parseUsageOutput, executeCommand, } = deps;
     function handleEvent(agentId, event) {
         const agent = agentService.getAgent(agentId);
         if (!agent) {
@@ -112,6 +112,30 @@ export function createRuntimeEventHandlers(deps) {
                 handleTaskToolResult(agentId, event, log);
                 agentService.updateAgent(agentId, { currentTool: undefined });
                 break;
+            case 'usage_snapshot': {
+                // Real-time context tracking from streaming usage data.
+                // Context window usage = input tokens only (output tokens don't count toward the limit).
+                // total_input = cache_read + cache_creation + input_tokens (the full prompt size).
+                if (event.tokens) {
+                    const isClaudeProvider = (agent.provider ?? 'claude') === 'claude';
+                    if (isClaudeProvider) {
+                        const cacheRead = event.tokens.cacheRead || 0;
+                        const cacheCreation = event.tokens.cacheCreation || 0;
+                        const inputTokens = event.tokens.input || 0;
+                        // Context window = input side only (system prompt + tools + messages).
+                        // Output tokens are the model's response and don't count toward the limit.
+                        const snapshotContextUsed = cacheRead + cacheCreation + inputTokens;
+                        if (snapshotContextUsed > 0) {
+                            const updates = {
+                                contextUsed: Math.max(0, snapshotContextUsed),
+                            };
+                            agentService.updateAgent(agentId, updates, false);
+                            log.log(`[usage_snapshot] ${agentId}: input=${inputTokens} + cacheRead=${cacheRead} + cacheCreation=${cacheCreation} = ${snapshotContextUsed} (output=${event.tokens.output || 0}) limit=${agent.contextLimit || '?'}`);
+                        }
+                    }
+                }
+                break;
+            }
             case 'step_complete': {
                 markStepCompleteReceived(agentId);
                 const isClaudeProvider = (agent.provider ?? 'claude') === 'claude';
@@ -120,12 +144,21 @@ export function createRuntimeEventHandlers(deps) {
                 const isContextCommand = lastTask === '/context' || lastTask === '/cost' || lastTask === '/compact';
                 let contextUsed = agent.contextUsed || 0;
                 let contextLimit = agent.contextLimit || 200000;
-                if (event.modelUsage) {
+                // 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).
+                const hasModelUsageData = event.modelUsage && Object.keys(event.modelUsage).length > 0;
+                if (hasModelUsageData && event.modelUsage) {
                     const cacheRead = event.modelUsage.cacheReadInputTokens || 0;
                     const cacheCreation = event.modelUsage.cacheCreationInputTokens || 0;
                     const inputTokens = event.modelUsage.inputTokens || 0;
                     const outputTokens = event.modelUsage.outputTokens || 0;
-                    contextLimit = event.modelUsage.contextWindow || 200000;
+                    // Only update contextLimit if the event actually carries contextWindow.
+                    // If undefined, keep the existing agent.contextLimit (which may have been
+                    // bumped by usage_snapshot or a previous step_complete).
+                    if (event.modelUsage.contextWindow) {
+                        contextLimit = event.modelUsage.contextWindow;
+                    }
                     if (isCodexProvider) {
                         const turnGrowthEstimate = estimateTokensFromText(agent.lastAssignedTask) + outputTokens;
                         const rollingEstimate = updateCodexRollingContextEstimate(agentId, turnGrowthEstimate);
@@ -136,16 +169,18 @@ export function createRuntimeEventHandlers(deps) {
                             : rollingEstimate;
                     }
                     else {
-                        contextUsed = cacheRead + cacheCreation + inputTokens + outputTokens;
+                        // Context window = input side only (output tokens don't count toward the limit)
+                        contextUsed = cacheRead + cacheCreation + inputTokens;
                     }
+                    log.log(`[step_complete] modelUsage data for ${agentId}: cacheRead=${cacheRead}, cacheCreation=${cacheCreation}, input=${inputTokens}, contextWindow=${event.modelUsage.contextWindow || 'none'}`);
                 }
                 else if (event.tokens) {
                     if (isClaudeProvider) {
                         const cacheRead = event.tokens.cacheRead || 0;
                         const cacheCreation = event.tokens.cacheCreation || 0;
                         const inputTokens = event.tokens.input || 0;
-                        const outputTokens = event.tokens.output || 0;
-                        contextUsed = cacheRead + cacheCreation + inputTokens + outputTokens;
+                        // Context window = input side only
+                        contextUsed = cacheRead + cacheCreation + inputTokens;
                     }
                     else {
                         const inputTokens = event.tokens.input || 0;
@@ -165,13 +200,35 @@ export function createRuntimeEventHandlers(deps) {
                     && (event.tokens.output || 0) === 0
                     && (event.tokens.cacheRead || 0) === 0
                     && (event.tokens.cacheCreation || 0) === 0;
-                const hasNoModelUsage = !event.modelUsage;
-                if (isClaudeProvider && hasZeroTokenUsage && hasNoModelUsage && !isContextCommand) {
+                // Treat empty objects {} as "no model usage" (they have no meaningful data)
+                const hasNoModelUsage = !hasModelUsageData;
+                // For /context, /cost, /compact: the context_stats event already set the
+                // authoritative contextUsed/contextLimit values. Don't overwrite them with
+                // zero-token step_complete data from the local command.
+                if (isContextCommand) {
+                    contextUsed = agent.contextUsed || 0;
+                    contextLimit = agent.contextLimit || 200000;
+                    log.log(`[step_complete] Context command for ${agentId}; preserving context values from context_stats`);
+                }
+                else if (isClaudeProvider && hasZeroTokenUsage && hasNoModelUsage) {
                     contextUsed = agent.contextUsed || 0;
                     contextLimit = agent.contextLimit || 200000;
                     log.log(`[step_complete] Claude empty usage detected for ${agentId}; preserving previous context`);
                 }
-                contextUsed = Math.max(0, Math.min(contextUsed, contextLimit));
+                else if (isClaudeProvider && !hasModelUsageData && event.tokens) {
+                    // modelUsage was {} (empty) but we DO have event.tokens.
+                    // The usage_snapshot handler already set the correct contextUsed value
+                    // from the assistant event's usage data. Don't overwrite it.
+                    // The event.tokens here come from the result event, which for Claude
+                    // in --print mode may have different semantics. Prefer the last
+                    // usage_snapshot value which is the most accurate real-time reading.
+                    log.log(`[step_complete] Claude empty modelUsage but has tokens for ${agentId}; preserving usage_snapshot contextUsed=${agent.contextUsed}`);
+                    contextUsed = agent.contextUsed || 0;
+                }
+                // Don't clamp contextUsed to contextLimit - models can have up to 1M context.
+                // The contextLimit comes from modelUsage.contextWindow which is authoritative.
+                contextUsed = Math.max(0, contextUsed);
+                log.log(`[step_complete] Final for ${agentId}: contextUsed=${contextUsed}, contextLimit=${contextLimit}, hasModelUsageData=${hasModelUsageData}, tokens=${JSON.stringify(event.tokens)}`);
                 const newTokensUsed = (agent.tokensUsed || 0) + (event.tokens?.input || 0) + (event.tokens?.output || 0);
                 const updates = {
                     tokensUsed: newTokensUsed,
@@ -195,16 +252,9 @@ export function createRuntimeEventHandlers(deps) {
                 else {
                     log.log(`[step_complete] Codex agent ${agentId} will be set idle on process completion`);
                 }
-                const hasPendingSilentRefresh = hasPendingSilentContextRefresh(agentId);
-                log.log(`[step_complete] Auto-refresh check: agentId=${agentId}, lastTask="${lastTask}", isContextCmd=${isContextCommand}, hasPending=${hasPendingSilentRefresh}`);
+                // 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.
                 clearPendingSilentContextRefresh(agentId);
-                const currentAgent = agentService.getAgent(agentId);
-                const hasSession = !!currentAgent?.sessionId;
-                const shouldRefresh = isClaudeProvider && hasSession && !isContextCommand && !hasPendingSilentRefresh;
-                log.log(`[step_complete] sessionId=${currentAgent?.sessionId}, shouldRefresh=${shouldRefresh}`);
-                if (shouldRefresh) {
-                    scheduleSilentContextRefresh(agentId, 'step_complete');
-                }
                 break;
             }
             case 'error':
@@ -255,18 +305,10 @@ export function createRuntimeEventHandlers(deps) {
             isDetached: false,
         });
         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.
         if (!receivedStepComplete && success) {
-            const agent = agentService.getAgent(agentId);
-            const lastTask = agent?.lastAssignedTask?.trim() || '';
-            const isContextCommand = lastTask === '/context' || lastTask === '/cost' || lastTask === '/compact';
-            const hasSession = !!agent?.sessionId;
-            const hasPendingSilentRefresh = hasPendingSilentContextRefresh(agentId);
-            log.log(`[handleComplete] Fallback /context check: agentId=${agentId}, receivedStepComplete=${receivedStepComplete}, lastTask="${lastTask}", isContextCmd=${isContextCommand}, hasSession=${hasSession}, hasPending=${hasPendingSilentRefresh}`);
-            const isClaudeProvider = (agent?.provider ?? 'claude') === 'claude';
-            if (isClaudeProvider && hasSession && !isContextCommand && !hasPendingSilentRefresh) {
-                log.log(`[handleComplete] Triggering fallback /context refresh for agent ${agentId}`);
-                scheduleSilentContextRefresh(agentId, 'handle_complete');
-            }
+            clearPendingSilentContextRefresh(agentId);
         }
     }
     function handleError(agentId, error) {

package/dist/src/packages/server/services/runtime-subagents.js CHANGED Viewed

@@ -34,6 +34,10 @@ export function handleTaskToolResult(agentId, event, log) {
     }
     log.log(`[Subagent] Completed: ${subagent.name} (${subagent.id}) for agent ${agentId}`);
     event.subagentName = subagent.name;
+    // Store completion stats from event onto the subagent before removal
+    if (event.subagentStats) {
+        subagent.stats = event.subagentStats;
+    }
     activeSubagents.delete(event.toolUseId);
     subagentIdToToolUseId.delete(subagent.id);
 }

package/dist/src/packages/server/services/supervisor-service.js CHANGED Viewed

@@ -266,6 +266,7 @@ export async function generateReport() {
                 recentNarratives: allNarratives,
                 tokensUsed: agent.tokensUsed,
                 contextUsed: agent.contextUsed,
+                contextLimit: agent.contextLimit,
                 lastActivityTime: agent.lastActivity,
             };
         }));
@@ -383,6 +384,7 @@ async function buildAgentSummary(agent) {
         recentNarratives: allNarratives,
         tokensUsed: agent.tokensUsed,
         contextUsed: agent.contextUsed,
+        contextLimit: agent.contextLimit,
         lastActivityTime: agent.lastActivity,
     };
 }
@@ -405,7 +407,7 @@ function buildSingleAgentPrompt(summary) {
             : 'No task assigned yet',
         taskAssignedSecondsAgo,
         tokensUsed: summary.tokensUsed,
-        contextPercent: Math.round((summary.contextUsed / 200000) * 100),
+        contextPercent: Math.round((summary.contextUsed / (summary.contextLimit || 200000)) * 100),
         timeSinceActivity: Math.round((Date.now() - summary.lastActivityTime) / 1000),
         recentActivities: summary.recentNarratives.map((n) => sanitizeUnicode(n.narrative)).slice(0, 5),
     };
@@ -476,7 +478,7 @@ function buildSupervisorPrompt(summaries) {
                 : 'No task assigned yet',
             taskAssignedSecondsAgo,
             tokensUsed: s.tokensUsed,
-            contextPercent: Math.round((s.contextUsed / 200000) * 100),
+            contextPercent: Math.round((s.contextUsed / (s.contextLimit || 200000)) * 100),
             timeSinceActivity: Math.round((Date.now() - s.lastActivityTime) / 1000),
             recentActivities: s.recentNarratives.map((n) => sanitizeUnicode(n.narrative)).slice(0, 5),
         };