oh-my-opencode 0.4.0 → 0.4.1

package/dist/index.js

@@ -2358,1344 +2358,1701 @@ STOP HERE - DO NOT CONTINUE TO NEXT TASK
 You are a technical writer who creates documentation that developers actually want to read.
 </guide>`
 };
-// src/agents/utils.ts
-var allBuiltinAgents = {
-  oracle: oracleAgent,
-  librarian: librarianAgent,
-  explore: exploreAgent,
-  "frontend-ui-ux-engineer": frontendUiUxEngineerAgent,
-  "document-writer": documentWriterAgent
-};
-function mergeAgentConfig(base, override) {
-  return {
-    ...base,
-    ...override,
-    tools: override.tools !== undefined ? { ...base.tools ?? {}, ...override.tools } : base.tools,
-    permission: override.permission !== undefined ? { ...base.permission ?? {}, ...override.permission } : base.permission
-  };
-}
-function createBuiltinAgents(disabledAgents = [], agentOverrides = {}) {
-  const result = {};
-  for (const [name, config] of Object.entries(allBuiltinAgents)) {
-    const agentName = name;
-    if (disabledAgents.includes(agentName)) {
-      continue;
-    }
-    const override = agentOverrides[agentName];
-    if (override) {
-      result[name] = mergeAgentConfig(config, override);
-    } else {
-      result[name] = config;
+// src/shared/frontmatter.ts
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const yamlContent = match[1];
+  const body = match[2];
+  const data = {};
+  for (const line of yamlContent.split(`
+`)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex !== -1) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value === "true")
+        value = true;
+      else if (value === "false")
+        value = false;
+      data[key] = value;
     }
   }
-  return result;
+  return { data, body };
 }
-// src/hooks/todo-continuation-enforcer.ts
-var CONTINUATION_PROMPT = `[SYSTEM REMINDER - TODO CONTINUATION]
-
-Incomplete tasks remain in your todo list. Continue working on the next pending task.
-
-- 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;
-  if (typeof error === "object") {
-    const errObj = error;
-    const name = errObj.name;
-    const message = errObj.message?.toLowerCase() ?? "";
-    if (name === "MessageAbortedError" || name === "AbortError")
-      return true;
-    if (name === "DOMException" && message.includes("abort"))
-      return true;
-    if (message.includes("aborted") || message.includes("cancelled") || message.includes("interrupted"))
-      return true;
+// src/shared/command-executor.ts
+import { spawn } from "child_process";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+var DEFAULT_ZSH_PATHS = ["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh"];
+function findZshPath(customZshPath) {
+  if (customZshPath && existsSync(customZshPath)) {
+    return customZshPath;
   }
-  if (typeof error === "string") {
-    const lower = error.toLowerCase();
-    return lower.includes("abort") || lower.includes("cancel") || lower.includes("interrupt");
+  for (const path of DEFAULT_ZSH_PATHS) {
+    if (existsSync(path)) {
+      return path;
+    }
   }
-  return false;
+  return null;
 }
-function createTodoContinuationEnforcer(ctx) {
-  const remindedSessions = new Set;
-  const interruptedSessions = new Set;
-  const errorSessions = new Set;
-  const pendingTimers = new Map;
-  return async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.error") {
-      const sessionID = props?.sessionID;
-      if (sessionID) {
-        errorSessions.add(sessionID);
-        if (detectInterrupt(props?.error)) {
-          interruptedSessions.add(sessionID);
-        }
-        const timer = pendingTimers.get(sessionID);
-        if (timer) {
-          clearTimeout(timer);
-          pendingTimers.delete(sessionID);
-        }
-      }
-      return;
-    }
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID;
-      if (!sessionID)
-        return;
-      const existingTimer = pendingTimers.get(sessionID);
-      if (existingTimer) {
-        clearTimeout(existingTimer);
-      }
-      const timer = setTimeout(async () => {
-        pendingTimers.delete(sessionID);
-        const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
-        interruptedSessions.delete(sessionID);
-        errorSessions.delete(sessionID);
-        if (shouldBypass) {
-          return;
-        }
-        if (remindedSessions.has(sessionID)) {
-          return;
-        }
-        let todos = [];
-        try {
-          const response = await ctx.client.session.todo({
-            path: { id: sessionID }
-          });
-          todos = response.data ?? response;
-        } catch {
-          return;
-        }
-        if (!todos || todos.length === 0) {
-          return;
-        }
-        const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
-        if (incomplete.length === 0) {
-          return;
-        }
-        remindedSessions.add(sessionID);
-        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
-          remindedSessions.delete(sessionID);
-          return;
-        }
-        try {
-          await ctx.client.session.prompt({
-            path: { id: sessionID },
-            body: {
-              parts: [
-                {
-                  type: "text",
-                  text: `${CONTINUATION_PROMPT}
-
-[Status: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.length} remaining]`
-                }
-              ]
-            },
-            query: { directory: ctx.directory }
-          });
-        } catch {
-          remindedSessions.delete(sessionID);
-        }
-      }, 200);
-      pendingTimers.set(sessionID, timer);
+var execAsync = promisify(exec);
+async function executeHookCommand(command, stdin, cwd, options) {
+  const home = process.env.HOME ?? "";
+  let expandedCommand = command.replace(/^~(?=\/|$)/g, home).replace(/\s~(?=\/)/g, ` ${home}`).replace(/\$CLAUDE_PROJECT_DIR/g, cwd).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd);
+  let finalCommand = expandedCommand;
+  if (options?.forceZsh) {
+    const zshPath = options.zshPath || findZshPath();
+    if (zshPath) {
+      const escapedCommand = expandedCommand.replace(/'/g, "'\\''");
+      finalCommand = `${zshPath} -lc '${escapedCommand}'`;
     }
-    if (event.type === "message.updated") {
-      const info = props?.info;
-      const sessionID = info?.sessionID;
-      if (sessionID && info?.role === "user") {
-        remindedSessions.delete(sessionID);
-        const timer = pendingTimers.get(sessionID);
-        if (timer) {
-          clearTimeout(timer);
-          pendingTimers.delete(sessionID);
-        }
+  }
+  return new Promise((resolve) => {
+    const proc = spawn(finalCommand, {
+      cwd,
+      shell: true,
+      env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd }
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.stdin?.write(stdin);
+    proc.stdin?.end();
+    proc.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      });
+    });
+    proc.on("error", (err) => {
+      resolve({
+        exitCode: 1,
+        stderr: err.message
+      });
+    });
+  });
+}
+async function executeCommand(command) {
+  try {
+    const { stdout, stderr } = await execAsync(command);
+    const out = stdout?.toString().trim() ?? "";
+    const err = stderr?.toString().trim() ?? "";
+    if (err) {
+      if (out) {
+        return `${out}
+[stderr: ${err}]`;
       }
+      return `[stderr: ${err}]`;
     }
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        remindedSessions.delete(sessionInfo.id);
-        interruptedSessions.delete(sessionInfo.id);
-        errorSessions.delete(sessionInfo.id);
-        const timer = pendingTimers.get(sessionInfo.id);
-        if (timer) {
-          clearTimeout(timer);
-          pendingTimers.delete(sessionInfo.id);
-        }
-      }
+    return out;
+  } catch (error) {
+    const e = error;
+    const stdout = e?.stdout?.toString().trim() ?? "";
+    const stderr = e?.stderr?.toString().trim() ?? "";
+    const errMsg = stderr || e?.message || String(error);
+    if (stdout) {
+      return `${stdout}
+[stderr: ${errMsg}]`;
     }
-  };
+    return `[stderr: ${errMsg}]`;
+  }
 }
-// src/hooks/context-window-monitor.ts
-var ANTHROPIC_DISPLAY_LIMIT = 1e6;
-var ANTHROPIC_ACTUAL_LIMIT = 200000;
-var CONTEXT_WARNING_THRESHOLD = 0.7;
-var CONTEXT_REMINDER = `[SYSTEM REMINDER - 1M Context Window]
-
-You are using Anthropic Claude with 1M context window.
-You have plenty of context remaining - do NOT rush or skip tasks.
-Complete your work thoroughly and methodically.`;
-function createContextWindowMonitorHook(ctx) {
-  const remindedSessions = new Set;
-  const toolExecuteAfter = async (input, output) => {
-    const { sessionID } = input;
-    if (remindedSessions.has(sessionID))
-      return;
-    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 lastAssistant = assistantMessages[assistantMessages.length - 1];
-      if (lastAssistant.providerID !== "anthropic")
-        return;
-      const lastTokens = lastAssistant.tokens;
-      const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
-      const actualUsagePercentage = totalInputTokens / ANTHROPIC_ACTUAL_LIMIT;
-      if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD)
-        return;
-      remindedSessions.add(sessionID);
-      const displayUsagePercentage = totalInputTokens / ANTHROPIC_DISPLAY_LIMIT;
-      const usedPct = (displayUsagePercentage * 100).toFixed(1);
-      const remainingPct = ((1 - displayUsagePercentage) * 100).toFixed(1);
-      const usedTokens = totalInputTokens.toLocaleString();
-      const limitTokens = ANTHROPIC_DISPLAY_LIMIT.toLocaleString();
-      output.output += `
-
-${CONTEXT_REMINDER}
-[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`;
-    } catch {}
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        remindedSessions.delete(sessionInfo.id);
-      }
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
-// 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
-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/constants.ts
-var OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
-var MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message");
-var PART_STORAGE = join(OPENCODE_STORAGE, "part");
-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}`;
+var COMMAND_PATTERN = /!`([^`]+)`/g;
+function findCommands(text) {
+  const matches = [];
+  let match;
+  COMMAND_PATTERN.lastIndex = 0;
+  while ((match = COMMAND_PATTERN.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      command: match[1],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return matches;
 }
-function getMessageDir(sessionID) {
-  if (!existsSync(MESSAGE_STORAGE))
-    return "";
-  const directPath = join2(MESSAGE_STORAGE, sessionID);
-  if (existsSync(directPath)) {
-    return directPath;
+async function resolveCommandsInText(text, depth = 0, maxDepth = 3) {
+  if (depth >= maxDepth) {
+    return text;
   }
-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join2(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync(sessionPath)) {
-      return sessionPath;
-    }
+  const matches = findCommands(text);
+  if (matches.length === 0) {
+    return text;
   }
-  return "";
-}
-function readMessages(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(join2(messageDir, file), "utf-8");
-      messages.push(JSON.parse(content));
-    } catch {
-      continue;
+  const tasks = matches.map((m) => executeCommand(m.command));
+  const results = await Promise.allSettled(tasks);
+  const replacements = new Map;
+  matches.forEach((match, idx) => {
+    const result = results[idx];
+    if (result.status === "rejected") {
+      replacements.set(match.fullMatch, `[error: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}]`);
+    } else {
+      replacements.set(match.fullMatch, result.value);
     }
-  }
-  return messages.sort((a, b) => {
-    const aTime = a.time?.created ?? 0;
-    const bTime = b.time?.created ?? 0;
-    if (aTime !== bTime)
-      return aTime - bTime;
-    return a.id.localeCompare(b.id);
   });
+  let resolved = text;
+  for (const [pattern, replacement] of replacements.entries()) {
+    resolved = resolved.split(pattern).join(replacement);
+  }
+  if (findCommands(resolved).length > 0) {
+    return resolveCommandsInText(resolved, depth + 1, maxDepth);
+  }
+  return resolved;
 }
-function readParts(messageID) {
-  const partDir = join2(PART_STORAGE, messageID);
-  if (!existsSync(partDir))
-    return [];
-  const parts = [];
-  for (const file of readdirSync(partDir)) {
-    if (!file.endsWith(".json"))
-      continue;
-    try {
-      const content = readFileSync(join2(partDir, file), "utf-8");
-      parts.push(JSON.parse(content));
-    } catch {
-      continue;
-    }
+// src/shared/file-reference-resolver.ts
+import { existsSync as existsSync2, readFileSync, statSync } from "fs";
+import { join, isAbsolute } from "path";
+var FILE_REFERENCE_PATTERN = /@([^\s@]+)/g;
+function findFileReferences(text) {
+  const matches = [];
+  let match;
+  FILE_REFERENCE_PATTERN.lastIndex = 0;
+  while ((match = FILE_REFERENCE_PATTERN.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      filePath: match[1],
+      start: match.index,
+      end: match.index + match[0].length
+    });
   }
-  return parts;
+  return matches;
 }
-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();
+function resolveFilePath(filePath, cwd) {
+  if (isAbsolute(filePath)) {
+    return filePath;
   }
-  if (part.type === "tool" || part.type === "tool_use") {
-    return true;
+  return join(cwd, filePath);
+}
+function readFileContent(resolvedPath) {
+  if (!existsSync2(resolvedPath)) {
+    return `[file not found: ${resolvedPath}]`;
   }
-  if (part.type === "tool_result") {
-    return true;
+  const stat = statSync(resolvedPath);
+  if (stat.isDirectory()) {
+    return `[cannot read directory: ${resolvedPath}]`;
   }
-  return false;
-}
-function messageHasContent(messageID) {
-  const parts = readParts(messageID);
-  return parts.some(hasContent);
+  const content = readFileSync(resolvedPath, "utf-8");
+  return content;
 }
-function injectTextPart(sessionID, messageID, text) {
-  const partDir = join2(PART_STORAGE, messageID);
-  if (!existsSync(partDir)) {
-    mkdirSync(partDir, { recursive: true });
+async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0, maxDepth = 3) {
+  if (depth >= maxDepth) {
+    return text;
   }
-  const partId = generatePartId();
-  const part = {
-    id: partId,
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-    synthetic: true
-  };
-  try {
-    writeFileSync(join2(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
-    return true;
-  } catch {
-    return false;
+  const matches = findFileReferences(text);
+  if (matches.length === 0) {
+    return text;
   }
-}
-function findEmptyMessages(sessionID) {
-  const messages = readMessages(sessionID);
-  const emptyIds = [];
-  for (const msg of messages) {
-    if (!messageHasContent(msg.id)) {
-      emptyIds.push(msg.id);
-    }
+  const replacements = new Map;
+  for (const match of matches) {
+    const resolvedPath = resolveFilePath(match.filePath, cwd);
+    const content = readFileContent(resolvedPath);
+    replacements.set(match.fullMatch, content);
   }
-  return emptyIds;
-}
-function findEmptyMessageByIndex(sessionID, targetIndex) {
-  const messages = readMessages(sessionID);
-  const indicesToTry = [targetIndex, targetIndex - 1];
-  for (const idx of indicesToTry) {
-    if (idx < 0 || idx >= messages.length)
-      continue;
-    const targetMsg = messages[idx];
-    if (!messageHasContent(targetMsg.id)) {
-      return targetMsg.id;
-    }
+  let resolved = text;
+  for (const [pattern, replacement] of replacements.entries()) {
+    resolved = resolved.split(pattern).join(replacement);
   }
-  return null;
-}
-function findMessagesWithThinkingBlocks(sessionID) {
-  const messages = readMessages(sessionID);
-  const result = [];
-  for (const msg of messages) {
-    if (msg.role !== "assistant")
-      continue;
-    const parts = readParts(msg.id);
-    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type));
-    if (hasThinking) {
-      result.push(msg.id);
-    }
+  if (findFileReferences(resolved).length > 0 && depth + 1 < maxDepth) {
+    return resolveFileReferencesInText(resolved, cwd, depth + 1, maxDepth);
   }
-  return result;
+  return resolved;
 }
-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 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 firstIsThinking = THINKING_TYPES.has(firstPart.type);
-    if (!firstIsThinking) {
-      result.push(msg.id);
-    }
-  }
-  return result;
+// src/shared/model-sanitizer.ts
+function sanitizeModelField(_model) {
+  return;
 }
-function prependThinkingPart(sessionID, messageID) {
-  const partDir = join2(PART_STORAGE, messageID);
-  if (!existsSync(partDir)) {
-    mkdirSync(partDir, { recursive: true });
-  }
-  const partId = `prt_0000000000_thinking`;
-  const part = {
-    id: partId,
-    sessionID,
-    messageID,
-    type: "thinking",
-    thinking: "",
-    synthetic: true
-  };
+// src/shared/logger.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var logFile = path.join(os.tmpdir(), "oh-my-opencode.log");
+function log(message, data) {
   try {
-    writeFileSync(join2(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
-    return true;
-  } catch {
-    return false;
-  }
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    fs.appendFileSync(logFile, logEntry);
+  } catch {}
 }
-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;
-    }
-  }
-  return anyRemoved;
+// src/shared/snake-case.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
-function findMessageByIndexNeedingThinking(sessionID, targetIndex) {
-  const messages = readMessages(sessionID);
-  if (targetIndex < 0 || targetIndex >= messages.length)
-    return null;
-  const targetMsg = messages[targetIndex];
-  if (targetMsg.role !== "assistant")
-    return null;
-  const parts = readParts(targetMsg.id);
-  if (parts.length === 0)
-    return null;
-  const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id));
-  const firstPart = sortedParts[0];
-  const firstIsThinking = THINKING_TYPES.has(firstPart.type);
-  if (!firstIsThinking) {
-    return targetMsg.id;
-  }
-  return null;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-// 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 objectToSnakeCase(obj, deep = true) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnake(key);
+    if (deep && isPlainObject(value)) {
+      result[snakeKey] = objectToSnakeCase(value, true);
+    } else if (deep && Array.isArray(value)) {
+      result[snakeKey] = value.map((item) => isPlainObject(item) ? objectToSnakeCase(item, true) : item);
+    } else {
+      result[snakeKey] = value;
+    }
+  }
+  return result;
 }
-function extractMessageIndex(error) {
-  const message = getErrorMessage(error);
-  const match = message.match(/messages\.(\d+)/);
-  return match ? parseInt(match[1], 10) : null;
+// src/shared/tool-name.ts
+var SPECIAL_TOOL_MAPPINGS = {
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  todoread: "TodoRead",
+  todowrite: "TodoWrite"
+};
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
 }
-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") || message.includes("expected") && message.includes("found"))) {
-    return "thinking_block_order";
+function transformToolName(toolName) {
+  const lower = toolName.toLowerCase();
+  if (lower in SPECIAL_TOOL_MAPPINGS) {
+    return SPECIAL_TOOL_MAPPINGS[lower];
   }
-  if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
-    return "thinking_disabled_violation";
+  if (toolName.includes("-") || toolName.includes("_")) {
+    return toPascalCase(toolName);
   }
-  if (message.includes("non-empty content") || message.includes("must have non-empty content")) {
-    return "empty_content_message";
+  return toolName.charAt(0).toUpperCase() + toolName.slice(1);
+}
+// src/shared/pattern-matcher.ts
+function matchesToolMatcher(toolName, matcher) {
+  if (!matcher) {
+    return true;
   }
-  return null;
+  const patterns = matcher.split("|").map((p) => p.trim());
+  return patterns.some((p) => {
+    if (p.includes("*")) {
+      const regex = new RegExp(`^${p.replace(/\*/g, ".*")}$`, "i");
+      return regex.test(toolName);
+    }
+    return p.toLowerCase() === toolName.toLowerCase();
+  });
 }
-function extractToolUseIds(parts) {
-  return parts.filter((p) => p.type === "tool_use" && !!p.id).map((p) => p.id);
+function findMatchingHooks(config, eventName, toolName) {
+  const hookMatchers = config[eventName];
+  if (!hookMatchers)
+    return [];
+  return hookMatchers.filter((hookMatcher) => {
+    if (!toolName)
+      return true;
+    return matchesToolMatcher(toolName, hookMatcher.matcher);
+  });
 }
-async function recoverToolResultMissing(client, sessionID, failedAssistantMsg) {
-  const parts = failedAssistantMsg.parts || [];
-  const toolUseIds = extractToolUseIds(parts);
-  if (toolUseIds.length === 0) {
+// src/shared/hook-disabled.ts
+function isHookDisabled(config, hookType) {
+  const { disabledHooks } = config;
+  if (disabledHooks === undefined) {
     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 }
-    });
+  if (disabledHooks === true) {
     return true;
-  } catch {
-    return false;
-  }
-}
-async function recoverThinkingBlockOrder(_client, sessionID, _failedAssistantMsg, _directory, error) {
-  const targetIndex = extractMessageIndex(error);
-  if (targetIndex !== null) {
-    const targetMessageID = findMessageByIndexNeedingThinking(sessionID, targetIndex);
-    if (targetMessageID) {
-      return prependThinkingPart(sessionID, targetMessageID);
-    }
-  }
-  const orphanMessages = findMessagesWithOrphanThinking(sessionID);
-  if (orphanMessages.length === 0) {
-    return false;
   }
-  let anySuccess = false;
-  for (const messageID of orphanMessages) {
-    if (prependThinkingPart(sessionID, messageID)) {
-      anySuccess = true;
-    }
+  if (Array.isArray(disabledHooks)) {
+    return disabledHooks.includes(hookType);
   }
-  return anySuccess;
+  return false;
 }
-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;
+// src/shared/deep-merge.ts
+var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+var MAX_DEPTH = 50;
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function deepMerge(base, override, depth = 0) {
+  if (!base && !override)
+    return;
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  if (depth > MAX_DEPTH)
+    return override ?? base;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    if (DANGEROUS_KEYS.has(key))
+      continue;
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (overrideValue === undefined)
+      continue;
+    if (isPlainObject2(baseValue) && isPlainObject2(overrideValue)) {
+      result[key] = deepMerge(baseValue, overrideValue, depth + 1);
+    } else {
+      result[key] = overrideValue;
     }
   }
-  return anySuccess;
+  return result;
 }
-async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory, error) {
-  const targetIndex = extractMessageIndex(error);
-  const failedID = failedAssistantMsg.info?.id;
-  if (targetIndex !== null) {
-    const targetMessageID = findEmptyMessageByIndex(sessionID, targetIndex);
-    if (targetMessageID) {
-      return injectTextPart(sessionID, targetMessageID, "(interrupted)");
+// src/agents/utils.ts
+var allBuiltinAgents = {
+  oracle: oracleAgent,
+  librarian: librarianAgent,
+  explore: exploreAgent,
+  "frontend-ui-ux-engineer": frontendUiUxEngineerAgent,
+  "document-writer": documentWriterAgent
+};
+function mergeAgentConfig(base, override) {
+  return deepMerge(base, override);
+}
+function createBuiltinAgents(disabledAgents = [], agentOverrides = {}) {
+  const result = {};
+  for (const [name, config] of Object.entries(allBuiltinAgents)) {
+    const agentName = name;
+    if (disabledAgents.includes(agentName)) {
+      continue;
     }
-  }
-  if (failedID) {
-    if (injectTextPart(sessionID, failedID, "(interrupted)")) {
-      return true;
+    const override = agentOverrides[agentName];
+    if (override) {
+      result[name] = mergeAgentConfig(config, override);
+    } else {
+      result[name] = config;
     }
   }
-  const emptyMessageIDs = findEmptyMessages(sessionID);
-  let anySuccess = false;
-  for (const messageID of emptyMessageIDs) {
-    if (injectTextPart(sessionID, messageID, "(interrupted)")) {
-      anySuccess = true;
-    }
+  return result;
+}
+// src/hooks/todo-continuation-enforcer.ts
+var CONTINUATION_PROMPT = `[SYSTEM REMINDER - TODO CONTINUATION]
+
+Incomplete tasks remain in your todo list. Continue working on the next pending task.
+
+- 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;
+  if (typeof error === "object") {
+    const errObj = error;
+    const name = errObj.name;
+    const message = errObj.message?.toLowerCase() ?? "";
+    if (name === "MessageAbortedError" || name === "AbortError")
+      return true;
+    if (name === "DOMException" && message.includes("abort"))
+      return true;
+    if (message.includes("aborted") || message.includes("cancelled") || message.includes("interrupted"))
+      return true;
   }
-  return anySuccess;
+  if (typeof error === "string") {
+    const lower = error.toLowerCase();
+    return lower.includes("abort") || lower.includes("cancel") || lower.includes("interrupt");
+  }
+  return false;
 }
-function createSessionRecoveryHook(ctx) {
-  const processingErrors = new Set;
-  let onAbortCallback = null;
-  const setOnAbortCallback = (callback) => {
-    onAbortCallback = callback;
+function createTodoContinuationEnforcer(ctx) {
+  const remindedSessions = new Set;
+  const interruptedSessions = new Set;
+  const errorSessions = new Set;
+  const recoveringSessions = new Set;
+  const pendingTimers = new Map;
+  const markRecovering = (sessionID) => {
+    recoveringSessions.add(sessionID);
   };
-  const isRecoverableError = (error) => {
-    return detectErrorType(error) !== null;
+  const markRecoveryComplete = (sessionID) => {
+    recoveringSessions.delete(sessionID);
   };
-  const handleSessionRecovery = async (info) => {
-    if (!info || info.role !== "assistant" || !info.error)
-      return false;
-    const errorType = detectErrorType(info.error);
-    if (!errorType)
-      return false;
-    const sessionID = info.sessionID;
-    const assistantMsgID = info.id;
-    if (!sessionID || !assistantMsgID)
-      return false;
-    if (processingErrors.has(assistantMsgID))
-      return false;
-    processingErrors.add(assistantMsgID);
-    try {
-      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {});
-      if (onAbortCallback) {
-        onAbortCallback(sessionID);
+  const handler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.error") {
+      const sessionID = props?.sessionID;
+      if (sessionID) {
+        errorSessions.add(sessionID);
+        if (detectInterrupt(props?.error)) {
+          interruptedSessions.add(sessionID);
+        }
+        const timer = pendingTimers.get(sessionID);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionID);
+        }
       }
-      const messagesResp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory }
-      });
-      const msgs = messagesResp.data;
-      const failedMsg = msgs?.find((m) => m.info?.id === assistantMsgID);
-      if (!failedMsg) {
-        return false;
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      const existingTimer = pendingTimers.get(sessionID);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
       }
-      const toastTitles = {
-        tool_result_missing: "Tool Crash Recovery",
-        thinking_block_order: "Thinking Block Recovery",
-        thinking_disabled_violation: "Thinking Strip Recovery",
-        empty_content_message: "Empty Message Recovery"
-      };
-      const toastMessages = {
-        tool_result_missing: "Injecting cancelled tool results...",
-        thinking_block_order: "Fixing message structure...",
-        thinking_disabled_violation: "Stripping thinking blocks...",
-        empty_content_message: "Fixing empty message..."
-      };
-      await ctx.client.tui.showToast({
-        body: {
-          title: toastTitles[errorType],
-          message: toastMessages[errorType],
-          variant: "warning",
-          duration: 3000
+      const timer = setTimeout(async () => {
+        pendingTimers.delete(sessionID);
+        if (recoveringSessions.has(sessionID)) {
+          return;
+        }
+        const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
+        interruptedSessions.delete(sessionID);
+        errorSessions.delete(sessionID);
+        if (shouldBypass) {
+          return;
+        }
+        if (remindedSessions.has(sessionID)) {
+          return;
+        }
+        let todos = [];
+        try {
+          const response = await ctx.client.session.todo({
+            path: { id: sessionID }
+          });
+          todos = response.data ?? response;
+        } catch {
+          return;
+        }
+        if (!todos || todos.length === 0) {
+          return;
+        }
+        const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+        if (incomplete.length === 0) {
+          return;
+        }
+        remindedSessions.add(sessionID);
+        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID) || recoveringSessions.has(sessionID)) {
+          remindedSessions.delete(sessionID);
+          return;
+        }
+        try {
+          await ctx.client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              parts: [
+                {
+                  type: "text",
+                  text: `${CONTINUATION_PROMPT}
+
+[Status: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.length} remaining]`
+                }
+              ]
+            },
+            query: { directory: ctx.directory }
+          });
+        } catch {
+          remindedSessions.delete(sessionID);
+        }
+      }, 200);
+      pendingTimers.set(sessionID, timer);
+    }
+    if (event.type === "message.updated") {
+      const info = props?.info;
+      const sessionID = info?.sessionID;
+      if (sessionID && info?.role === "user") {
+        remindedSessions.delete(sessionID);
+        const timer = pendingTimers.get(sessionID);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionID);
+        }
+      }
+    }
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        remindedSessions.delete(sessionInfo.id);
+        interruptedSessions.delete(sessionInfo.id);
+        errorSessions.delete(sessionInfo.id);
+        recoveringSessions.delete(sessionInfo.id);
+        const timer = pendingTimers.get(sessionInfo.id);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionInfo.id);
         }
-      }).catch(() => {});
-      let success = false;
-      if (errorType === "tool_result_missing") {
-        success = await recoverToolResultMissing(ctx.client, sessionID, failedMsg);
-      } else if (errorType === "thinking_block_order") {
-        success = await recoverThinkingBlockOrder(ctx.client, sessionID, failedMsg, ctx.directory, info.error);
-      } else if (errorType === "thinking_disabled_violation") {
-        success = await recoverThinkingDisabledViolation(ctx.client, sessionID, failedMsg);
-      } else if (errorType === "empty_content_message") {
-        success = await recoverEmptyContentMessage(ctx.client, sessionID, failedMsg, ctx.directory, info.error);
       }
-      return success;
-    } catch (err) {
-      console.error("[session-recovery] Recovery failed:", err);
-      return false;
-    } finally {
-      processingErrors.delete(assistantMsgID);
     }
   };
   return {
-    handleSessionRecovery,
-    isRecoverableError,
-    setOnAbortCallback
+    handler,
+    markRecovering,
+    markRecoveryComplete
   };
 }
-// src/hooks/comment-checker/cli.ts
-var {spawn: spawn2 } = globalThis.Bun;
-import { createRequire as createRequire2 } from "module";
-import { dirname, join as join4 } from "path";
-import { existsSync as existsSync3 } from "fs";
-import * as fs from "fs";
+// src/hooks/context-window-monitor.ts
+var ANTHROPIC_DISPLAY_LIMIT = 1e6;
+var ANTHROPIC_ACTUAL_LIMIT = 200000;
+var CONTEXT_WARNING_THRESHOLD = 0.7;
+var CONTEXT_REMINDER = `[SYSTEM REMINDER - 1M Context Window]
 
-// src/hooks/comment-checker/downloader.ts
-var {spawn } = globalThis.Bun;
-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";
-var DEBUG_FILE = "/tmp/comment-checker-debug.log";
-function debugLog(...args) {
-  if (DEBUG) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
-`;
-    appendFileSync(DEBUG_FILE, msg);
-  }
-}
-var REPO = "code-yeongyu/go-claude-code-comment-checker";
-var PLATFORM_MAP = {
-  "darwin-arm64": { os: "darwin", arch: "arm64", ext: "tar.gz" },
-  "darwin-x64": { os: "darwin", arch: "amd64", ext: "tar.gz" },
-  "linux-arm64": { os: "linux", arch: "arm64", ext: "tar.gz" },
-  "linux-x64": { os: "linux", arch: "amd64", ext: "tar.gz" },
-  "win32-x64": { os: "windows", arch: "amd64", ext: "zip" }
-};
-function getCacheDir() {
-  const xdgCache2 = process.env.XDG_CACHE_HOME;
-  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 = join3(getCacheDir(), getBinaryName());
-  return existsSync2(binaryPath) ? binaryPath : null;
-}
-function getPackageVersion() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkg = require2("@code-yeongyu/comment-checker/package.json");
-    return pkg.version;
-  } catch {
-    return "0.4.1";
-  }
-}
-async function extractTarGz(archivePath, destDir) {
-  debugLog("Extracting tar.gz:", archivePath, "to", destDir);
-  const proc = spawn(["tar", "-xzf", archivePath, "-C", destDir], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`tar extraction failed (exit ${exitCode}): ${stderr}`);
-  }
+You are using Anthropic Claude with 1M context window.
+You have plenty of context remaining - do NOT rush or skip tasks.
+Complete your work thoroughly and methodically.`;
+function createContextWindowMonitorHook(ctx) {
+  const remindedSessions = new Set;
+  const toolExecuteAfter = async (input, output) => {
+    const { sessionID } = input;
+    if (remindedSessions.has(sessionID))
+      return;
+    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 lastAssistant = assistantMessages[assistantMessages.length - 1];
+      if (lastAssistant.providerID !== "anthropic")
+        return;
+      const lastTokens = lastAssistant.tokens;
+      const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
+      const actualUsagePercentage = totalInputTokens / ANTHROPIC_ACTUAL_LIMIT;
+      if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD)
+        return;
+      remindedSessions.add(sessionID);
+      const displayUsagePercentage = totalInputTokens / ANTHROPIC_DISPLAY_LIMIT;
+      const usedPct = (displayUsagePercentage * 100).toFixed(1);
+      const remainingPct = ((1 - displayUsagePercentage) * 100).toFixed(1);
+      const usedTokens = totalInputTokens.toLocaleString();
+      const limitTokens = ANTHROPIC_DISPLAY_LIMIT.toLocaleString();
+      output.output += `
+
+${CONTEXT_REMINDER}
+[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`;
+    } catch {}
+  };
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        remindedSessions.delete(sessionInfo.id);
+      }
+    }
+  };
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler
+  };
 }
-async function extractZip(archivePath, destDir) {
-  debugLog("Extracting zip:", archivePath, "to", destDir);
-  const proc = process.platform === "win32" ? spawn(["powershell", "-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], {
-    stdout: "pipe",
-    stderr: "pipe"
-  }) : spawn(["unzip", "-o", archivePath, "-d", destDir], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
-  }
+// src/hooks/session-recovery/storage.ts
+import { existsSync as existsSync3, mkdirSync, readdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { join as join4 } from "path";
+
+// src/hooks/session-recovery/constants.ts
+import { join as join3 } from "path";
+
+// node_modules/xdg-basedir/index.js
+import os2 from "os";
+import path2 from "path";
+var homeDirectory = os2.homedir();
+var { env } = process;
+var xdgData = env.XDG_DATA_HOME || (homeDirectory ? path2.join(homeDirectory, ".local", "share") : undefined);
+var xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path2.join(homeDirectory, ".config") : undefined);
+var xdgState = env.XDG_STATE_HOME || (homeDirectory ? path2.join(homeDirectory, ".local", "state") : undefined);
+var xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? path2.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);
 }
-async function downloadCommentChecker() {
-  const platformKey = `${process.platform}-${process.arch}`;
-  const platformInfo = PLATFORM_MAP[platformKey];
-  if (!platformInfo) {
-    debugLog(`Unsupported platform: ${platformKey}`);
-    return null;
-  }
-  const cacheDir = getCacheDir();
-  const binaryName = getBinaryName();
-  const binaryPath = join3(cacheDir, binaryName);
-  if (existsSync2(binaryPath)) {
-    debugLog("Binary already cached at:", binaryPath);
-    return binaryPath;
+var xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
+if (xdgConfig) {
+  xdgConfigDirectories.unshift(xdgConfig);
+}
+
+// src/hooks/session-recovery/constants.ts
+var OPENCODE_STORAGE = join3(xdgData ?? "", "opencode", "storage");
+var MESSAGE_STORAGE = join3(OPENCODE_STORAGE, "message");
+var PART_STORAGE = join3(OPENCODE_STORAGE, "part");
+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) {
+  if (!existsSync3(MESSAGE_STORAGE))
+    return "";
+  const directPath = join4(MESSAGE_STORAGE, sessionID);
+  if (existsSync3(directPath)) {
+    return directPath;
   }
-  const version = getPackageVersion();
-  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 (!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 = join3(cacheDir, assetName);
-    const arrayBuffer = await response.arrayBuffer();
-    await Bun.write(archivePath, arrayBuffer);
-    debugLog(`Downloaded archive to: ${archivePath}`);
-    if (ext === "tar.gz") {
-      await extractTarGz(archivePath, cacheDir);
-    } else {
-      await extractZip(archivePath, cacheDir);
-    }
-    if (existsSync2(archivePath)) {
-      unlinkSync2(archivePath);
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join4(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync3(sessionPath)) {
+      return sessionPath;
     }
-    if (process.platform !== "win32" && existsSync2(binaryPath)) {
-      chmodSync(binaryPath, 493);
+  }
+  return "";
+}
+function readMessages(sessionID) {
+  const messageDir = getMessageDir(sessionID);
+  if (!messageDir || !existsSync3(messageDir))
+    return [];
+  const messages = [];
+  for (const file of readdirSync(messageDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const content = readFileSync2(join4(messageDir, file), "utf-8");
+      messages.push(JSON.parse(content));
+    } catch {
+      continue;
     }
-    debugLog(`Successfully downloaded binary to: ${binaryPath}`);
-    console.log(`[oh-my-opencode] comment-checker binary ready.`);
-    return binaryPath;
-  } catch (err) {
-    debugLog(`Failed to download: ${err}`);
-    console.error(`[oh-my-opencode] Failed to download comment-checker: ${err instanceof Error ? err.message : err}`);
-    console.error(`[oh-my-opencode] Comment checking disabled.`);
-    return null;
   }
+  return messages.sort((a, b) => {
+    const aTime = a.time?.created ?? 0;
+    const bTime = b.time?.created ?? 0;
+    if (aTime !== bTime)
+      return aTime - bTime;
+    return a.id.localeCompare(b.id);
+  });
 }
-async function ensureCommentCheckerBinary() {
-  const cachedPath = getCachedBinaryPath();
-  if (cachedPath) {
-    debugLog("Using cached binary:", cachedPath);
-    return cachedPath;
+function readParts(messageID) {
+  const partDir = join4(PART_STORAGE, messageID);
+  if (!existsSync3(partDir))
+    return [];
+  const parts = [];
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const content = readFileSync2(join4(partDir, file), "utf-8");
+      parts.push(JSON.parse(content));
+    } catch {
+      continue;
+    }
   }
-  return downloadCommentChecker();
+  return parts;
 }
-
-// src/hooks/comment-checker/cli.ts
-var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE2 = "/tmp/comment-checker-debug.log";
-function debugLog2(...args) {
-  if (DEBUG2) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
-`;
-    fs.appendFileSync(DEBUG_FILE2, msg);
+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 getBinaryName2() {
-  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
+function messageHasContent(messageID) {
+  const parts = readParts(messageID);
+  return parts.some(hasContent);
 }
-function findCommentCheckerPathSync() {
-  const binaryName = getBinaryName2();
+function injectTextPart(sessionID, messageID, text) {
+  const partDir = join4(PART_STORAGE, messageID);
+  if (!existsSync3(partDir)) {
+    mkdirSync(partDir, { recursive: true });
+  }
+  const partId = generatePartId();
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "text",
+    text,
+    synthetic: true
+  };
   try {
-    const require2 = createRequire2(import.meta.url);
-    const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const cliDir = dirname(cliPkgPath);
-    const binaryPath = join4(cliDir, "bin", binaryName);
-    if (existsSync3(binaryPath)) {
-      debugLog2("found binary in main package:", binaryPath);
-      return binaryPath;
-    }
+    writeFileSync(join4(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    return true;
   } catch {
-    debugLog2("main package not installed");
+    return false;
   }
-  const cachedPath = getCachedBinaryPath();
-  if (cachedPath) {
-    debugLog2("found binary in cache:", cachedPath);
-    return cachedPath;
+}
+function findEmptyMessages(sessionID) {
+  const messages = readMessages(sessionID);
+  const emptyIds = [];
+  for (const msg of messages) {
+    if (!messageHasContent(msg.id)) {
+      emptyIds.push(msg.id);
+    }
+  }
+  return emptyIds;
+}
+function findEmptyMessageByIndex(sessionID, targetIndex) {
+  const messages = readMessages(sessionID);
+  const indicesToTry = [targetIndex, targetIndex - 1];
+  for (const idx of indicesToTry) {
+    if (idx < 0 || idx >= messages.length)
+      continue;
+    const targetMsg = messages[idx];
+    if (!messageHasContent(targetMsg.id)) {
+      return targetMsg.id;
+    }
   }
-  debugLog2("no binary found in known locations");
   return null;
 }
-var resolvedCliPath = null;
-var initPromise = null;
-async function getCommentCheckerPath() {
-  if (resolvedCliPath !== null) {
-    return resolvedCliPath;
-  }
-  if (initPromise) {
-    return initPromise;
+function findMessagesWithThinkingBlocks(sessionID) {
+  const messages = readMessages(sessionID);
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant")
+      continue;
+    const parts = readParts(msg.id);
+    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type));
+    if (hasThinking) {
+      result.push(msg.id);
+    }
   }
-  initPromise = (async () => {
-    const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync3(syncPath)) {
-      resolvedCliPath = syncPath;
-      debugLog2("using sync-resolved path:", syncPath);
-      return syncPath;
+  return result;
+}
+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 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 firstIsThinking = THINKING_TYPES.has(firstPart.type);
+    if (!firstIsThinking) {
+      result.push(msg.id);
     }
-    debugLog2("triggering lazy download...");
-    const downloadedPath = await ensureCommentCheckerBinary();
-    if (downloadedPath) {
-      resolvedCliPath = downloadedPath;
-      debugLog2("using downloaded path:", downloadedPath);
-      return downloadedPath;
+  }
+  return result;
+}
+function prependThinkingPart(sessionID, messageID) {
+  const partDir = join4(PART_STORAGE, messageID);
+  if (!existsSync3(partDir)) {
+    mkdirSync(partDir, { recursive: true });
+  }
+  const partId = `prt_0000000000_thinking`;
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "thinking",
+    thinking: "",
+    synthetic: true
+  };
+  try {
+    writeFileSync(join4(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stripThinkingParts(messageID) {
+  const partDir = join4(PART_STORAGE, messageID);
+  if (!existsSync3(partDir))
+    return false;
+  let anyRemoved = false;
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const filePath = join4(partDir, file);
+      const content = readFileSync2(filePath, "utf-8");
+      const part = JSON.parse(content);
+      if (THINKING_TYPES.has(part.type)) {
+        unlinkSync(filePath);
+        anyRemoved = true;
+      }
+    } catch {
+      continue;
     }
-    debugLog2("no binary available");
-    return null;
-  })();
-  return initPromise;
+  }
+  return anyRemoved;
 }
-function startBackgroundInit() {
-  if (!initPromise) {
-    initPromise = getCommentCheckerPath();
-    initPromise.then((path2) => {
-      debugLog2("background init complete:", path2 || "no binary");
-    }).catch((err) => {
-      debugLog2("background init error:", err);
-    });
+function findMessageByIndexNeedingThinking(sessionID, targetIndex) {
+  const messages = readMessages(sessionID);
+  if (targetIndex < 0 || targetIndex >= messages.length)
+    return null;
+  const targetMsg = messages[targetIndex];
+  if (targetMsg.role !== "assistant")
+    return null;
+  const parts = readParts(targetMsg.id);
+  if (parts.length === 0)
+    return null;
+  const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id));
+  const firstPart = sortedParts[0];
+  const firstIsThinking = THINKING_TYPES.has(firstPart.type);
+  if (!firstIsThinking) {
+    return targetMsg.id;
   }
+  return null;
 }
-var COMMENT_CHECKER_CLI_PATH = findCommentCheckerPathSync();
-async function runCommentChecker(input, cliPath) {
-  const binaryPath = cliPath ?? resolvedCliPath ?? COMMENT_CHECKER_CLI_PATH;
-  if (!binaryPath) {
-    debugLog2("comment-checker binary not found");
-    return { hasComments: false, message: "" };
+
+// 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 extractMessageIndex(error) {
+  const message = getErrorMessage(error);
+  const match = message.match(/messages\.(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function detectErrorType(error) {
+  const message = getErrorMessage(error);
+  if (message.includes("tool_use") && message.includes("tool_result")) {
+    return "tool_result_missing";
   }
-  if (!existsSync3(binaryPath)) {
-    debugLog2("comment-checker binary does not exist:", binaryPath);
-    return { hasComments: false, message: "" };
+  if (message.includes("thinking") && (message.includes("first block") || message.includes("must start with") || message.includes("preceeding") || message.includes("expected") && message.includes("found"))) {
+    return "thinking_block_order";
   }
-  const jsonInput = JSON.stringify(input);
-  debugLog2("running comment-checker with input:", jsonInput.substring(0, 200));
+  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 {
-    const proc = spawn2([binaryPath], {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe"
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: { parts: toolResultParts }
     });
-    proc.stdin.write(jsonInput);
-    proc.stdin.end();
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-    debugLog2("exit code:", exitCode, "stdout length:", stdout.length, "stderr length:", stderr.length);
-    if (exitCode === 0) {
-      return { hasComments: false, message: "" };
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function recoverThinkingBlockOrder(_client, sessionID, _failedAssistantMsg, _directory, error) {
+  const targetIndex = extractMessageIndex(error);
+  if (targetIndex !== null) {
+    const targetMessageID = findMessageByIndexNeedingThinking(sessionID, targetIndex);
+    if (targetMessageID) {
+      return prependThinkingPart(sessionID, targetMessageID);
     }
-    if (exitCode === 2) {
-      return { hasComments: true, message: stderr };
+  }
+  const orphanMessages = findMessagesWithOrphanThinking(sessionID);
+  if (orphanMessages.length === 0) {
+    return false;
+  }
+  let anySuccess = false;
+  for (const messageID of orphanMessages) {
+    if (prependThinkingPart(sessionID, messageID)) {
+      anySuccess = true;
     }
-    debugLog2("unexpected exit code:", exitCode, "stderr:", stderr);
-    return { hasComments: false, message: "" };
-  } catch (err) {
-    debugLog2("failed to run comment-checker:", err);
-    return { hasComments: false, message: "" };
   }
+  return anySuccess;
 }
-
-// src/hooks/comment-checker/index.ts
-import * as fs2 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) {
-  if (DEBUG3) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
-`;
-    fs2.appendFileSync(DEBUG_FILE3, msg);
+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;
 }
-var pendingCalls = new Map;
-var PENDING_CALL_TTL = 60000;
-var cliPathPromise = null;
-function cleanupOldPendingCalls() {
-  const now = Date.now();
-  for (const [callID, call] of pendingCalls) {
-    if (now - call.timestamp > PENDING_CALL_TTL) {
-      pendingCalls.delete(callID);
+async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory, error) {
+  const targetIndex = extractMessageIndex(error);
+  const failedID = failedAssistantMsg.info?.id;
+  if (targetIndex !== null) {
+    const targetMessageID = findEmptyMessageByIndex(sessionID, targetIndex);
+    if (targetMessageID) {
+      return injectTextPart(sessionID, targetMessageID, "(interrupted)");
+    }
+  }
+  if (failedID) {
+    if (injectTextPart(sessionID, failedID, "(interrupted)")) {
+      return true;
+    }
+  }
+  const emptyMessageIDs = findEmptyMessages(sessionID);
+  let anySuccess = false;
+  for (const messageID of emptyMessageIDs) {
+    if (injectTextPart(sessionID, messageID, "(interrupted)")) {
+      anySuccess = true;
     }
   }
+  return anySuccess;
 }
-setInterval(cleanupOldPendingCalls, 1e4);
-function createCommentCheckerHooks() {
-  debugLog3("createCommentCheckerHooks called");
-  startBackgroundInit();
-  cliPathPromise = getCommentCheckerPath();
-  cliPathPromise.then((path2) => {
-    debugLog3("CLI path resolved:", path2 || "disabled (no binary)");
-  }).catch((err) => {
-    debugLog3("CLI path resolution error:", err);
-  });
-  return {
-    "tool.execute.before": async (input, output) => {
-      debugLog3("tool.execute.before:", { tool: input.tool, callID: input.callID, args: output.args });
-      const toolLower = input.tool.toLowerCase();
-      if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
-        debugLog3("skipping non-write/edit tool:", toolLower);
-        return;
-      }
-      const filePath = output.args.filePath ?? output.args.file_path ?? output.args.path;
-      const content = output.args.content;
-      const oldString = output.args.oldString ?? output.args.old_string;
-      const newString = output.args.newString ?? output.args.new_string;
-      const edits = output.args.edits;
-      debugLog3("extracted filePath:", filePath);
-      if (!filePath) {
-        debugLog3("no filePath found");
-        return;
+function createSessionRecoveryHook(ctx) {
+  const processingErrors = new Set;
+  let onAbortCallback = null;
+  let onRecoveryCompleteCallback = null;
+  const setOnAbortCallback = (callback) => {
+    onAbortCallback = callback;
+  };
+  const setOnRecoveryCompleteCallback = (callback) => {
+    onRecoveryCompleteCallback = callback;
+  };
+  const isRecoverableError = (error) => {
+    return detectErrorType(error) !== null;
+  };
+  const handleSessionRecovery = async (info) => {
+    if (!info || info.role !== "assistant" || !info.error)
+      return false;
+    const errorType = detectErrorType(info.error);
+    if (!errorType)
+      return false;
+    const sessionID = info.sessionID;
+    const assistantMsgID = info.id;
+    if (!sessionID || !assistantMsgID)
+      return false;
+    if (processingErrors.has(assistantMsgID))
+      return false;
+    processingErrors.add(assistantMsgID);
+    try {
+      if (onAbortCallback) {
+        onAbortCallback(sessionID);
       }
-      debugLog3("registering pendingCall:", { callID: input.callID, filePath, tool: toolLower });
-      pendingCalls.set(input.callID, {
-        filePath,
-        content,
-        oldString,
-        newString,
-        edits,
-        tool: toolLower,
-        sessionID: input.sessionID,
-        timestamp: Date.now()
+      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+      const messagesResp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory }
       });
-    },
-    "tool.execute.after": async (input, output) => {
-      debugLog3("tool.execute.after:", { tool: input.tool, callID: input.callID });
-      const pendingCall = pendingCalls.get(input.callID);
-      if (!pendingCall) {
-        debugLog3("no pendingCall found for:", input.callID);
-        return;
-      }
-      pendingCalls.delete(input.callID);
-      debugLog3("processing pendingCall:", pendingCall);
-      const outputLower = output.output.toLowerCase();
-      const isToolFailure = outputLower.includes("error:") || outputLower.includes("failed to") || outputLower.includes("could not") || outputLower.startsWith("error");
-      if (isToolFailure) {
-        debugLog3("skipping due to tool failure in output");
-        return;
+      const msgs = messagesResp.data;
+      const failedMsg = msgs?.find((m) => m.info?.id === assistantMsgID);
+      if (!failedMsg) {
+        return false;
       }
-      try {
-        const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync4(cliPath)) {
-          debugLog3("CLI not available, skipping comment check");
-          return;
+      const toastTitles = {
+        tool_result_missing: "Tool Crash Recovery",
+        thinking_block_order: "Thinking Block Recovery",
+        thinking_disabled_violation: "Thinking Strip Recovery",
+        empty_content_message: "Empty Message Recovery"
+      };
+      const toastMessages = {
+        tool_result_missing: "Injecting cancelled tool results...",
+        thinking_block_order: "Fixing message structure...",
+        thinking_disabled_violation: "Stripping thinking blocks...",
+        empty_content_message: "Fixing empty message..."
+      };
+      await ctx.client.tui.showToast({
+        body: {
+          title: toastTitles[errorType],
+          message: toastMessages[errorType],
+          variant: "warning",
+          duration: 3000
         }
-        debugLog3("using CLI:", cliPath);
-        await processWithCli(input, pendingCall, output, cliPath);
-      } catch (err) {
-        debugLog3("tool.execute.after failed:", err);
+      }).catch(() => {});
+      let success = false;
+      if (errorType === "tool_result_missing") {
+        success = await recoverToolResultMissing(ctx.client, sessionID, failedMsg);
+      } else if (errorType === "thinking_block_order") {
+        success = await recoverThinkingBlockOrder(ctx.client, sessionID, failedMsg, ctx.directory, info.error);
+      } else if (errorType === "thinking_disabled_violation") {
+        success = await recoverThinkingDisabledViolation(ctx.client, sessionID, failedMsg);
+      } else if (errorType === "empty_content_message") {
+        success = await recoverEmptyContentMessage(ctx.client, sessionID, failedMsg, ctx.directory, info.error);
+      }
+      return success;
+    } catch (err) {
+      console.error("[session-recovery] Recovery failed:", err);
+      return false;
+    } finally {
+      processingErrors.delete(assistantMsgID);
+      if (sessionID && onRecoveryCompleteCallback) {
+        onRecoveryCompleteCallback(sessionID);
       }
     }
   };
-}
-async function processWithCli(input, pendingCall, output, cliPath) {
-  debugLog3("using CLI mode with path:", cliPath);
-  const hookInput = {
-    session_id: pendingCall.sessionID,
-    tool_name: pendingCall.tool.charAt(0).toUpperCase() + pendingCall.tool.slice(1),
-    transcript_path: "",
-    cwd: process.cwd(),
-    hook_event_name: "PostToolUse",
-    tool_input: {
-      file_path: pendingCall.filePath,
-      content: pendingCall.content,
-      old_string: pendingCall.oldString,
-      new_string: pendingCall.newString,
-      edits: pendingCall.edits
-    }
+  return {
+    handleSessionRecovery,
+    isRecoverableError,
+    setOnAbortCallback,
+    setOnRecoveryCompleteCallback
   };
-  const result = await runCommentChecker(hookInput, cliPath);
-  if (result.hasComments && result.message) {
-    debugLog3("CLI detected comments, appending message");
-    output.output += `
+}
+// src/hooks/comment-checker/cli.ts
+var {spawn: spawn3 } = globalThis.Bun;
+import { createRequire as createRequire2 } from "module";
+import { dirname, join as join6 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import * as fs2 from "fs";
 
-${result.message}`;
-  } else {
-    debugLog3("CLI: no comments detected");
+// src/hooks/comment-checker/downloader.ts
+var {spawn: spawn2 } = globalThis.Bun;
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { homedir } from "os";
+import { createRequire } from "module";
+var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE = "/tmp/comment-checker-debug.log";
+function debugLog(...args) {
+  if (DEBUG) {
+    const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
+`;
+    appendFileSync2(DEBUG_FILE, msg);
   }
 }
-// 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);
+var REPO = "code-yeongyu/go-claude-code-comment-checker";
+var PLATFORM_MAP = {
+  "darwin-arm64": { os: "darwin", arch: "arm64", ext: "tar.gz" },
+  "darwin-x64": { os: "darwin", arch: "amd64", ext: "tar.gz" },
+  "linux-arm64": { os: "linux", arch: "arm64", ext: "tar.gz" },
+  "linux-x64": { os: "linux", arch: "amd64", ext: "tar.gz" },
+  "win32-x64": { os: "windows", arch: "amd64", ext: "zip" }
+};
+function getCacheDir() {
+  const xdgCache2 = process.env.XDG_CACHE_HOME;
+  const base = xdgCache2 || join5(homedir(), ".cache");
+  return join5(base, "oh-my-opencode", "bin");
 }
-function truncateToTokenLimit(output, maxTokens) {
-  const currentTokens = estimateTokens(output);
-  if (currentTokens <= maxTokens) {
-    return { result: output, truncated: false };
+function getBinaryName() {
+  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
+}
+function getCachedBinaryPath() {
+  const binaryPath = join5(getCacheDir(), getBinaryName());
+  return existsSync4(binaryPath) ? binaryPath : null;
+}
+function getPackageVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("@code-yeongyu/comment-checker/package.json");
+    return pkg.version;
+  } catch {
+    return "0.4.1";
   }
-  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
-    };
+}
+async function extractTarGz(archivePath, destDir) {
+  debugLog("Extracting tar.gz:", archivePath, "to", destDir);
+  const proc = spawn2(["tar", "-xzf", archivePath, "-C", destDir], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`tar extraction failed (exit ${exitCode}): ${stderr}`);
   }
-  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
-    };
+}
+async function extractZip(archivePath, destDir) {
+  debugLog("Extracting zip:", archivePath, "to", destDir);
+  const proc = process.platform === "win32" ? spawn2(["powershell", "-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], {
+    stdout: "pipe",
+    stderr: "pipe"
+  }) : spawn2(["unzip", "-o", archivePath, "-d", destDir], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
   }
-  let resultLines = [];
-  let currentTokenCount = 0;
-  for (const line of contentLines) {
-    const lineTokens = estimateTokens(line + `
-`);
-    if (currentTokenCount + lineTokens > availableTokens) {
-      break;
-    }
-    resultLines.push(line);
-    currentTokenCount += lineTokens;
+}
+async function downloadCommentChecker() {
+  const platformKey = `${process.platform}-${process.arch}`;
+  const platformInfo = PLATFORM_MAP[platformKey];
+  if (!platformInfo) {
+    debugLog(`Unsupported platform: ${platformKey}`);
+    return null;
+  }
+  const cacheDir = getCacheDir();
+  const binaryName = getBinaryName();
+  const binaryPath = join5(cacheDir, binaryName);
+  if (existsSync4(binaryPath)) {
+    debugLog("Binary already cached at:", binaryPath);
+    return binaryPath;
+  }
+  const version = getPackageVersion();
+  const { os: os3, arch, ext } = platformInfo;
+  const assetName = `comment-checker_v${version}_${os3}_${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 (!existsSync4(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 = join5(cacheDir, assetName);
+    const arrayBuffer = await response.arrayBuffer();
+    await Bun.write(archivePath, arrayBuffer);
+    debugLog(`Downloaded archive to: ${archivePath}`);
+    if (ext === "tar.gz") {
+      await extractTarGz(archivePath, cacheDir);
+    } else {
+      await extractZip(archivePath, cacheDir);
+    }
+    if (existsSync4(archivePath)) {
+      unlinkSync2(archivePath);
+    }
+    if (process.platform !== "win32" && existsSync4(binaryPath)) {
+      chmodSync(binaryPath, 493);
+    }
+    debugLog(`Successfully downloaded binary to: ${binaryPath}`);
+    console.log(`[oh-my-opencode] comment-checker binary ready.`);
+    return binaryPath;
+  } catch (err) {
+    debugLog(`Failed to download: ${err}`);
+    console.error(`[oh-my-opencode] Failed to download comment-checker: ${err instanceof Error ? err.message : err}`);
+    console.error(`[oh-my-opencode] Comment checking disabled.`);
+    return null;
   }
-  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 lastAssistant = assistantMessages[assistantMessages.length - 1];
-      const lastTokens = lastAssistant.tokens;
-      const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 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
-  };
+async function ensureCommentCheckerBinary() {
+  const cachedPath = getCachedBinaryPath();
+  if (cachedPath) {
+    debugLog("Using cached binary:", cachedPath);
+    return cachedPath;
+  }
+  return downloadCommentChecker();
 }
-// 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`);
+// src/hooks/comment-checker/cli.ts
+var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE2 = "/tmp/comment-checker-debug.log";
+function debugLog2(...args) {
+  if (DEBUG2) {
+    const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
+`;
+    fs2.appendFileSync(DEBUG_FILE2, msg);
+  }
 }
-function loadInjectedPaths(sessionID) {
-  const filePath = getStoragePath(sessionID);
-  if (!existsSync5(filePath))
-    return new Set;
+function getBinaryName2() {
+  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
+}
+function findCommentCheckerPathSync() {
+  const binaryName = getBinaryName2();
   try {
-    const content = readFileSync2(filePath, "utf-8");
-    const data = JSON.parse(content);
-    return new Set(data.injectedPaths);
+    const require2 = createRequire2(import.meta.url);
+    const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
+    const cliDir = dirname(cliPkgPath);
+    const binaryPath = join6(cliDir, "bin", binaryName);
+    if (existsSync5(binaryPath)) {
+      debugLog2("found binary in main package:", binaryPath);
+      return binaryPath;
+    }
   } catch {
-    return new Set;
+    debugLog2("main package not installed");
+  }
+  const cachedPath = getCachedBinaryPath();
+  if (cachedPath) {
+    debugLog2("found binary in cache:", cachedPath);
+    return cachedPath;
   }
+  debugLog2("no binary found in known locations");
+  return null;
 }
-function saveInjectedPaths(sessionID, paths) {
-  if (!existsSync5(AGENTS_INJECTOR_STORAGE)) {
-    mkdirSync3(AGENTS_INJECTOR_STORAGE, { recursive: true });
+var resolvedCliPath = null;
+var initPromise = null;
+async function getCommentCheckerPath() {
+  if (resolvedCliPath !== null) {
+    return resolvedCliPath;
   }
-  const data = {
-    sessionID,
-    injectedPaths: [...paths],
-    updatedAt: Date.now()
-  };
-  writeFileSync2(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+  if (initPromise) {
+    return initPromise;
+  }
+  initPromise = (async () => {
+    const syncPath = findCommentCheckerPathSync();
+    if (syncPath && existsSync5(syncPath)) {
+      resolvedCliPath = syncPath;
+      debugLog2("using sync-resolved path:", syncPath);
+      return syncPath;
+    }
+    debugLog2("triggering lazy download...");
+    const downloadedPath = await ensureCommentCheckerBinary();
+    if (downloadedPath) {
+      resolvedCliPath = downloadedPath;
+      debugLog2("using downloaded path:", downloadedPath);
+      return downloadedPath;
+    }
+    debugLog2("no binary available");
+    return null;
+  })();
+  return initPromise;
 }
-function clearInjectedPaths(sessionID) {
-  const filePath = getStoragePath(sessionID);
-  if (existsSync5(filePath)) {
-    unlinkSync3(filePath);
+function startBackgroundInit() {
+  if (!initPromise) {
+    initPromise = getCommentCheckerPath();
+    initPromise.then((path3) => {
+      debugLog2("background init complete:", path3 || "no binary");
+    }).catch((err) => {
+      debugLog2("background init error:", err);
+    });
   }
 }
-
-// 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);
+var COMMENT_CHECKER_CLI_PATH = findCommentCheckerPathSync();
+async function runCommentChecker(input, cliPath) {
+  const binaryPath = cliPath ?? resolvedCliPath ?? COMMENT_CHECKER_CLI_PATH;
+  if (!binaryPath) {
+    debugLog2("comment-checker binary not found");
+    return { hasComments: false, message: "" };
   }
-  function resolveFilePath(title) {
-    if (!title)
-      return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve(ctx.directory, title);
+  if (!existsSync5(binaryPath)) {
+    debugLog2("comment-checker binary does not exist:", binaryPath);
+    return { hasComments: false, message: "" };
   }
-  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;
+  const jsonInput = JSON.stringify(input);
+  debugLog2("running comment-checker with input:", jsonInput.substring(0, 200));
+  try {
+    const proc = spawn3([binaryPath], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    proc.stdin.write(jsonInput);
+    proc.stdin.end();
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    debugLog2("exit code:", exitCode, "stdout length:", stdout.length, "stderr length:", stderr.length);
+    if (exitCode === 0) {
+      return { hasComments: false, message: "" };
     }
-    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 (exitCode === 2) {
+      return { hasComments: true, message: stderr };
     }
-    if (toInject.length === 0)
-      return;
-    for (const { path: path2, content } of toInject) {
-      output.output += `
+    debugLog2("unexpected exit code:", exitCode, "stderr:", stderr);
+    return { hasComments: false, message: "" };
+  } catch (err) {
+    debugLog2("failed to run comment-checker:", err);
+    return { hasComments: false, message: "" };
+  }
+}
 
-[Directory Context: ${path2}]
-${content}`;
+// src/hooks/comment-checker/index.ts
+import * as fs3 from "fs";
+import { existsSync as existsSync6 } from "fs";
+var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE3 = "/tmp/comment-checker-debug.log";
+function debugLog3(...args) {
+  if (DEBUG3) {
+    const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
+`;
+    fs3.appendFileSync(DEBUG_FILE3, msg);
+  }
+}
+var pendingCalls = new Map;
+var PENDING_CALL_TTL = 60000;
+var cliPathPromise = null;
+function cleanupOldPendingCalls() {
+  const now = Date.now();
+  for (const [callID, call] of pendingCalls) {
+    if (now - call.timestamp > PENDING_CALL_TTL) {
+      pendingCalls.delete(callID);
     }
-    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);
+  }
+}
+setInterval(cleanupOldPendingCalls, 1e4);
+function createCommentCheckerHooks() {
+  debugLog3("createCommentCheckerHooks called");
+  startBackgroundInit();
+  cliPathPromise = getCommentCheckerPath();
+  cliPathPromise.then((path3) => {
+    debugLog3("CLI path resolved:", path3 || "disabled (no binary)");
+  }).catch((err) => {
+    debugLog3("CLI path resolution error:", err);
+  });
+  return {
+    "tool.execute.before": async (input, output) => {
+      debugLog3("tool.execute.before:", { tool: input.tool, callID: input.callID, args: output.args });
+      const toolLower = input.tool.toLowerCase();
+      if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
+        debugLog3("skipping non-write/edit tool:", toolLower);
+        return;
       }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        sessionCaches.delete(sessionID);
-        clearInjectedPaths(sessionID);
+      const filePath = output.args.filePath ?? output.args.file_path ?? output.args.path;
+      const content = output.args.content;
+      const oldString = output.args.oldString ?? output.args.old_string;
+      const newString = output.args.newString ?? output.args.new_string;
+      const edits = output.args.edits;
+      debugLog3("extracted filePath:", filePath);
+      if (!filePath) {
+        debugLog3("no filePath found");
+        return;
+      }
+      debugLog3("registering pendingCall:", { callID: input.callID, filePath, tool: toolLower });
+      pendingCalls.set(input.callID, {
+        filePath,
+        content,
+        oldString,
+        newString,
+        edits,
+        tool: toolLower,
+        sessionID: input.sessionID,
+        timestamp: Date.now()
+      });
+    },
+    "tool.execute.after": async (input, output) => {
+      debugLog3("tool.execute.after:", { tool: input.tool, callID: input.callID });
+      const pendingCall = pendingCalls.get(input.callID);
+      if (!pendingCall) {
+        debugLog3("no pendingCall found for:", input.callID);
+        return;
+      }
+      pendingCalls.delete(input.callID);
+      debugLog3("processing pendingCall:", pendingCall);
+      const outputLower = output.output.toLowerCase();
+      const isToolFailure = outputLower.includes("error:") || outputLower.includes("failed to") || outputLower.includes("could not") || outputLower.startsWith("error");
+      if (isToolFailure) {
+        debugLog3("skipping due to tool failure in output");
+        return;
+      }
+      try {
+        const cliPath = await cliPathPromise;
+        if (!cliPath || !existsSync6(cliPath)) {
+          debugLog3("CLI not available, skipping comment check");
+          return;
+        }
+        debugLog3("using CLI:", cliPath);
+        await processWithCli(input, pendingCall, output, cliPath);
+      } catch (err) {
+        debugLog3("tool.execute.after failed:", err);
       }
     }
   };
+}
+async function processWithCli(input, pendingCall, output, cliPath) {
+  debugLog3("using CLI mode with path:", cliPath);
+  const hookInput = {
+    session_id: pendingCall.sessionID,
+    tool_name: pendingCall.tool.charAt(0).toUpperCase() + pendingCall.tool.slice(1),
+    transcript_path: "",
+    cwd: process.cwd(),
+    hook_event_name: "PostToolUse",
+    tool_input: {
+      file_path: pendingCall.filePath,
+      content: pendingCall.content,
+      old_string: pendingCall.oldString,
+      new_string: pendingCall.newString,
+      edits: pendingCall.edits
+    }
+  };
+  const result = await runCommentChecker(hookInput, cliPath);
+  if (result.hasComments && result.message) {
+    debugLog3("CLI detected comments, appending message");
+    output.output += `
+
+${result.message}`;
+  } else {
+    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 lastAssistant = assistantMessages[assistantMessages.length - 1];
+      const lastTokens = lastAssistant.tokens;
+      const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 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,
-    event: eventHandler
+    "tool.execute.after": toolExecuteAfter
   };
 }
-// src/hooks/directory-readme-injector/index.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname3, join as join10, resolve as resolve2 } from "path";
+// src/hooks/directory-agents-injector/index.ts
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join9, resolve } from "path";
 
-// src/hooks/directory-readme-injector/storage.ts
+// src/hooks/directory-agents-injector/storage.ts
 import {
   existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync4,
-  writeFileSync as writeFileSync3,
-  unlinkSync as unlinkSync4
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  unlinkSync as unlinkSync3
 } from "fs";
-import { join as join9 } from "path";
-
-// src/hooks/directory-readme-injector/constants.ts
 import { join as join8 } from "path";
-var OPENCODE_STORAGE3 = join8(xdgData ?? "", "opencode", "storage");
-var README_INJECTOR_STORAGE = join8(OPENCODE_STORAGE3, "directory-readme");
-var README_FILENAME = "README.md";
 
-// src/hooks/directory-readme-injector/storage.ts
-function getStoragePath2(sessionID) {
-  return join9(README_INJECTOR_STORAGE, `${sessionID}.json`);
+// src/hooks/directory-agents-injector/constants.ts
+import { join as join7 } from "path";
+var OPENCODE_STORAGE2 = join7(xdgData ?? "", "opencode", "storage");
+var AGENTS_INJECTOR_STORAGE = join7(OPENCODE_STORAGE2, "directory-agents");
+var AGENTS_FILENAME = "AGENTS.md";
+
+// src/hooks/directory-agents-injector/storage.ts
+function getStoragePath(sessionID) {
+  return join8(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
 }
-function loadInjectedPaths2(sessionID) {
-  const filePath = getStoragePath2(sessionID);
+function loadInjectedPaths(sessionID) {
+  const filePath = getStoragePath(sessionID);
   if (!existsSync7(filePath))
     return new Set;
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
     return new Set;
   }
 }
-function saveInjectedPaths2(sessionID, paths) {
-  if (!existsSync7(README_INJECTOR_STORAGE)) {
-    mkdirSync4(README_INJECTOR_STORAGE, { recursive: true });
+function saveInjectedPaths(sessionID, paths) {
+  if (!existsSync7(AGENTS_INJECTOR_STORAGE)) {
+    mkdirSync3(AGENTS_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
     sessionID,
     injectedPaths: [...paths],
     updatedAt: Date.now()
   };
-  writeFileSync3(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
+  writeFileSync2(getStoragePath(sessionID), JSON.stringify(data, null, 2));
 }
-function clearInjectedPaths2(sessionID) {
-  const filePath = getStoragePath2(sessionID);
+function clearInjectedPaths(sessionID) {
+  const filePath = getStoragePath(sessionID);
   if (existsSync7(filePath)) {
-    unlinkSync4(filePath);
+    unlinkSync3(filePath);
   }
 }
 
-// src/hooks/directory-readme-injector/index.ts
-function createDirectoryReadmeInjectorHook(ctx) {
+// src/hooks/directory-agents-injector/index.ts
+function createDirectoryAgentsInjectorHook(ctx) {
   const sessionCaches = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
-      sessionCaches.set(sessionID, loadInjectedPaths2(sessionID));
+      sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath(title) {
+  function resolveFilePath2(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 = join9(current, AGENTS_FILENAME);
+      if (existsSync8(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 = resolveFilePath2(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 = readFileSync4(agentsPath, "utf-8");
+        toInject.push({ path: agentsPath, content });
+        cache.add(agentsDir);
+      } catch {}
+    }
+    if (toInject.length === 0)
+      return;
+    for (const { path: path3, content } of toInject) {
+      output.output += `
+
+[Directory Context: ${path3}]
+${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/directory-readme-injector/index.ts
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, join as join12, resolve as resolve2 } from "path";
+
+// src/hooks/directory-readme-injector/storage.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync3,
+  unlinkSync as unlinkSync4
+} from "fs";
+import { join as join11 } from "path";
+
+// src/hooks/directory-readme-injector/constants.ts
+import { join as join10 } from "path";
+var OPENCODE_STORAGE3 = join10(xdgData ?? "", "opencode", "storage");
+var README_INJECTOR_STORAGE = join10(OPENCODE_STORAGE3, "directory-readme");
+var README_FILENAME = "README.md";
+
+// src/hooks/directory-readme-injector/storage.ts
+function getStoragePath2(sessionID) {
+  return join11(README_INJECTOR_STORAGE, `${sessionID}.json`);
+}
+function loadInjectedPaths2(sessionID) {
+  const filePath = getStoragePath2(sessionID);
+  if (!existsSync9(filePath))
+    return new Set;
+  try {
+    const content = readFileSync5(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return new Set(data.injectedPaths);
+  } catch {
+    return new Set;
+  }
+}
+function saveInjectedPaths2(sessionID, paths) {
+  if (!existsSync9(README_INJECTOR_STORAGE)) {
+    mkdirSync4(README_INJECTOR_STORAGE, { recursive: true });
+  }
+  const data = {
+    sessionID,
+    injectedPaths: [...paths],
+    updatedAt: Date.now()
+  };
+  writeFileSync3(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
+}
+function clearInjectedPaths2(sessionID) {
+  const filePath = getStoragePath2(sessionID);
+  if (existsSync9(filePath)) {
+    unlinkSync4(filePath);
+  }
+}
+
+// src/hooks/directory-readme-injector/index.ts
+function createDirectoryReadmeInjectorHook(ctx) {
+  const sessionCaches = new Map;
+  function getSessionCache(sessionID) {
+    if (!sessionCaches.has(sessionID)) {
+      sessionCaches.set(sessionID, loadInjectedPaths2(sessionID));
+    }
+    return sessionCaches.get(sessionID);
+  }
+  function resolveFilePath2(title) {
     if (!title)
       return null;
     if (title.startsWith("/"))
@@ -3706,8 +4063,8 @@ function createDirectoryReadmeInjectorHook(ctx) {
     const found = [];
     let current = startDir;
     while (true) {
-      const readmePath = join10(current, README_FILENAME);
-      if (existsSync8(readmePath)) {
+      const readmePath = join12(current, README_FILENAME);
+      if (existsSync10(readmePath)) {
         found.push(readmePath);
       }
       if (current === ctx.directory)
@@ -3724,7 +4081,7 @@ function createDirectoryReadmeInjectorHook(ctx) {
   const toolExecuteAfter = async (input, output) => {
     if (input.tool.toLowerCase() !== "read")
       return;
-    const filePath = resolveFilePath(output.title);
+    const filePath = resolveFilePath2(output.title);
     if (!filePath)
       return;
     const dir = dirname3(filePath);
@@ -3736,17 +4093,17 @@ function createDirectoryReadmeInjectorHook(ctx) {
       if (cache.has(readmeDir))
         continue;
       try {
-        const content = readFileSync5(readmePath, "utf-8");
+        const content = readFileSync6(readmePath, "utf-8");
         toInject.push({ path: readmePath, content });
         cache.add(readmeDir);
       } catch {}
     }
     if (toInject.length === 0)
       return;
-    for (const { path: path2, content } of toInject) {
+    for (const { path: path3, content } of toInject) {
       output.output += `
 
-[Project README: ${path2}]
+[Project README: ${path3}]
 ${content}`;
     }
     saveInjectedPaths2(input.sessionID, cache);
@@ -4310,477 +4667,167 @@ function createThinkModeHook() {
         return;
       }
       output.message.model = {
-        providerID: currentModel.providerID,
-        modelID: highVariant
-      };
-      state.modelSwitched = true;
-      thinkModeState.set(sessionID, state);
-    },
-    event: async ({ event }) => {
-      if (event.type === "session.deleted") {
-        const props = event.properties;
-        if (props?.info?.id) {
-          thinkModeState.delete(props.info.id);
-        }
-      }
-    }
-  };
-}
-// src/hooks/claude-code-hooks/config.ts
-import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
-import { existsSync as existsSync9 } from "fs";
-function normalizeHookMatcher(raw) {
-  return {
-    matcher: raw.matcher ?? raw.pattern ?? "*",
-    hooks: raw.hooks
-  };
-}
-function normalizeHooksConfig(raw) {
-  const result = {};
-  const eventTypes = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "Stop"
-  ];
-  for (const eventType of eventTypes) {
-    if (raw[eventType]) {
-      result[eventType] = raw[eventType].map(normalizeHookMatcher);
-    }
-  }
-  return result;
-}
-function getClaudeSettingsPaths(customPath) {
-  const home = homedir2();
-  const paths = [
-    join11(home, ".claude", "settings.json"),
-    join11(process.cwd(), ".claude", "settings.json"),
-    join11(process.cwd(), ".claude", "settings.local.json")
-  ];
-  if (customPath && existsSync9(customPath)) {
-    paths.unshift(customPath);
-  }
-  return paths;
-}
-function mergeHooksConfig(base, override) {
-  const result = { ...base };
-  const eventTypes = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "Stop"
-  ];
-  for (const eventType of eventTypes) {
-    if (override[eventType]) {
-      result[eventType] = [...base[eventType] || [], ...override[eventType]];
-    }
-  }
-  return result;
-}
-async function loadClaudeHooksConfig(customSettingsPath) {
-  const paths = getClaudeSettingsPaths(customSettingsPath);
-  let mergedConfig = {};
-  for (const settingsPath of paths) {
-    if (existsSync9(settingsPath)) {
-      try {
-        const content = await Bun.file(settingsPath).text();
-        const settings = JSON.parse(content);
-        if (settings.hooks) {
-          const normalizedHooks = normalizeHooksConfig(settings.hooks);
-          mergedConfig = mergeHooksConfig(mergedConfig, normalizedHooks);
-        }
-      } catch {
-        continue;
-      }
-    }
-  }
-  return Object.keys(mergedConfig).length > 0 ? mergedConfig : null;
-}
-
-// src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync10 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join13 } from "path";
-
-// src/shared/logger.ts
-import * as fs3 from "fs";
-import * as os2 from "os";
-import * as path2 from "path";
-var logFile = path2.join(os2.tmpdir(), "oh-my-opencode.log");
-function log(message, data) {
-  try {
-    const timestamp = new Date().toISOString();
-    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
-`;
-    fs3.appendFileSync(logFile, logEntry);
-  } catch {}
-}
-
-// src/hooks/claude-code-hooks/config-loader.ts
-var USER_CONFIG_PATH = join13(homedir3(), ".config", "opencode", "opencode-cc-plugin.json");
-function getProjectConfigPath() {
-  return join13(process.cwd(), ".opencode", "opencode-cc-plugin.json");
-}
-async function loadConfigFromPath(path3) {
-  if (!existsSync10(path3)) {
-    return null;
-  }
-  try {
-    const content = await Bun.file(path3).text();
-    return JSON.parse(content);
-  } catch (error) {
-    log("Failed to load config", { path: path3, error });
-    return null;
-  }
-}
-function mergeDisabledHooks(base, override) {
-  if (!override)
-    return base ?? {};
-  if (!base)
-    return override;
-  return {
-    Stop: override.Stop ?? base.Stop,
-    PreToolUse: override.PreToolUse ?? base.PreToolUse,
-    PostToolUse: override.PostToolUse ?? base.PostToolUse,
-    UserPromptSubmit: override.UserPromptSubmit ?? base.UserPromptSubmit
-  };
-}
-async function loadPluginExtendedConfig() {
-  const userConfig = await loadConfigFromPath(USER_CONFIG_PATH);
-  const projectConfig = await loadConfigFromPath(getProjectConfigPath());
-  const merged = {
-    disabledHooks: mergeDisabledHooks(userConfig?.disabledHooks, projectConfig?.disabledHooks)
-  };
-  if (userConfig || projectConfig) {
-    log("Plugin extended config loaded", {
-      userConfigExists: userConfig !== null,
-      projectConfigExists: projectConfig !== null,
-      mergedDisabledHooks: merged.disabledHooks
-    });
-  }
-  return merged;
-}
-var regexCache = new Map;
-function getRegex(pattern) {
-  let regex = regexCache.get(pattern);
-  if (!regex) {
-    try {
-      regex = new RegExp(pattern);
-      regexCache.set(pattern, regex);
-    } catch {
-      regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-      regexCache.set(pattern, regex);
-    }
-  }
-  return regex;
-}
-function isHookCommandDisabled(eventType, command, config) {
-  if (!config?.disabledHooks)
-    return false;
-  const patterns = config.disabledHooks[eventType];
-  if (!patterns || patterns.length === 0)
-    return false;
-  return patterns.some((pattern) => {
-    const regex = getRegex(pattern);
-    return regex.test(command);
-  });
-}
-
-// src/shared/frontmatter.ts
-function parseFrontmatter(content) {
-  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
-  const match = content.match(frontmatterRegex);
-  if (!match) {
-    return { data: {}, body: content };
-  }
-  const yamlContent = match[1];
-  const body = match[2];
-  const data = {};
-  for (const line of yamlContent.split(`
-`)) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex !== -1) {
-      const key = line.slice(0, colonIndex).trim();
-      let value = line.slice(colonIndex + 1).trim();
-      if (value === "true")
-        value = true;
-      else if (value === "false")
-        value = false;
-      data[key] = value;
-    }
-  }
-  return { data, body };
-}
-// src/shared/command-executor.ts
-import { spawn as spawn3 } from "child_process";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { existsSync as existsSync11 } from "fs";
-var DEFAULT_ZSH_PATHS = ["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh"];
-function findZshPath(customZshPath) {
-  if (customZshPath && existsSync11(customZshPath)) {
-    return customZshPath;
-  }
-  for (const path3 of DEFAULT_ZSH_PATHS) {
-    if (existsSync11(path3)) {
-      return path3;
-    }
-  }
-  return null;
-}
-var execAsync = promisify(exec);
-async function executeHookCommand(command, stdin, cwd, options) {
-  const home = process.env.HOME ?? "";
-  let expandedCommand = command.replace(/^~(?=\/|$)/g, home).replace(/\s~(?=\/)/g, ` ${home}`).replace(/\$CLAUDE_PROJECT_DIR/g, cwd).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd);
-  let finalCommand = expandedCommand;
-  if (options?.forceZsh) {
-    const zshPath = options.zshPath || findZshPath();
-    if (zshPath) {
-      const escapedCommand = expandedCommand.replace(/'/g, "'\\''");
-      finalCommand = `${zshPath} -lc '${escapedCommand}'`;
-    }
-  }
-  return new Promise((resolve3) => {
-    const proc = spawn3(finalCommand, {
-      cwd,
-      shell: true,
-      env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd }
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.stdin?.write(stdin);
-    proc.stdin?.end();
-    proc.on("close", (code) => {
-      resolve3({
-        exitCode: code ?? 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim()
-      });
-    });
-    proc.on("error", (err) => {
-      resolve3({
-        exitCode: 1,
-        stderr: err.message
-      });
-    });
-  });
-}
-async function executeCommand(command) {
-  try {
-    const { stdout, stderr } = await execAsync(command);
-    const out = stdout?.toString().trim() ?? "";
-    const err = stderr?.toString().trim() ?? "";
-    if (err) {
-      if (out) {
-        return `${out}
-[stderr: ${err}]`;
-      }
-      return `[stderr: ${err}]`;
-    }
-    return out;
-  } catch (error) {
-    const e = error;
-    const stdout = e?.stdout?.toString().trim() ?? "";
-    const stderr = e?.stderr?.toString().trim() ?? "";
-    const errMsg = stderr || e?.message || String(error);
-    if (stdout) {
-      return `${stdout}
-[stderr: ${errMsg}]`;
-    }
-    return `[stderr: ${errMsg}]`;
-  }
-}
-var COMMAND_PATTERN = /!`([^`]+)`/g;
-function findCommands(text) {
-  const matches = [];
-  let match;
-  COMMAND_PATTERN.lastIndex = 0;
-  while ((match = COMMAND_PATTERN.exec(text)) !== null) {
-    matches.push({
-      fullMatch: match[0],
-      command: match[1],
-      start: match.index,
-      end: match.index + match[0].length
-    });
-  }
-  return matches;
-}
-async function resolveCommandsInText(text, depth = 0, maxDepth = 3) {
-  if (depth >= maxDepth) {
-    return text;
-  }
-  const matches = findCommands(text);
-  if (matches.length === 0) {
-    return text;
-  }
-  const tasks = matches.map((m) => executeCommand(m.command));
-  const results = await Promise.allSettled(tasks);
-  const replacements = new Map;
-  matches.forEach((match, idx) => {
-    const result = results[idx];
-    if (result.status === "rejected") {
-      replacements.set(match.fullMatch, `[error: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}]`);
-    } else {
-      replacements.set(match.fullMatch, result.value);
+        providerID: currentModel.providerID,
+        modelID: highVariant
+      };
+      state.modelSwitched = true;
+      thinkModeState.set(sessionID, state);
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        if (props?.info?.id) {
+          thinkModeState.delete(props.info.id);
+        }
+      }
     }
-  });
-  let resolved = text;
-  for (const [pattern, replacement] of replacements.entries()) {
-    resolved = resolved.split(pattern).join(replacement);
-  }
-  if (findCommands(resolved).length > 0) {
-    return resolveCommandsInText(resolved, depth + 1, maxDepth);
-  }
-  return resolved;
+  };
 }
-// src/shared/file-reference-resolver.ts
-import { existsSync as existsSync12, readFileSync as readFileSync6, statSync } from "fs";
-import { join as join14, isAbsolute } from "path";
-var FILE_REFERENCE_PATTERN = /@([^\s@]+)/g;
-function findFileReferences(text) {
-  const matches = [];
-  let match;
-  FILE_REFERENCE_PATTERN.lastIndex = 0;
-  while ((match = FILE_REFERENCE_PATTERN.exec(text)) !== null) {
-    matches.push({
-      fullMatch: match[0],
-      filePath: match[1],
-      start: match.index,
-      end: match.index + match[0].length
-    });
-  }
-  return matches;
+// src/hooks/claude-code-hooks/config.ts
+import { homedir as homedir2 } from "os";
+import { join as join13 } from "path";
+import { existsSync as existsSync11 } from "fs";
+function normalizeHookMatcher(raw) {
+  return {
+    matcher: raw.matcher ?? raw.pattern ?? "*",
+    hooks: raw.hooks
+  };
 }
-function resolveFilePath(filePath, cwd) {
-  if (isAbsolute(filePath)) {
-    return filePath;
+function normalizeHooksConfig(raw) {
+  const result = {};
+  const eventTypes = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "Stop"
+  ];
+  for (const eventType of eventTypes) {
+    if (raw[eventType]) {
+      result[eventType] = raw[eventType].map(normalizeHookMatcher);
+    }
   }
-  return join14(cwd, filePath);
+  return result;
 }
-function readFileContent(resolvedPath) {
-  if (!existsSync12(resolvedPath)) {
-    return `[file not found: ${resolvedPath}]`;
-  }
-  const stat = statSync(resolvedPath);
-  if (stat.isDirectory()) {
-    return `[cannot read directory: ${resolvedPath}]`;
+function getClaudeSettingsPaths(customPath) {
+  const home = homedir2();
+  const paths = [
+    join13(home, ".claude", "settings.json"),
+    join13(process.cwd(), ".claude", "settings.json"),
+    join13(process.cwd(), ".claude", "settings.local.json")
+  ];
+  if (customPath && existsSync11(customPath)) {
+    paths.unshift(customPath);
   }
-  const content = readFileSync6(resolvedPath, "utf-8");
-  return content;
+  return paths;
 }
-async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0, maxDepth = 3) {
-  if (depth >= maxDepth) {
-    return text;
-  }
-  const matches = findFileReferences(text);
-  if (matches.length === 0) {
-    return text;
-  }
-  const replacements = new Map;
-  for (const match of matches) {
-    const resolvedPath = resolveFilePath(match.filePath, cwd);
-    const content = readFileContent(resolvedPath);
-    replacements.set(match.fullMatch, content);
-  }
-  let resolved = text;
-  for (const [pattern, replacement] of replacements.entries()) {
-    resolved = resolved.split(pattern).join(replacement);
-  }
-  if (findFileReferences(resolved).length > 0 && depth + 1 < maxDepth) {
-    return resolveFileReferencesInText(resolved, cwd, depth + 1, maxDepth);
+function mergeHooksConfig(base, override) {
+  const result = { ...base };
+  const eventTypes = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "Stop"
+  ];
+  for (const eventType of eventTypes) {
+    if (override[eventType]) {
+      result[eventType] = [...base[eventType] || [], ...override[eventType]];
+    }
   }
-  return resolved;
-}
-// src/shared/model-sanitizer.ts
-function sanitizeModelField(_model) {
-  return;
-}
-// src/shared/snake-case.ts
-function camelToSnake(str) {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return result;
 }
-function objectToSnakeCase(obj, deep = true) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const snakeKey = camelToSnake(key);
-    if (deep && isPlainObject(value)) {
-      result[snakeKey] = objectToSnakeCase(value, true);
-    } else if (deep && Array.isArray(value)) {
-      result[snakeKey] = value.map((item) => isPlainObject(item) ? objectToSnakeCase(item, true) : item);
-    } else {
-      result[snakeKey] = value;
+async function loadClaudeHooksConfig(customSettingsPath) {
+  const paths = getClaudeSettingsPaths(customSettingsPath);
+  let mergedConfig = {};
+  for (const settingsPath of paths) {
+    if (existsSync11(settingsPath)) {
+      try {
+        const content = await Bun.file(settingsPath).text();
+        const settings = JSON.parse(content);
+        if (settings.hooks) {
+          const normalizedHooks = normalizeHooksConfig(settings.hooks);
+          mergedConfig = mergeHooksConfig(mergedConfig, normalizedHooks);
+        }
+      } catch {
+        continue;
+      }
     }
   }
-  return result;
+  return Object.keys(mergedConfig).length > 0 ? mergedConfig : null;
 }
-// src/shared/tool-name.ts
-var SPECIAL_TOOL_MAPPINGS = {
-  webfetch: "WebFetch",
-  websearch: "WebSearch",
-  todoread: "TodoRead",
-  todowrite: "TodoWrite"
-};
-function toPascalCase(str) {
-  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+
+// src/hooks/claude-code-hooks/config-loader.ts
+import { existsSync as existsSync12 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join14 } from "path";
+var USER_CONFIG_PATH = join14(homedir3(), ".config", "opencode", "opencode-cc-plugin.json");
+function getProjectConfigPath() {
+  return join14(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
-function transformToolName(toolName) {
-  const lower = toolName.toLowerCase();
-  if (lower in SPECIAL_TOOL_MAPPINGS) {
-    return SPECIAL_TOOL_MAPPINGS[lower];
+async function loadConfigFromPath(path3) {
+  if (!existsSync12(path3)) {
+    return null;
   }
-  if (toolName.includes("-") || toolName.includes("_")) {
-    return toPascalCase(toolName);
+  try {
+    const content = await Bun.file(path3).text();
+    return JSON.parse(content);
+  } catch (error) {
+    log("Failed to load config", { path: path3, error });
+    return null;
   }
-  return toolName.charAt(0).toUpperCase() + toolName.slice(1);
 }
-// src/shared/pattern-matcher.ts
-function matchesToolMatcher(toolName, matcher) {
-  if (!matcher) {
-    return true;
+function mergeDisabledHooks(base, override) {
+  if (!override)
+    return base ?? {};
+  if (!base)
+    return override;
+  return {
+    Stop: override.Stop ?? base.Stop,
+    PreToolUse: override.PreToolUse ?? base.PreToolUse,
+    PostToolUse: override.PostToolUse ?? base.PostToolUse,
+    UserPromptSubmit: override.UserPromptSubmit ?? base.UserPromptSubmit
+  };
+}
+async function loadPluginExtendedConfig() {
+  const userConfig = await loadConfigFromPath(USER_CONFIG_PATH);
+  const projectConfig = await loadConfigFromPath(getProjectConfigPath());
+  const merged = {
+    disabledHooks: mergeDisabledHooks(userConfig?.disabledHooks, projectConfig?.disabledHooks)
+  };
+  if (userConfig || projectConfig) {
+    log("Plugin extended config loaded", {
+      userConfigExists: userConfig !== null,
+      projectConfigExists: projectConfig !== null,
+      mergedDisabledHooks: merged.disabledHooks
+    });
   }
-  const patterns = matcher.split("|").map((p) => p.trim());
-  return patterns.some((p) => {
-    if (p.includes("*")) {
-      const regex = new RegExp(`^${p.replace(/\*/g, ".*")}$`, "i");
-      return regex.test(toolName);
-    }
-    return p.toLowerCase() === toolName.toLowerCase();
-  });
+  return merged;
 }
-function findMatchingHooks(config, eventName, toolName) {
-  const hookMatchers = config[eventName];
-  if (!hookMatchers)
-    return [];
-  return hookMatchers.filter((hookMatcher) => {
-    if (!toolName)
-      return true;
-    return matchesToolMatcher(toolName, hookMatcher.matcher);
-  });
+var regexCache = new Map;
+function getRegex(pattern) {
+  let regex = regexCache.get(pattern);
+  if (!regex) {
+    try {
+      regex = new RegExp(pattern);
+      regexCache.set(pattern, regex);
+    } catch {
+      regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      regexCache.set(pattern, regex);
+    }
+  }
+  return regex;
 }
-// src/shared/hook-disabled.ts
-function isHookDisabled(config, hookType) {
-  const { disabledHooks } = config;
-  if (disabledHooks === undefined) {
+function isHookCommandDisabled(eventType, command, config) {
+  if (!config?.disabledHooks)
     return false;
-  }
-  if (disabledHooks === true) {
-    return true;
-  }
-  if (Array.isArray(disabledHooks)) {
-    return disabledHooks.includes(hookType);
-  }
-  return false;
+  const patterns = config.disabledHooks[eventType];
+  if (!patterns || patterns.length === 0)
+    return false;
+  return patterns.some((pattern) => {
+    const regex = getRegex(pattern);
+    return regex.test(command);
+  });
 }
+
 // src/hooks/claude-code-hooks/plugin-config.ts
 var DEFAULT_CONFIG = {
   forceZsh: true,
@@ -8419,7 +8466,7 @@ __export(exports_util, {
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
   issue: () => issue,
-  isPlainObject: () => isPlainObject2,
+  isPlainObject: () => isPlainObject3,
   isObject: () => isObject,
   hexToUint8Array: () => hexToUint8Array,
   getSizableOrigin: () => getSizableOrigin,
@@ -8601,7 +8648,7 @@ var allowsEval = cached(() => {
     return false;
   }
 });
-function isPlainObject2(o) {
+function isPlainObject3(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -8616,7 +8663,7 @@ function isPlainObject2(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject2(o))
+  if (isPlainObject3(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -8799,7 +8846,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -8818,7 +8865,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = {
@@ -10968,7 +11015,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject2(a) && isPlainObject2(b)) {
+  if (isPlainObject3(a) && isPlainObject3(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -11098,7 +11145,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
     const input = payload.value;
-    if (!isPlainObject2(input)) {
+    if (!isPlainObject3(input)) {
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
@@ -22680,7 +22727,7 @@ function mergeConfigs(base, override) {
   return {
     ...base,
     ...override,
-    agents: override.agents !== undefined ? { ...base.agents ?? {}, ...override.agents } : base.agents,
+    agents: deepMerge(base.agents, override.agents),
     disabled_agents: [
       ...new Set([
         ...base.disabled_agents ?? [],
@@ -22693,7 +22740,7 @@ function mergeConfigs(base, override) {
         ...override.disabled_mcps ?? []
       ])
     ],
-    claude_code: override.claude_code !== undefined || base.claude_code !== undefined ? { ...base.claude_code ?? {}, ...override.claude_code ?? {} } : undefined
+    claude_code: deepMerge(base.claude_code, override.claude_code)
   };
 }
 function loadPluginConfig(directory) {
@@ -22717,6 +22764,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
   const contextWindowMonitor = createContextWindowMonitorHook(ctx);
   const sessionRecovery = createSessionRecoveryHook(ctx);
+  sessionRecovery.setOnAbortCallback(todoContinuationEnforcer.markRecovering);
+  sessionRecovery.setOnRecoveryCompleteCallback(todoContinuationEnforcer.markRecoveryComplete);
   const commentChecker = createCommentCheckerHooks();
   const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
   const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
@@ -22795,7 +22844,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await autoUpdateChecker.event(input);
       await claudeCodeHooks.event(input);
       await backgroundNotificationHook.event(input);
-      await todoContinuationEnforcer(input);
+      await todoContinuationEnforcer.handler(input);
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
       await directoryReadmeInjector.event(input);