oh-my-opencode 3.7.1 → 3.7.3

package/dist/cli/index.js

@@ -4440,7 +4440,7 @@ function renamed(from, to) {
   };
 }
 var isNothing_1, isObject_1, toArray_1, repeat_1, isNegativeZero_1, extend_1, common, exception, snippet, TYPE_CONSTRUCTOR_OPTIONS, YAML_NODE_KINDS, type, schema, str, seq, map, failsafe, _null, bool, int, YAML_FLOAT_PATTERN, SCIENTIFIC_WITHOUT_DOT, float, json, core, YAML_DATE_REGEXP, YAML_TIMESTAMP_REGEXP, timestamp, merge, BASE64_MAP = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
-\r`, binary, _hasOwnProperty$3, _toString$2, omap, _toString$1, pairs, _hasOwnProperty$2, set, _default, _hasOwnProperty$1, CONTEXT_FLOW_IN = 1, CONTEXT_FLOW_OUT = 2, CONTEXT_BLOCK_IN = 3, CONTEXT_BLOCK_OUT = 4, CHOMPING_CLIP = 1, CHOMPING_STRIP = 2, CHOMPING_KEEP = 3, PATTERN_NON_PRINTABLE, PATTERN_NON_ASCII_LINE_BREAKS, PATTERN_FLOW_INDICATORS, PATTERN_TAG_HANDLE, PATTERN_TAG_URI, simpleEscapeCheck, simpleEscapeMap, i, directiveHandlers, loadAll_1, load_1, loader, _toString, _hasOwnProperty, CHAR_BOM = 65279, CHAR_TAB = 9, CHAR_LINE_FEED = 10, CHAR_CARRIAGE_RETURN = 13, CHAR_SPACE = 32, CHAR_EXCLAMATION = 33, CHAR_DOUBLE_QUOTE = 34, CHAR_SHARP = 35, CHAR_PERCENT = 37, CHAR_AMPERSAND = 38, CHAR_SINGLE_QUOTE = 39, CHAR_ASTERISK = 42, CHAR_COMMA = 44, CHAR_MINUS = 45, CHAR_COLON = 58, CHAR_EQUALS = 61, CHAR_GREATER_THAN = 62, CHAR_QUESTION = 63, CHAR_COMMERCIAL_AT = 64, CHAR_LEFT_SQUARE_BRACKET = 91, CHAR_RIGHT_SQUARE_BRACKET = 93, CHAR_GRAVE_ACCENT = 96, CHAR_LEFT_CURLY_BRACKET = 123, CHAR_VERTICAL_LINE = 124, CHAR_RIGHT_CURLY_BRACKET = 125, ESCAPE_SEQUENCES, DEPRECATED_BOOLEANS_SYNTAX, DEPRECATED_BASE60_SYNTAX, QUOTING_TYPE_SINGLE = 1, QUOTING_TYPE_DOUBLE = 2, STYLE_PLAIN = 1, STYLE_SINGLE = 2, STYLE_LITERAL = 3, STYLE_FOLDED = 4, STYLE_DOUBLE = 5, dump_1, dumper, load, loadAll, dump, safeLoad, safeLoadAll, safeDump;
+\r`, binary, _hasOwnProperty$3, _toString$2, omap, _toString$1, pairs, _hasOwnProperty$2, set, _default, _hasOwnProperty$1, CONTEXT_FLOW_IN = 1, CONTEXT_FLOW_OUT = 2, CONTEXT_BLOCK_IN = 3, CONTEXT_BLOCK_OUT = 4, CHOMPING_CLIP = 1, CHOMPING_STRIP = 2, CHOMPING_KEEP = 3, PATTERN_NON_PRINTABLE, PATTERN_NON_ASCII_LINE_BREAKS, PATTERN_FLOW_INDICATORS, PATTERN_TAG_HANDLE, PATTERN_TAG_URI, simpleEscapeCheck, simpleEscapeMap, i, directiveHandlers, loadAll_1, load_1, loader, _toString, _hasOwnProperty, CHAR_BOM = 65279, CHAR_TAB = 9, CHAR_LINE_FEED = 10, CHAR_CARRIAGE_RETURN = 13, CHAR_SPACE = 32, CHAR_EXCLAMATION = 33, CHAR_DOUBLE_QUOTE = 34, CHAR_SHARP = 35, CHAR_PERCENT = 37, CHAR_AMPERSAND = 38, CHAR_SINGLE_QUOTE = 39, CHAR_ASTERISK = 42, CHAR_COMMA = 44, CHAR_MINUS = 45, CHAR_COLON = 58, CHAR_EQUALS = 61, CHAR_GREATER_THAN = 62, CHAR_QUESTION = 63, CHAR_COMMERCIAL_AT = 64, CHAR_LEFT_SQUARE_BRACKET = 91, CHAR_RIGHT_SQUARE_BRACKET = 93, CHAR_GRAVE_ACCENT = 96, CHAR_LEFT_CURLY_BRACKET = 123, CHAR_VERTICAL_LINE = 124, CHAR_RIGHT_CURLY_BRACKET = 125, ESCAPE_SEQUENCES, DEPRECATED_BOOLEANS_SYNTAX, DEPRECATED_BASE60_SYNTAX, QUOTING_TYPE_SINGLE = 1, QUOTING_TYPE_DOUBLE = 2, STYLE_PLAIN = 1, STYLE_SINGLE = 2, STYLE_LITERAL = 3, STYLE_FOLDED = 4, STYLE_DOUBLE = 5, dump_1, dumper, Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump, jsYaml;
 var init_js_yaml = __esm(() => {
   /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
   isNothing_1 = isNothing;
@@ -4793,15 +4793,69 @@ var init_js_yaml = __esm(() => {
   dumper = {
     dump: dump_1
   };
+  Type = type;
+  Schema = schema;
+  FAILSAFE_SCHEMA = failsafe;
+  JSON_SCHEMA = json;
+  CORE_SCHEMA = core;
+  DEFAULT_SCHEMA = _default;
   load = loader.load;
   loadAll = loader.loadAll;
   dump = dumper.dump;
+  YAMLException = exception;
+  types = {
+    binary,
+    float,
+    map,
+    null: _null,
+    pairs,
+    set,
+    timestamp,
+    bool,
+    int,
+    merge,
+    omap,
+    seq,
+    str
+  };
   safeLoad = renamed("safeLoad", "load");
   safeLoadAll = renamed("safeLoadAll", "loadAll");
   safeDump = renamed("safeDump", "dump");
+  jsYaml = {
+    Type,
+    Schema,
+    FAILSAFE_SCHEMA,
+    JSON_SCHEMA,
+    CORE_SCHEMA,
+    DEFAULT_SCHEMA,
+    load,
+    loadAll,
+    dump,
+    YAMLException,
+    types,
+    safeLoad,
+    safeLoadAll,
+    safeDump
+  };
 });
 
 // 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, hadFrontmatter: false, parseError: false };
+  }
+  const yamlContent = match[1];
+  const body = match[2];
+  try {
+    const parsed = jsYaml.load(yamlContent, { schema: jsYaml.JSON_SCHEMA });
+    const data = parsed ?? {};
+    return { data, body, hadFrontmatter: true, parseError: false };
+  } catch {
+    return { data: {}, body, hadFrontmatter: true, parseError: true };
+  }
+}
 var init_frontmatter = __esm(() => {
   init_js_yaml();
 });
@@ -8999,7 +9053,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.7.1",
+  version: "3.7.3",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -9073,13 +9127,13 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.7.1",
-    "oh-my-opencode-darwin-x64": "3.7.1",
-    "oh-my-opencode-linux-arm64": "3.7.1",
-    "oh-my-opencode-linux-arm64-musl": "3.7.1",
-    "oh-my-opencode-linux-x64": "3.7.1",
-    "oh-my-opencode-linux-x64-musl": "3.7.1",
-    "oh-my-opencode-windows-x64": "3.7.1"
+    "oh-my-opencode-darwin-arm64": "3.7.3",
+    "oh-my-opencode-darwin-x64": "3.7.3",
+    "oh-my-opencode-linux-arm64": "3.7.3",
+    "oh-my-opencode-linux-arm64-musl": "3.7.3",
+    "oh-my-opencode-linux-x64": "3.7.3",
+    "oh-my-opencode-linux-x64-musl": "3.7.3",
+    "oh-my-opencode-windows-x64": "3.7.3"
   },
   trustedDependencies: [
     "@ast-grep/cli",
@@ -10131,7 +10185,7 @@ async function install(args) {
 }
 
 // src/cli/run/runner.ts
-var import_picocolors14 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/event-state.ts
 function createEventState() {
@@ -10143,7 +10197,22 @@ function createEventState() {
     lastPartText: "",
     currentTool: null,
     hasReceivedMeaningfulWork: false,
-    messageCount: 0
+    messageCount: 0,
+    currentAgent: null,
+    currentModel: null,
+    currentVariant: null,
+    currentMessageRole: null,
+    agentColorsByName: {},
+    partTypesById: {},
+    inThinkBlock: false,
+    lastReasoningText: "",
+    hasPrintedThinkingLine: false,
+    lastThinkingLineWidth: 0,
+    messageRoleById: {},
+    lastThinkingSummary: "",
+    textAtLineStart: true,
+    thinkingAtLineStart: false,
+    currentMessageId: null
   };
 }
 // src/cli/run/event-formatting.ts
@@ -10218,6 +10287,14 @@ function logEventVerbose(ctx, payload) {
       }
       break;
     }
+    case "message.part.delta": {
+      const deltaProps = props;
+      const field = deltaProps?.field ?? "unknown";
+      const delta = deltaProps?.delta ?? "";
+      const preview = delta.slice(0, 80).replace(/\n/g, "\\n");
+      console.error(import_picocolors5.default.dim(`${sessionTag} message.part.delta (${field}): "${preview}${delta.length > 80 ? "..." : ""}"`));
+      break;
+    }
     case "message.updated": {
       const msgProps = props;
       const role = msgProps?.info?.role ?? "unknown";
@@ -10264,10 +10341,222 @@ function logEventVerbose(ctx, payload) {
   }
 }
 // src/cli/run/event-stream-processor.ts
-var import_picocolors7 = __toESM(require_picocolors(), 1);
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/event-handlers.ts
+var import_picocolors7 = __toESM(require_picocolors(), 1);
+
+// src/cli/run/tool-input-preview.ts
+function formatToolHeader(toolName, input) {
+  if (toolName === "glob") {
+    const pattern = str2(input.pattern);
+    const root = str2(input.path);
+    return {
+      icon: "\u2731",
+      title: pattern ? `Glob "${pattern}"` : "Glob",
+      description: root ? `in ${root}` : undefined
+    };
+  }
+  if (toolName === "grep") {
+    const pattern = str2(input.pattern);
+    const root = str2(input.path);
+    return {
+      icon: "\u2731",
+      title: pattern ? `Grep "${pattern}"` : "Grep",
+      description: root ? `in ${root}` : undefined
+    };
+  }
+  if (toolName === "list") {
+    const path3 = str2(input.path);
+    return {
+      icon: "\u2192",
+      title: path3 ? `List ${path3}` : "List"
+    };
+  }
+  if (toolName === "read") {
+    const filePath = str2(input.filePath);
+    return {
+      icon: "\u2192",
+      title: filePath ? `Read ${filePath}` : "Read",
+      description: formatKeyValues(input, ["filePath"])
+    };
+  }
+  if (toolName === "write") {
+    const filePath = str2(input.filePath);
+    return {
+      icon: "\u2190",
+      title: filePath ? `Write ${filePath}` : "Write"
+    };
+  }
+  if (toolName === "edit") {
+    const filePath = str2(input.filePath);
+    return {
+      icon: "\u2190",
+      title: filePath ? `Edit ${filePath}` : "Edit",
+      description: formatKeyValues(input, ["filePath", "oldString", "newString"])
+    };
+  }
+  if (toolName === "webfetch") {
+    const url = str2(input.url);
+    return {
+      icon: "%",
+      title: url ? `WebFetch ${url}` : "WebFetch",
+      description: formatKeyValues(input, ["url"])
+    };
+  }
+  if (toolName === "websearch_web_search_exa") {
+    const query = str2(input.query);
+    return {
+      icon: "\u25C8",
+      title: query ? `Web Search "${query}"` : "Web Search"
+    };
+  }
+  if (toolName === "grep_app_searchGitHub") {
+    const query = str2(input.query);
+    return {
+      icon: "\u25C7",
+      title: query ? `Code Search "${query}"` : "Code Search"
+    };
+  }
+  if (toolName === "task") {
+    const desc = str2(input.description);
+    const subagent = str2(input.subagent_type);
+    return {
+      icon: "#",
+      title: desc || (subagent ? `${subagent} Task` : "Task"),
+      description: subagent ? `agent=${subagent}` : undefined
+    };
+  }
+  if (toolName === "bash") {
+    const command = str2(input.command);
+    return {
+      icon: "$",
+      title: command || "bash",
+      description: formatKeyValues(input, ["command"])
+    };
+  }
+  if (toolName === "skill") {
+    const name = str2(input.name);
+    return {
+      icon: "\u2192",
+      title: name ? `Skill "${name}"` : "Skill"
+    };
+  }
+  if (toolName === "todowrite") {
+    return {
+      icon: "#",
+      title: "Todos"
+    };
+  }
+  return {
+    icon: "\u2699",
+    title: toolName,
+    description: formatKeyValues(input, [])
+  };
+}
+function formatKeyValues(input, exclude) {
+  const entries = Object.entries(input).filter(([key, value]) => {
+    if (exclude.includes(key))
+      return false;
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  });
+  if (!entries.length)
+    return;
+  return entries.map(([key, value]) => `${key}=${String(value)}`).join(" ");
+}
+function str2(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : undefined;
+}
+
+// src/cli/run/display-chars.ts
+var isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS);
+var displayChars = {
+  treeEnd: isCI ? "`-" : "\u2514\u2500",
+  treeIndent: "   ",
+  treeJoin: isCI ? "   " : "      "
+};
+
+// src/cli/run/output-renderer.ts
 var import_picocolors6 = __toESM(require_picocolors(), 1);
+function renderAgentHeader(agent, model, variant, agentColorsByName) {
+  if (!agent && !model)
+    return;
+  const agentLabel = agent ? import_picocolors6.default.bold(colorizeWithProfileColor(agent, agentColorsByName[agent])) : "";
+  const modelBase = model ?? "";
+  const variantSuffix = variant ? ` (${variant})` : "";
+  const modelLabel = model ? import_picocolors6.default.dim(`${modelBase}${variantSuffix}`) : "";
+  process.stdout.write(`
+`);
+  if (modelLabel) {
+    process.stdout.write(`  ${modelLabel}  
+`);
+  }
+  if (agentLabel) {
+    process.stdout.write(`  ${import_picocolors6.default.dim("\u2514\u2500")} ${agentLabel}  
+`);
+  }
+  process.stdout.write(`
+`);
+}
+function openThinkBlock() {
+  process.stdout.write(`
+  ${import_picocolors6.default.dim("\u2503  Thinking:")} `);
+}
+function closeThinkBlock() {
+  process.stdout.write(`  
+
+`);
+}
+function writePaddedText(text, atLineStart) {
+  const isGitHubActions = process.env.GITHUB_ACTIONS === "true";
+  if (isGitHubActions) {
+    return { output: text, atLineStart: text.endsWith(`
+`) };
+  }
+  let output = "";
+  let lineStart = atLineStart;
+  for (let i2 = 0;i2 < text.length; i2++) {
+    const ch = text[i2];
+    if (lineStart) {
+      output += "  ";
+      lineStart = false;
+    }
+    if (ch === `
+`) {
+      output += `  
+`;
+      lineStart = true;
+      continue;
+    }
+    output += ch;
+  }
+  return { output, atLineStart: lineStart };
+}
+function colorizeWithProfileColor(text, hexColor) {
+  if (!hexColor)
+    return import_picocolors6.default.magenta(text);
+  const rgb = parseHexColor(hexColor);
+  if (!rgb)
+    return import_picocolors6.default.magenta(text);
+  const [r2, g2, b3] = rgb;
+  return `\x1B[38;2;${r2};${g2};${b3}m${text}\x1B[39m`;
+}
+function parseHexColor(hexColor) {
+  const cleaned = hexColor.trim();
+  const match = cleaned.match(/^#?([A-Fa-f0-9]{6})$/);
+  if (!match)
+    return null;
+  const hex = match[1];
+  const r2 = Number.parseInt(hex.slice(0, 2), 16);
+  const g2 = Number.parseInt(hex.slice(2, 4), 16);
+  const b3 = Number.parseInt(hex.slice(4, 6), 16);
+  return [r2, g2, b3];
+}
+
+// src/cli/run/event-handlers.ts
 function getSessionId(props) {
   return props?.sessionID ?? props?.sessionId;
 }
@@ -10277,6 +10566,12 @@ function getInfoSessionId(props) {
 function getPartSessionId(props) {
   return props?.part?.sessionID ?? props?.part?.sessionId;
 }
+function getPartMessageId(props) {
+  return props?.part?.messageID;
+}
+function getDeltaMessageId(props) {
+  return props?.messageID;
+}
 function handleSessionIdle(ctx, payload, state) {
   if (payload.type !== "session.idle")
     return;
@@ -10306,7 +10601,7 @@ function handleSessionError(ctx, payload, state) {
   if (getSessionId(props) === ctx.sessionID) {
     state.mainSessionError = true;
     state.lastError = serializeError(props?.error);
-    console.error(import_picocolors6.default.red(`
+    console.error(import_picocolors7.default.red(`
 [session.error] ${state.lastError}`));
   }
 }
@@ -10318,13 +10613,36 @@ function handleMessagePartUpdated(ctx, payload, state) {
   const infoSid = getInfoSessionId(props);
   if ((partSid ?? infoSid) !== ctx.sessionID)
     return;
+  const role = props?.info?.role;
+  const mappedRole = getPartMessageId(props) ? state.messageRoleById[getPartMessageId(props) ?? ""] : undefined;
+  if ((role ?? mappedRole) === "user")
+    return;
   const part = props?.part;
   if (!part)
     return;
+  if (part.id && part.type) {
+    state.partTypesById[part.id] = part.type;
+  }
+  if (part.type === "reasoning") {
+    ensureThinkBlockOpen(state);
+    const reasoningText = part.text ?? "";
+    const newText = reasoningText.slice(state.lastReasoningText.length);
+    if (newText) {
+      const padded = writePaddedText(newText, state.thinkingAtLineStart);
+      process.stdout.write(import_picocolors7.default.dim(padded.output));
+      state.thinkingAtLineStart = padded.atLineStart;
+      state.hasReceivedMeaningfulWork = true;
+    }
+    state.lastReasoningText = reasoningText;
+    return;
+  }
+  closeThinkBlockIfNeeded(state);
   if (part.type === "text" && part.text) {
     const newText = part.text.slice(state.lastPartText.length);
     if (newText) {
-      process.stdout.write(newText);
+      const padded = writePaddedText(newText, state.textAtLineStart);
+      process.stdout.write(padded.output);
+      state.textAtLineStart = padded.atLineStart;
       state.hasReceivedMeaningfulWork = true;
     }
     state.lastPartText = part.text;
@@ -10333,42 +10651,67 @@ function handleMessagePartUpdated(ctx, payload, state) {
     handleToolPart(ctx, part, state);
   }
 }
+function handleMessagePartDelta(ctx, payload, state) {
+  if (payload.type !== "message.part.delta")
+    return;
+  const props = payload.properties;
+  const sessionID = props?.sessionID ?? props?.sessionId;
+  if (sessionID !== ctx.sessionID)
+    return;
+  const role = getDeltaMessageId(props) ? state.messageRoleById[getDeltaMessageId(props) ?? ""] : undefined;
+  if (role === "user")
+    return;
+  if (props?.field !== "text")
+    return;
+  const partType = props?.partID ? state.partTypesById[props.partID] : undefined;
+  const delta = props.delta ?? "";
+  if (!delta)
+    return;
+  if (partType === "reasoning") {
+    ensureThinkBlockOpen(state);
+    const padded2 = writePaddedText(delta, state.thinkingAtLineStart);
+    process.stdout.write(import_picocolors7.default.dim(padded2.output));
+    state.thinkingAtLineStart = padded2.atLineStart;
+    state.lastReasoningText += delta;
+    state.hasReceivedMeaningfulWork = true;
+    return;
+  }
+  closeThinkBlockIfNeeded(state);
+  const padded = writePaddedText(delta, state.textAtLineStart);
+  process.stdout.write(padded.output);
+  state.textAtLineStart = padded.atLineStart;
+  state.lastPartText += delta;
+  state.hasReceivedMeaningfulWork = true;
+}
 function handleToolPart(_ctx, part, state) {
   const toolName = part.tool || part.name || "unknown";
   const status = part.state?.status;
   if (status === "running") {
+    if (state.currentTool !== null)
+      return;
     state.currentTool = toolName;
-    let inputPreview = "";
-    const input = part.state?.input;
-    if (input) {
-      if (input.command) {
-        inputPreview = ` ${import_picocolors6.default.dim(String(input.command).slice(0, 60))}`;
-      } else if (input.pattern) {
-        inputPreview = ` ${import_picocolors6.default.dim(String(input.pattern).slice(0, 40))}`;
-      } else if (input.filePath) {
-        inputPreview = ` ${import_picocolors6.default.dim(String(input.filePath))}`;
-      } else if (input.query) {
-        inputPreview = ` ${import_picocolors6.default.dim(String(input.query).slice(0, 40))}`;
-      }
-    }
+    const header = formatToolHeader(toolName, part.state?.input ?? {});
+    const suffix = header.description ? ` ${import_picocolors7.default.dim(header.description)}` : "";
     state.hasReceivedMeaningfulWork = true;
     process.stdout.write(`
-${import_picocolors6.default.cyan(">")} ${import_picocolors6.default.bold(toolName)}${inputPreview}
+  ${import_picocolors7.default.cyan(header.icon)} ${import_picocolors7.default.bold(header.title)}${suffix}  
 `);
   }
   if (status === "completed" || status === "error") {
+    if (state.currentTool === null)
+      return;
     const output = part.state?.output || "";
-    const maxLen = 200;
-    const preview = output.length > maxLen ? output.slice(0, maxLen) + "..." : output;
-    if (preview.trim()) {
-      const lines = preview.split(`
-`).slice(0, 3);
-      process.stdout.write(import_picocolors6.default.dim(`   \u2514\u2500 ${lines.join(`
-      `)}
+    if (output.trim()) {
+      process.stdout.write(import_picocolors7.default.dim(`  ${displayChars.treeEnd} output  
 `));
+      const padded = writePaddedText(output, true);
+      process.stdout.write(import_picocolors7.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
+      process.stdout.write(`
+`);
     }
     state.currentTool = null;
     state.lastPartText = "";
+    state.textAtLineStart = true;
   }
 }
 function handleMessageUpdated(ctx, payload, state) {
@@ -10377,11 +10720,36 @@ function handleMessageUpdated(ctx, payload, state) {
   const props = payload.properties;
   if (getInfoSessionId(props) !== ctx.sessionID)
     return;
+  state.currentMessageRole = props?.info?.role ?? null;
+  const messageID = props?.info?.id ?? null;
+  const role = props?.info?.role;
+  if (messageID && role) {
+    state.messageRoleById[messageID] = role;
+  }
   if (props?.info?.role !== "assistant")
     return;
-  state.hasReceivedMeaningfulWork = true;
-  state.messageCount++;
-  state.lastPartText = "";
+  const isNewMessage = !messageID || messageID !== state.currentMessageId;
+  if (isNewMessage) {
+    state.currentMessageId = messageID;
+    state.hasReceivedMeaningfulWork = true;
+    state.messageCount++;
+    state.lastPartText = "";
+    state.lastReasoningText = "";
+    state.hasPrintedThinkingLine = false;
+    state.lastThinkingSummary = "";
+    state.textAtLineStart = true;
+    state.thinkingAtLineStart = false;
+    closeThinkBlockIfNeeded(state);
+  }
+  const agent = props?.info?.agent ?? null;
+  const model = props?.info?.modelID ?? null;
+  const variant = props?.info?.variant ?? null;
+  if (agent !== state.currentAgent || model !== state.currentModel || variant !== state.currentVariant) {
+    state.currentAgent = agent;
+    state.currentModel = model;
+    state.currentVariant = variant;
+    renderAgentHeader(agent, model, variant, state.agentColorsByName);
+  }
 }
 function handleToolExecute(ctx, payload, state) {
   if (payload.type !== "tool.execute")
@@ -10389,24 +10757,16 @@ function handleToolExecute(ctx, payload, state) {
   const props = payload.properties;
   if (getSessionId(props) !== ctx.sessionID)
     return;
+  closeThinkBlockIfNeeded(state);
+  if (state.currentTool !== null)
+    return;
   const toolName = props?.name || "unknown";
   state.currentTool = toolName;
-  let inputPreview = "";
-  if (props?.input) {
-    const input = props.input;
-    if (input.command) {
-      inputPreview = ` ${import_picocolors6.default.dim(String(input.command).slice(0, 60))}`;
-    } else if (input.pattern) {
-      inputPreview = ` ${import_picocolors6.default.dim(String(input.pattern).slice(0, 40))}`;
-    } else if (input.filePath) {
-      inputPreview = ` ${import_picocolors6.default.dim(String(input.filePath))}`;
-    } else if (input.query) {
-      inputPreview = ` ${import_picocolors6.default.dim(String(input.query).slice(0, 40))}`;
-    }
-  }
+  const header = formatToolHeader(toolName, props?.input ?? {});
+  const suffix = header.description ? ` ${import_picocolors7.default.dim(header.description)}` : "";
   state.hasReceivedMeaningfulWork = true;
   process.stdout.write(`
-${import_picocolors6.default.cyan(">")} ${import_picocolors6.default.bold(toolName)}${inputPreview}
+  ${import_picocolors7.default.cyan(header.icon)} ${import_picocolors7.default.bold(header.title)}${suffix}  
 `);
 }
 function handleToolResult(ctx, payload, state) {
@@ -10415,37 +10775,52 @@ function handleToolResult(ctx, payload, state) {
   const props = payload.properties;
   if (getSessionId(props) !== ctx.sessionID)
     return;
+  closeThinkBlockIfNeeded(state);
+  if (state.currentTool === null)
+    return;
   const output = props?.output || "";
-  const maxLen = 200;
-  const preview = output.length > maxLen ? output.slice(0, maxLen) + "..." : output;
-  if (preview.trim()) {
-    const lines = preview.split(`
-`).slice(0, 3);
-    process.stdout.write(import_picocolors6.default.dim(`   \u2514\u2500 ${lines.join(`
-      `)}
+  if (output.trim()) {
+    process.stdout.write(import_picocolors7.default.dim(`  ${displayChars.treeEnd} output  
 `));
+    const padded = writePaddedText(output, true);
+    process.stdout.write(import_picocolors7.default.dim(padded.output + (padded.atLineStart ? "" : "  ")));
+    process.stdout.write(`
+`);
   }
   state.currentTool = null;
   state.lastPartText = "";
+  state.textAtLineStart = true;
 }
 function handleTuiToast(_ctx, payload, state) {
   if (payload.type !== "tui.toast.show")
     return;
   const props = payload.properties;
-  const title = props?.title ? `${props.title}: ` : "";
-  const message = props?.message?.trim();
   const variant = props?.variant ?? "info";
-  if (!message)
-    return;
   if (variant === "error") {
-    state.mainSessionError = true;
-    state.lastError = `${title}${message}`;
-    console.error(import_picocolors6.default.red(`
-[tui.toast.error] ${state.lastError}`));
-    return;
+    const title = props?.title ? `${props.title}: ` : "";
+    const message = props?.message?.trim();
+    if (message) {
+      state.mainSessionError = true;
+      state.lastError = `${title}${message}`;
+    }
   }
-  const colorize = variant === "warning" ? import_picocolors6.default.yellow : import_picocolors6.default.dim;
-  console.log(colorize(`[toast:${variant}] ${title}${message}`));
+}
+function ensureThinkBlockOpen(state) {
+  if (state.inThinkBlock)
+    return;
+  openThinkBlock();
+  state.inThinkBlock = true;
+  state.hasPrintedThinkingLine = false;
+  state.thinkingAtLineStart = false;
+}
+function closeThinkBlockIfNeeded(state) {
+  if (!state.inThinkBlock)
+    return;
+  closeThinkBlock();
+  state.inThinkBlock = false;
+  state.lastThinkingLineWidth = 0;
+  state.lastThinkingSummary = "";
+  state.thinkingAtLineStart = false;
 }
 
 // src/cli/run/event-stream-processor.ts
@@ -10456,20 +10831,25 @@ async function processEvents(ctx, stream, state) {
     try {
       const payload = event;
       if (!payload?.type) {
-        console.error(import_picocolors7.default.dim(`[event] no type: ${JSON.stringify(event)}`));
+        if (ctx.verbose) {
+          console.error(import_picocolors8.default.dim(`[event] no type: ${JSON.stringify(event)}`));
+        }
         continue;
       }
-      logEventVerbose(ctx, payload);
+      if (ctx.verbose) {
+        logEventVerbose(ctx, payload);
+      }
       handleSessionError(ctx, payload, state);
       handleSessionIdle(ctx, payload, state);
       handleSessionStatus(ctx, payload, state);
       handleMessagePartUpdated(ctx, payload, state);
+      handleMessagePartDelta(ctx, payload, state);
       handleMessageUpdated(ctx, payload, state);
       handleToolExecute(ctx, payload, state);
       handleToolResult(ctx, payload, state);
       handleTuiToast(ctx, payload, state);
     } catch (err) {
-      console.error(import_picocolors7.default.red(`[event error] ${err}`));
+      console.error(import_picocolors8.default.red(`[event error] ${err}`));
     }
   }
 }
@@ -11224,14 +11604,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str2 = "";
+  let str3 = "";
   for (let i2 = 0;i2 < length; i2++) {
-    str2 += chars[Math.floor(Math.random() * chars.length)];
+    str3 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str2;
+  return str3;
 }
-function esc(str2) {
-  return JSON.stringify(str2);
+function esc(str3) {
+  return JSON.stringify(str3);
 }
 var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
 function isObject2(data) {
@@ -11325,8 +11705,8 @@ var getParsedType = (data) => {
 };
 var propertyKeyTypes = new Set(["string", "number", "symbol"]);
 var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
-function escapeRegex(str2) {
-  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str3) {
+  return str3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -20561,10 +20941,10 @@ function _property(property, schema2, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types2, params) {
+function _mime(types3, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types2,
+    mime: types3,
     ...normalizeParams(params)
   });
 }
@@ -22474,7 +22854,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   ZodType.init(inst, def);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types2, params) => inst.check(_mime(Array.isArray(types2) ? types2 : [types2], params));
+  inst.mime = (types3, params) => inst.check(_mime(Array.isArray(types3) ? types3 : [types3], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -23040,9 +23420,11 @@ var HookNameSchema = exports_external.enum([
   "claude-code-hooks",
   "auto-slash-command",
   "edit-error-recovery",
+  "json-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
   "sisyphus-junior-notepad",
+  "sisyphus-gpt-hephaestus-reminder",
   "start-work",
   "atlas",
   "unstable-agent-babysitter",
@@ -24739,7 +25121,7 @@ async function createOpencode(options) {
 
 // src/cli/run/server-connection.ts
 init_port_utils();
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 import { delimiter, dirname, join as join8 } from "path";
@@ -24831,13 +25213,25 @@ function prependResolvedOpencodeBinToPath(env = process.env, resolve2 = resolveF
 }
 
 // src/cli/run/server-connection.ts
+function isPortStartFailure(error45, port) {
+  if (!(error45 instanceof Error)) {
+    return false;
+  }
+  return error45.message.includes(`Failed to start server on port ${port}`);
+}
+async function startServer(options) {
+  const { signal, port } = options;
+  const { client: client3, server: server2 } = await withWorkingOpencodePath(() => createOpencode({ signal, port, hostname: "127.0.0.1" }));
+  console.log(import_picocolors9.default.dim("Server listening at"), import_picocolors9.default.cyan(server2.url));
+  return { client: client3, cleanup: () => server2.close() };
+}
 async function createServerConnection(options) {
   prependResolvedOpencodeBinToPath();
   const { port, attach, signal } = options;
   if (attach !== undefined) {
-    console.log(import_picocolors8.default.dim("Attaching to existing server at"), import_picocolors8.default.cyan(attach));
-    const client4 = createOpencodeClient({ baseUrl: attach });
-    return { client: client4, cleanup: () => {} };
+    console.log(import_picocolors9.default.dim("Attaching to existing server at"), import_picocolors9.default.cyan(attach));
+    const client3 = createOpencodeClient({ baseUrl: attach });
+    return { client: client3, cleanup: () => {} };
   }
   if (port !== undefined) {
     if (port < 1 || port > 65535) {
@@ -24845,28 +25239,46 @@ async function createServerConnection(options) {
     }
     const available = await isPortAvailable(port, "127.0.0.1");
     if (available) {
-      console.log(import_picocolors8.default.dim("Starting server on port"), import_picocolors8.default.cyan(port.toString()));
-      const { client: client5, server: server3 } = await withWorkingOpencodePath(() => createOpencode({ signal, port, hostname: "127.0.0.1" }));
-      console.log(import_picocolors8.default.dim("Server listening at"), import_picocolors8.default.cyan(server3.url));
-      return { client: client5, cleanup: () => server3.close() };
+      console.log(import_picocolors9.default.dim("Starting server on port"), import_picocolors9.default.cyan(port.toString()));
+      try {
+        return await startServer({ signal, port });
+      } catch (error45) {
+        if (!isPortStartFailure(error45, port)) {
+          throw error45;
+        }
+        const stillAvailable = await isPortAvailable(port, "127.0.0.1");
+        if (stillAvailable) {
+          throw error45;
+        }
+        console.log(import_picocolors9.default.dim("Port"), import_picocolors9.default.cyan(port.toString()), import_picocolors9.default.dim("became occupied, attaching to existing server"));
+        const client4 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
+        return { client: client4, cleanup: () => {} };
+      }
     }
-    console.log(import_picocolors8.default.dim("Port"), import_picocolors8.default.cyan(port.toString()), import_picocolors8.default.dim("is occupied, attaching to existing server"));
-    const client4 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
-    return { client: client4, cleanup: () => {} };
+    console.log(import_picocolors9.default.dim("Port"), import_picocolors9.default.cyan(port.toString()), import_picocolors9.default.dim("is occupied, attaching to existing server"));
+    const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
+    return { client: client3, cleanup: () => {} };
   }
   const { port: selectedPort, wasAutoSelected } = await getAvailableServerPort(DEFAULT_SERVER_PORT, "127.0.0.1");
   if (wasAutoSelected) {
-    console.log(import_picocolors8.default.dim("Auto-selected port"), import_picocolors8.default.cyan(selectedPort.toString()));
+    console.log(import_picocolors9.default.dim("Auto-selected port"), import_picocolors9.default.cyan(selectedPort.toString()));
   } else {
-    console.log(import_picocolors8.default.dim("Starting server on port"), import_picocolors8.default.cyan(selectedPort.toString()));
+    console.log(import_picocolors9.default.dim("Starting server on port"), import_picocolors9.default.cyan(selectedPort.toString()));
+  }
+  try {
+    return await startServer({ signal, port: selectedPort });
+  } catch (error45) {
+    if (!isPortStartFailure(error45, selectedPort)) {
+      throw error45;
+    }
+    const { port: retryPort } = await getAvailableServerPort(selectedPort + 1, "127.0.0.1");
+    console.log(import_picocolors9.default.dim("Retrying server start on port"), import_picocolors9.default.cyan(retryPort.toString()));
+    return await startServer({ signal, port: retryPort });
   }
-  const { client: client3, server: server2 } = await withWorkingOpencodePath(() => createOpencode({ signal, port: selectedPort, hostname: "127.0.0.1" }));
-  console.log(import_picocolors8.default.dim("Server listening at"), import_picocolors8.default.cyan(server2.url));
-  return { client: client3, cleanup: () => server2.close() };
 }
 
 // src/cli/run/session-resolver.ts
-var import_picocolors9 = __toESM(require_picocolors(), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 var SESSION_CREATE_MAX_RETRIES = 3;
 var SESSION_CREATE_RETRY_DELAY_MS = 1000;
 async function resolveSession(options) {
@@ -24892,11 +25304,11 @@ async function resolveSession(options) {
       query: { directory }
     });
     if (res.error) {
-      console.error(import_picocolors9.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES} failed:`));
-      console.error(import_picocolors9.default.dim(`  Error: ${serializeError(res.error)}`));
+      console.error(import_picocolors10.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES} failed:`));
+      console.error(import_picocolors10.default.dim(`  Error: ${serializeError(res.error)}`));
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
-        console.log(import_picocolors9.default.dim(`  Retrying in ${delay}ms...`));
+        console.log(import_picocolors10.default.dim(`  Retrying in ${delay}ms...`));
         await new Promise((resolve2) => setTimeout(resolve2, delay));
       }
       continue;
@@ -24904,10 +25316,10 @@ async function resolveSession(options) {
     if (res.data?.id) {
       return res.data.id;
     }
-    console.error(import_picocolors9.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES}: No session ID returned`));
+    console.error(import_picocolors10.default.yellow(`Session create attempt ${attempt}/${SESSION_CREATE_MAX_RETRIES}: No session ID returned`));
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
-      console.log(import_picocolors9.default.dim(`  Retrying in ${delay}ms...`));
+      console.log(import_picocolors10.default.dim(`  Retrying in ${delay}ms...`));
       await new Promise((resolve2) => setTimeout(resolve2, delay));
     }
   }
@@ -24946,14 +25358,14 @@ function createJsonOutputManager(options = {}) {
 }
 
 // src/cli/run/on-complete-hook.ts
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 async function executeOnCompleteHook(options) {
   const { command, sessionId, exitCode, durationMs, messageCount } = options;
   const trimmedCommand = command.trim();
   if (!trimmedCommand) {
     return;
   }
-  console.error(import_picocolors10.default.dim(`Running on-complete hook: ${trimmedCommand}`));
+  console.error(import_picocolors11.default.dim(`Running on-complete hook: ${trimmedCommand}`));
   try {
     const proc = Bun.spawn(["sh", "-c", trimmedCommand], {
       env: {
@@ -24968,16 +25380,16 @@ async function executeOnCompleteHook(options) {
     });
     const hookExitCode = await proc.exited;
     if (hookExitCode !== 0) {
-      console.error(import_picocolors10.default.yellow(`Warning: on-complete hook exited with code ${hookExitCode}`));
+      console.error(import_picocolors11.default.yellow(`Warning: on-complete hook exited with code ${hookExitCode}`));
     }
   } catch (error45) {
-    console.error(import_picocolors10.default.yellow(`Warning: Failed to execute on-complete hook: ${error45 instanceof Error ? error45.message : String(error45)}`));
+    console.error(import_picocolors11.default.yellow(`Warning: Failed to execute on-complete hook: ${error45 instanceof Error ? error45.message : String(error45)}`));
   }
 }
 
 // src/cli/run/agent-resolver.ts
 init_agent_display_names();
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
 var CORE_AGENT_ORDER = ["sisyphus", "hephaestus", "prometheus", "atlas"];
 var DEFAULT_AGENT = "sisyphus";
 var normalizeAgentName = (agent) => {
@@ -25022,35 +25434,224 @@ var resolveRunAgent = (options, pluginConfig, env = process.env) => {
     const fallbackName = getAgentDisplayName(fallback);
     const fallbackDisabled = isAgentDisabled(fallback, pluginConfig);
     if (fallbackDisabled) {
-      console.log(import_picocolors11.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
+      console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`));
       return fallbackName;
     }
-    console.log(import_picocolors11.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
+    console.log(import_picocolors12.default.yellow(`Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`));
     return fallbackName;
   }
   return resolved.resolvedName;
 };
 
 // src/cli/run/poll-for-completion.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/completion.ts
 init_shared();
-var import_picocolors12 = __toESM(require_picocolors(), 1);
+var import_picocolors13 = __toESM(require_picocolors(), 1);
+// src/features/boulder-state/constants.ts
+var BOULDER_DIR = ".sisyphus";
+var BOULDER_FILE = "boulder.json";
+var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
+var NOTEPAD_DIR = "notepads";
+var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
+// src/features/boulder-state/storage.ts
+import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync3, readdirSync } from "fs";
+import { dirname as dirname3, join as join9, basename } from "path";
+function getBoulderFilePath(directory) {
+  return join9(directory, BOULDER_DIR, BOULDER_FILE);
+}
+function readBoulderState(directory) {
+  const filePath = getBoulderFilePath(directory);
+  if (!existsSync11(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync11(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    if (!Array.isArray(parsed.session_ids)) {
+      parsed.session_ids = [];
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function getPlanProgress(planPath) {
+  if (!existsSync11(planPath)) {
+    return { total: 0, completed: 0, isComplete: true };
+  }
+  try {
+    const content = readFileSync11(planPath, "utf-8");
+    const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
+    const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
+    const total = uncheckedMatches.length + checkedMatches.length;
+    const completed = checkedMatches.length;
+    return {
+      total,
+      completed,
+      isComplete: total === 0 || completed === total
+    };
+  } catch {
+    return { total: 0, completed: 0, isComplete: true };
+  }
+}
+// src/features/run-continuation-state/constants.ts
+var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
+// src/features/run-continuation-state/storage.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync12, rmSync, writeFileSync as writeFileSync8 } from "fs";
+import { join as join10 } from "path";
+function getMarkerPath(directory, sessionID) {
+  return join10(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+}
+function readContinuationMarker(directory, sessionID) {
+  const markerPath = getMarkerPath(directory, sessionID);
+  if (!existsSync12(markerPath))
+    return null;
+  try {
+    const raw = readFileSync12(markerPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isContinuationMarkerActive(marker) {
+  if (!marker)
+    return false;
+  return Object.values(marker.sources).some((entry) => entry?.state === "active");
+}
+function getActiveContinuationMarkerReason(marker) {
+  if (!marker)
+    return null;
+  const active = Object.entries(marker.sources).find(([, entry2]) => entry2?.state === "active");
+  if (!active || !active[1])
+    return null;
+  const [source, entry] = active;
+  return entry.reason ?? `${source} continuation is active`;
+}
+// src/hooks/ralph-loop/storage.ts
+init_frontmatter();
+import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync9, unlinkSync, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+
+// src/hooks/ralph-loop/constants.ts
+var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
+var DEFAULT_MAX_ITERATIONS = 100;
+var DEFAULT_COMPLETION_PROMISE = "DONE";
+
+// src/hooks/ralph-loop/storage.ts
+function getStateFilePath(directory, customPath) {
+  return customPath ? join11(directory, customPath) : join11(directory, DEFAULT_STATE_FILE);
+}
+function readState(directory, customPath) {
+  const filePath = getStateFilePath(directory, customPath);
+  if (!existsSync13(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync13(filePath, "utf-8");
+    const { data, body } = parseFrontmatter(content);
+    const active = data.active;
+    const iteration = data.iteration;
+    if (active === undefined || iteration === undefined) {
+      return null;
+    }
+    const isActive = active === true || active === "true";
+    const iterationNum = typeof iteration === "number" ? iteration : Number(iteration);
+    if (isNaN(iterationNum)) {
+      return null;
+    }
+    const stripQuotes = (val) => {
+      const str3 = String(val ?? "");
+      return str3.replace(/^["']|["']$/g, "");
+    };
+    return {
+      active: isActive,
+      iteration: iterationNum,
+      max_iterations: Number(data.max_iterations) || DEFAULT_MAX_ITERATIONS,
+      completion_promise: stripQuotes(data.completion_promise) || DEFAULT_COMPLETION_PROMISE,
+      started_at: stripQuotes(data.started_at) || new Date().toISOString(),
+      prompt: body.trim(),
+      session_id: data.session_id ? stripQuotes(data.session_id) : undefined,
+      ultrawork: data.ultrawork === true || data.ultrawork === "true" ? true : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/run/continuation-state.ts
+function getContinuationState(directory, sessionID) {
+  const marker = readContinuationMarker(directory, sessionID);
+  return {
+    hasActiveBoulder: hasActiveBoulderContinuation(directory, sessionID),
+    hasActiveRalphLoop: hasActiveRalphLoopContinuation(directory, sessionID),
+    hasHookMarker: marker !== null,
+    hasTodoHookMarker: marker?.sources.todo !== undefined,
+    hasActiveHookMarker: isContinuationMarkerActive(marker),
+    activeHookMarkerReason: getActiveContinuationMarkerReason(marker)
+  };
+}
+function hasActiveBoulderContinuation(directory, sessionID) {
+  const boulder = readBoulderState(directory);
+  if (!boulder)
+    return false;
+  if (!boulder.session_ids.includes(sessionID))
+    return false;
+  const progress = getPlanProgress(boulder.active_plan);
+  return !progress.isComplete;
+}
+function hasActiveRalphLoopContinuation(directory, sessionID) {
+  const state = readState(directory);
+  if (!state || !state.active)
+    return false;
+  if (state.session_id && state.session_id !== sessionID) {
+    return false;
+  }
+  return true;
+}
+
+// src/cli/run/completion.ts
 async function checkCompletionConditions(ctx) {
   try {
-    if (!await areAllTodosComplete(ctx)) {
+    const continuationState = getContinuationState(ctx.directory, ctx.sessionID);
+    if (continuationState.hasActiveHookMarker) {
+      const reason = continuationState.activeHookMarkerReason ?? "continuation hook is active";
+      console.log(import_picocolors13.default.dim(`  Waiting: ${reason}`));
+      return false;
+    }
+    if (!continuationState.hasTodoHookMarker && !await areAllTodosComplete(ctx)) {
       return false;
     }
     if (!await areAllChildrenIdle(ctx)) {
       return false;
     }
+    if (!areContinuationHooksIdle(continuationState)) {
+      return false;
+    }
     return true;
   } catch (err) {
-    console.error(import_picocolors12.default.red(`[completion] API error: ${err}`));
+    console.error(import_picocolors13.default.red(`[completion] API error: ${err}`));
     return false;
   }
 }
+function areContinuationHooksIdle(continuationState) {
+  if (continuationState.hasActiveBoulder) {
+    console.log(import_picocolors13.default.dim("  Waiting: boulder continuation is active"));
+    return false;
+  }
+  if (continuationState.hasActiveRalphLoop) {
+    console.log(import_picocolors13.default.dim("  Waiting: ralph-loop continuation is active"));
+    return false;
+  }
+  return true;
+}
 async function areAllTodosComplete(ctx) {
   const todosRes = await ctx.client.session.todo({
     path: { id: ctx.sessionID },
@@ -25059,7 +25660,7 @@ async function areAllTodosComplete(ctx) {
   const todos = normalizeSDKResponse(todosRes, []);
   const incompleteTodos = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
   if (incompleteTodos.length > 0) {
-    console.log(import_picocolors12.default.dim(`  Waiting: ${incompleteTodos.length} todos remaining`));
+    console.log(import_picocolors13.default.dim(`  Waiting: ${incompleteTodos.length} todos remaining`));
     return false;
   }
   return true;
@@ -25083,7 +25684,7 @@ async function areAllDescendantsIdle(ctx, sessionID, allStatuses) {
   for (const child of children) {
     const status = allStatuses[child.id];
     if (status && status.type !== "idle") {
-      console.log(import_picocolors12.default.dim(`  Waiting: session ${child.id.slice(0, 8)}... is ${status.type}`));
+      console.log(import_picocolors13.default.dim(`  Waiting: session ${child.id.slice(0, 8)}... is ${status.type}`));
       return false;
     }
     const descendantsIdle = await areAllDescendantsIdle(ctx, child.id, allStatuses);
@@ -25097,9 +25698,9 @@ async function areAllDescendantsIdle(ctx, sessionID, allStatuses) {
 // src/cli/run/poll-for-completion.ts
 init_shared();
 var DEFAULT_POLL_INTERVAL_MS = 500;
-var DEFAULT_REQUIRED_CONSECUTIVE = 3;
+var DEFAULT_REQUIRED_CONSECUTIVE = 1;
 var ERROR_GRACE_CYCLES = 3;
-var MIN_STABILIZATION_MS = 1e4;
+var MIN_STABILIZATION_MS = 0;
 async function pollForCompletion(ctx, eventState, abortController, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const requiredConsecutive = options.requiredConsecutive ?? DEFAULT_REQUIRED_CONSECUTIVE;
@@ -25110,13 +25711,16 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
   const pollStartTimestamp = Date.now();
   while (!abortController.signal.aborted) {
     await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+    if (abortController.signal.aborted) {
+      return 130;
+    }
     if (eventState.mainSessionError) {
       errorCycleCount++;
       if (errorCycleCount >= ERROR_GRACE_CYCLES) {
-        console.error(import_picocolors13.default.red(`
+        console.error(import_picocolors14.default.red(`
 
 Session ended with error: ${eventState.lastError}`));
-        console.error(import_picocolors13.default.yellow("Check if todos were completed before the error."));
+        console.error(import_picocolors14.default.yellow("Check if todos were completed before the error."));
         return 1;
       }
       continue;
@@ -25138,6 +25742,10 @@ Session ended with error: ${eventState.lastError}`));
       continue;
     }
     if (!eventState.hasReceivedMeaningfulWork) {
+      if (minStabilizationMs <= 0) {
+        consecutiveCompleteChecks = 0;
+        continue;
+      }
       if (Date.now() - pollStartTimestamp < minStabilizationMs) {
         consecutiveCompleteChecks = 0;
         continue;
@@ -25153,9 +25761,12 @@ Session ended with error: ${eventState.lastError}`));
     }
     const shouldExit = await checkCompletionConditions(ctx);
     if (shouldExit) {
+      if (abortController.signal.aborted) {
+        return 130;
+      }
       consecutiveCompleteChecks++;
       if (consecutiveCompleteChecks >= requiredConsecutive) {
-        console.log(import_picocolors13.default.green(`
+        console.log(import_picocolors14.default.green(`
 
 All tasks completed.`));
         return 0;
@@ -25182,25 +25793,40 @@ async function getMainSessionStatus(ctx) {
   }
 }
 
+// src/cli/run/agent-profile-colors.ts
+init_shared();
+async function loadAgentProfileColors(client3) {
+  try {
+    const agentsRes = await client3.app.agents();
+    const agents = normalizeSDKResponse(agentsRes, [], {
+      preferResponseOnMissingData: true
+    });
+    const colors = {};
+    for (const agent of agents) {
+      if (!agent.name || !agent.color)
+        continue;
+      colors[agent.name] = agent.color;
+    }
+    return colors;
+  } catch {
+    return {};
+  }
+}
+
 // src/cli/run/runner.ts
-var DEFAULT_TIMEOUT_MS = 600000;
 var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
     eventProcessor.then(() => true),
     new Promise((resolve2) => setTimeout(() => resolve2(false), timeoutMs))
   ]);
-  if (!completed) {
-    console.log(import_picocolors14.default.dim(`[run] Event stream did not close within ${timeoutMs}ms after abort; continuing shutdown.`));
-  }
 }
 async function run(options) {
   process.env.OPENCODE_CLI_RUN_MODE = "true";
   const startTime = Date.now();
   const {
     message,
-    directory = process.cwd(),
-    timeout = DEFAULT_TIMEOUT_MS
+    directory = process.cwd()
   } = options;
   const jsonManager = options.json ? createJsonOutputManager() : null;
   if (jsonManager)
@@ -25208,14 +25834,6 @@ async function run(options) {
   const pluginConfig = loadPluginConfig(directory, { command: "run" });
   const resolvedAgent = resolveRunAgent(options, pluginConfig);
   const abortController = new AbortController;
-  let timeoutId = null;
-  if (timeout > 0) {
-    timeoutId = setTimeout(() => {
-      console.log(import_picocolors14.default.yellow(`
-Timeout reached. Aborting...`));
-      abortController.abort();
-    }, timeout);
-  }
   try {
     const { client: client3, cleanup: serverCleanup } = await createServerConnection({
       port: options.port,
@@ -25223,12 +25841,10 @@ Timeout reached. Aborting...`));
       signal: abortController.signal
     });
     const cleanup = () => {
-      if (timeoutId)
-        clearTimeout(timeoutId);
       serverCleanup();
     };
     process.on("SIGINT", () => {
-      console.log(import_picocolors14.default.yellow(`
+      console.log(import_picocolors15.default.yellow(`
 Interrupted. Shutting down...`));
       cleanup();
       process.exit(130);
@@ -25239,13 +25855,18 @@ Interrupted. Shutting down...`));
         sessionId: options.sessionId,
         directory
       });
-      console.log(import_picocolors14.default.dim(`Session: ${sessionID}`));
-      const ctx = { client: client3, sessionID, directory, abortController };
+      console.log(import_picocolors15.default.dim(`Session: ${sessionID}`));
+      const ctx = {
+        client: client3,
+        sessionID,
+        directory,
+        abortController,
+        verbose: options.verbose ?? false
+      };
       const events = await client3.event.subscribe({ query: { directory } });
       const eventState = createEventState();
+      eventState.agentColorsByName = await loadAgentProfileColors(client3);
       const eventProcessor = processEvents(ctx, events.stream, eventState).catch(() => {});
-      console.log(import_picocolors14.default.dim(`
-Sending prompt...`));
       await client3.session.promptAsync({
         path: { id: sessionID },
         body: {
@@ -25254,8 +25875,6 @@ Sending prompt...`));
         },
         query: { directory }
       });
-      console.log(import_picocolors14.default.dim(`Waiting for completion...
-`));
       const exitCode = await pollForCompletion(ctx, eventState, abortController);
       abortController.abort();
       await waitForEventProcessorShutdown(eventProcessor);
@@ -25285,14 +25904,12 @@ Sending prompt...`));
       throw err;
     }
   } catch (err) {
-    if (timeoutId)
-      clearTimeout(timeoutId);
     if (jsonManager)
       jsonManager.restore();
     if (err instanceof Error && err.name === "AbortError") {
       return 130;
     }
-    console.error(import_picocolors14.default.red(`Error: ${serializeError(err)}`));
+    console.error(import_picocolors15.default.red(`Error: ${serializeError(err)}`));
     return 1;
   }
 }
@@ -25300,53 +25917,53 @@ Sending prompt...`));
 init_checker();
 
 // src/cli/get-local-version/formatter.ts
-var import_picocolors15 = __toESM(require_picocolors(), 1);
+var import_picocolors16 = __toESM(require_picocolors(), 1);
 var SYMBOLS2 = {
-  check: import_picocolors15.default.green("[OK]"),
-  cross: import_picocolors15.default.red("[X]"),
-  arrow: import_picocolors15.default.cyan("->"),
-  info: import_picocolors15.default.blue("[i]"),
-  warn: import_picocolors15.default.yellow("[!]"),
-  pin: import_picocolors15.default.magenta("[PINNED]"),
-  dev: import_picocolors15.default.cyan("[DEV]")
+  check: import_picocolors16.default.green("[OK]"),
+  cross: import_picocolors16.default.red("[X]"),
+  arrow: import_picocolors16.default.cyan("->"),
+  info: import_picocolors16.default.blue("[i]"),
+  warn: import_picocolors16.default.yellow("[!]"),
+  pin: import_picocolors16.default.magenta("[PINNED]"),
+  dev: import_picocolors16.default.cyan("[DEV]")
 };
 function formatVersionOutput(info) {
   const lines = [];
   lines.push("");
-  lines.push(import_picocolors15.default.bold(import_picocolors15.default.white("oh-my-opencode Version Information")));
-  lines.push(import_picocolors15.default.dim("\u2500".repeat(50)));
+  lines.push(import_picocolors16.default.bold(import_picocolors16.default.white("oh-my-opencode Version Information")));
+  lines.push(import_picocolors16.default.dim("\u2500".repeat(50)));
   lines.push("");
   if (info.currentVersion) {
-    lines.push(`  Current Version: ${import_picocolors15.default.cyan(info.currentVersion)}`);
+    lines.push(`  Current Version: ${import_picocolors16.default.cyan(info.currentVersion)}`);
   } else {
-    lines.push(`  Current Version: ${import_picocolors15.default.dim("unknown")}`);
+    lines.push(`  Current Version: ${import_picocolors16.default.dim("unknown")}`);
   }
   if (!info.isLocalDev && info.latestVersion) {
-    lines.push(`  Latest Version:  ${import_picocolors15.default.cyan(info.latestVersion)}`);
+    lines.push(`  Latest Version:  ${import_picocolors16.default.cyan(info.latestVersion)}`);
   }
   lines.push("");
   switch (info.status) {
     case "up-to-date":
-      lines.push(`  ${SYMBOLS2.check} ${import_picocolors15.default.green("You're up to date!")}`);
+      lines.push(`  ${SYMBOLS2.check} ${import_picocolors16.default.green("You're up to date!")}`);
       break;
     case "outdated":
-      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors15.default.yellow("Update available")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Run:")} ${import_picocolors15.default.cyan("cd ~/.config/opencode && bun update oh-my-opencode")}`);
+      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors16.default.yellow("Update available")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Run:")} ${import_picocolors16.default.cyan("cd ~/.config/opencode && bun update oh-my-opencode")}`);
       break;
     case "local-dev":
-      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors15.default.cyan("Running in local development mode")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Using file:// protocol from config")}`);
+      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors16.default.cyan("Running in local development mode")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Using file:// protocol from config")}`);
       break;
     case "pinned":
-      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors15.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
-      lines.push(`  ${import_picocolors15.default.dim("Update check skipped for pinned versions")}`);
+      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors16.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
+      lines.push(`  ${import_picocolors16.default.dim("Update check skipped for pinned versions")}`);
       break;
     case "error":
-      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors15.default.red("Unable to check for updates")}`);
-      lines.push(`  ${import_picocolors15.default.dim("Network error or npm registry unavailable")}`);
+      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors16.default.red("Unable to check for updates")}`);
+      lines.push(`  ${import_picocolors16.default.dim("Network error or npm registry unavailable")}`);
       break;
     case "unknown":
-      lines.push(`  ${SYMBOLS2.info} ${import_picocolors15.default.yellow("Version information unavailable")}`);
+      lines.push(`  ${SYMBOLS2.info} ${import_picocolors16.default.yellow("Version information unavailable")}`);
       break;
   }
   lines.push("");
@@ -25446,21 +26063,21 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/constants.ts
-var import_picocolors16 = __toESM(require_picocolors(), 1);
+var import_picocolors17 = __toESM(require_picocolors(), 1);
 var SYMBOLS3 = {
-  check: import_picocolors16.default.green("\u2713"),
-  cross: import_picocolors16.default.red("\u2717"),
-  warn: import_picocolors16.default.yellow("\u26A0"),
-  info: import_picocolors16.default.blue("\u2139"),
-  arrow: import_picocolors16.default.cyan("\u2192"),
-  bullet: import_picocolors16.default.dim("\u2022"),
-  skip: import_picocolors16.default.dim("\u25CB")
+  check: import_picocolors17.default.green("\u2713"),
+  cross: import_picocolors17.default.red("\u2717"),
+  warn: import_picocolors17.default.yellow("\u26A0"),
+  info: import_picocolors17.default.blue("\u2139"),
+  arrow: import_picocolors17.default.cyan("\u2192"),
+  bullet: import_picocolors17.default.dim("\u2022"),
+  skip: import_picocolors17.default.dim("\u25CB")
 };
 var STATUS_COLORS = {
-  pass: import_picocolors16.default.green,
-  fail: import_picocolors16.default.red,
-  warn: import_picocolors16.default.yellow,
-  skip: import_picocolors16.default.dim
+  pass: import_picocolors17.default.green,
+  fail: import_picocolors17.default.red,
+  warn: import_picocolors17.default.yellow,
+  skip: import_picocolors17.default.dim
 };
 var CHECK_IDS = {
   SYSTEM: "system",
@@ -25483,29 +26100,29 @@ var PACKAGE_NAME4 = "oh-my-opencode";
 var OPENCODE_BINARIES2 = ["opencode", "opencode-desktop"];
 
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync23 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join13 } from "path";
+import { join as join16 } from "path";
 function getDesktopAppPaths(platform) {
   const home = homedir5();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join13(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join16(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join13(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join16(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join13(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join16(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -25513,8 +26130,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join13(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join13(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join16(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join16(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -25526,7 +26143,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync16) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync19) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -25573,13 +26190,13 @@ function compareVersions(current, minimum) {
 }
 
 // src/cli/doctor/checks/system-plugin.ts
-import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync21 } from "fs";
 init_shared();
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync17(paths.configJsonc))
+  if (existsSync20(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync17(paths.configJson))
+  if (existsSync20(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -25615,7 +26232,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync18(configPath, "utf-8");
+    const content = readFileSync21(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -25652,32 +26269,32 @@ function getPluginInfo() {
 // src/cli/doctor/checks/system-loaded-version.ts
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join14 } from "path";
+import { join as join17 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join14(homedir6(), "Library", "Caches");
+    return join17(homedir6(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join14(homedir6(), "AppData", "Local");
-  return join14(homedir6(), ".cache");
+    return process.env.LOCALAPPDATA ?? join17(homedir6(), "AppData", "Local");
+  return join17(homedir6(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join14(xdgCacheHome, "opencode");
+    return join17(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join14(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync18(fromShared) || !existsSync18(platformDefault))
+  const platformDefault = join17(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync21(fromShared) || !existsSync21(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function readPackageJson(filePath) {
-  if (!existsSync18(filePath))
+  if (!existsSync21(filePath))
     return null;
   try {
-    const content = readFileSync19(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -25691,8 +26308,8 @@ function normalizeVersion(value) {
 }
 function getLoadedPluginVersion() {
   const cacheDir = resolveOpenCodeCacheDir();
-  const cachePackagePath = join14(cacheDir, "package.json");
-  const installedPackagePath = join14(cacheDir, "node_modules", PACKAGE_NAME4, "package.json");
+  const cachePackagePath = join17(cacheDir, "package.json");
+  const installedPackagePath = join17(cacheDir, "node_modules", PACKAGE_NAME4, "package.json");
   const cachePackage = readPackageJson(cachePackagePath);
   const installedPackage = readPackageJson(installedPackagePath);
   const expectedVersion = normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME4]);
@@ -25715,10 +26332,10 @@ init_shared();
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync19(configPath))
+  if (!existsSync22(configPath))
     return false;
   try {
-    parseJsonc(readFileSync20(configPath, "utf-8"));
+    parseJsonc(readFileSync23(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -25820,28 +26437,28 @@ async function checkSystem() {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { join as join21 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync20, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync24 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 function getOpenCodeCacheDir2() {
   const xdgCache = process.env.XDG_CACHE_HOME;
   if (xdgCache)
-    return join15(xdgCache, "opencode");
-  return join15(homedir7(), ".cache", "opencode");
+    return join18(xdgCache, "opencode");
+  return join18(homedir7(), ".cache", "opencode");
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join15(getOpenCodeCacheDir2(), "models.json");
-  if (!existsSync20(cacheFile)) {
+  const cacheFile = join18(getOpenCodeCacheDir2(), "models.json");
+  if (!existsSync23(cacheFile)) {
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync21(cacheFile, "utf-8");
+    const content = readFileSync24(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const providers = Object.keys(data);
     let modelCount = 0;
@@ -25862,16 +26479,16 @@ init_model_requirements();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync22 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync25 } from "fs";
+import { join as join19 } from "path";
 var PACKAGE_NAME5 = "oh-my-opencode";
-var USER_CONFIG_BASE = join16(getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir, PACKAGE_NAME5);
-var PROJECT_CONFIG_BASE = join16(process.cwd(), ".opencode", PACKAGE_NAME5);
+var USER_CONFIG_BASE = join19(getOpenCodeConfigPaths({ binary: "opencode", version: null }).configDir, PACKAGE_NAME5);
+var PROJECT_CONFIG_BASE = join19(process.cwd(), ".opencode", PACKAGE_NAME5);
 function loadOmoConfig() {
   const projectDetected = detectConfigFile(PROJECT_CONFIG_BASE);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync22(projectDetected.path, "utf-8");
+      const content = readFileSync25(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -25880,7 +26497,7 @@ function loadOmoConfig() {
   const userDetected = detectConfigFile(USER_CONFIG_BASE);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync22(userDetected.path, "utf-8");
+      const content = readFileSync25(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -25891,7 +26508,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -25930,7 +26547,7 @@ function getCategoryEffectiveVariant(categoryName, requirement, config2) {
 // src/cli/doctor/checks/model-resolution-details.ts
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join17(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join20(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -26042,8 +26659,8 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var USER_CONFIG_BASE2 = join18(getOpenCodeConfigDir({ binary: "opencode" }), PACKAGE_NAME4);
-var PROJECT_CONFIG_BASE2 = join18(process.cwd(), ".opencode", PACKAGE_NAME4);
+var USER_CONFIG_BASE2 = join21(getOpenCodeConfigDir({ binary: "opencode" }), PACKAGE_NAME4);
+var PROJECT_CONFIG_BASE2 = join21(process.cwd(), ".opencode", PACKAGE_NAME4);
 function findConfigPath() {
   const projectConfig = detectConfigFile(PROJECT_CONFIG_BASE2);
   if (projectConfig.format !== "none")
@@ -26059,7 +26676,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync23(configPath, "utf-8");
+    const content = readFileSync26(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -26162,9 +26779,9 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname5, join as join19 } from "path";
+import { dirname as dirname7, join as join22 } from "path";
 async function checkBinaryExists(binary2) {
   try {
     const path9 = Bun.which(binary2);
@@ -26220,15 +26837,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync22 } = await import("fs");
-    const { join: join20 } = await import("path");
+    const { existsSync: existsSync25 } = await import("fs");
+    const { join: join23 } = await import("path");
     const { homedir: homedir8 } = await import("os");
     const pathsToCheck = [
-      join20(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join20(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join23(homedir8(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join23(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync22(napiPath)) {
+      if (existsSync25(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -26253,8 +26870,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire2(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join19(dirname5(pkgPath), "bin", binaryName);
-    if (existsSync21(binaryPath))
+    const binaryPath = join22(dirname7(pkgPath), "bin", binaryName);
+    if (existsSync24(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -26372,14 +26989,14 @@ init_jsonc_parser();
 
 // src/tools/lsp/server-installation.ts
 init_shared();
-import { existsSync as existsSync22 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { join as join23 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync22(cmd))
+    if (existsSync25(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -26401,23 +27018,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync22(join20(p2, cmd + suffix))) {
+      if (existsSync25(join23(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join20(getDataDir(), "opencode");
+  const dataDir = join23(getDataDir(), "opencode");
   const additionalBases = [
-    join20(cwd, "node_modules", ".bin"),
-    join20(configDir, "bin"),
-    join20(configDir, "node_modules", ".bin"),
-    join20(dataDir, "bin")
+    join23(cwd, "node_modules", ".bin"),
+    join23(configDir, "bin"),
+    join23(configDir, "node_modules", ".bin"),
+    join23(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync22(join20(base, cmd + suffix))) {
+      if (existsSync25(join23(base, cmd + suffix))) {
         return true;
       }
     }
@@ -26451,24 +27068,24 @@ function getLspServerStats(servers) {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync23, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync27 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join21 } from "path";
+import { join as join24 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join21(homedir8(), ".claude", ".mcp.json"),
-    join21(process.cwd(), ".mcp.json"),
-    join21(process.cwd(), ".claude", ".mcp.json")
+    join24(homedir8(), ".claude", ".mcp.json"),
+    join24(process.cwd(), ".mcp.json"),
+    join24(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync23(configPath))
+    if (!existsSync26(configPath))
       continue;
     try {
-      const content = readFileSync24(configPath, "utf-8");
+      const content = readFileSync27(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -26629,10 +27246,10 @@ function getAllCheckDefinitions() {
 }
 
 // src/cli/doctor/format-default.ts
-var import_picocolors18 = __toESM(require_picocolors(), 1);
+var import_picocolors19 = __toESM(require_picocolors(), 1);
 
 // src/cli/doctor/format-shared.ts
-var import_picocolors17 = __toESM(require_picocolors(), 1);
+var import_picocolors18 = __toESM(require_picocolors(), 1);
 function formatStatusSymbol(status) {
   const colorFn = STATUS_COLORS[status];
   switch (status) {
@@ -26647,23 +27264,23 @@ function formatStatusSymbol(status) {
   }
 }
 function formatStatusMark(available) {
-  return available ? import_picocolors17.default.green(SYMBOLS3.check) : import_picocolors17.default.red(SYMBOLS3.cross);
+  return available ? import_picocolors18.default.green(SYMBOLS3.check) : import_picocolors18.default.red(SYMBOLS3.cross);
 }
 function formatHeader() {
   return `
-${import_picocolors17.default.bgMagenta(import_picocolors17.default.white(" oMoMoMoMo Doctor "))}
+${import_picocolors18.default.bgMagenta(import_picocolors18.default.white(" oMoMoMoMo Doctor "))}
 `;
 }
 function formatIssue(issue2, index) {
   const lines = [];
-  const severityColor = issue2.severity === "error" ? import_picocolors17.default.red : import_picocolors17.default.yellow;
+  const severityColor = issue2.severity === "error" ? import_picocolors18.default.red : import_picocolors18.default.yellow;
   lines.push(`${index}. ${severityColor(issue2.title)}`);
-  lines.push(`   ${import_picocolors17.default.dim(issue2.description)}`);
+  lines.push(`   ${import_picocolors18.default.dim(issue2.description)}`);
   if (issue2.fix) {
-    lines.push(`   ${import_picocolors17.default.cyan("Fix:")} ${import_picocolors17.default.dim(issue2.fix)}`);
+    lines.push(`   ${import_picocolors18.default.cyan("Fix:")} ${import_picocolors18.default.dim(issue2.fix)}`);
   }
   if (issue2.affects && issue2.affects.length > 0) {
-    lines.push(`   ${import_picocolors17.default.cyan("Affects:")} ${import_picocolors17.default.dim(issue2.affects.join(", "))}`);
+    lines.push(`   ${import_picocolors18.default.cyan("Affects:")} ${import_picocolors18.default.dim(issue2.affects.join(", "))}`);
   }
   return lines.join(`
 `);
@@ -26677,12 +27294,12 @@ function formatDefault(result) {
   if (allIssues.length === 0) {
     const opencodeVer = result.systemInfo.opencodeVersion ?? "unknown";
     const pluginVer = result.systemInfo.pluginVersion ?? "unknown";
-    lines.push(` ${import_picocolors18.default.green(SYMBOLS3.check)} ${import_picocolors18.default.green(`System OK (opencode ${opencodeVer} \xB7 oh-my-opencode ${pluginVer})`)}`);
+    lines.push(` ${import_picocolors19.default.green(SYMBOLS3.check)} ${import_picocolors19.default.green(`System OK (opencode ${opencodeVer} \xB7 oh-my-opencode ${pluginVer})`)}`);
   } else {
     const issueCount = allIssues.filter((i2) => i2.severity === "error").length;
     const warnCount = allIssues.filter((i2) => i2.severity === "warning").length;
     const totalStr = `${issueCount + warnCount} ${issueCount + warnCount === 1 ? "issue" : "issues"}`;
-    lines.push(` ${import_picocolors18.default.yellow(SYMBOLS3.warn)} ${totalStr} found:
+    lines.push(` ${import_picocolors19.default.yellow(SYMBOLS3.warn)} ${totalStr} found:
 `);
     allIssues.forEach((issue2, index) => {
       lines.push(formatIssue(issue2, index + 1));
@@ -26694,7 +27311,7 @@ function formatDefault(result) {
 }
 
 // src/cli/doctor/format-status.ts
-var import_picocolors19 = __toESM(require_picocolors(), 1);
+var import_picocolors20 = __toESM(require_picocolors(), 1);
 function formatStatus(result) {
   const lines = [];
   lines.push(formatHeader());
@@ -26705,7 +27322,7 @@ function formatStatus(result) {
   const bunVer = systemInfo.bunVersion ?? "unknown";
   lines.push(` ${padding}System     ${opencodeVer} \xB7 ${pluginVer} \xB7 Bun ${bunVer}`);
   const configPath = systemInfo.configPath ?? "unknown";
-  const configStatus = systemInfo.configValid ? import_picocolors19.default.green("(valid)") : import_picocolors19.default.red("(invalid)");
+  const configStatus = systemInfo.configValid ? import_picocolors20.default.green("(valid)") : import_picocolors20.default.red("(invalid)");
   lines.push(` ${padding}Config     ${configPath} ${configStatus}`);
   const lspText = `LSP ${tools.lspInstalled}/${tools.lspTotal}`;
   const astGrepMark = formatStatusMark(tools.astGrepCli);
@@ -26722,13 +27339,13 @@ function formatStatus(result) {
 }
 
 // src/cli/doctor/format-verbose.ts
-var import_picocolors20 = __toESM(require_picocolors(), 1);
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 function formatVerbose(result) {
   const lines = [];
   lines.push(formatHeader());
   const { systemInfo, tools, results, summary } = result;
-  lines.push(`${import_picocolors20.default.bold("System Information")}`);
-  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  lines.push(`${import_picocolors21.default.bold("System Information")}`);
+  lines.push(`${import_picocolors21.default.dim("\u2500".repeat(40))}`);
   lines.push(`  ${formatStatusSymbol("pass")} opencode    ${systemInfo.opencodeVersion ?? "unknown"}`);
   lines.push(`  ${formatStatusSymbol("pass")} oh-my-opencode ${systemInfo.pluginVersion ?? "unknown"}`);
   if (systemInfo.loadedVersion) {
@@ -26739,33 +27356,33 @@ function formatVerbose(result) {
   }
   lines.push(`  ${formatStatusSymbol("pass")} path        ${systemInfo.opencodePath ?? "unknown"}`);
   if (systemInfo.isLocalDev) {
-    lines.push(`  ${import_picocolors20.default.yellow("*")} ${import_picocolors20.default.dim("(local development mode)")}`);
+    lines.push(`  ${import_picocolors21.default.yellow("*")} ${import_picocolors21.default.dim("(local development mode)")}`);
   }
   lines.push("");
-  lines.push(`${import_picocolors20.default.bold("Configuration")}`);
-  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
-  const configStatus = systemInfo.configValid ? import_picocolors20.default.green("valid") : import_picocolors20.default.red("invalid");
+  lines.push(`${import_picocolors21.default.bold("Configuration")}`);
+  lines.push(`${import_picocolors21.default.dim("\u2500".repeat(40))}`);
+  const configStatus = systemInfo.configValid ? import_picocolors21.default.green("valid") : import_picocolors21.default.red("invalid");
   lines.push(`  ${formatStatusSymbol(systemInfo.configValid ? "pass" : "fail")} ${systemInfo.configPath ?? "unknown"} (${configStatus})`);
   lines.push("");
-  lines.push(`${import_picocolors20.default.bold("Tools")}`);
-  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  lines.push(`${import_picocolors21.default.bold("Tools")}`);
+  lines.push(`${import_picocolors21.default.dim("\u2500".repeat(40))}`);
   lines.push(`  ${formatStatusSymbol("pass")} LSP         ${tools.lspInstalled}/${tools.lspTotal} installed`);
   lines.push(`  ${formatStatusSymbol(tools.astGrepCli ? "pass" : "fail")} ast-grep CLI ${tools.astGrepCli ? "installed" : "not found"}`);
   lines.push(`  ${formatStatusSymbol(tools.astGrepNapi ? "pass" : "fail")} ast-grep napi ${tools.astGrepNapi ? "installed" : "not found"}`);
   lines.push(`  ${formatStatusSymbol(tools.commentChecker ? "pass" : "fail")} comment-checker ${tools.commentChecker ? "installed" : "not found"}`);
   lines.push(`  ${formatStatusSymbol(tools.ghCli.installed && tools.ghCli.authenticated ? "pass" : "fail")} gh CLI ${tools.ghCli.installed ? "installed" : "not found"}${tools.ghCli.authenticated && tools.ghCli.username ? ` (${tools.ghCli.username})` : ""}`);
   lines.push("");
-  lines.push(`${import_picocolors20.default.bold("MCPs")}`);
-  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+  lines.push(`${import_picocolors21.default.bold("MCPs")}`);
+  lines.push(`${import_picocolors21.default.dim("\u2500".repeat(40))}`);
   if (tools.mcpBuiltin.length === 0) {
-    lines.push(`  ${import_picocolors20.default.dim("No built-in MCPs")}`);
+    lines.push(`  ${import_picocolors21.default.dim("No built-in MCPs")}`);
   } else {
     for (const mcp of tools.mcpBuiltin) {
       lines.push(`  ${formatStatusSymbol("pass")} ${mcp}`);
     }
   }
   if (tools.mcpUser.length > 0) {
-    lines.push(`  ${import_picocolors20.default.cyan("+")} ${tools.mcpUser.length} user MCP(s):`);
+    lines.push(`  ${import_picocolors21.default.cyan("+")} ${tools.mcpUser.length} user MCP(s):`);
     for (const mcp of tools.mcpUser) {
       lines.push(`    ${formatStatusSymbol("pass")} ${mcp}`);
     }
@@ -26773,20 +27390,20 @@ function formatVerbose(result) {
   lines.push("");
   const allIssues = results.flatMap((r2) => r2.issues);
   if (allIssues.length > 0) {
-    lines.push(`${import_picocolors20.default.bold("Issues")}`);
-    lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
+    lines.push(`${import_picocolors21.default.bold("Issues")}`);
+    lines.push(`${import_picocolors21.default.dim("\u2500".repeat(40))}`);
     allIssues.forEach((issue2, index) => {
       lines.push(formatIssue(issue2, index + 1));
       lines.push("");
     });
   }
-  lines.push(`${import_picocolors20.default.bold("Summary")}`);
-  lines.push(`${import_picocolors20.default.dim("\u2500".repeat(40))}`);
-  const passText = summary.passed > 0 ? import_picocolors20.default.green(`${summary.passed} passed`) : `${summary.passed} passed`;
-  const failText = summary.failed > 0 ? import_picocolors20.default.red(`${summary.failed} failed`) : `${summary.failed} failed`;
-  const warnText = summary.warnings > 0 ? import_picocolors20.default.yellow(`${summary.warnings} warnings`) : `${summary.warnings} warnings`;
+  lines.push(`${import_picocolors21.default.bold("Summary")}`);
+  lines.push(`${import_picocolors21.default.dim("\u2500".repeat(40))}`);
+  const passText = summary.passed > 0 ? import_picocolors21.default.green(`${summary.passed} passed`) : `${summary.passed} passed`;
+  const failText = summary.failed > 0 ? import_picocolors21.default.red(`${summary.failed} failed`) : `${summary.failed} failed`;
+  const warnText = summary.warnings > 0 ? import_picocolors21.default.yellow(`${summary.warnings} warnings`) : `${summary.warnings} warnings`;
   lines.push(`  ${passText}, ${failText}, ${warnText}`);
-  lines.push(`  ${import_picocolors20.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
+  lines.push(`  ${import_picocolors21.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
   return lines.join(`
 `);
 }
@@ -26870,11 +27487,11 @@ async function doctor(options = { mode: "default" }) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync24, mkdirSync as mkdirSync3, readFileSync as readFileSync25, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname6, join as join22 } from "path";
+import { chmodSync, existsSync as existsSync27, mkdirSync as mkdirSync6, readFileSync as readFileSync28, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname8, join as join25 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join22(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join25(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -26911,11 +27528,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync24(filePath)) {
+  if (!existsSync27(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync25(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -26924,11 +27541,11 @@ function readStore() {
 function writeStore(store) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname6(filePath);
-    if (!existsSync24(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    const dir = dirname8(filePath);
+    if (!existsSync27(dir)) {
+      mkdirSync6(dir, { recursive: true });
     }
-    writeFileSync9(filePath, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 384 });
+    writeFileSync12(filePath, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 384 });
     chmodSync(filePath, 384);
     return true;
   } catch {
@@ -26960,8 +27577,8 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync24(filePath)) {
-        unlinkSync(filePath);
+      if (existsSync27(filePath)) {
+        unlinkSync2(filePath);
       }
       return true;
     } catch {
@@ -27132,30 +27749,11 @@ function isRecord2(value) {
 }
 
 // src/features/mcp-oauth/callback-server.ts
+init_port_utils();
 var DEFAULT_PORT = 19877;
-var MAX_PORT_ATTEMPTS2 = 20;
 var TIMEOUT_MS = 5 * 60 * 1000;
-async function isPortAvailable2(port) {
-  try {
-    const server2 = Bun.serve({
-      port,
-      hostname: "127.0.0.1",
-      fetch: () => new Response
-    });
-    server2.stop(true);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function findAvailablePort2(startPort = DEFAULT_PORT) {
-  for (let attempt = 0;attempt < MAX_PORT_ATTEMPTS2; attempt++) {
-    const port = startPort + attempt;
-    if (await isPortAvailable2(port)) {
-      return port;
-    }
-  }
-  throw new Error(`No available port found in range ${startPort}-${startPort + MAX_PORT_ATTEMPTS2 - 1}`);
+  return findAvailablePort(startPort);
 }
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
@@ -27542,11 +28140,10 @@ Model Providers (Priority: Native > Copilot > OpenCode Zen > Z.ai > Kimi):
   const exitCode = await install(args);
   process.exit(exitCode);
 });
-program2.command("run <message>").allowUnknownOption().passThroughOptions().description("Run opencode with todo/background task completion enforcement").option("-a, --agent <name>", "Agent to use (default: from CLI/env/config, fallback: Sisyphus)").option("-d, --directory <path>", "Working directory").option("-t, --timeout <ms>", "Timeout in milliseconds (default: 30 minutes)", parseInt).option("-p, --port <port>", "Server port (attaches if port already in use)", parseInt).option("--attach <url>", "Attach to existing opencode server URL").option("--on-complete <command>", "Shell command to run after completion").option("--json", "Output structured JSON result to stdout").option("--session-id <id>", "Resume existing session instead of creating new one").addHelpText("after", `
+program2.command("run <message>").allowUnknownOption().passThroughOptions().description("Run opencode with todo/background task completion enforcement").option("-a, --agent <name>", "Agent to use (default: from CLI/env/config, fallback: Sisyphus)").option("-d, --directory <path>", "Working directory").option("-p, --port <port>", "Server port (attaches if port already in use)", parseInt).option("--attach <url>", "Attach to existing opencode server URL").option("--on-complete <command>", "Shell command to run after completion").option("--json", "Output structured JSON result to stdout").option("--verbose", "Show full event stream (default: messages/tools only)").option("--session-id <id>", "Resume existing session instead of creating new one").addHelpText("after", `
 Examples:
   $ bunx oh-my-opencode run "Fix the bug in index.ts"
   $ bunx oh-my-opencode run --agent Sisyphus "Implement feature X"
-  $ bunx oh-my-opencode run --timeout 3600000 "Large refactoring task"
   $ bunx oh-my-opencode run --port 4321 "Fix the bug"
   $ bunx oh-my-opencode run --attach http://127.0.0.1:4321 "Fix the bug"
   $ bunx oh-my-opencode run --json "Fix the bug" | jq .sessionId
@@ -27574,11 +28171,11 @@ Unlike 'opencode run', this command waits until:
     message,
     agent: options.agent,
     directory: options.directory,
-    timeout: options.timeout,
     port: options.port,
     attach: options.attach,
     onComplete: options.onComplete,
     json: options.json ?? false,
+    verbose: options.verbose ?? false,
     sessionId: options.sessionId
   };
   const exitCode = await run(runOptions);