oh-my-opencode 0.1.24 → 0.1.26

package/dist/index.js

@@ -602,18 +602,13 @@ function createBuiltinAgents(disabledAgents = [], agentOverrides = {}) {
   return result;
 }
 // src/hooks/todo-continuation-enforcer.ts
-var CONTINUATION_PROMPT = `[SYSTEM REMINDER - TODO ENFORCEMENT]
+var CONTINUATION_PROMPT = `[SYSTEM REMINDER - TODO CONTINUATION]
 
-Your todo list is NOT complete. There are still incomplete tasks remaining.
+Incomplete tasks remain in your todo list. Continue working on the next pending task.
 
-CRITICAL INSTRUCTION:
-- You MUST NOT stop working until ALL todos are marked as completed
-- Continue working on the next pending task immediately
-- Work honestly and diligently to finish every task
-- Do NOT ask for permission to continue - just proceed with the work
-- Mark each task as completed as soon as you finish it
-
-Resume your work NOW.`;
+- Proceed without asking for permission
+- Mark each task complete when finished
+- Do not stop until all tasks are done`;
 function detectInterrupt(error) {
   if (!error)
     return false;
@@ -694,7 +689,7 @@ function createTodoContinuationEnforcer(ctx) {
                 type: "text",
                 text: `${CONTINUATION_PROMPT}
 
-[Status: ${incomplete.length}/${todos.length} tasks remaining]`
+[Status: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.length} remaining]`
               }
             ]
           },
@@ -790,6 +785,32 @@ ${CONTEXT_REMINDER}
   };
 }
 // src/hooks/session-recovery.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// node_modules/xdg-basedir/index.js
+import os from "os";
+import path from "path";
+var homeDirectory = os.homedir();
+var { env } = process;
+var xdgData = env.XDG_DATA_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "share") : undefined);
+var xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path.join(homeDirectory, ".config") : undefined);
+var xdgState = env.XDG_STATE_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "state") : undefined);
+var xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? path.join(homeDirectory, ".cache") : undefined);
+var xdgRuntime = env.XDG_RUNTIME_DIR || undefined;
+var xdgDataDirectories = (env.XDG_DATA_DIRS || "/usr/local/share/:/usr/share/").split(":");
+if (xdgData) {
+  xdgDataDirectories.unshift(xdgData);
+}
+var xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
+if (xdgConfig) {
+  xdgConfigDirectories.unshift(xdgConfig);
+}
+
+// src/hooks/session-recovery.ts
+var OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+var MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message");
+var PART_STORAGE = join(OPENCODE_STORAGE, "part");
 function getErrorMessage(error) {
   if (!error)
     return "";
@@ -894,80 +915,121 @@ async function recoverThinkingDisabledViolation(client, sessionID, failedAssista
   return false;
 }
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
-function hasNonEmptyOutput(msg) {
-  const parts = msg.parts;
-  if (!parts || parts.length === 0)
-    return false;
-  return parts.some((p) => {
-    if (THINKING_TYPES.has(p.type))
-      return false;
-    if (p.type === "step-start" || p.type === "step-finish")
+var META_TYPES = new Set(["step-start", "step-finish"]);
+function generatePartId() {
+  const timestamp = Date.now().toString(16);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `prt_${timestamp}${random}`;
+}
+function getMessageDir(sessionID) {
+  const projectHash = readdirSync(MESSAGE_STORAGE).find((dir) => {
+    const sessionDir = join(MESSAGE_STORAGE, dir);
+    try {
+      return readdirSync(sessionDir).some((f) => f.includes(sessionID.replace("ses_", "")));
+    } catch {
       return false;
-    if (p.type === "text" && p.text && p.text.trim())
-      return true;
-    if (p.type === "tool_use" && p.id)
-      return true;
-    if (p.type === "tool_result")
-      return true;
-    return false;
+    }
   });
+  if (projectHash) {
+    return join(MESSAGE_STORAGE, projectHash, sessionID);
+  }
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync(sessionPath)) {
+      return sessionPath;
+    }
+  }
+  return "";
 }
-function findEmptyContentMessage(msgs) {
-  for (let i = 0;i < msgs.length; i++) {
-    const msg = msgs[i];
-    const isLastMessage = i === msgs.length - 1;
-    const isAssistant = msg.info?.role === "assistant";
-    if (isLastMessage && isAssistant)
+function readMessagesFromStorage(sessionID) {
+  const messageDir = getMessageDir(sessionID);
+  if (!messageDir || !existsSync(messageDir))
+    return [];
+  const messages = [];
+  for (const file of readdirSync(messageDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const content = readFileSync(join(messageDir, file), "utf-8");
+      messages.push(JSON.parse(content));
+    } catch {
       continue;
-    if (!hasNonEmptyOutput(msg)) {
-      return msg;
     }
   }
-  return null;
+  return messages.sort((a, b) => a.id.localeCompare(b.id));
 }
-async function recoverEmptyContentMessage(client, sessionID, failedAssistantMsg, directory) {
-  try {
-    const messagesResp = await client.session.messages({
-      path: { id: sessionID },
-      query: { directory }
-    });
-    const msgs = messagesResp.data;
-    if (!msgs || msgs.length === 0)
-      return false;
-    const emptyMsg = findEmptyContentMessage(msgs) || failedAssistantMsg;
-    const messageID = emptyMsg.info?.id;
-    if (!messageID)
-      return false;
-    const existingParts = emptyMsg.parts || [];
-    const hasOnlyThinkingOrMeta = existingParts.length > 0 && existingParts.every((p) => THINKING_TYPES.has(p.type) || p.type === "step-start" || p.type === "step-finish");
-    if (hasOnlyThinkingOrMeta) {
-      const strippedParts = [{ type: "text", text: "(interrupted)" }];
-      try {
-        await client.message?.update?.({
-          path: { id: messageID },
-          body: { parts: strippedParts }
-        });
-        return true;
-      } catch {}
-      try {
-        await client.session.patch?.({
-          path: { id: sessionID },
-          body: { messageID, parts: strippedParts }
-        });
-        return true;
-      } catch {}
+function readPartsFromStorage(messageID) {
+  const partDir = join(PART_STORAGE, messageID);
+  if (!existsSync(partDir))
+    return [];
+  const parts = [];
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const content = readFileSync(join(partDir, file), "utf-8");
+      parts.push(JSON.parse(content));
+    } catch {
+      continue;
     }
-    const revertTargetID = emptyMsg.info?.parentID || messageID;
-    await client.session.revert({
-      path: { id: sessionID },
-      body: { messageID: revertTargetID },
-      query: { directory }
-    });
+  }
+  return parts;
+}
+function injectTextPartToStorage(sessionID, messageID, text) {
+  const partDir = join(PART_STORAGE, messageID);
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true });
+  }
+  const partId = generatePartId();
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "text",
+    text
+  };
+  try {
+    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
   }
 }
+function findEmptyContentMessageFromStorage(sessionID) {
+  const messages = readMessagesFromStorage(sessionID);
+  for (let i = 0;i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant")
+      continue;
+    const isLastMessage = i === messages.length - 1;
+    if (isLastMessage)
+      continue;
+    const parts = readPartsFromStorage(msg.id);
+    const hasContent = parts.some((p) => {
+      if (THINKING_TYPES.has(p.type))
+        return false;
+      if (META_TYPES.has(p.type))
+        return false;
+      if (p.type === "text" && p.text?.trim())
+        return true;
+      if (p.type === "tool_use")
+        return true;
+      if (p.type === "tool_result")
+        return true;
+      return false;
+    });
+    if (!hasContent && parts.length > 0) {
+      return msg.id;
+    }
+  }
+  return null;
+}
+async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory) {
+  const emptyMessageID = findEmptyContentMessageFromStorage(sessionID) || failedAssistantMsg.info?.id;
+  if (!emptyMessageID)
+    return false;
+  return injectTextPartToStorage(sessionID, emptyMessageID, "(interrupted)");
+}
 async function fallbackRevertStrategy(client, sessionID, failedAssistantMsg, directory) {
   const parentMsgID = failedAssistantMsg.info?.parentID;
   const messagesResp = await client.session.messages({
@@ -1093,14 +1155,14 @@ function createSessionRecoveryHook(ctx) {
 // src/hooks/comment-checker/cli.ts
 var {spawn: spawn2 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
-import { dirname, join as join2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 import * as fs from "fs";
 
 // src/hooks/comment-checker/downloader.ts
 var {spawn } = globalThis.Bun;
-import { existsSync, mkdirSync, chmodSync, unlinkSync, appendFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync, unlinkSync, appendFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 import { createRequire } from "module";
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
@@ -1121,16 +1183,16 @@ var PLATFORM_MAP = {
   "win32-x64": { os: "windows", arch: "amd64", ext: "zip" }
 };
 function getCacheDir() {
-  const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join(homedir(), ".cache");
-  return join(base, "oh-my-opencode", "bin");
+  const xdgCache2 = process.env.XDG_CACHE_HOME;
+  const base = xdgCache2 || join2(homedir(), ".cache");
+  return join2(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join(getCacheDir(), getBinaryName());
-  return existsSync(binaryPath) ? binaryPath : null;
+  const binaryPath = join2(getCacheDir(), getBinaryName());
+  return existsSync2(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -1177,26 +1239,26 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join(cacheDir, binaryName);
-  if (existsSync(binaryPath)) {
+  const binaryPath = join2(cacheDir, binaryName);
+  if (existsSync2(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
   const version = getPackageVersion();
-  const { os, arch, ext } = platformInfo;
-  const assetName = `comment-checker_v${version}_${os}_${arch}.${ext}`;
+  const { os: os2, arch, ext } = platformInfo;
+  const assetName = `comment-checker_v${version}_${os2}_${arch}.${ext}`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/v${version}/${assetName}`;
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
-    if (!existsSync(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true });
+    if (!existsSync2(cacheDir)) {
+      mkdirSync2(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join(cacheDir, assetName);
+    const archivePath = join2(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -1205,10 +1267,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync(archivePath)) {
+    if (existsSync2(archivePath)) {
       unlinkSync(archivePath);
     }
-    if (process.platform !== "win32" && existsSync(binaryPath)) {
+    if (process.platform !== "win32" && existsSync2(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -1261,8 +1323,8 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join2(cliDir, "bin", binaryName);
-    if (existsSync2(binaryPath)) {
+    const binaryPath = join3(cliDir, "bin", binaryName);
+    if (existsSync3(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -1275,8 +1337,8 @@ function findCommentCheckerPathSync() {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname(pkgPath);
-      const binaryPath = join2(pkgDir, "bin", binaryName);
-      if (existsSync2(binaryPath)) {
+      const binaryPath = join3(pkgDir, "bin", binaryName);
+      if (existsSync3(binaryPath)) {
         debugLog2("found binary in platform package:", binaryPath);
         return binaryPath;
       }
@@ -1289,10 +1351,10 @@ function findCommentCheckerPathSync() {
       "/opt/homebrew/bin/comment-checker",
       "/usr/local/bin/comment-checker"
     ];
-    for (const path of homebrewPaths) {
-      if (existsSync2(path)) {
-        debugLog2("found binary via homebrew:", path);
-        return path;
+    for (const path2 of homebrewPaths) {
+      if (existsSync3(path2)) {
+        debugLog2("found binary via homebrew:", path2);
+        return path2;
       }
     }
   }
@@ -1315,7 +1377,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync2(syncPath)) {
+    if (syncPath && existsSync3(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -1335,8 +1397,8 @@ async function getCommentCheckerPath() {
 function startBackgroundInit() {
   if (!initPromise) {
     initPromise = getCommentCheckerPath();
-    initPromise.then((path) => {
-      debugLog2("background init complete:", path || "no binary");
+    initPromise.then((path2) => {
+      debugLog2("background init complete:", path2 || "no binary");
     }).catch((err) => {
       debugLog2("background init error:", err);
     });
@@ -1349,7 +1411,7 @@ async function runCommentChecker(input, cliPath) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync2(binaryPath)) {
+  if (!existsSync3(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -1383,7 +1445,7 @@ async function runCommentChecker(input, cliPath) {
 
 // src/hooks/comment-checker/index.ts
 import * as fs2 from "fs";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
 var DEBUG_FILE3 = "/tmp/comment-checker-debug.log";
 function debugLog3(...args) {
@@ -1409,8 +1471,8 @@ function createCommentCheckerHooks() {
   debugLog3("createCommentCheckerHooks called");
   startBackgroundInit();
   cliPathPromise = getCommentCheckerPath();
-  cliPathPromise.then((path) => {
-    debugLog3("CLI path resolved:", path || "disabled (no binary)");
+  cliPathPromise.then((path2) => {
+    debugLog3("CLI path resolved:", path2 || "disabled (no binary)");
   }).catch((err) => {
     debugLog3("CLI path resolution error:", err);
   });
@@ -1461,7 +1523,7 @@ function createCommentCheckerHooks() {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync3(cliPath)) {
+        if (!cliPath || !existsSync4(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -1499,6 +1561,208 @@ ${result.message}`;
     debugLog3("CLI: no comments detected");
   }
 }
+// src/hooks/grep-output-truncator.ts
+var ANTHROPIC_ACTUAL_LIMIT2 = 200000;
+var CHARS_PER_TOKEN_ESTIMATE = 4;
+var TARGET_MAX_TOKENS = 50000;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
+}
+function truncateToTokenLimit(output, maxTokens) {
+  const currentTokens = estimateTokens(output);
+  if (currentTokens <= maxTokens) {
+    return { result: output, truncated: false };
+  }
+  const lines = output.split(`
+`);
+  if (lines.length <= 3) {
+    const maxChars = maxTokens * CHARS_PER_TOKEN_ESTIMATE;
+    return {
+      result: output.slice(0, maxChars) + `
+
+[Output truncated due to context window limit]`,
+      truncated: true
+    };
+  }
+  const headerLines = lines.slice(0, 3);
+  const contentLines = lines.slice(3);
+  const headerText = headerLines.join(`
+`);
+  const headerTokens = estimateTokens(headerText);
+  const availableTokens = maxTokens - headerTokens - 50;
+  if (availableTokens <= 0) {
+    return {
+      result: headerText + `
+
+[Content truncated due to context window limit]`,
+      truncated: true
+    };
+  }
+  let resultLines = [];
+  let currentTokenCount = 0;
+  for (const line of contentLines) {
+    const lineTokens = estimateTokens(line + `
+`);
+    if (currentTokenCount + lineTokens > availableTokens) {
+      break;
+    }
+    resultLines.push(line);
+    currentTokenCount += lineTokens;
+  }
+  const truncatedContent = [...headerLines, ...resultLines].join(`
+`);
+  const removedCount = contentLines.length - resultLines.length;
+  return {
+    result: truncatedContent + `
+
+[${removedCount} more lines truncated due to context window limit]`,
+    truncated: true
+  };
+}
+function createGrepOutputTruncatorHook(ctx) {
+  const GREP_TOOLS = ["safe_grep", "Grep"];
+  const toolExecuteAfter = async (input, output) => {
+    if (!GREP_TOOLS.includes(input.tool))
+      return;
+    const { sessionID } = input;
+    try {
+      const response = await ctx.client.session.messages({
+        path: { id: sessionID }
+      });
+      const messages = response.data ?? response;
+      const assistantMessages = messages.filter((m) => m.info.role === "assistant").map((m) => m.info);
+      if (assistantMessages.length === 0)
+        return;
+      const totalInputTokens = assistantMessages.reduce((sum, m) => {
+        const inputTokens = m.tokens?.input ?? 0;
+        const cacheReadTokens = m.tokens?.cache?.read ?? 0;
+        return sum + inputTokens + cacheReadTokens;
+      }, 0);
+      const remainingTokens = ANTHROPIC_ACTUAL_LIMIT2 - totalInputTokens;
+      const maxOutputTokens = Math.min(remainingTokens * 0.5, TARGET_MAX_TOKENS);
+      if (maxOutputTokens <= 0) {
+        output.output = "[Output suppressed - context window exhausted]";
+        return;
+      }
+      const { result, truncated } = truncateToTokenLimit(output.output, maxOutputTokens);
+      if (truncated) {
+        output.output = result;
+      }
+    } catch {}
+  };
+  return {
+    "tool.execute.after": toolExecuteAfter
+  };
+}
+// src/hooks/pulse-monitor.ts
+function createPulseMonitorHook(ctx) {
+  const STANDARD_TIMEOUT = 5 * 60 * 1000;
+  const THINKING_TIMEOUT = 5 * 60 * 1000;
+  const CHECK_INTERVAL = 5 * 1000;
+  let lastHeartbeat = Date.now();
+  let isMonitoring = false;
+  let currentSessionID = null;
+  let monitorTimer = null;
+  let isThinking = false;
+  const startMonitoring = (sessionID) => {
+    if (currentSessionID !== sessionID) {
+      currentSessionID = sessionID;
+      isThinking = false;
+    }
+    lastHeartbeat = Date.now();
+    if (!isMonitoring) {
+      isMonitoring = true;
+      if (monitorTimer)
+        clearInterval(monitorTimer);
+      monitorTimer = setInterval(async () => {
+        if (!isMonitoring || !currentSessionID)
+          return;
+        const timeSinceLastHeartbeat = Date.now() - lastHeartbeat;
+        const currentTimeout = isThinking ? THINKING_TIMEOUT : STANDARD_TIMEOUT;
+        if (timeSinceLastHeartbeat > currentTimeout) {
+          await recoverStalledSession(currentSessionID, timeSinceLastHeartbeat, isThinking);
+        }
+      }, CHECK_INTERVAL);
+    }
+  };
+  const stopMonitoring = () => {
+    isMonitoring = false;
+    if (monitorTimer) {
+      clearInterval(monitorTimer);
+      monitorTimer = null;
+    }
+  };
+  const updateHeartbeat = (isThinkingUpdate) => {
+    if (isMonitoring) {
+      lastHeartbeat = Date.now();
+      if (isThinkingUpdate !== undefined) {
+        isThinking = isThinkingUpdate;
+      }
+    }
+  };
+  const recoverStalledSession = async (sessionID, stalledDuration, wasThinking) => {
+    stopMonitoring();
+    try {
+      const durationSec = Math.round(stalledDuration / 1000);
+      const typeStr = wasThinking ? "Thinking" : "Standard";
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Pulse Monitor: Cardiac Arrest",
+          message: `Session stalled (${typeStr}) for ${durationSec}s. Defibrillating...`,
+          variant: "error",
+          duration: 5000
+        }
+      }).catch(() => {});
+      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: { parts: [{ type: "text", text: "The connection was unstable and stalled. Please continue from where you left off." }] },
+        query: { directory: ctx.directory }
+      });
+      startMonitoring(sessionID);
+    } catch (err) {
+      console.error("[PulseMonitor] Recovery failed:", err);
+      stopMonitoring();
+    }
+  };
+  return {
+    event: async (input) => {
+      const { event } = input;
+      const props = event.properties;
+      if (event.type === "session.updated" || event.type === "message.part.updated") {
+        const sessionID = props?.info?.id || props?.sessionID;
+        if (sessionID) {
+          if (!isMonitoring)
+            startMonitoring(sessionID);
+          let thinkingUpdate = undefined;
+          if (event.type === "message.part.updated") {
+            const part = props?.part;
+            if (part) {
+              const THINKING_TYPES2 = ["thinking", "redacted_thinking", "reasoning"];
+              if (THINKING_TYPES2.includes(part.type)) {
+                thinkingUpdate = true;
+              } else if (part.type === "text" || part.type === "tool_use") {
+                thinkingUpdate = false;
+              }
+            }
+          }
+          updateHeartbeat(thinkingUpdate);
+        }
+      } else if (event.type === "session.idle" || event.type === "session.error" || event.type === "session.stopped") {
+        stopMonitoring();
+      }
+    },
+    "tool.execute.before": async () => {
+      stopMonitoring();
+    },
+    "tool.execute.after": async (input) => {
+      if (input.sessionID) {
+        startMonitoring(input.sessionID);
+      }
+    }
+  };
+}
 // src/features/terminal/title.ts
 var STATUS_ICONS = {
   ready: "",
@@ -1707,17 +1971,31 @@ var EXT_TO_LANG = {
   ".svelte": "svelte",
   ".astro": "astro",
   ".yaml": "yaml",
-  ".yml": "yaml"
+  ".yml": "yaml",
+  ".json": "json",
+  ".jsonc": "jsonc",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".less": "less",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".fish": "fish",
+  ".md": "markdown",
+  ".tf": "terraform",
+  ".tfvars": "terraform"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync4, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
-function loadJsonFile(path) {
-  if (!existsSync4(path))
+function loadJsonFile(path2) {
+  if (!existsSync5(path2))
     return null;
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    return JSON.parse(readFileSync2(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -1725,9 +2003,9 @@ function loadJsonFile(path) {
 function getConfigPaths() {
   const cwd = process.cwd();
   return {
-    project: join3(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join3(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join3(homedir2(), ".config", "opencode", "opencode.json")
+    project: join4(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join4(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join4(homedir2(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -1820,7 +2098,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync4(join3(p, cmd))) {
+    if (existsSync5(join4(p, cmd))) {
       return true;
     }
   }
@@ -1870,7 +2148,7 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn3 } = globalThis.Bun;
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { extname, resolve } from "path";
 class LSPServerManager {
   static instance;
@@ -2000,6 +2278,7 @@ class LSPClient {
   openedFiles = new Set;
   stderrBuffer = [];
   processExited = false;
+  diagnosticsStore = new Map;
   constructor(root, server) {
     this.root = root;
     this.server = server;
@@ -2124,7 +2403,11 @@ stderr: ${stderr}` : ""));
       this.buffer = this.buffer.slice(end);
       try {
         const msg = JSON.parse(content);
-        if ("id" in msg && "method" in msg) {
+        if ("method" in msg && !("id" in msg)) {
+          if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri) {
+            this.diagnosticsStore.set(msg.params.uri, msg.params.diagnostics ?? []);
+          }
+        } else if ("id" in msg && "method" in msg) {
           this.handleServerRequest(msg.id, msg.method, msg.params);
         } else if ("id" in msg && this.pending.has(msg.id)) {
           const handler = this.pending.get(msg.id);
@@ -2186,9 +2469,15 @@ ${msg}`);
 \r
 ${msg}`);
   }
-  handleServerRequest(id, method, _params) {
+  handleServerRequest(id, method, params) {
     if (method === "workspace/configuration") {
-      this.respond(id, [{}]);
+      const items = params?.items ?? [];
+      const result = items.map((item) => {
+        if (item.section === "json")
+          return { validate: { enable: true } };
+        return {};
+      });
+      this.respond(id, result);
     } else if (method === "client/registerCapability") {
       this.respond(id, null);
     } else if (method === "window/workDoneProgress/create") {
@@ -2250,14 +2539,16 @@ ${msg}`);
       ...this.server.initialization
     });
     this.notify("initialized");
-    this.notify("workspace/didChangeConfiguration", { settings: {} });
+    this.notify("workspace/didChangeConfiguration", {
+      settings: { json: { validate: { enable: true } } }
+    });
     await new Promise((r) => setTimeout(r, 300));
   }
   async openFile(filePath) {
     const absPath = resolve(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync2(absPath, "utf-8");
+    const text = readFileSync3(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -2308,11 +2599,18 @@ ${msg}`);
   }
   async diagnostics(filePath) {
     const absPath = resolve(filePath);
+    const uri = `file://${absPath}`;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
-    return this.send("textDocument/diagnostic", {
-      textDocument: { uri: `file://${absPath}` }
-    });
+    try {
+      const result = await this.send("textDocument/diagnostic", {
+        textDocument: { uri }
+      });
+      if (result && typeof result === "object" && "items" in result) {
+        return result;
+      }
+    } catch {}
+    return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async prepareRename(filePath, line, character) {
     const absPath = resolve(filePath);
@@ -2360,20 +2658,21 @@ ${msg}`);
     this.proc?.kill();
     this.proc = null;
     this.processExited = true;
+    this.diagnosticsStore.clear();
   }
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve2 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve2(filePath);
-  if (!existsSync5(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync6(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync5(__require("path").join(dir, marker))) {
+      if (existsSync6(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -2487,12 +2786,22 @@ function formatPrepareRenameResult(result) {
   if ("defaultBehavior" in result) {
     return result.defaultBehavior ? "Rename supported (using default behavior)" : "Cannot rename at this position";
   }
-  const startLine = result.range.start.line + 1;
-  const startChar = result.range.start.character;
-  const endLine = result.range.end.line + 1;
-  const endChar = result.range.end.character;
-  const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
-  return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
+  if ("range" in result && result.range) {
+    const startLine = result.range.start.line + 1;
+    const startChar = result.range.start.character;
+    const endLine = result.range.end.line + 1;
+    const endChar = result.range.end.character;
+    const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
+    return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
+  }
+  if ("start" in result && "end" in result) {
+    const startLine = result.start.line + 1;
+    const startChar = result.start.character;
+    const endLine = result.end.line + 1;
+    const endChar = result.end.character;
+    return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}`;
+  }
+  return "Cannot rename at this position";
 }
 function formatCodeAction(action) {
   let result = `[${action.kind || "action"}] ${action.title}`;
@@ -2521,7 +2830,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync3(filePath, "utf-8");
+    let content = readFileSync4(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -2546,7 +2855,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync(filePath, lines.join(`
+    writeFileSync2(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -2577,7 +2886,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync(filePath, "", "utf-8");
+            writeFileSync2(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -2587,8 +2896,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync3(oldPath, "utf-8");
-            writeFileSync(newPath, content, "utf-8");
+            const content = readFileSync4(oldPath, "utf-8");
+            writeFileSync2(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -3368,10 +3677,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3730,11 +4039,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -3902,7 +4211,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path = []) => {
+  const processError = (error2, path2 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -3912,7 +4221,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3944,8 +4253,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15288,13 +15597,13 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname2, join as join5 } from "path";
-import { existsSync as existsSync7, statSync } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { existsSync as existsSync8, statSync } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, chmodSync as chmodSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, chmodSync as chmodSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -15320,19 +15629,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join4(homedir3(), "AppData", "Local");
-    return join4(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join5(homedir3(), "AppData", "Local");
+    return join5(base2, "oh-my-opencode", "bin");
   }
-  const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join4(homedir3(), ".cache");
-  return join4(base, "oh-my-opencode", "bin");
+  const xdgCache2 = process.env.XDG_CACHE_HOME;
+  const base = xdgCache2 || join5(homedir3(), ".cache");
+  return join5(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join4(getCacheDir2(), getBinaryName3());
-  return existsSync6(binaryPath) ? binaryPath : null;
+  const binaryPath = join5(getCacheDir2(), getBinaryName3());
+  return existsSync7(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn4([
@@ -15358,30 +15667,30 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName3();
-  const binaryPath = join4(cacheDir, binaryName);
-  if (existsSync6(binaryPath)) {
+  const binaryPath = join5(cacheDir, binaryName);
+  if (existsSync7(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os } = platformInfo;
-  const assetName = `app-${arch}-${os}.zip`;
+  const { arch, os: os2 } = platformInfo;
+  const assetName = `app-${arch}-${os2}.zip`;
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync6(cacheDir)) {
-      mkdirSync2(cacheDir, { recursive: true });
+    if (!existsSync7(cacheDir)) {
+      mkdirSync3(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join4(cacheDir, assetName);
+    const archivePath = join5(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync6(archivePath)) {
+    if (existsSync7(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync6(binaryPath)) {
+    if (process.platform !== "win32" && existsSync7(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -15432,8 +15741,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname2(cliPkgPath);
-    const sgPath = join5(cliDir, binaryName);
-    if (existsSync7(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join6(cliDir, binaryName);
+    if (existsSync8(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -15444,17 +15753,17 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname2(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join5(pkgDir, astGrepName);
-      if (existsSync7(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join6(pkgDir, astGrepName);
+      if (existsSync8(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path of homebrewPaths) {
-      if (existsSync7(path) && isValidBinary(path)) {
-        return path;
+    for (const path2 of homebrewPaths) {
+      if (existsSync8(path2) && isValidBinary(path2)) {
+        return path2;
       }
     }
   }
@@ -15472,8 +15781,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path) {
-  resolvedCliPath2 = path;
+function setSgCliPath(path2) {
+  resolvedCliPath2 = path2;
 }
 var SG_CLI_PATH = getSgCliPath();
 var CLI_LANGUAGES = [
@@ -15537,11 +15846,11 @@ var LANG_EXTENSIONS = {
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync8(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync9(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -15549,7 +15858,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync8(syncPath)) {
+    if (syncPath && existsSync9(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -15583,7 +15892,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync8(cliPath) && cliPath !== "sg") {
+  if (!existsSync9(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -16028,8 +16337,8 @@ var ast_grep_transform = tool({
 var {spawn: spawn6 } = globalThis.Bun;
 
 // src/tools/safe-grep/constants.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join6, dirname as dirname3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -16050,13 +16359,13 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join6(execDir, rgName),
-    join6(execDir, "bin", rgName),
-    join6(execDir, "..", "bin", rgName),
-    join6(execDir, "..", "libexec", rgName)
+    join7(execDir, rgName),
+    join7(execDir, "bin", rgName),
+    join7(execDir, "..", "bin", rgName),
+    join7(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync9(candidate)) {
+    if (existsSync10(candidate)) {
       return candidate;
     }
   }
@@ -16389,11 +16698,11 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 });
 // src/index.ts
 import * as fs3 from "fs";
-import * as path from "path";
+import * as path2 from "path";
 function loadPluginConfig(directory) {
   const configPaths = [
-    path.join(directory, "oh-my-opencode.json"),
-    path.join(directory, ".oh-my-opencode.json")
+    path2.join(directory, "oh-my-opencode.json"),
+    path2.join(directory, ".oh-my-opencode.json")
   ];
   for (const configPath of configPaths) {
     try {
@@ -16418,7 +16727,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
   const contextWindowMonitor = createContextWindowMonitorHook(ctx);
   const sessionRecovery = createSessionRecoveryHook(ctx);
+  const pulseMonitor = createPulseMonitorHook(ctx);
   const commentChecker = createCommentCheckerHooks();
+  const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
   updateTerminalTitle({ sessionId: "main" });
   const pluginConfig = loadPluginConfig(ctx.directory);
   let mainSessionID;
@@ -16444,6 +16755,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
     event: async (input) => {
       await todoContinuationEnforcer(input);
       await contextWindowMonitor.event(input);
+      await pulseMonitor.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
@@ -16526,6 +16838,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       }
     },
     "tool.execute.before": async (input, output) => {
+      await pulseMonitor["tool.execute.before"]();
       await commentChecker["tool.execute.before"](input, output);
       if (input.sessionID === mainSessionID) {
         updateTerminalTitle({
@@ -16538,6 +16851,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
       }
     },
     "tool.execute.after": async (input, output) => {
+      await pulseMonitor["tool.execute.after"](input);
+      await grepOutputTruncator["tool.execute.after"](input, output);
       await contextWindowMonitor["tool.execute.after"](input, output);
       await commentChecker["tool.execute.after"](input, output);
       if (input.sessionID === mainSessionID) {