oh-my-opencode 0.1.25 → 0.1.27

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]`
               }
             ]
           },
@@ -789,8 +784,11 @@ ${CONTEXT_REMINDER}
     event: eventHandler
   };
 }
-// src/hooks/session-recovery.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+// src/hooks/session-recovery/storage.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/hooks/session-recovery/constants.ts
 import { join } from "path";
 
 // node_modules/xdg-basedir/index.js
@@ -812,141 +810,36 @@ if (xdgConfig) {
   xdgConfigDirectories.unshift(xdgConfig);
 }
 
-// src/hooks/session-recovery.ts
+// src/hooks/session-recovery/constants.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 "";
-  if (typeof error === "string")
-    return error.toLowerCase();
-  const errorObj = error;
-  return (errorObj.data?.message || errorObj.message || "").toLowerCase();
-}
-function detectErrorType(error) {
-  const message = getErrorMessage(error);
-  if (message.includes("tool_use") && message.includes("tool_result")) {
-    return "tool_result_missing";
-  }
-  if (message.includes("thinking") && (message.includes("first block") || message.includes("must start with") || message.includes("preceeding"))) {
-    return "thinking_block_order";
-  }
-  if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
-    return "thinking_disabled_violation";
-  }
-  if (message.includes("non-empty content") || message.includes("must have non-empty content")) {
-    return "empty_content_message";
-  }
-  return null;
-}
-function extractToolUseIds(parts) {
-  return parts.filter((p) => p.type === "tool_use" && !!p.id).map((p) => p.id);
-}
-async function recoverToolResultMissing(client, sessionID, failedAssistantMsg) {
-  const parts = failedAssistantMsg.parts || [];
-  const toolUseIds = extractToolUseIds(parts);
-  if (toolUseIds.length === 0) {
-    return false;
-  }
-  const toolResultParts = toolUseIds.map((id) => ({
-    type: "tool_result",
-    tool_use_id: id,
-    content: "Operation cancelled by user (ESC pressed)"
-  }));
-  try {
-    await client.session.prompt({
-      path: { id: sessionID },
-      body: { parts: toolResultParts }
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function recoverThinkingBlockOrder(client, sessionID, failedAssistantMsg, directory) {
-  const messageID = failedAssistantMsg.info?.id;
-  if (!messageID) {
-    return false;
-  }
-  const existingParts = failedAssistantMsg.parts || [];
-  const patchedParts = [{ type: "thinking", thinking: "" }, ...existingParts];
-  try {
-    await client.message?.update?.({
-      path: { id: messageID },
-      body: { parts: patchedParts }
-    });
-    return true;
-  } catch {}
-  try {
-    await client.session.patch?.({
-      path: { id: sessionID },
-      body: {
-        messageID,
-        parts: patchedParts
-      }
-    });
-    return true;
-  } catch {}
-  return await fallbackRevertStrategy(client, sessionID, failedAssistantMsg, directory);
-}
-async function recoverThinkingDisabledViolation(client, sessionID, failedAssistantMsg) {
-  const messageID = failedAssistantMsg.info?.id;
-  if (!messageID) {
-    return false;
-  }
-  const existingParts = failedAssistantMsg.parts || [];
-  const strippedParts = existingParts.filter((p) => p.type !== "thinking" && p.type !== "redacted_thinking");
-  if (strippedParts.length === 0) {
-    return false;
-  }
-  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 {}
-  return false;
-}
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
 var META_TYPES = new Set(["step-start", "step-finish"]);
+var CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"]);
+
+// src/hooks/session-recovery/storage.ts
 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 (projectHash) {
-    return join(MESSAGE_STORAGE, projectHash, sessionID);
+  if (!existsSync(MESSAGE_STORAGE))
+    return "";
+  const directPath = join2(MESSAGE_STORAGE, sessionID);
+  if (existsSync(directPath)) {
+    return directPath;
   }
   for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID);
+    const sessionPath = join2(MESSAGE_STORAGE, dir, sessionID);
     if (existsSync(sessionPath)) {
       return sessionPath;
     }
   }
   return "";
 }
-function readMessagesFromStorage(sessionID) {
+function readMessages(sessionID) {
   const messageDir = getMessageDir(sessionID);
   if (!messageDir || !existsSync(messageDir))
     return [];
@@ -955,7 +848,7 @@ function readMessagesFromStorage(sessionID) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync(join(messageDir, file), "utf-8");
+      const content = readFileSync(join2(messageDir, file), "utf-8");
       messages.push(JSON.parse(content));
     } catch {
       continue;
@@ -963,8 +856,8 @@ function readMessagesFromStorage(sessionID) {
   }
   return messages.sort((a, b) => a.id.localeCompare(b.id));
 }
-function readPartsFromStorage(messageID) {
-  const partDir = join(PART_STORAGE, messageID);
+function readParts(messageID) {
+  const partDir = join2(PART_STORAGE, messageID);
   if (!existsSync(partDir))
     return [];
   const parts = [];
@@ -972,7 +865,7 @@ function readPartsFromStorage(messageID) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync(join(partDir, file), "utf-8");
+      const content = readFileSync(join2(partDir, file), "utf-8");
       parts.push(JSON.parse(content));
     } catch {
       continue;
@@ -980,8 +873,29 @@ function readPartsFromStorage(messageID) {
   }
   return parts;
 }
-function injectTextPartToStorage(sessionID, messageID, text) {
-  const partDir = join(PART_STORAGE, messageID);
+function hasContent(part) {
+  if (THINKING_TYPES.has(part.type))
+    return false;
+  if (META_TYPES.has(part.type))
+    return false;
+  if (part.type === "text") {
+    const textPart = part;
+    return !!textPart.text?.trim();
+  }
+  if (part.type === "tool" || part.type === "tool_use") {
+    return true;
+  }
+  if (part.type === "tool_result") {
+    return true;
+  }
+  return false;
+}
+function messageHasContent(messageID) {
+  const parts = readParts(messageID);
+  return parts.some(hasContent);
+}
+function injectTextPart(sessionID, messageID, text) {
+  const partDir = join2(PART_STORAGE, messageID);
   if (!existsSync(partDir)) {
     mkdirSync(partDir, { recursive: true });
   }
@@ -991,17 +905,19 @@ function injectTextPartToStorage(sessionID, messageID, text) {
     sessionID,
     messageID,
     type: "text",
-    text
+    text,
+    synthetic: true
   };
   try {
-    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync(join2(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
   }
 }
-function findEmptyContentMessageFromStorage(sessionID) {
-  const messages = readMessagesFromStorage(sessionID);
+function findEmptyMessages(sessionID) {
+  const messages = readMessages(sessionID);
+  const emptyIds = [];
   for (let i = 0;i < messages.length; i++) {
     const msg = messages[i];
     if (msg.role !== "assistant")
@@ -1009,72 +925,187 @@ function findEmptyContentMessageFromStorage(sessionID) {
     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;
+    if (!messageHasContent(msg.id)) {
+      emptyIds.push(msg.id);
     }
   }
-  return null;
+  return emptyIds;
 }
-async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory) {
-  const emptyMessageID = findEmptyContentMessageFromStorage(sessionID) || failedAssistantMsg.info?.id;
-  if (!emptyMessageID)
-    return false;
-  return injectTextPartToStorage(sessionID, emptyMessageID, "(interrupted)");
+function findMessagesWithThinkingBlocks(sessionID) {
+  const messages = readMessages(sessionID);
+  const result = [];
+  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 = readParts(msg.id);
+    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type));
+    if (hasThinking) {
+      result.push(msg.id);
+    }
+  }
+  return result;
 }
-async function fallbackRevertStrategy(client, sessionID, failedAssistantMsg, directory) {
-  const parentMsgID = failedAssistantMsg.info?.parentID;
-  const messagesResp = await client.session.messages({
-    path: { id: sessionID },
-    query: { directory }
-  });
-  const msgs = messagesResp.data;
-  if (!msgs || msgs.length === 0) {
-    return false;
+function findMessagesWithOrphanThinking(sessionID) {
+  const messages = readMessages(sessionID);
+  const result = [];
+  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 = readParts(msg.id);
+    if (parts.length === 0)
+      continue;
+    const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id));
+    const firstPart = sortedParts[0];
+    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type));
+    const firstIsThinking = THINKING_TYPES.has(firstPart.type);
+    if (hasThinking && !firstIsThinking) {
+      result.push(msg.id);
+    }
   }
-  let targetUserMsg = null;
-  if (parentMsgID) {
-    targetUserMsg = msgs.find((m) => m.info?.id === parentMsgID) ?? null;
+  return result;
+}
+function prependThinkingPart(sessionID, messageID) {
+  const partDir = join2(PART_STORAGE, messageID);
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true });
   }
-  if (!targetUserMsg) {
-    for (let i = msgs.length - 1;i >= 0; i--) {
-      if (msgs[i].info?.role === "user") {
-        targetUserMsg = msgs[i];
-        break;
+  const partId = `prt_0000000000_thinking`;
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "thinking",
+    thinking: "",
+    synthetic: true
+  };
+  try {
+    writeFileSync(join2(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stripThinkingParts(messageID) {
+  const partDir = join2(PART_STORAGE, messageID);
+  if (!existsSync(partDir))
+    return false;
+  let anyRemoved = false;
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const filePath = join2(partDir, file);
+      const content = readFileSync(filePath, "utf-8");
+      const part = JSON.parse(content);
+      if (THINKING_TYPES.has(part.type)) {
+        unlinkSync(filePath);
+        anyRemoved = true;
       }
+    } catch {
+      continue;
     }
   }
-  if (!targetUserMsg?.parts?.length) {
+  return anyRemoved;
+}
+
+// src/hooks/session-recovery/index.ts
+function getErrorMessage(error) {
+  if (!error)
+    return "";
+  if (typeof error === "string")
+    return error.toLowerCase();
+  const errorObj = error;
+  return (errorObj.data?.message || errorObj.error?.message || errorObj.message || "").toLowerCase();
+}
+function detectErrorType(error) {
+  const message = getErrorMessage(error);
+  if (message.includes("tool_use") && message.includes("tool_result")) {
+    return "tool_result_missing";
+  }
+  if (message.includes("thinking") && (message.includes("first block") || message.includes("must start with") || message.includes("preceeding"))) {
+    return "thinking_block_order";
+  }
+  if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
+    return "thinking_disabled_violation";
+  }
+  if (message.includes("non-empty content") || message.includes("must have non-empty content")) {
+    return "empty_content_message";
+  }
+  return null;
+}
+function extractToolUseIds(parts) {
+  return parts.filter((p) => p.type === "tool_use" && !!p.id).map((p) => p.id);
+}
+async function recoverToolResultMissing(client, sessionID, failedAssistantMsg) {
+  const parts = failedAssistantMsg.parts || [];
+  const toolUseIds = extractToolUseIds(parts);
+  if (toolUseIds.length === 0) {
     return false;
   }
-  await client.session.revert({
-    path: { id: sessionID },
-    body: { messageID: targetUserMsg.info?.id ?? "" },
-    query: { directory }
-  });
-  const textParts = targetUserMsg.parts.filter((p) => p.type === "text" && p.text).map((p) => ({ type: "text", text: p.text ?? "" }));
-  if (textParts.length === 0) {
+  const toolResultParts = toolUseIds.map((id) => ({
+    type: "tool_result",
+    tool_use_id: id,
+    content: "Operation cancelled by user (ESC pressed)"
+  }));
+  try {
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: { parts: toolResultParts }
+    });
+    return true;
+  } catch {
     return false;
   }
-  await client.session.prompt({
-    path: { id: sessionID },
-    body: { parts: textParts },
-    query: { directory }
-  });
-  return true;
+}
+async function recoverThinkingBlockOrder(_client, sessionID, _failedAssistantMsg, _directory) {
+  const orphanMessages = findMessagesWithOrphanThinking(sessionID);
+  if (orphanMessages.length === 0) {
+    return false;
+  }
+  let anySuccess = false;
+  for (const messageID of orphanMessages) {
+    if (prependThinkingPart(sessionID, messageID)) {
+      anySuccess = true;
+    }
+  }
+  return anySuccess;
+}
+async function recoverThinkingDisabledViolation(_client, sessionID, _failedAssistantMsg) {
+  const messagesWithThinking = findMessagesWithThinkingBlocks(sessionID);
+  if (messagesWithThinking.length === 0) {
+    return false;
+  }
+  let anySuccess = false;
+  for (const messageID of messagesWithThinking) {
+    if (stripThinkingParts(messageID)) {
+      anySuccess = true;
+    }
+  }
+  return anySuccess;
+}
+async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory) {
+  const emptyMessageIDs = findEmptyMessages(sessionID);
+  if (emptyMessageIDs.length === 0) {
+    const fallbackID = failedAssistantMsg.info?.id;
+    if (!fallbackID)
+      return false;
+    return injectTextPart(sessionID, fallbackID, "(interrupted)");
+  }
+  let anySuccess = false;
+  for (const messageID of emptyMessageIDs) {
+    if (injectTextPart(sessionID, messageID, "(interrupted)")) {
+      anySuccess = true;
+    }
+  }
+  return anySuccess;
 }
 function createSessionRecoveryHook(ctx) {
   const processingErrors = new Set;
@@ -1122,14 +1153,12 @@ function createSessionRecoveryHook(ctx) {
         tool_result_missing: "Injecting cancelled tool results...",
         thinking_block_order: "Fixing message structure...",
         thinking_disabled_violation: "Stripping thinking blocks...",
-        empty_content_message: "Deleting empty message..."
+        empty_content_message: "Fixing empty message..."
       };
-      const toastTitle = toastTitles[errorType];
-      const toastMessage = toastMessages[errorType];
       await ctx.client.tui.showToast({
         body: {
-          title: toastTitle,
-          message: toastMessage,
+          title: toastTitles[errorType],
+          message: toastMessages[errorType],
           variant: "warning",
           duration: 3000
         }
@@ -1160,14 +1189,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 join3 } from "path";
+import { dirname, join as join4 } 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 as existsSync2, mkdirSync as mkdirSync2, chmodSync, unlinkSync, appendFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync, unlinkSync as unlinkSync2, appendFileSync } from "fs";
+import { join as join3 } from "path";
 import { homedir } from "os";
 import { createRequire } from "module";
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
@@ -1189,14 +1218,14 @@ var PLATFORM_MAP = {
 };
 function getCacheDir() {
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join2(homedir(), ".cache");
-  return join2(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join3(homedir(), ".cache");
+  return join3(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join2(getCacheDir(), getBinaryName());
+  const binaryPath = join3(getCacheDir(), getBinaryName());
   return existsSync2(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
@@ -1244,7 +1273,7 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join2(cacheDir, binaryName);
+  const binaryPath = join3(cacheDir, binaryName);
   if (existsSync2(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
@@ -1263,7 +1292,7 @@ async function downloadCommentChecker() {
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join2(cacheDir, assetName);
+    const archivePath = join3(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -1273,7 +1302,7 @@ async function downloadCommentChecker() {
       await extractZip(archivePath, cacheDir);
     }
     if (existsSync2(archivePath)) {
-      unlinkSync(archivePath);
+      unlinkSync2(archivePath);
     }
     if (process.platform !== "win32" && existsSync2(binaryPath)) {
       chmodSync(binaryPath, 493);
@@ -1328,7 +1357,7 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join3(cliDir, "bin", binaryName);
+    const binaryPath = join4(cliDir, "bin", binaryName);
     if (existsSync3(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
@@ -1342,7 +1371,7 @@ function findCommentCheckerPathSync() {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname(pkgPath);
-      const binaryPath = join3(pkgDir, "bin", binaryName);
+      const binaryPath = join4(pkgDir, "bin", binaryName);
       if (existsSync3(binaryPath)) {
         debugLog2("found binary in platform package:", binaryPath);
         return binaryPath;
@@ -1566,6 +1595,370 @@ ${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/hooks/directory-agents-injector/index.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join7, resolve } from "path";
+
+// src/hooks/directory-agents-injector/storage.ts
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  unlinkSync as unlinkSync3
+} from "fs";
+import { join as join6 } from "path";
+
+// src/hooks/directory-agents-injector/constants.ts
+import { join as join5 } from "path";
+var OPENCODE_STORAGE2 = join5(xdgData ?? "", "opencode", "storage");
+var AGENTS_INJECTOR_STORAGE = join5(OPENCODE_STORAGE2, "directory-agents");
+var AGENTS_FILENAME = "AGENTS.md";
+
+// src/hooks/directory-agents-injector/storage.ts
+function getStoragePath(sessionID) {
+  return join6(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
+}
+function loadInjectedPaths(sessionID) {
+  const filePath = getStoragePath(sessionID);
+  if (!existsSync5(filePath))
+    return new Set;
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return new Set(data.injectedPaths);
+  } catch {
+    return new Set;
+  }
+}
+function saveInjectedPaths(sessionID, paths) {
+  if (!existsSync5(AGENTS_INJECTOR_STORAGE)) {
+    mkdirSync3(AGENTS_INJECTOR_STORAGE, { recursive: true });
+  }
+  const data = {
+    sessionID,
+    injectedPaths: [...paths],
+    updatedAt: Date.now()
+  };
+  writeFileSync2(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+}
+function clearInjectedPaths(sessionID) {
+  const filePath = getStoragePath(sessionID);
+  if (existsSync5(filePath)) {
+    unlinkSync3(filePath);
+  }
+}
+
+// src/hooks/directory-agents-injector/index.ts
+function createDirectoryAgentsInjectorHook(ctx) {
+  const sessionCaches = new Map;
+  function getSessionCache(sessionID) {
+    if (!sessionCaches.has(sessionID)) {
+      sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
+    }
+    return sessionCaches.get(sessionID);
+  }
+  function resolveFilePath(title) {
+    if (!title)
+      return null;
+    if (title.startsWith("/"))
+      return title;
+    return resolve(ctx.directory, title);
+  }
+  function findAgentsMdUp(startDir) {
+    const found = [];
+    let current = startDir;
+    while (true) {
+      const agentsPath = join7(current, AGENTS_FILENAME);
+      if (existsSync6(agentsPath)) {
+        found.push(agentsPath);
+      }
+      if (current === ctx.directory)
+        break;
+      const parent = dirname2(current);
+      if (parent === current)
+        break;
+      if (!parent.startsWith(ctx.directory))
+        break;
+      current = parent;
+    }
+    return found.reverse();
+  }
+  const toolExecuteAfter = async (input, output) => {
+    if (input.tool.toLowerCase() !== "read")
+      return;
+    const filePath = resolveFilePath(output.title);
+    if (!filePath)
+      return;
+    const dir = dirname2(filePath);
+    const cache = getSessionCache(input.sessionID);
+    const agentsPaths = findAgentsMdUp(dir);
+    const toInject = [];
+    for (const agentsPath of agentsPaths) {
+      const agentsDir = dirname2(agentsPath);
+      if (cache.has(agentsDir))
+        continue;
+      try {
+        const content = readFileSync3(agentsPath, "utf-8");
+        toInject.push({ path: agentsPath, content });
+        cache.add(agentsDir);
+      } catch {}
+    }
+    if (toInject.length === 0)
+      return;
+    for (const { path: path2, content } of toInject) {
+      output.output += `
+
+[Directory Context: ${path2}]
+${content}`;
+    }
+    saveInjectedPaths(input.sessionID, cache);
+  };
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        sessionCaches.delete(sessionInfo.id);
+        clearInjectedPaths(sessionInfo.id);
+      }
+    }
+    if (event.type === "session.compacted") {
+      const sessionID = props?.sessionID ?? props?.info?.id;
+      if (sessionID) {
+        sessionCaches.delete(sessionID);
+        clearInjectedPaths(sessionID);
+      }
+    }
+  };
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler
+  };
+}
+// src/hooks/empty-task-response-detector.ts
+var EMPTY_RESPONSE_WARNING = `[Task Empty Response Warning]
+
+Task invocation completed but returned no response. This indicates the agent either:
+- Failed to execute properly
+- Did not terminate correctly
+- Returned an empty result
+
+Note: The call has already completed - you are NOT waiting for a response. Proceed accordingly.`;
+function createEmptyTaskResponseDetectorHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (input.tool !== "Task")
+        return;
+      const responseText = output.output?.trim() ?? "";
+      if (responseText === "") {
+        output.output = EMPTY_RESPONSE_WARNING;
+      }
+    }
+  };
+}
 // src/features/terminal/title.ts
 var STATUS_ICONS = {
   ready: "",
@@ -1774,17 +2167,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 existsSync5, readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { join as join8 } from "path";
 import { homedir as homedir2 } from "os";
 function loadJsonFile(path2) {
-  if (!existsSync5(path2))
+  if (!existsSync7(path2))
     return null;
   try {
-    return JSON.parse(readFileSync2(path2, "utf-8"));
+    return JSON.parse(readFileSync4(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -1792,9 +2199,9 @@ function loadJsonFile(path2) {
 function getConfigPaths() {
   const cwd = process.cwd();
   return {
-    project: join4(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join4(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join4(homedir2(), ".config", "opencode", "opencode.json")
+    project: join8(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join8(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join8(homedir2(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -1887,7 +2294,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync5(join4(p, cmd))) {
+    if (existsSync7(join8(p, cmd))) {
       return true;
     }
   }
@@ -1937,8 +2344,8 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn3 } = globalThis.Bun;
-import { readFileSync as readFileSync3 } from "fs";
-import { extname, resolve } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { extname, resolve as resolve2 } from "path";
 class LSPServerManager {
   static instance;
   clients = new Map;
@@ -2067,6 +2474,7 @@ class LSPClient {
   openedFiles = new Set;
   stderrBuffer = [];
   processExited = false;
+  diagnosticsStore = new Map;
   constructor(root, server) {
     this.root = root;
     this.server = server;
@@ -2087,7 +2495,7 @@ class LSPClient {
     }
     this.startReading();
     this.startStderrReading();
-    await new Promise((resolve2) => setTimeout(resolve2, 100));
+    await new Promise((resolve3) => setTimeout(resolve3, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -2191,7 +2599,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);
@@ -2220,8 +2632,8 @@ stderr: ${stderr}` : ""));
 \r
 `;
     this.proc.stdin.write(header + msg);
-    return new Promise((resolve2, reject) => {
-      this.pending.set(id, { resolve: resolve2, reject });
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
       setTimeout(() => {
         if (this.pending.has(id)) {
           this.pending.delete(id);
@@ -2253,9 +2665,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") {
@@ -2317,14 +2735,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);
+    const absPath = resolve2(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync3(absPath, "utf-8");
+    const text = readFileSync5(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -2339,7 +2759,7 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 1000));
   }
   async hover(filePath, line, character) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/hover", {
       textDocument: { uri: `file://${absPath}` },
@@ -2347,7 +2767,7 @@ ${msg}`);
     });
   }
   async definition(filePath, line, character) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/definition", {
       textDocument: { uri: `file://${absPath}` },
@@ -2355,7 +2775,7 @@ ${msg}`);
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/references", {
       textDocument: { uri: `file://${absPath}` },
@@ -2364,7 +2784,7 @@ ${msg}`);
     });
   }
   async documentSymbols(filePath) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/documentSymbol", {
       textDocument: { uri: `file://${absPath}` }
@@ -2374,15 +2794,22 @@ ${msg}`);
     return this.send("workspace/symbol", { query });
   }
   async diagnostics(filePath) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(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);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/prepareRename", {
       textDocument: { uri: `file://${absPath}` },
@@ -2390,7 +2817,7 @@ ${msg}`);
     });
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/rename", {
       textDocument: { uri: `file://${absPath}` },
@@ -2399,7 +2826,7 @@ ${msg}`);
     });
   }
   async codeAction(filePath, startLine, startChar, endLine, endChar, only) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/codeAction", {
       textDocument: { uri: `file://${absPath}` },
@@ -2427,29 +2854,30 @@ ${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 existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { extname as extname2, resolve as resolve3 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 function findWorkspaceRoot(filePath) {
-  let dir = resolve2(filePath);
-  if (!existsSync6(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  let dir = resolve3(filePath);
+  if (!existsSync8(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 (existsSync6(__require("path").join(dir, marker))) {
+      if (existsSync8(__require("path").join(dir, marker))) {
         return dir;
       }
     }
     dir = __require("path").dirname(dir);
   }
-  return __require("path").dirname(resolve2(filePath));
+  return __require("path").dirname(resolve3(filePath));
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve2(filePath);
+  const absPath = resolve3(filePath);
   const ext = extname2(absPath);
   const server = findServerForExtension(ext);
   if (!server) {
@@ -2598,7 +3026,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync4(filePath, "utf-8");
+    let content = readFileSync6(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -2623,7 +3051,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync2(filePath, lines.join(`
+    writeFileSync3(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -2654,7 +3082,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync2(filePath, "", "utf-8");
+            writeFileSync3(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -2664,8 +3092,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync4(oldPath, "utf-8");
-            writeFileSync2(newPath, content, "utf-8");
+            const content = readFileSync6(oldPath, "utf-8");
+            writeFileSync3(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -15365,13 +15793,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 join6 } from "path";
-import { existsSync as existsSync8, statSync } from "fs";
+import { dirname as dirname3, join as join10 } from "path";
+import { existsSync as existsSync10, statSync } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, chmodSync as chmodSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, chmodSync as chmodSync2, unlinkSync as unlinkSync4 } from "fs";
+import { join as join9 } from "path";
 import { homedir as homedir3 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -15397,19 +15825,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join5(homedir3(), "AppData", "Local");
-    return join5(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join9(homedir3(), "AppData", "Local");
+    return join9(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join5(homedir3(), ".cache");
-  return join5(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join9(homedir3(), ".cache");
+  return join9(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join5(getCacheDir2(), getBinaryName3());
-  return existsSync7(binaryPath) ? binaryPath : null;
+  const binaryPath = join9(getCacheDir2(), getBinaryName3());
+  return existsSync9(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn4([
@@ -15435,8 +15863,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName3();
-  const binaryPath = join5(cacheDir, binaryName);
-  if (existsSync7(binaryPath)) {
+  const binaryPath = join9(cacheDir, binaryName);
+  if (existsSync9(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os2 } = platformInfo;
@@ -15444,21 +15872,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync7(cacheDir)) {
-      mkdirSync3(cacheDir, { recursive: true });
+    if (!existsSync9(cacheDir)) {
+      mkdirSync4(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join5(cacheDir, assetName);
+    const archivePath = join9(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync7(archivePath)) {
-      unlinkSync2(archivePath);
+    if (existsSync9(archivePath)) {
+      unlinkSync4(archivePath);
     }
-    if (process.platform !== "win32" && existsSync7(binaryPath)) {
+    if (process.platform !== "win32" && existsSync9(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -15508,9 +15936,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname2(cliPkgPath);
-    const sgPath = join6(cliDir, binaryName);
-    if (existsSync8(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname3(cliPkgPath);
+    const sgPath = join10(cliDir, binaryName);
+    if (existsSync10(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -15519,10 +15947,10 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire4(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname2(pkgPath);
+      const pkgDir = dirname3(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join6(pkgDir, astGrepName);
-      if (existsSync8(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join10(pkgDir, astGrepName);
+      if (existsSync10(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -15530,7 +15958,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path2 of homebrewPaths) {
-      if (existsSync8(path2) && isValidBinary(path2)) {
+      if (existsSync10(path2) && isValidBinary(path2)) {
         return path2;
       }
     }
@@ -15614,11 +16042,11 @@ var LANG_EXTENSIONS = {
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync9(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync11(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -15626,7 +16054,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync9(syncPath)) {
+    if (syncPath && existsSync11(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -15660,7 +16088,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync9(cliPath) && cliPath !== "sg") {
+  if (!existsSync11(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -16101,12 +16529,12 @@ var ast_grep_transform = tool({
     }
   }
 });
-// src/tools/safe-grep/cli.ts
+// src/tools/grep/cli.ts
 var {spawn: spawn6 } = globalThis.Bun;
 
-// src/tools/safe-grep/constants.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+// src/tools/grep/constants.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join11, dirname as dirname4 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -16123,17 +16551,17 @@ function findExecutable(name) {
 }
 function getOpenCodeBundledRg() {
   const execPath = process.execPath;
-  const execDir = dirname3(execPath);
+  const execDir = dirname4(execPath);
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join7(execDir, rgName),
-    join7(execDir, "bin", rgName),
-    join7(execDir, "..", "bin", rgName),
-    join7(execDir, "..", "libexec", rgName)
+    join11(execDir, rgName),
+    join11(execDir, "bin", rgName),
+    join11(execDir, "..", "bin", rgName),
+    join11(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync10(candidate)) {
+    if (existsSync12(candidate)) {
       return candidate;
     }
   }
@@ -16175,7 +16603,7 @@ var RG_SAFETY_FLAGS = [
 ];
 var GREP_SAFETY_FLAGS = ["-n", "-H", "--color=never"];
 
-// src/tools/safe-grep/cli.ts
+// src/tools/grep/cli.ts
 function buildRgArgs(options) {
   const args = [
     ...RG_SAFETY_FLAGS,
@@ -16319,7 +16747,7 @@ async function runRg(options) {
   }
 }
 
-// src/tools/safe-grep/utils.ts
+// src/tools/grep/utils.ts
 function formatGrepResult(result) {
   if (result.error) {
     return `Error: ${result.error}`;
@@ -16350,8 +16778,8 @@ function formatGrepResult(result) {
 `);
 }
 
-// src/tools/safe-grep/tools.ts
-var safe_grep = tool({
+// src/tools/grep/tools.ts
+var grep = tool({
   description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
   args: {
     pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
@@ -16375,6 +16803,162 @@ var safe_grep = tool({
   }
 });
 
+// src/tools/glob/cli.ts
+var {spawn: spawn7 } = globalThis.Bun;
+
+// src/tools/glob/constants.ts
+var DEFAULT_TIMEOUT_MS3 = 60000;
+var DEFAULT_LIMIT = 100;
+var DEFAULT_MAX_DEPTH2 = 20;
+var DEFAULT_MAX_OUTPUT_BYTES3 = 10 * 1024 * 1024;
+var RG_FILES_FLAGS = [
+  "--files",
+  "--color=never",
+  "--glob=!.git/*"
+];
+
+// src/tools/glob/cli.ts
+import { stat } from "fs/promises";
+function buildRgArgs2(options) {
+  const args = [
+    ...RG_FILES_FLAGS,
+    `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH2, DEFAULT_MAX_DEPTH2)}`
+  ];
+  if (options.hidden)
+    args.push("--hidden");
+  if (options.noIgnore)
+    args.push("--no-ignore");
+  args.push(`--glob=${options.pattern}`);
+  return args;
+}
+function buildFindArgs(options) {
+  const args = ["."];
+  const maxDepth = Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH2, DEFAULT_MAX_DEPTH2);
+  args.push("-maxdepth", String(maxDepth));
+  args.push("-type", "f");
+  args.push("-name", options.pattern);
+  if (!options.hidden) {
+    args.push("-not", "-path", "*/.*");
+  }
+  return args;
+}
+async function getFileMtime(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.mtime.getTime();
+  } catch {
+    return 0;
+  }
+}
+async function runRgFiles(options) {
+  const cli = resolveGrepCli();
+  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
+  const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
+  const isRg = cli.backend === "rg";
+  const args = isRg ? buildRgArgs2(options) : buildFindArgs(options);
+  const paths = options.paths?.length ? options.paths : ["."];
+  if (isRg) {
+    args.push(...paths);
+  }
+  const cwd = paths[0] || ".";
+  const proc = spawn7([cli.path, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: isRg ? undefined : cwd
+  });
+  const timeoutPromise = new Promise((_, reject) => {
+    const id = setTimeout(() => {
+      proc.kill();
+      reject(new Error(`Glob search timeout after ${timeout}ms`));
+    }, timeout);
+    proc.exited.then(() => clearTimeout(id));
+  });
+  try {
+    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    if (exitCode > 1 && stderr.trim()) {
+      return {
+        files: [],
+        totalFiles: 0,
+        truncated: false,
+        error: stderr.trim()
+      };
+    }
+    const truncatedOutput = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES3;
+    const outputToProcess = truncatedOutput ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES3) : stdout;
+    const lines = outputToProcess.trim().split(`
+`).filter(Boolean);
+    const files = [];
+    let truncated = false;
+    for (const line of lines) {
+      if (files.length >= limit) {
+        truncated = true;
+        break;
+      }
+      const filePath = isRg ? line : `${cwd}/${line}`;
+      const mtime = await getFileMtime(filePath);
+      files.push({ path: filePath, mtime });
+    }
+    files.sort((a, b) => b.mtime - a.mtime);
+    return {
+      files,
+      totalFiles: files.length,
+      truncated: truncated || truncatedOutput
+    };
+  } catch (e) {
+    return {
+      files: [],
+      totalFiles: 0,
+      truncated: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+
+// src/tools/glob/utils.ts
+function formatGlobResult(result) {
+  if (result.error) {
+    return `Error: ${result.error}`;
+  }
+  if (result.files.length === 0) {
+    return "No files found";
+  }
+  const lines = [];
+  lines.push(`Found ${result.totalFiles} file(s)`);
+  lines.push("");
+  for (const file2 of result.files) {
+    lines.push(file2.path);
+  }
+  if (result.truncated) {
+    lines.push("");
+    lines.push("(Results are truncated. Consider using a more specific path or pattern.)");
+  }
+  return lines.join(`
+`);
+}
+
+// src/tools/glob/tools.ts
+var glob = tool({
+  description: "Fast file pattern matching tool with safety limits (60s timeout, 100 file limit). " + 'Supports glob patterns like "**/*.js" or "src/**/*.ts". ' + "Returns matching file paths sorted by modification time. " + "Use this tool when you need to find files by name patterns.",
+  args: {
+    pattern: tool.schema.string().describe("The glob pattern to match files against"),
+    path: tool.schema.string().optional().describe("The directory to search in. If not specified, the current working directory will be used. " + 'IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - ' + "simply omit it for the default behavior. Must be a valid directory path if provided.")
+  },
+  execute: async (args) => {
+    try {
+      const paths = args.path ? [args.path] : undefined;
+      const result = await runRgFiles({
+        pattern: args.pattern,
+        paths
+      });
+      return formatGlobResult(result);
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+});
+
 // src/tools/index.ts
 var builtinTools = {
   lsp_hover,
@@ -16390,7 +16974,8 @@ var builtinTools = {
   lsp_code_action_resolve,
   ast_grep_search,
   ast_grep_replace,
-  safe_grep
+  grep,
+  glob
 };
 
 // src/mcp/websearch-exa.ts
@@ -16495,7 +17080,11 @@ 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);
+  const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
+  const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
   updateTerminalTitle({ sessionId: "main" });
   const pluginConfig = loadPluginConfig(ctx.directory);
   let mainSessionID;
@@ -16510,8 +17099,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
         ...agents
       };
       config3.tools = {
-        ...config3.tools,
-        grep: false
+        ...config3.tools
       };
       config3.mcp = {
         ...config3.mcp,
@@ -16521,6 +17109,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
     event: async (input) => {
       await todoContinuationEnforcer(input);
       await contextWindowMonitor.event(input);
+      await pulseMonitor.event(input);
+      await directoryAgentsInjector.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
@@ -16603,6 +17193,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({
@@ -16615,8 +17206,12 @@ 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);
+      await directoryAgentsInjector["tool.execute.after"](input, output);
+      await emptyTaskResponseDetector["tool.execute.after"](input, output);
       if (input.sessionID === mainSessionID) {
         updateTerminalTitle({
           sessionId: input.sessionID,