opencode-orchestrator 1.0.33 → 1.0.35

package/README.md

@@ -23,50 +23,17 @@ In an OpenCode environment:
 
 ## Overview
 
-OpenCode Orchestrator is a framework designed to manage complex software engineering tasks through parallel multi-agent execution. It extends the capabilities of standard AI agents by introducing a hierarchical delegation model and a multi-stage verification pipeline.
-
-### Key Characteristics
-*   **Parallel Execution**: Manages multiple concurrent agent sessions to accelerate development.
-*   **Hierarchical Delegation**: Supports recursive task decomposition (Fractal Spawning) for complex requirements.
-*   **Integrated Verification**: Employs a multi-stage pipeline (Unit & Integration) to ensure code quality.
-*   **Persistent State**: Uses structured logging to maintain state and recover from interruptions.
-
----
-
-## Core Philosophy: Adaptive Engineering
-
-The orchestrator follows an **Explore → Learn → Adapt → Act** cycle to ensure agents remain grounded in the project's specific context.
-
-*   **Explore**: Systematically discover the project structure, tech stack, and documentation.
-*   **Learn**: Extract existing patterns, naming conventions, and architectural decisions from the codebase.
-*   **Adapt**: Adjust implementation strategies and verification parameters based on learned context.
-*   **Act**: Execute tasks through parallel delegation with evidence-based verification.
-
----
-
-## 🏗️ Architecture
-
-The system is built upon two core mechanisms that handle scaling and quality control.
-
-### HPFA (Hyper-Parallel Fractal Architecture)
-HPFA is a parallel execution model that enables task decomposition at scale.
-*   **Managed Concurrency**: Orchestrates up to 50 parallel agent sessions simultaneously.
-*   **Recursive Scaling**: Allows "Worker" agents to spawn sub-workers for modular tasks, ensuring deep architectural coverage.
-
-### MSVP (Multi-Stage Verification Pipeline)
-MSVP is a structured verification process that decouples implementation from quality assurance.
-*   **Stage 1 (Unit Verification)**: Reviewers validate individual module changes and run local tests immediately after implementation.
-*   **Stage 2 (Integration Review)**: A master reviewer verifies cross-module consistency and system integrity after all individual units are completed.
+OpenCode Orchestrator manages complex software tasks through **parallel multi-agent execution**. Commander orchestrates Workers and Reviewers to implement and verify code concurrently.
 
 ---
 
-## 📊 Workflow Diagram
+## 📊 Workflow
 
 ```text
               [User Task Input]
                      │
            ┌─────────▼─────────┐
-           │     COMMANDER     │  (Orchestration & Discovery)
+           │     COMMANDER     │  (Orchestration)
            └─────────┬─────────┘
                      │
            ┌─────────▼─────────┐
@@ -74,52 +41,51 @@ MSVP is a structured verification process that decouples implementation from qua
            └─────────┬─────────┘
                      │
     ┌────────────────▼────────────────┐
-    │     COMMANDER: Parallel Launch  │
+    │   COMMANDER: Parallel Workers   │
     └──────┬─────────┬─────────┬──────┘
            │         │         │
     ┌──────▼──┐ ┌────▼───┐ ┌───▼────┐
-    │ WORKER A│ │ WORKER B│ │ WORKER C│  (Implementation)
-    └────┬────┘ └────┬───┘ └────┬────┘
-         │           │          │
-    ┌────▼────┐ ┌────▼───┐ ┌────▼────┐
-    │REVIEWER │ │REVIEWER │ │REVIEWER │  (Unit Verification)
-    └────┬────┘ └────┬───┘ └────┬────┘
-         │           │          │
-    ═════▼═══════════▼══════════▼══════
-    │          SYNC BARRIER           │
-    ════════════════╤══════════════════
-                    │
-          ┌─────────▼─────────┐
-          │  MASTER REVIEWER  │  (E2E Verification)
-          └─────────┬─────────┘
-                    │
-          ┌─────────▼─────────┐
-          │  Mission Sealed?  │
-          └─────────┬─────────┘
-               No ↙   ↘ Yes
-            [Loop]   [Complete]
+    │ WORKER  │ │ WORKER │ │ WORKER │
+    └──────┬──┘ └────┬───┘ └────┬────┘
+           │         │          │
+    ╔══════▼═════════▼══════════▼══════╗
+    ║   COMMANDER: Parallel Reviewers  ║
+    ╚══════╤═════════╤══════════╤══════╝
+           │         │          │
+    ┌──────▼──┐ ┌────▼───┐ ┌────▼────┐
+    │REVIEWER │ │REVIEWER │ │REVIEWER │
+    └──────┬──┘ └────┬───┘ └────┬────┘
+           │         │          │
+          ═▼═════════▼══════════▼═
+          │     SYNC BARRIER     │
+          ═══════════╤═══════════
+                     │
+           ┌─────────▼─────────┐
+           │  MASTER REVIEWER  │  (E2E Verification)
+           └─────────┬─────────┘
+                     │
+                [MISSION SEALED]
 ```
 
 ---
 
-## 🚀 System Roles
+## 🚀 Agents
 
-| Role | Responsibility | Key Actions |
-|:-----|:---------------|:------------|
-| **Commander** | Mission Control | Task assignment, conflict resolution, global synchronization |
-| **Planner** | Architecture | Environment analysis, dependency mapping, TODO generation |
-| **Worker** | Implementation | Code writing, file modification, unit test creation |
-| **Reviewer** | Quality Control| Static analysis, build verification, integration testing |
+| Agent | Role |
+|:------|:-----|
+| **Commander** | Orchestrates all agents, manages task flow |
+| **Planner** | Creates TODO.md with task breakdown |
+| **Worker** | Implements features, writes tests |
+| **Reviewer** | Validates code, runs verification |
 
 ---
 
-## 🛠️ Features
+## ✨ Key Features
 
-*   **Concurrent Task Management**: Efficiently handles up to 50 background agent sessions.
-*   **Automated Context Synthesis**: Parallel scouters gather environment intelligence (Structure, Stack, Docs) instantly.
-*   **Synchronized Verification**: Ensures all distributed tasks pass Stage 1 review before final integration.
-*   **Fault Tolerance**: Automatically resumes progress from checkpoints in case of tool or session failure.
-*   **Context Optimization**: Monitors context window limits and performs automated compaction for long sessions.
+- **Parallel Execution**: Up to 50 concurrent agent sessions
+- **Two-Stage Verification**: Unit review → Master review → Seal
+- **Fault Tolerance**: Auto-recovery from failures
+- **Context Optimization**: Manages token limits automatically
 
 ---
 

package/dist/agents/prompts/planner/forbidden.d.ts

@@ -2,5 +2,6 @@
  * Planner Forbidden Actions
  *
  * Stay in your lane - research and plan, never implement.
+ * Planner is a TERMINAL node and cannot spawn other agents.
  */
 export declare const PLANNER_FORBIDDEN: string;

package/dist/index.js

@@ -951,15 +951,16 @@ var PHASE_1_THINK_ANALYSIS = `### 1.1 ANALYZE & SCOPE (INPUT)
 ### 1.4 RISK ASSESSMENT
 - 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. **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.
+var PHASE_5_MSVP = `1. **STAGE 1 (Unit)**: As Workers complete, Commander spawns ${AGENT_NAMES.REVIEWER} for each to verify.
+2. **STAGE 2 (Integration Master)**: Once all Units pass, Commander spawns Master ${AGENT_NAMES.REVIEWER} for cross-module validation.
+3. **E2E VALIDATION**: Master Reviewer runs 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.`;
+var HPFA_RULES = `1. **Commander Parallel Workers**: Commander spawns multiple Workers in parallel for independent modules.
+2. **Commander Parallel Reviewers**: As Workers complete, Commander spawns Unit Reviewers for each.
+3. **Speculative Racing**: Launch multiple strategies in parallel (mode: race) for uncertainty.
+4. **Asynchronous Batching**: Group non-dependent tool calls to trigger host-side parallelism.
+5. **Barrier-Sync Pipeline**: Commander waits at sync barrier before launching Master Reviewer.
+6. **Terminal Nodes**: Workers and Reviewers are TERMINAL - they cannot spawn any sub-agents.`;
 
 // src/shared/prompt/constants/scouts.ts
 var SCOUT_LABEL = "Scout";
@@ -14294,12 +14295,15 @@ ${PROMPT_TAGS.ROLE.close}`;
 var PLANNER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
 **PLANNER FORBIDDEN ACTIONS**
 
-
+## \u26D4 NEVER Spawn or Delegate (CRITICAL)
+- NEVER use \`${TOOL_NAMES.DELEGATE_TASK}\` to spawn agents
+- NEVER use \`${TOOL_NAMES.CALL_AGENT}\` to create sessions
+- You are a TERMINAL node - create plans, don't execute them
+- ${AGENT_NAMES.COMMANDER} is the ONLY agent who can spawn Workers/Reviewers
 
 ## Never Implement
 - NEVER write actual code \u2192 Only plan and research
 - NEVER execute build/test commands \u2192 That's ${AGENT_NAMES.WORKER}/${AGENT_NAMES.REVIEWER}'s job
-
 - NEVER modify source files \u2192 Only ${PATHS.TODO} and ${PATHS.DOCS}/
 
 ## Never Assume

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

@@ -17,9 +17,15 @@ export declare const PHASE_0_DIRECT_DISCOVERY: string;
 export declare const PHASE_1_THINK_ANALYSIS: string;
 /**
  * Phase 5: MSVP (Multi-Stage Verification Pipeline)
+ *
+ * NOTE: Commander spawns both Workers AND Reviewers.
+ * Workers are terminal nodes and do not spawn Reviewers themselves.
  */
 export declare const PHASE_5_MSVP: string;
 /**
  * HPFA (Hyper-Parallel Fractal Architecture) Rules
+ *
+ * All spawning happens at Commander level only.
+ * Workers and Reviewers are terminal nodes and cannot spawn sub-agents.
  */
-export declare const HPFA_RULES = "1. **Fractal Spawning**: Workers spawn sub-workers for complex files/modules.\n2. **Speculative Racing**: Launch multiple strategies in parallel (mode: race) for uncertainty.\n3. **Asynchronous Batching**: Group non-dependent tool calls to trigger host-side parallelism.\n4. **Barrier-Sync Pipeline**: Reviewers start Unit Review (Stage 1) while other workers still run.\n5. **Real-time Brain Sync**: Parallel sessions share public interfaces via shared task logs.";
+export declare const HPFA_RULES = "1. **Commander Parallel Workers**: Commander spawns multiple Workers in parallel for independent modules.\n2. **Commander Parallel Reviewers**: As Workers complete, Commander spawns Unit Reviewers for each.\n3. **Speculative Racing**: Launch multiple strategies in parallel (mode: race) for uncertainty.\n4. **Asynchronous Batching**: Group non-dependent tool calls to trigger host-side parallelism.\n5. **Barrier-Sync Pipeline**: Commander waits at sync barrier before launching Master Reviewer.\n6. **Terminal Nodes**: Workers and Reviewers are TERMINAL - they cannot spawn any sub-agents.";

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