micode 0.7.6 → 0.8.0

package/src/hooks/auto-compact.ts

@@ -1,241 +1,195 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { getContextLimit } from "../utils/model-limits";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 
-interface TokenLimitError {
-  currentTokens?: number;
-  maxTokens?: number;
-  providerID?: string;
-  modelID?: string;
-}
-
-// Parse Anthropic token limit errors
-function parseTokenLimitError(error: unknown): TokenLimitError | null {
-  if (!error) return null;
-
-  const errorStr = typeof error === "string" ? error : JSON.stringify(error);
-
-  // Check for Anthropic-specific token limit messages
-  const patterns = [
-    /prompt is too long.*?(\d+)\s*tokens.*?maximum.*?(\d+)/i,
-    /context.*?(\d+).*?exceeds.*?(\d+)/i,
-    /token limit.*?(\d+).*?max.*?(\d+)/i,
-  ];
-
-  for (const pattern of patterns) {
-    const match = errorStr.match(pattern);
-    if (match) {
-      return {
-        currentTokens: parseInt(match[1], 10),
-        maxTokens: parseInt(match[2], 10),
-      };
-    }
-  }
+// Compact when this percentage of context is used
+const COMPACT_THRESHOLD = 0.50;
 
-  // Check for generic rate limit / context errors
-  if (
-    errorStr.includes("context_length_exceeded") ||
-    errorStr.includes("token") ||
-    errorStr.includes("prompt is too long")
-  ) {
-    return {};
-  }
-
-  return null;
-}
+const LEDGER_DIR = "thoughts/ledgers";
 
 interface AutoCompactState {
-  pendingCompact: Set<string>;
-  errorData: Map<string, TokenLimitError>;
-  retryCount: Map<string, number>;
   inProgress: Set<string>;
+  lastCompactTime: Map<string, number>;
 }
 
+// Cooldown between compaction attempts (prevent rapid re-triggering)
+const COMPACT_COOLDOWN_MS = 30_000; // 30 seconds
+
 export function createAutoCompactHook(ctx: PluginInput) {
   const state: AutoCompactState = {
-    pendingCompact: new Set(),
-    errorData: new Map(),
-    retryCount: new Map(),
     inProgress: new Set(),
+    lastCompactTime: new Map(),
   };
 
-  const MAX_RETRIES = 3;
+  async function writeSummaryToLedger(sessionID: string): Promise<void> {
+    try {
+      // Fetch session messages to find the summary
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+
+      const messages = (resp as { data?: unknown[] }).data;
+      if (!Array.isArray(messages)) return;
+
+      // Find the summary message (has summary: true)
+      const summaryMsg = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "assistant" && info?.summary === true;
+      }) as Record<string, unknown> | undefined;
+
+      if (!summaryMsg) return;
+
+      // Extract text parts from the summary
+      const parts = summaryMsg.parts as Array<{ type: string; text?: string }> | undefined;
+      if (!parts) return;
+
+      const summaryText = parts
+        .filter((p) => p.type === "text" && p.text)
+        .map((p) => p.text)
+        .join("\n\n");
+
+      if (!summaryText.trim()) return;
+
+      // Create ledger directory if needed
+      const ledgerDir = join(ctx.directory, LEDGER_DIR);
+      await mkdir(ledgerDir, { recursive: true });
+
+      // Write ledger file - summary is already structured (Factory.ai/pi-mono format)
+      const timestamp = new Date().toISOString();
+      const sessionName = sessionID.slice(0, 8); // Use first 8 chars of session ID
+      const ledgerPath = join(ledgerDir, `CONTINUITY_${sessionName}.md`);
+
+      // Add metadata header, then the structured summary as-is
+      const ledgerContent = `---
+session: ${sessionName}
+updated: ${timestamp}
+---
+
+${summaryText}
+`;
+
+      await writeFile(ledgerPath, ledgerContent, "utf-8");
+    } catch (e) {
+      // Don't fail the compaction flow if ledger write fails
+      console.error("[auto-compact] Failed to write ledger:", e);
+    }
+  }
+
+  async function triggerCompaction(
+    sessionID: string,
+    providerID: string,
+    modelID: string,
+    usageRatio: number,
+  ): Promise<void> {
+    if (state.inProgress.has(sessionID)) {
+      return;
+    }
+
+    // Check cooldown
+    const lastCompact = state.lastCompactTime.get(sessionID) || 0;
+    if (Date.now() - lastCompact < COMPACT_COOLDOWN_MS) {
+      return;
+    }
 
-  async function attemptRecovery(sessionID: string, providerID?: string, modelID?: string): Promise<void> {
-    if (state.inProgress.has(sessionID)) return;
     state.inProgress.add(sessionID);
 
-    const retries = state.retryCount.get(sessionID) || 0;
+    try {
+      const usedPercent = Math.round(usageRatio * 100);
+      const thresholdPercent = Math.round(COMPACT_THRESHOLD * 100);
 
-    if (retries >= MAX_RETRIES) {
       await ctx.client.tui
         .showToast({
           body: {
-            title: "Auto Compact Failed",
-            message: "Max retries reached. Please start a new session or manually compact.",
-            variant: "error",
-            duration: 5000,
+            title: "Auto Compacting",
+            message: `Context at ${usedPercent}% (threshold: ${thresholdPercent}%). Summarizing...`,
+            variant: "warning",
+            duration: 3000,
           },
         })
         .catch(() => {});
-      state.inProgress.delete(sessionID);
-      state.pendingCompact.delete(sessionID);
-      return;
-    }
 
-    try {
+      await ctx.client.session.summarize({
+        path: { id: sessionID },
+        body: { providerID, modelID },
+        query: { directory: ctx.directory },
+      });
+
+      state.lastCompactTime.set(sessionID, Date.now());
+
+      // Write summary to ledger file
+      await writeSummaryToLedger(sessionID);
+
       await ctx.client.tui
         .showToast({
           body: {
-            title: "Context Limit Hit",
-            message: `Attempting to summarize session (attempt ${retries + 1}/${MAX_RETRIES})...`,
-            variant: "warning",
+            title: "Compaction Complete",
+            message: "Session summarized and ledger updated.",
+            variant: "success",
             duration: 3000,
           },
         })
         .catch(() => {});
-
-      // Try to summarize the session
-      if (providerID && modelID) {
-        await ctx.client.session.summarize({
-          path: { id: sessionID },
-          body: { providerID, modelID },
-          query: { directory: ctx.directory },
-        });
-
-        await ctx.client.tui
-          .showToast({
-            body: {
-              title: "Session Compacted",
-              message: "Context has been summarized. Continuing...",
-              variant: "success",
-              duration: 3000,
-            },
-          })
-          .catch(() => {});
-
-        // Clear state on success
-        state.pendingCompact.delete(sessionID);
-        state.errorData.delete(sessionID);
-        state.retryCount.delete(sessionID);
-
-        // Send continue prompt
-        setTimeout(async () => {
-          try {
-            await ctx.client.session.prompt({
-              path: { id: sessionID },
-              body: { parts: [{ type: "text", text: "Continue" }] },
-              query: { directory: ctx.directory },
-            });
-          } catch {}
-        }, 500);
-      } else {
-        await ctx.client.tui
-          .showToast({
-            body: {
-              title: "Cannot Auto-Compact",
-              message: "Missing model info. Please compact manually with /compact.",
-              variant: "error",
-              duration: 5000,
-            },
-          })
-          .catch(() => {});
-      }
-    } catch (_e) {
-      state.retryCount.set(sessionID, retries + 1);
-
-      // Exponential backoff
-      const delay = Math.min(1000 * 2 ** retries, 10000);
-      setTimeout(() => {
-        state.inProgress.delete(sessionID);
-        attemptRecovery(sessionID, providerID, modelID);
-      }, delay);
-      return;
+    } catch (e) {
+      const errorMsg = e instanceof Error ? e.message : String(e);
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Compaction Failed",
+            message: errorMsg.slice(0, 100),
+            variant: "error",
+            duration: 5000,
+          },
+        })
+        .catch(() => {});
+    } finally {
+      state.inProgress.delete(sessionID);
     }
-
-    state.inProgress.delete(sessionID);
   }
 
   return {
     event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
       const props = event.properties as Record<string, unknown> | undefined;
 
-      // Clean up on session delete
+      // Cleanup on session delete
       if (event.type === "session.deleted") {
         const sessionInfo = props?.info as { id?: string } | undefined;
         if (sessionInfo?.id) {
-          state.pendingCompact.delete(sessionInfo.id);
-          state.errorData.delete(sessionInfo.id);
-          state.retryCount.delete(sessionInfo.id);
           state.inProgress.delete(sessionInfo.id);
+          state.lastCompactTime.delete(sessionInfo.id);
         }
         return;
       }
 
-      // Detect token limit errors
-      if (event.type === "session.error") {
-        const sessionID = props?.sessionID as string | undefined;
-        const error = props?.error;
-
-        if (!sessionID) return;
-
-        const parsed = parseTokenLimitError(error);
-        if (parsed) {
-          state.pendingCompact.add(sessionID);
-          state.errorData.set(sessionID, parsed);
-
-          // Get last assistant message for provider/model info
-          const lastAssistant = await getLastAssistantInfo(sessionID);
-          const providerID = parsed.providerID || lastAssistant?.providerID;
-          const modelID = parsed.modelID || lastAssistant?.modelID;
-
-          attemptRecovery(sessionID, providerID, modelID);
-        }
-      }
-
-      // Also check message.updated for errors
+      // Monitor usage on assistant message completion
       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" && info.error) {
-          const parsed = parseTokenLimitError(info.error);
-          if (parsed) {
-            parsed.providerID = info.providerID as string | undefined;
-            parsed.modelID = info.modelID as string | undefined;
+        if (!sessionID || info?.role !== "assistant") return;
+
+        // Skip if this is already a summary message
+        if (info?.summary === true) return;
+
+        const tokens = info?.tokens as { input?: number; cache?: { read?: number } } | undefined;
+        const inputTokens = tokens?.input || 0;
+        const cacheRead = tokens?.cache?.read || 0;
+        const totalUsed = inputTokens + cacheRead;
 
-            state.pendingCompact.add(sessionID);
-            state.errorData.set(sessionID, parsed);
+        if (totalUsed === 0) return;
 
-            attemptRecovery(sessionID, parsed.providerID, parsed.modelID);
-          }
+        const modelID = (info?.modelID as string) || "";
+        const providerID = (info?.providerID as string) || "";
+        const contextLimit = getContextLimit(modelID);
+        const usageRatio = totalUsed / contextLimit;
+
+        // Trigger compaction if over threshold
+        if (usageRatio >= COMPACT_THRESHOLD) {
+          triggerCompaction(sessionID, providerID, modelID, usageRatio);
         }
       }
     },
   };
-
-  async function getLastAssistantInfo(sessionID: string): Promise<{ providerID?: string; modelID?: string } | null> {
-    try {
-      const resp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory },
-      });
-
-      const data = (resp as { data?: unknown[] }).data;
-      if (!Array.isArray(data)) return null;
-
-      const lastAssistant = [...data].reverse().find((m) => {
-        const msg = m as Record<string, unknown>;
-        const info = msg.info as Record<string, unknown> | undefined;
-        return info?.role === "assistant";
-      });
-
-      if (!lastAssistant) return null;
-      const info = (lastAssistant as { info?: Record<string, unknown> }).info;
-      return {
-        providerID: info?.providerID as string | undefined,
-        modelID: info?.modelID as string | undefined,
-      };
-    } catch {
-      return null;
-    }
-  }
 }

package/src/hooks/context-injector.ts

@@ -2,11 +2,11 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import { readFile } from "node:fs/promises";
 import { join, dirname, resolve } from "node:path";
 
-// Files to inject at project root level
-const ROOT_CONTEXT_FILES = ["ARCHITECTURE.md", "CODE_STYLE.md", "AGENTS.md", "CLAUDE.md", "README.md"] as const;
+// Files to inject at project root level (AGENTS.md and CLAUDE.md handled by OpenCode natively)
+const ROOT_CONTEXT_FILES = ["ARCHITECTURE.md", "CODE_STYLE.md", "README.md"] as const;
 
-// Files to collect when walking up directories
-const DIRECTORY_CONTEXT_FILES = ["AGENTS.md", "README.md"] as const;
+// Files to collect when walking up directories (AGENTS.md handled by OpenCode natively)
+const DIRECTORY_CONTEXT_FILES = ["README.md"] as const;
 
 // Tools that trigger directory-aware context injection
 const FILE_ACCESS_TOOLS = ["Read", "read", "Edit", "edit"];

package/src/hooks/context-window-monitor.ts

@@ -68,9 +68,9 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
 
         if (!sessionID || info?.role !== "assistant") return;
 
-        const usage = info.usage as Record<string, unknown> | undefined;
-        const inputTokens = (usage?.inputTokens as number) || 0;
-        const cacheRead = (usage?.cacheReadInputTokens as number) || 0;
+        const tokens = info.tokens as { input?: number; cache?: { read?: number } } | undefined;
+        const inputTokens = tokens?.input || 0;
+        const cacheRead = tokens?.cache?.read || 0;
         const totalUsed = inputTokens + cacheRead;
 
         const modelID = (info.modelID as string) || "";

package/src/index.ts

@@ -9,6 +9,7 @@ import { ast_grep_search, ast_grep_replace, checkAstGrepAvailable } from "./tool
 import { btca_ask, checkBtcaAvailable } from "./tools/btca";
 import { look_at } from "./tools/look-at";
 import { artifact_search } from "./tools/artifact-search";
+import { createSpawnAgentTool } from "./tools/spawn-agent";
 
 // Hooks
 import { createAutoCompactHook } from "./hooks/auto-compact";
@@ -17,10 +18,9 @@ import { createSessionRecoveryHook } from "./hooks/session-recovery";
 import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
 import { createContextWindowMonitorHook } from "./hooks/context-window-monitor";
 import { createCommentCheckerHook } from "./hooks/comment-checker";
-import { createAutoClearLedgerHook } from "./hooks/auto-clear-ledger";
 import { createLedgerLoaderHook } from "./hooks/ledger-loader";
 import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
-import { createFileOpsTrackerHook } from "./hooks/file-ops-tracker";
+import { createFileOpsTrackerHook, getFileOps } from "./hooks/file-ops-tracker";
 
 // PTY System
 import { PTYManager, createPtyTools } from "./tools/pty";
@@ -84,7 +84,6 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
   // Hooks
   const autoCompactHook = createAutoCompactHook(ctx);
   const contextInjectorHook = createContextInjectorHook(ctx);
-  const autoClearLedgerHook = createAutoClearLedgerHook(ctx);
   const ledgerLoaderHook = createLedgerLoaderHook(ctx);
   const sessionRecoveryHook = createSessionRecoveryHook(ctx);
   const tokenAwareTruncationHook = createTokenAwareTruncationHook(ctx);
@@ -97,6 +96,9 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
   const ptyManager = new PTYManager();
   const ptyTools = createPtyTools(ptyManager);
 
+  // Spawn agent tool (for subagents to spawn other subagents)
+  const spawn_agent = createSpawnAgentTool(ctx);
+
   return {
     // Tools
     tool: {
@@ -105,6 +107,7 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       btca_ask,
       look_at,
       artifact_search,
+      spawn_agent,
       ...ptyTools,
     },
 
@@ -194,6 +197,62 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       }
     },
 
+    // Structured compaction prompt (Factory.ai / pi-mono best practices)
+    "experimental.session.compacting": async (
+      input: { sessionID: string },
+      output: { context: string[]; prompt?: string },
+    ) => {
+      // Get file operations for this session
+      const fileOps = getFileOps(input.sessionID);
+      const readPaths = Array.from(fileOps.read).sort();
+      const modifiedPaths = Array.from(fileOps.modified).sort();
+
+      const fileOpsSection = `
+## File Operations
+### Read
+${readPaths.length > 0 ? readPaths.map((p) => `- \`${p}\``).join("\n") : "- (none)"}
+
+### Modified
+${modifiedPaths.length > 0 ? modifiedPaths.map((p) => `- \`${p}\``).join("\n") : "- (none)"}`;
+
+      output.prompt = `Create a structured summary for continuing this conversation. Use this EXACT format:
+
+# Session Summary
+
+## Goal
+{The core objective being pursued - one sentence describing success criteria}
+
+## Constraints & Preferences
+{Technical requirements, patterns to follow, things to avoid - or "(none)"}
+
+## Progress
+### Done
+- [x] {Completed items with specific details}
+
+### In Progress
+- [ ] {Current work - what's actively being worked on}
+
+### Blocked
+- {Issues preventing progress, if any - or "(none)"}
+
+## Key Decisions
+- **{Decision}**: {Rationale - why this choice was made}
+
+## Next Steps
+1. {Ordered list of what to do next - be specific}
+
+## Critical Context
+- {Data, examples, references, or findings needed to continue work}
+- {Important discoveries or insights from this session}
+${fileOpsSection}
+
+IMPORTANT:
+- Preserve EXACT file paths and function names
+- Focus on information needed to continue seamlessly
+- Be specific about what was done, not vague summaries
+- Include any error messages or issues encountered`;
+    },
+
     // Tool output processing
     "tool.execute.after": async (
       input: { tool: string; sessionID: string; callID: string; args?: Record<string, unknown> },
@@ -218,6 +277,20 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       );
     },
 
+    // Filter out CLAUDE.md/AGENTS.md from system prompt for our agents
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system = output.system.filter((s) => {
+        // Keep entries that don't come from CLAUDE.md or AGENTS.md
+        if (s.startsWith("Instructions from:")) {
+          const path = s.split("\n")[0];
+          if (path.includes("CLAUDE.md") || path.includes("AGENTS.md")) {
+            return false;
+          }
+        }
+        return true;
+      });
+    },
+
     event: async ({ event }) => {
       // Session cleanup (think mode + PTY)
       if (event.type === "session.deleted") {
@@ -230,7 +303,6 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
 
       // Run all event hooks
       await autoCompactHook.event({ event });
-      await autoClearLedgerHook.event({ event });
       await sessionRecoveryHook.event({ event });
       await tokenAwareTruncationHook.event({ event });
       await contextWindowMonitorHook.event({ event });

package/src/tools/spawn-agent.ts

@@ -0,0 +1,93 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import type { PluginInput } from "@opencode-ai/plugin";
+
+interface SessionCreateResponse {
+  data?: { id?: string };
+}
+
+interface MessagePart {
+  type: string;
+  text?: string;
+}
+
+interface SessionMessage {
+  info?: { role?: "user" | "assistant" };
+  parts?: MessagePart[];
+}
+
+interface SessionMessagesResponse {
+  data?: SessionMessage[];
+}
+
+export function createSpawnAgentTool(ctx: PluginInput) {
+  return tool({
+    description: `FOR SUBAGENTS ONLY - Primary agents (commander, brainstormer) should use the built-in Task tool instead.
+Spawn a subagent to execute a task synchronously. The agent runs to completion and returns its result.
+Use this when you are a SUBAGENT (executor, planner, project-initializer) and need to spawn other subagents.
+For parallel execution, call spawn_agent multiple times in ONE message.`,
+    args: {
+      agent: tool.schema.string().describe("Agent to spawn (e.g., 'implementer', 'reviewer')"),
+      prompt: tool.schema.string().describe("Full prompt/instructions for the agent"),
+      description: tool.schema.string().describe("Short description of the task"),
+    },
+    execute: async (args) => {
+      const { agent, prompt, description } = args;
+
+      try {
+        // Create new session for the subagent
+        const sessionResp = (await ctx.client.session.create({
+          body: {},
+          query: { directory: ctx.directory },
+        })) as SessionCreateResponse;
+
+        const sessionID = sessionResp.data?.id;
+        if (!sessionID) {
+          return `## spawn_agent Failed\n\nFailed to create session for agent "${agent}"`;
+        }
+
+        // Run the prompt synchronously (waits for completion)
+        await ctx.client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [{ type: "text", text: prompt }],
+            agent: agent,
+          },
+          query: { directory: ctx.directory },
+        });
+
+        // Get the result from session messages
+        const messagesResp = (await ctx.client.session.messages({
+          path: { id: sessionID },
+          query: { directory: ctx.directory },
+        })) as SessionMessagesResponse;
+
+        // Find the last assistant message
+        const messages = messagesResp.data || [];
+        const lastAssistant = messages
+          .filter((m) => m.info?.role === "assistant")
+          .pop();
+
+        const result =
+          lastAssistant?.parts
+            ?.filter((p) => p.type === "text" && p.text)
+            .map((p) => p.text)
+            .join("\n") || "(No response from agent)";
+
+        // Clean up session
+        await ctx.client.session
+          .delete({
+            path: { id: sessionID },
+            query: { directory: ctx.directory },
+          })
+          .catch(() => {
+            // Ignore cleanup errors
+          });
+
+        return `## ${description}\n\n**Agent**: ${agent}\n\n### Result\n\n${result}`;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return `## spawn_agent Failed\n\n**Agent**: ${agent}\n**Error**: ${errorMsg}`;
+      }
+    },
+  });
+}