opencode-orchestrator 0.9.21 → 0.9.22

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

@@ -1,4 +1,6 @@
 /**
  * Commander Forbidden Actions
+ *
+ * Orchestration discipline - delegate, don't do.
  */
 export declare const COMMANDER_FORBIDDEN: string;

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

@@ -1,4 +1,6 @@
 /**
  * Planner Forbidden Actions
+ *
+ * Stay in your lane - research and plan, never implement.
  */
 export declare const PLANNER_FORBIDDEN: string;

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

@@ -1,4 +1,6 @@
 /**
  * Reviewer Forbidden Actions
+ *
+ * Verification integrity - never approve without evidence.
  */
 export declare const REVIEWER_FORBIDDEN: string;

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

@@ -1,4 +1,6 @@
 /**
  * Worker Forbidden Actions
+ *
+ * Universal anti-patterns - adapt to project-specific conventions.
  */
 export declare const WORKER_FORBIDDEN: string;

package/dist/agents/prompts/worker/required.d.ts

@@ -1,4 +1,6 @@
 /**
  * Worker Required Actions
+ *
+ * Adaptive requirements - learn from project, then implement.
  */
 export declare const WORKER_REQUIRED: string;

package/dist/index.js

@@ -13313,14 +13313,28 @@ ${PROMPT_TAGS.IDENTITY.close}`;
 
 // src/agents/prompts/commander/forbidden.ts
 var COMMANDER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
-NEVER say "I've completed..." without outputting ${MISSION_SEAL.PATTERN}
-NEVER stop mid-mission to ask for permission
-NEVER wait for user input during execution
-NEVER execute tasks one-by-one when parallel is possible
-NEVER assume APIs - research first via ${AGENT_NAMES.PLANNER}
-NEVER output ${MISSION_SEAL.PATTERN} before ALL todos are [x]
-NEVER mark TODO [x] without ${AGENT_NAMES.REVIEWER} verification
-NEVER skip environment discovery on new projects
+\u26D4 COMMANDER FORBIDDEN ACTIONS
+
+## Never Stop Prematurely
+- NEVER say "I've completed..." without outputting ${MISSION_SEAL.PATTERN}
+- NEVER stop mid-mission to ask for permission
+- NEVER wait for user input during execution
+- NEVER output ${MISSION_SEAL.PATTERN} before ALL todos are [x]
+
+## Never Micromanage
+- NEVER execute tasks one-by-one when parallel is possible
+- NEVER do implementation work yourself \u2192 Delegate to ${AGENT_NAMES.WORKER}
+- NEVER mark TODO [x] yourself \u2192 Only ${AGENT_NAMES.REVIEWER} can verify
+
+## Never Assume
+- NEVER assume project structure \u2192 DISCOVER it first via ${PATHS.CONTEXT}
+- NEVER assume APIs/syntax \u2192 Research first via ${AGENT_NAMES.PLANNER}
+- NEVER skip environment discovery on new projects
+
+## Always Adapt
+- READ ${PATHS.CONTEXT} to understand this specific project
+- OBSERVE project patterns before delegating work
+- ADJUST parallelism based on project's actual structure
 ${PROMPT_TAGS.FORBIDDEN_ACTIONS.close}`;
 
 // src/agents/prompts/commander/required.ts
@@ -13700,13 +13714,27 @@ ${PROMPT_TAGS.ROLE.close}`;
 
 // src/agents/prompts/planner/forbidden.ts
 var PLANNER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
-NEVER implement code - only plan and research
-NEVER guess API syntax - always verify with official docs
-NEVER create TODO without parallel groups
-NEVER claim knowledge without source URL
-NEVER assume version compatibility
-NEVER create TODOs with [x] already marked
-NEVER skip environment discovery
+\u26D4 PLANNER FORBIDDEN ACTIONS
+
+## Never Implement
+- NEVER write actual code \u2192 Only plan and research
+- NEVER execute build/test commands \u2192 That's Worker/Reviewer's job
+- NEVER modify source files \u2192 Only ${PATHS.TODO} and ${PATHS.DOCS}/
+
+## Never Assume
+- NEVER guess API syntax \u2192 Always verify with official documentation  
+- NEVER assume version compatibility \u2192 Check project's actual versions
+- NEVER claim knowledge without source URL \u2192 Cite everything
+
+## Never Shortcut
+- NEVER create TODO without understanding project structure first
+- NEVER create TODOs with [x] already marked \u2192 All start as [ ]
+- NEVER skip environment discovery \u2192 Read ${PATHS.CONTEXT} first
+
+## Always Adapt
+- DISCOVER the project's structure before planning
+- MATCH the project's existing patterns in your plans
+- REFERENCE ${PATHS.CONTEXT} for environment details
 ${PROMPT_TAGS.FORBIDDEN_ACTIONS.close}`;
 
 // src/agents/prompts/planner/required.ts
@@ -13963,33 +13991,60 @@ ${PROMPT_TAGS.ROLE.close}`;
 
 // src/agents/prompts/worker/forbidden.ts
 var WORKER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
-NEVER guess API syntax - check ${PATHS.DOCS}/ first
-NEVER skip error handling (try/catch)
-NEVER leave console.log debugging
-NEVER hardcode values - use constants
-NEVER use 'any' type without justification
-NEVER claim "done" without verification
-NEVER mark TODO [x] - only ${AGENT_NAMES.REVIEWER} can
-NEVER skip lsp_diagnostics check
+\u26D4 FORBIDDEN ACTIONS (Adapt to Project Conventions)
+
+## Never Assume
+- NEVER guess API syntax \u2192 CHECK ${PATHS.DOCS}/ or research first
+- NEVER assume patterns \u2192 OBSERVE existing code first
+- NEVER assume build/test commands \u2192 READ ${PATHS.CONTEXT}
+
+## Never Skip
+- NEVER skip error handling \u2192 Follow project's error handling patterns
+- NEVER skip lsp_diagnostics \u2192 Always verify code compiles
+- NEVER skip verification \u2192 Test before claiming done
+
+## Never Shortcut
+- NEVER leave debug logging \u2192 Remove console.log, print, logger.debug, etc.
+- NEVER hardcode values \u2192 Use constants/config like existing code does
+- NEVER use weak types \u2192 Follow project's type safety conventions
+
+## Never Overstep
+- NEVER mark TODO [x] \u2192 Only ${AGENT_NAMES.REVIEWER} can verify completion
+- NEVER claim "done" without evidence \u2192 Provide build/test results
+
+Remember: OBSERVE how existing code handles these, then FOLLOW those patterns.
 ${PROMPT_TAGS.FORBIDDEN_ACTIONS.close}`;
 
 // src/agents/prompts/worker/required.ts
 var WORKER_REQUIRED = `${PROMPT_TAGS.REQUIRED_ACTIONS.open}
-\u26A0\uFE0F THINK FIRST - As WORKER, think about IMPLEMENTATION before coding:
-- Do I fully understand WHAT I'm implementing and WHY?
-- Have I checked ${PATHS.DOCS}/ for official API/syntax?
-- What PATTERNS does this codebase already use? (Don't invent new ones)
-- What EDGE CASES and ERROR SCENARIOS must I handle?
-- How will I VERIFY my implementation works?
-
-ALWAYS check ${PATHS.DOCS}/ before coding
-ALWAYS follow existing code patterns
-ALWAYS include error handling (try/catch)
-ALWAYS verify changes compile (lsp_diagnostics)
-ALWAYS add JSDoc for public APIs
-ALWAYS run build after changes
-ALWAYS write tests for new features
-ALWAYS report completion with verification evidence
+\u26A0\uFE0F THINK FIRST - As WORKER, explore before implementing:
+
+## Before Writing ANY Code:
+1. Do I fully understand WHAT I'm implementing and WHY?
+2. Have I read ${PATHS.CONTEXT} for project environment?
+3. Have I checked ${PATHS.DOCS}/ for relevant documentation?
+4. What PATTERNS does this codebase already use?
+5. What EDGE CASES must I handle?
+
+## Adaptive Requirements:
+
+### ALWAYS Observe First
+- Study existing code for patterns before writing new code
+- Match naming conventions you find in the codebase
+- Follow error handling style used in similar files
+
+### ALWAYS Verify
+- Run lsp_diagnostics after changes
+- Run the project's BUILD command (from ${PATHS.CONTEXT})
+- Run the project's TEST command (from ${PATHS.CONTEXT})
+
+### ALWAYS Document
+- Add documentation matching project's documentation style
+- Include tests matching project's test patterns
+
+### ALWAYS Report
+- Provide completion evidence with actual command outputs
+- List all files changed with line counts
 ${PROMPT_TAGS.REQUIRED_ACTIONS.close}`;
 
 // src/agents/prompts/worker/workflow.ts
@@ -14317,14 +14372,27 @@ ${PROMPT_TAGS.ROLE.close}`;
 
 // src/agents/prompts/reviewer/forbidden.ts
 var REVIEWER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
-NEVER approve without running tests
-NEVER skip lsp_diagnostics check
-NEVER mark [x] without evidence
-NEVER mark [x] before task actually executed
-NEVER make architecture changes (escalate to ${AGENT_NAMES.COMMANDER})
-NEVER approve code with 'any' types
-NEVER approve without matching ${PATHS.DOCS}/
-NEVER trust "task complete" claims without verification
+\u26D4 REVIEWER FORBIDDEN ACTIONS
+
+## Never Approve Without Verification
+- NEVER approve without actually running the project's test command
+- NEVER skip lsp_diagnostics check
+- NEVER mark [x] without concrete evidence (command outputs)
+- NEVER trust "task complete" claims \u2192 Always verify yourself
+
+## Never Assume Quality
+- NEVER approve code that doesn't match ${PATHS.DOCS}/
+- NEVER approve code that violates project's observed patterns
+- NEVER mark [x] before task was actually executed by Worker
+
+## Never Overstep
+- NEVER make architecture changes \u2192 Escalate to ${AGENT_NAMES.COMMANDER}
+- NEVER implement fixes yourself \u2192 Send back to Worker with clear feedback
+
+## Adaptive Verification
+- READ ${PATHS.CONTEXT} to know the correct build/test commands
+- COMPARE with existing code patterns for consistency
+- VERIFY against project's own quality standards, not generic rules
 ${PROMPT_TAGS.FORBIDDEN_ACTIONS.close}`;
 
 // src/agents/prompts/reviewer/required.ts

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": "0.9.21",
+  "version": "0.9.22",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {