micode 0.8.1 → 0.8.3

package/package.json

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

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,23 @@ ${summaryText}
         })
         .catch(() => {});
 
+      // Set up listener BEFORE calling summarize to avoid race condition
+      // (summary message event could fire before we start listening)
+      const compactionPromise = waitForCompaction(sessionID);
+
+      // 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 summary message to be created (message.updated with summary: true)
+      await compactionPromise;
+
       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
@@ -159,19 +189,36 @@ ${summaryText}
         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;
       }
 
-      // Monitor usage on assistant message completion
+      // Monitor message events
       if (event.type === "message.updated") {
         const info = props?.info as Record<string, unknown> | undefined;
         const sessionID = info?.sessionID as string | undefined;
 
         if (!sessionID || info?.role !== "assistant") return;
 
-        // Skip if this is already a summary message
-        if (info?.summary === true) return;
+        // Check if this is a summary message - signals compaction complete
+        if (info?.summary === true) {
+          const pending = state.pendingCompactions.get(sessionID);
+          if (pending) {
+            clearTimeout(pending.timeoutId);
+            state.pendingCompactions.delete(sessionID);
+            pending.resolve();
+          }
+          return;
+        }
+
+        // Skip triggering compaction if we're already waiting for one
+        if (state.pendingCompactions.has(sessionID)) return;
 
         const tokens = info?.tokens as { input?: number; cache?: { read?: number } } | undefined;
         const inputTokens = tokens?.input || 0;