@covibes/zeroshot 1.1.4 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [1.2.0](https://github.com/covibes/zeroshot/compare/v1.1.4...v1.2.0) (2025-12-28)
+
+
+### Bug Fixes
+
+* **status-footer:** robust terminal resize handling ([767a610](https://github.com/covibes/zeroshot/commit/767a610027b3e2bb238b54c31a3a7e93db635319))
+
+
+### Features
+
+* **agent:** publish TOKEN_USAGE events with task completion ([c79482c](https://github.com/covibes/zeroshot/commit/c79482c82582b75a692ba71005c821decdc1d769))
+* **stream-parser:** add token usage tracking to result events ([91ad850](https://github.com/covibes/zeroshot/commit/91ad8507f42fd1a398bdc06f3b91b0a13eec8941))
+
 ## [1.1.4](https://github.com/covibes/zeroshot/compare/v1.1.3...v1.1.4) (2025-12-28)
 
 

package/lib/stream-json-parser.js

@@ -45,8 +45,9 @@ function parseStreamLine(line) {
     return parseUserMessage(event.message);
   }
 
-  // result - final task result
+  // result - final task result (includes token usage and cost)
   if (event.type === 'result') {
+    const usage = event.usage || {};
     return {
       type: 'result',
       success: event.subtype === 'success',
@@ -54,6 +55,13 @@ function parseStreamLine(line) {
       error: event.is_error ? event.result : null,
       cost: event.total_cost_usd,
       duration: event.duration_ms,
+      // Token usage from Claude API
+      inputTokens: usage.input_tokens || 0,
+      outputTokens: usage.output_tokens || 0,
+      cacheReadInputTokens: usage.cache_read_input_tokens || 0,
+      cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
+      // Per-model breakdown (for multi-model tasks)
+      modelUsage: event.modelUsage || null,
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@covibes/zeroshot",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Multi-agent orchestration engine for Claude - cluster coordinator and CLI",
   "main": "src/orchestrator.js",
   "bin": {

package/src/agent/agent-lifecycle.js

@@ -278,8 +278,28 @@ async function executeTask(agent, triggeringMessage) {
         iteration: agent.iteration,
         success: true,
         taskId: agent.currentTaskId,
+        tokenUsage: result.tokenUsage || null,
       });
 
+      // Publish TOKEN_USAGE event for aggregation and tracking
+      if (result.tokenUsage) {
+        agent.messageBus.publish({
+          cluster_id: agent.cluster.id,
+          topic: 'TOKEN_USAGE',
+          sender: agent.id,
+          content: {
+            text: `${agent.id} used ${result.tokenUsage.inputTokens} input + ${result.tokenUsage.outputTokens} output tokens`,
+            data: {
+              agentId: agent.id,
+              role: agent.role,
+              model: agent._selectModel(),
+              iteration: agent.iteration,
+              ...result.tokenUsage,
+            },
+          },
+        });
+      }
+
       // Execute onComplete hook
       await executeHook({
         hook: agent.config.hooks?.onComplete,

package/src/agent/agent-task-executor.js

@@ -54,6 +54,44 @@ function sanitizeErrorMessage(error) {
 // Track if we've already ensured the AskUserQuestion hook is installed
 let askUserQuestionHookInstalled = false;
 
+/**
+ * Extract token usage from NDJSON output.
+ * Looks for the 'result' event line which contains usage data.
+ *
+ * @param {string} output - Full NDJSON output from Claude CLI
+ * @returns {Object|null} Token usage data or null if not found
+ */
+function extractTokenUsage(output) {
+  if (!output) return null;
+
+  const lines = output.split('\n');
+
+  // Find the result line containing usage data
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    try {
+      const event = JSON.parse(line.trim());
+      if (event.type === 'result') {
+        const usage = event.usage || {};
+        return {
+          inputTokens: usage.input_tokens || 0,
+          outputTokens: usage.output_tokens || 0,
+          cacheReadInputTokens: usage.cache_read_input_tokens || 0,
+          cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
+          totalCostUsd: event.total_cost_usd || null,
+          durationMs: event.duration_ms || null,
+          modelUsage: event.modelUsage || null,
+        };
+      }
+    } catch {
+      // Not valid JSON, continue
+    }
+  }
+
+  return null;
+}
+
 /**
  * Ensure the AskUserQuestion blocking hook is installed in user's Claude config.
  * This adds defense-in-depth by blocking the tool at the Claude CLI level.
@@ -569,6 +607,7 @@ function followClaudeTaskLogs(agent, taskId) {
               success,
               output,
               error: sanitizeErrorMessage(errorContext),
+              tokenUsage: extractTokenUsage(output),
             });
           }, 500);
         }
@@ -590,6 +629,7 @@ function followClaudeTaskLogs(agent, taskId) {
           success: false,
           output,
           error: reason,
+          tokenUsage: extractTokenUsage(output),
         });
       },
     };
@@ -907,6 +947,7 @@ function followClaudeTaskLogsIsolated(agent, taskId) {
                 output: fullOutput,
                 taskId,
                 result: parsedResult,
+                tokenUsage: extractTokenUsage(fullOutput),
               });
             }
           } catch (pollErr) {

package/src/status-footer.js

@@ -8,6 +8,13 @@
  *
  * Uses ANSI escape sequences to maintain a fixed footer while
  * allowing normal terminal output to scroll above it.
+ *
+ * ROBUST RESIZE HANDLING:
+ * - Debounced resize events (100ms) prevent rapid-fire redraws
+ * - Render lock prevents concurrent renders from corrupting state
+ * - Full footer clear before scroll region reset prevents artifacts
+ * - Dimension checkpointing skips unnecessary redraws
+ * - Graceful degradation for terminals < 8 rows
  */
 
 const { getProcessMetrics } = require('./process-metrics');
@@ -37,6 +44,20 @@ const COLORS = {
   bgBlack: `${CSI}40m`,
 };
 
+/**
+ * Debounce function - prevents rapid-fire calls during resize
+ * @param {Function} fn - Function to debounce
+ * @param {number} ms - Debounce delay in milliseconds
+ * @returns {Function} Debounced function
+ */
+function debounce(fn, ms) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), ms);
+  };
+}
+
 /**
  * @typedef {Object} AgentState
  * @property {string} id - Agent ID
@@ -65,6 +86,17 @@ class StatusFooter {
     this.clusterId = null;
     this.clusterState = 'initializing';
     this.startTime = Date.now();
+
+    // Robust resize handling state
+    this.isRendering = false; // Render lock - prevents concurrent renders
+    this.pendingResize = false; // Queue resize if render in progress
+    this.lastKnownRows = 0; // Track terminal dimensions for change detection
+    this.lastKnownCols = 0;
+    this.minRows = 8; // Minimum rows for footer display (graceful degradation)
+    this.hidden = false; // True when terminal too small for footer
+
+    // Debounced resize handler (100ms) - prevents rapid-fire redraws
+    this._debouncedResize = debounce(() => this._handleResize(), 100);
   }
 
   /**
@@ -95,22 +127,80 @@ class StatusFooter {
     process.stdout.write(`${CSI}${row};${col}H`);
   }
 
+  /**
+   * Clear a specific line completely
+   * @param {number} row - 1-based row number
+   * @private
+   */
+  _clearLine(row) {
+    process.stdout.write(`${CSI}${row};1H${CLEAR_LINE}`);
+  }
+
+  /**
+   * Clear all footer lines (uses last known height for safety)
+   * @private
+   */
+  _clearFooterArea() {
+    const { rows } = this.getTerminalSize();
+    // Use max of current and last footer height to ensure full cleanup
+    const heightToClear = Math.max(this.footerHeight, this.lastFooterHeight, 3);
+    const startRow = Math.max(1, rows - heightToClear + 1);
+
+    for (let row = startRow; row <= rows; row++) {
+      this._clearLine(row);
+    }
+  }
+
   /**
    * Set up scroll region to reserve space for footer
+   * ROBUST: Clears footer area first, resets to full screen, then sets new region
    */
   setupScrollRegion() {
     if (!this.isTTY()) return;
 
-    const { rows } = this.getTerminalSize();
+    const { rows, cols } = this.getTerminalSize();
+
+    // Graceful degradation: hide footer if terminal too small
+    if (rows < this.minRows) {
+      if (!this.hidden) {
+        this.hidden = true;
+        // Reset to full screen scroll
+        process.stdout.write(`${CSI}1;${rows}r`);
+        this.scrollRegionSet = false;
+      }
+      return;
+    }
+
+    // Restore footer if terminal grew large enough
+    if (this.hidden) {
+      this.hidden = false;
+    }
+
     const scrollEnd = rows - this.footerHeight;
 
-    // Set scroll region (lines 1 to scrollEnd)
+    // CRITICAL: Save cursor before any manipulation
+    process.stdout.write(SAVE_CURSOR);
+    process.stdout.write(HIDE_CURSOR);
+
+    // Step 1: Reset scroll region to full screen first (prevents artifacts)
+    process.stdout.write(`${CSI}1;${rows}r`);
+
+    // Step 2: Clear footer area completely (prevents ghosting)
+    this._clearFooterArea();
+
+    // Step 3: Set new scroll region (lines 1 to scrollEnd)
     process.stdout.write(`${CSI}1;${scrollEnd}r`);
 
-    // Move cursor to top of scroll region
-    process.stdout.write(`${CSI}1;1H`);
+    // Step 4: Move cursor to bottom of scroll region (safe position)
+    process.stdout.write(`${CSI}${scrollEnd};1H`);
+
+    // Restore cursor and show it
+    process.stdout.write(RESTORE_CURSOR);
+    process.stdout.write(SHOW_CURSOR);
 
     this.scrollRegionSet = true;
+    this.lastKnownRows = rows;
+    this.lastKnownCols = cols;
   }
 
   /**
@@ -124,6 +214,35 @@ class StatusFooter {
     this.scrollRegionSet = false;
   }
 
+  /**
+   * Handle terminal resize event
+   * Called via debounced wrapper to prevent rapid-fire redraws
+   * @private
+   */
+  _handleResize() {
+    if (!this.isTTY()) return;
+
+    const { rows, cols } = this.getTerminalSize();
+
+    // Skip if dimensions haven't actually changed (debounce may still fire)
+    if (rows === this.lastKnownRows && cols === this.lastKnownCols) {
+      return;
+    }
+
+    // If render in progress, queue resize for after
+    if (this.isRendering) {
+      this.pendingResize = true;
+      return;
+    }
+
+    // Update dimensions and reconfigure
+    this.lastKnownRows = rows;
+    this.lastKnownCols = cols;
+
+    this.setupScrollRegion();
+    this.render();
+  }
+
   /**
    * Register cluster for monitoring
    * @param {string} clusterId
@@ -223,72 +342,101 @@ class StatusFooter {
 
   /**
    * Render the footer
+   * ROBUST: Uses render lock to prevent concurrent renders from corrupting state
    */
   async render() {
     if (!this.enabled || !this.isTTY()) return;
 
-    const { rows, cols } = this.getTerminalSize();
+    // Graceful degradation: don't render if hidden
+    if (this.hidden) return;
 
-    // Collect metrics for all agents with PIDs
-    for (const [agentId, agent] of this.agents) {
-      if (agent.pid) {
-        try {
-          const metrics = await getProcessMetrics(agent.pid, { samplePeriodMs: 500 });
-          this.metricsCache.set(agentId, metrics);
-        } catch {
-          // Process may have exited
-          this.metricsCache.delete(agentId);
-        }
-      }
+    // Render lock: prevent concurrent renders
+    if (this.isRendering) {
+      return;
     }
+    this.isRendering = true;
 
-    // Get executing agents for display
-    const executingAgents = Array.from(this.agents.entries())
-      .filter(([, agent]) => agent.state === 'executing')
-      .slice(0, this.maxAgentRows);
+    try {
+      const { rows, cols } = this.getTerminalSize();
 
-    // Calculate dynamic footer height: header + agent rows + separator + summary
-    // Minimum 3 lines (header + "no agents" message + summary)
-    const agentRowCount = Math.max(1, executingAgents.length);
-    const newHeight = 2 + agentRowCount + 1; // header + agents + summary (separator merged with summary)
+      // Double-check terminal size (may have changed since last check)
+      if (rows < this.minRows) {
+        this.hidden = true;
+        this.resetScrollRegion();
+        return;
+      }
 
-    // Update scroll region if height changed
-    if (newHeight !== this.footerHeight) {
-      this.footerHeight = newHeight;
-      this.setupScrollRegion();
-    }
+      // Collect metrics for all agents with PIDs
+      for (const [agentId, agent] of this.agents) {
+        if (agent.pid) {
+          try {
+            const metrics = await getProcessMetrics(agent.pid, { samplePeriodMs: 500 });
+            this.metricsCache.set(agentId, metrics);
+          } catch {
+            // Process may have exited
+            this.metricsCache.delete(agentId);
+          }
+        }
+      }
 
-    // Build footer lines
-    const headerLine = this.buildHeaderLine(cols);
-    const agentRows = this.buildAgentRows(executingAgents, cols);
-    const summaryLine = this.buildSummaryLine(cols);
+      // Get executing agents for display
+      const executingAgents = Array.from(this.agents.entries())
+        .filter(([, agent]) => agent.state === 'executing')
+        .slice(0, this.maxAgentRows);
+
+      // Calculate dynamic footer height: header + agent rows + summary
+      // Minimum 3 lines (header + "no agents" message + summary)
+      const agentRowCount = Math.max(1, executingAgents.length);
+      const newHeight = 2 + agentRowCount + 1; // header + agents + summary
+
+      // Update scroll region if height changed
+      if (newHeight !== this.footerHeight) {
+        this.lastFooterHeight = this.footerHeight;
+        this.footerHeight = newHeight;
+        this.setupScrollRegion();
+      }
 
-    // Save cursor, render footer, restore cursor
-    process.stdout.write(SAVE_CURSOR);
-    process.stdout.write(HIDE_CURSOR);
+      // Build footer lines
+      const headerLine = this.buildHeaderLine(cols);
+      const agentRows = this.buildAgentRows(executingAgents, cols);
+      const summaryLine = this.buildSummaryLine(cols);
 
-    // Render from top of footer area
-    let currentRow = rows - this.footerHeight + 1;
+      // Save cursor, render footer, restore cursor
+      process.stdout.write(SAVE_CURSOR);
+      process.stdout.write(HIDE_CURSOR);
 
-    // Header line
-    this.moveTo(currentRow++, 1);
-    process.stdout.write(CLEAR_LINE);
-    process.stdout.write(`${COLORS.bgBlack}${headerLine}${COLORS.reset}`);
+      // Render from top of footer area
+      let currentRow = rows - this.footerHeight + 1;
 
-    // Agent rows
-    for (const agentRow of agentRows) {
+      // Header line
       this.moveTo(currentRow++, 1);
       process.stdout.write(CLEAR_LINE);
-      process.stdout.write(`${COLORS.bgBlack}${agentRow}${COLORS.reset}`);
-    }
+      process.stdout.write(`${COLORS.bgBlack}${headerLine}${COLORS.reset}`);
+
+      // Agent rows
+      for (const agentRow of agentRows) {
+        this.moveTo(currentRow++, 1);
+        process.stdout.write(CLEAR_LINE);
+        process.stdout.write(`${COLORS.bgBlack}${agentRow}${COLORS.reset}`);
+      }
 
-    // Summary line (with bottom border)
-    this.moveTo(currentRow, 1);
-    process.stdout.write(CLEAR_LINE);
-    process.stdout.write(`${COLORS.bgBlack}${summaryLine}${COLORS.reset}`);
+      // Summary line (with bottom border)
+      this.moveTo(currentRow, 1);
+      process.stdout.write(CLEAR_LINE);
+      process.stdout.write(`${COLORS.bgBlack}${summaryLine}${COLORS.reset}`);
 
-    process.stdout.write(RESTORE_CURSOR);
-    process.stdout.write(SHOW_CURSOR);
+      process.stdout.write(RESTORE_CURSOR);
+      process.stdout.write(SHOW_CURSOR);
+    } finally {
+      this.isRendering = false;
+
+      // Process pending resize if one was queued during render
+      if (this.pendingResize) {
+        this.pendingResize = false;
+        // Use setImmediate to avoid deep recursion
+        setImmediate(() => this._handleResize());
+      }
+    }
   }
 
   /**
@@ -402,7 +550,7 @@ class StatusFooter {
     parts.push(` ${COLORS.gray}│${COLORS.reset} ${COLORS.dim}${duration}${COLORS.reset}`);
 
     // Agent counts
-    const executing = Array.from(this.agents.values()).filter(a => a.state === 'executing').length;
+    const executing = Array.from(this.agents.values()).filter((a) => a.state === 'executing').length;
     const total = this.agents.size;
     parts.push(` ${COLORS.gray}│${COLORS.reset} ${COLORS.green}${executing}/${total}${COLORS.reset} active`);
 
@@ -456,13 +604,21 @@ class StatusFooter {
       return;
     }
 
+    // Initialize dimension tracking
+    const { rows, cols } = this.getTerminalSize();
+    this.lastKnownRows = rows;
+    this.lastKnownCols = cols;
+
+    // Check for graceful degradation at startup
+    if (rows < this.minRows) {
+      this.hidden = true;
+      return; // Don't set up scroll region for tiny terminals
+    }
+
     this.setupScrollRegion();
 
-    // Handle terminal resize
-    process.stdout.on('resize', () => {
-      this.setupScrollRegion();
-      this.render();
-    });
+    // Handle terminal resize with debounced handler
+    process.stdout.on('resize', this._debouncedResize);
 
     // Start refresh interval
     this.intervalId = setInterval(() => {
@@ -482,19 +638,19 @@ class StatusFooter {
       this.intervalId = null;
     }
 
-    if (this.isTTY()) {
+    // Remove resize listener
+    process.stdout.removeListener('resize', this._debouncedResize);
+
+    if (this.isTTY() && !this.hidden) {
       // Reset scroll region
       this.resetScrollRegion();
 
-      // Clear all footer lines (dynamic height)
-      const { rows } = this.getTerminalSize();
-      const startRow = rows - this.footerHeight + 1;
-      for (let row = startRow; row <= rows; row++) {
-        this.moveTo(row, 1);
-        process.stdout.write(CLEAR_LINE);
-      }
+      // Clear all footer lines
+      this._clearFooterArea();
 
       // Move cursor to safe position
+      const { rows } = this.getTerminalSize();
+      const startRow = rows - this.footerHeight + 1;
       this.moveTo(startRow, 1);
       process.stdout.write(SHOW_CURSOR);
     }
@@ -507,14 +663,7 @@ class StatusFooter {
     if (!this.isTTY()) return;
 
     this.resetScrollRegion();
-
-    // Clear all footer lines (dynamic height)
-    const { rows } = this.getTerminalSize();
-    const startRow = rows - this.footerHeight + 1;
-    for (let row = startRow; row <= rows; row++) {
-      this.moveTo(row, 1);
-      process.stdout.write(CLEAR_LINE);
-    }
+    this._clearFooterArea();
   }
 
   /**
@@ -523,6 +672,14 @@ class StatusFooter {
   show() {
     if (!this.isTTY()) return;
 
+    // Reset hidden state and check terminal size
+    const { rows } = this.getTerminalSize();
+    if (rows < this.minRows) {
+      this.hidden = true;
+      return;
+    }
+
+    this.hidden = false;
     this.setupScrollRegion();
     this.render();
   }