opencode-orchestrator 1.0.30 → 1.0.33

package/README.md

@@ -66,42 +66,38 @@ MSVP is a structured verification process that decouples implementation from qua
               [User Task Input]
                      │
            ┌─────────▼─────────┐
-           │     COMMANDER     │ (Orchestration context)
+           │     COMMANDER     │  (Orchestration & Discovery)
            └─────────┬─────────┘
                      │
-    ┌────────────────▼────────────────┐
-    │  Phase 0: Parallel Discovery    │ (Structure, Tech Stack, Docs, Infra)
-    └────────────────┬────────────────┘
-                     │
            ┌─────────▼─────────┐
-           │      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,
@@ -907,46 +923,16 @@ var PHILOSOPHY_TAGLINE = "Explore \u2192 Learn \u2192 Adapt \u2192 Act";
 var PHILOSOPHY_QUOTE = "Like an astronaut landing on unknown planets \u2014 never assume, always discover.";
 var PHILOSOPHY_LEARN_PRINCIPLE = "LEARN = DOCUMENT: What you discover, you record. Your learnings become the team's knowledge.";
 
-// src/shared/prompt/constants/scouts.ts
-var SCOUT_LABEL = "Scout";
-var SCOUT_STRUCTURE = {
-  ID: "STRUCTURE",
-  NAME: `${SCOUT_LABEL}: Structure`,
-  PROMPT: "Analyze the project folder structure. Locate source code (src, lib), tests, and documentation directories. Map out the tree at depth 2-3."
-};
-var SCOUT_STACK = {
-  ID: "STACK",
-  NAME: `${SCOUT_LABEL}: Stack`,
-  PROMPT: "Identify the technology stack. Parse package.json, Cargo.toml, go.mod, or pyproject.toml. Determine build and test commands."
-};
-var SCOUT_DOCS = {
-  ID: "DOCS",
-  NAME: `${SCOUT_LABEL}: Docs`,
-  PROMPT: "Digest the project documentation. Read README.md, CONTRIBUTING.md, and any files in docs/ to understand the core architecture and mission."
-};
-var SCOUT_INFRA = {
-  ID: "INFRA",
-  NAME: `${SCOUT_LABEL}: Infra`,
-  PROMPT: "Detect infrastructure and environment configs. Search for Dockerfiles, CI/CD workflows (.github, .gitlab), and environment variable templates."
-};
-var SCOUT_INTEGRATION = {
-  ID: "INTEGRATION",
-  NAME: `${SCOUT_LABEL}: Integration`,
-  PROMPT: "Read all modified files and their cross-module dependencies in parallel. Map the actual integration surface and identify potential consistency issues."
-};
-
 // src/shared/prompt/constants/mandates.ts
-var PHASE_0_SCOUT_SWARM = `**Mandatory Parallel Initialization**: DO NOT run discovery tools (ls, grep, find) yourself. Your job is to ORCHESTRATE and synthesize results.
+var PHASE_0_DIRECT_DISCOVERY = `**Direct Project Discovery**: Read the project directly to understand it.
 
-1. **LAUNCH Parallel Scouts**: In your VERY FIRST response, you must output ALL of the following \`${TOOL_NAMES.DELEGATE_TASK}\` calls simultaneously (background: true) for:
-   - **[${SCOUT_STRUCTURE.NAME}]**: ${SCOUT_STRUCTURE.PROMPT} (To ${AGENT_NAMES.PLANNER})
-   - **[${SCOUT_STACK.NAME}]**: ${SCOUT_STACK.PROMPT} (To ${AGENT_NAMES.PLANNER})
-   - **[${SCOUT_DOCS.NAME}]**: ${SCOUT_DOCS.PROMPT} (To ${AGENT_NAMES.PLANNER})
-   - **[${SCOUT_INFRA.NAME}]**: ${SCOUT_INFRA.PROMPT} (To ${AGENT_NAMES.PLANNER})
-2. **PARALLEL SYNC**: Use \`${TOOL_NAMES.LIST_TASKS}\` to monitor progress. 
-3. **ONE-PASS INGESTION**: Once all scouts show DONE, use \`${TOOL_NAMES.GET_TASK_RESULT}\` for ALL scouts in a single turn to consolidate findings into \`${PATHS.CONTEXT}\`.
+1. **STRUCTURE**: Run \`ls -la\` and \`find . -maxdepth 2 -type d | head -30\` to map the project layout.
+2. **STACK**: Read config files (package.json, Cargo.toml, go.mod, etc.) to identify build/test commands.
+3. **DOCS**: Read README.md and key documentation to understand the architecture.
+4. **INFRA**: Check for Dockerfile, CI/CD configs, and infrastructure files.
+5. **CONSOLIDATE**: Save findings to \`${PATHS.CONTEXT}\`.
 
-[CRITICAL]: Sequential execution (running tools yourself) is a mission failure. Launch the swarm NOW.`;
+[EFFICIENT]: Direct reading is faster and cheaper than delegating to parallel scouts.`;
 var PHASE_1_THINK_ANALYSIS = `### 1.1 ANALYZE & SCOPE (INPUT)
 - **Review consolidated ${PATHS.CONTEXT} from Phase 0.**
 - Map discovered files to the user's request.
@@ -966,16 +952,43 @@ var PHASE_1_THINK_ANALYSIS = `### 1.1 ANALYZE & SCOPE (INPUT)
 - Identify high-risk parts and fallback plans.
 - If agent fails \u2192 See RECOVERY section.`;
 var PHASE_5_MSVP = `1. **STAGE 1 (Unit)**: Workers MUST trigger ${AGENT_NAMES.REVIEWER} for unit verification immediately upon completion.
-2. **PARALLEL DISCOVERY**: Before Stage 2, launch a swarm of scouts (background: true) using **[${SCOUT_INTEGRATION.NAME}]**: ${SCOUT_INTEGRATION.PROMPT} (To ${AGENT_NAMES.PLANNER}).
-3. **STAGE 2 (Integration Master)**: The Master ${AGENT_NAMES.REVIEWER} ingests all scout findings to validate cross-module consistency.
-4. **E2E VALIDATION**: Run full system tests and build pass check.
-5. **SEAL GATE**: No SEALED output until ${PATHS.TODO} is all [x] and zero issues remain.`;
+2. **STAGE 2 (Integration Master)**: The Master ${AGENT_NAMES.REVIEWER} directly reads all modified files and validates cross-module consistency.
+3. **E2E VALIDATION**: Run full system tests and build pass check.
+4. **SEAL GATE**: No SEALED output until ${PATHS.TODO} is all [x] and zero issues remain.`;
 var HPFA_RULES = `1. **Fractal Spawning**: Workers spawn sub-workers for complex files/modules.
 2. **Speculative Racing**: Launch multiple strategies in parallel (mode: race) for uncertainty.
 3. **Asynchronous Batching**: Group non-dependent tool calls to trigger host-side parallelism.
 4. **Barrier-Sync Pipeline**: Reviewers start Unit Review (Stage 1) while other workers still run.
 5. **Real-time Brain Sync**: Parallel sessions share public interfaces via shared task logs.`;
 
+// src/shared/prompt/constants/scouts.ts
+var SCOUT_LABEL = "Scout";
+var SCOUT_STRUCTURE = {
+  ID: "STRUCTURE",
+  NAME: `${SCOUT_LABEL}: Structure`,
+  PROMPT: "Analyze the project folder structure. Locate source code (src, lib), tests, and documentation directories. Map out the tree at depth 2-3."
+};
+var SCOUT_STACK = {
+  ID: "STACK",
+  NAME: `${SCOUT_LABEL}: Stack`,
+  PROMPT: "Identify the technology stack. Parse package.json, Cargo.toml, go.mod, or pyproject.toml. Determine build and test commands."
+};
+var SCOUT_DOCS = {
+  ID: "DOCS",
+  NAME: `${SCOUT_LABEL}: Docs`,
+  PROMPT: "Digest the project documentation. Read README.md, CONTRIBUTING.md, and any files in docs/ to understand the core architecture and mission."
+};
+var SCOUT_INFRA = {
+  ID: "INFRA",
+  NAME: `${SCOUT_LABEL}: Infra`,
+  PROMPT: "Detect infrastructure and environment configs. Search for Dockerfiles, CI/CD workflows (.github, .gitlab), and environment variable templates."
+};
+var SCOUT_INTEGRATION = {
+  ID: "INTEGRATION",
+  NAME: `${SCOUT_LABEL}: Integration`,
+  PROMPT: "Read all modified files and their cross-module dependencies in parallel. Map the actual integration surface and identify potential consistency issues."
+};
+
 // src/core/agents/consts/task-status.const.ts
 var TASK_STATUS = {
   PENDING: STATUS_LABEL.PENDING,
@@ -13427,11 +13440,13 @@ tool.schema = external_exports;
 var ENVIRONMENT_DISCOVERY = `${PROMPT_TAGS.ENVIRONMENT_DISCOVERY.open}
 **MANDATORY FIRST STEP** - Before any planning or coding:
 
-## \u26A1 Parallel Discovery Strategy
-To maximize cognitive velocity, execute Phase 0 as a **Parallel Discovery Swarm**:
-1. **Delegate** independent scouts (background=true) for Structure, Stack, and Infra discovery.
-2. **Consolidate** all empirical evidence once scouts complete their missions.
-3. **Verify** findings against existing codebase before sealing the initial context.
+## \u26A1 Direct Discovery (Efficient)
+Read the project directly - this is faster and cheaper than delegating to parallel scouts:
+1. **Read** project structure, config files, and documentation directly.
+2. **Document** all findings to \`${PATHS.CONTEXT}\`.
+3. **Verify** findings against existing codebase.
+
+[NOTE]: Direct reading saves tokens and avoids parallel wait overhead.
 
 ## 1. Project Structure Discovery
 Explore the project root to understand its organization:
@@ -13949,8 +13964,8 @@ ${PROMPT_TAGS.TOOLS.close}`;
 
 // src/agents/prompts/commander/execution.ts
 var COMMANDER_EXECUTION = `${PROMPT_TAGS.EXECUTION_STRATEGY.open}
-## ${PHASES.PHASE_0.ID}: ${PHASES.PHASE_0.NAME} (Cognitive Velocity Launch)
-${PHASE_0_SCOUT_SWARM}
+## ${PHASES.PHASE_0.ID}: ${PHASES.PHASE_0.NAME} (Direct Discovery)
+${PHASE_0_DIRECT_DISCOVERY}
 
 ## ${PHASES.PHASE_1.ID}: ${PHASES.PHASE_1.NAME} (Mandatory - Never Skip!)
 **THINK FIRST**: As ${AGENT_NAMES.COMMANDER}, think about ORCHESTRATION and synthesis before action.
@@ -14586,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
@@ -14596,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
@@ -15001,16 +15020,21 @@ ${PHASE_5_MSVP}
 
 ### Role Specialization
 1. **UNIT REVIEW (Stage 1)**: Triggered by Workers. Focus on local file correctness and unit tests.
-2. **MASTER REVIEW (Stage 2)**: Triggered by Commander in Phase 5. Focus on cross-module consistency and system-wide integration using **Parallel Integration Scout** findings.
+2. **MASTER REVIEW (Stage 2)**: Triggered by Commander in Phase 5. Read modified files directly and focus on cross-module consistency and system-wide integration.
 
-[CRITICAL]: As Master Reviewer, you MUST read the results of the Integration Scouts before making a verdict.
+[CRITICAL]: As Master Reviewer, read all modified files directly from ${PATHS.WORK_LOG} before making a verdict.
 ${PROMPT_TAGS.ROLE.close}`;
 
 // src/agents/prompts/reviewer/forbidden.ts
 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
@@ -15027,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
@@ -15235,12 +15258,14 @@ Before running integration tests, all merged files must:
 
 ### Integration Workflow (Master Mode)
 
-#### Step 0: Ingest Parallel Scout Findings
-Read the output of the **[${SCOUT_INTEGRATION.NAME}]** swarm. Locate:
+#### Step 0: Direct File Reading
+Read all modified files directly from ${PATHS.WORK_LOG}. Identify:
 - Cross-module interface changes
 - Shared constant modifications
 - Potential synchronization bottlenecks
 
+[NOTE]: Read directly - no parallel scout overhead, saves tokens.
+
 #### Step 1: Check ${PATHS.TODO} Status
 \`\`\`bash
 cat ${PATHS.TODO}
@@ -15302,7 +15327,7 @@ Write to ${PATHS.INTEGRATION_STATUS}:
 
 **CRITICAL**:
 - E2E only at ${PATHS.TODO} completion time!
-- Use the parallel intelligence from **[${SCOUT_INTEGRATION.NAME}]** to ensure 100% mission integrity.
+- Read modified files directly for maximum efficiency.
 - All ${PATHS.TODO} [x] + no issues = SEALED!
 ${PROMPT_TAGS.INTEGRATION_TESTING.close}`;
 
@@ -17996,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/prompt/constants/index.d.ts

@@ -4,5 +4,5 @@
 export { PROMPT_TAGS, wrapTag } from "./tags.js";
 export { WORK_STATUS } from "./status.js";
 export { PHILOSOPHY_PHASES, PHILOSOPHY_TAGLINE, PHILOSOPHY_QUOTE, PHILOSOPHY_LEARN_PRINCIPLE, EXECUTION_CYCLE, EXECUTION_CYCLE_STEPS, } from "./philosophy.js";
-export { PHASE_0_SCOUT_SWARM, PHASE_1_THINK_ANALYSIS, PHASE_5_MSVP, HPFA_RULES } from "./mandates.js";
+export { PHASE_0_DIRECT_DISCOVERY, PHASE_1_THINK_ANALYSIS, PHASE_5_MSVP, HPFA_RULES } from "./mandates.js";
 export { SCOUT_LABEL, SCOUT_STRUCTURE, SCOUT_STACK, SCOUT_DOCS, SCOUT_INFRA, SCOUT_INTEGRATION } from "./scouts.js";

package/dist/shared/prompt/constants/mandates.d.ts

@@ -1,15 +1,16 @@
 /**
  * Architectural Mandates - Immutable Core Logic
  *
- *
  * These constants define the non-negotiable architectural requirements
  * that ensure the orchestrator operates according to the verified diagram.
+ *
+ * NOTE: Direct reading is preferred over parallel scouts to reduce token costs.
  */
 /**
- * Phase 0: Discovery Swarm Mandate
- * Force parallel execution of scouts to maximize velocity.
+ * Phase 0: Direct Discovery
+ * Read directly - no parallel scout overhead, saves tokens and time.
  */
-export declare const PHASE_0_SCOUT_SWARM: string;
+export declare const PHASE_0_DIRECT_DISCOVERY: string;
 /**
  * Phase 1: THINK (Strategic Mandate)
  */

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.30",
+  "version": "1.0.33",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {