@covibes/zeroshot 5.2.1 → 5.4.0

package/src/providers/opencode/output-parser.js

@@ -0,0 +1,122 @@
+function parseToolPart(part) {
+  const state = part.state || {};
+
+  if (state.status === 'pending' || state.status === 'running') {
+    return {
+      type: 'tool_call',
+      toolName: part.tool,
+      toolId: part.callID,
+      input: state.input || {},
+    };
+  }
+
+  if (state.status === 'completed') {
+    return {
+      type: 'tool_result',
+      toolId: part.callID,
+      content: state.output || '',
+      isError: false,
+    };
+  }
+
+  if (state.status === 'error') {
+    return {
+      type: 'tool_result',
+      toolId: part.callID,
+      content: state.error || '',
+      isError: true,
+    };
+  }
+
+  return null;
+}
+
+function parseStepFinish(part) {
+  const tokens = part.tokens || {};
+  return {
+    type: 'result',
+    success: true,
+    inputTokens: tokens.input || 0,
+    outputTokens: tokens.output || 0,
+  };
+}
+
+function parsePart(part) {
+  if (!part || typeof part !== 'object') return null;
+
+  if (part.type === 'text' && part.text) {
+    return { type: 'text', text: part.text };
+  }
+
+  if (part.type === 'reasoning' && part.text) {
+    return { type: 'thinking', text: part.text };
+  }
+
+  if (part.type === 'tool') {
+    return parseToolPart(part);
+  }
+
+  if (part.type === 'step-finish') {
+    return parseStepFinish(part);
+  }
+
+  return null;
+}
+
+function parseErrorEvent(event) {
+  const error = event.error || {};
+  return {
+    type: 'result',
+    success: false,
+    error: error.data?.message || error.message || error.name || 'Unknown error',
+  };
+}
+
+function parseEvent(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return null;
+  }
+
+  if (!event || typeof event !== 'object') return null;
+
+  if (event.type === 'error') {
+    return parseErrorEvent(event);
+  }
+
+  if (event.type === 'text' || event.type === 'step_start' || event.type === 'step_finish') {
+    return parsePart(event.part || event);
+  }
+
+  if (event.type === 'message.part.updated') {
+    return parsePart(event.properties?.part);
+  }
+
+  return null;
+}
+
+function parseChunk(chunk) {
+  const events = [];
+  const lines = chunk.split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const event = parseEvent(line);
+    if (!event) continue;
+    if (Array.isArray(event)) {
+      events.push(...event);
+    } else {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+module.exports = {
+  parseEvent,
+  parseChunk,
+  parsePart,
+};

package/src/schemas/sub-cluster.js

@@ -30,16 +30,18 @@
  * @param {Number} depth - Current nesting depth (for recursion limit)
  * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
  */
+const MAX_SUBCLUSTER_DEPTH = 5;
+
 function validateSubCluster(agentConfig, depth = 0) {
   const errors = [];
   const warnings = [];
 
   // Max nesting depth to prevent infinite recursion
-  const MAX_DEPTH = 5;
-
-  if (depth > MAX_DEPTH) {
-    errors.push(`Sub-cluster '${agentConfig.id}' exceeds max nesting depth (${MAX_DEPTH})`);
-    return { valid: false, errors, warnings };
+  if (depth > MAX_SUBCLUSTER_DEPTH) {
+    errors.push(
+      `Sub-cluster '${agentConfig.id}' exceeds max nesting depth (${MAX_SUBCLUSTER_DEPTH})`
+    );
+    return buildValidationResult(errors, warnings);
   }
 
   // Validate required fields
@@ -47,19 +49,44 @@ function validateSubCluster(agentConfig, depth = 0) {
     errors.push(`Agent '${agentConfig.id}' must have type: 'subcluster'`);
   }
 
+  if (!validateSubClusterConfig(agentConfig, depth, errors, warnings)) {
+    return buildValidationResult(errors, warnings);
+  }
+
+  // Validate triggers (sub-cluster must have triggers to activate)
+  validateSubClusterTriggers(agentConfig, errors);
+
+  // Validate hooks structure
+  validateSubClusterHooks(agentConfig, errors);
+
+  // Check for context bridging configuration
+  validateContextStrategy(agentConfig, errors);
+
+  return buildValidationResult(errors, warnings);
+}
+
+function buildValidationResult(errors, warnings) {
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+function validateSubClusterConfig(agentConfig, depth, errors, warnings) {
   if (!agentConfig.config) {
     errors.push(`Sub-cluster '${agentConfig.id}' missing config field`);
-    return { valid: false, errors, warnings };
+    return false;
   }
 
   if (!agentConfig.config.agents || !Array.isArray(agentConfig.config.agents)) {
     errors.push(`Sub-cluster '${agentConfig.id}' config.agents must be an array`);
-    return { valid: false, errors, warnings };
+    return false;
   }
 
   if (agentConfig.config.agents.length === 0) {
     errors.push(`Sub-cluster '${agentConfig.id}' config.agents cannot be empty`);
-    return { valid: false, errors, warnings };
+    return false;
   }
 
   // Recursively validate nested cluster config
@@ -71,46 +98,48 @@ function validateSubCluster(agentConfig, depth = 0) {
   }
 
   warnings.push(...childValidation.warnings.map((w) => `Sub-cluster '${agentConfig.id}': ${w}`));
+  return true;
+}
 
-  // Validate triggers (sub-cluster must have triggers to activate)
+function validateSubClusterTriggers(agentConfig, errors) {
   if (!agentConfig.triggers || agentConfig.triggers.length === 0) {
     errors.push(`Sub-cluster '${agentConfig.id}' must have triggers to activate`);
   }
+}
 
-  // Validate hooks structure
-  if (agentConfig.hooks) {
-    if (agentConfig.hooks.onComplete) {
-      const hook = agentConfig.hooks.onComplete;
-      if (!hook.action) {
-        errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing action`);
-      }
-      if (hook.action === 'publish_message' && !hook.config?.topic) {
-        errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing config.topic`);
-      }
-    }
+function validateSubClusterHooks(agentConfig, errors) {
+  if (!agentConfig.hooks?.onComplete) {
+    return;
   }
 
-  // Check for context bridging configuration
-  if (agentConfig.contextStrategy?.parentTopics) {
-    if (!Array.isArray(agentConfig.contextStrategy.parentTopics)) {
-      errors.push(`Sub-cluster '${agentConfig.id}' contextStrategy.parentTopics must be an array`);
-    } else {
-      // Validate each parent topic is a string
-      for (const topic of agentConfig.contextStrategy.parentTopics) {
-        if (typeof topic !== 'string') {
-          errors.push(
-            `Sub-cluster '${agentConfig.id}' parentTopics must contain strings, got ${typeof topic}`
-          );
-        }
-      }
-    }
+  const hook = agentConfig.hooks.onComplete;
+  if (!hook.action) {
+    errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing action`);
+  }
+  if (hook.action === 'publish_message' && !hook.config?.topic) {
+    errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing config.topic`);
   }
+}
 
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-  };
+function validateContextStrategy(agentConfig, errors) {
+  const parentTopics = agentConfig.contextStrategy?.parentTopics;
+  if (!parentTopics) {
+    return;
+  }
+
+  if (!Array.isArray(parentTopics)) {
+    errors.push(`Sub-cluster '${agentConfig.id}' contextStrategy.parentTopics must be an array`);
+    return;
+  }
+
+  // Validate each parent topic is a string
+  for (const topic of parentTopics) {
+    if (typeof topic !== 'string') {
+      errors.push(
+        `Sub-cluster '${agentConfig.id}' parentTopics must contain strings, got ${typeof topic}`
+      );
+    }
+  }
 }
 
 /**

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

@@ -36,6 +36,7 @@ class SubClusterWrapper {
     this.childClusterId = null;
 
     this.quiet = options.quiet || false;
+    this.modelOverride = options.modelOverride || null;
   }
 
   /**
@@ -285,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`;
+    const lines = [
+      '# Child Cluster Context',
+      '',
+      `Parent Cluster: ${this.parentCluster.id}`,
+      `SubCluster ID: ${this.id}`,
+      `Iteration: ${this.iteration}`,
+      '',
+    ];
 
-    // Add messages from specified parent topics
-    if (parentTopics.length > 0) {
-      context += `## Parent Cluster Messages\n\n`;
+    this._appendParentTopicContext(lines, parentTopics);
+    this._appendTriggeringMessageContext(lines, triggeringMessage);
 
-      for (const topic of parentTopics) {
-        const messages = this.messageBus.query({
-          cluster_id: this.parentCluster.id,
-          topic,
-          limit: 10,
-        });
+    return lines.join('\n');
+  }
+
+  _appendParentTopicContext(lines, parentTopics) {
+    if (parentTopics.length === 0) {
+      return;
+    }
+
+    lines.push('## Parent Cluster Messages', '');
 
-        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';
-          }
-        }
+    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 [];
+    }
+
+    const lines = [`### Topic: ${topic}`, ''];
+
+    for (const message of messages) {
+      lines.push(...this._buildMessageContextLines(message));
+      lines.push('');
+    }
+
+    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);
     }
 
-    // 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`;
+    if (data) {
+      lines.push(`Data: ${JSON.stringify(data, null, 2)}`);
     }
 
-    return context;
+    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);
+    }
   }
 
   /**
@@ -341,17 +383,31 @@ class SubClusterWrapper {
     this.childClusterId = childId;
 
     // Create child orchestrator with separate database
-    const childOrchestrator = new Orchestrator({
+    const childOrchestrator = await Orchestrator.create({
       quiet: this.quiet,
       skipLoad: true,
       storageDir: path.join(this.parentCluster.ledger.dbPath, '..', 'subclusters', childId),
     });
 
+    const childConfig = JSON.parse(JSON.stringify(this.config.config));
+    const parentConfig = this.parentCluster?.config || {};
+
+    if (parentConfig.forceProvider) {
+      childConfig.forceProvider = parentConfig.forceProvider;
+      childConfig.defaultProvider = parentConfig.forceProvider;
+      if (parentConfig.forceLevel) {
+        childConfig.forceLevel = parentConfig.forceLevel;
+        childConfig.defaultLevel = parentConfig.forceLevel;
+      }
+    } else if (parentConfig.defaultProvider && !childConfig.defaultProvider) {
+      childConfig.defaultProvider = parentConfig.defaultProvider;
+    }
+
     // Start child cluster with text input (context from parent)
     const childCluster = await childOrchestrator.start(
-      this.config.config, // Child cluster config
+      childConfig, // Child cluster config
       { text: context },
-      { testMode: false }
+      { testMode: false, modelOverride: this.modelOverride || undefined }
     );
 
     // Create message bridge

package/src/task-runner.js

@@ -1,18 +1,20 @@
 /**
- * TaskRunner - Strategy Pattern interface for executing Claude tasks
+ * TaskRunner - Strategy Pattern interface for executing provider tasks
  *
- * Implementations must provide a `run()` method that executes a Claude task
+ * Implementations must provide a `run()` method that executes a task
  * with the given context and options. Different runners can implement various
- * execution strategies (Claude CLI, mock responses, etc).
+ * execution strategies (CLI, mock responses, etc).
  */
 class TaskRunner {
   /**
-   * Execute a Claude task with the given context and options
+   * Execute a provider task with the given context and options
    *
-   * @param {string} _context - Full prompt/context for Claude to process
+   * @param {string} _context - Full prompt/context for the provider to process
    * @param {Object} _options - Execution options
    * @param {string} _options.agentId - Identifier for this agent/task
-   * @param {string} _options.model - Model to use (e.g., 'opus', 'sonnet', 'haiku')
+   * @param {string} _options.model - Model to use (provider-specific model id)
+   * @param {string} [_options.provider] - Provider to use (claude|codex|gemini)
+   * @param {object} [_options.modelSpec] - Resolved model spec (level/model/reasoningEffort)
    * @param {string} [_options.outputFormat] - Output format ('text', 'json', 'stream-json')
    * @param {Object} [_options.jsonSchema] - JSON schema for structured output validation
    * @param {string} [_options.cwd] - Working directory for task execution