micode 0.7.2 → 0.7.4

package/package.json

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

package/src/agents/brainstormer.ts

@@ -13,55 +13,37 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
 <critical-rules>
   <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>BACKGROUND TASKS: Use background_task for parallel codebase analysis.</rule>
-  <rule>TOOLS (grep, read, etc.): Do NOT use directly - use background subagents instead.</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>
 </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>
+<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" spawn="background_task">
-    Find files, modules, patterns. Fire multiple with different queries.
-    Example: background_task(agent="codebase-locator", prompt="Find authentication code", description="Find auth files")
-  </subagent>
-  <subagent name="codebase-analyzer" spawn="background_task">
-    Deep analysis of specific modules. Fire multiple for different areas.
-    Example: background_task(agent="codebase-analyzer", prompt="Analyze the auth module", description="Analyze auth")
-  </subagent>
-  <subagent name="pattern-finder" spawn="background_task">
-    Find existing patterns in codebase. Fire for different pattern types.
-    Example: background_task(agent="pattern-finder", prompt="Find error handling patterns", description="Find error patterns")
-  </subagent>
-  <subagent name="planner" spawn="Task" when="design approved">
-    Creates detailed implementation plan from validated design.
-    Example: Task(subagent_type="planner", prompt="Create implementation plan for [design path]", description="Create plan")
-  </subagent>
+  <subagent name="codebase-locator">Find files, modules, patterns.</subagent>
+  <subagent name="codebase-analyzer">Deep analysis of specific modules.</subagent>
+  <subagent name="pattern-finder">Find existing patterns in codebase.</subagent>
+  <subagent name="planner">Creates detailed implementation plan from validated design.</subagent>
 </available-subagents>
 
 <process>
-<phase name="understanding" pattern="fire-poll-collect">
-  <action>Fire background tasks in PARALLEL to gather context:</action>
-  <fire-example>
-    In a SINGLE message, fire ALL background tasks:
+<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 existing [related feature]", description="Analyze [feature]")
-    background_task(agent="pattern-finder", prompt="Find patterns for [similar functionality]", description="Find patterns")
-  </fire-example>
-  <poll>
-    background_list()
-    - Look for "ALL COMPLETE" in the output
-    - If still running: wait a moment, call background_list() again
-    - Max 5 polls, then proceed anyway with available results
-  </poll>
-  <collect>
-    When background_list shows "ALL COMPLETE" or after max polls:
-    - Call background_output(task_id=...) for each completed task
-    - Skip errored tasks
-  </collect>
+    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")
+  </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
+  </workflow>
+  <rule>Do NOT proceed to questions until you have codebase context</rule>
   <focus>purpose, constraints, success criteria</focus>
 </phase>
 
@@ -95,8 +77,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>
-    Task(
-      subagent_type="planner",
+    background_task(
+      agent="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"
     )
@@ -107,8 +89,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">Use background_task for parallel research, poll with background_list, collect with background_output</principle>
-  <principle name="parallel-fire">Fire ALL background tasks in a SINGLE message for true parallelism</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="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

@@ -84,8 +84,19 @@ Just do it - including obvious follow-up actions.
 <agent name="planner" mode="subagent" purpose="Create detailed implementation plans"/>
 <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>
+<example>
+  background_task(agent="planner", prompt="Create plan for...", description="Create plan")
+  background_list()  // check status
+  background_output(task_id="bg_xxx")  // get results
+</example>
+</spawning>
 <parallelization>
-<safe>locator, analyzer, pattern-finder</safe>
+<safe>locator, analyzer, pattern-finder (fire multiple in one message)</safe>
 <sequential>planner then executor</sequential>
 </parallelization>
 </agents>

package/src/agents/executor.ts

@@ -82,23 +82,17 @@ Example: 3 independent tasks
     Executes ONE task from the plan.
     Input: Single task with context (which files, what to do).
     Output: Changes made and verification results for that task.
-    <invocation type="background">
+    <invocation>
       background_task(description="Implement task 1", prompt="...", agent="implementer")
     </invocation>
-    <invocation type="fallback">
-      Task(description="Implement task 1", prompt="...", subagent_type="implementer")
-    </invocation>
   </subagent>
   <subagent name="reviewer">
     Reviews ONE task's implementation.
     Input: Single task's changes against its requirements.
     Output: APPROVED or CHANGES REQUESTED for that task.
-    <invocation type="background">
+    <invocation>
       background_task(description="Review task 1", prompt="...", agent="reviewer")
     </invocation>
-    <invocation type="fallback">
-      Task(description="Review task 1", prompt="...", subagent_type="reviewer")
-    </invocation>
   </subagent>
 </available-subagents>
 
@@ -129,13 +123,6 @@ IMPORTANT: Always poll with background_list first to check status,
 then fetch results with background_output only for completed tasks.
 </fire-and-check-loop>
 
-<fallback-rule>
-If background_task fails or is unavailable, fall back to Task() tool:
-- Task(description="...", prompt="...", subagent_type="implementer")
-- Task(description="...", prompt="...", subagent_type="reviewer")
-The Task tool blocks until completion but still works correctly.
-</fallback-rule>
-
 <rules>
 <rule>Parse ALL tasks from plan before starting execution</rule>
 <rule>ALWAYS analyze dependencies before parallelizing</rule>

package/src/agents/planner.ts

@@ -13,24 +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>
-
-<fallback-rule>
-If background_task fails or is unavailable, fall back to Task() for sequential execution.
-Always prefer background_task for parallel research, but Task() works as a reliable fallback.
-</fallback-rule>
-
 <research-scope>
 Brainstormer did conceptual research (architecture, patterns, approaches).
 Your research is IMPLEMENTATION-LEVEL only:
@@ -48,19 +37,19 @@ All research must serve the design - never second-guess design decisions.
 </library-research>
 
 <available-subagents>
-  <subagent name="codebase-locator" spawn="background">
+  <subagent name="codebase-locator">
     Find exact file paths needed for implementation.
     Examples: "Find exact path to UserService", "Find test directory structure"
   </subagent>
-  <subagent name="codebase-analyzer" spawn="background">
+  <subagent name="codebase-analyzer">
     Get exact signatures and types for code examples.
     Examples: "Get function signature for createUser", "Get type definition for UserConfig"
   </subagent>
-  <subagent name="pattern-finder" spawn="background">
+  <subagent name="pattern-finder">
     Find exact patterns to copy in code examples.
     Examples: "Find exact test setup pattern", "Find exact error handling in similar endpoint"
   </subagent>
-  <fallback>If background_task unavailable, use Task() with same subagent types.</fallback>
+  <rule>Use the Task tool to spawn subagents synchronously.</rule>
 </available-subagents>
 
 <inputs>
@@ -76,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>
@@ -183,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

@@ -89,35 +89,24 @@ const PROMPT = `
   </parallel-execution-strategy>
 
   <available-subagents>
-    <subagent name="codebase-locator" spawn="multiple">
+    <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: background_task(description="Find entry points", prompt="Find all entry points and main files", agent="codebase-locator")
-      Fallback: Task(description="Find entry points", prompt="Find all entry points and main files", subagent_type="codebase-locator")
+      background_task(description="Find entry points", prompt="Find all entry points and main files", agent="codebase-locator")
     </subagent>
-    <subagent name="codebase-analyzer" spawn="multiple">
+    <subagent name="codebase-analyzer">
       Deep module analyzer. Spawn multiple for different areas.
       Examples: "Analyze src/core", "Analyze api layer", "Analyze database module"
-      
-      Background: background_task(description="Analyze core", prompt="Analyze the core module", agent="codebase-analyzer")
-      Fallback: Task(description="Analyze core", prompt="Analyze the core module", subagent_type="codebase-analyzer")
+      background_task(description="Analyze core", prompt="Analyze the core module", agent="codebase-analyzer")
     </subagent>
-    <subagent name="pattern-finder" spawn="multiple">
+    <subagent name="pattern-finder">
       Pattern extractor. Spawn for different pattern types.
       Examples: "Find naming patterns", "Find error handling patterns", "Find async patterns"
-      
-      Background: background_task(description="Find patterns", prompt="Find naming conventions", agent="pattern-finder")
-      Fallback: Task(description="Find patterns", prompt="Find naming conventions", subagent_type="pattern-finder")
+      background_task(description="Find patterns", prompt="Find naming conventions", agent="pattern-finder")
     </subagent>
+    <rule>ALWAYS use background_task to spawn subagents. NEVER use Task tool.</rule>
   </available-subagents>
 
-  <fallback-rule>
-    If background_task fails or is unavailable, fall back to Task() tool.
-    The Task tool provides synchronous subagent execution.
-    Example fallback: Task(description="Find entry points", prompt="Find all entry points", subagent_type="codebase-locator")
-  </fallback-rule>
-
   <critical-instruction>
     Use background_task to fire subagents for TRUE parallelism.
     Fire ALL background_task calls in a SINGLE message.

package/src/hooks/artifact-auto-index.ts

@@ -88,7 +88,6 @@ export function createArtifactAutoIndexHook(_ctx: PluginInput) {
           const index = await getArtifactIndex();
           const record = parseLedger(content, filePath, ledgerMatch[1]);
           await index.indexLedger(record);
-          console.log(`[artifact-auto-index] Indexed ledger: ${filePath}`);
           return;
         }
 
@@ -99,7 +98,6 @@ export function createArtifactAutoIndexHook(_ctx: PluginInput) {
           const index = await getArtifactIndex();
           const record = parsePlan(content, filePath, planMatch[1]);
           await index.indexPlan(record);
-          console.log(`[artifact-auto-index] Indexed plan: ${filePath}`);
           return;
         }
       } catch (e) {

package/src/index.ts

@@ -80,9 +80,6 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
 
   // Load user config for model overrides
   const userConfig = await loadMicodeConfig();
-  if (userConfig?.agents) {
-    console.log(`[micode] Loaded model overrides for: ${Object.keys(userConfig.agents).join(", ")}`);
-  }
 
   // Think mode state per session
   const thinkModeState = new Map<string, boolean>();

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

@@ -140,6 +140,15 @@ export class BackgroundTaskManager {
     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());
   }
@@ -311,8 +320,6 @@ export class BackgroundTaskManager {
         const sessionStatus = statusMap[task.sessionID];
         const statusType = sessionStatus?.type;
 
-        console.log(`[background-task] Poll ${task.id}: session=${task.sessionID} status=${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
@@ -360,6 +367,35 @@ export class BackgroundTaskManager {
   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;

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

@@ -1,6 +1,15 @@
 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.
@@ -12,7 +21,8 @@ Useful for: parallel research, concurrent implementation, async reviews.`,
       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, ctx) => {
+    execute: async (args, toolContext) => {
+      const ctx = toolContext as ToolContextWithMetadata;
       try {
         const task = await manager.launch({
           description: args.description,
@@ -22,6 +32,12 @@ Useful for: parallel research, concurrent implementation, async reviews.`,
           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 |