@covibes/zeroshot 1.4.0 → 2.0.0

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

@@ -51,6 +51,72 @@ function sanitizeErrorMessage(error) {
   return error;
 }
 
+/**
+ * Strip timestamp prefix from log lines.
+ * Log lines may have format: [epochMs]{json...} or [epochMs]text
+ *
+ * @param {string} line - Raw log line
+ * @returns {string} Line content without timestamp prefix, empty string for invalid input
+ */
+function stripTimestampPrefix(line) {
+  if (!line || typeof line !== 'string') return '';
+  const trimmed = line.trim().replace(/\r$/, '');
+  if (!trimmed) return '';
+  const match = trimmed.match(/^\[(\d{13})\](.*)$/);
+  return match ? match[2] : trimmed;
+}
+
+/**
+ * Extract error context from task output.
+ * Shared by both isolated and non-isolated modes.
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {string} params.output - Full task output
+ * @param {string} [params.statusOutput] - Status command output (non-isolated only)
+ * @param {string} params.taskId - Task ID for error messages
+ * @param {boolean} [params.isNotFound=false] - True if task was not found
+ * @returns {string|null} Sanitized error context or null if extraction failed
+ */
+function extractErrorContext({ output, statusOutput, taskId, isNotFound = false }) {
+  // Task not found - explicit error
+  if (isNotFound) {
+    return sanitizeErrorMessage(`Task ${taskId} not found (may have crashed or been killed)`);
+  }
+
+  // Try status output first (only available in non-isolated mode)
+  if (statusOutput) {
+    const statusErrorMatch = statusOutput.match(/Error:\s*(.+)/);
+    if (statusErrorMatch) {
+      return sanitizeErrorMessage(statusErrorMatch[1].trim());
+    }
+  }
+
+  // Fall back to extracting from output (last 500 chars)
+  const lastOutput = (output || '').slice(-500).trim();
+  if (!lastOutput) {
+    return sanitizeErrorMessage('Task failed with no output (check if task was interrupted or timed out)');
+  }
+
+  // Common error patterns
+  const errorPatterns = [
+    /Error:\s*(.+)/i,
+    /error:\s*(.+)/i,
+    /failed:\s*(.+)/i,
+    /Exception:\s*(.+)/i,
+    /panic:\s*(.+)/i,
+  ];
+
+  for (const pattern of errorPatterns) {
+    const match = lastOutput.match(pattern);
+    if (match) {
+      return sanitizeErrorMessage(match[1].slice(0, 200));
+    }
+  }
+
+  // No pattern matched - include last portion of output
+  return sanitizeErrorMessage(`Task failed. Last output: ${lastOutput.slice(-200)}`);
+}
+
 // Track if we've already ensured the AskUserQuestion hook is installed
 let askUserQuestionHookInstalled = false;
 
@@ -68,10 +134,11 @@ function extractTokenUsage(output) {
 
   // Find the result line containing usage data
   for (const line of lines) {
-    if (!line.trim()) continue;
+    const content = stripTimestampPrefix(line);
+    if (!content) continue;
 
     try {
-      const event = JSON.parse(line.trim());
+      const event = JSON.parse(content);
       if (event.type === 'result') {
         const usage = event.usage || {};
         return {
@@ -527,14 +594,45 @@ function followClaudeTaskLogs(agent, taskId) {
         // Track exec failures - if status command keeps failing, something is wrong
         if (error) {
           consecutiveExecFailures++;
-          if (consecutiveExecFailures === MAX_CONSECUTIVE_FAILURES) {
+          if (consecutiveExecFailures >= MAX_CONSECUTIVE_FAILURES) {
             console.error(
-              `[Agent ${agent.id}] ⚠️ Status polling failed ${MAX_CONSECUTIVE_FAILURES} times consecutively!`
+              `[Agent ${agent.id}] ⚠️ Status polling failed ${MAX_CONSECUTIVE_FAILURES} times consecutively! STOPPING.`
             );
             console.error(`  Command: ${ctPath} status ${taskId}`);
             console.error(`  Error: ${error.message}`);
             console.error(`  Stderr: ${stderr || 'none'}`);
             console.error(`  This may indicate zeroshot is not in PATH or task storage is corrupted.`);
+
+            // Stop polling and resolve with failure
+            if (!resolved) {
+              resolved = true;
+              clearInterval(pollInterval);
+              clearInterval(statusCheckInterval);
+              agent.currentTask = null;
+
+              // Publish error for orchestrator/resume
+              agent._publish({
+                topic: 'AGENT_ERROR',
+                receiver: 'broadcast',
+                content: {
+                  text: `Task ${taskId} polling failed after ${MAX_CONSECUTIVE_FAILURES} consecutive failures`,
+                  data: {
+                    taskId,
+                    error: 'polling_timeout',
+                    attempts: consecutiveExecFailures,
+                    role: agent.role,
+                    iteration: agent.iteration,
+                  },
+                },
+              });
+
+              resolve({
+                success: false,
+                output,
+                error: `Status polling failed ${MAX_CONSECUTIVE_FAILURES} times - task may not exist`,
+              });
+            }
+            return;
           }
           return; // Keep polling - might be transient
         }
@@ -566,47 +664,15 @@ function followClaudeTaskLogs(agent, taskId) {
             clearInterval(statusCheckInterval);
             agent.currentTask = null;
 
-            // Extract meaningful error context when task fails
-            let errorContext = null;
-            if (!success) {
-              // Try to extract error from status output first
-              const statusErrorMatch = stdout.match(/Error:\s*(.+)/);
-              if (statusErrorMatch) {
-                errorContext = statusErrorMatch[1].trim();
-              } else {
-                // Fall back to last 500 chars of output (likely contains the failure reason)
-                const lastOutput = output.slice(-500).trim();
-                if (lastOutput) {
-                  // Look for common error patterns in output
-                  const errorPatterns = [
-                    /Error:\s*(.+)/i,
-                    /error:\s*(.+)/i,
-                    /failed:\s*(.+)/i,
-                    /Exception:\s*(.+)/i,
-                    /panic:\s*(.+)/i,
-                  ];
-                  for (const pattern of errorPatterns) {
-                    const match = lastOutput.match(pattern);
-                    if (match) {
-                      errorContext = match[1].slice(0, 200);
-                      break;
-                    }
-                  }
-                  // If no pattern matched, include last portion of output
-                  if (!errorContext) {
-                    errorContext = `Task failed. Last output: ${lastOutput.slice(-200)}`;
-                  }
-                } else {
-                  errorContext =
-                    'Task failed with no output (check if task was interrupted or timed out)';
-                }
-              }
-            }
+            // Extract error context using shared helper
+            const errorContext = !success
+              ? extractErrorContext({ output, statusOutput: stdout, taskId })
+              : null;
 
             resolve({
               success,
               output,
-              error: sanitizeErrorMessage(errorContext),
+              error: errorContext,
               tokenUsage: extractTokenUsage(output),
             });
           }, 500);
@@ -912,12 +978,14 @@ function followClaudeTaskLogsIsolated(agent, taskId) {
               `zeroshot status ${taskId} 2>/dev/null || echo "not_found"`,
             ]);
 
-            const statusOutput = statusResult.stdout.toLowerCase();
-            if (
-              statusOutput.includes('success') ||
-              statusOutput.includes('error') ||
-              statusOutput.includes('not_found')
-            ) {
+            // Use same regex patterns as non-isolated mode (lines 649-650)
+            // CRITICAL: Don't use substring matching - it matches "error" in "is_error":false
+            const statusOutput = statusResult.stdout;
+            const isSuccess = /Status:\s+completed/i.test(statusOutput);
+            const isError = /Status:\s+failed/i.test(statusOutput);
+            const isNotFound = statusOutput.includes('not_found');
+
+            if (isSuccess || isError || isNotFound) {
               // Task finished - read final output and resolve
               const finalReadResult = await manager.execInContainer(clusterId, [
                 'sh',
@@ -940,13 +1008,23 @@ function followClaudeTaskLogsIsolated(agent, taskId) {
               cleanup();
               taskExited = true;
 
-              // Parse result from output (same logic as non-isolated mode)
+              // Determine success status
+              const success = isSuccess && !isError;
+
+              // Extract error context using shared helper
+              const errorContext = !success
+                ? extractErrorContext({ output: fullOutput, taskId, isNotFound })
+                : null;
+
+              // Parse result from output
               const parsedResult = agent._parseResultOutput(fullOutput);
 
               resolve({
+                success,
                 output: fullOutput,
                 taskId,
                 result: parsedResult,
+                error: errorContext,
                 tokenUsage: extractTokenUsage(fullOutput),
               });
             }
@@ -956,18 +1034,19 @@ function followClaudeTaskLogsIsolated(agent, taskId) {
           }
         }, 500);
 
-        // Safety timeout (same as non-isolated mode)
-        const timeoutMs = agent.timeout || 300000; // 5 minutes default
-        setTimeout(() => {
-          if (!taskExited) {
-            cleanup();
-            reject(
-              new Error(
-                `Task ${taskId} timeout after ${timeoutMs}ms (isolated mode)`
-              )
-            );
-          }
-        }, timeoutMs);
+        // Safety timeout (0 = no timeout, task runs until completion)
+        if (agent.timeout > 0) {
+          setTimeout(() => {
+            if (!taskExited) {
+              cleanup();
+              reject(
+                new Error(
+                  `Task ${taskId} timeout after ${agent.timeout}ms (isolated mode)`
+                )
+              );
+            }
+          }, agent.timeout);
+        }
       })
       .catch((err) => {
         cleanup();
@@ -994,11 +1073,14 @@ function parseResultOutput(agent, output) {
   let trimmedOutput = output.trim();
 
   // IMPORTANT: Output is NDJSON (one JSON object per line) from streaming log
+  // Lines may have timestamp prefix: [epochMs]{json...}
   // Find the line with "type":"result" which contains the actual result
   const lines = trimmedOutput.split('\n');
   const resultLine = lines.find((line) => {
     try {
-      const obj = JSON.parse(line.trim());
+      const content = stripTimestampPrefix(line);
+      if (!content.startsWith('{')) return false;
+      const obj = JSON.parse(content);
       return obj.type === 'result';
     } catch {
       return false;
@@ -1006,13 +1088,15 @@ function parseResultOutput(agent, output) {
   });
 
   // Use the result line if found, otherwise use last non-empty line
+  // CRITICAL: Strip timestamp prefix before assigning to trimmedOutput
   if (resultLine) {
-    trimmedOutput = resultLine.trim();
+    trimmedOutput = stripTimestampPrefix(resultLine);
   } else if (lines.length > 1) {
-    // Fallback: use last non-empty line
+    // Fallback: use last non-empty line (also strip timestamp)
     for (let i = lines.length - 1; i >= 0; i--) {
-      if (lines[i].trim()) {
-        trimmedOutput = lines[i].trim();
+      const content = stripTimestampPrefix(lines[i]);
+      if (content) {
+        trimmedOutput = content;
         break;
       }
     }

package/src/config-validator.js

@@ -415,6 +415,19 @@ function validateAgents(config) {
       }
     }
 
+    // Check for git operations in validator prompts (unreliable in agents)
+    if (agent.role === 'validator') {
+      const prompt = typeof agent.prompt === 'string' ? agent.prompt : agent.prompt?.system;
+      const gitPatterns = ['git diff', 'git status', 'git log', 'git show'];
+      for (const pattern of gitPatterns) {
+        if (prompt?.includes(pattern)) {
+          errors.push(
+            `Validator '${agent.id}' uses '${pattern}' - git state is unreliable in agents`
+          );
+        }
+      }
+    }
+
     // JSON output without schema
     if (agent.outputFormat === 'json' && !agent.jsonSchema) {
       warnings.push(

package/src/isolation-manager.js

@@ -191,7 +191,7 @@ class IsolationManager {
                 try {
                   installResult = await this.execInContainer(
                     clusterId,
-                    ['sh', '-c', 'npm install --no-audit --no-fund 2>&1'],
+                    ['sh', '-c', 'npm_config_engine_strict=false npm install --no-audit --no-fund'],
                     {}
                   );
 
@@ -201,16 +201,18 @@ class IsolationManager {
                   }
 
                   // Failed - retry if not last attempt
+                  // Use stderr if available, otherwise stdout (npm writes some errors to stdout)
+                  const errorOutput = (installResult.stderr || installResult.stdout || '').slice(0, 500);
                   if (attempt < maxRetries) {
                     const delay = baseDelay * Math.pow(2, attempt - 1);
                     console.warn(
                       `[IsolationManager] ⚠️ npm install failed (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms...`
                     );
-                    console.warn(`[IsolationManager] Error: ${installResult.stderr.slice(0, 200)}`);
+                    console.warn(`[IsolationManager] Error: ${errorOutput}`);
                     await new Promise((_resolve) => setTimeout(_resolve, delay));
                   } else {
                     console.warn(
-                      `[IsolationManager] ⚠️ npm install failed after ${maxRetries} attempts (non-fatal): ${installResult.stderr.slice(0, 200)}`
+                      `[IsolationManager] ⚠️ npm install failed after ${maxRetries} attempts (non-fatal): ${errorOutput}`
                     );
                   }
                 } catch (execErr) {
@@ -342,8 +344,9 @@ class IsolationManager {
    * @param {number} [timeout=10] - Timeout in seconds before SIGKILL
    * @returns {Promise<void>}
    */
-  stopContainer(clusterId, timeout = 10) {
-    const containerId = this.containers.get(clusterId);
+  stopContainer(clusterId, timeout = 10, explicitContainerId = null) {
+    // Use explicit containerId (from restored state) or in-memory Map
+    const containerId = explicitContainerId || this.containers.get(clusterId);
     if (!containerId) {
       return; // Already stopped or never started
     }
@@ -369,8 +372,9 @@ class IsolationManager {
    * @param {boolean} [force=false] - Force remove running container
    * @returns {Promise<void>}
    */
-  removeContainer(clusterId, force = false) {
-    const containerId = this.containers.get(clusterId);
+  removeContainer(clusterId, force = false, explicitContainerId = null) {
+    // Use explicit containerId (from restored state) or in-memory Map
+    const containerId = explicitContainerId || this.containers.get(clusterId);
     if (!containerId) {
       return;
     }

package/src/orchestrator.js

@@ -126,9 +126,55 @@ class Orchestrator {
       const clusterIds = Object.keys(data);
       this._log(`[Orchestrator] Found ${clusterIds.length} clusters in file:`, clusterIds);
 
+      // Track clusters to remove (missing .db files or 0 messages)
+      const clustersToRemove = [];
+      // Track clusters with 0 messages (corrupted from SIGINT race condition)
+      const corruptedClusters = [];
+
       for (const [clusterId, clusterData] of Object.entries(data)) {
+        // Skip clusters whose .db file doesn't exist (orphaned registry entries)
+        const dbPath = path.join(this.storageDir, `${clusterId}.db`);
+        if (!fs.existsSync(dbPath)) {
+          console.warn(`[Orchestrator] Cluster ${clusterId} has no database file, removing from registry`);
+          clustersToRemove.push(clusterId);
+          continue;
+        }
+
         this._log(`[Orchestrator] Loading cluster: ${clusterId}`);
-        this._loadSingleCluster(clusterId, clusterData);
+        const cluster = this._loadSingleCluster(clusterId, clusterData);
+
+        // VALIDATION: Detect 0-message clusters (corrupted from SIGINT during initialization)
+        // These clusters were created before the initCompletePromise fix was applied
+        if (cluster && cluster.messageBus) {
+          const messageCount = cluster.messageBus.count({ cluster_id: clusterId });
+          if (messageCount === 0) {
+            console.warn(`[Orchestrator] ⚠️  Cluster ${clusterId} has 0 messages (corrupted)`);
+            console.warn(`[Orchestrator]    This likely occurred from SIGINT during initialization.`);
+            console.warn(`[Orchestrator]    Marking as 'corrupted' - use 'zeroshot kill ${clusterId}' to remove.`);
+            corruptedClusters.push(clusterId);
+            // Mark cluster as corrupted for visibility in status/list commands
+            cluster.state = 'corrupted';
+            cluster.corruptedReason = 'SIGINT during initialization (0 messages in ledger)';
+          }
+        }
+      }
+
+      // Clean up orphaned entries from clusters.json
+      if (clustersToRemove.length > 0) {
+        for (const clusterId of clustersToRemove) {
+          delete data[clusterId];
+        }
+        fs.writeFileSync(clustersFile, JSON.stringify(data, null, 2));
+        this._log(`[Orchestrator] Removed ${clustersToRemove.length} orphaned cluster(s) from registry`);
+      }
+
+      // Log summary of corrupted clusters
+      if (corruptedClusters.length > 0) {
+        console.warn(`\n[Orchestrator] ⚠️  Found ${corruptedClusters.length} corrupted cluster(s):`);
+        for (const clusterId of corruptedClusters) {
+          console.warn(`    - ${clusterId}`);
+        }
+        console.warn(`[Orchestrator] Run 'zeroshot clear' to remove all corrupted clusters.\n`);
       }
 
       this._log(`[Orchestrator] Total clusters loaded: ${this.clusters.size}`);
@@ -494,6 +540,13 @@ class Orchestrator {
     }
 
     // Build cluster object
+    // CRITICAL: initComplete promise ensures ISSUE_OPENED is published before stop() completes
+    // This prevents 0-message clusters from SIGINT during async initialization
+    let resolveInitComplete;
+    const initCompletePromise = new Promise((resolve) => {
+      resolveInitComplete = resolve;
+    });
+
     const cluster = {
       id: clusterId,
       config,
@@ -504,6 +557,9 @@ class Orchestrator {
       createdAt: Date.now(),
       // Track PID for zombie detection (this process owns the cluster)
       pid: process.pid,
+      // Initialization completion tracking (for safe SIGINT handling)
+      initCompletePromise,
+      _resolveInitComplete: resolveInitComplete,
       // Isolation state (only if enabled)
       // CRITICAL: Store workDir for resume capability - without this, resume() can't recreate container
       isolation: options.isolation
@@ -652,6 +708,12 @@ class Orchestrator {
         },
       });
 
+      // CRITICAL: Mark initialization complete AFTER ISSUE_OPENED is published
+      // This ensures stop() waits for at least 1 message before stopping
+      if (cluster._resolveInitComplete) {
+        cluster._resolveInitComplete();
+      }
+
       this._log(`Cluster ${clusterId} started with ${cluster.agents.length} agents`);
 
       // Watch for CLUSTER_COMPLETE message to auto-stop
@@ -818,6 +880,10 @@ class Orchestrator {
       };
     } catch (error) {
       cluster.state = 'failed';
+      // CRITICAL: Resolve the promise on failure too, so stop() doesn't hang
+      if (cluster._resolveInitComplete) {
+        cluster._resolveInitComplete();
+      }
       console.error(`Cluster ${clusterId} failed to start:`, error);
       throw error;
     }
@@ -833,6 +899,17 @@ class Orchestrator {
       throw new Error(`Cluster ${clusterId} not found`);
     }
 
+    // CRITICAL: Wait for initialization to complete before stopping
+    // This ensures ISSUE_OPENED is published, preventing 0-message clusters
+    // Timeout after 30s to prevent infinite hang if init truly fails
+    if (cluster.initCompletePromise && cluster.state === 'initializing') {
+      this._log(`[Orchestrator] Waiting for initialization to complete before stopping...`);
+      await Promise.race([
+        cluster.initCompletePromise,
+        new Promise((resolve) => setTimeout(resolve, 30000)),
+      ]);
+    }
+
     cluster.state = 'stopping';
 
     // Stop all agents (including subclusters which handle their own children)

package/src/status-footer.js

@@ -96,6 +96,11 @@ class StatusFooter {
     this.minRows = 8; // Minimum rows for footer display (graceful degradation)
     this.hidden = false; // True when terminal too small for footer
 
+    // Output queue - serializes all stdout to prevent cursor corruption
+    // When scroll region is active, console.log() can corrupt cursor position
+    // All output must go through print() to coordinate with render cycles
+    this.printQueue = [];
+
     // Debounced resize handler (100ms) - prevents rapid-fire redraws
     this._debouncedResize = debounce(() => this._handleResize(), 100);
   }
@@ -108,6 +113,38 @@ class StatusFooter {
     return process.stdout.isTTY === true;
   }
 
+  /**
+   * Print text to stdout, coordinating with the render cycle.
+   * When a render is in progress, queues output to prevent cursor corruption.
+   * When no render is active, writes immediately.
+   *
+   * MUST be used instead of console.log() when status footer is active.
+   * @param {string} text - Text to print (newline will be added)
+   */
+  print(text) {
+    if (this.isRendering) {
+      // Queue for later - render() will flush after restoring cursor
+      this.printQueue.push(text);
+    } else {
+      // Write immediately - no render in progress
+      process.stdout.write(text + '\n');
+    }
+  }
+
+  /**
+   * Flush queued output to stdout.
+   * Called after render() restores cursor to ensure proper positioning.
+   * @private
+   */
+  _flushPrintQueue() {
+    if (this.printQueue.length === 0) return;
+
+    // Write all queued output
+    const output = this.printQueue.map(text => text + '\n').join('');
+    this.printQueue = [];
+    process.stdout.write(output);
+  }
+
   /**
    * Get terminal dimensions
    * @returns {{ rows: number, cols: number }}
@@ -495,6 +532,19 @@ class StatusFooter {
     } finally {
       this.isRendering = false;
 
+      // CRITICAL: Position cursor at bottom of scroll region before flushing
+      // Without this, output goes below footer if cursor was restored outside scroll region
+      // (RESTORE_CURSOR at line 527 may restore to row outside the scrollable area)
+      if (this.scrollRegionSet) {
+        const { rows } = this.getTerminalSize();
+        const scrollEnd = rows - this.footerHeight;
+        process.stdout.write(this._moveToStr(scrollEnd, 1));
+      }
+
+      // Flush any output that was queued during render
+      // Must happen BEFORE pending resize to preserve output order
+      this._flushPrintQueue();
+
       // Process pending resize if one was queued during render
       if (this.pendingResize) {
         this.pendingResize = false;
@@ -728,13 +778,15 @@ class StatusFooter {
       // Prevents interleaving with agent output during cleanup
       let buffer = '';
 
-      // Reset scroll region
+      // CRITICAL: Clear footer area BEFORE resetting scroll region
+      // While scroll region is active, footer area contains only status bar content
+      // After reset, those lines may contain scrolled output (which we DON'T want to clear)
+      buffer += this._clearFooterAreaStr();
+
+      // Now reset scroll region (full terminal is scrollable again)
       buffer += this._resetScrollRegionStr();
       this.scrollRegionSet = false;
 
-      // Clear all footer lines
-      buffer += this._clearFooterAreaStr();
-
       // Move cursor to safe position and show cursor
       const { rows } = this.getTerminalSize();
       const startRow = rows - this.footerHeight + 1;
@@ -753,9 +805,10 @@ class StatusFooter {
     if (!this.isTTY()) return;
 
     // Single atomic write for hide operation
-    let buffer = this._resetScrollRegionStr();
+    // CRITICAL: Clear footer BEFORE resetting scroll region (same reason as stop())
+    let buffer = this._clearFooterAreaStr();
+    buffer += this._resetScrollRegionStr();
     this.scrollRegionSet = false;
-    buffer += this._clearFooterAreaStr();
     process.stdout.write(buffer);
   }
 

package/src/template-resolver.js

@@ -43,8 +43,11 @@ class TemplateResolver {
     // Validate required params
     this._validateParams(template, params);
 
+    // Apply defaults for missing params (e.g., timeout: 0)
+    const paramsWithDefaults = this._applyDefaults(template, params);
+
     // Deep clone and resolve
-    const resolved = this._resolveObject(JSON.parse(JSON.stringify(template)), params);
+    const resolved = this._resolveObject(JSON.parse(JSON.stringify(template)), paramsWithDefaults);
 
     // Filter out conditional agents that don't meet their condition
     if (resolved.agents) {
@@ -86,6 +89,25 @@ class TemplateResolver {
     }
   }
 
+  /**
+   * Apply template defaults for any missing params
+   * @private
+   * @param {any} template
+   * @param {any} params
+   * @returns {any} params with defaults applied
+   */
+  _applyDefaults(template, params) {
+    if (!template.params) return params;
+
+    const result = { ...params };
+    for (const [name, schema] of Object.entries(template.params)) {
+      if (result[name] === undefined && schema.default !== undefined) {
+        result[name] = schema.default;
+      }
+    }
+    return result;
+  }
+
   /**
    * Recursively resolve placeholders in an object
    * @private