opencode-orchestrator 1.0.31 → 1.0.33

package/README.md

@@ -66,38 +66,38 @@ MSVP is a structured verification process that decouples implementation from qua
               [User Task Input]
                      │
            ┌─────────▼─────────┐
-           │     COMMANDER     │ (Orchestration context)
+           │     COMMANDER     │  (Orchestration & Discovery)
            └─────────┬─────────┘
                      │
            ┌─────────▼─────────┐
-           │      PLANNER      │ (Create Hierarchical Plan)
+           │      PLANNER      │  (Create TODO.md)
            └─────────┬─────────┘
                      │
     ┌────────────────▼────────────────┐
-    │  Phase 1: Parallel Execution    │ (HPFA Implementation Grid)
+    │     COMMANDER: Parallel Launch  │
     └──────┬─────────┬─────────┬──────┘
            │         │         │
     ┌──────▼──┐ ┌────▼───┐ ┌───▼────┐
-    │ WORKER  │ │ WORKER │ │ WORKER │ (Fractal Spawning)
-    └──────┬──┘ └────┬───┘ └───┬────┘
-           │         │         │
-    ┌──────▼──┐ ┌────▼───┐ ┌───▼────┐
-    │ REVIEWER│ │ REVIEWER│ │ REVIEWER│ (Stage 1: Unit Verification)
-    └──────┬──┘ └────┬───┘ └───┬────┘
-           │         │         │
-    ───────▼─────────▼─────────▼───────
-    │          Sync Barrier           │ (Wait for all units)
-    ─────────────────┬─────────────────
-                     │
-           ┌─────────▼─────────┐
-           │  MASTER REVIEWER  │ (Stage 2: e2e Verification)
-           └─────────┬─────────┘
-                     │
-           ┌─────────▼─────────┐
-           │  Mission Sealed?  │
-           └─────────┬─────────┘
-                No ↙   ↘ Yes
-             [Loop]   [Complete]
+    │ WORKER A│ │ WORKER B│ │ WORKER C│  (Implementation)
+    └────┬────┘ └────┬───┘ └────┬────┘
+         │           │          │
+    ┌────▼────┐ ┌────▼───┐ ┌────▼────┐
+    │REVIEWER │ │REVIEWER │ │REVIEWER │  (Unit Verification)
+    └────┬────┘ └────┬───┘ └────┬────┘
+         │           │          │
+    ═════▼═══════════▼══════════▼══════
+    │          SYNC BARRIER           │
+    ════════════════╤══════════════════
+                    │
+          ┌─────────▼─────────┐
+          │  MASTER REVIEWER  │  (E2E Verification)
+          └─────────┬─────────┘
+                    │
+          ┌─────────▼─────────┐
+          │  Mission Sealed?  │
+          └─────────┬─────────┘
+               No ↙   ↘ Yes
+            [Loop]   [Complete]
 ```
 
 ---

package/dist/index.js

@@ -334,8 +334,24 @@ var PARALLEL_TASK = {
   // Task lifecycle (24 hours for long tasks)
   TTL_MS: 24 * TIME.HOUR,
   CLEANUP_DELAY_MS: 10 * TIME.MINUTE,
-  MAX_DEPTH: 8,
-  // Titan-Class depth for complex fractal missions
+  /**
+   * Maximum recursion depth for parallel task spawning
+   * 
+   * Depth hierarchy:
+   * - Depth 0: Commander (can spawn Planner/Worker/Reviewer)
+   * - Depth 1: Planner (can spawn Worker)
+   * - Depth 2: Worker/Reviewer (TERMINAL - cannot spawn sub-agents)
+   * - Depth 3: BLOCKED
+   * 
+   * This prevents infinite recursion and ensures Master Reviewer
+   * doesn't wait indefinitely for deeply nested sub-tasks.
+   */
+  MAX_DEPTH: 3,
+  /**
+   * Terminal node depth - agents at this depth cannot spawn sub-agents.
+   * Worker and Reviewer are terminal nodes by design.
+   */
+  TERMINAL_DEPTH: 2,
   // Concurrency limits (Aggressive for intense processing)
   DEFAULT_CONCURRENCY: 10,
   MAX_CONCURRENCY: 50,
@@ -14585,7 +14601,12 @@ ${PROMPT_TAGS.ROLE.close}`;
 var WORKER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
 **FORBIDDEN ACTIONS (Adapt to Project Conventions)**
 
-
+## \u26D4 NEVER Spawn or Delegate (CRITICAL)
+- NEVER use \`${TOOL_NAMES.DELEGATE_TASK}\` to spawn sub-workers
+- NEVER use \`${TOOL_NAMES.CALL_AGENT}\` to create additional sessions
+- You are a TERMINAL node - complete your assigned file directly
+- If task is too complex, REPORT BACK to ${AGENT_NAMES.COMMANDER} with specific blockers
+- Violating this rule causes infinite recursion and system failure
 
 ## Never Assume
 - NEVER guess API syntax \u2192 CHECK ${PATHS.DOCS}/ or research first
@@ -14595,7 +14616,6 @@ var WORKER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
 ## Never Skip
 - NEVER skip error handling \u2192 Follow project's error handling patterns
 - NEVER skip ${TOOL_NAMES.LSP_DIAGNOSTICS} \u2192 Always verify code compiles
-
 - NEVER skip verification \u2192 Test before claiming done
 
 ## Never Shortcut
@@ -15009,7 +15029,12 @@ ${PROMPT_TAGS.ROLE.close}`;
 var REVIEWER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
 **FORBIDDEN ACTIONS**
 
-
+## \u26D4 NEVER Spawn or Delegate (CRITICAL)
+- NEVER use \`${TOOL_NAMES.DELEGATE_TASK}\` to spawn additional reviewers
+- NEVER use \`${TOOL_NAMES.CALL_AGENT}\` to create sub-sessions
+- You are a TERMINAL node - verify your assigned file directly
+- If verification scope is too large, REPORT BACK to ${AGENT_NAMES.COMMANDER}
+- Violating this rule causes infinite recursion and blocks Master Review
 
 ## Never Approve Without Verification
 - NEVER approve without actually running the project's test command
@@ -15026,7 +15051,6 @@ var REVIEWER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
 - NEVER make architecture changes \u2192 Escalate to ${AGENT_NAMES.COMMANDER}
 - NEVER implement fixes yourself \u2192 Send back to ${AGENT_NAMES.WORKER} with clear feedback
 
-
 ## Adaptive Verification
 - READ ${PATHS.CONTEXT} to know the correct build/test commands
 - COMPARE with existing code patterns for consistency
@@ -17997,6 +18021,17 @@ var createDelegateTaskTool = (manager, client) => tool({
     const parentTask = allTasks.find((t) => t.sessionID === ctx.sessionID);
     const parentDepth = parentTask?.depth ?? 0;
     log(`${PARALLEL_LOG.DELEGATE_TASK} execute() called`, { agent, description, background, resume, mode, groupID, parentSession: ctx.sessionID, depth: parentDepth });
+    if (parentDepth >= PARALLEL_TASK.TERMINAL_DEPTH) {
+      log(`${PARALLEL_LOG.DELEGATE_TASK} Terminal node guard triggered`, { parentDepth, TERMINAL_DEPTH: PARALLEL_TASK.TERMINAL_DEPTH });
+      return `${OUTPUT_LABEL.ERROR} Delegation blocked: You are a terminal node (depth ${parentDepth}).
+
+**${AGENT_NAMES.WORKER} and ${AGENT_NAMES.REVIEWER} cannot spawn sub-agents.** This prevents infinite recursion.
+
+If your task is too complex, please:
+1. Report back to ${AGENT_NAMES.COMMANDER} with specific blockers
+2. Request task decomposition at the ${AGENT_NAMES.PLANNER} level
+3. Complete your assigned file directly without delegation`;
+    }
     const sessionClient = client;
     if (background === void 0) {
       return `${OUTPUT_LABEL.ERROR} 'background' parameter is REQUIRED.`;

package/dist/shared/task/constants/parallel-task.d.ts

@@ -9,7 +9,24 @@ export declare const TASK_MODE: {
 export declare const PARALLEL_TASK: {
     readonly TTL_MS: number;
     readonly CLEANUP_DELAY_MS: number;
-    readonly MAX_DEPTH: 8;
+    /**
+     * Maximum recursion depth for parallel task spawning
+     *
+     * Depth hierarchy:
+     * - Depth 0: Commander (can spawn Planner/Worker/Reviewer)
+     * - Depth 1: Planner (can spawn Worker)
+     * - Depth 2: Worker/Reviewer (TERMINAL - cannot spawn sub-agents)
+     * - Depth 3: BLOCKED
+     *
+     * This prevents infinite recursion and ensures Master Reviewer
+     * doesn't wait indefinitely for deeply nested sub-tasks.
+     */
+    readonly MAX_DEPTH: 3;
+    /**
+     * Terminal node depth - agents at this depth cannot spawn sub-agents.
+     * Worker and Reviewer are terminal nodes by design.
+     */
+    readonly TERMINAL_DEPTH: 2;
     readonly DEFAULT_CONCURRENCY: 10;
     readonly MAX_CONCURRENCY: 50;
     readonly SYNC_TIMEOUT_MS: number;

package/package.json

@@ -2,7 +2,7 @@
   "name": "opencode-orchestrator",
   "displayName": "OpenCode Orchestrator",
   "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {