micode 0.8.0 → 0.8.2

package/package.json

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

package/src/agents/brainstormer.ts

@@ -32,6 +32,7 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
   <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>
+  <subagent name="executor">Executes implementation plan with implementer/reviewer cycles.</subagent>
 </available-subagents>
 
 <process>
@@ -87,14 +88,27 @@ This is DESIGN ONLY. The planner agent handles detailed implementation plans.
     )
   </spawn>
   <rule>Do NOT ask again - if user approved, spawn planner immediately</rule>
-  <after-handoff>
-    <action>Report ONLY: "Implementation plan created at thoughts/shared/plans/YYYY-MM-DD-{topic}.md"</action>
-    <action>Tell user: "Ready to execute? Ask the commander to run the plan."</action>
+  <after-planner>
+    <action>Report: "Implementation plan created at thoughts/shared/plans/YYYY-MM-DD-{topic}.md"</action>
+    <action>Ask user: "Ready to execute the plan?"</action>
+    <rule>Wait for user response before proceeding</rule>
+  </after-planner>
+</phase>
+
+<phase name="execution" trigger="user approves execution">
+  <action>When user says yes/execute/go, spawn the executor:</action>
+  <spawn>
+    Task(
+      subagent_type="executor",
+      prompt="Execute the implementation plan at thoughts/shared/plans/YYYY-MM-DD-{topic}.md",
+      description="Execute implementation plan"
+    )
+  </spawn>
+  <after-execution>
+    <action>Report executor results to user</action>
     <rule priority="CRITICAL">YOUR JOB IS DONE. STOP HERE.</rule>
-    <rule>Do NOT process, summarize, or act on the planner's output</rule>
-    <rule>Do NOT write any code - the plan contains code but that's for the executor</rule>
-    <rule>Do NOT continue the conversation - wait for user's next request</rule>
-  </after-handoff>
+    <rule>Do NOT write any code yourself</rule>
+  </after-execution>
 </phase>
 </process>
 

package/src/hooks/auto-compact.ts

@@ -4,13 +4,23 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
 // Compact when this percentage of context is used
-const COMPACT_THRESHOLD = 0.50;
+const COMPACT_THRESHOLD = 0.5;
 
 const LEDGER_DIR = "thoughts/ledgers";
 
+// Timeout for waiting for compaction to complete (2 minutes)
+const COMPACTION_TIMEOUT_MS = 120_000;
+
+interface PendingCompaction {
+  resolve: () => void;
+  reject: (error: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+}
+
 interface AutoCompactState {
   inProgress: Set<string>;
   lastCompactTime: Map<string, number>;
+  pendingCompactions: Map<string, PendingCompaction>;
 }
 
 // Cooldown between compaction attempts (prevent rapid re-triggering)
@@ -20,6 +30,7 @@ export function createAutoCompactHook(ctx: PluginInput) {
   const state: AutoCompactState = {
     inProgress: new Set(),
     lastCompactTime: new Map(),
+    pendingCompactions: new Map(),
   };
 
   async function writeSummaryToLedger(sessionID: string): Promise<void> {
@@ -78,6 +89,17 @@ ${summaryText}
     }
   }
 
+  function waitForCompaction(sessionID: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        state.pendingCompactions.delete(sessionID);
+        reject(new Error("Compaction timed out"));
+      }, COMPACTION_TIMEOUT_MS);
+
+      state.pendingCompactions.set(sessionID, { resolve, reject, timeoutId });
+    });
+  }
+
   async function triggerCompaction(
     sessionID: string,
     providerID: string,
@@ -111,15 +133,19 @@ ${summaryText}
         })
         .catch(() => {});
 
+      // Start the compaction - this returns immediately while compaction runs async
       await ctx.client.session.summarize({
         path: { id: sessionID },
         body: { providerID, modelID },
         query: { directory: ctx.directory },
       });
 
+      // Wait for the session.compacted event to confirm completion
+      await waitForCompaction(sessionID);
+
       state.lastCompactTime.set(sessionID, Date.now());
 
-      // Write summary to ledger file
+      // Write summary to ledger file (only after compaction is confirmed complete)
       await writeSummaryToLedger(sessionID);
 
       await ctx.client.tui
@@ -153,12 +179,32 @@ ${summaryText}
     event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
       const props = event.properties as Record<string, unknown> | undefined;
 
+      // Handle compaction completion
+      if (event.type === "session.compacted") {
+        const sessionID = props?.sessionID as string | undefined;
+        if (sessionID) {
+          const pending = state.pendingCompactions.get(sessionID);
+          if (pending) {
+            clearTimeout(pending.timeoutId);
+            state.pendingCompactions.delete(sessionID);
+            pending.resolve();
+          }
+        }
+        return;
+      }
+
       // Cleanup on session delete
       if (event.type === "session.deleted") {
         const sessionInfo = props?.info as { id?: string } | undefined;
         if (sessionInfo?.id) {
           state.inProgress.delete(sessionInfo.id);
           state.lastCompactTime.delete(sessionInfo.id);
+          const pending = state.pendingCompactions.get(sessionInfo.id);
+          if (pending) {
+            clearTimeout(pending.timeoutId);
+            state.pendingCompactions.delete(sessionInfo.id);
+            pending.reject(new Error("Session deleted"));
+          }
         }
         return;
       }