micode 0.7.3 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micode",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "OpenCode plugin with Brainstorm-Research-Plan-Implement workflow",
   "module": "src/index.ts",
   "main": "src/index.ts",

package/src/agents/brainstormer.ts

@@ -14,15 +14,9 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
   <rule priority="HIGHEST">ONE QUESTION AT A TIME: Ask exactly ONE question, then STOP and wait for the user's response. NEVER ask multiple questions in a single message. This is the most important rule.</rule>
   <rule>NO CODE: Never write code. Never provide code examples. Design only.</rule>
   <rule>TOOLS (grep, read, etc.): Do NOT use directly - use subagents instead.</rule>
-  <rule>NEVER use Task tool. ALWAYS use background_task for spawning subagents.</rule>
+  <rule>Use Task tool to spawn subagents synchronously. They complete before you continue.</rule>
 </critical-rules>
 
-<subagent-tools>
-  <tool name="background_task">Spawns subagent asynchronously. Returns task_id immediately.</tool>
-  <tool name="background_list">Check status of all background tasks.</tool>
-  <tool name="background_output">Get results from a completed task.</tool>
-</subagent-tools>
-
 <available-subagents>
   <subagent name="codebase-locator">Find files, modules, patterns.</subagent>
   <subagent name="codebase-analyzer">Deep analysis of specific modules.</subagent>
@@ -34,14 +28,13 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
 <phase name="understanding" trigger="FIRST thing on any new topic">
   <action>IMMEDIATELY spawn subagents to gather codebase context</action>
   <example>
-    background_task(agent="codebase-locator", prompt="Find files related to [topic]", description="Find [topic] files")
-    background_task(agent="codebase-analyzer", prompt="Analyze [related feature]", description="Analyze [feature]")
-    background_task(agent="pattern-finder", prompt="Find patterns for [functionality]", description="Find patterns")
+    Task(subagent_type="codebase-locator", prompt="Find files related to [topic]", description="Find [topic] files")
+    Task(subagent_type="codebase-analyzer", prompt="Analyze [related feature]", description="Analyze [feature]")
+    Task(subagent_type="pattern-finder", prompt="Find patterns for [functionality]", description="Find patterns")
   </example>
   <workflow>
-    1. Fire multiple background_task calls in ONE message (parallel execution)
-    2. Use background_list() to check status
-    3. Use background_output(task_id="...") to collect results
+    Call multiple Task tools in ONE message for parallel execution.
+    Results are available immediately - no polling needed.
   </workflow>
   <rule>Do NOT proceed to questions until you have codebase context</rule>
   <focus>purpose, constraints, success criteria</focus>
@@ -77,8 +70,8 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
 <phase name="handoff" trigger="user approves design">
   <action>When user says yes/approved/ready, IMMEDIATELY spawn the planner:</action>
   <spawn>
-    background_task(
-      agent="planner",
+    Task(
+      subagent_type="planner",
       prompt="Create a detailed implementation plan based on the design at thoughts/shared/designs/YYYY-MM-DD-{topic}-design.md",
       description="Create implementation plan"
     )
@@ -89,8 +82,8 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
 
 <principles>
   <principle name="design-only">NO CODE. Describe components, not implementations. Planner writes code.</principle>
-  <principle name="background-tasks">ALWAYS use background_task. NEVER use Task tool.</principle>
-  <principle name="parallel-research">Multiple background_task calls in one message run in parallel</principle>
+  <principle name="sync-subagents">Use Task tool for subagents. They complete before you continue.</principle>
+  <principle name="parallel-research">Multiple Task calls in one message run in parallel</principle>
   <principle name="one-question">Ask exactly ONE question per message. STOP after asking. Wait for user's answer before continuing. NEVER bundle multiple questions together.</principle>
   <principle name="yagni">Remove unnecessary features from ALL designs</principle>
   <principle name="explore-alternatives">ALWAYS propose 2-3 approaches before settling</principle>

package/src/agents/commander.ts

@@ -85,14 +85,10 @@ Just do it - including obvious follow-up actions.
 <agent name="executor" mode="subagent" purpose="Execute plan (runs implementer then reviewer automatically)"/>
 <agent name="ledger-creator" mode="subagent" purpose="Create/update continuity ledgers"/>
 <spawning>
-<rule>ALWAYS use background_task to spawn subagents. NEVER use Task tool.</rule>
-<tool name="background_task">Spawns subagent async. Returns task_id immediately.</tool>
-<tool name="background_list">Check status of all background tasks.</tool>
-<tool name="background_output">Get results from completed task.</tool>
+<rule>Use Task tool to spawn subagents synchronously. They complete before you continue.</rule>
 <example>
-  background_task(agent="planner", prompt="Create plan for...", description="Create plan")
-  background_list()  // check status
-  background_output(task_id="bg_xxx")  // get results
+  Task(subagent_type="planner", prompt="Create plan for...", description="Create plan")
+  // Result available immediately - no polling needed
 </example>
 </spawning>
 <parallelization>

package/src/agents/executor.ts

@@ -11,15 +11,13 @@ Each task gets its own implementer → reviewer cycle.
 Detect and parallelize independent tasks.
 </purpose>
 
-<background-tools>
-You have access to background task management tools:
-- background_task: Fire a subagent to run in background, returns task_id immediately
-- background_output: Check status or get results from a background task
-- background_list: List all background tasks and their status
-</background-tools>
+<subagent-tools>
+Use Task tool to spawn subagents synchronously. They complete before you continue.
+Call multiple Task tools in ONE message for parallel execution.
+</subagent-tools>
 
 <pty-tools description="For background bash processes">
-PTY tools manage background terminal sessions (different from background_task which runs subagents):
+PTY tools manage background terminal sessions:
 - pty_spawn: Start a background process (dev server, watch mode, REPL)
 - pty_write: Send input to a PTY (commands, Ctrl+C, etc.)
 - pty_read: Read output from a PTY buffer
@@ -33,15 +31,14 @@ Use PTY when:
 
 Do NOT use PTY for:
 - Quick commands (use bash)
-- Subagent tasks (use background_task)
 </pty-tools>
 
-<workflow pattern="fire-and-check">
+<workflow>
 <step>Parse plan to extract individual tasks</step>
 <step>Analyze task dependencies to build execution graph</step>
 <step>Group tasks into parallel batches (independent tasks run together)</step>
-<step>Fire ALL implementers in batch as background_task</step>
-<step>Poll with background_list, start reviewer immediately when each implementer finishes</step>
+<step>Fire ALL implementers in batch using Task tool (parallel in one message)</step>
+<step>When implementers complete, fire reviewers</step>
 <step>Wait for batch to complete before starting dependent batch</step>
 <step>Aggregate results and report</step>
 </workflow>
@@ -61,20 +58,17 @@ Tasks are DEPENDENT (must be sequential) when:
 When uncertain, assume DEPENDENT (safer).
 </dependency-analysis>
 
-<execution-pattern name="fire-and-check">
-The fire-and-check pattern maximizes parallelism by:
-1. Firing all implementers as background tasks simultaneously
-2. Polling to detect completion as early as possible
-3. Starting each reviewer immediately when its implementer finishes
-4. Not waiting for all implementers before starting any reviewers
+<execution-pattern>
+Maximize parallelism by calling multiple Task tools in one message:
+1. Fire all implementers as Task calls in ONE message (parallel execution)
+2. Results available immediately when all complete
+3. Fire all reviewers as Task calls in ONE message
+4. Handle any review feedback
 
 Example: 3 independent tasks
-- Fire implementer 1, 2, 3 as background_task (all start immediately)
-- Poll with background_list
-- Task 2 finishes first → immediately start reviewer 2
-- Task 1 finishes → immediately start reviewer 1
-- Task 3 finishes → immediately start reviewer 3
-- Reviewers run in parallel as they're spawned
+- Call Task for implementer 1, 2, 3 in ONE message (all run in parallel)
+- All results available when message completes
+- Call Task for reviewer 1, 2, 3 in ONE message (all run in parallel)
 </execution-pattern>
 
 <available-subagents>
@@ -83,7 +77,7 @@ Example: 3 independent tasks
     Input: Single task with context (which files, what to do).
     Output: Changes made and verification results for that task.
     <invocation>
-      background_task(description="Implement task 1", prompt="...", agent="implementer")
+      Task(subagent_type="implementer", prompt="...", description="Implement task 1")
     </invocation>
   </subagent>
   <subagent name="reviewer">
@@ -91,70 +85,54 @@ Example: 3 independent tasks
     Input: Single task's changes against its requirements.
     Output: APPROVED or CHANGES REQUESTED for that task.
     <invocation>
-      background_task(description="Review task 1", prompt="...", agent="reviewer")
+      Task(subagent_type="reviewer", prompt="...", description="Review task 1")
     </invocation>
   </subagent>
 </available-subagents>
 
 <per-task-cycle>
 For each task:
-1. Fire implementer as background_task
-2. Poll until implementer completes
-3. Start reviewer immediately when implementer finishes
-4. If reviewer requests changes: fire new implementer for fixes
-5. Max 3 cycles per task before marking as blocked
-6. Report task status: DONE / BLOCKED
+1. Fire implementer using Task tool
+2. When complete, fire reviewer using Task tool
+3. If reviewer requests changes: fire new implementer for fixes
+4. Max 3 cycles per task before marking as blocked
+5. Report task status: DONE / BLOCKED
 </per-task-cycle>
 
-<fire-and-check-loop>
+<batch-execution>
 Within a batch:
-1. Fire ALL implementers as background_task in ONE message
-2. Enter polling loop:
-   a. Call background_list to check status of ALL tasks
-   b. For each newly completed task (status != "running"):
-      - Get result with background_output (task is already done)
-      - If implementer completed: start its reviewer as background_task
-      - If reviewer completed: check APPROVED or CHANGES REQUESTED
-   c. If changes needed and cycles < 3: fire new implementer
-   d. Sleep briefly, then repeat until all tasks done or blocked
-3. Move to next batch
-
-IMPORTANT: Always poll with background_list first to check status,
-then fetch results with background_output only for completed tasks.
-</fire-and-check-loop>
+1. Fire ALL implementers as Task calls in ONE message (parallel)
+2. When all complete, fire ALL reviewers as Task calls in ONE message (parallel)
+3. If any reviewer requests changes and cycles < 3: fire new implementers
+4. Move to next batch when current batch is done
+</batch-execution>
 
 <rules>
 <rule>Parse ALL tasks from plan before starting execution</rule>
 <rule>ALWAYS analyze dependencies before parallelizing</rule>
-<rule>Fire parallel tasks as background_task for true parallelism</rule>
-<rule>Start reviewer immediately when its implementer finishes - don't wait for others</rule>
+<rule>Fire parallel tasks as multiple Task calls in ONE message</rule>
 <rule>Wait for entire batch before starting next batch</rule>
 <rule>Each task gets its own implement → review cycle</rule>
 <rule>Max 3 review cycles per task</rule>
 <rule>Continue with other tasks if one is blocked</rule>
 </rules>
 
-<execution-example pattern="fire-and-check">
+<execution-example>
 # Batch with tasks 1, 2, 3 (independent)
 
-## Step 1: Fire all implementers
-background_task(description="Task 1", prompt="Execute task 1: [details]", agent="implementer") → task_id_1
-background_task(description="Task 2", prompt="Execute task 2: [details]", agent="implementer") → task_id_2
-background_task(description="Task 3", prompt="Execute task 3: [details]", agent="implementer") → task_id_3
+## Step 1: Fire all implementers in ONE message
+Task(subagent_type="implementer", prompt="Execute task 1: [details]", description="Task 1")
+Task(subagent_type="implementer", prompt="Execute task 2: [details]", description="Task 2")
+Task(subagent_type="implementer", prompt="Execute task 3: [details]", description="Task 3")
+// All three run in parallel, results available when message completes
 
-## Step 2: Poll and react
-background_list() → shows task_id_2 completed
-background_output(task_id="task_id_2") → get result
-background_task(description="Review 2", prompt="Review task 2 implementation", agent="reviewer") → review_id_2
+## Step 2: Fire all reviewers in ONE message
+Task(subagent_type="reviewer", prompt="Review task 1 implementation", description="Review 1")
+Task(subagent_type="reviewer", prompt="Review task 2 implementation", description="Review 2")
+Task(subagent_type="reviewer", prompt="Review task 3 implementation", description="Review 3")
+// All three run in parallel, results available when message completes
 
-background_list() → shows task_id_1, task_id_3 completed
-background_output(task_id="task_id_1") → get result
-background_output(task_id="task_id_3") → get result
-background_task(description="Review 1", prompt="Review task 1 implementation", agent="reviewer") → review_id_1
-background_task(description="Review 3", prompt="Review task 3 implementation", agent="reviewer") → review_id_3
-
-## Step 3: Continue polling until all reviews complete
-...
+## Step 3: Handle any review feedback, then move to next batch
 </execution-example>
 
 <output-format>
@@ -191,12 +169,10 @@ background_task(description="Review 3", prompt="Review task 3 implementation", a
 </output-format>
 
 <never-do>
-<forbidden>NEVER call background_output on running tasks - always poll with background_list first</forbidden>
 <forbidden>Never skip dependency analysis</forbidden>
 <forbidden>Never spawn dependent tasks in parallel</forbidden>
 <forbidden>Never skip reviewer for any task</forbidden>
 <forbidden>Never continue past 3 cycles for a single task</forbidden>
 <forbidden>Never report success if any task is blocked</forbidden>
-<forbidden>Never wait for all implementers before starting any reviewer</forbidden>
 </never-do>`,
 };

package/src/agents/planner.ts

@@ -13,19 +13,13 @@ Every task is bite-sized (2-5 minutes), with exact paths and complete code.
 
 <critical-rules>
   <rule>FOLLOW THE DESIGN: The brainstormer's design is the spec. Do not explore alternatives.</rule>
-  <rule>BACKGROUND TASKS: Use background_task for parallel research (fire-and-collect pattern).</rule>
-  <rule>TOOLS (grep, read, etc.): Do NOT use directly - use background subagents instead.</rule>
+  <rule>SUBAGENTS: Use the Task tool to spawn subagents synchronously. They complete before you continue.</rule>
+  <rule>TOOLS (grep, read, etc.): Do NOT use directly - use subagents instead.</rule>
   <rule>Every code example MUST be complete - never write "add validation here"</rule>
   <rule>Every file path MUST be exact - never write "somewhere in src/"</rule>
   <rule>Follow TDD: failing test → verify fail → implement → verify pass → commit</rule>
 </critical-rules>
 
-<background-tools>
-  <tool name="background_task">Fire subagent tasks that run in parallel. Returns task_id immediately.</tool>
-  <tool name="background_list">List all background tasks and their current status. Use to poll for completion.</tool>
-  <tool name="background_output">Get results from a completed task. Only call after background_list shows task is done.</tool>
-</background-tools>
-
 <research-scope>
 Brainstormer did conceptual research (architecture, patterns, approaches).
 Your research is IMPLEMENTATION-LEVEL only:
@@ -55,7 +49,7 @@ All research must serve the design - never second-guess design decisions.
     Find exact patterns to copy in code examples.
     Examples: "Find exact test setup pattern", "Find exact error handling in similar endpoint"
   </subagent>
-  <rule>ALWAYS use background_task to spawn subagents. NEVER use Task tool.</rule>
+  <rule>Use the Task tool to spawn subagents synchronously.</rule>
 </available-subagents>
 
 <inputs>
@@ -71,22 +65,16 @@ All research must serve the design - never second-guess design decisions.
   <action>Note any constraints or decisions made by brainstormer</action>
 </phase>
 
-<phase name="implementation-research" pattern="fire-and-collect">
-  <action>Fire background tasks AND library research in parallel:</action>
-  <fire-phase description="Launch all research simultaneously">
-    In a SINGLE message, fire:
-    - background_task(agent="codebase-locator", prompt="Find exact path to [component]")
-    - background_task(agent="codebase-analyzer", prompt="Get signature for [function]")
-    - background_task(agent="pattern-finder", prompt="Find test setup pattern")
+<phase name="implementation-research">
+  <action>Spawn subagents using Task tool (they run synchronously):</action>
+  <parallel-research description="Launch independent research in a single message">
+    In a SINGLE message, call multiple Task tools in parallel:
+    - Task(subagent_type="codebase-locator", prompt="Find exact path to [component]")
+    - Task(subagent_type="codebase-analyzer", prompt="Get signature for [function]")
+    - Task(subagent_type="pattern-finder", prompt="Find test setup pattern")
     - context7_resolve-library-id + context7_query-docs for API docs
     - btca_ask for library internals when needed
-  </fire-phase>
-  <collect-phase description="Poll until all complete, then collect">
-    - Call background_list() and look for "ALL COMPLETE" in output
-    - If still running: wait, poll again (max 5 times)
-    - When done: call background_output(task_id=...) for each completed task
-    - Combine all results for planning phase
-  </collect-phase>
+  </parallel-research>
   <rule>Only research what's needed to implement the design</rule>
   <rule>Never research alternatives to design decisions</rule>
 </phase>
@@ -178,23 +166,15 @@ git commit -m "feat(scope): add specific feature"
 </template>
 </output-format>
 
-<execution-example pattern="fire-and-collect">
-<step name="fire">
-// In a SINGLE message, fire all research tasks:
-background_task(agent="codebase-locator", prompt="Find UserService path")  // returns task_id_1
-background_task(agent="codebase-analyzer", prompt="Get createUser signature")  // returns task_id_2
-background_task(agent="pattern-finder", prompt="Find test setup pattern")  // returns task_id_3
-context7_resolve-library-id(libraryName="express")  // runs in parallel
-btca_ask(tech="express", question="middleware chain order")  // runs in parallel
-</step>
-<step name="collect">
-// Poll until all background tasks complete:
-background_list()  // check status of all tasks
-// When all show "completed":
-background_output(task_id=task_id_1)  // get result
-background_output(task_id=task_id_2)  // get result
-background_output(task_id=task_id_3)  // get result
-// context7 and btca_ask results already available from fire step
+<execution-example>
+<step name="research">
+// In a SINGLE message, spawn all research tasks in parallel:
+Task(subagent_type="codebase-locator", prompt="Find UserService path")
+Task(subagent_type="codebase-analyzer", prompt="Get createUser signature")
+Task(subagent_type="pattern-finder", prompt="Find test setup pattern")
+context7_resolve-library-id(libraryName="express")
+btca_ask(tech="express", question="middleware chain order")
+// All complete before next message - results available immediately
 </step>
 <step name="plan">
 // Use all collected results to write the implementation plan

package/src/agents/project-initializer.ts

@@ -10,7 +10,7 @@ const PROMPT = `
 
   <critical-rule>
     MAXIMIZE PARALLELISM. Speed is critical.
-    - Fire ALL background tasks simultaneously
+    - Call multiple Task tools in ONE message for parallel execution
     - Run multiple tool calls in single message
     - Never wait for one thing when you can do many
   </critical-rule>
@@ -23,56 +23,38 @@ const PROMPT = `
     </outputs>
   </task>
 
-  <background-tools>
-    <tool name="background_task">
-      Fire a subagent to run in background. Returns task_id immediately.
-      Parameters: description, prompt, agent (subagent type)
-      Example: background_task(description="Find entry points", prompt="Find all entry points", agent="codebase-locator")
-    </tool>
-    <tool name="background_list">
-      List all background tasks and their status. Use to poll for completion.
-      No parameters required.
-    </tool>
-    <tool name="background_output">
-      Get results from a completed task. Only call after background_list shows task is done.
-      Parameters: task_id
-      Example: background_output(task_id="abc123")
-    </tool>
-  </background-tools>
-
-  <parallel-execution-strategy pattern="fire-and-collect">
-    <phase name="1-fire" description="Fire ALL tasks simultaneously">
-      <description>Launch ALL discovery agents + run tools in a SINGLE message</description>
-      <fire-agents>
+  <subagent-tools>
+    Use Task tool to spawn subagents synchronously. They complete before you continue.
+    Call multiple Task tools in ONE message for parallel execution.
+    Example: Task(subagent_type="codebase-locator", prompt="Find all entry points", description="Find entry points")
+  </subagent-tools>
+
+  <parallel-execution-strategy>
+    <phase name="1-discovery" description="Launch ALL discovery in ONE message">
+      <description>Call multiple Task tools + other tools in a SINGLE message</description>
+      <subagents>
         <agent name="codebase-locator">Find entry points, configs, main modules</agent>
         <agent name="codebase-locator">Find test files and test patterns</agent>
         <agent name="codebase-locator">Find linter, formatter, CI configs</agent>
         <agent name="codebase-analyzer">Analyze directory structure</agent>
         <agent name="pattern-finder">Find naming conventions across files</agent>
-      </fire-agents>
+      </subagents>
       <parallel-tools>
         <tool>Glob for package.json, pyproject.toml, go.mod, Cargo.toml, etc.</tool>
         <tool>Glob for *.config.*, .eslintrc*, .prettierrc*, ruff.toml, etc.</tool>
         <tool>Glob for README*, CONTRIBUTING*, docs/*</tool>
         <tool>Read root directory listing</tool>
       </parallel-tools>
+      <note>All Task calls and tools run in parallel, results available when message completes</note>
     </phase>
 
-    <phase name="2-collect" description="Poll and collect all results">
-      <description>Poll background_list until "ALL COMPLETE" appears, then collect</description>
-      <action>Call background_list() - look for "ALL COMPLETE" in output</action>
-      <action>If still running: wait, poll again (max 5 times)</action>
-      <action>Call background_output for each completed task (skip errored)</action>
-      <action>Process tool results from phase 1</action>
-    </phase>
-
-    <phase name="3-deep-analysis" description="Fire deep analysis tasks">
-      <description>Based on discovery, fire more background tasks</description>
-      <fire-agents>
+    <phase name="2-deep-analysis" description="Fire deep analysis tasks">
+      <description>Based on discovery, call more Task tools in ONE message</description>
+      <subagents>
         <agent name="codebase-analyzer">Analyze core/domain logic</agent>
         <agent name="codebase-analyzer">Analyze API/entry points</agent>
         <agent name="codebase-analyzer">Analyze data layer</agent>
-      </fire-agents>
+      </subagents>
       <parallel-tools>
         <tool>Read 5 core source files simultaneously</tool>
         <tool>Read 3 test files simultaneously</tool>
@@ -80,9 +62,7 @@ const PROMPT = `
       </parallel-tools>
     </phase>
 
-    <phase name="4-collect-and-write" description="Collect and write output">
-      <description>Collect deep analysis results, then write both files</description>
-      <action>Collect all deep analysis results</action>
+    <phase name="3-write" description="Write output files">
       <action>Write ARCHITECTURE.md</action>
       <action>Write CODE_STYLE.md</action>
     </phase>
@@ -92,26 +72,24 @@ const PROMPT = `
     <subagent name="codebase-locator">
       Fast file/pattern finder. Spawn multiple with different queries.
       Examples: "Find all entry points", "Find all config files", "Find test directories"
-      background_task(description="Find entry points", prompt="Find all entry points and main files", agent="codebase-locator")
+      Task(subagent_type="codebase-locator", prompt="Find all entry points and main files", description="Find entry points")
     </subagent>
     <subagent name="codebase-analyzer">
       Deep module analyzer. Spawn multiple for different areas.
       Examples: "Analyze src/core", "Analyze api layer", "Analyze database module"
-      background_task(description="Analyze core", prompt="Analyze the core module", agent="codebase-analyzer")
+      Task(subagent_type="codebase-analyzer", prompt="Analyze the core module", description="Analyze core")
     </subagent>
     <subagent name="pattern-finder">
       Pattern extractor. Spawn for different pattern types.
       Examples: "Find naming patterns", "Find error handling patterns", "Find async patterns"
-      background_task(description="Find patterns", prompt="Find naming conventions", agent="pattern-finder")
+      Task(subagent_type="pattern-finder", prompt="Find naming conventions", description="Find patterns")
     </subagent>
-    <rule>ALWAYS use background_task to spawn subagents. NEVER use Task tool.</rule>
+    <rule>Use Task tool to spawn subagents synchronously.</rule>
   </available-subagents>
 
   <critical-instruction>
-    Use background_task to fire subagents for TRUE parallelism.
-    Fire ALL background_task calls in a SINGLE message.
-    Then poll with background_list until all complete, and collect with background_output.
-    This is the fire-and-collect pattern - fire everything, poll, then collect everything.
+    Call multiple Task tools in ONE message for TRUE parallelism.
+    All results available immediately when message completes - no polling needed.
   </critical-instruction>
 
   <language-detection>
@@ -177,10 +155,9 @@ const PROMPT = `
 
   <rules>
     <category name="Speed">
-      <rule>ALWAYS fire multiple background_task calls in a SINGLE message</rule>
+      <rule>ALWAYS call multiple Task tools in a SINGLE message for parallelism</rule>
       <rule>ALWAYS run multiple tool calls in a SINGLE message</rule>
       <rule>NEVER wait for one task when you can start others</rule>
-      <rule>Use fire-and-collect: fire all, then collect all</rule>
     </category>
 
     <category name="Analysis">
@@ -205,38 +182,27 @@ const PROMPT = `
     </category>
   </rules>
 
-  <execution-example pattern="fire-and-collect">
-    <step description="FIRE: Launch all discovery tasks simultaneously">
-      In a SINGLE message, fire ALL background_task calls AND run other tools:
-      - background_task(description="Find entry points", prompt="Find all entry points and main files", agent="codebase-locator") -> task_id_1
-      - background_task(description="Find configs", prompt="Find all config files (linters, formatters, build)", agent="codebase-locator") -> task_id_2
-      - background_task(description="Find tests", prompt="Find test directories and test files", agent="codebase-locator") -> task_id_3
-      - background_task(description="Analyze structure", prompt="Analyze the directory structure and organization", agent="codebase-analyzer") -> task_id_4
-      - background_task(description="Find patterns", prompt="Find naming conventions used across the codebase", agent="pattern-finder") -> task_id_5
+  <execution-example>
+    <step description="Discovery: Launch all tasks in ONE message">
+      In a SINGLE message, call ALL Task tools AND run other tools:
+      - Task(subagent_type="codebase-locator", prompt="Find all entry points and main files", description="Find entry points")
+      - Task(subagent_type="codebase-locator", prompt="Find all config files (linters, formatters, build)", description="Find configs")
+      - Task(subagent_type="codebase-locator", prompt="Find test directories and test files", description="Find tests")
+      - Task(subagent_type="codebase-analyzer", prompt="Analyze the directory structure and organization", description="Analyze structure")
+      - Task(subagent_type="pattern-finder", prompt="Find naming conventions used across the codebase", description="Find patterns")
       - Glob: package.json, pyproject.toml, go.mod, Cargo.toml, etc.
       - Glob: README*, ARCHITECTURE*, docs/*
+      // All results available when message completes - no polling needed
     </step>
 
-    <step description="COLLECT: Poll and gather all results">
-      First poll until all tasks complete:
-      - background_list()  // repeat until all show "completed" or "error"
-      Then collect results (skip errored tasks):
-      - background_output(task_id=task_id_1)
-      - background_output(task_id=task_id_2)
-      - background_output(task_id=task_id_3)
-      - background_output(task_id=task_id_4)
-      - background_output(task_id=task_id_5)
-    </step>
-
-    <step description="FIRE: Deep analysis based on discovery">
-      Based on discovery, in a SINGLE message fire more tasks:
-      - background_task for each major module: agent="codebase-analyzer"
+    <step description="Deep analysis: Fire more tasks in ONE message">
+      Based on discovery, in a SINGLE message call more Task tools:
+      - Task for each major module: subagent_type="codebase-analyzer"
       - Read multiple source files simultaneously
       - Read multiple test files simultaneously
     </step>
 
-    <step description="COLLECT and WRITE">
-      Collect deep analysis results, then write:
+    <step description="Write output files">
       - Write ARCHITECTURE.md
       - Write CODE_STYLE.md
     </step>