@covibes/zeroshot 5.3.0 → 5.4.0

package/src/status-footer.js

@@ -58,7 +58,7 @@ const AGENT_STATE = Object.freeze({
 // Agent states that indicate "active" work (from agent-lifecycle.js)
 // These should show in the footer with metrics
 const ACTIVE_STATES = new Set([
-  AGENT_STATE.EXECUTING_TASK,   // Actually running claude CLI
+  AGENT_STATE.EXECUTING_TASK, // Actually running claude CLI
   AGENT_STATE.EVALUATING_LOGIC, // Evaluating trigger conditions
   AGENT_STATE.BUILDING_CONTEXT, // Building context for task
 ]);
@@ -81,7 +81,8 @@ function debounce(fn, ms) {
  * @typedef {Object} AgentState
  * @property {string} id - Agent ID
  * @property {string} state - Agent state (idle, executing, etc.)
- * @property {number|null} pid - Process ID if running
+ * @property {number|null} processPid - Process ID if running (preferred)
+ * @property {number|null} pid - Legacy alias for processPid
  * @property {number} iteration - Current iteration
  */
 
@@ -175,7 +176,7 @@ class StatusFooter {
     if (this.printQueue.length === 0) return;
 
     // Write all queued output
-    const output = this.printQueue.map(text => text + '\n').join('');
+    const output = this.printQueue.map((text) => text + '\n').join('');
     this.printQueue = [];
     process.stdout.write(output);
   }
@@ -396,8 +397,11 @@ class StatusFooter {
    * @param {AgentState} agentState
    */
   updateAgent(agentState) {
+    const processPid = agentState.processPid ?? agentState.pid ?? null;
     this.agents.set(agentState.id, {
       ...agentState,
+      processPid,
+      pid: processPid,
       lastUpdate: Date.now(),
     });
   }
@@ -418,11 +422,12 @@ class StatusFooter {
    */
   async _sampleMetrics() {
     for (const [agentId, agent] of this.agents) {
-      if (!agent.pid) continue;
+      const processPid = agent.processPid ?? agent.pid;
+      if (!processPid) continue;
 
       try {
         // Get actual metrics with 200ms sample window (for CPU calculation)
-        const raw = await getProcessMetrics(agent.pid, { samplePeriodMs: 200 });
+        const raw = await getProcessMetrics(processPid, { samplePeriodMs: 200 });
         const existing = this.interpolatedMetrics.get(agentId);
 
         this.interpolatedMetrics.set(agentId, {
@@ -458,14 +463,8 @@ class StatusFooter {
       if (!data.target || !data.current) continue;
 
       // Lerp CPU and RAM toward target (they fluctuate)
-      data.current.cpuPercent = this._lerp(
-        data.current.cpuPercent,
-        data.target.cpuPercent
-      );
-      data.current.memoryMB = this._lerp(
-        data.current.memoryMB,
-        data.target.memoryMB
-      );
+      data.current.cpuPercent = this._lerp(data.current.cpuPercent, data.target.cpuPercent);
+      data.current.memoryMB = this._lerp(data.current.memoryMB, data.target.memoryMB);
       // Network is cumulative counter - no interpolation, just use latest
     }
   }
@@ -767,60 +766,107 @@ class StatusFooter {
     // Border with corner
     parts.push(`${COLORS.gray}└─${COLORS.reset}`);
 
-    // Cluster state
+    this.appendClusterStateSummary(parts);
+    this.appendDurationSummary(parts);
+    this.appendAgentCountSummary(parts);
+    this.appendTokenCostSummary(parts);
+    this.appendAggregateMetricsSummary(parts);
+
+    // Pad and close with bottom corner
+    return this.padSummaryLine(parts, width);
+  }
+
+  appendClusterStateSummary(parts) {
     const stateColor = this.clusterState === 'running' ? COLORS.green : COLORS.yellow;
     parts.push(` ${stateColor}${this.clusterState}${COLORS.reset}`);
+  }
 
-    // Duration
+  appendDurationSummary(parts) {
     const duration = this.formatDuration(Date.now() - this.startTime);
     parts.push(` ${COLORS.gray}│${COLORS.reset} ${COLORS.dim}${duration}${COLORS.reset}`);
+  }
 
-    // Agent counts
-    const executing = Array.from(this.agents.values()).filter((a) => ACTIVE_STATES.has(a.state)).length;
-    const total = this.agents.size;
-    parts.push(` ${COLORS.gray}│${COLORS.reset} ${COLORS.green}${executing}/${total}${COLORS.reset} active`);
+  appendAgentCountSummary(parts) {
+    const { executing, total } = this.getActiveAgentCounts();
+    parts.push(
+      ` ${COLORS.gray}│${COLORS.reset} ${COLORS.green}${executing}/${total}${COLORS.reset} active`
+    );
+  }
 
-    // Token cost (from message bus)
-    if (this.messageBus && this.clusterId) {
-      try {
-        const tokensByRole = this.messageBus.getTokensByRole(this.clusterId);
-        const totalCost = tokensByRole?._total?.totalCostUsd || 0;
-        if (totalCost > 0) {
-          // Format: $0.05 or $1.23 or $12.34
-          const costStr = totalCost < 0.01 ? '<$0.01' : `$${totalCost.toFixed(2)}`;
-          parts.push(` ${COLORS.gray}│${COLORS.reset} ${COLORS.yellow}${costStr}${COLORS.reset}`);
-        }
-      } catch {
-        // Ignore errors - token tracking is optional
+  getActiveAgentCounts() {
+    const executing = Array.from(this.agents.values()).filter((a) =>
+      ACTIVE_STATES.has(a.state)
+    ).length;
+    return { executing, total: this.agents.size };
+  }
+
+  appendTokenCostSummary(parts) {
+    const costStr = this.getTokenCostSummary();
+    if (!costStr) {
+      return;
+    }
+    parts.push(` ${COLORS.gray}│${COLORS.reset} ${COLORS.yellow}${costStr}${COLORS.reset}`);
+  }
+
+  getTokenCostSummary() {
+    if (!this.messageBus || !this.clusterId) {
+      return null;
+    }
+
+    try {
+      const tokensByRole = this.messageBus.getTokensByRole(this.clusterId);
+      const totalCost = tokensByRole?._total?.totalCostUsd || 0;
+      if (totalCost <= 0) {
+        return null;
       }
+
+      // Format: $0.05 or $1.23 or $12.34
+      return totalCost < 0.01 ? '<$0.01' : `$${totalCost.toFixed(2)}`;
+    } catch {
+      // Ignore errors - token tracking is optional
+      return null;
     }
+  }
 
-    // Aggregate metrics (using interpolated values for smooth display)
+  appendAggregateMetricsSummary(parts) {
+    const { totalCpu, totalMem, totalBytesSent, totalBytesReceived } = this.getAggregateMetrics();
+
+    if (totalCpu <= 0 && totalMem <= 0) {
+      return;
+    }
+
+    parts.push(` ${COLORS.gray}│${COLORS.reset}`);
+    let aggregateStr = ` ${COLORS.cyan}Σ${COLORS.reset} `;
+    aggregateStr += `${COLORS.dim}CPU:${COLORS.reset}${totalCpu.toFixed(1)}%`;
+    aggregateStr += ` ${COLORS.dim}RAM:${COLORS.reset}${totalMem.toFixed(1)}MB`;
+    if (totalBytesSent > 0 || totalBytesReceived > 0) {
+      aggregateStr += ` ${COLORS.dim}NET:${COLORS.reset}${COLORS.cyan}↑${this.formatBytes(totalBytesSent)} ↓${this.formatBytes(totalBytesReceived)}${COLORS.reset}`;
+    }
+    parts.push(aggregateStr);
+  }
+
+  getAggregateMetrics() {
     let totalCpu = 0;
     let totalMem = 0;
     let totalBytesSent = 0;
     let totalBytesReceived = 0;
+
+    // Aggregate metrics (using interpolated values for smooth display)
     for (const data of this.interpolatedMetrics.values()) {
-      if (data.exists && data.current) {
-        totalCpu += data.current.cpuPercent;
-        totalMem += data.current.memoryMB;
-        totalBytesSent += data.network?.bytesSent || 0;
-        totalBytesReceived += data.network?.bytesReceived || 0;
+      if (!data.exists || !data.current) {
+        continue;
       }
-    }
 
-    if (totalCpu > 0 || totalMem > 0) {
-      parts.push(` ${COLORS.gray}│${COLORS.reset}`);
-      let aggregateStr = ` ${COLORS.cyan}Σ${COLORS.reset} `;
-      aggregateStr += `${COLORS.dim}CPU:${COLORS.reset}${totalCpu.toFixed(1)}%`;
-      aggregateStr += ` ${COLORS.dim}RAM:${COLORS.reset}${totalMem.toFixed(1)}MB`;
-      if (totalBytesSent > 0 || totalBytesReceived > 0) {
-        aggregateStr += ` ${COLORS.dim}NET:${COLORS.reset}${COLORS.cyan}↑${this.formatBytes(totalBytesSent)} ↓${this.formatBytes(totalBytesReceived)}${COLORS.reset}`;
-      }
-      parts.push(aggregateStr);
+      totalCpu += data.current.cpuPercent;
+      totalMem += data.current.memoryMB;
+      totalBytesSent += data.network?.bytesSent || 0;
+      totalBytesReceived += data.network?.bytesReceived || 0;
     }
 
-    // Pad and close with bottom corner
+    return { totalCpu, totalMem, totalBytesSent, totalBytesReceived };
+  }
+
+  padSummaryLine(parts, width) {
     const content = parts.join('');
     const contentLen = this.stripAnsi(content).length;
     const padding = Math.max(0, width - contentLen - 1);

package/src/sub-cluster-wrapper.js

@@ -286,47 +286,88 @@ class SubClusterWrapper {
   _buildChildContext(triggeringMessage) {
     const parentTopics = this.config.contextStrategy?.parentTopics || [];
 
-    let context = `# Child Cluster Context\n\n`;
-    context += `Parent Cluster: ${this.parentCluster.id}\n`;
-    context += `SubCluster ID: ${this.id}\n`;
-    context += `Iteration: ${this.iteration}\n\n`;
-
-    // Add messages from specified parent topics
-    if (parentTopics.length > 0) {
-      context += `## Parent Cluster Messages\n\n`;
-
-      for (const topic of parentTopics) {
-        const messages = this.messageBus.query({
-          cluster_id: this.parentCluster.id,
-          topic,
-          limit: 10,
-        });
+    const lines = [
+      '# Child Cluster Context',
+      '',
+      `Parent Cluster: ${this.parentCluster.id}`,
+      `SubCluster ID: ${this.id}`,
+      `Iteration: ${this.iteration}`,
+      '',
+    ];
+
+    this._appendParentTopicContext(lines, parentTopics);
+    this._appendTriggeringMessageContext(lines, triggeringMessage);
+
+    return lines.join('\n');
+  }
 
-        if (messages.length > 0) {
-          context += `### Topic: ${topic}\n\n`;
-          for (const msg of messages) {
-            context += `[${new Date(msg.timestamp).toISOString()}] ${msg.sender}:\n`;
-            if (msg.content?.text) {
-              context += `${msg.content.text}\n`;
-            }
-            if (msg.content?.data) {
-              context += `Data: ${JSON.stringify(msg.content.data, null, 2)}\n`;
-            }
-            context += '\n';
-          }
-        }
+  _appendParentTopicContext(lines, parentTopics) {
+    if (parentTopics.length === 0) {
+      return;
+    }
+
+    lines.push('## Parent Cluster Messages', '');
+
+    for (const topic of parentTopics) {
+      const topicLines = this._buildTopicContextLines(topic);
+      if (topicLines.length === 0) {
+        continue;
       }
+
+      lines.push(...topicLines);
+    }
+  }
+
+  _buildTopicContextLines(topic) {
+    const messages = this.messageBus.query({
+      cluster_id: this.parentCluster.id,
+      topic,
+      limit: 10,
+    });
+
+    if (messages.length === 0) {
+      return [];
     }
 
-    // Add triggering message
-    context += `\n## Triggering Message\n\n`;
-    context += `Topic: ${triggeringMessage.topic}\n`;
-    context += `Sender: ${triggeringMessage.sender}\n`;
-    if (triggeringMessage.content?.text) {
-      context += `\n${triggeringMessage.content.text}\n`;
+    const lines = [`### Topic: ${topic}`, ''];
+
+    for (const message of messages) {
+      lines.push(...this._buildMessageContextLines(message));
+      lines.push('');
     }
 
-    return context;
+    return lines;
+  }
+
+  _buildMessageContextLines(message) {
+    const lines = [`[${new Date(message.timestamp).toISOString()}] ${message.sender}:`];
+    const text = message.content?.text;
+    const data = message.content?.data;
+
+    if (text) {
+      lines.push(text);
+    }
+
+    if (data) {
+      lines.push(`Data: ${JSON.stringify(data, null, 2)}`);
+    }
+
+    return lines;
+  }
+
+  _appendTriggeringMessageContext(lines, triggeringMessage) {
+    lines.push(
+      '',
+      '## Triggering Message',
+      '',
+      `Topic: ${triggeringMessage.topic}`,
+      `Sender: ${triggeringMessage.sender}`
+    );
+
+    const text = triggeringMessage.content?.text;
+    if (text) {
+      lines.push('', text);
+    }
   }
 
   /**

package/src/template-resolver.js

@@ -272,25 +272,28 @@ class TemplateResolver {
    * @returns {any}
    */
   _parseValue(str) {
-    str = str.trim();
+    const trimmed = str.trim();
 
     // String literals (single or double quotes)
-    if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
-      return str.slice(1, -1);
+    if (
+      (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))
+    ) {
+      return trimmed.slice(1, -1);
     }
 
     // Boolean literals
-    if (str === 'true') return true;
-    if (str === 'false') return false;
-    if (str === 'undefined' || str === 'null') return undefined;
+    if (trimmed === 'true') return true;
+    if (trimmed === 'false') return false;
+    if (trimmed === 'undefined' || trimmed === 'null') return undefined;
 
     // Numbers
-    if (/^-?\d+(\.\d+)?$/.test(str)) {
-      return parseFloat(str);
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+      return parseFloat(trimmed);
     }
 
     // Return as-is for other cases
-    return str;
+    return trimmed;
   }
 
   /**

package/src/tui/data-poller.js

@@ -10,6 +10,7 @@
 
 const pidusage = require('pidusage');
 const Ledger = require('../ledger');
+const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
@@ -138,47 +139,11 @@ class DataPoller {
     try {
       const clusters = this.orchestrator.listClusters();
       const stats = {};
+      const pids = this._collectClusterPids(clusters);
 
-      // Collect all PIDs from all agents
-      const pids = [];
-      for (const cluster of clusters) {
-        try {
-          const status = this.orchestrator.getStatus(cluster.id);
-          for (const agent of status.agents || []) {
-            if (agent.pid) {
-              pids.push(agent.pid);
-            }
-          }
-        } catch {
-          // Skip clusters that error
-          continue;
-        }
-      }
-
-      // Get stats for all PIDs
       if (pids.length > 0) {
-        try {
-          const pidStats = await pidusage(pids);
-
-          // Convert to map format: pid -> { cpu, memory }
-          for (const pid of pids) {
-            if (pidStats[pid]) {
-              stats[pid] = {
-                cpu: pidStats[pid].cpu || 0,
-                memory: pidStats[pid].memory || 0,
-              };
-            } else {
-              // Process died - set to zero
-              stats[pid] = { cpu: 0, memory: 0 };
-            }
-          }
-        } catch {
-          // pidusage throws if any process is dead
-          // Set all to zero and continue
-          for (const pid of pids) {
-            stats[pid] = { cpu: 0, memory: 0 };
-          }
-        }
+        const pidStats = await this._safePidUsage(pids);
+        this._populatePidStats(stats, pids, pidStats);
       }
 
       this.onUpdate({
@@ -198,54 +163,36 @@ class DataPoller {
    */
   _watchForNewClusters() {
     this.watchForNewClustersStopFn = this.orchestrator.watchForNewClusters((cluster) => {
-      try {
-        // Lazy load ledger only when we need to stream messages
-        // This avoids loading all ledgers on startup
-        if (!this.ledgers.has(cluster.id)) {
-          const storageDir = this.orchestrator.storageDir || path.join(os.homedir(), '.zeroshot');
-          const dbPath = path.join(storageDir, `${cluster.id}.db`);
-
-          // Only load if database file exists
-          const fs = require('fs');
-          if (!fs.existsSync(dbPath)) {
-            return; // Skip non-existent ledgers
-          }
-
-          const ledger = new Ledger(dbPath);
-          this.ledgers.set(cluster.id, ledger);
-        }
-
-        // Start streaming messages
-        this._streamLedgerMessages(cluster.id);
+      // Lazy load ledger only when we need to stream messages
+      // This avoids loading all ledgers on startup
+      const ledger = this._loadLedgerForCluster(cluster, {
+        label: 'cluster',
+        requireExisting: true,
+      });
 
-        // Emit update about new cluster
-        this.onUpdate({
-          type: 'new_cluster',
-          cluster,
-        });
-      } catch (error) {
-        console.error(
-          `[DataPoller] Failed to load ledger for cluster ${cluster.id}:`,
-          error.message
-        );
+      if (!ledger) {
+        return;
       }
+
+      // Start streaming messages
+      this._streamLedgerMessages(cluster.id);
+
+      // Emit update about new cluster
+      this.onUpdate({
+        type: 'new_cluster',
+        cluster,
+      });
     }, 2000);
 
     // Also load ledgers for all existing clusters
     const existingClusters = this.orchestrator.listClusters();
     for (const cluster of existingClusters) {
-      try {
-        const storageDir = this.orchestrator.storageDir || path.join(os.homedir(), '.zeroshot');
-        const dbPath = path.join(storageDir, `${cluster.id}.db`);
-        const ledger = new Ledger(dbPath);
-        this.ledgers.set(cluster.id, ledger);
-        this._streamLedgerMessages(cluster.id);
-      } catch (error) {
-        console.error(
-          `[DataPoller] Failed to load ledger for existing cluster ${cluster.id}:`,
-          error.message
-        );
+      const ledger = this._loadLedgerForCluster(cluster, { label: 'existing cluster' });
+      if (!ledger) {
+        continue;
       }
+
+      this._streamLedgerMessages(cluster.id);
     }
   }
 
@@ -295,31 +242,108 @@ class DataPoller {
     const clusters = this.orchestrator.listClusters();
 
     for (const cluster of clusters) {
-      try {
-        const status = this.orchestrator.getStatus(cluster.id);
-
-        for (const agent of status.agents || []) {
-          if (agent.pid) {
-            try {
-              const pidStat = await pidusage(agent.pid);
-              stats[agent.pid] = {
-                cpu: pidStat.cpu || 0,
-                memory: pidStat.memory || 0,
-              };
-            } catch {
-              // Process died - set to zero
-              stats[agent.pid] = { cpu: 0, memory: 0 };
-            }
-          }
-        }
-      } catch {
-        // Skip clusters that error
-        continue;
+      const pids = this._getClusterAgentPids(cluster);
+      for (const pid of pids) {
+        stats[pid] = await this._getSinglePidStat(pid);
       }
     }
 
     return stats;
   }
+
+  _collectClusterPids(clusters) {
+    const pids = [];
+
+    for (const cluster of clusters) {
+      pids.push(...this._getClusterAgentPids(cluster));
+    }
+
+    return pids;
+  }
+
+  _getClusterAgentPids(cluster) {
+    try {
+      const status = this.orchestrator.getStatus(cluster.id);
+      const pids = [];
+
+      for (const agent of status.agents || []) {
+        if (agent.pid) {
+          pids.push(agent.pid);
+        }
+      }
+
+      return pids;
+    } catch {
+      // Skip clusters that error
+      return [];
+    }
+  }
+
+  async _getSinglePidStat(pid) {
+    try {
+      const pidStat = await pidusage(pid);
+      return {
+        cpu: pidStat.cpu || 0,
+        memory: pidStat.memory || 0,
+      };
+    } catch {
+      // Process died - set to zero
+      return { cpu: 0, memory: 0 };
+    }
+  }
+
+  async _safePidUsage(pids) {
+    try {
+      return await pidusage(pids);
+    } catch {
+      return null;
+    }
+  }
+
+  _populatePidStats(stats, pids, pidStats) {
+    for (const pid of pids) {
+      const entry = pidStats?.[pid];
+      stats[pid] = {
+        cpu: entry?.cpu || 0,
+        memory: entry?.memory || 0,
+      };
+    }
+  }
+
+  _loadLedgerForCluster(cluster, options) {
+    const { label, requireExisting = false } = options;
+
+    try {
+      return this._ensureLedger(cluster.id, { requireExisting });
+    } catch (error) {
+      console.error(
+        `[DataPoller] Failed to load ledger for ${label} ${cluster.id}:`,
+        error.message
+      );
+      return null;
+    }
+  }
+
+  _ensureLedger(clusterId, { requireExisting = false } = {}) {
+    const existing = this.ledgers.get(clusterId);
+    if (existing) {
+      return existing;
+    }
+
+    const dbPath = this._getLedgerPath(clusterId);
+    if (requireExisting && !fs.existsSync(dbPath)) {
+      return null;
+    }
+
+    const ledger = new Ledger(dbPath);
+    this.ledgers.set(clusterId, ledger);
+    return ledger;
+  }
+
+  _getLedgerPath(clusterId) {
+    const storageDir = this.orchestrator.storageDir || path.join(os.homedir(), '.zeroshot');
+    return path.join(storageDir, `${clusterId}.db`);
+  }
 }
 
 module.exports = DataPoller;

package/src/tui/formatters.js

@@ -64,12 +64,13 @@ const formatCPU = (percent) => {
   if (typeof percent !== 'number' || percent < 0) return '0.0%';
 
   // Assert normalized range (should never exceed 100% after per-core normalization)
-  if (percent > 100) {
+  let normalizedPercent = percent;
+  if (normalizedPercent > 100) {
     console.warn(`[formatCPU] CPU percent ${percent}% exceeds 100% - normalization bug?`);
-    percent = 100;
+    normalizedPercent = 100;
   }
 
-  return `${percent.toFixed(1)}%`;
+  return `${normalizedPercent.toFixed(1)}%`;
 };
 
 /**