opencode-orchestrator 1.0.30 → 1.0.31

package/README.md

@@ -69,10 +69,6 @@ MSVP is a structured verification process that decouples implementation from qua
            │     COMMANDER     │ (Orchestration context)
            └─────────┬─────────┘
                      │
-    ┌────────────────▼────────────────┐
-    │  Phase 0: Parallel Discovery    │ (Structure, Tech Stack, Docs, Infra)
-    └────────────────┬────────────────┘
-                     │
            ┌─────────▼─────────┐
            │      PLANNER      │ (Create Hierarchical Plan)
            └─────────┬─────────┘

package/dist/index.js

@@ -907,46 +907,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 +936,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 +13424,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 +13948,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.
@@ -15001,9 +15000,9 @@ ${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
@@ -15235,12 +15234,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 +15303,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}`;
 

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/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.31",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {