micode 0.7.4 → 0.7.6

package/INSTALL_CLAUDE.md

@@ -159,7 +159,6 @@ Never run this automatically without consent.
 | `ast_grep_search` | AST-aware code search |
 | `ast_grep_replace` | AST-aware code replace |
 | `look_at` | Screenshot analysis |
-| `background_task` | Run tasks in background |
 
 ### Model Override
 

package/README.md

@@ -71,23 +71,12 @@ Maintain context across sessions with structured compaction. Run `/ledger` to cr
 | `look_at` | Extract file structure |
 | `artifact_search` | Search past plans/ledgers |
 | `btca_ask` | Query library source code |
-| `background_task` | Fire subagent in background |
-| `background_list` | List tasks and status |
-| `background_output` | Get task results |
-| `background_cancel` | Cancel task(s) |
 | `pty_spawn` | Start background terminal session |
 | `pty_write` | Send input to PTY |
 | `pty_read` | Read PTY output |
 | `pty_list` | List PTY sessions |
 | `pty_kill` | Terminate PTY |
 
-### Background Tasks vs PTY
-
-| System | Purpose | Use Case |
-|--------|---------|----------|
-| `background_task` | Async AI subagents | Research, implementation, reviews |
-| `pty_spawn` | Async bash processes | Dev servers, watch modes, REPLs |
-
 ## Hooks
 
 - **Think Mode** - Keywords like "think hard" enable 32k token thinking budget

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micode",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "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/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>

package/src/index.ts

@@ -22,9 +22,6 @@ import { createLedgerLoaderHook } from "./hooks/ledger-loader";
 import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
 import { createFileOpsTrackerHook } from "./hooks/file-ops-tracker";
 
-// Background Task System
-import { BackgroundTaskManager, createBackgroundTaskTools } from "./tools/background-task";
-
 // PTY System
 import { PTYManager, createPtyTools } from "./tools/pty";
 
@@ -96,10 +93,6 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
   const artifactAutoIndexHook = createArtifactAutoIndexHook(ctx);
   const fileOpsTrackerHook = createFileOpsTrackerHook(ctx);
 
-  // Background Task System
-  const backgroundTaskManager = new BackgroundTaskManager(ctx);
-  const backgroundTaskTools = createBackgroundTaskTools(backgroundTaskManager);
-
   // PTY System
   const ptyManager = new PTYManager();
   const ptyTools = createPtyTools(ptyManager);
@@ -112,7 +105,6 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       btca_ask,
       look_at,
       artifact_search,
-      ...backgroundTaskTools,
       ...ptyTools,
     },
 
@@ -243,9 +235,6 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       await tokenAwareTruncationHook.event({ event });
       await contextWindowMonitorHook.event({ event });
 
-      // Background task manager event handling
-      backgroundTaskManager.handleEvent(event);
-
       // File ops tracker cleanup
       await fileOpsTrackerHook.event({ event });
     },

package/src/tools/background-task/index.ts

@@ -1,3 +0,0 @@
-export { BackgroundTaskManager } from "./manager";
-export { createBackgroundTaskTools } from "./tools";
-export type { BackgroundTask, BackgroundTaskInput } from "./types";

package/src/tools/background-task/manager.ts

@@ -1,433 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import type {
-  BackgroundTask,
-  BackgroundTaskInput,
-  SessionCreateResponse,
-  SessionStatusResponse,
-  SessionMessagesResponse,
-} from "./types";
-
-const POLL_INTERVAL_MS = 2000;
-const TASK_TTL_MS = 60 * 60 * 1000; // 1 hour
-
-function generateTaskId(): string {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "bg_";
-  for (let i = 0; i < 8; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-
-function formatDuration(start: Date, end?: Date): string {
-  const ms = (end || new Date()).getTime() - start.getTime();
-  const seconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(seconds / 60);
-
-  if (minutes > 0) {
-    return `${minutes}m ${seconds % 60}s`;
-  }
-  return `${seconds}s`;
-}
-
-export class BackgroundTaskManager {
-  private tasks: Map<string, BackgroundTask> = new Map();
-  private notifications: Map<string, BackgroundTask[]> = new Map();
-  private pollingInterval?: ReturnType<typeof setInterval>;
-  private ctx: PluginInput;
-
-  constructor(ctx: PluginInput) {
-    this.ctx = ctx;
-  }
-
-  async launch(input: BackgroundTaskInput): Promise<BackgroundTask> {
-    const taskId = generateTaskId();
-
-    // Create new session for background task
-    const sessionResp = await this.ctx.client.session.create({
-      body: {},
-      query: { directory: this.ctx.directory },
-    });
-
-    const sessionData = sessionResp as SessionCreateResponse;
-    const sessionID = sessionData.data?.id;
-
-    if (!sessionID) {
-      throw new Error("Failed to create background session");
-    }
-
-    const task: BackgroundTask = {
-      id: taskId,
-      sessionID,
-      parentSessionID: input.parentSessionID,
-      parentMessageID: input.parentMessageID,
-      description: input.description,
-      prompt: input.prompt,
-      agent: input.agent,
-      status: "running",
-      startedAt: new Date(),
-      progress: {
-        toolCalls: 0,
-        lastUpdate: new Date(),
-      },
-    };
-
-    this.tasks.set(taskId, task);
-
-    // Fire-and-forget prompt
-    this.ctx.client.session
-      .prompt({
-        path: { id: sessionID },
-        body: {
-          parts: [{ type: "text", text: input.prompt }],
-          agent: input.agent,
-        },
-        query: { directory: this.ctx.directory },
-      })
-      .catch((error) => {
-        console.error(`[background-task] Failed to prompt session ${sessionID}:`, error);
-        task.status = "error";
-        task.error = error instanceof Error ? error.message : String(error);
-        task.completedAt = new Date();
-        this.markForNotification(task);
-      });
-
-    // Start polling if not already
-    this.startPolling();
-
-    return task;
-  }
-
-  async cancel(taskId: string): Promise<boolean> {
-    const task = this.tasks.get(taskId);
-    if (!task || task.status !== "running") {
-      return false;
-    }
-
-    try {
-      // Fire-and-forget abort
-      this.ctx.client.session
-        .abort({
-          path: { id: task.sessionID },
-          query: { directory: this.ctx.directory },
-        })
-        .catch((error) => {
-          console.error(`[background-task] Failed to abort session ${task.sessionID}:`, error);
-        });
-
-      task.status = "cancelled";
-      task.completedAt = new Date();
-      this.markForNotification(task);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async cancelAll(): Promise<number> {
-    let cancelled = 0;
-    for (const task of this.tasks.values()) {
-      if (task.status === "running") {
-        if (await this.cancel(task.id)) {
-          cancelled++;
-        }
-      }
-    }
-    return cancelled;
-  }
-
-  getTask(taskId: string): BackgroundTask | undefined {
-    return this.tasks.get(taskId);
-  }
-
-  findBySession(sessionID: string): BackgroundTask | undefined {
-    for (const task of this.tasks.values()) {
-      if (task.sessionID === sessionID) {
-        return task;
-      }
-    }
-    return undefined;
-  }
-
-  getAllTasks(): BackgroundTask[] {
-    return Array.from(this.tasks.values());
-  }
-
-  /**
-   * Poll all running tasks and update their status.
-   * Called by background_list to ensure fresh status.
-   */
-  async refreshTaskStatus(): Promise<void> {
-    const runningTasks = this.getRunningTasks();
-    if (runningTasks.length === 0) return;
-
-    try {
-      // Get all session statuses in one call
-      const resp = await this.ctx.client.session.status({
-        query: { directory: this.ctx.directory },
-      });
-
-      const statusResp = resp as SessionStatusResponse;
-      const statusMap = statusResp.data || {};
-
-      for (const task of runningTasks) {
-        const sessionStatus = statusMap[task.sessionID];
-        const statusType = sessionStatus?.type;
-
-        // Store last known session status for debugging
-        (task as BackgroundTask & { _sessionStatus?: string })._sessionStatus = statusType;
-
-        if (statusType === "idle" || statusType === undefined) {
-          // Session is idle OR not in status map (likely finished and cleaned up)
-          // Try to get result - if successful, mark as completed
-          const result = await this.fetchTaskResult(task);
-          if (result !== undefined || statusType === "idle") {
-            task.status = "completed";
-            task.completedAt = new Date();
-            task.result = result;
-          }
-          // If result is undefined and statusType is undefined, keep waiting
-          // (might be a timing issue with status propagation)
-        }
-      }
-    } catch (error) {
-      console.error("[background-task] Failed to refresh task status:", error);
-      // Don't mark all tasks as error - they may still be running
-    }
-  }
-
-  getRunningTasks(): BackgroundTask[] {
-    return this.getAllTasks().filter((t) => t.status === "running");
-  }
-
-  async getTaskResult(taskId: string): Promise<string | undefined> {
-    const task = this.tasks.get(taskId);
-    if (!task || task.status === "running") {
-      return undefined;
-    }
-
-    if (task.result) {
-      return task.result;
-    }
-
-    const result = await this.fetchTaskResult(task);
-    if (result !== undefined) {
-      task.result = result;
-    }
-    return result;
-  }
-
-  /**
-   * Fetch result from session messages without checking task status.
-   * Used during polling to check if a session has completed.
-   */
-  private async fetchTaskResult(task: BackgroundTask): Promise<string | undefined> {
-    try {
-      const resp = await this.ctx.client.session.messages({
-        path: { id: task.sessionID },
-        query: { directory: this.ctx.directory },
-      });
-
-      const messagesResp = resp as SessionMessagesResponse;
-      const messages = messagesResp.data || [];
-      const lastAssistant = [...messages].reverse().find((m) => m.info?.role === "assistant");
-
-      if (lastAssistant) {
-        const textParts = lastAssistant.parts?.filter((p) => p.type === "text") || [];
-        return textParts.map((p) => p.text || "").join("\n");
-      }
-    } catch (error) {
-      console.error(`[background-task] Failed to fetch result for task ${task.id}:`, error);
-    }
-
-    return undefined;
-  }
-
-  formatTaskStatus(task: BackgroundTask): string {
-    const duration = formatDuration(task.startedAt, task.completedAt);
-    const status = task.status.toUpperCase();
-
-    let output = `## Task: ${task.description}\n\n`;
-    output += `| Field | Value |\n|-------|-------|\n`;
-    output += `| ID | ${task.id} |\n`;
-    output += `| Status | ${status} |\n`;
-    output += `| Agent | ${task.agent} |\n`;
-    output += `| Duration | ${duration} |\n`;
-
-    if (task.progress) {
-      output += `| Tool Calls | ${task.progress.toolCalls} |\n`;
-      if (task.progress.lastTool) {
-        output += `| Last Tool | ${task.progress.lastTool} |\n`;
-      }
-    }
-
-    if (task.error) {
-      output += `\n### Error\n${task.error}\n`;
-    }
-
-    return output;
-  }
-
-  private startPolling(): void {
-    if (this.pollingInterval) return;
-
-    this.pollingInterval = setInterval(() => {
-      this.pollRunningTasks();
-    }, POLL_INTERVAL_MS);
-  }
-
-  private stopPolling(): void {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-      this.pollingInterval = undefined;
-    }
-  }
-
-  private cleanupOldTasks(): void {
-    const now = Date.now();
-    for (const [taskId, task] of this.tasks) {
-      // Only cleanup completed/cancelled/error tasks
-      if (task.status === "running") continue;
-
-      const completedAt = task.completedAt?.getTime() || 0;
-      if (now - completedAt > TASK_TTL_MS) {
-        this.tasks.delete(taskId);
-      }
-    }
-  }
-
-  private async pollRunningTasks(): Promise<void> {
-    // Cleanup old completed tasks to prevent memory leak
-    this.cleanupOldTasks();
-
-    const runningTasks = this.getRunningTasks();
-
-    if (runningTasks.length === 0) {
-      this.stopPolling();
-      return;
-    }
-
-    try {
-      // Get all session statuses in one call
-      const resp = await this.ctx.client.session.status({
-        query: { directory: this.ctx.directory },
-      });
-
-      const statusResp = resp as SessionStatusResponse;
-      const statusMap = statusResp.data || {};
-
-      for (const task of runningTasks) {
-        const sessionStatus = statusMap[task.sessionID];
-        const statusType = sessionStatus?.type;
-
-        if (statusType === "idle" || statusType === undefined) {
-          // Session is idle OR not in status map (likely finished and cleaned up)
-          // Try to get result - if successful, mark as completed
-          const result = await this.fetchTaskResult(task);
-          if (result !== undefined || statusType === "idle") {
-            task.status = "completed";
-            task.completedAt = new Date();
-            task.result = result;
-            this.markForNotification(task);
-
-            await this.ctx.client.tui
-              .showToast({
-                body: {
-                  title: "Background Task Complete",
-                  message: task.description,
-                  variant: "success",
-                  duration: 5000,
-                },
-              })
-              .catch((error) => {
-                console.error(`[background-task] Failed to show toast for task ${task.id}:`, error);
-              });
-          }
-          // If result is undefined and statusType is undefined, keep waiting
-        }
-      }
-    } catch (error) {
-      console.error("[background-task] Failed to poll tasks:", error);
-      // Don't mark tasks as error - they may still be running, just can't check
-    }
-  }
-
-  private markForNotification(task: BackgroundTask): void {
-    const existing = this.notifications.get(task.parentSessionID) || [];
-    existing.push(task);
-    this.notifications.set(task.parentSessionID, existing);
-  }
-
-  getPendingNotifications(parentSessionID: string): BackgroundTask[] {
-    const notifications = this.notifications.get(parentSessionID) || [];
-    this.notifications.delete(parentSessionID);
-    return notifications;
-  }
-
-  handleEvent(event: { type: string; properties?: unknown }): void {
-    const props = event.properties as Record<string, unknown> | undefined;
-
-    // Primary completion detection: session.idle event
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID as string | undefined;
-      if (!sessionID) return;
-
-      const task = this.findBySession(sessionID);
-      if (!task || task.status !== "running") return;
-
-      task.status = "completed";
-      task.completedAt = new Date();
-      this.fetchTaskResult(task).then((result) => {
-        task.result = result;
-      });
-      this.markForNotification(task);
-
-      this.ctx.client.tui
-        .showToast({
-          body: {
-            title: "Background Task Complete",
-            message: task.description,
-            variant: "success",
-            duration: 5000,
-          },
-        })
-        .catch((error) => {
-          console.error(`[background-task] Failed to show toast for task ${task.id}:`, error);
-        });
-    }
-
-    // Track tool usage for progress
-    if (event.type === "message.part.updated") {
-      const info = props?.info as Record<string, unknown> | undefined;
-      const sessionID = info?.sessionID as string | undefined;
-      const partType = info?.type as string | undefined;
-
-      if (sessionID && partType === "tool_use") {
-        for (const task of this.tasks.values()) {
-          if (task.sessionID === sessionID && task.status === "running") {
-            if (!task.progress) {
-              task.progress = { toolCalls: 0, lastUpdate: new Date() };
-            }
-            task.progress.toolCalls++;
-            task.progress.lastTool = (info?.name as string) || undefined;
-            task.progress.lastUpdate = new Date();
-            break;
-          }
-        }
-      }
-    }
-
-    // Cleanup on session delete
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined;
-      if (sessionInfo?.id) {
-        for (const task of this.tasks.values()) {
-          if (task.sessionID === sessionInfo.id && task.status === "running") {
-            task.status = "cancelled";
-            task.completedAt = new Date();
-          }
-        }
-      }
-    }
-  }
-}

package/src/tools/background-task/tools.ts

@@ -1,161 +0,0 @@
-import { tool } from "@opencode-ai/plugin/tool";
-import type { BackgroundTaskManager } from "./manager";
-
-// Extended tool context with metadata for UI navigation
-type ToolContextWithMetadata = {
-  sessionID: string;
-  messageID?: string;
-  agent: string;
-  abort: AbortSignal;
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void;
-};
-
-export function createBackgroundTaskTools(manager: BackgroundTaskManager) {
-  const background_task = tool({
-    description: `Launch a task to run in the background using a subagent.
-The task runs independently while you continue working.
-Use background_output to check progress or get results when complete.
-Useful for: parallel research, concurrent implementation, async reviews.`,
-    args: {
-      description: tool.schema.string().describe("Short description of the task (shown in status)"),
-      prompt: tool.schema.string().describe("Full prompt/instructions for the background agent"),
-      agent: tool.schema.string().describe("Agent to use (e.g., 'codebase-analyzer', 'implementer')"),
-    },
-    execute: async (args, toolContext) => {
-      const ctx = toolContext as ToolContextWithMetadata;
-      try {
-        const task = await manager.launch({
-          description: args.description,
-          prompt: args.prompt,
-          agent: args.agent,
-          parentSessionID: ctx.sessionID,
-          parentMessageID: ctx.messageID || "",
-        });
-
-        // Set metadata for OpenCode UI session navigation (ctrl+x + arrow keys)
-        ctx.metadata?.({
-          title: args.description,
-          metadata: { sessionId: task.sessionID },
-        });
-
-        return `## Background Task Launched
-
-| Field | Value |
-|-------|-------|
-| Task ID | ${task.id} |
-| Agent | ${args.agent} |
-| Status | RUNNING |
-
-Use \`background_output\` with task_id="${task.id}" to check progress or get results.`;
-      } catch (error) {
-        return `Failed to launch background task: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-  });
-
-  const background_output = tool({
-    description: `Get status or results from a background task.
-Returns immediately with current status. Use background_list to poll for completion.`,
-    args: {
-      task_id: tool.schema.string().describe("ID of the task to check (e.g., 'bg_abc12345')"),
-    },
-    execute: async (args) => {
-      const { task_id } = args;
-
-      const task = manager.getTask(task_id);
-      if (!task) {
-        return `Task not found: ${task_id}`;
-      }
-
-      // Format status
-      let output = manager.formatTaskStatus(task);
-
-      // Include result if completed
-      if (task.status === "completed") {
-        const result = await manager.getTaskResult(task_id);
-        if (result) {
-          output += `\n### Result\n${result}\n`;
-        }
-      }
-
-      return output;
-    },
-  });
-
-  const background_cancel = tool({
-    description: `Cancel a running background task or all tasks.`,
-    args: {
-      task_id: tool.schema.string().optional().describe("ID of the task to cancel (omit to cancel all)"),
-      all: tool.schema.boolean().optional().describe("Cancel all running tasks (default: false)"),
-    },
-    execute: async (args) => {
-      const { task_id, all = false } = args;
-
-      if (all) {
-        const cancelled = await manager.cancelAll();
-        return `Cancelled ${cancelled} running task(s).`;
-      }
-
-      if (!task_id) {
-        return "Provide task_id or set all=true to cancel tasks.";
-      }
-
-      const success = await manager.cancel(task_id);
-      if (success) {
-        return `Task ${task_id} cancelled.`;
-      }
-
-      return `Could not cancel task ${task_id}. It may already be completed or not exist.`;
-    },
-  });
-
-  const background_list = tool({
-    description: `List all background tasks and their status.`,
-    args: {},
-    execute: async () => {
-      // Refresh status of running tasks before returning
-      await manager.refreshTaskStatus();
-      const tasks = manager.getAllTasks();
-
-      if (tasks.length === 0) {
-        return "No background tasks.";
-      }
-
-      const completed = tasks.filter((t) => t.status === "completed").length;
-      const errored = tasks.filter((t) => t.status === "error").length;
-      const running = tasks.filter((t) => t.status === "running").length;
-      const total = tasks.length;
-      const allDone = running === 0;
-
-      let output = "## Background Tasks\n\n";
-      output += `**Status: ${completed + errored}/${total} done${allDone ? " ✓ ALL COMPLETE" : ` (${running} still running)`}**\n\n`;
-      output += "| ID | Description | Agent | Status | Duration | Session |\n";
-      output += "|----|-------------|-------|--------|----------|---------|";
-
-      for (const task of tasks) {
-        const duration = task.completedAt
-          ? `${Math.round((task.completedAt.getTime() - task.startedAt.getTime()) / 1000)}s`
-          : `${Math.round((Date.now() - task.startedAt.getTime()) / 1000)}s`;
-
-        // Show session status for debugging
-        const sessionStatus = (task as { _sessionStatus?: string })._sessionStatus || "?";
-        const statusDisplay = task.status === "running" ? `${task.status} (${sessionStatus})` : task.status;
-
-        output += `| ${task.id} | ${task.description} | ${task.agent} | ${statusDisplay} | ${duration} | ${task.sessionID} |\n`;
-      }
-
-      if (allDone) {
-        output += "\n**→ All tasks complete. Proceed to collect results with background_output.**";
-      }
-
-      return output;
-    },
-  });
-
-  return {
-    background_task,
-    background_output,
-    background_cancel,
-    background_list,
-  };
-}

package/src/tools/background-task/types.ts

@@ -1,68 +0,0 @@
-export interface BackgroundTask {
-  id: string;
-  sessionID: string;
-  parentSessionID: string;
-  parentMessageID: string;
-  description: string;
-  prompt: string;
-  agent: string;
-  status: "running" | "completed" | "error" | "cancelled";
-  startedAt: Date;
-  completedAt?: Date;
-  result?: string;
-  error?: string;
-  progress?: {
-    toolCalls: number;
-    lastTool?: string;
-    lastUpdate: Date;
-  };
-}
-
-export interface BackgroundTaskInput {
-  description: string;
-  prompt: string;
-  agent: string;
-  parentSessionID: string;
-  parentMessageID: string;
-}
-
-// API Response Types - SDK wraps responses in { data: T } format
-export interface SessionCreateResponse {
-  data?: {
-    id?: string;
-  };
-}
-
-// SessionStatus from OpenCode SDK - status is a discriminated union with 'type' field
-export type SessionStatus =
-  | { type: "idle" }
-  | { type: "retry"; attempt: number; message: string; next: number }
-  | { type: "busy" };
-
-// session.status() returns { data: map of sessionID -> SessionStatus }
-export interface SessionStatusResponse {
-  data?: {
-    [sessionID: string]: SessionStatus;
-  };
-}
-
-export interface MessagePart {
-  type: string;
-  text?: string;
-}
-
-export interface MessageInfo {
-  role?: "user" | "assistant";
-  sessionID?: string;
-  type?: string;
-  name?: string;
-}
-
-export interface SessionMessage {
-  info?: MessageInfo;
-  parts?: MessagePart[];
-}
-
-export interface SessionMessagesResponse {
-  data?: SessionMessage[];
-}