oh-my-opencode 0.1.32 → 0.3.0

package/dist/index.js

@@ -1989,10 +1989,166 @@ function createThinkModeHook() {
     }
   };
 }
-// src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+// src/hooks/claude-code-hooks/config.ts
 import { homedir as homedir2 } from "os";
-import { join as join8, basename } from "path";
+import { join as join8 } from "path";
+import { existsSync as existsSync7 } 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 = [
+    join8(home, ".claude", "settings.json"),
+    join8(process.cwd(), ".claude", "settings.json"),
+    join8(process.cwd(), ".claude", "settings.local.json")
+  ];
+  if (customPath && existsSync7(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 (existsSync7(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 existsSync8 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join10 } 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 = join10(homedir3(), ".config", "opencode", "opencode-cc-plugin.json");
+function getProjectConfigPath() {
+  return join10(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+}
+async function loadConfigFromPath(path3) {
+  if (!existsSync8(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) {
@@ -2017,31 +2173,1181 @@ function parseFrontmatter(content) {
       data[key] = value;
     }
   }
-  return { data, body };
+  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 existsSync9 } from "fs";
+var DEFAULT_ZSH_PATHS = ["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh"];
+function findZshPath(customZshPath) {
+  if (customZshPath && existsSync9(customZshPath)) {
+    return customZshPath;
+  }
+  for (const path3 of DEFAULT_ZSH_PATHS) {
+    if (existsSync9(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((resolve2) => {
+    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) => {
+      resolve2({
+        exitCode: code ?? 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      });
+    });
+    proc.on("error", (err) => {
+      resolve2({
+        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);
+    }
+  });
+  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 existsSync10, readFileSync as readFileSync4, statSync } from "fs";
+import { join as join11, 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;
+}
+function resolveFilePath(filePath, cwd) {
+  if (isAbsolute(filePath)) {
+    return filePath;
+  }
+  return join11(cwd, filePath);
+}
+function readFileContent(resolvedPath) {
+  if (!existsSync10(resolvedPath)) {
+    return `[file not found: ${resolvedPath}]`;
+  }
+  const stat = statSync(resolvedPath);
+  if (stat.isDirectory()) {
+    return `[cannot read directory: ${resolvedPath}]`;
+  }
+  const content = readFileSync4(resolvedPath, "utf-8");
+  return content;
+}
+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);
+  }
+  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);
+}
+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;
+}
+// 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 transformToolName(toolName) {
+  const lower = toolName.toLowerCase();
+  if (lower in SPECIAL_TOOL_MAPPINGS) {
+    return SPECIAL_TOOL_MAPPINGS[lower];
+  }
+  if (toolName.includes("-") || toolName.includes("_")) {
+    return toPascalCase(toolName);
+  }
+  return toolName.charAt(0).toUpperCase() + toolName.slice(1);
+}
+// src/shared/pattern-matcher.ts
+function matchesToolMatcher(toolName, matcher) {
+  if (!matcher) {
+    return true;
+  }
+  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 findMatchingHooks(config, eventName, toolName) {
+  const hookMatchers = config[eventName];
+  if (!hookMatchers)
+    return [];
+  return hookMatchers.filter((hookMatcher) => {
+    if (!toolName)
+      return true;
+    return matchesToolMatcher(toolName, hookMatcher.matcher);
+  });
+}
+// src/shared/hook-disabled.ts
+function isHookDisabled(config, hookType) {
+  const { disabledHooks } = config;
+  if (disabledHooks === undefined) {
+    return false;
+  }
+  if (disabledHooks === true) {
+    return true;
+  }
+  if (Array.isArray(disabledHooks)) {
+    return disabledHooks.includes(hookType);
+  }
+  return false;
+}
+// src/hooks/claude-code-hooks/plugin-config.ts
+var DEFAULT_CONFIG = {
+  forceZsh: true,
+  zshPath: "/bin/zsh"
+};
+
+// src/hooks/claude-code-hooks/pre-tool-use.ts
+function buildInputLines(toolInput) {
+  return Object.entries(toolInput).slice(0, 3).map(([key, val]) => {
+    const valStr = String(val).slice(0, 40);
+    return `  ${key}: ${valStr}${String(val).length > 40 ? "..." : ""}`;
+  }).join(`
+`);
+}
+async function executePreToolUseHooks(ctx, config, extendedConfig) {
+  if (!config) {
+    return { decision: "allow" };
+  }
+  const transformedToolName = transformToolName(ctx.toolName);
+  const matchers = findMatchingHooks(config, "PreToolUse", transformedToolName);
+  if (matchers.length === 0) {
+    return { decision: "allow" };
+  }
+  const stdinData = {
+    session_id: ctx.sessionId,
+    transcript_path: ctx.transcriptPath,
+    cwd: ctx.cwd,
+    permission_mode: ctx.permissionMode ?? "bypassPermissions",
+    hook_event_name: "PreToolUse",
+    tool_name: transformedToolName,
+    tool_input: objectToSnakeCase(ctx.toolInput),
+    tool_use_id: ctx.toolUseId,
+    hook_source: "opencode-plugin"
+  };
+  const startTime = Date.now();
+  let firstHookName;
+  const inputLines = buildInputLines(ctx.toolInput);
+  for (const matcher of matchers) {
+    for (const hook of matcher.hooks) {
+      if (hook.type !== "command")
+        continue;
+      if (isHookCommandDisabled("PreToolUse", hook.command, extendedConfig ?? null)) {
+        log("PreToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName });
+        continue;
+      }
+      const hookName = hook.command.split("/").pop() || hook.command;
+      if (!firstHookName)
+        firstHookName = hookName;
+      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      if (result.exitCode === 2) {
+        return {
+          decision: "deny",
+          reason: result.stderr || result.stdout || "Hook blocked the operation",
+          elapsedMs: Date.now() - startTime,
+          hookName: firstHookName,
+          toolName: transformedToolName,
+          inputLines
+        };
+      }
+      if (result.exitCode === 1) {
+        return {
+          decision: "ask",
+          reason: result.stderr || result.stdout,
+          elapsedMs: Date.now() - startTime,
+          hookName: firstHookName,
+          toolName: transformedToolName,
+          inputLines
+        };
+      }
+      if (result.stdout) {
+        try {
+          const output = JSON.parse(result.stdout);
+          let decision;
+          let reason;
+          let modifiedInput;
+          if (output.hookSpecificOutput?.permissionDecision) {
+            decision = output.hookSpecificOutput.permissionDecision;
+            reason = output.hookSpecificOutput.permissionDecisionReason;
+            modifiedInput = output.hookSpecificOutput.updatedInput;
+          } else if (output.decision) {
+            const legacyDecision = output.decision;
+            if (legacyDecision === "approve" || legacyDecision === "allow") {
+              decision = "allow";
+            } else if (legacyDecision === "block" || legacyDecision === "deny") {
+              decision = "deny";
+            } else if (legacyDecision === "ask") {
+              decision = "ask";
+            }
+            reason = output.reason;
+          }
+          const hasCommonFields = output.continue !== undefined || output.stopReason !== undefined || output.suppressOutput !== undefined || output.systemMessage !== undefined;
+          if (decision || hasCommonFields) {
+            return {
+              decision: decision ?? "allow",
+              reason,
+              modifiedInput,
+              elapsedMs: Date.now() - startTime,
+              hookName: firstHookName,
+              toolName: transformedToolName,
+              inputLines,
+              continue: output.continue,
+              stopReason: output.stopReason,
+              suppressOutput: output.suppressOutput,
+              systemMessage: output.systemMessage
+            };
+          }
+        } catch {}
+      }
+    }
+  }
+  return { decision: "allow" };
+}
+
+// src/hooks/claude-code-hooks/transcript.ts
+import { join as join12 } from "path";
+import { mkdirSync as mkdirSync4, appendFileSync as appendFileSync5, existsSync as existsSync11, writeFileSync as writeFileSync3, unlinkSync as unlinkSync4 } from "fs";
+import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
+import { randomUUID } from "crypto";
+var TRANSCRIPT_DIR = join12(homedir4(), ".claude", "transcripts");
+function getTranscriptPath(sessionId) {
+  return join12(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+}
+function ensureTranscriptDir() {
+  if (!existsSync11(TRANSCRIPT_DIR)) {
+    mkdirSync4(TRANSCRIPT_DIR, { recursive: true });
+  }
+}
+function appendTranscriptEntry(sessionId, entry) {
+  ensureTranscriptDir();
+  const path3 = getTranscriptPath(sessionId);
+  const line = JSON.stringify(entry) + `
+`;
+  appendFileSync5(path3, line);
+}
+function recordToolUse(sessionId, toolName, toolInput) {
+  appendTranscriptEntry(sessionId, {
+    type: "tool_use",
+    timestamp: new Date().toISOString(),
+    tool_name: toolName,
+    tool_input: toolInput
+  });
+}
+function recordToolResult(sessionId, toolName, toolInput, toolOutput) {
+  appendTranscriptEntry(sessionId, {
+    type: "tool_result",
+    timestamp: new Date().toISOString(),
+    tool_name: toolName,
+    tool_input: toolInput,
+    tool_output: toolOutput
+  });
+}
+function recordUserMessage(sessionId, content) {
+  appendTranscriptEntry(sessionId, {
+    type: "user",
+    timestamp: new Date().toISOString(),
+    content
+  });
+}
+async function buildTranscriptFromSession(client, sessionId, directory, currentToolName, currentToolInput) {
+  try {
+    const response = await client.session.messages({
+      path: { id: sessionId },
+      query: { directory }
+    });
+    const messages = response["200"] ?? response.data ?? (Array.isArray(response) ? response : []);
+    const entries = [];
+    if (Array.isArray(messages)) {
+      for (const msg of messages) {
+        if (msg.info?.role !== "assistant")
+          continue;
+        for (const part of msg.parts || []) {
+          if (part.type !== "tool")
+            continue;
+          if (part.state?.status !== "completed")
+            continue;
+          if (!part.state?.input)
+            continue;
+          const rawToolName = part.tool;
+          const toolName = transformToolName(rawToolName);
+          const entry = {
+            type: "assistant",
+            message: {
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_use",
+                  name: toolName,
+                  input: part.state.input
+                }
+              ]
+            }
+          };
+          entries.push(JSON.stringify(entry));
+        }
+      }
+    }
+    const currentEntry = {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            name: transformToolName(currentToolName),
+            input: currentToolInput
+          }
+        ]
+      }
+    };
+    entries.push(JSON.stringify(currentEntry));
+    const tempPath = join12(tmpdir2(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync3(tempPath, entries.join(`
+`) + `
+`);
+    return tempPath;
+  } catch {
+    try {
+      const currentEntry = {
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              name: transformToolName(currentToolName),
+              input: currentToolInput
+            }
+          ]
+        }
+      };
+      const tempPath = join12(tmpdir2(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync3(tempPath, JSON.stringify(currentEntry) + `
+`);
+      return tempPath;
+    } catch {
+      return null;
+    }
+  }
+}
+function deleteTempTranscript(path3) {
+  if (!path3)
+    return;
+  try {
+    unlinkSync4(path3);
+  } catch {}
+}
+
+// src/hooks/claude-code-hooks/post-tool-use.ts
+async function executePostToolUseHooks(ctx, config, extendedConfig) {
+  if (!config) {
+    return { block: false };
+  }
+  const transformedToolName = transformToolName(ctx.toolName);
+  const matchers = findMatchingHooks(config, "PostToolUse", transformedToolName);
+  if (matchers.length === 0) {
+    return { block: false };
+  }
+  let tempTranscriptPath = null;
+  try {
+    if (ctx.client) {
+      tempTranscriptPath = await buildTranscriptFromSession(ctx.client, ctx.sessionId, ctx.cwd, ctx.toolName, ctx.toolInput);
+    }
+    const stdinData = {
+      session_id: ctx.sessionId,
+      transcript_path: tempTranscriptPath ?? ctx.transcriptPath,
+      cwd: ctx.cwd,
+      permission_mode: ctx.permissionMode ?? "bypassPermissions",
+      hook_event_name: "PostToolUse",
+      tool_name: transformedToolName,
+      tool_input: objectToSnakeCase(ctx.toolInput),
+      tool_response: objectToSnakeCase(ctx.toolOutput),
+      tool_use_id: ctx.toolUseId,
+      hook_source: "opencode-plugin"
+    };
+    const messages = [];
+    const warnings = [];
+    let firstHookName;
+    const startTime = Date.now();
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks) {
+        if (hook.type !== "command")
+          continue;
+        if (isHookCommandDisabled("PostToolUse", hook.command, extendedConfig ?? null)) {
+          log("PostToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName });
+          continue;
+        }
+        const hookName = hook.command.split("/").pop() || hook.command;
+        if (!firstHookName)
+          firstHookName = hookName;
+        const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+        if (result.stdout) {
+          messages.push(result.stdout);
+        }
+        if (result.exitCode === 2) {
+          if (result.stderr) {
+            warnings.push(`[${hookName}]
+${result.stderr.trim()}`);
+          }
+          continue;
+        }
+        if (result.exitCode === 0 && result.stdout) {
+          try {
+            const output = JSON.parse(result.stdout);
+            if (output.decision === "block") {
+              return {
+                block: true,
+                reason: output.reason || result.stderr,
+                message: messages.join(`
+`),
+                warnings: warnings.length > 0 ? warnings : undefined,
+                elapsedMs: Date.now() - startTime,
+                hookName: firstHookName,
+                toolName: transformedToolName,
+                additionalContext: output.hookSpecificOutput?.additionalContext,
+                continue: output.continue,
+                stopReason: output.stopReason,
+                suppressOutput: output.suppressOutput,
+                systemMessage: output.systemMessage
+              };
+            }
+            if (output.hookSpecificOutput?.additionalContext || output.continue !== undefined || output.systemMessage || output.suppressOutput === true || output.stopReason !== undefined) {
+              return {
+                block: false,
+                message: messages.join(`
+`),
+                warnings: warnings.length > 0 ? warnings : undefined,
+                elapsedMs: Date.now() - startTime,
+                hookName: firstHookName,
+                toolName: transformedToolName,
+                additionalContext: output.hookSpecificOutput?.additionalContext,
+                continue: output.continue,
+                stopReason: output.stopReason,
+                suppressOutput: output.suppressOutput,
+                systemMessage: output.systemMessage
+              };
+            }
+          } catch {}
+        } else if (result.exitCode !== 0 && result.exitCode !== 2) {
+          try {
+            const output = JSON.parse(result.stdout || "{}");
+            if (output.decision === "block") {
+              return {
+                block: true,
+                reason: output.reason || result.stderr,
+                message: messages.join(`
+`),
+                warnings: warnings.length > 0 ? warnings : undefined,
+                elapsedMs: Date.now() - startTime,
+                hookName: firstHookName,
+                toolName: transformedToolName,
+                additionalContext: output.hookSpecificOutput?.additionalContext,
+                continue: output.continue,
+                stopReason: output.stopReason,
+                suppressOutput: output.suppressOutput,
+                systemMessage: output.systemMessage
+              };
+            }
+          } catch {}
+        }
+      }
+    }
+    const elapsedMs = Date.now() - startTime;
+    return {
+      block: false,
+      message: messages.length > 0 ? messages.join(`
+`) : undefined,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      elapsedMs,
+      hookName: firstHookName,
+      toolName: transformedToolName
+    };
+  } finally {
+    deleteTempTranscript(tempTranscriptPath);
+  }
+}
+
+// src/hooks/claude-code-hooks/user-prompt-submit.ts
+var USER_PROMPT_SUBMIT_TAG_OPEN = "<user-prompt-submit-hook>";
+var USER_PROMPT_SUBMIT_TAG_CLOSE = "</user-prompt-submit-hook>";
+async function executeUserPromptSubmitHooks(ctx, config, extendedConfig) {
+  const modifiedParts = ctx.parts;
+  const messages = [];
+  if (ctx.parentSessionId) {
+    return { block: false, modifiedParts, messages };
+  }
+  if (ctx.prompt.includes(USER_PROMPT_SUBMIT_TAG_OPEN) && ctx.prompt.includes(USER_PROMPT_SUBMIT_TAG_CLOSE)) {
+    return { block: false, modifiedParts, messages };
+  }
+  if (!config) {
+    return { block: false, modifiedParts, messages };
+  }
+  const matchers = findMatchingHooks(config, "UserPromptSubmit");
+  if (matchers.length === 0) {
+    return { block: false, modifiedParts, messages };
+  }
+  const stdinData = {
+    session_id: ctx.sessionId,
+    cwd: ctx.cwd,
+    permission_mode: ctx.permissionMode ?? "bypassPermissions",
+    hook_event_name: "UserPromptSubmit",
+    prompt: ctx.prompt,
+    session: { id: ctx.sessionId },
+    hook_source: "opencode-plugin"
+  };
+  for (const matcher of matchers) {
+    for (const hook of matcher.hooks) {
+      if (hook.type !== "command")
+        continue;
+      if (isHookCommandDisabled("UserPromptSubmit", hook.command, extendedConfig ?? null)) {
+        log("UserPromptSubmit hook command skipped (disabled by config)", { command: hook.command });
+        continue;
+      }
+      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      if (result.stdout) {
+        const output = result.stdout.trim();
+        if (output.startsWith(USER_PROMPT_SUBMIT_TAG_OPEN)) {
+          messages.push(output);
+        } else {
+          messages.push(`${USER_PROMPT_SUBMIT_TAG_OPEN}
+${output}
+${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
+        }
+      }
+      if (result.exitCode !== 0) {
+        try {
+          const output = JSON.parse(result.stdout || "{}");
+          if (output.decision === "block") {
+            return {
+              block: true,
+              reason: output.reason || result.stderr,
+              modifiedParts,
+              messages
+            };
+          }
+        } catch {}
+      }
+    }
+  }
+  return { block: false, modifiedParts, messages };
+}
+
+// src/hooks/claude-code-hooks/todo.ts
+import { join as join13 } from "path";
+import { homedir as homedir5 } from "os";
+var TODO_DIR = join13(homedir5(), ".claude", "todos");
+function getTodoPath(sessionId) {
+  return join13(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+}
+
+// src/hooks/claude-code-hooks/stop.ts
+var stopHookActiveState = new Map;
+async function executeStopHooks(ctx, config, extendedConfig) {
+  if (ctx.parentSessionId) {
+    return { block: false };
+  }
+  if (!config) {
+    return { block: false };
+  }
+  const matchers = findMatchingHooks(config, "Stop");
+  if (matchers.length === 0) {
+    return { block: false };
+  }
+  const stdinData = {
+    session_id: ctx.sessionId,
+    transcript_path: ctx.transcriptPath,
+    cwd: ctx.cwd,
+    permission_mode: ctx.permissionMode ?? "bypassPermissions",
+    hook_event_name: "Stop",
+    stop_hook_active: stopHookActiveState.get(ctx.sessionId) ?? false,
+    todo_path: getTodoPath(ctx.sessionId),
+    hook_source: "opencode-plugin"
+  };
+  for (const matcher of matchers) {
+    for (const hook of matcher.hooks) {
+      if (hook.type !== "command")
+        continue;
+      if (isHookCommandDisabled("Stop", hook.command, extendedConfig ?? null)) {
+        log("Stop hook command skipped (disabled by config)", { command: hook.command });
+        continue;
+      }
+      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      if (result.exitCode === 2) {
+        const reason = result.stderr || result.stdout || "Blocked by stop hook";
+        return {
+          block: true,
+          reason,
+          injectPrompt: reason
+        };
+      }
+      if (result.stdout) {
+        try {
+          const output = JSON.parse(result.stdout);
+          if (output.stop_hook_active !== undefined) {
+            stopHookActiveState.set(ctx.sessionId, output.stop_hook_active);
+          }
+          const isBlock = output.decision === "block";
+          const injectPrompt = output.inject_prompt ?? (isBlock && output.reason ? output.reason : undefined);
+          return {
+            block: isBlock,
+            reason: output.reason,
+            stopHookActive: output.stop_hook_active,
+            permissionMode: output.permission_mode,
+            injectPrompt
+          };
+        } catch {}
+      }
+    }
+  }
+  return { block: false };
+}
+
+// src/hooks/claude-code-hooks/tool-input-cache.ts
+var cache = new Map;
+var CACHE_TTL = 60000;
+function cacheToolInput(sessionId, toolName, invocationId, toolInput) {
+  const key = `${sessionId}:${toolName}:${invocationId}`;
+  cache.set(key, { toolInput, timestamp: Date.now() });
+}
+function getToolInput(sessionId, toolName, invocationId) {
+  const key = `${sessionId}:${toolName}:${invocationId}`;
+  const entry = cache.get(key);
+  if (!entry)
+    return null;
+  cache.delete(key);
+  if (Date.now() - entry.timestamp > CACHE_TTL)
+    return null;
+  return entry.toolInput;
+}
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of cache.entries()) {
+    if (now - entry.timestamp > CACHE_TTL) {
+      cache.delete(key);
+    }
+  }
+}, CACHE_TTL);
+
+// src/features/hook-message-injector/injector.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join15 } from "path";
+
+// src/features/hook-message-injector/constants.ts
+import { join as join14 } from "path";
+import { homedir as homedir6 } from "os";
+var xdgData2 = process.env.XDG_DATA_HOME || join14(homedir6(), ".local", "share");
+var OPENCODE_STORAGE3 = join14(xdgData2, "opencode", "storage");
+var MESSAGE_STORAGE2 = join14(OPENCODE_STORAGE3, "message");
+var PART_STORAGE2 = join14(OPENCODE_STORAGE3, "part");
+
+// src/features/hook-message-injector/injector.ts
+function findNearestMessageWithFields(messageDir) {
+  try {
+    const files = readdirSync2(messageDir).filter((f) => f.endsWith(".json")).sort().reverse();
+    for (const file of files) {
+      try {
+        const content = readFileSync5(join15(messageDir, file), "utf-8");
+        const msg = JSON.parse(content);
+        if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
+          return msg;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function generateMessageId() {
+  const timestamp = Date.now().toString(16);
+  const random = Math.random().toString(36).substring(2, 14);
+  return `msg_${timestamp}${random}`;
+}
+function generatePartId2() {
+  const timestamp = Date.now().toString(16);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `prt_${timestamp}${random}`;
+}
+function getOrCreateMessageDir(sessionID) {
+  if (!existsSync12(MESSAGE_STORAGE2)) {
+    mkdirSync5(MESSAGE_STORAGE2, { recursive: true });
+  }
+  const directPath = join15(MESSAGE_STORAGE2, sessionID);
+  if (existsSync12(directPath)) {
+    return directPath;
+  }
+  for (const dir of readdirSync2(MESSAGE_STORAGE2)) {
+    const sessionPath = join15(MESSAGE_STORAGE2, dir, sessionID);
+    if (existsSync12(sessionPath)) {
+      return sessionPath;
+    }
+  }
+  mkdirSync5(directPath, { recursive: true });
+  return directPath;
+}
+function injectHookMessage(sessionID, hookContent, originalMessage) {
+  const messageDir = getOrCreateMessageDir(sessionID);
+  const needsFallback = !originalMessage.agent || !originalMessage.model?.providerID || !originalMessage.model?.modelID;
+  const fallback = needsFallback ? findNearestMessageWithFields(messageDir) : null;
+  const now = Date.now();
+  const messageID = generateMessageId();
+  const partID = generatePartId2();
+  const resolvedAgent = originalMessage.agent ?? fallback?.agent ?? "general";
+  const resolvedModel = originalMessage.model?.providerID && originalMessage.model?.modelID ? { providerID: originalMessage.model.providerID, modelID: originalMessage.model.modelID } : fallback?.model?.providerID && fallback?.model?.modelID ? { providerID: fallback.model.providerID, modelID: fallback.model.modelID } : undefined;
+  const resolvedTools = originalMessage.tools ?? fallback?.tools;
+  const messageMeta = {
+    id: messageID,
+    sessionID,
+    role: "user",
+    time: {
+      created: now
+    },
+    agent: resolvedAgent,
+    model: resolvedModel,
+    path: originalMessage.path?.cwd ? {
+      cwd: originalMessage.path.cwd,
+      root: originalMessage.path.root ?? "/"
+    } : undefined,
+    tools: resolvedTools
+  };
+  const textPart = {
+    id: partID,
+    type: "text",
+    text: hookContent,
+    synthetic: true,
+    time: {
+      start: now,
+      end: now
+    },
+    messageID,
+    sessionID
+  };
+  try {
+    writeFileSync4(join15(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+    const partDir = join15(PART_STORAGE2, messageID);
+    if (!existsSync12(partDir)) {
+      mkdirSync5(partDir, { recursive: true });
+    }
+    writeFileSync4(join15(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
 }
+// src/hooks/claude-code-hooks/index.ts
+var sessionFirstMessageProcessed = new Set;
+var sessionErrorState = new Map;
+var sessionInterruptState = new Map;
+function createClaudeCodeHooksHook(ctx, config = {}) {
+  return {
+    "chat.message": async (input, output) => {
+      const interruptState = sessionInterruptState.get(input.sessionID);
+      if (interruptState?.interrupted) {
+        log("chat.message hook skipped - session interrupted", { sessionID: input.sessionID });
+        return;
+      }
+      const claudeConfig = await loadClaudeHooksConfig();
+      const extendedConfig = await loadPluginExtendedConfig();
+      const textParts = output.parts.filter((p) => p.type === "text" && p.text);
+      const prompt = textParts.map((p) => p.text ?? "").join(`
+`);
+      recordUserMessage(input.sessionID, prompt);
+      const messageParts = textParts.map((p) => ({
+        type: p.type,
+        text: p.text
+      }));
+      const interruptStateBeforeHooks = sessionInterruptState.get(input.sessionID);
+      if (interruptStateBeforeHooks?.interrupted) {
+        log("chat.message hooks skipped - interrupted during preparation", { sessionID: input.sessionID });
+        return;
+      }
+      let parentSessionId;
+      try {
+        const sessionInfo = await ctx.client.session.get({
+          path: { id: input.sessionID }
+        });
+        parentSessionId = sessionInfo.data?.parentID;
+      } catch {}
+      const isFirstMessage = !sessionFirstMessageProcessed.has(input.sessionID);
+      sessionFirstMessageProcessed.add(input.sessionID);
+      if (isFirstMessage) {
+        log("Skipping UserPromptSubmit hooks on first message for title generation", { sessionID: input.sessionID });
+        return;
+      }
+      if (!isHookDisabled(config, "UserPromptSubmit")) {
+        const userPromptCtx = {
+          sessionId: input.sessionID,
+          parentSessionId,
+          prompt,
+          parts: messageParts,
+          cwd: ctx.directory
+        };
+        const result = await executeUserPromptSubmitHooks(userPromptCtx, claudeConfig, extendedConfig);
+        if (result.block) {
+          throw new Error(result.reason ?? "Hook blocked the prompt");
+        }
+        const interruptStateAfterHooks = sessionInterruptState.get(input.sessionID);
+        if (interruptStateAfterHooks?.interrupted) {
+          log("chat.message injection skipped - interrupted during hooks", { sessionID: input.sessionID });
+          return;
+        }
+        if (result.messages.length > 0) {
+          const hookContent = result.messages.join(`
 
-// src/shared/model-sanitizer.ts
-function sanitizeModelField(_model) {
-  return;
-}
+`);
+          const message = output.message;
+          const success = injectHookMessage(input.sessionID, hookContent, {
+            agent: message.agent,
+            model: message.model,
+            path: message.path ?? { cwd: ctx.directory, root: "/" },
+            tools: message.tools
+          });
+          log(success ? "Hook message injected via file system" : "File injection failed", {
+            sessionID: input.sessionID
+          });
+        }
+      }
+    },
+    "tool.execute.before": async (input, output) => {
+      const claudeConfig = await loadClaudeHooksConfig();
+      const extendedConfig = await loadPluginExtendedConfig();
+      recordToolUse(input.sessionID, input.tool, output.args);
+      cacheToolInput(input.sessionID, input.tool, input.callID, output.args);
+      if (!isHookDisabled(config, "PreToolUse")) {
+        const preCtx = {
+          sessionId: input.sessionID,
+          toolName: input.tool,
+          toolInput: output.args,
+          cwd: ctx.directory,
+          toolUseId: input.callID
+        };
+        const result = await executePreToolUseHooks(preCtx, claudeConfig, extendedConfig);
+        if (result.decision === "deny") {
+          ctx.client.tui.showToast({
+            body: {
+              title: "PreToolUse Hook Executed",
+              message: `\u2717 ${result.toolName ?? input.tool} ${result.hookName ?? "hook"}: BLOCKED ${result.elapsedMs ?? 0}ms
+${result.inputLines ?? ""}`,
+              variant: "error",
+              duration: 4000
+            }
+          }).catch(() => {});
+          throw new Error(result.reason ?? "Hook blocked the operation");
+        }
+        if (result.modifiedInput) {
+          Object.assign(output.args, result.modifiedInput);
+        }
+      }
+    },
+    "tool.execute.after": async (input, output) => {
+      const claudeConfig = await loadClaudeHooksConfig();
+      const extendedConfig = await loadPluginExtendedConfig();
+      const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {};
+      recordToolResult(input.sessionID, input.tool, cachedInput, output.metadata || {});
+      if (!isHookDisabled(config, "PostToolUse")) {
+        const postClient = {
+          session: {
+            messages: (opts) => ctx.client.session.messages(opts)
+          }
+        };
+        const postCtx = {
+          sessionId: input.sessionID,
+          toolName: input.tool,
+          toolInput: cachedInput,
+          toolOutput: {
+            title: input.tool,
+            output: output.output,
+            metadata: output.metadata
+          },
+          cwd: ctx.directory,
+          transcriptPath: getTranscriptPath(input.sessionID),
+          toolUseId: input.callID,
+          client: postClient,
+          permissionMode: "bypassPermissions"
+        };
+        const result = await executePostToolUseHooks(postCtx, claudeConfig, extendedConfig);
+        if (result.block) {
+          ctx.client.tui.showToast({
+            body: {
+              title: "PostToolUse Hook Warning",
+              message: result.reason ?? "Hook returned warning",
+              variant: "warning",
+              duration: 4000
+            }
+          }).catch(() => {});
+        }
+        if (result.warnings && result.warnings.length > 0) {
+          output.output = `${output.output}
+
+${result.warnings.join(`
+`)}`;
+        }
+        if (result.message) {
+          output.output = `${output.output}
 
+${result.message}`;
+        }
+        if (result.hookName) {
+          ctx.client.tui.showToast({
+            body: {
+              title: "PostToolUse Hook Executed",
+              message: `\u25B6 ${result.toolName ?? input.tool} ${result.hookName}: ${result.elapsedMs ?? 0}ms`,
+              variant: "success",
+              duration: 2000
+            }
+          }).catch(() => {});
+        }
+      }
+    },
+    event: async (input) => {
+      const { event } = input;
+      if (event.type === "session.error") {
+        const props = event.properties;
+        const sessionID = props?.sessionID;
+        if (sessionID) {
+          sessionErrorState.set(sessionID, {
+            hasError: true,
+            errorMessage: String(props?.error ?? "Unknown error")
+          });
+        }
+        return;
+      }
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        const sessionInfo = props?.info;
+        if (sessionInfo?.id) {
+          sessionErrorState.delete(sessionInfo.id);
+          sessionInterruptState.delete(sessionInfo.id);
+          sessionFirstMessageProcessed.delete(sessionInfo.id);
+        }
+        return;
+      }
+      if (event.type === "session.idle") {
+        const props = event.properties;
+        const sessionID = props?.sessionID;
+        if (!sessionID)
+          return;
+        const claudeConfig = await loadClaudeHooksConfig();
+        const extendedConfig = await loadPluginExtendedConfig();
+        const errorStateBefore = sessionErrorState.get(sessionID);
+        const endedWithErrorBefore = errorStateBefore?.hasError === true;
+        const interruptStateBefore = sessionInterruptState.get(sessionID);
+        const interruptedBefore = interruptStateBefore?.interrupted === true;
+        let parentSessionId;
+        try {
+          const sessionInfo = await ctx.client.session.get({
+            path: { id: sessionID }
+          });
+          parentSessionId = sessionInfo.data?.parentID;
+        } catch {}
+        if (!isHookDisabled(config, "Stop")) {
+          const stopCtx = {
+            sessionId: sessionID,
+            parentSessionId,
+            cwd: ctx.directory
+          };
+          const stopResult = await executeStopHooks(stopCtx, claudeConfig, extendedConfig);
+          const errorStateAfter = sessionErrorState.get(sessionID);
+          const endedWithErrorAfter = errorStateAfter?.hasError === true;
+          const interruptStateAfter = sessionInterruptState.get(sessionID);
+          const interruptedAfter = interruptStateAfter?.interrupted === true;
+          const shouldBypass = endedWithErrorBefore || endedWithErrorAfter || interruptedBefore || interruptedAfter;
+          if (shouldBypass && stopResult.block) {
+            const interrupted = interruptedBefore || interruptedAfter;
+            const endedWithError = endedWithErrorBefore || endedWithErrorAfter;
+            log("Stop hook block ignored", { sessionID, block: stopResult.block, interrupted, endedWithError });
+          } else if (stopResult.block && stopResult.injectPrompt) {
+            log("Stop hook returned block with inject_prompt", { sessionID });
+            ctx.client.session.prompt({
+              path: { id: sessionID },
+              body: { parts: [{ type: "text", text: stopResult.injectPrompt }] },
+              query: { directory: ctx.directory }
+            }).catch((err) => log("Failed to inject prompt from Stop hook", err));
+          } else if (stopResult.block) {
+            log("Stop hook returned block", { sessionID, reason: stopResult.reason });
+          }
+        }
+        sessionErrorState.delete(sessionID);
+        sessionInterruptState.delete(sessionID);
+      }
+    }
+  };
+}
 // src/features/claude-code-command-loader/loader.ts
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join16, basename } from "path";
 function isMarkdownFile(entry) {
   return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
 }
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync7(commandsDir)) {
+  if (!existsSync13(commandsDir)) {
     return [];
   }
-  const entries = readdirSync2(commandsDir, { withFileTypes: true });
+  const entries = readdirSync3(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join8(commandsDir, entry.name);
+    const commandPath = join16(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
-      const content = readFileSync4(commandPath, "utf-8");
+      const content = readFileSync6(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -2080,50 +3386,50 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join8(homedir2(), ".claude", "commands");
+  const userCommandsDir = join16(homedir7(), ".claude", "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join8(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join16(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join8(homedir2(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join16(homedir7(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join8(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join16(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync, readlinkSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join9, resolve as resolve2 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync2, readlinkSync } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join17, resolve as resolve2 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync8(skillsDir)) {
+  if (!existsSync14(skillsDir)) {
     return [];
   }
-  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  const entries = readdirSync4(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join9(skillsDir, entry.name);
+    const skillPath = join17(skillsDir, entry.name);
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     let resolvedPath = skillPath;
-    if (statSync(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+    if (statSync2(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
       resolvedPath = resolve2(skillPath, "..", readlinkSync(skillPath));
     }
-    const skillMdPath = join9(resolvedPath, "SKILL.md");
-    if (!existsSync8(skillMdPath))
+    const skillMdPath = join17(resolvedPath, "SKILL.md");
+    if (!existsSync14(skillMdPath))
       continue;
     try {
-      const content = readFileSync5(skillMdPath, "utf-8");
+      const content = readFileSync7(skillMdPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const skillName = data.name || entry.name;
       const originalDescription = data.description || "";
@@ -2154,7 +3460,7 @@ $ARGUMENTS
   return skills;
 }
 function loadUserSkillsAsCommands() {
-  const userSkillsDir = join9(homedir3(), ".claude", "skills");
+  const userSkillsDir = join17(homedir8(), ".claude", "skills");
   const skills = loadSkillsFromDir(userSkillsDir, "user");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -2162,7 +3468,7 @@ function loadUserSkillsAsCommands() {
   }, {});
 }
 function loadProjectSkillsAsCommands() {
-  const projectSkillsDir = join9(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join17(process.cwd(), ".claude", "skills");
   const skills = loadSkillsFromDir(projectSkillsDir, "project");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -2170,9 +3476,9 @@ function loadProjectSkillsAsCommands() {
   }, {});
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join10, basename as basename2 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join18, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -2189,18 +3495,18 @@ function isMarkdownFile2(entry) {
   return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync9(agentsDir)) {
+  if (!existsSync15(agentsDir)) {
     return [];
   }
-  const entries = readdirSync4(agentsDir, { withFileTypes: true });
+  const entries = readdirSync5(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile2(entry))
       continue;
-    const agentPath = join10(agentsDir, entry.name);
+    const agentPath = join18(agentsDir, entry.name);
     const agentName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync6(agentPath, "utf-8");
+      const content = readFileSync8(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -2227,7 +3533,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join10(homedir4(), ".claude", "agents");
+  const userAgentsDir = join18(homedir9(), ".claude", "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -2236,7 +3542,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join10(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join18(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -2245,9 +3551,9 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync10 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join12 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join19 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -2311,32 +3617,18 @@ function transformMcpServer(name, server) {
   return config;
 }
 
-// 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/features/claude-code-mcp-loader/loader.ts
 function getMcpConfigPaths() {
-  const home = homedir5();
+  const home = homedir10();
   const cwd = process.cwd();
   return [
-    { path: join12(home, ".claude", ".mcp.json"), scope: "user" },
-    { path: join12(cwd, ".mcp.json"), scope: "project" },
-    { path: join12(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join19(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join19(cwd, ".mcp.json"), scope: "project" },
+    { path: join19(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync10(filePath)) {
+  if (!existsSync16(filePath)) {
     return null;
   }
   try {
@@ -2377,10 +3669,10 @@ async function loadMcpConfigs() {
   return { servers, loadedServers };
 }
 // src/features/claude-code-session-state/state.ts
-var sessionErrorState = new Map;
-var sessionInterruptState = new Map;
+var sessionErrorState2 = new Map;
+var sessionInterruptState2 = new Map;
 var subagentSessions = new Set;
-var sessionFirstMessageProcessed = new Set;
+var sessionFirstMessageProcessed2 = new Set;
 var currentSessionID;
 var currentSessionTitle;
 var mainSessionID;
@@ -2622,14 +3914,14 @@ var EXT_TO_LANG = {
   ".tfvars": "terraform"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync17, readFileSync as readFileSync9 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir11 } from "os";
 function loadJsonFile(path3) {
-  if (!existsSync11(path3))
+  if (!existsSync17(path3))
     return null;
   try {
-    return JSON.parse(readFileSync7(path3, "utf-8"));
+    return JSON.parse(readFileSync9(path3, "utf-8"));
   } catch {
     return null;
   }
@@ -2637,9 +3929,9 @@ function loadJsonFile(path3) {
 function getConfigPaths() {
   const cwd = process.cwd();
   return {
-    project: join13(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join13(homedir6(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join13(homedir6(), ".config", "opencode", "opencode.json")
+    project: join20(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join20(homedir11(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join20(homedir11(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -2732,7 +4024,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync11(join13(p, cmd))) {
+    if (existsSync17(join20(p, cmd))) {
       return true;
     }
   }
@@ -2781,8 +4073,8 @@ function getAllServers() {
   return result;
 }
 // src/tools/lsp/client.ts
-var {spawn: spawn3 } = globalThis.Bun;
-import { readFileSync as readFileSync8 } from "fs";
+var {spawn: spawn4 } = globalThis.Bun;
+import { readFileSync as readFileSync10 } from "fs";
 import { extname, resolve as resolve3 } from "path";
 class LSPServerManager {
   static instance;
@@ -2918,7 +4210,7 @@ class LSPClient {
     this.server = server;
   }
   async start() {
-    this.proc = spawn3(this.server.command, {
+    this.proc = spawn4(this.server.command, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
@@ -3182,7 +4474,7 @@ ${msg}`);
     const absPath = resolve3(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync8(absPath, "utf-8");
+    const text = readFileSync10(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -3297,16 +4589,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve4 } from "path";
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve4(filePath);
-  if (!existsSync12(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync18(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync12(__require("path").join(dir, marker))) {
+      if (existsSync18(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -3464,7 +4756,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync9(filePath, "utf-8");
+    let content = readFileSync11(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -3489,7 +4781,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync3(filePath, lines.join(`
+    writeFileSync5(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -3520,7 +4812,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync3(filePath, "", "utf-8");
+            writeFileSync5(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -3530,8 +4822,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync9(oldPath, "utf-8");
-            writeFileSync3(newPath, content, "utf-8");
+            const content = readFileSync11(oldPath, "utf-8");
+            writeFileSync5(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -4172,7 +5464,7 @@ __export(exports_util, {
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
   issue: () => issue,
-  isPlainObject: () => isPlainObject,
+  isPlainObject: () => isPlainObject2,
   isObject: () => isObject,
   hexToUint8Array: () => hexToUint8Array,
   getSizableOrigin: () => getSizableOrigin,
@@ -4354,7 +5646,7 @@ var allowsEval = cached(() => {
     return false;
   }
 });
-function isPlainObject(o) {
+function isPlainObject2(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -4369,7 +5661,7 @@ function isPlainObject(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject(o))
+  if (isPlainObject2(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -4552,7 +5844,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -4571,7 +5863,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = {
@@ -6721,7 +8013,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject(a) && isPlainObject(b)) {
+  if (isPlainObject2(a) && isPlainObject2(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -6851,7 +8143,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
     const input = payload.value;
-    if (!isPlainObject(input)) {
+    if (!isPlainObject2(input)) {
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
@@ -16231,14 +17523,14 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname3, join as join15 } from "path";
-import { existsSync as existsSync14, statSync as statSync2 } from "fs";
+import { dirname as dirname3, join as join22 } from "path";
+import { existsSync as existsSync20, statSync as statSync3 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
-var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, chmodSync as chmodSync2, unlinkSync as unlinkSync4 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir7 } from "os";
+var {spawn: spawn5 } = globalThis.Bun;
+import { existsSync as existsSync19, mkdirSync as mkdirSync6, chmodSync as chmodSync2, unlinkSync as unlinkSync5 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir12 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -16263,26 +17555,26 @@ var PLATFORM_MAP2 = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join14(homedir7(), "AppData", "Local");
-    return join14(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join21(homedir12(), "AppData", "Local");
+    return join21(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join14(homedir7(), ".cache");
-  return join14(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join21(homedir12(), ".cache");
+  return join21(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join14(getCacheDir2(), getBinaryName3());
-  return existsSync13(binaryPath) ? binaryPath : null;
+  const binaryPath = join21(getCacheDir2(), getBinaryName3());
+  return existsSync19(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
-  const proc = process.platform === "win32" ? spawn4([
+  const proc = process.platform === "win32" ? spawn5([
     "powershell",
     "-command",
     `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`
-  ], { stdout: "pipe", stderr: "pipe" }) : spawn4(["unzip", "-o", archivePath, "-d", destDir], { stdout: "pipe", stderr: "pipe" });
+  ], { stdout: "pipe", stderr: "pipe" }) : spawn5(["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();
@@ -16301,8 +17593,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName3();
-  const binaryPath = join14(cacheDir, binaryName);
-  if (existsSync13(binaryPath)) {
+  const binaryPath = join21(cacheDir, binaryName);
+  if (existsSync19(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os3 } = platformInfo;
@@ -16310,21 +17602,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync13(cacheDir)) {
-      mkdirSync4(cacheDir, { recursive: true });
+    if (!existsSync19(cacheDir)) {
+      mkdirSync6(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join14(cacheDir, assetName);
+    const archivePath = join21(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync13(archivePath)) {
-      unlinkSync4(archivePath);
+    if (existsSync19(archivePath)) {
+      unlinkSync5(archivePath);
     }
-    if (process.platform !== "win32" && existsSync13(binaryPath)) {
+    if (process.platform !== "win32" && existsSync19(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -16346,7 +17638,7 @@ async function ensureAstGrepBinary() {
 // src/tools/ast-grep/constants.ts
 function isValidBinary(filePath) {
   try {
-    return statSync2(filePath).size > 1e4;
+    return statSync3(filePath).size > 1e4;
   } catch {
     return false;
   }
@@ -16375,8 +17667,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname3(cliPkgPath);
-    const sgPath = join15(cliDir, binaryName);
-    if (existsSync14(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join22(cliDir, binaryName);
+    if (existsSync20(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -16387,8 +17679,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname3(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join15(pkgDir, astGrepName);
-      if (existsSync14(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join22(pkgDir, astGrepName);
+      if (existsSync20(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -16396,7 +17688,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path3 of homebrewPaths) {
-      if (existsSync14(path3) && isValidBinary(path3)) {
+      if (existsSync20(path3) && isValidBinary(path3)) {
         return path3;
       }
     }
@@ -16451,12 +17743,12 @@ var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
-var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync15 } from "fs";
+var {spawn: spawn6 } = globalThis.Bun;
+import { existsSync as existsSync21 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync15(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync21(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -16464,7 +17756,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync15(syncPath)) {
+    if (syncPath && existsSync21(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -16498,14 +17790,14 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync15(cliPath) && cliPath !== "sg") {
+  if (!existsSync21(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
     }
   }
   const timeout = DEFAULT_TIMEOUT_MS;
-  const proc = spawn5([cliPath, ...args], {
+  const proc = spawn6([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -16759,11 +18051,11 @@ var ast_grep_replace = tool({
   }
 });
 // src/tools/grep/cli.ts
-var {spawn: spawn6 } = globalThis.Bun;
+var {spawn: spawn7 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join16, dirname as dirname4 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { join as join23, dirname as dirname4 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -16784,13 +18076,13 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join16(execDir, rgName),
-    join16(execDir, "bin", rgName),
-    join16(execDir, "..", "bin", rgName),
-    join16(execDir, "..", "libexec", rgName)
+    join23(execDir, rgName),
+    join23(execDir, "bin", rgName),
+    join23(execDir, "..", "bin", rgName),
+    join23(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate)) {
+    if (existsSync22(candidate)) {
       return candidate;
     }
   }
@@ -16931,7 +18223,7 @@ async function runRg(options) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn6([cli.path, ...args], {
+  const proc = spawn7([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -17033,7 +18325,7 @@ var grep = tool({
 });
 
 // src/tools/glob/cli.ts
-var {spawn: spawn7 } = globalThis.Bun;
+var {spawn: spawn8 } = globalThis.Bun;
 
 // src/tools/glob/constants.ts
 var DEFAULT_TIMEOUT_MS3 = 60000;
@@ -17090,7 +18382,7 @@ async function runRgFiles(options) {
     args.push(...paths);
   }
   const cwd = paths[0] || ".";
-  const proc = spawn7([cli.path, ...args], {
+  const proc = spawn8([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe",
     cwd: isRg ? undefined : cwd
@@ -17188,145 +18480,14 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync18, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join18, basename as basename3, dirname as dirname5 } from "path";
-// src/shared/command-executor.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-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 (error45) {
-    const e = error45;
-    const stdout = e?.stdout?.toString().trim() ?? "";
-    const stderr = e?.stderr?.toString().trim() ?? "";
-    const errMsg = stderr || e?.message || String(error45);
-    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);
-    }
-  });
-  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 existsSync17, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
-import { join as join17, 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;
-}
-function resolveFilePath(filePath, cwd) {
-  if (isAbsolute(filePath)) {
-    return filePath;
-  }
-  return join17(cwd, filePath);
-}
-function readFileContent(resolvedPath) {
-  if (!existsSync17(resolvedPath)) {
-    return `[file not found: ${resolvedPath}]`;
-  }
-  const stat2 = statSync3(resolvedPath);
-  if (stat2.isDirectory()) {
-    return `[cannot read directory: ${resolvedPath}]`;
-  }
-  const content = readFileSync10(resolvedPath, "utf-8");
-  return content;
-}
-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);
-  }
-  return resolved;
-}
-// src/tools/slashcommand/tools.ts
+import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join24, basename as basename3, dirname as dirname5 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync18(commandsDir)) {
+  if (!existsSync23(commandsDir)) {
     return [];
   }
-  const entries = readdirSync5(commandsDir, { withFileTypes: true });
+  const entries = readdirSync6(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
@@ -17335,10 +18496,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
       continue;
     if (!entry.isFile())
       continue;
-    const commandPath = join18(commandsDir, entry.name);
+    const commandPath = join24(commandsDir, entry.name);
     const commandName = basename3(entry.name, ".md");
     try {
-      const content = readFileSync11(commandPath, "utf-8");
+      const content = readFileSync12(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const metadata = {
         name: commandName,
@@ -17362,10 +18523,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands;
 }
 function discoverCommandsSync() {
-  const userCommandsDir = join18(homedir8(), ".claude", "commands");
-  const projectCommandsDir = join18(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join18(homedir8(), ".config", "opencode", "command");
-  const opencodeProjectDir = join18(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join24(homedir13(), ".claude", "commands");
+  const projectCommandsDir = join24(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join24(homedir13(), ".config", "opencode", "command");
+  const opencodeProjectDir = join24(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -17489,19 +18650,19 @@ Try a different command name.`;
   }
 });
 // src/tools/skill/tools.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync4, readlinkSync as readlinkSync2, readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join19, resolve as resolve5, basename as basename4 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync7, statSync as statSync4, readlinkSync as readlinkSync2, readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join25, resolve as resolve5, basename as basename4 } from "path";
 function discoverSkillsFromDir(skillsDir, scope) {
-  if (!existsSync19(skillsDir)) {
+  if (!existsSync24(skillsDir)) {
     return [];
   }
-  const entries = readdirSync6(skillsDir, { withFileTypes: true });
+  const entries = readdirSync7(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join19(skillsDir, entry.name);
+    const skillPath = join25(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       let resolvedPath = skillPath;
       try {
@@ -17512,11 +18673,11 @@ function discoverSkillsFromDir(skillsDir, scope) {
       } catch {
         continue;
       }
-      const skillMdPath = join19(resolvedPath, "SKILL.md");
-      if (!existsSync19(skillMdPath))
+      const skillMdPath = join25(resolvedPath, "SKILL.md");
+      if (!existsSync24(skillMdPath))
         continue;
       try {
-        const content = readFileSync12(skillMdPath, "utf-8");
+        const content = readFileSync13(skillMdPath, "utf-8");
         const { data } = parseFrontmatter(content);
         skills.push({
           name: data.name || entry.name,
@@ -17531,8 +18692,8 @@ function discoverSkillsFromDir(skillsDir, scope) {
   return skills;
 }
 function discoverSkillsSync() {
-  const userSkillsDir = join19(homedir9(), ".claude", "skills");
-  const projectSkillsDir = join19(process.cwd(), ".claude", "skills");
+  const userSkillsDir = join25(homedir14(), ".claude", "skills");
+  const projectSkillsDir = join25(process.cwd(), ".claude", "skills");
   const userSkills = discoverSkillsFromDir(userSkillsDir, "user");
   const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project");
   return [...projectSkills, ...userSkills];
@@ -17553,12 +18714,12 @@ function resolveSymlink(skillPath) {
 }
 async function parseSkillMd(skillPath) {
   const resolvedPath = resolveSymlink(skillPath);
-  const skillMdPath = join19(resolvedPath, "SKILL.md");
-  if (!existsSync19(skillMdPath)) {
+  const skillMdPath = join25(resolvedPath, "SKILL.md");
+  if (!existsSync24(skillMdPath)) {
     return null;
   }
   try {
-    let content = readFileSync12(skillMdPath, "utf-8");
+    let content = readFileSync13(skillMdPath, "utf-8");
     content = await resolveCommandsInText(content);
     const { data, body } = parseFrontmatter(content);
     const metadata = {
@@ -17566,12 +18727,12 @@ async function parseSkillMd(skillPath) {
       description: data.description || "",
       license: data.license
     };
-    const referencesDir = join19(resolvedPath, "references");
-    const scriptsDir = join19(resolvedPath, "scripts");
-    const assetsDir = join19(resolvedPath, "assets");
-    const references = existsSync19(referencesDir) ? readdirSync6(referencesDir).filter((f) => !f.startsWith(".")) : [];
-    const scripts = existsSync19(scriptsDir) ? readdirSync6(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
-    const assets = existsSync19(assetsDir) ? readdirSync6(assetsDir).filter((f) => !f.startsWith(".")) : [];
+    const referencesDir = join25(resolvedPath, "references");
+    const scriptsDir = join25(resolvedPath, "scripts");
+    const assetsDir = join25(resolvedPath, "assets");
+    const references = existsSync24(referencesDir) ? readdirSync7(referencesDir).filter((f) => !f.startsWith(".")) : [];
+    const scripts = existsSync24(scriptsDir) ? readdirSync7(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
+    const assets = existsSync24(assetsDir) ? readdirSync7(assetsDir).filter((f) => !f.startsWith(".")) : [];
     return {
       name: metadata.name,
       path: resolvedPath,
@@ -17586,15 +18747,15 @@ async function parseSkillMd(skillPath) {
   }
 }
 async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync19(skillsDir)) {
+  if (!existsSync24(skillsDir)) {
     return [];
   }
-  const entries = readdirSync6(skillsDir, { withFileTypes: true });
+  const entries = readdirSync7(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join19(skillsDir, entry.name);
+    const skillPath = join25(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const skillInfo = await parseSkillMd(skillPath);
       if (skillInfo) {
@@ -17605,8 +18766,8 @@ async function discoverSkillsFromDirAsync(skillsDir) {
   return skills;
 }
 async function discoverSkills() {
-  const userSkillsDir = join19(homedir9(), ".claude", "skills");
-  const projectSkillsDir = join19(process.cwd(), ".claude", "skills");
+  const userSkillsDir = join25(homedir14(), ".claude", "skills");
+  const projectSkillsDir = join25(process.cwd(), ".claude", "skills");
   const userSkills = await discoverSkillsFromDirAsync(userSkillsDir);
   const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir);
   return [...projectSkills, ...userSkills];
@@ -17635,9 +18796,9 @@ async function loadSkillWithReferences(skill, includeRefs) {
   const referencesLoaded = [];
   if (includeRefs && skill.references.length > 0) {
     for (const ref of skill.references) {
-      const refPath = join19(skill.path, "references", ref);
+      const refPath = join25(skill.path, "references", ref);
       try {
-        let content = readFileSync12(refPath, "utf-8");
+        let content = readFileSync13(refPath, "utf-8");
         content = await resolveCommandsInText(content);
         referencesLoaded.push({ path: ref, content });
       } catch {}
@@ -17870,6 +19031,7 @@ function loadPluginConfig(directory) {
   return {};
 }
 var OhMyOpenCodePlugin = async (ctx) => {
+  const pluginConfig = loadPluginConfig(ctx.directory);
   const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
   const contextWindowMonitor = createContextWindowMonitorHook(ctx);
   const sessionRecovery = createSessionRecoveryHook(ctx);
@@ -17878,19 +19040,22 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
   const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
   const thinkMode = createThinkModeHook();
+  const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {});
   updateTerminalTitle({ sessionId: "main" });
-  const pluginConfig = loadPluginConfig(ctx.directory);
   return {
     tool: builtinTools,
+    "chat.message": async (input, output) => {
+      await claudeCodeHooks["chat.message"]?.(input, output);
+    },
     config: async (config3) => {
       const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents);
       const userAgents = loadUserAgents();
       const projectAgents = loadProjectAgents();
       config3.agent = {
-        ...config3.agent,
         ...builtinAgents,
         ...userAgents,
-        ...projectAgents
+        ...projectAgents,
+        ...config3.agent
       };
       config3.tools = {
         ...config3.tools
@@ -17919,6 +19084,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       };
     },
     event: async (input) => {
+      await claudeCodeHooks.event(input);
       await todoContinuationEnforcer(input);
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
@@ -18002,6 +19168,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       }
     },
     "tool.execute.before": async (input, output) => {
+      await claudeCodeHooks["tool.execute.before"](input, output);
       await commentChecker["tool.execute.before"](input, output);
       if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({
@@ -18014,6 +19181,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       }
     },
     "tool.execute.after": async (input, output) => {
+      await claudeCodeHooks["tool.execute.after"](input, output);
       await grepOutputTruncator["tool.execute.after"](input, output);
       await contextWindowMonitor["tool.execute.after"](input, output);
       await commentChecker["tool.execute.after"](input, output);