oh-my-opencode 4.5.12 → 4.7.0

package/dist/index.js

@@ -4503,6 +4503,7 @@ import { spawn } from "child_process";
 async function executeHookCommand(command, stdin, cwd, options) {
   const home = getHomeDirectory();
   const timeoutMs = options?.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS;
+  const killGraceMs = options?.killGraceMs ?? SIGKILL_GRACE_MS;
   const expandedCommand = command.replace(/^~(?=\/|$)/g, home).replace(/\s~(?=\/)/g, ` ${home}`).replace(/\$CLAUDE_PROJECT_DIR/g, cwd).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd);
   let finalCommand = expandedCommand;
   if (options?.forceZsh) {
@@ -4519,6 +4520,7 @@ async function executeHookCommand(command, stdin, cwd, options) {
   }
   return new Promise((resolve2) => {
     let settled = false;
+    let timedOut = false;
     let killTimer = null;
     const isWin32 = process.platform === "win32";
     const PROTECTED_ENV_KEYS = new Set(["HOME", "CLAUDE_PROJECT_DIR"]);
@@ -4566,6 +4568,15 @@ async function executeHookCommand(command, stdin, cwd, options) {
       resolve2(result);
     };
     proc.on("close", (code) => {
+      if (timedOut) {
+        appendTimeoutNotice();
+        settle({
+          exitCode: 124,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+        return;
+      }
       settle({
         exitCode: code ?? 1,
         stdout: stdout.trim(),
@@ -4575,6 +4586,19 @@ async function executeHookCommand(command, stdin, cwd, options) {
     proc.on("error", (err) => {
       settle({ exitCode: 1, stderr: err.message });
     });
+    const killWindowsProcessTree = (onComplete) => {
+      if (!proc.pid) {
+        onComplete?.();
+        return;
+      }
+      const killer = spawn("taskkill", ["/PID", String(proc.pid), "/T", "/F"], {
+        windowsHide: true,
+        stdio: "ignore"
+      });
+      const finish = () => onComplete?.();
+      killer.on("error", finish);
+      killer.on("close", finish);
+    };
     const killProcessGroup = (signal) => {
       try {
         if (!isWin32 && proc.pid) {
@@ -4585,20 +4609,57 @@ async function executeHookCommand(command, stdin, cwd, options) {
           }
         } else {
           proc.kill(signal);
+          if (signal === "SIGKILL") {
+            killWindowsProcessTree();
+          }
         }
       } catch {}
     };
+    const appendTimeoutNotice = () => {
+      if (!stderr.includes("Hook command timed out after")) {
+        stderr += `
+Hook command timed out after ${timeoutMs}ms`;
+      }
+    };
     const timeoutTimer = setTimeout(() => {
       if (settled)
         return;
+      timedOut = true;
+      appendTimeoutNotice();
+      if (isWin32) {
+        killWindowsProcessTree(() => {
+          settle({
+            exitCode: 124,
+            stdout: stdout.trim(),
+            stderr: stderr.trim()
+          });
+        });
+        return;
+      }
       killProcessGroup("SIGTERM");
       killTimer = setTimeout(() => {
         if (settled)
           return;
+        if (isWin32) {
+          killWindowsProcessTree(() => {
+            settle({
+              exitCode: 124,
+              stdout: stdout.trim(),
+              stderr: stderr.trim()
+            });
+          });
+          return;
+        }
         killProcessGroup("SIGKILL");
-      }, SIGKILL_GRACE_MS);
-      stderr += `
-Hook command timed out after ${timeoutMs}ms`;
+        settle({
+          exitCode: 124,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      }, killGraceMs);
+      if (killTimer && typeof killTimer === "object" && "unref" in killTimer) {
+        killTimer.unref();
+      }
     }, timeoutMs);
     if (timeoutTimer && typeof timeoutTimer === "object" && "unref" in timeoutTimer) {
       timeoutTimer.unref();
@@ -4965,8 +5026,8 @@ var init_model_requirements = __esm(() => {
         { providers: ["opencode-go"], model: "qwen3.5-plus" },
         { providers: ["vercel"], model: "minimax-m2.7-highspeed" },
         { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
-        { providers: ["anthropic", "opencode", "vercel"], model: "claude-haiku-4-5" },
-        { providers: ["openai", "opencode", "vercel"], model: "gpt-5.4-nano" }
+        { providers: ["anthropic", "vercel"], model: "claude-haiku-4-5" },
+        { providers: ["openai", "vercel"], model: "gpt-5.4-nano" }
       ]
     },
     explore: {
@@ -4975,8 +5036,8 @@ var init_model_requirements = __esm(() => {
         { providers: ["opencode-go"], model: "qwen3.5-plus" },
         { providers: ["vercel"], model: "minimax-m2.7-highspeed" },
         { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
-        { providers: ["anthropic", "opencode", "vercel"], model: "claude-haiku-4-5" },
-        { providers: ["openai", "opencode", "vercel"], model: "gpt-5.4-nano" }
+        { providers: ["anthropic", "vercel"], model: "claude-haiku-4-5" },
+        { providers: ["openai", "vercel"], model: "gpt-5.4-nano" }
       ]
     },
     "multimodal-looker": {
@@ -5155,7 +5216,7 @@ var init_model_requirements = __esm(() => {
           model: "gpt-5.4-mini"
         },
         {
-          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
+          providers: ["anthropic", "github-copilot", "vercel"],
           model: "claude-haiku-4-5"
         },
         {
@@ -5432,7 +5493,7 @@ var init_model_capability_heuristics = __esm(() => {
     },
     {
       family: "kimi",
-      includes: ["kimi", "k2"],
+      pattern: /(?:kimi|k2(?![-.]?p\d))/,
       variants: ["low", "medium", "high"],
       supportsThinking: false
     },
@@ -5673,7 +5734,7 @@ function claudeVersionDot(model) {
 function applyGatewayTransforms(model) {
   return claudeVersionDot(model).replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview");
 }
-function transformModelForProviderUsingAnthropicBehavior(provider, model, directAnthropicTransform) {
+function transformModelForProviderUsingAnthropicBehavior(provider, model) {
   if (provider === "vercel") {
     const slashIndex = model.indexOf("/");
     if (slashIndex !== -1) {
@@ -5694,12 +5755,12 @@ function transformModelForProviderUsingAnthropicBehavior(provider, model, direct
     return model.replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview").replace(GEMINI_3_FLASH_PREVIEW, "gemini-3-flash-preview");
   }
   if (provider === "anthropic") {
-    return directAnthropicTransform(model);
+    return model;
   }
   return model;
 }
 function transformModelForProvider(provider, model) {
-  return transformModelForProviderUsingAnthropicBehavior(provider, model, claudeVersionDot);
+  return transformModelForProviderUsingAnthropicBehavior(provider, model);
 }
 var CLAUDE_VERSION_DOT, GEMINI_31_PRO_PREVIEW, GEMINI_3_FLASH_PREVIEW;
 var init_provider_model_id_transform = __esm(() => {
@@ -8736,8 +8797,30 @@ function resolveConfigPath(pathValue) {
     return resolvedPath;
   }
 }
+function isWslEnvironment() {
+  return process.platform === "linux" && (Boolean(process.env.WSL_DISTRO_NAME?.trim()) || Boolean(process.env.WSL_INTEROP?.trim()));
+}
+function isWindowsUserConfigRoot(pathValue) {
+  const normalizedPath = pathValue.replaceAll("\\", "/").toLowerCase();
+  return /^[a-z]:\/users\//.test(normalizedPath) || /^\/mnt\/[a-z]\/users\//.test(normalizedPath);
+}
+function getWindowsUserFromConfigRoot(pathValue) {
+  const normalizedPath = pathValue.replaceAll("\\", "/");
+  const match = /^(?:[a-z]:|\/mnt\/[a-z])\/Users\/([^/]+)/i.exec(normalizedPath);
+  return match?.[1] ?? null;
+}
+function getWslLinuxHomeDir(windowsConfigRoot) {
+  const envHome = process.env.HOME?.trim();
+  if (envHome && envHome.startsWith("/") && !isWindowsUserConfigRoot(envHome)) {
+    return envHome;
+  }
+  const user = process.env.USER?.trim() || process.env.LOGNAME?.trim() || process.env.SUDO_USER?.trim() || (windowsConfigRoot ? getWindowsUserFromConfigRoot(windowsConfigRoot) : undefined);
+  return user ? join6("/home", user) : null;
+}
 function getCliDefaultConfigDir() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir5(), ".config");
+  const envXdgConfig = process.env.XDG_CONFIG_HOME?.trim();
+  const shouldIgnoreWindowsXdg = envXdgConfig !== undefined && envXdgConfig.length > 0 && isWslEnvironment() && isWindowsUserConfigRoot(envXdgConfig);
+  const xdgConfig = shouldIgnoreWindowsXdg ? join6(getWslLinuxHomeDir(envXdgConfig) ?? "/home", ".config") : envXdgConfig || join6(homedir5(), ".config");
   return resolveConfigPath(join6(xdgConfig, "opencode"));
 }
 function getCliCustomConfigDir() {
@@ -54030,7 +54113,7 @@ function buildTmuxAttachCommand(serverUrl, sessionId, directory = process.cwd())
 }
 function buildTmuxPlaceholderCommand(description) {
   const escapedDescription = shellEscapeForDoubleQuotedCommand(description);
-  return `${TMUX_COMMAND_SHELL} -c "printf '%s\\n%s\\n' "OMO subagent pane ready: ${escapedDescription}" "Focus this pane to attach."; exec tail -f /dev/null"`;
+  return `${TMUX_COMMAND_SHELL} -c "printf '%s\\n%s\\n' \\"OMO subagent pane ready: ${escapedDescription}\\" \\"Focus this pane to attach.\\"; while :; do sleep 86400; done"`;
 }
 var TMUX_COMMAND_SHELL = "/bin/sh";
 var init_pane_command = () => {};
@@ -55033,7 +55116,7 @@ async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName)
     }
   }
 }
-var DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS = 2000, DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS = 30000, DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, DEFAULT_PROMPT_QUEUE_RETRY_MS = 250, promptGateMessagesFetchTimeoutMsForTesting;
+var DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS = 2000, DEFAULT_PROMPT_SEMANTIC_DEDUPE_HOLD_MS = 15000, DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS = 30000, DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, DEFAULT_PROMPT_QUEUE_RETRY_MS = 250, promptGateMessagesFetchTimeoutMsForTesting;
 
 // src/shared/prompt-async-gate/pending-tool-turn.ts
 function getPromptQuery(input) {
@@ -55146,6 +55229,45 @@ var init_pending_tool_turn = __esm(() => {
   init_message_inspection_error();
 });
 
+// src/shared/prompt-async-gate/recent-dispatches.ts
+function recentDispatchKey(sessionID, dedupeKey) {
+  return `${sessionID}\x00${dedupeKey}`;
+}
+function pruneRecentPromptDispatches(now = Date.now()) {
+  for (const [key, dispatch] of recentPromptDispatches) {
+    if (dispatch.expiresAt <= now) {
+      recentPromptDispatches.delete(key);
+    }
+  }
+}
+function getRecentPromptDispatch(sessionID, dedupeKey) {
+  pruneRecentPromptDispatches();
+  return recentPromptDispatches.get(recentDispatchKey(sessionID, dedupeKey));
+}
+function rememberRecentPromptDispatch(args) {
+  pruneRecentPromptDispatches();
+  if (args.holdMs <= 0) {
+    return;
+  }
+  recentPromptDispatches.set(recentDispatchKey(args.sessionID, args.dedupeKey), {
+    source: args.source,
+    expiresAt: Date.now() + args.holdMs
+  });
+  log("[prompt-async-gate] remembered semantic prompt dispatch", {
+    sessionID: args.sessionID,
+    source: args.source,
+    holdMs: args.holdMs
+  });
+}
+function deleteRecentPromptDispatch(sessionID, dedupeKey) {
+  recentPromptDispatches.delete(recentDispatchKey(sessionID, dedupeKey));
+}
+var recentPromptDispatches;
+var init_recent_dispatches = __esm(() => {
+  init_logger();
+  recentPromptDispatches = new Map;
+});
+
 // src/shared/prompt-async-gate/reservations.ts
 function setExpiredReservationHandler(handler) {
   expiredReservationHandler = handler;
@@ -55227,6 +55349,7 @@ async function dispatchAfterSessionIdle(args) {
     dedupeKey,
     settleMs,
     postDispatchHoldMs,
+    semanticDedupeHoldMs,
     dispatchTimeoutMs,
     checkStatus,
     checkToolState,
@@ -55284,10 +55407,25 @@ async function dispatchAfterSessionIdle(args) {
     log(`[prompt-async-gate] ${sessionName} dispatching`, { sessionID, source });
     dispatchAttempted = true;
     const response = await withDispatchTimeout(dispatch(input), dispatchTimeoutMs, `[prompt-async-gate] ${sessionName} dispatch`);
+    rememberRecentPromptDispatch({
+      sessionID,
+      dedupeKey,
+      source,
+      holdMs: semanticDedupeHoldMs
+    });
     log(`[prompt-async-gate] ${sessionName} dispatched`, { sessionID, source });
     return { status: "dispatched", response };
   } catch (error) {
-    log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: String(error) });
+    if (dispatchAttempted) {
+      rememberRecentPromptDispatch({
+        sessionID,
+        dedupeKey,
+        source,
+        holdMs: semanticDedupeHoldMs
+      });
+    }
+    const errorText = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: errorText });
     return { status: "failed", error, dispatchAttempted };
   } finally {
     finishPromptReservation(sessionID, reservation, dispatchAttempted, postDispatchHoldMs);
@@ -55297,6 +55435,7 @@ var init_session_idle_dispatch = __esm(() => {
   init_logger();
   init_session_idle_settle();
   init_pending_tool_turn();
+  init_recent_dispatches();
   init_reservations();
 });
 
@@ -55404,6 +55543,7 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
         dedupeKey: entry.dedupeKey,
         settleMs: entry.settleMs,
         postDispatchHoldMs: entry.postDispatchHoldMs,
+        semanticDedupeHoldMs: entry.semanticDedupeHoldMs,
         dispatchTimeoutMs: entry.dispatchTimeoutMs,
         checkStatus: entry.checkStatus,
         checkToolState: entry.checkToolState,
@@ -55487,27 +55627,119 @@ var init_queue = __esm(() => {
   });
 });
 
-// src/shared/prompt-async-gate.ts
+// src/shared/prompt-async-gate/semantic-dedupe.ts
+import { createHash } from "crypto";
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function canonicalizePromptInputForDedupe(key, value, seen = new WeakSet, depth = 0) {
+  if (key === "signal") {
+    return "[AbortSignal]";
+  }
+  if (typeof value === "function") {
+    return `[Function:${value.name}]`;
+  }
+  if (depth > MAX_PROMPT_DEDUPE_DEPTH) {
+    return "[MaxDepth]";
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    try {
+      return value.map((entry) => canonicalizePromptInputForDedupe("", entry, seen, depth + 1));
+    } finally {
+      seen.delete(value);
+    }
+  }
+  if (!isPlainRecord(value)) {
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  try {
+    const canonicalEntries = [];
+    for (const entryKey of Object.keys(value).sort()) {
+      canonicalEntries.push([
+        entryKey,
+        canonicalizePromptInputForDedupe(entryKey, value[entryKey], seen, depth + 1)
+      ]);
+    }
+    return Object.fromEntries(canonicalEntries);
+  } finally {
+    seen.delete(value);
+  }
+}
+function isContinuationTextPartLike(value) {
+  if (!isPlainRecord(value)) {
+    return false;
+  }
+  if (value.type !== "text" || typeof value.text !== "string") {
+    return false;
+  }
+  if (!hasInternalInitiatorMarker(value.text)) {
+    return false;
+  }
+  if (!isPlainRecord(value.metadata)) {
+    return false;
+  }
+  return value.metadata.compaction_continue === true;
+}
+function hasContinuationPromptIntent(input) {
+  if (!isPlainRecord(input) || !isPlainRecord(input.body) || !Array.isArray(input.body.parts)) {
+    return false;
+  }
+  return input.body.parts.some((part) => isContinuationTextPartLike(part));
+}
+function normalizePromptInputForSemanticDedupe(input) {
+  if (hasContinuationPromptIntent(input)) {
+    return {
+      __omo_internal_intent: "continuation"
+    };
+  }
+  return canonicalizePromptInputForDedupe("", input);
+}
 function stringifyPromptInputForDedupe(input) {
   try {
-    const serialized = JSON.stringify(input, (key, value) => {
-      if (key === "signal") {
-        return "[AbortSignal]";
-      }
-      if (typeof value === "function") {
-        return `[Function:${value.name}]`;
-      }
-      return value;
-    });
+    const serialized = JSON.stringify(normalizePromptInputForSemanticDedupe(input));
     return serialized ?? String(input);
-  } catch {
-    return String(input);
+  } catch (error) {
+    const errorTag = error instanceof Error ? error.name : String(error);
+    return `${String(input)}:[unserializable:${errorTag}]`;
   }
 }
-function createDefaultDedupeKey(source, input) {
+function createSemanticPromptDedupeKey(input) {
   const fingerprint = stringifyPromptInputForDedupe(input);
-  return `${source}:${fingerprint.length}:${fingerprint.slice(0, 8192)}`;
+  const digest = createHash("sha256").update(fingerprint, "utf8").digest("hex");
+  return `semantic:${digest}`;
 }
+function coalesceRecentSemanticPromptDispatch(args) {
+  const recentDispatch = getRecentPromptDispatch(args.sessionID, args.dedupeKey);
+  if (!recentDispatch) {
+    return;
+  }
+  log("[prompt-async-gate] prompt coalesced with recent semantic dispatch", {
+    sessionID: args.sessionID,
+    source: args.source,
+    queuedBy: recentDispatch.source
+  });
+  return { status: "queued", queuedBy: recentDispatch.source, position: 0 };
+}
+var MAX_PROMPT_DEDUPE_DEPTH = 64;
+var init_semantic_dedupe = __esm(() => {
+  init_internal_initiator_marker();
+  init_logger();
+  init_recent_dispatches();
+});
+
+// src/shared/prompt-async-gate.ts
 function hasObjectSessionPath(input) {
   return typeof input === "object" && input !== null && "path" in input && typeof input.path === "object" && input.path !== null && "id" in input.path && typeof input.path.id === "string";
 }
@@ -55537,9 +55769,10 @@ async function dispatchInternalPrompt(args) {
     source,
     settleMs = DEFAULT_SESSION_IDLE_SETTLE_MS
   } = args;
-  const dedupeKey = args.dedupeKey ?? createDefaultDedupeKey(source, input);
+  const dedupeKey = args.dedupeKey ?? createSemanticPromptDedupeKey(input);
   const queueRetryMs = args.queueRetryMs ?? DEFAULT_PROMPT_QUEUE_RETRY_MS;
   const postDispatchHoldMs = args.postDispatchHoldMs ?? DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS;
+  const semanticDedupeHoldMs = args.semanticDedupeHoldMs ?? (postDispatchHoldMs > 0 ? DEFAULT_PROMPT_SEMANTIC_DEDUPE_HOLD_MS : 0);
   const dispatchTimeoutMs = args.dispatchTimeoutMs ?? DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS;
   const sessionName = args.mode === "async" ? "promptAsync" : "prompt";
   const dispatch = (() => {
@@ -55572,6 +55805,10 @@ async function dispatchInternalPrompt(args) {
     if (queuedBy !== undefined || isPromptQueueDraining(sessionID)) {
       return { status: "reserved", reservedBy: queuedBy ?? source };
     }
+    const recentDispatchResult2 = coalesceRecentSemanticPromptDispatch({ sessionID, dedupeKey, source });
+    if (recentDispatchResult2) {
+      return recentDispatchResult2;
+    }
     return dispatchAfterSessionIdle({
       sessionName,
       client,
@@ -55581,6 +55818,7 @@ async function dispatchInternalPrompt(args) {
       dedupeKey,
       settleMs,
       postDispatchHoldMs,
+      semanticDedupeHoldMs,
       dispatchTimeoutMs,
       checkStatus: args.checkStatus !== false,
       checkToolState: args.checkToolState !== false,
@@ -55588,6 +55826,10 @@ async function dispatchInternalPrompt(args) {
     });
   }
   if (args.queue !== false) {
+    const recentDispatchResult2 = coalesceRecentSemanticPromptDispatch({ sessionID, dedupeKey, source });
+    if (recentDispatchResult2) {
+      return recentDispatchResult2;
+    }
     return enqueueInternalPrompt({
       id: nextPromptQueueID(),
       sessionID,
@@ -55598,6 +55840,7 @@ async function dispatchInternalPrompt(args) {
       dedupeKey,
       settleMs,
       postDispatchHoldMs,
+      semanticDedupeHoldMs,
       dispatchTimeoutMs,
       queueRetryMs,
       checkStatus: args.checkStatus !== false,
@@ -55605,6 +55848,10 @@ async function dispatchInternalPrompt(args) {
       dispatch: async (_dispatchInput) => dispatchWithPathCompatibility(dispatch, input)
     });
   }
+  const recentDispatchResult = coalesceRecentSemanticPromptDispatch({ sessionID, dedupeKey, source });
+  if (recentDispatchResult) {
+    return recentDispatchResult;
+  }
   return dispatchAfterSessionIdle({
     sessionName,
     client,
@@ -55614,6 +55861,7 @@ async function dispatchInternalPrompt(args) {
     dedupeKey,
     settleMs,
     postDispatchHoldMs,
+    semanticDedupeHoldMs,
     dispatchTimeoutMs,
     checkStatus: args.checkStatus !== false,
     checkToolState: args.checkToolState !== false,
@@ -55638,6 +55886,7 @@ function releasePromptAsyncReservation(sessionID, source, options) {
     return false;
   }
   deletePromptReservation(sessionID);
+  deleteRecentPromptDispatch(sessionID, existing.dedupeKey);
   releaseInFlightPromptMatchingDedupe(sessionID, existing.dedupeKey);
   schedulePromptQueueDrain(sessionID, 0);
   log("[prompt-async-gate] promptAsync reservation released", {
@@ -55651,8 +55900,10 @@ var init_prompt_async_gate = __esm(() => {
   init_logger();
   init_session_idle_settle();
   init_queue();
+  init_recent_dispatches();
   init_reservations();
   init_session_idle_dispatch();
+  init_semantic_dedupe();
 });
 
 // src/shared/prompt-failure-classifier.ts
@@ -63914,8 +64165,8 @@ var require_utils2 = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path21) {
-    let input = path21;
+  function removeDotSegments(path22) {
+    let input = path22;
     const output = [];
     let nextSlash = -1;
     let len = 0;
@@ -64158,8 +64409,8 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path21, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path21 && path21 !== "/" ? path21 : undefined;
+      const [path22, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path22 && path22 !== "/" ? path22 : undefined;
       wsComponent.query = query;
       wsComponent.resourceName = undefined;
     }
@@ -67334,12 +67585,12 @@ var require_dist = __commonJS((exports, module) => {
       throw new Error(`Unknown format "${name}"`);
     return f;
   };
-  function addFormats(ajv, list, fs22, exportName) {
+  function addFormats(ajv, list, fs23, exportName) {
     var _a;
     var _b;
     (_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
     for (const f of list)
-      ajv.addFormat(f, fs22[f]);
+      ajv.addFormat(f, fs23[f]);
   }
   module.exports = exports = formatsPlugin;
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -67350,8 +67601,8 @@ var require_dist = __commonJS((exports, module) => {
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs22 = __require("fs");
-  function checkPathExt(path21, options) {
+  var fs23 = __require("fs");
+  function checkPathExt(path22, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -67362,25 +67613,25 @@ var require_windows = __commonJS((exports, module) => {
     }
     for (var i2 = 0;i2 < pathext.length; i2++) {
       var p = pathext[i2].toLowerCase();
-      if (p && path21.substr(-p.length).toLowerCase() === p) {
+      if (p && path22.substr(-p.length).toLowerCase() === p) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat7, path21, options) {
+  function checkStat(stat7, path22, options) {
     if (!stat7.isSymbolicLink() && !stat7.isFile()) {
       return false;
     }
-    return checkPathExt(path21, options);
+    return checkPathExt(path22, options);
   }
-  function isexe(path21, options, cb) {
-    fs22.stat(path21, function(er, stat7) {
-      cb(er, er ? false : checkStat(stat7, path21, options));
+  function isexe(path22, options, cb) {
+    fs23.stat(path22, function(er, stat7) {
+      cb(er, er ? false : checkStat(stat7, path22, options));
     });
   }
-  function sync(path21, options) {
-    return checkStat(fs22.statSync(path21), path21, options);
+  function sync(path22, options) {
+    return checkStat(fs23.statSync(path22), path22, options);
   }
 });
 
@@ -67388,14 +67639,14 @@ var require_windows = __commonJS((exports, module) => {
 var require_mode = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs22 = __require("fs");
-  function isexe(path21, options, cb) {
-    fs22.stat(path21, function(er, stat7) {
+  var fs23 = __require("fs");
+  function isexe(path22, options, cb) {
+    fs23.stat(path22, function(er, stat7) {
       cb(er, er ? false : checkStat(stat7, options));
     });
   }
-  function sync(path21, options) {
-    return checkStat(fs22.statSync(path21), options);
+  function sync(path22, options) {
+    return checkStat(fs23.statSync(path22), options);
   }
   function checkStat(stat7, options) {
     return stat7.isFile() && checkMode(stat7, options);
@@ -67417,7 +67668,7 @@ var require_mode = __commonJS((exports, module) => {
 
 // node_modules/.bun/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS((exports, module) => {
-  var fs22 = __require("fs");
+  var fs23 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -67426,7 +67677,7 @@ var require_isexe = __commonJS((exports, module) => {
   }
   module.exports = isexe;
   isexe.sync = sync;
-  function isexe(path21, options, cb) {
+  function isexe(path22, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -67436,7 +67687,7 @@ var require_isexe = __commonJS((exports, module) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve25, reject) {
-        isexe(path21, options || {}, function(er, is) {
+        isexe(path22, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
@@ -67445,7 +67696,7 @@ var require_isexe = __commonJS((exports, module) => {
         });
       });
     }
-    core2(path21, options || {}, function(er, is) {
+    core2(path22, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -67455,9 +67706,9 @@ var require_isexe = __commonJS((exports, module) => {
       cb(er, is);
     });
   }
-  function sync(path21, options) {
+  function sync(path22, options) {
     try {
-      return core2.sync(path21, options || {});
+      return core2.sync(path22, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -67471,7 +67722,7 @@ var require_isexe = __commonJS((exports, module) => {
 // node_modules/.bun/which@2.0.2/node_modules/which/which.js
 var require_which = __commonJS((exports, module) => {
   var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path21 = __require("path");
+  var path22 = __require("path");
   var COLON = isWindows2 ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -67507,7 +67758,7 @@ var require_which = __commonJS((exports, module) => {
         return opt.all && found.length ? resolve25(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path21.join(pathPart, cmd);
+      const pCmd = path22.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       resolve25(subStep(p, i2, 0));
     });
@@ -67534,7 +67785,7 @@ var require_which = __commonJS((exports, module) => {
     for (let i2 = 0;i2 < pathEnv.length; i2++) {
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path21.join(pathPart, cmd);
+      const pCmd = path22.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j = 0;j < pathExt.length; j++) {
         const cur = p + pathExt[j];
@@ -67575,7 +67826,7 @@ var require_path_key = __commonJS((exports, module) => {
 
 // node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports, module) => {
-  var path21 = __require("path");
+  var path22 = __require("path");
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -67592,7 +67843,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
     try {
       resolved = which.sync(parsed.command, {
         path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path21.delimiter : undefined
+        pathExt: withoutPathExt ? path22.delimiter : undefined
       });
     } catch (e) {} finally {
       if (shouldSwitchCwd) {
@@ -67600,7 +67851,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
       }
     }
     if (resolved) {
-      resolved = path21.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path22.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -67645,8 +67896,8 @@ var require_shebang_command = __commonJS((exports, module) => {
     if (!match) {
       return null;
     }
-    const [path21, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary2 = path21.split("/").pop();
+    const [path22, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary2 = path22.split("/").pop();
     if (binary2 === "env") {
       return argument;
     }
@@ -67656,16 +67907,16 @@ var require_shebang_command = __commonJS((exports, module) => {
 
 // node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS((exports, module) => {
-  var fs22 = __require("fs");
+  var fs23 = __require("fs");
   var shebangCommand = require_shebang_command();
   function readShebang(command) {
     const size = 150;
     const buffer2 = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs22.openSync(command, "r");
-      fs22.readSync(fd, buffer2, 0, size, 0);
-      fs22.closeSync(fd);
+      fd = fs23.openSync(command, "r");
+      fs23.readSync(fd, buffer2, 0, size, 0);
+      fs23.closeSync(fd);
     } catch (e) {}
     return shebangCommand(buffer2.toString());
   }
@@ -67674,7 +67925,7 @@ var require_readShebang = __commonJS((exports, module) => {
 
 // node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
 var require_parse2 = __commonJS((exports, module) => {
-  var path21 = __require("path");
+  var path22 = __require("path");
   var resolveCommand2 = require_resolveCommand();
   var escape2 = require_escape();
   var readShebang = require_readShebang();
@@ -67699,7 +67950,7 @@ var require_parse2 = __commonJS((exports, module) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path21.normalize(parsed.command);
+      parsed.command = path22.normalize(parsed.command);
       parsed.command = escape2.command(parsed.command);
       parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -68406,6 +68657,10 @@ function registerAgentName(name) {
     }
   }
 }
+function clearRegisteredAgentNames() {
+  registeredAgentNames.clear();
+  registeredAgentAliases.clear();
+}
 function isAgentRegistered(name) {
   return registeredAgentNames.has(normalizeRegisteredAgentName(name));
 }
@@ -69458,80 +69713,6 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
     dispose: () => sessionStateStore.shutdown()
   };
 }
-// src/hooks/context-window-monitor.ts
-init_context_limit_resolver2();
-init_compaction_marker();
-init_event_session_id();
-init_system_directive();
-var CONTEXT_WARNING_THRESHOLD = 0.7;
-function createContextReminder(actualLimit) {
-  const limitTokens = actualLimit.toLocaleString();
-  return `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
-
-You are using a ${limitTokens}-token context window.
-You still have context remaining - do NOT rush or skip tasks.
-Complete your work thoroughly and methodically.`;
-}
-function createContextWindowMonitorHook(_ctx, modelCacheState) {
-  const remindedSessions = new Set;
-  const tokenCache = new Map;
-  const toolExecuteAfter = async (input, output) => {
-    const { sessionID } = input;
-    if (remindedSessions.has(sessionID))
-      return;
-    const cached2 = tokenCache.get(sessionID);
-    if (!cached2)
-      return;
-    const actualLimit = resolveActualContextLimit(cached2.providerID, cached2.modelID, modelCacheState);
-    if (!actualLimit)
-      return;
-    const lastTokens = cached2.tokens;
-    const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
-    const actualUsagePercentage = totalInputTokens / actualLimit;
-    if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD)
-      return;
-    remindedSessions.add(sessionID);
-    const clampedPercentage = Math.min(Math.max(actualUsagePercentage, 0), 1);
-    const usedPct = (clampedPercentage * 100).toFixed(1);
-    const remainingPct = ((1 - clampedPercentage) * 100).toFixed(1);
-    const usedTokens = totalInputTokens.toLocaleString();
-    const limitTokens = actualLimit.toLocaleString();
-    output.output += `
-
-${createContextReminder(actualLimit)}
-[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`;
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionID = resolveSessionEventID(props);
-      if (sessionID) {
-        remindedSessions.delete(sessionID);
-        tokenCache.delete(sessionID);
-      }
-    }
-    if (event.type === "message.updated") {
-      const info = props?.info;
-      const finish = info?.finish;
-      if (!info || info.role !== "assistant" || !finish)
-        return;
-      if (isCompactionAgent(info.agent))
-        return;
-      const sessionID = resolveMessageEventSessionID(props);
-      if (!sessionID || !info.providerID || !info.tokens)
-        return;
-      tokenCache.set(sessionID, {
-        providerID: info.providerID,
-        modelID: info.modelID ?? "",
-        tokens: info.tokens
-      });
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
 // src/hooks/session-notification-content.ts
 init_shared();
 function extractMessageText(message) {
@@ -72000,9 +72181,18 @@ function debugLog2(...args) {
 function getBinaryName2() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
+function resolveCommentCheckerPathFromPath(binaryName, which = Bun.which) {
+  try {
+    return which(binaryName);
+  } catch (error) {
+    debugLog2("PATH lookup failed:", error);
+    return null;
+  }
+}
 function findCommentCheckerPathSync() {
+  const binaryName = getBinaryName2();
   const resolvedPath = resolveCommentCheckerBinary({
-    binaryName: getBinaryName2(),
+    binaryName,
     cachedBinaryPath: getCachedBinaryPath2(),
     existsSync: existsSync35,
     importMetaUrl: import.meta.url
@@ -72011,6 +72201,11 @@ function findCommentCheckerPathSync() {
     debugLog2("resolved binary path:", resolvedPath);
     return resolvedPath;
   }
+  const pathBinary = resolveCommentCheckerPathFromPath(binaryName);
+  if (pathBinary !== null && existsSync35(pathBinary)) {
+    debugLog2("resolved PATH binary:", pathBinary);
+    return pathBinary;
+  }
   debugLog2("no binary found in known locations");
   return null;
 }
@@ -72900,7 +73095,7 @@ function findClosingDelimiter(content, openingLength) {
 }
 // packages/rules-engine/src/matcher.ts
 var import_picomatch = __toESM(require_picomatch2(), 1);
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { basename as basename6, relative as relative8 } from "path";
 var matcherCache = new Map;
 var MAX_MATCHER_CACHE_ENTRIES = 256;
@@ -72929,7 +73124,7 @@ function shouldApplyRule(metadata, currentFilePath, projectRoot) {
   return { applies: false };
 }
 function createContentHash(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
 }
 function isDuplicateByRealPath(realPath, cache) {
   return cache.has(realPath);
@@ -76338,9 +76533,7 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
 `);
     const cacheEntry = transcriptCache.get(sessionId);
     if (cacheEntry) {
-      cacheEntry.baseEntries = allEntries;
       cacheEntry.tempPath = tempPath;
-      cacheEntry.createdAt = Date.now();
     }
     return tempPath;
   } catch (error) {
@@ -85262,6 +85455,9 @@ function suppressComboStandalones(detected) {
     return detected;
   return detected.filter((k) => k.type !== "ultrawork" && k.type !== "hyperplan");
 }
+function filterAlreadyInjectedKeywords(detected, text) {
+  return detected.filter((keyword) => !text.includes(keyword.message));
+}
 function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultMode) {
   const disabledKeywords = config?.disabled_keywords;
   const enabledExpansions = config?.enabled_expansions;
@@ -85339,6 +85535,11 @@ function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultM
           return;
         }
       }
+      detectedKeywords = filterAlreadyInjectedKeywords(detectedKeywords, cleanText);
+      if (detectedKeywords.length === 0) {
+        log(`[keyword-detector] Skipping already injected keyword messages`, { sessionID: input.sessionID });
+        return;
+      }
       const hasUltrawork = detectedKeywords.some((k) => k.type === "ultrawork");
       if (hasUltrawork) {
         const runtimeVariant = getRuntimeVariant(input, output.message);
@@ -87513,9 +87714,10 @@ function collectAssistantText(message) {
   if (!Array.isArray(message.parts)) {
     return "";
   }
+  const allowTextParts = message.info?.role === "assistant";
   let text = "";
   for (const part of message.parts) {
-    if (part.type !== "text" && part.type !== "tool_result") {
+    if (part.type !== "tool_result" && !(allowTextParts && part.type === "text")) {
       continue;
     }
     text += `${text ? `
@@ -87534,9 +87736,6 @@ async function detectOracleVerificationFromParentSession(ctx, parentSessionID, d
     const messageArray = Array.isArray(messagesResponse) ? messagesResponse : Array.isArray(responseData) ? responseData : [];
     for (let index = messageArray.length - 1;index >= 0; index -= 1) {
       const message = messageArray[index];
-      if (message.info?.role !== "assistant") {
-        continue;
-      }
       const assistantText = collectAssistantText(message);
       if (!isOracleVerified(assistantText)) {
         continue;
@@ -87555,6 +87754,30 @@ async function detectOracleVerificationFromParentSession(ctx, parentSessionID, d
     return;
   }
 }
+function showCompletionToastBestEffort(ctx, state3) {
+  const showToast = ctx.client.tui?.showToast;
+  if (!showToast) {
+    return;
+  }
+  const toastBody = {
+    body: {
+      title: "ULTRAWORK LOOP COMPLETE!",
+      message: `JUST ULW ULW! Task completed after ${state3.iteration} iteration(s)`,
+      variant: "success",
+      duration: 5000
+    }
+  };
+  const logToastError = (error) => {
+    log(`[${HOOK_NAME3}] Failed to show ulw completion toast`, {
+      error: String(error)
+    });
+  };
+  try {
+    Promise.resolve(showToast(toastBody)).catch(logToastError);
+  } catch (error) {
+    logToastError(error);
+  }
+}
 async function handlePendingVerification(ctx, input) {
   const {
     sessionID,
@@ -87570,6 +87793,15 @@ async function handlePendingVerification(ctx, input) {
     if (!verificationSessionID && state3.session_id) {
       const recoveredVerificationSessionID = await detectOracleVerificationFromParentSession(ctx, state3.session_id, directory, apiTimeoutMs);
       if (recoveredVerificationSessionID) {
+        if (state3.completion_promise === ULTRAWORK_VERIFICATION_PROMISE) {
+          log(`[${HOOK_NAME3}] Oracle verification evidence found in parent session, completing ultrawork loop`, {
+            parentSessionID: state3.session_id,
+            recoveredVerificationSessionID
+          });
+          loopState.clear();
+          showCompletionToastBestEffort(ctx, state3);
+          return;
+        }
         const updatedState = loopState.setVerificationSessionID(state3.session_id, recoveredVerificationSessionID);
         if (updatedState) {
           log(`[${HOOK_NAME3}] Recovered missing verification session from parent evidence`, {
@@ -87657,8 +87889,8 @@ var USER_MESSAGE_IN_PROGRESS_WINDOW_MS = 2000;
 function sleep(ms) {
   return ms > 0 ? new Promise((resolve14) => setTimeout(resolve14, ms)) : Promise.resolve();
 }
-function hasRunningBackgroundTasks(backgroundManager, sessionID) {
-  return backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
+function hasActiveBackgroundTasks(backgroundManager, sessionID) {
+  return backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "pending" || task.status === "running") : false;
 }
 function getRuntimeRetryActivitySessionID(eventType, props) {
   if (eventType === "message.updated") {
@@ -87841,8 +88073,8 @@ function createRalphLoopEventHandler(ctx, options) {
         if (!state3 || !state3.active) {
           return;
         }
-        if (hasRunningBackgroundTasks(options.backgroundManager, sessionID)) {
-          log(`[${HOOK_NAME3}] Skipped: background tasks running`, { sessionID });
+        if (hasActiveBackgroundTasks(options.backgroundManager, sessionID)) {
+          log(`[${HOOK_NAME3}] Skipped: background tasks active`, { sessionID });
           return;
         }
         const verificationSessionID = state3.verification_pending ? state3.verification_session_id : undefined;
@@ -88076,8 +88308,8 @@ function createRalphLoopEventHandler(ctx, options) {
           handleErroredLoopSession(props, options.loopState);
           return;
         }
-        if (hasRunningBackgroundTasks(options.backgroundManager, sessionID)) {
-          log(`[${HOOK_NAME3}] Skipped runtime error retry: background tasks running`, { sessionID });
+        if (hasActiveBackgroundTasks(options.backgroundManager, sessionID)) {
+          log(`[${HOOK_NAME3}] Skipped runtime error retry: background tasks active`, { sessionID });
           return;
         }
         log(`[${HOOK_NAME3}] Retrying after runtime session error`, {
@@ -91169,6 +91401,12 @@ var initDeepSkill = {
   template: loadSharedSkillTemplate("init-deep"),
   argumentHint: "[--create-new] [--max-depth=N]"
 };
+// src/features/builtin-skills/skills/debugging.ts
+var debuggingSkill = {
+  name: "debugging",
+  description: "MUST USE for any real runtime debugging across ANY language or binary \u2014 crashes, silent failures, wrong responses, stuck processes, memory leaks, async misbehavior, unexplained timing, reverse engineering. Runs a hypothesis-driven loop: form \u22653 hypotheses, investigate in parallel, after 2 failed rounds spawn Oracles from orthogonal angles, confirm root cause, lock with a failing test, fix minimally, QA by actually USING the system, scrub artifacts. The actual HOW lives in `references/` \u2014 READ THEM. Triggers: 'debug this', 'why is X not working', 'hanging', 'attach a debugger', 'reverse engineer', 'pwndbg', 'gdb', 'lldb', 'node inspect', 'tsx debug', 'pdb', 'dlv', 'delve', 'rust-gdb', 'set a breakpoint', 'context window exploded', 'why is the response empty', 'attach the debugger', 'debug it', 'why is this happening', 'trace this bug', 'reproduce and fix', 'silent failure', 'HTTP 200 but empty', 'why did it stop', 'inspect the binary', 'reverse engineering', 'playwright'.",
+  template: loadSharedSkillTemplate("debugging")
+};
 // src/features/builtin-skills/security-research/SKILL.md
 var SKILL_default = `# Security Research - Team Mode Vulnerability Audit
 
@@ -91604,6 +91842,7 @@ function createBuiltinSkills(options = {}) {
     reviewWorkSkill,
     removeAiSlopsSkill,
     initDeepSkill,
+    debuggingSkill,
     securityResearchSkill,
     securityReviewSkill
   ];
@@ -92008,7 +92247,6 @@ var GitMasterConfigSchema = z17.object({
 import { z as z18 } from "zod";
 var HookNameSchema = z18.enum([
   "todo-continuation-enforcer",
-  "context-window-monitor",
   "session-recovery",
   "session-notification",
   "comment-checker",
@@ -92567,9 +92805,55 @@ async function discoverConfigSourceSkills(options) {
   }));
   return deduplicateSkillsByName(loadedBySource.flat());
 }
+// src/features/opencode-skill-loader/opencode-config-skills-reader.ts
+init_jsonc_parser2();
+init_opencode_config_dir();
+import * as fs21 from "fs";
+import * as path17 from "path";
+function getConfigPaths3(directory) {
+  const globalConfigDir = getOpenCodeConfigDir({ binary: "opencode" });
+  return [
+    path17.join(directory, ".opencode", "opencode.json"),
+    path17.join(directory, ".opencode", "opencode.jsonc"),
+    path17.join(globalConfigDir, "opencode.json"),
+    path17.join(globalConfigDir, "opencode.jsonc")
+  ];
+}
+function toStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function readOpencodeConfigSkills(directory) {
+  const paths = [];
+  const urls = [];
+  for (const configPath of getConfigPaths3(directory)) {
+    try {
+      if (!fs21.existsSync(configPath))
+        continue;
+      const content = fs21.readFileSync(configPath, "utf-8");
+      const parseResult = parseJsoncSafe(content);
+      if (!parseResult.data?.skills)
+        continue;
+      for (const p of toStringArray(parseResult.data.skills.paths)) {
+        if (!paths.includes(p))
+          paths.push(p);
+      }
+      for (const u of toStringArray(parseResult.data.skills.urls)) {
+        if (!urls.includes(u))
+          urls.push(u);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (paths.length === 0 && urls.length === 0)
+    return;
+  return { paths, urls };
+}
 // src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync63, readdirSync as readdirSync19, readFileSync as readFileSync46, statSync as statSync9 } from "fs";
-import { basename as basename9, join as join75 } from "path";
+import { existsSync as existsSync64, readdirSync as readdirSync19, readFileSync as readFileSync47, statSync as statSync9 } from "fs";
+import { basename as basename9, join as join76 } from "path";
 
 // src/tools/slashcommand/command-discovery-deps.ts
 init_excluded_dirs();
@@ -94112,7 +94396,7 @@ function loadBuiltinCommands(disabledCommands, options) {
 // src/tools/slashcommand/command-discovery.ts
 var NESTED_COMMAND_SEPARATOR = "/";
 function discoverCommandsFromDir(commandsDir, scope, prefix = "") {
-  if (!existsSync63(commandsDir))
+  if (!existsSync64(commandsDir))
     return [];
   if (!statSync9(commandsDir).isDirectory()) {
     log(`[command-discovery] Skipping non-directory path: ${commandsDir}`);
@@ -94127,16 +94411,16 @@ function discoverCommandsFromDir(commandsDir, scope, prefix = "") {
       if (entry.name.startsWith("."))
         continue;
       const nestedPrefix = prefix ? `${prefix}${NESTED_COMMAND_SEPARATOR}${entry.name}` : entry.name;
-      commands2.push(...discoverCommandsFromDir(join75(commandsDir, entry.name), scope, nestedPrefix));
+      commands2.push(...discoverCommandsFromDir(join76(commandsDir, entry.name), scope, nestedPrefix));
       continue;
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join75(commandsDir, entry.name);
+    const commandPath = join76(commandsDir, entry.name);
     const baseCommandName = basename9(entry.name, ".md");
     const commandName = prefix ? `${prefix}${NESTED_COMMAND_SEPARATOR}${baseCommandName}` : baseCommandName;
     try {
-      const content = readFileSync46(commandPath, "utf-8");
+      const content = readFileSync47(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -94188,8 +94472,8 @@ function deduplicateCommandInfosByName(commands2) {
   return deduplicatedCommands;
 }
 function discoverCommandsSync(directory, options) {
-  const userCommandsDir = join75(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join75(directory ?? process.cwd(), ".claude", "commands");
+  const userCommandsDir = join76(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join76(directory ?? process.cwd(), ".claude", "commands");
   const opencodeGlobalDirs = getOpenCodeCommandDirs({ binary: "opencode" });
   const opencodeProjectDirs = findProjectOpencodeCommandDirs(directory ?? process.cwd());
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
@@ -94689,7 +94973,7 @@ var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 var PROMETHEUS_PLANS_DIR = ".omo/plans";
 // packages/boulder-state/src/top-level-task.ts
-import { existsSync as existsSync64, readFileSync as readFileSync47 } from "fs";
+import { existsSync as existsSync65, readFileSync as readFileSync48 } from "fs";
 var TODO_HEADING_PATTERN = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN = /^##\s+/;
@@ -94712,11 +94996,11 @@ function buildTaskRef(section, taskLabel) {
   };
 }
 function readCurrentTopLevelTask(planPath) {
-  if (!existsSync64(planPath)) {
+  if (!existsSync65(planPath)) {
     return null;
   }
   try {
-    const content = readFileSync47(planPath, "utf-8");
+    const content = readFileSync48(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     let section = "other";
     for (const line of lines) {
@@ -94741,10 +95025,10 @@ function readCurrentTopLevelTask(planPath) {
   }
 }
 // packages/boulder-state/src/storage/path.ts
-import { existsSync as existsSync65 } from "fs";
-import { isAbsolute as isAbsolute13, join as join76, relative as relative11, resolve as resolve15 } from "path";
+import { existsSync as existsSync66 } from "fs";
+import { isAbsolute as isAbsolute13, join as join77, relative as relative11, resolve as resolve15 } from "path";
 function getBoulderFilePath(directory) {
-  return join76(directory, BOULDER_DIR, BOULDER_FILE);
+  return join77(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function resolveTrackedPath(baseDirectory, trackedPath) {
   return isAbsolute13(trackedPath) ? resolve15(trackedPath) : resolve15(baseDirectory, trackedPath);
@@ -94762,14 +95046,14 @@ function resolveBoulderPlanPath(directory, state3) {
   }
   const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
   const worktreePlanPath = resolve15(absoluteWorktreePath, relativePlanPath);
-  return existsSync65(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
+  return existsSync66(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
 }
 function resolveBoulderPlanPathForWork(directory, work) {
   return resolveBoulderPlanPath(directory, work);
 }
 // packages/boulder-state/src/storage/plan-progress.ts
-import { existsSync as existsSync66, readFileSync as readFileSync48, readdirSync as readdirSync20, statSync as statSync10 } from "fs";
-import { basename as basename10, join as join77 } from "path";
+import { existsSync as existsSync67, readFileSync as readFileSync49, readdirSync as readdirSync20, statSync as statSync10 } from "fs";
+import { basename as basename10, join as join78 } from "path";
 var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
@@ -94782,11 +95066,11 @@ var PROMETHEUS_PLAN_DIRS = [PROMETHEUS_PLANS_DIR, LEGACY_PROMETHEUS_PLANS_DIR];
 function findPrometheusPlans(directory) {
   try {
     return PROMETHEUS_PLAN_DIRS.flatMap((planDir) => {
-      const plansDir = join77(directory, planDir);
-      if (!existsSync66(plansDir)) {
+      const plansDir = join78(directory, planDir);
+      if (!existsSync67(plansDir)) {
         return [];
       }
-      return readdirSync20(plansDir).filter((file) => file.endsWith(".md")).map((file) => join77(plansDir, file));
+      return readdirSync20(plansDir).filter((file) => file.endsWith(".md")).map((file) => join78(plansDir, file));
     }).sort((left, right) => statSync10(right).mtimeMs - statSync10(left).mtimeMs);
   } catch {
     return [];
@@ -94796,11 +95080,11 @@ function getPlanName(planPath) {
   return basename10(planPath, ".md");
 }
 function getPlanProgress(planPath) {
-  if (!existsSync66(planPath)) {
+  if (!existsSync67(planPath)) {
     return { total: 0, completed: 0, isComplete: false };
   }
   try {
-    const content = readFileSync48(planPath, "utf-8");
+    const content = readFileSync49(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN2.test(line) || FINAL_VERIFICATION_HEADING_PATTERN2.test(line));
     if (hasStructuredSections) {
@@ -94930,14 +95214,14 @@ function selectMirrorWork(state3) {
   return sorted[0] ?? null;
 }
 // packages/boulder-state/src/storage/read-state.ts
-import { existsSync as existsSync67, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync68, readFileSync as readFileSync50 } from "fs";
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync67(filePath)) {
+  if (!existsSync68(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync49(filePath, "utf-8");
+    const content = readFileSync50(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -95068,13 +95352,13 @@ function getTaskSessionState(directory, taskKey) {
   return state3.task_sessions[taskKey] ?? null;
 }
 // packages/boulder-state/src/storage/write-state.ts
-import { existsSync as existsSync68, mkdirSync as mkdirSync17, unlinkSync as unlinkSync13, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync69, mkdirSync as mkdirSync17, unlinkSync as unlinkSync13, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname25 } from "path";
 function writeBoulderState(directory, state3) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname25(filePath);
-    if (!existsSync68(dir)) {
+    if (!existsSync69(dir)) {
       mkdirSync17(dir, { recursive: true });
     }
     const stateToWrite = { ...state3 };
@@ -95110,7 +95394,7 @@ function writeBoulderState(directory, state3) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync68(filePath)) {
+    if (existsSync69(filePath)) {
       unlinkSync13(filePath);
     }
     return true;
@@ -95815,6 +96099,23 @@ function buildExplicitPlanContext(params) {
   const allPlans = findPrometheusPlans(directory);
   const matchedPlan = findPlanByName(allPlans, explicitPlanName);
   if (!matchedPlan) {
+    const incompletePlans = allPlans.filter((planPath) => !getPlanProgress(planPath).isComplete);
+    if (incompletePlans.length === 1) {
+      createNewWorkOrInitialize({
+        directory,
+        planPath: incompletePlans[0],
+        sessionId,
+        activeAgent,
+        worktreePath
+      });
+      return buildAutoSelectedPlanContextInfoOnly({
+        planPath: incompletePlans[0],
+        sessionId,
+        timestamp: timestamp2,
+        worktreeBlock,
+        reason: `Only incomplete plan available after "${explicitPlanName}" did not match any plan`
+      });
+    }
     return buildMissingPlanContext(explicitPlanName, allPlans);
   }
   const progress = getPlanProgress(matchedPlan);
@@ -96221,8 +96522,8 @@ function isAbortError2(error) {
 // src/hooks/atlas/session-last-agent.ts
 init_shared();
 init_compaction_marker();
-import { readFileSync as readFileSync50, readdirSync as readdirSync21 } from "fs";
-import { join as join78 } from "path";
+import { readFileSync as readFileSync51, readdirSync as readdirSync21 } from "fs";
+import { join as join79 } from "path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -96276,7 +96577,7 @@ async function getLastAgentFromSession(sessionID, client, deps = {}) {
   try {
     const messages = readdirSync21(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync50(join78(messageDir, fileName), "utf-8");
+        const content = readFileSync51(join79(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -96796,7 +97097,7 @@ function getTaskLabelSortValue(taskLabel) {
   const parsed = Number.parseInt(taskLabel.replace(/[^0-9]/g, ""), 10);
   return Number.isNaN(parsed) ? Number.POSITIVE_INFINITY : parsed;
 }
-function hasRunningBackgroundTasks2(sessionID, options) {
+function hasRunningBackgroundTasks(sessionID, options) {
   const backgroundManager = options?.backgroundManager;
   return backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
 }
@@ -96925,7 +97226,7 @@ function scheduleRetry(input) {
     });
     if (!canContinueSession)
       return;
-    if (hasRunningBackgroundTasks2(sessionID, options)) {
+    if (hasRunningBackgroundTasks(sessionID, options)) {
       scheduleRetry({ ctx, sessionID, sessionState, options });
       return;
     }
@@ -97111,7 +97412,7 @@ async function handleAtlasSessionIdle(input) {
     sessionState.promptFailureCount = 0;
     sessionState.lastFailureAt = undefined;
   }
-  if (hasRunningBackgroundTasks2(sessionID, options)) {
+  if (hasRunningBackgroundTasks(sessionID, options)) {
     scheduleRetry({ ctx, sessionID, sessionState, options });
     log(`[${HOOK_NAME7}] Skipped: background tasks running`, { sessionID });
     return;
@@ -97271,7 +97572,7 @@ function createAtlasEventHandler(input) {
 // src/hooks/atlas/tool-execute-after.ts
 init_logger();
 init_session_utils();
-import { existsSync as existsSync70, readFileSync as readFileSync52 } from "fs";
+import { existsSync as existsSync71, readFileSync as readFileSync53 } from "fs";
 import { resolve as resolve18 } from "path";
 
 // src/hooks/atlas/background-launch-session-tracking.ts
@@ -97419,7 +97720,7 @@ async function resolveFallbackTrackedSessionId(input) {
 init_git_worktree();
 
 // src/hooks/atlas/final-wave-plan-state.ts
-import { existsSync as existsSync69, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync70, readFileSync as readFileSync52 } from "fs";
 var TODO_HEADING_PATTERN3 = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN3 = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN3 = /^##\s+/;
@@ -97427,11 +97728,11 @@ var UNCHECKED_CHECKBOX_PATTERN3 = /^\s*[-*]\s*\[\s*\]\s*(.+)$/;
 var TODO_TASK_PATTERN3 = /^\d+\./;
 var FINAL_WAVE_TASK_PATTERN3 = /^F\d+\./i;
 function readFinalWavePlanState(planPath) {
-  if (!existsSync69(planPath)) {
+  if (!existsSync70(planPath)) {
     return null;
   }
   try {
-    const content = readFileSync51(planPath, "utf-8");
+    const content = readFileSync52(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     let section = "other";
     let pendingImplementationTaskCount = 0;
@@ -97681,7 +97982,7 @@ function isWriteOrEditToolName(toolName) {
 
 // src/hooks/atlas/tool-execute-after.ts
 function isTrackedTaskChecked(planPath, taskKey) {
-  if (!existsSync70(planPath)) {
+  if (!existsSync71(planPath)) {
     return false;
   }
   const [section, label] = taskKey.split(":");
@@ -97694,7 +97995,7 @@ function isTrackedTaskChecked(planPath, taskKey) {
     return false;
   }
   try {
-    const content = readFileSync52(planPath, "utf-8");
+    const content = readFileSync53(planPath, "utf-8");
     return matcher.test(content);
   } catch {
     return false;
@@ -97738,11 +98039,11 @@ function parseCheckedTopLevelTaskKeys(planContent) {
   return checkedKeys;
 }
 function readCheckedTaskKeysFromPlan(planPath) {
-  if (!existsSync70(planPath)) {
+  if (!existsSync71(planPath)) {
     return new Set;
   }
   try {
-    return parseCheckedTopLevelTaskKeys(readFileSync52(planPath, "utf-8"));
+    return parseCheckedTopLevelTaskKeys(readFileSync53(planPath, "utf-8"));
   } catch {
     return new Set;
   }
@@ -97949,7 +98250,7 @@ init_logger();
 init_replace_tool_args();
 init_system_directive();
 init_session_utils();
-import { existsSync as existsSync71, readFileSync as readFileSync53 } from "fs";
+import { existsSync as existsSync72, readFileSync as readFileSync54 } from "fs";
 import { resolve as resolve19 } from "path";
 var TASK_SECTION_HEADER_PATTERN = /^##\s*1\.\s*TASK\s*$/i;
 var TODO_TASK_LINE_PATTERN = /^(?:[-*]\s*\[\s*\]\s*)?(\d+)\.\s+(.+)$/;
@@ -98010,8 +98311,8 @@ function createToolExecuteBeforeHandler2(input) {
       const planPath = sessionWork ? resolveBoulderPlanPathForWork(ctx.directory, sessionWork) : state3 ? resolveBoulderPlanPath(ctx.directory, state3) : null;
       if (planPath && resolve19(filePath) === resolve19(planPath) && pendingPlanSnapshots) {
         try {
-          if (existsSync71(planPath)) {
-            pendingPlanSnapshots.set(toolInput.callID, readFileSync53(planPath, "utf-8"));
+          if (existsSync72(planPath)) {
+            pendingPlanSnapshots.set(toolInput.callID, readFileSync54(planPath, "utf-8"));
           }
         } catch {
           pendingPlanSnapshots.delete(toolInput.callID);
@@ -99871,16 +100172,16 @@ function createPreemptiveCompactionHook(ctx, pluginConfig, modelCacheState) {
 init_shared();
 
 // src/hooks/tasks-todowrite-disabler/constants.ts
-var BLOCKED_TOOLS2 = ["TodoWrite", "TodoRead"];
-var REPLACEMENT_MESSAGE = `TodoRead/TodoWrite are DISABLED because experimental.task_system is enabled.
+var BLOCKED_TOOLS2 = ["TodoRead"];
+var REPLACEMENT_MESSAGE = `TodoRead is DISABLED because experimental.task_system is enabled.
 
-**ACTION REQUIRED**: RE-REGISTER what you were about to write as Todo using Task tools NOW. Then ASSIGN yourself and START WORKING immediately.
+**ACTION REQUIRED**: Use Task tools to inspect work state. TodoWrite is still allowed so the live todo panel keeps updating, but reads belong to the task system.
 
-**Use these tools instead:**
-- TaskCreate: Create new task with auto-generated ID
-- TaskUpdate: Update status, assign owner, add dependencies
+**Use these tools instead of TodoRead:**
 - TaskList: List active tasks with dependency info
 - TaskGet: Get full task details
+- TaskCreate: Create new task with auto-generated ID
+- TaskUpdate: Update status, assign owner, add dependencies
 
 **Workflow:**
 1. TaskCreate({ subject: "your task description" })
@@ -99899,7 +100200,7 @@ Even if the task seems trivial (1 line fix, simple edit, quick change), you MUST
 
 **WHY?** Task tracking = visibility = accountability. Skipping registration = invisible work = chaos.
 
-DO NOT retry TodoWrite. Convert to TaskCreate NOW.`;
+DO NOT retry TodoRead. Use TaskList or TaskGet NOW.`;
 
 // src/hooks/tasks-todowrite-disabler/hook.ts
 function createTasksTodowriteDisablerHook(config) {
@@ -100345,6 +100646,7 @@ function getLastUserRetryPayload(messagesResponse, sessionID) {
 }
 
 // src/hooks/runtime-fallback/auto-retry.ts
+init_internal_initiator_marker();
 var SESSION_TTL_MS = 30 * 60 * 1000;
 function createAutoRetryHelpers(deps) {
   const {
@@ -100457,7 +100759,7 @@ function createAutoRetryHelpers(deps) {
           sessionID,
           hint: "This can occur when the working directory contains .git and messages are not yet persisted"
         });
-        return [{ type: "text", text: "continue" }];
+        return [createInternalAgentContinuationTextPart("continue")];
       })();
       log(`[${HOOK_NAME11}] Auto-retrying with fallback model (${source})`, {
         sessionID,
@@ -101751,12 +102053,12 @@ function createRuntimeFallbackHook(ctx, options, factoryOverrides = {}) {
   };
 }
 // src/hooks/write-existing-file-guard/hook.ts
-import { existsSync as existsSync73, realpathSync as realpathSync8 } from "fs";
-import { basename as basename11, dirname as dirname26, isAbsolute as isAbsolute16, join as join79, normalize as normalize2, relative as relative13, resolve as resolve20 } from "path";
+import { existsSync as existsSync74, realpathSync as realpathSync8 } from "fs";
+import { basename as basename11, dirname as dirname26, isAbsolute as isAbsolute16, join as join80, normalize as normalize2, relative as relative13, resolve as resolve20 } from "path";
 
 // src/hooks/write-existing-file-guard/tool-execute-before-handler.ts
 init_shared();
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 
 // src/hooks/write-existing-file-guard/session-read-permissions.ts
 function touchSession(sessionLastAccess, sessionID) {
@@ -101857,7 +102159,7 @@ async function handleWriteExistingFileGuardToolExecuteBefore(params) {
     return;
   }
   if (toolName === "read") {
-    if (!existsSync72(resolvedPath) || !input.sessionID) {
+    if (!existsSync73(resolvedPath) || !input.sessionID) {
       return;
     }
     registerReadPermission({
@@ -101874,7 +102176,7 @@ async function handleWriteExistingFileGuardToolExecuteBefore(params) {
   if (argsRecord && "overwrite" in argsRecord) {
     delete argsRecord.overwrite;
   }
-  if (!existsSync72(resolvedPath)) {
+  if (!existsSync73(resolvedPath)) {
     return;
   }
   if (isOmoWorkspacePath(canonicalPath)) {
@@ -101933,7 +102235,7 @@ function isPathInsideDirectory(pathToCheck, directory) {
 }
 function toCanonicalPath2(absolutePath) {
   let canonicalPath = absolutePath;
-  if (existsSync73(absolutePath)) {
+  if (existsSync74(absolutePath)) {
     try {
       canonicalPath = realpathSync8.native(absolutePath);
     } catch {
@@ -101941,8 +102243,8 @@ function toCanonicalPath2(absolutePath) {
     }
   } else {
     const absoluteDir = dirname26(absolutePath);
-    const resolvedDir = existsSync73(absoluteDir) ? realpathSync8.native(absoluteDir) : absoluteDir;
-    canonicalPath = join79(resolvedDir, basename11(absolutePath));
+    const resolvedDir = existsSync74(absoluteDir) ? realpathSync8.native(absoluteDir) : absoluteDir;
+    canonicalPath = join80(resolvedDir, basename11(absolutePath));
   }
   return normalize2(canonicalPath);
 }
@@ -102986,16 +103288,16 @@ class Diff {
       }
     }
   }
-  addToPath(path17, added, removed, oldPosInc, options) {
-    const last = path17.lastComponent;
+  addToPath(path18, added, removed, oldPosInc, options) {
+    const last = path18.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path17.oldPos + oldPosInc,
+        oldPos: path18.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path17.oldPos + oldPosInc,
+        oldPos: path18.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -104657,8 +104959,8 @@ init_jsonc_parser2();
 init_opencode_config_dir();
 init_plugin_identity();
 init_plugin_entry_migrator();
-import { existsSync as existsSync74, readFileSync as readFileSync54 } from "fs";
-import { join as join80 } from "path";
+import { existsSync as existsSync75, readFileSync as readFileSync55 } from "fs";
+import { join as join81 } from "path";
 
 // src/hooks/legacy-plugin-toast/plugin-entry-migrator.ts
 init_migrate_legacy_plugin_entry();
@@ -104666,18 +104968,18 @@ init_migrate_legacy_plugin_entry();
 // src/hooks/legacy-plugin-toast/auto-migrate.ts
 function detectOpenCodeConfigPath(overrideConfigDir) {
   if (overrideConfigDir) {
-    const jsoncPath = join80(overrideConfigDir, "opencode.jsonc");
-    const jsonPath = join80(overrideConfigDir, "opencode.json");
-    if (existsSync74(jsoncPath))
+    const jsoncPath = join81(overrideConfigDir, "opencode.jsonc");
+    const jsonPath = join81(overrideConfigDir, "opencode.json");
+    if (existsSync75(jsoncPath))
       return jsoncPath;
-    if (existsSync74(jsonPath))
+    if (existsSync75(jsonPath))
       return jsonPath;
     return null;
   }
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync74(paths.configJsonc))
+  if (existsSync75(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync74(paths.configJson))
+  if (existsSync75(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -104686,7 +104988,7 @@ function autoMigrateLegacyPluginEntry(overrideConfigDir) {
   if (!configPath)
     return { migrated: false, from: null, to: null, configPath: null };
   try {
-    const content = readFileSync54(configPath, "utf-8");
+    const content = readFileSync55(configPath, "utf-8");
     const parseResult = parseJsoncSafe(content);
     if (!parseResult.data?.plugin)
       return { migrated: false, from: null, to: null, configPath };
@@ -104870,7 +105172,7 @@ function createNotepadWriteGuardHook() {
   };
 }
 // src/hooks/plan-format-validator/hook.ts
-import { existsSync as existsSync75, readFileSync as readFileSync55 } from "fs";
+import { existsSync as existsSync76, readFileSync as readFileSync56 } from "fs";
 import { resolve as resolve21 } from "path";
 init_logger();
 var WRITE_TOOLS = new Set(["Write", "Edit", "write", "edit"]);
@@ -104954,9 +105256,9 @@ function createPlanFormatValidatorHook(_ctx) {
       if (!isPlanFilePath(filePath))
         return;
       const resolvedPath = resolve21(_ctx.directory, filePath);
-      if (!existsSync75(resolvedPath))
+      if (!existsSync76(resolvedPath))
         return;
-      const content = readFileSync55(resolvedPath, "utf-8");
+      const content = readFileSync56(resolvedPath, "utf-8");
       if (!CHECKBOX_PATTERN.test(content))
         return;
       const rawCount = countRawTopLevelCheckboxes(content);
@@ -105086,21 +105388,21 @@ tool.schema = z36;
 
 // src/shared/ripgrep-cli.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync77 } from "fs";
-import { dirname as dirname27, join as join82 } from "path";
+import { existsSync as existsSync78 } from "fs";
+import { dirname as dirname27, join as join83 } from "path";
 
 // src/tools/grep/downloader.ts
 init_shared();
 init_plugin_identity();
 init_binary_downloader();
-import { existsSync as existsSync76, readdirSync as readdirSync22 } from "fs";
-import { join as join81 } from "path";
+import { existsSync as existsSync77, readdirSync as readdirSync22 } from "fs";
+import { join as join82 } from "path";
 function findFileRecursive(dir, filename) {
   try {
     const entries = readdirSync22(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join81(entry.parentPath ?? dir, entry.name);
+        return join82(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -105121,11 +105423,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join81(homeDir, ".cache", CACHE_DIR_NAME, "bin");
+  return join82(homeDir, ".cache", CACHE_DIR_NAME, "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join81(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join82(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -105142,7 +105444,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join81(destDir, binaryName);
+    const destPath = join82(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync6 } = await import("fs");
       renameSync6(foundPath, destPath);
@@ -105157,13 +105459,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync76(rgPath)) {
+  if (existsSync77(rgPath)) {
     return rgPath;
   }
   ensureCacheDir(installDir);
   const filename = `ripgrep-${RG_VERSION}-${config.platform}.${config.extension}`;
   const url = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join81(installDir, filename);
+  const archivePath = join82(installDir, filename);
   try {
     await downloadArchive(url, archivePath);
     if (config.extension === "tar.gz") {
@@ -105172,7 +105474,7 @@ async function downloadAndInstallRipgrep() {
       await extractZip2(archivePath, installDir);
     }
     ensureExecutable(rgPath);
-    if (!existsSync76(rgPath)) {
+    if (!existsSync77(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
@@ -105184,7 +105486,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync76(rgPath) ? rgPath : null;
+  return existsSync77(rgPath) ? rgPath : null;
 }
 
 // src/shared/ripgrep-cli.ts
@@ -105220,15 +105522,15 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join82(getOpenCodeCacheDir(), "bin", rgName),
-    join82(getDataDir(), "opencode", "bin", rgName),
-    join82(execDir, rgName),
-    join82(execDir, "bin", rgName),
-    join82(execDir, "..", "bin", rgName),
-    join82(execDir, "..", "libexec", rgName)
+    join83(getOpenCodeCacheDir(), "bin", rgName),
+    join83(getDataDir(), "opencode", "bin", rgName),
+    join83(execDir, rgName),
+    join83(execDir, "bin", rgName),
+    join83(execDir, "..", "bin", rgName),
+    join83(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync77(candidate)) {
+    if (existsSync78(candidate)) {
       return candidate;
     }
   }
@@ -105971,10 +106273,13 @@ function formatSlashCommand(command) {
   return lines.join(`
 `);
 }
-function formatCombinedDescription(skills2, commands2) {
-  const availableSkills = skills2 ?? [];
+function formatCombinedDescription(skills2, commands2, options = {}) {
+  const availableSkills = options.includeSkills ? skills2 ?? [] : [];
   const availableCommands = commands2 ?? [];
   if (availableSkills.length === 0 && availableCommands.length === 0) {
+    if ((skills2?.length ?? 0) > 0) {
+      return TOOL_DESCRIPTION_PREFIX;
+    }
     return TOOL_DESCRIPTION_NO_SKILLS;
   }
   const availableItems = [
@@ -105986,7 +106291,7 @@ function formatCombinedDescription(skills2, commands2) {
   }
   return `${TOOL_DESCRIPTION_PREFIX}
 <available_items>
-Priority: project > user > opencode > builtin/plugin | Skills listed before commands
+Priority: project > user > opencode > builtin/plugin${options.includeSkills ? " | Skills listed before commands" : ""}
 Invoke via: skill(name="item-name") - omit leading slash for commands.
 ${availableItems.join(`
 `)}
@@ -106228,7 +106533,9 @@ function createSkillTool(options) {
     const commands2 = getCommands();
     const publicSkills = skills2.filter((s) => !s.definition.agent);
     const skillInfos = publicSkills.map(loadedSkillToInfo);
-    cachedDescription = formatCombinedDescription(skillInfos, commands2);
+    cachedDescription = formatCombinedDescription(skillInfos, commands2, {
+      includeSkills: options.includeSkillsInDescription
+    });
     return cachedDescription;
   };
   if (options.skills !== undefined) {
@@ -106246,12 +106553,16 @@ function createSkillTool(options) {
         }
       } catch {}
     }
-    cachedDescription = formatCombinedDescription(skillInfos, commandsForDescription);
+    cachedDescription = formatCombinedDescription(skillInfos, commandsForDescription, {
+      includeSkills: options.includeSkillsInDescription
+    });
     if (needsAsyncRefresh) {
       buildDescription(true);
     }
   } else if (options.commands !== undefined) {
-    cachedDescription = formatCombinedDescription([], options.commands);
+    cachedDescription = formatCombinedDescription([], options.commands, {
+      includeSkills: options.includeSkillsInDescription
+    });
   }
   return tool({
     get description() {
@@ -106267,7 +106578,9 @@ function createSkillTool(options) {
     async execute(args, ctx) {
       const skills2 = await getSkills(ctx);
       const commands2 = getCommands();
-      cachedDescription = formatCombinedDescription(skills2.map(loadedSkillToInfo), commands2);
+      cachedDescription = formatCombinedDescription(skills2.map(loadedSkillToInfo), commands2, {
+        includeSkills: options.includeSkillsInDescription
+      });
       const requestedName = args.name.replace(/^\//, "");
       const matchedSkill = matchSkillByName(skills2, requestedName);
       if (matchedSkill) {
@@ -106328,9 +106641,9 @@ var skill = createSkillTool({ directory: process.cwd() });
 // src/tools/session-manager/constants.ts
 init_shared();
 init_shared();
-import { join as join83 } from "path";
-var TODO_DIR2 = join83(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join83(getClaudeConfigDir(), "transcripts");
+import { join as join84 } from "path";
+var TODO_DIR2 = join84(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join84(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
 
 Returns a list of available session IDs with metadata including message count, date range, and agents used.
@@ -106407,12 +106720,12 @@ init_opencode_storage_detection();
 init_shared();
 
 // src/tools/session-manager/file-storage.ts
-import { existsSync as existsSync78 } from "fs";
+import { existsSync as existsSync79 } from "fs";
 import { readdir as readdir5, readFile as readFile8 } from "fs/promises";
-import { join as join84 } from "path";
+import { join as join85 } from "path";
 init_opencode_message_dir();
 async function getFileMainSessions(directory) {
-  if (!existsSync78(SESSION_STORAGE))
+  if (!existsSync79(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -106420,13 +106733,13 @@ async function getFileMainSessions(directory) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join84(SESSION_STORAGE, projectDir.name);
+      const projectPath = join85(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir5(projectPath);
       for (const file of sessionFiles) {
         if (!file.endsWith(".json"))
           continue;
         try {
-          const content = await readFile8(join84(projectPath, file), "utf-8");
+          const content = await readFile8(join85(projectPath, file), "utf-8");
           const meta = JSON.parse(content);
           if (meta.parentID)
             continue;
@@ -106444,7 +106757,7 @@ async function getFileMainSessions(directory) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getFileAllSessions() {
-  if (!existsSync78(MESSAGE_STORAGE))
+  if (!existsSync79(MESSAGE_STORAGE))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -106453,7 +106766,7 @@ async function getFileAllSessions() {
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const sessionPath = join84(dir, entry.name);
+        const sessionPath = join85(dir, entry.name);
         const files = await readdir5(sessionPath);
         if (files.some((file) => file.endsWith(".json"))) {
           sessions.push(entry.name);
@@ -106473,7 +106786,7 @@ async function fileSessionExists(sessionID) {
 }
 async function getFileSessionMessages(sessionID) {
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync78(messageDir))
+  if (!messageDir || !existsSync79(messageDir))
     return [];
   const messages = [];
   try {
@@ -106482,7 +106795,7 @@ async function getFileSessionMessages(sessionID) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const content = await readFile8(join84(messageDir, file), "utf-8");
+        const content = await readFile8(join85(messageDir, file), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -106508,8 +106821,8 @@ async function getFileSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join84(PART_STORAGE, messageID);
-  if (!existsSync78(partDir))
+  const partDir = join85(PART_STORAGE, messageID);
+  if (!existsSync79(partDir))
     return [];
   const parts = [];
   try {
@@ -106518,7 +106831,7 @@ async function readParts2(messageID) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const content = await readFile8(join84(partDir, file), "utf-8");
+        const content = await readFile8(join85(partDir, file), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -106530,14 +106843,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function getFileSessionTodos(sessionID) {
-  if (!existsSync78(TODO_DIR2))
+  if (!existsSync79(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir5(TODO_DIR2);
     const todoFiles = allFiles.filter((file) => file === `${sessionID}.json`);
     for (const file of todoFiles) {
       try {
-        const content = await readFile8(join84(TODO_DIR2, file), "utf-8");
+        const content = await readFile8(join85(TODO_DIR2, file), "utf-8");
         const data = JSON.parse(content);
         if (!Array.isArray(data))
           continue;
@@ -106557,10 +106870,10 @@ async function getFileSessionTodos(sessionID) {
   return [];
 }
 async function getFileSessionTranscript(sessionID) {
-  if (!existsSync78(TRANSCRIPT_DIR2))
+  if (!existsSync79(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join84(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync78(transcriptFile))
+  const transcriptFile = join85(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync79(transcriptFile))
     return 0;
   try {
     const content = await readFile8(transcriptFile, "utf-8");
@@ -108365,25 +108678,25 @@ init_session_tools_store();
 init_file_utils2();
 init_shared();
 init_opencode_config_dir();
-import { existsSync as existsSync81, readdirSync as readdirSync23 } from "fs";
-import { join as join85 } from "path";
+import { existsSync as existsSync82, readdirSync as readdirSync23 } from "fs";
+import { join as join86 } from "path";
 
 // src/features/claude-code-agent-loader/agent-definitions-loader.ts
 init_frontmatter2();
 init_logger();
-import { existsSync as existsSync80, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync81, readFileSync as readFileSync58 } from "fs";
 import { basename as basename12, extname as extname3 } from "path";
 
 // src/features/claude-code-agent-loader/json-agent-loader.ts
 init_jsonc_parser2();
 init_claude_model_mapper();
-import { existsSync as existsSync79, readFileSync as readFileSync56 } from "fs";
+import { existsSync as existsSync80, readFileSync as readFileSync57 } from "fs";
 function parseJsonAgentFile(filePath, scope) {
   try {
-    if (!existsSync79(filePath)) {
+    if (!existsSync80(filePath)) {
       return null;
     }
-    const content = readFileSync56(filePath, "utf-8");
+    const content = readFileSync57(filePath, "utf-8");
     const { data } = parseJsoncSafe(content);
     if (!data) {
       return null;
@@ -108420,10 +108733,10 @@ function parseJsonAgentFile(filePath, scope) {
 init_claude_model_mapper();
 function parseMarkdownAgentFile(filePath, scope) {
   try {
-    if (!existsSync80(filePath)) {
+    if (!existsSync81(filePath)) {
       return null;
     }
-    const content = readFileSync57(filePath, "utf-8");
+    const content = readFileSync58(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const fileName = basename12(filePath);
     const agentName = fileName.replace(/\.md$/i, "");
@@ -108455,7 +108768,7 @@ function parseMarkdownAgentFile(filePath, scope) {
 function loadAgentDefinitions(paths, scope) {
   const result = Object.create(null);
   for (const filePath of paths) {
-    if (!existsSync80(filePath)) {
+    if (!existsSync81(filePath)) {
       log(`[agent-definitions-loader] File not found, skipping: ${filePath}`);
       continue;
     }
@@ -108480,7 +108793,7 @@ function loadAgentDefinitions(paths, scope) {
 
 // src/features/claude-code-agent-loader/loader.ts
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync81(agentsDir)) {
+  if (!existsSync82(agentsDir)) {
     return [];
   }
   const entries = readdirSync23(agentsDir, { withFileTypes: true });
@@ -108488,7 +108801,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join85(agentsDir, entry.name);
+    const agentPath = join86(agentsDir, entry.name);
     const agent = parseMarkdownAgentFile(agentPath, scope);
     if (agent) {
       agents.push(agent);
@@ -108497,7 +108810,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join85(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join86(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = Object.create(null);
   for (const agent of agents) {
@@ -108506,7 +108819,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents(directory) {
-  const projectAgentsDir = join85(directory ?? process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join86(directory ?? process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = Object.create(null);
   for (const agent of agents) {
@@ -108518,7 +108831,7 @@ function loadOpencodeGlobalAgents() {
   const result = Object.create(null);
   const configDirs = getOpenCodeConfigDirs({ binary: "opencode" });
   for (const configDir of configDirs) {
-    const opencodeAgentsDir = join85(configDir, "agents");
+    const opencodeAgentsDir = join86(configDir, "agents");
     const agents = loadAgentsFromDir(opencodeAgentsDir, "opencode");
     for (const agent of agents) {
       if (!(agent.name in result)) {
@@ -108529,7 +108842,7 @@ function loadOpencodeGlobalAgents() {
   return result;
 }
 function loadOpencodeProjectAgents(directory) {
-  const opencodeProjectDir = join85(directory ?? process.cwd(), ".opencode", "agents");
+  const opencodeProjectDir = join86(directory ?? process.cwd(), ".opencode", "agents");
   const agents = loadAgentsFromDir(opencodeProjectDir, "opencode-project");
   const result = Object.create(null);
   for (const agent of agents) {
@@ -108541,16 +108854,16 @@ function loadOpencodeProjectAgents(directory) {
 init_opencode_config_dir();
 init_jsonc_parser2();
 init_resolve_agent_definition_paths();
-import * as fs21 from "fs";
-import * as path17 from "path";
+import * as fs22 from "fs";
+import * as path18 from "path";
 init_claude_model_mapper();
-function getConfigPaths3(directory) {
+function getConfigPaths4(directory) {
   const globalConfigDir = getOpenCodeConfigDir({ binary: "opencode" });
   const paths = [
-    path17.join(directory, ".opencode", "opencode.json"),
-    path17.join(directory, ".opencode", "opencode.jsonc"),
-    path17.join(globalConfigDir, "opencode.json"),
-    path17.join(globalConfigDir, "opencode.jsonc")
+    path18.join(directory, ".opencode", "opencode.json"),
+    path18.join(directory, ".opencode", "opencode.jsonc"),
+    path18.join(globalConfigDir, "opencode.json"),
+    path18.join(globalConfigDir, "opencode.jsonc")
   ];
   return paths;
 }
@@ -108579,15 +108892,15 @@ function convertInlineAgent(agentData) {
 }
 function readOpencodeConfigAgents(directory) {
   const result = Object.create(null);
-  for (const configPath of getConfigPaths3(directory)) {
+  for (const configPath of getConfigPaths4(directory)) {
     try {
-      if (!fs21.existsSync(configPath))
+      if (!fs22.existsSync(configPath))
         continue;
-      const content = fs21.readFileSync(configPath, "utf-8");
+      const content = fs22.readFileSync(configPath, "utf-8");
       const parseResult = parseJsoncSafe(content);
       if (!parseResult.data)
         continue;
-      const configDir = path17.dirname(configPath);
+      const configDir = path18.dirname(configPath);
       const agentsToLoad = parseResult.data.agents || parseResult.data.agent;
       if (agentsToLoad && typeof agentsToLoad === "object") {
         for (const [agentName, agentData] of Object.entries(agentsToLoad)) {
@@ -109283,9 +109596,9 @@ import { pathToFileURL } from "url";
 // src/tools/look-at/image-converter.ts
 init_shared();
 import * as childProcess2 from "child_process";
-import { existsSync as existsSync83, mkdtempSync, readFileSync as readFileSync59, rmSync as rmSync4, unlinkSync as unlinkSync14, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync84, mkdtempSync, readFileSync as readFileSync60, rmSync as rmSync4, unlinkSync as unlinkSync14, writeFileSync as writeFileSync19 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { dirname as dirname31, join as join87 } from "path";
+import { dirname as dirname31, join as join88 } from "path";
 var SUPPORTED_FORMATS = new Set([
   "image/jpeg",
   "image/png",
@@ -109323,11 +109636,11 @@ function needsConversion(mimeType) {
   return mimeType.startsWith("image/");
 }
 function convertImageToJpeg(inputPath, mimeType) {
-  if (!existsSync83(inputPath)) {
+  if (!existsSync84(inputPath)) {
     throw new Error(`File not found: ${inputPath}`);
   }
-  const tempDir = mkdtempSync(join87(tmpdir7(), "opencode-img-"));
-  const outputPath = join87(tempDir, "converted.jpg");
+  const tempDir = mkdtempSync(join88(tmpdir7(), "opencode-img-"));
+  const outputPath = join88(tempDir, "converted.jpg");
   log(`[image-converter] Converting ${mimeType} to JPEG: ${inputPath}`);
   try {
     if (process.platform === "darwin") {
@@ -109337,7 +109650,7 @@ function convertImageToJpeg(inputPath, mimeType) {
           encoding: "utf-8",
           timeout: CONVERSION_TIMEOUT_MS
         });
-        if (existsSync83(outputPath)) {
+        if (existsSync84(outputPath)) {
           log(`[image-converter] Converted using sips: ${outputPath}`);
           return outputPath;
         }
@@ -109352,7 +109665,7 @@ function convertImageToJpeg(inputPath, mimeType) {
         encoding: "utf-8",
         timeout: CONVERSION_TIMEOUT_MS
       });
-      if (existsSync83(outputPath)) {
+      if (existsSync84(outputPath)) {
         log(`[image-converter] Converted using ImageMagick: ${outputPath}`);
         return outputPath;
       }
@@ -109365,7 +109678,7 @@ function convertImageToJpeg(inputPath, mimeType) {
 ` + `  RHEL/CentOS: sudo yum install ImageMagick`);
   } catch (error) {
     try {
-      if (existsSync83(outputPath)) {
+      if (existsSync84(outputPath)) {
         unlinkSync14(outputPath);
       }
     } catch {}
@@ -109379,11 +109692,11 @@ function convertImageToJpeg(inputPath, mimeType) {
 function cleanupConvertedImage(filePath) {
   try {
     const tempDirectory = dirname31(filePath);
-    if (existsSync83(filePath)) {
+    if (existsSync84(filePath)) {
       unlinkSync14(filePath);
       log(`[image-converter] Cleaned up temporary file: ${filePath}`);
     }
-    if (existsSync83(tempDirectory)) {
+    if (existsSync84(tempDirectory)) {
       rmSync4(tempDirectory, { recursive: true, force: true });
       log(`[image-converter] Cleaned up temporary directory: ${tempDirectory}`);
     }
@@ -109392,9 +109705,9 @@ function cleanupConvertedImage(filePath) {
   }
 }
 function convertBase64ImageToJpeg(base64Data, mimeType) {
-  const tempDir = mkdtempSync(join87(tmpdir7(), "opencode-b64-"));
+  const tempDir = mkdtempSync(join88(tmpdir7(), "opencode-b64-"));
   const inputExt = mimeType.split("/")[1] || "bin";
-  const inputPath = join87(tempDir, `input.${inputExt}`);
+  const inputPath = join88(tempDir, `input.${inputExt}`);
   const tempFiles = [inputPath];
   try {
     const cleanBase64 = base64Data.replace(/^data:[^;]+;base64,/, "");
@@ -109403,14 +109716,14 @@ function convertBase64ImageToJpeg(base64Data, mimeType) {
     log(`[image-converter] Converting Base64 ${mimeType} to JPEG`);
     const outputPath = convertImageToJpeg(inputPath, mimeType);
     tempFiles.push(outputPath);
-    const convertedBuffer = readFileSync59(outputPath);
+    const convertedBuffer = readFileSync60(outputPath);
     const convertedBase64 = convertedBuffer.toString("base64");
     log(`[image-converter] Base64 conversion successful`);
     return { base64: convertedBase64, tempFiles };
   } catch (error) {
     tempFiles.forEach((file) => {
       try {
-        if (existsSync83(file))
+        if (existsSync84(file))
           unlinkSync14(file);
       } catch {}
     });
@@ -109549,13 +109862,68 @@ function asSessionMessage(value) {
 function getCreatedTime(message) {
   return message.info?.time?.created ?? 0;
 }
+function asText(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function collectContentText(value) {
+  const directText = asText(value);
+  if (directText)
+    return [directText];
+  if (!Array.isArray(value))
+    return [];
+  const texts = [];
+  for (const block of value) {
+    if (!isObject2(block))
+      continue;
+    const text = asText(block["text"]) ?? asText(block["content"]);
+    if (text)
+      texts.push(text);
+  }
+  return texts;
+}
+function normalizeThinkingText(text) {
+  const answerMatches = [...text.matchAll(/<answer\b[^>]*>([\s\S]*?)<\/answer>/gi)].map((match) => match[1]?.trim()).filter((value) => Boolean(value));
+  const withoutThinking = text.replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, "").trim();
+  const normalized = answerMatches.length > 0 ? answerMatches.join(`
+`) : withoutThinking;
+  return normalized.length > 0 ? normalized : null;
+}
 function getTextParts(message) {
   if (!Array.isArray(message.parts))
     return [];
   return message.parts.filter((part) => isObject2(part)).map((part) => ({
     type: typeof part["type"] === "string" ? part["type"] : undefined,
-    text: typeof part["text"] === "string" ? part["text"] : undefined
-  })).filter((part) => part.type === "text" && Boolean(part.text));
+    text: typeof part["text"] === "string" ? part["text"] : undefined,
+    content: part["content"],
+    reasoning: typeof part["reasoning"] === "string" ? part["reasoning"] : undefined,
+    reasoningContent: typeof part["reasoning_content"] === "string" ? part["reasoning_content"] : undefined
+  }));
+}
+function extractTextFromParts(parts) {
+  const textCandidates = [];
+  const reasoningCandidates = [];
+  for (const part of parts) {
+    const contentTexts = collectContentText(part.content);
+    const directText = asText(part.text);
+    if (part.type === "text") {
+      if (directText)
+        textCandidates.push(directText);
+      textCandidates.push(...contentTexts);
+    } else if (part.type === "reasoning" || part.type === "thinking") {
+      if (directText)
+        reasoningCandidates.push(directText);
+      textCandidates.push(...contentTexts);
+    }
+    const reasoningText = asText(part.reasoningContent) ?? asText(part.reasoning);
+    if (reasoningText)
+      reasoningCandidates.push(reasoningText);
+  }
+  const primaryText = textCandidates.map(normalizeThinkingText).filter((text) => text !== null).join(`
+`);
+  if (primaryText)
+    return primaryText;
+  return reasoningCandidates.map(normalizeThinkingText).filter((text) => text !== null).join(`
+`) || null;
 }
 function extractLatestAssistantText(messages) {
   return extractLatestAssistantOutcome(messages).text;
@@ -109571,9 +109939,7 @@ function extractLatestAssistantOutcome(messages) {
   if (!lastAssistantMessage) {
     return { text: null, errorName: null, hasAssistant, completed: false };
   }
-  const textParts = getTextParts(lastAssistantMessage);
-  const text = textParts.map((part) => part.text).join(`
-`) || null;
+  const text = extractTextFromParts(getTextParts(lastAssistantMessage));
   const allParts = Array.isArray(lastAssistantMessage.parts) ? lastAssistantMessage.parts : [];
   const errorPart = allParts.find((part) => isObject2(part) && typeof part["type"] === "string" && part["type"] === "error");
   const errorName = errorPart && typeof errorPart["error"] === "string" ? errorPart["error"] : null;
@@ -109971,9 +110337,9 @@ function getMissingFilePathFromError(error) {
   if (!(error instanceof Error)) {
     return null;
   }
-  const path18 = Reflect.get(error, "path");
-  if (typeof path18 === "string" && path18.length > 0) {
-    return path18;
+  const path19 = Reflect.get(error, "path");
+  if (typeof path19 === "string" && path19.length > 0) {
+    return path19;
   }
   if (error instanceof Error) {
     const match = /open '([^']+)'/.exec(error.message);
@@ -112948,7 +113314,7 @@ function isExplicitSyncRun(runInBackground) {
 // src/tools/delegate-task/index.ts
 init_constants();
 // src/tools/task/task-create.ts
-import { join as join89 } from "path";
+import { join as join90 } from "path";
 
 // src/tools/task/types.ts
 import { z as z37 } from "zod";
@@ -113004,18 +113370,18 @@ var TaskDeleteInputSchema = z37.object({
 
 // src/features/claude-tasks/storage.ts
 init_opencode_config_dir();
-import { join as join88, dirname as dirname32, basename as basename14, isAbsolute as isAbsolute17 } from "path";
-import { existsSync as existsSync84, mkdirSync as mkdirSync18, readFileSync as readFileSync60, writeFileSync as writeFileSync20, renameSync as renameSync6, unlinkSync as unlinkSync15, readdirSync as readdirSync24 } from "fs";
+import { join as join89, dirname as dirname32, basename as basename14, isAbsolute as isAbsolute17 } from "path";
+import { existsSync as existsSync85, mkdirSync as mkdirSync18, readFileSync as readFileSync61, writeFileSync as writeFileSync20, renameSync as renameSync6, unlinkSync as unlinkSync15, readdirSync as readdirSync24 } from "fs";
 import { randomUUID as randomUUID5 } from "crypto";
 function getTaskDir(config = {}) {
   const tasksConfig = config.sisyphus?.tasks;
   const storagePath = tasksConfig?.storage_path;
   if (storagePath) {
-    return isAbsolute17(storagePath) ? storagePath : join88(process.cwd(), storagePath);
+    return isAbsolute17(storagePath) ? storagePath : join89(process.cwd(), storagePath);
   }
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const listId = resolveTaskListId(config);
-  return join88(configDir, "tasks", listId);
+  return join89(configDir, "tasks", listId);
 }
 function sanitizePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "-") || "default";
@@ -113033,16 +113399,16 @@ function resolveTaskListId(config = {}) {
   return sanitizePathSegment(basename14(process.cwd()));
 }
 function ensureDir(dirPath) {
-  if (!existsSync84(dirPath)) {
+  if (!existsSync85(dirPath)) {
     mkdirSync18(dirPath, { recursive: true });
   }
 }
 function readJsonSafe(filePath, schema2) {
   try {
-    if (!existsSync84(filePath)) {
+    if (!existsSync85(filePath)) {
       return null;
     }
-    const content = readFileSync60(filePath, "utf-8");
+    const content = readFileSync61(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = schema2.safeParse(parsed);
     if (!result.success) {
@@ -113062,7 +113428,7 @@ function writeJsonAtomic(filePath, data) {
     renameSync6(tempPath, filePath);
   } catch (error) {
     try {
-      if (existsSync84(tempPath)) {
+      if (existsSync85(tempPath)) {
         unlinkSync15(tempPath);
       }
     } catch {}
@@ -113074,7 +113440,7 @@ function generateTaskId() {
   return `T-${randomUUID5()}`;
 }
 function acquireLock2(dirPath) {
-  const lockPath = join88(dirPath, ".lock");
+  const lockPath = join89(dirPath, ".lock");
   const lockId = randomUUID5();
   const createLock = (timestamp2) => {
     writeFileSync20(lockPath, JSON.stringify({ id: lockId, timestamp: timestamp2 }), {
@@ -113084,7 +113450,7 @@ function acquireLock2(dirPath) {
   };
   const isStale = () => {
     try {
-      const lockContent = readFileSync60(lockPath, "utf-8");
+      const lockContent = readFileSync61(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -113122,9 +113488,9 @@ function acquireLock2(dirPath) {
     acquired: true,
     release: () => {
       try {
-        if (!existsSync84(lockPath))
+        if (!existsSync85(lockPath))
           return;
-        const lockContent = readFileSync60(lockPath, "utf-8");
+        const lockContent = readFileSync61(lockPath, "utf-8");
         const lockData = JSON.parse(lockContent);
         if (lockData.id !== lockId)
           return;
@@ -113287,7 +113653,7 @@ async function handleCreate(args, config, ctx, context) {
         threadID: context.sessionID
       };
       const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(join89(taskDir, `${taskId}.json`), validatedTask);
+      writeJsonAtomic(join90(taskDir, `${taskId}.json`), validatedTask);
       await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
       return JSON.stringify({
         task: {
@@ -113309,7 +113675,7 @@ async function handleCreate(args, config, ctx, context) {
   }
 }
 // src/tools/task/task-get.ts
-import { join as join90 } from "path";
+import { join as join91 } from "path";
 var TASK_ID_PATTERN = /^T-[A-Za-z0-9-]+$/;
 function parseTaskId(id) {
   if (!TASK_ID_PATTERN.test(id))
@@ -113334,7 +113700,7 @@ Returns null if the task does not exist or the file is invalid.`,
           return JSON.stringify({ error: "invalid_task_id" });
         }
         const taskDir = getTaskDir(config);
-        const taskPath = join90(taskDir, `${taskId}.json`);
+        const taskPath = join91(taskDir, `${taskId}.json`);
         const task = readJsonSafe(taskPath, TaskObjectSchema);
         return JSON.stringify({ task: task ?? null });
       } catch (error) {
@@ -113347,8 +113713,8 @@ Returns null if the task does not exist or the file is invalid.`,
   });
 }
 // src/tools/task/task-list.ts
-import { join as join91 } from "path";
-import { existsSync as existsSync85, readdirSync as readdirSync25 } from "fs";
+import { join as join92 } from "path";
+import { existsSync as existsSync86, readdirSync as readdirSync25 } from "fs";
 function createTaskList(config) {
   return tool({
     description: `List all active tasks with summary information.
@@ -113359,7 +113725,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
     args: {},
     execute: async () => {
       const taskDir = getTaskDir(config);
-      if (!existsSync85(taskDir)) {
+      if (!existsSync86(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
       const files = readdirSync25(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
@@ -113368,7 +113734,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
       }
       const allTasks = [];
       for (const fileId of files) {
-        const task = readJsonSafe(join91(taskDir, `${fileId}.json`), TaskObjectSchema);
+        const task = readJsonSafe(join92(taskDir, `${fileId}.json`), TaskObjectSchema);
         if (task) {
           allTasks.push(task);
         }
@@ -113396,7 +113762,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
   });
 }
 // src/tools/task/task-update.ts
-import { join as join92 } from "path";
+import { join as join93 } from "path";
 var TASK_ID_PATTERN2 = /^T-[A-Za-z0-9-]+$/;
 function parseTaskId2(id) {
   if (!TASK_ID_PATTERN2.test(id))
@@ -113444,7 +113810,7 @@ async function handleUpdate(args, config, ctx, context) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
     try {
-      const taskPath = join92(taskDir, `${taskId}.json`);
+      const taskPath = join93(taskDir, `${taskId}.json`);
       const task = readJsonSafe(taskPath, TaskObjectSchema);
       if (!task) {
         return JSON.stringify({ error: "task_not_found" });
@@ -113502,10 +113868,10 @@ init_bun_file_shim();
 // src/tools/hashline-edit/formatter-trigger.ts
 init_shared();
 init_bun_spawn_shim();
-import path18 from "path";
+import path19 from "path";
 var cachedFormattersByDirectory = new Map;
 function getFormatterCacheKey(directory) {
-  return path18.resolve(directory);
+  return path19.resolve(directory);
 }
 async function resolveFormatters(client, directory) {
   const cacheKey = getFormatterCacheKey(directory);
@@ -113556,7 +113922,7 @@ function buildFormatterCommand(command, filePath) {
   return command.map((arg) => arg.replace(/\$FILE/g, filePath));
 }
 async function runFormattersForFile(client, directory, filePath) {
-  const ext = path18.extname(filePath);
+  const ext = path19.extname(filePath);
   if (!ext)
     return;
   const formatters = await resolveFormatters(client, directory);
@@ -113876,17 +114242,17 @@ function buildMemberPromptBody(member, text) {
 // src/features/team-mode/team-mailbox/reservation.ts
 init_paths();
 import { mkdir as mkdir3, readdir as readdir6, rename as rename2, stat as stat5 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 var RESERVED_PREFIX = ".delivering-";
 var RESERVED_SUFFIX = ".json";
 function isMissingPathError(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function buildReservation(inboxDir, messageId) {
-  const inboxPath = path19.join(inboxDir, `${messageId}.json`);
-  const reservedPath = path19.join(inboxDir, `${RESERVED_PREFIX}${messageId}${RESERVED_SUFFIX}`);
-  const processedDir = path19.join(inboxDir, "processed");
-  const processedPath = path19.join(processedDir, `${messageId}.json`);
+  const inboxPath = path20.join(inboxDir, `${messageId}.json`);
+  const reservedPath = path20.join(inboxDir, `${RESERVED_PREFIX}${messageId}${RESERVED_SUFFIX}`);
+  const processedDir = path20.join(inboxDir, "processed");
+  const processedPath = path20.join(processedDir, `${messageId}.json`);
   return { reservedPath, inboxPath, processedPath, processedDir };
 }
 async function reserveMessageForDelivery(teamRunId, recipientName, messageId, config) {
@@ -113922,7 +114288,7 @@ init_store();
 init_locks();
 import { Buffer as Buffer2 } from "buffer";
 import { mkdir as mkdir4, readdir as readdir7, stat as stat6 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 class BroadcastNotPermittedError extends Error {
   constructor(message = "broadcast requires lead role") {
@@ -113991,7 +114357,7 @@ async function getUnreadSizeBytes(inboxDir) {
       return !entry.name.startsWith(".");
     });
     const sizes = await Promise.all(unreadEntries.map(async (entry) => {
-      const fileStats = await stat6(path20.join(inboxDir, entry.name));
+      const fileStats = await stat6(path21.join(inboxDir, entry.name));
       return fileStats.size;
     }));
     return sizes.reduce((totalBytes, fileSize) => totalBytes + fileSize, 0);
@@ -114037,8 +114403,8 @@ async function sendMessage(message, teamRunId, config, context) {
       if (nextUnreadSizeBytes > config.recipient_unread_max_bytes) {
         throw new RecipientBackpressureError;
       }
-      const unreservedPath = path20.join(inboxDir, `${message.messageId}.json`);
-      const reservedPath = path20.join(inboxDir, `.delivering-${message.messageId}.json`);
+      const unreservedPath = path21.join(inboxDir, `${message.messageId}.json`);
+      const reservedPath = path21.join(inboxDir, `.delivering-${message.messageId}.json`);
       if (await fileExists(unreservedPath) || await fileExists(reservedPath)) {
         throw new DuplicateMessageIdError;
       }
@@ -114387,7 +114753,6 @@ function createRuntimeTmuxConfig(pluginConfig) {
 function createSessionHooks(args) {
   const { ctx, pluginConfig, modelCacheState, backgroundManager, modelFallbackControllerAccessor, isHookEnabled, safeHookEnabled } = args;
   const safeHook = (hookName, factory) => safeCreateHook(hookName, factory, { enabled: safeHookEnabled });
-  const contextWindowMonitor = isHookEnabled("context-window-monitor") ? safeHook("context-window-monitor", () => createContextWindowMonitorHook(ctx, modelCacheState)) : null;
   const preemptiveCompaction = isHookEnabled("preemptive-compaction") && pluginConfig.experimental?.preemptive_compaction ? safeHook("preemptive-compaction", () => createPreemptiveCompactionHook(ctx, pluginConfig, modelCacheState)) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? safeHook("session-recovery", () => createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental })) : null;
   let sessionNotification = null;
@@ -114485,7 +114850,6 @@ function createSessionHooks(args) {
   })) : null;
   const legacyPluginToast = isHookEnabled("legacy-plugin-toast") ? safeHook("legacy-plugin-toast", () => createLegacyPluginToastHook(ctx)) : null;
   return {
-    contextWindowMonitor,
     preemptiveCompaction,
     sessionRecovery,
     sessionNotification,
@@ -114794,8 +115158,8 @@ function createUnstableAgentBabysitter(args) {
     directory: ctx.directory,
     client: {
       session: {
-        messages: async ({ path: path21 }) => {
-          const result = await ctx.client.session.messages({ path: path21 });
+        messages: async ({ path: path22 }) => {
+          const result = await ctx.client.session.messages({ path: path22 });
           if (Array.isArray(result))
             return result;
           if (typeof result === "object" && result !== null) {
@@ -114954,7 +115318,7 @@ function createHooks(args) {
   };
 }
 // src/features/background-agent/manager.ts
-import { join as join94 } from "path";
+import { join as join95 } from "path";
 init_shared();
 init_event_session_id();
 init_session_category_registry();
@@ -115234,8 +115598,8 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 }
 
 // src/features/background-agent/compaction-aware-message-resolver.ts
-import { readdirSync as readdirSync26, readFileSync as readFileSync61 } from "fs";
-import { join as join93 } from "path";
+import { readdirSync as readdirSync26, readFileSync as readFileSync62 } from "fs";
+import { join as join94 } from "path";
 init_compaction_marker();
 init_compaction_marker();
 function hasFullAgentAndModel(message) {
@@ -115316,7 +115680,7 @@ function findNearestMessageExcludingCompaction(messageDir, sessionID) {
     const messages = [];
     for (const file of files) {
       try {
-        const content = readFileSync61(join93(messageDir, file), "utf-8");
+        const content = readFileSync62(join94(messageDir, file), "utf-8");
         const parsed = JSON.parse(content);
         if (hasCompactionPartInStorage(parsed.id) || isCompactionAgent(parsed.agent)) {
           continue;
@@ -115356,6 +115720,16 @@ class ConcurrencyManager {
     }
     return 5;
   }
+  getConcurrencyKey(model) {
+    if (this.config?.modelConcurrency?.[model] !== undefined) {
+      return model;
+    }
+    const provider = model.split("/")[0];
+    if (provider && this.config?.providerConcurrency?.[provider] !== undefined) {
+      return provider;
+    }
+    return model;
+  }
   async acquire(model) {
     const limit = this.getConcurrencyLimit(model);
     if (limit === Infinity) {
@@ -115390,6 +115764,9 @@ class ConcurrencyManager {
     const queue = this.queues.get(model);
     while (queue && queue.length > 0) {
       const next = queue.shift();
+      if (!next) {
+        continue;
+      }
       if (!next.settled) {
         next.resolve();
         return;
@@ -115583,7 +115960,8 @@ async function tryFallbackRetry(args) {
     });
     throw new TeamModeFallbackError(`team-mode fallback denied: cannot preserve team context for task ${task.id} (teamRunId=${task.teamRunId})`);
   }
-  const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
+  const rawKey = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
+  const key = concurrencyManager.getConcurrencyKey(rawKey);
   const queue = queuesByKey.get(key) ?? [];
   const retryInput = {
     description: task.description,
@@ -116063,7 +116441,8 @@ class ParentWakeNotifier {
       const role = this.getParentWakeMessageRole(message);
       if (role === "assistant") {
         const waiting = this.getParentWakeMessageFinish(message) === "tool-calls" || message.parts?.some((part) => this.parentWakePartIsWaitingOnTool(part)) === true;
-        return waiting ? { waiting: true, activityAt: getParentWakeMessageActivityAt(message) } : { waiting: false };
+        const activityAt = getParentWakeMessageActivityAt(message);
+        return waiting ? { waiting: true, activityAt } : { waiting: false, activityAt };
       }
       if (role === "user") {
         if (isSyntheticOrInternalUserMessage(message)) {
@@ -116162,16 +116541,18 @@ class ParentWakeNotifier {
     }
     const latestToolWaitAgeMs = toolWaitState.activityAt === undefined ? 0 : now - toolWaitState.activityAt;
     const deferAge = now - wake.toolCallDeferralStartedAt;
+    const latestAssistantActivityAgeMs = toolWaitState.activityAt === undefined ? deferAge : now - toolWaitState.activityAt;
     if (wake.shouldReply && toolWaitState.waiting && deferAge >= this.options.toolCallDeferMaxMs && latestToolWaitAgeMs >= this.options.toolCallDeferMaxMs) {
       log("[background-agent] Sending parent wake after stale tool-call deferral window:", {
         sessionID
       });
       return { defer: false, skipPromptGateToolStateCheck: true };
     }
-    if (!toolWaitState.waiting && deferAge >= this.options.toolCallDeferMaxMs) {
+    if (!toolWaitState.waiting && deferAge >= this.options.toolCallDeferMaxMs && latestAssistantActivityAgeMs >= this.options.toolCallDeferMaxMs) {
       log("[background-agent] Sending parent wake after stale assistant-text deferral window:", {
         sessionID,
-        deferAgeMs: deferAge
+        deferAgeMs: deferAge,
+        latestAssistantActivityAgeMs
       });
       return { defer: false, skipPromptGateToolStateCheck: true };
     }
@@ -116236,8 +116617,13 @@ function scheduleForcedExit(cleanupResult, exitCode, exitAfterCleanup = false) {
     }
   });
 }
+var _shutdownInProgress = false;
+function markShutdownStarted() {
+  _shutdownInProgress = true;
+}
 function registerProcessSignal(signal, handler, exitAfter) {
   const listener = () => {
+    markShutdownStarted();
     const cleanupResult = handler();
     if (exitAfter) {
       scheduleForcedExit(cleanupResult, 0, true);
@@ -116264,11 +116650,32 @@ function describeProcessCleanupError(error) {
   }
   return { raw: String(error) };
 }
+var HARMLESS_SHUTDOWN_ERRNO_CODES = new Set(["EPIPE", "ECONNRESET"]);
+var STDIO_WRITE_FDS = new Set([1, 2]);
+function isStdioWriteError(error) {
+  const syscall = error.syscall;
+  const fd = error.fd;
+  return syscall === "write" && typeof fd === "number" && STDIO_WRITE_FDS.has(fd);
+}
+function isHarmlessShutdownError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const code = error.code;
+  if (typeof code !== "string")
+    return false;
+  if (!HARMLESS_SHUTDOWN_ERRNO_CODES.has(code))
+    return false;
+  if (isStdioWriteError(error))
+    return true;
+  return _shutdownInProgress;
+}
 function registerErrorEvent(signal) {
   let logging = false;
   const listener = (error) => {
     if (logging)
       return;
+    if (isHarmlessShutdownError(error))
+      return;
     logging = true;
     log(`[background-agent] ${signal} observed; keeping host alive and skipping cleanup (signal handlers run on real shutdown)`, describeProcessCleanupError(error));
     logging = false;
@@ -116293,9 +116700,13 @@ function registerManagerForCleanup(manager) {
     for (const m of cleanupManagers) {
       try {
         promises.push(Promise.resolve(m.shutdown()).catch((error) => {
+          if (isHarmlessShutdownError(error))
+            return;
           log("[background-agent] Error during async shutdown cleanup:", error);
         }));
       } catch (error) {
+        if (isHarmlessShutdownError(error))
+          continue;
         log("[background-agent] Error during shutdown cleanup:", error);
       }
     }
@@ -117988,10 +118399,8 @@ The fallback retry session is now created and can be inspected directly.
     };
   }
   getConcurrencyKeyFromInput(input) {
-    if (input.model) {
-      return `${input.model.providerID}/${input.model.modelID}`;
-    }
-    return input.agent;
+    const modelKey = input.model ? `${input.model.providerID}/${input.model.modelID}` : input.agent;
+    return this.concurrencyManager.getConcurrencyKey(modelKey);
   }
   async trackTask(input) {
     const existingTask = this.tasks.get(input.taskId);
@@ -118005,7 +118414,7 @@ The fallback retry session is now created and can be inspected directly.
         existingTask.parentAgent = input.parentAgent;
       }
       if (!existingTask.concurrencyGroup) {
-        existingTask.concurrencyGroup = input.concurrencyKey ?? existingTask.agent;
+        existingTask.concurrencyGroup = input.concurrencyKey ? this.concurrencyManager.getConcurrencyKey(input.concurrencyKey) : existingTask.agent;
       }
       if (existingTask.sessionId) {
         subagentSessions.add(existingTask.sessionId);
@@ -118021,9 +118430,10 @@ The fallback retry session is now created and can be inspected directly.
       log("[background-agent] External task already registered:", { taskId: existingTask.id, sessionID: existingTask.sessionId, status: existingTask.status });
       return existingTask;
     }
-    const concurrencyGroup = input.concurrencyKey ?? input.agent ?? "task";
-    if (input.concurrencyKey) {
-      await this.concurrencyManager.acquire(input.concurrencyKey);
+    const concurrencyKey = input.concurrencyKey ? this.concurrencyManager.getConcurrencyKey(input.concurrencyKey) : undefined;
+    const concurrencyGroup = concurrencyKey ?? input.agent ?? "task";
+    if (concurrencyKey) {
+      await this.concurrencyManager.acquire(concurrencyKey);
     }
     const task = {
       id: input.taskId,
@@ -118040,7 +118450,7 @@ The fallback retry session is now created and can be inspected directly.
         lastUpdate: new Date
       },
       parentAgent: input.parentAgent,
-      concurrencyKey: input.concurrencyKey,
+      concurrencyKey,
       concurrencyGroup
     };
     this.addTask(task);
@@ -118076,7 +118486,7 @@ The fallback retry session is now created and can be inspected directly.
       clearTimeout(completionTimer);
       this.completionTimers.delete(existingTask.id);
     }
-    const concurrencyKey = existingTask.concurrencyGroup ?? existingTask.agent;
+    const concurrencyKey = this.concurrencyManager.getConcurrencyKey(existingTask.concurrencyGroup ?? existingTask.agent);
     await this.concurrencyManager.acquire(concurrencyKey);
     existingTask.concurrencyKey = concurrencyKey;
     existingTask.concurrencyGroup = concurrencyKey;
@@ -119102,7 +119512,7 @@ The task was re-queued on a fallback model after a retryable failure.
           parentSessionID: task.parentSessionId
         });
       }
-      const messageDir = join94(MESSAGE_STORAGE, task.parentSessionId);
+      const messageDir = join95(MESSAGE_STORAGE, task.parentSessionId);
       const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir, task.parentSessionId) : null;
       agent = currentMessage?.agent ?? task.parentAgent;
       model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
@@ -119445,11 +119855,11 @@ The task was re-queued on a fallback model after a retryable failure.
 }
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync as chmodSync2, existsSync as existsSync86, mkdirSync as mkdirSync19, readFileSync as readFileSync62, renameSync as renameSync7, unlinkSync as unlinkSync16, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname33, join as join95 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync87, mkdirSync as mkdirSync19, readFileSync as readFileSync63, renameSync as renameSync7, unlinkSync as unlinkSync16, writeFileSync as writeFileSync21 } from "fs";
+import { dirname as dirname33, join as join96 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join95(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join96(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -119486,11 +119896,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync86(filePath)) {
+  if (!existsSync87(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync62(filePath, "utf-8");
+    const content = readFileSync63(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -119500,7 +119910,7 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname33(filePath);
-    if (!existsSync86(dir)) {
+    if (!existsSync87(dir)) {
       mkdirSync19(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
@@ -119692,13 +120102,13 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
 import { spawn as spawn3 } from "child_process";
-import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
 import { createServer as createServer2 } from "http";
 function generateCodeVerifier() {
   return randomBytes2(32).toString("base64url");
 }
 function generateCodeChallenge(verifier) {
-  return createHash2("sha256").update(verifier).digest("base64url");
+  return createHash3("sha256").update(verifier).digest("base64url");
 }
 function buildAuthorizationUrl(authorizationEndpoint, options) {
   const url = new URL(authorizationEndpoint);
@@ -125389,8 +125799,33 @@ async function executeActions(actions, ctx) {
 // src/features/tmux-subagent/polling-manager.ts
 init_tmux();
 init_shared();
-init_shared();
 init_event_session_id();
+
+// src/features/tmux-subagent/session-status-parser.ts
+function parseSessionStatusResponse(response) {
+  if (typeof response === "object" && response !== null && "data" in response) {
+    return parseSessionStatusMap(response.data);
+  }
+  return parseSessionStatusMap(response);
+}
+function parseSessionStatusMap(data) {
+  if (typeof data !== "object" || data === null)
+    return {};
+  const record3 = data;
+  const result = {};
+  for (const [sessionId, value] of Object.entries(record3)) {
+    if (typeof value !== "object" || value === null)
+      continue;
+    const valueRecord = value;
+    const type2 = valueRecord["type"];
+    if (typeof type2 !== "string")
+      continue;
+    result[sessionId] = { type: type2 };
+  }
+  return result;
+}
+
+// src/features/tmux-subagent/polling-manager.ts
 var MIN_STABILITY_TIME_MS3 = 10 * 1000;
 var STABLE_POLLS_REQUIRED = 3;
 
@@ -125446,7 +125881,7 @@ class TmuxPollingManager {
       }
       await this.activateFocusedPanes();
       const statusResult = await this.client.session.status({ path: undefined });
-      const allStatuses = normalizeSDKResponse(statusResult, {});
+      const allStatuses = parseSessionStatusResponse(statusResult);
       log("[tmux-session-manager] pollSessions", {
         trackedSessions: Array.from(this.sessions.keys()),
         allStatusKeys: Object.keys(allStatuses)
@@ -125493,7 +125928,7 @@ class TmuxPollingManager {
           if ((tracked.stableIdlePolls ?? 0) >= STABLE_POLLS_REQUIRED) {
             const stableWindowActivityVersion = tracked.observedIdleActivityVersion ?? activityVersion;
             const recheckResult = await this.client.session.status({ path: undefined });
-            const recheckStatuses = normalizeSDKResponse(recheckResult, {});
+            const recheckStatuses = parseSessionStatusResponse(recheckResult);
             const recheckStatus = recheckStatuses[sessionId];
             const latestTracked = this.sessions.get(sessionId) ?? tracked;
             const recheckActivityVersion = latestTracked.activityVersion ?? 0;
@@ -125634,36 +126069,18 @@ init_tmux();
 init_shared();
 
 // src/features/tmux-subagent/attachable-session-status.ts
-var ATTACHABLE_SESSION_STATUSES = ["idle", "running", "busy"];
+var ATTACHABLE_SESSION_STATUSES = ["idle", "running", "busy", "retry"];
 function isAttachableSessionStatus(status) {
   return ATTACHABLE_SESSION_STATUSES.some((attachableSessionStatus) => attachableSessionStatus === status);
 }
 
-// src/features/tmux-subagent/session-status-parser.ts
-function parseSessionStatusMap(data) {
-  if (typeof data !== "object" || data === null)
-    return {};
-  const record3 = data;
-  const result = {};
-  for (const [sessionId, value] of Object.entries(record3)) {
-    if (typeof value !== "object" || value === null)
-      continue;
-    const valueRecord = value;
-    const type2 = valueRecord["type"];
-    if (typeof type2 !== "string")
-      continue;
-    result[sessionId] = { type: type2 };
-  }
-  return result;
-}
-
 // src/features/tmux-subagent/session-ready-waiter.ts
 async function waitForSessionReady(params) {
   const startTime = Date.now();
   while (Date.now() - startTime < SESSION_READY_TIMEOUT_MS) {
     try {
       const statusResult = await params.client.session.status({ path: undefined });
-      const allStatuses = parseSessionStatusMap(statusResult.data);
+      const allStatuses = parseSessionStatusResponse(statusResult);
       const sessionStatus = allStatuses[params.sessionId]?.type;
       if (isAttachableSessionStatus(sessionStatus)) {
         log("[tmux-session-manager] session ready", {
@@ -126172,7 +126589,7 @@ class TmuxSessionManager {
   async getSessionStatusType(sessionId) {
     try {
       const statusResult = await this.client.session.status({ path: undefined });
-      const allStatuses = parseSessionStatusMap(statusResult.data);
+      const allStatuses = parseSessionStatusResponse(statusResult);
       return allStatuses[sessionId]?.type;
     } catch (error) {
       this.deps.log("[tmux-session-manager] failed to read session status before spawn", {
@@ -127078,14 +127495,14 @@ async function isTmuxAvailable() {
 }
 
 // src/openclaw/reply-listener.ts
-import { dirname as dirname35, join as join98 } from "path";
+import { dirname as dirname35, join as join99 } from "path";
 
 // src/openclaw/session-registry.ts
 init_data_path();
 import {
-  existsSync as existsSync87,
+  existsSync as existsSync88,
   mkdirSync as mkdirSync20,
-  readFileSync as readFileSync63,
+  readFileSync as readFileSync64,
   writeFileSync as writeFileSync22,
   openSync as openSync3,
   closeSync as closeSync3,
@@ -127094,11 +127511,11 @@ import {
   statSync as statSync12,
   constants as constants20
 } from "fs";
-import { join as join96, dirname as dirname34 } from "path";
+import { join as join97, dirname as dirname34 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
-var OPENCLAW_STORAGE_DIR = join96(getOpenCodeStorageDir(), "openclaw");
-var REGISTRY_PATH = join96(OPENCLAW_STORAGE_DIR, "reply-session-registry.jsonl");
-var REGISTRY_LOCK_PATH = join96(OPENCLAW_STORAGE_DIR, "reply-session-registry.lock");
+var OPENCLAW_STORAGE_DIR = join97(getOpenCodeStorageDir(), "openclaw");
+var REGISTRY_PATH = join97(OPENCLAW_STORAGE_DIR, "reply-session-registry.jsonl");
+var REGISTRY_LOCK_PATH = join97(OPENCLAW_STORAGE_DIR, "reply-session-registry.lock");
 var SECURE_FILE_MODE = 384;
 var MAX_AGE_MS = 24 * 60 * 60 * 1000;
 var LOCK_TIMEOUT_MS = 2000;
@@ -127107,7 +127524,7 @@ var LOCK_RETRY_MS2 = 20;
 var LOCK_STALE_MS = 1e4;
 function ensureRegistryDir() {
   const registryDir = dirname34(REGISTRY_PATH);
-  if (!existsSync87(registryDir)) {
+  if (!existsSync88(registryDir)) {
     mkdirSync20(registryDir, { recursive: true, mode: 448 });
   }
 }
@@ -127126,9 +127543,9 @@ function isPidAlive2(pid) {
 }
 function readLockSnapshot() {
   try {
-    if (!existsSync87(REGISTRY_LOCK_PATH))
+    if (!existsSync88(REGISTRY_LOCK_PATH))
       return null;
-    const raw = readFileSync63(REGISTRY_LOCK_PATH, "utf-8");
+    const raw = readFileSync64(REGISTRY_LOCK_PATH, "utf-8");
     const trimmed = raw.trim();
     if (!trimmed)
       return { raw, pid: null, token: null };
@@ -127152,9 +127569,9 @@ function readLockSnapshot() {
 }
 function removeLockIfUnchanged(snapshot) {
   try {
-    if (!existsSync87(REGISTRY_LOCK_PATH))
+    if (!existsSync88(REGISTRY_LOCK_PATH))
       return false;
-    const currentRaw = readFileSync63(REGISTRY_LOCK_PATH, "utf-8");
+    const currentRaw = readFileSync64(REGISTRY_LOCK_PATH, "utf-8");
     if (currentRaw !== snapshot.raw)
       return false;
     unlinkSync17(REGISTRY_LOCK_PATH);
@@ -127258,10 +127675,10 @@ function withRegistryLock(onLocked, onLockUnavailable) {
   }
 }
 function readAllMappingsUnsafe() {
-  if (!existsSync87(REGISTRY_PATH))
+  if (!existsSync88(REGISTRY_PATH))
     return [];
   try {
-    const content = readFileSync63(REGISTRY_PATH, "utf-8");
+    const content = readFileSync64(REGISTRY_PATH, "utf-8");
     return content.split(`
 `).filter((line) => line.trim()).map((line) => {
       try {
@@ -127316,7 +127733,7 @@ function removeSession(sessionId) {
 import {
   appendFileSync as appendFileSync6,
   chmodSync as chmodSync3,
-  existsSync as existsSync89,
+  existsSync as existsSync90,
   renameSync as renameSync8,
   statSync as statSync13,
   unlinkSync as unlinkSync18,
@@ -127324,31 +127741,31 @@ import {
 } from "fs";
 
 // src/openclaw/reply-listener-paths.ts
-import { existsSync as existsSync88, mkdirSync as mkdirSync21 } from "fs";
+import { existsSync as existsSync89, mkdirSync as mkdirSync21 } from "fs";
 import { homedir as homedir19 } from "os";
-import { join as join97 } from "path";
+import { join as join98 } from "path";
 var REPLY_LISTENER_SECURE_FILE_MODE = 384;
 function resolveReplyListenerHomeDir() {
   return process.env.HOME ?? process.env.USERPROFILE ?? homedir19();
 }
 function getReplyListenerStateDir() {
-  return join97(resolveReplyListenerHomeDir(), ".omo", "openclaw", "state");
+  return join98(resolveReplyListenerHomeDir(), ".omo", "openclaw", "state");
 }
 function getReplyListenerPidFilePath() {
-  return join97(getReplyListenerStateDir(), "reply-listener.pid");
+  return join98(getReplyListenerStateDir(), "reply-listener.pid");
 }
 function getReplyListenerStateFilePath() {
-  return join97(getReplyListenerStateDir(), "reply-listener-state.json");
+  return join98(getReplyListenerStateDir(), "reply-listener-state.json");
 }
 function getReplyListenerConfigFilePath() {
-  return join97(getReplyListenerStateDir(), "reply-listener-config.json");
+  return join98(getReplyListenerStateDir(), "reply-listener-config.json");
 }
 function getReplyListenerLogFilePath() {
-  return join97(getReplyListenerStateDir(), "reply-listener.log");
+  return join98(getReplyListenerStateDir(), "reply-listener.log");
 }
 function ensureReplyListenerStateDir() {
   const stateDir = getReplyListenerStateDir();
-  if (!existsSync88(stateDir)) {
+  if (!existsSync89(stateDir)) {
     mkdirSync21(stateDir, { recursive: true, mode: 448 });
   }
 }
@@ -127364,13 +127781,13 @@ function writeSecureReplyListenerFile(filePath, content) {
 }
 function rotateReplyListenerLogIfNeeded(logPath) {
   try {
-    if (!existsSync89(logPath))
+    if (!existsSync90(logPath))
       return;
     const stats = statSync13(logPath);
     if (stats.size <= MAX_REPLY_LISTENER_LOG_SIZE_BYTES)
       return;
     const backupPath = `${logPath}.old`;
-    if (existsSync89(backupPath)) {
+    if (existsSync90(backupPath)) {
       unlinkSync18(backupPath);
     }
     renameSync8(logPath, backupPath);
@@ -127411,7 +127828,7 @@ class ReplyListenerRateLimiter {
 }
 
 // src/openclaw/reply-listener-state.ts
-import { existsSync as existsSync90, readFileSync as readFileSync64, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync91, readFileSync as readFileSync65, unlinkSync as unlinkSync19 } from "fs";
 var REPLY_LISTENER_STARTUP_TOKEN_ENV = "OMO_OPENCLAW_REPLY_LISTENER_STARTUP_TOKEN";
 function createDefaultReplyListenerState() {
   return {
@@ -127473,9 +127890,9 @@ function createPendingReplyListenerState(startupToken) {
 function readReplyListenerDaemonState() {
   try {
     const stateFilePath = getReplyListenerStateFilePath();
-    if (!existsSync90(stateFilePath))
+    if (!existsSync91(stateFilePath))
       return null;
-    return normalizeReplyListenerState(JSON.parse(readFileSync64(stateFilePath, "utf-8")));
+    return normalizeReplyListenerState(JSON.parse(readFileSync65(stateFilePath, "utf-8")));
   } catch {
     return null;
   }
@@ -127490,9 +127907,9 @@ function writeReplyListenerDaemonState(state3) {
 function readReplyListenerDaemonConfig() {
   try {
     const configFilePath = getReplyListenerConfigFilePath();
-    if (!existsSync90(configFilePath))
+    if (!existsSync91(configFilePath))
       return null;
-    return JSON.parse(readFileSync64(configFilePath, "utf-8"));
+    return JSON.parse(readFileSync65(configFilePath, "utf-8"));
   } catch {
     return null;
   }
@@ -127503,9 +127920,9 @@ function writeReplyListenerDaemonConfig(config) {
 function readReplyListenerPid() {
   try {
     const pidFilePath = getReplyListenerPidFilePath();
-    if (!existsSync90(pidFilePath))
+    if (!existsSync91(pidFilePath))
       return null;
-    const pid = Number.parseInt(readFileSync64(pidFilePath, "utf-8").trim(), 10);
+    const pid = Number.parseInt(readFileSync65(pidFilePath, "utf-8").trim(), 10);
     return Number.isNaN(pid) ? null : pid;
   } catch {
     return null;
@@ -127516,7 +127933,7 @@ function writeReplyListenerPid(pid) {
 }
 function removeReplyListenerPid() {
   const pidFilePath = getReplyListenerPidFilePath();
-  if (existsSync90(pidFilePath)) {
+  if (existsSync91(pidFilePath)) {
     unlinkSync19(pidFilePath);
   }
 }
@@ -127533,7 +127950,7 @@ function markReplyListenerStopped(state3, error) {
 
 // src/openclaw/reply-listener-process.ts
 init_bun_spawn_shim();
-import { readFileSync as readFileSync65 } from "fs";
+import { readFileSync as readFileSync66 } from "fs";
 var REPLY_LISTENER_DAEMON_IDENTITY_MARKER = "--openclaw-reply-listener-daemon";
 var REPLY_LISTENER_DAEMON_ENV_ALLOWLIST = [
   "PATH",
@@ -127588,7 +128005,7 @@ function isReplyListenerProcessRunning(pid) {
 async function isReplyListenerDaemonProcess(pid) {
   try {
     if (process.platform === "linux") {
-      const cmdline = readFileSync65(`/proc/${pid}/cmdline`, "utf-8");
+      const cmdline = readFileSync66(`/proc/${pid}/cmdline`, "utf-8");
       return cmdline.includes(REPLY_LISTENER_DAEMON_IDENTITY_MARKER);
     }
     const processInfo = spawn2(["ps", "-p", String(pid), "-o", "args="], {
@@ -127750,7 +128167,7 @@ async function startReplyListener(config) {
   pendingState.configSignature = getReplyListenerRuntimeSignature(normalizedConfig);
   writeReplyListenerDaemonState(pendingState);
   const currentFile = import.meta.url;
-  const daemonScript = currentFile.endsWith(".ts") ? join98(dirname35(new URL(currentFile).pathname), "daemon.ts") : join98(dirname35(new URL(currentFile).pathname), "daemon.js");
+  const daemonScript = currentFile.endsWith(".ts") ? join99(dirname35(new URL(currentFile).pathname), "daemon.ts") : join99(dirname35(new URL(currentFile).pathname), "daemon.js");
   try {
     const processInfo = spawnReplyListenerDaemon(daemonScript, startupToken);
     processInfo.unref();
@@ -128134,21 +128551,21 @@ init_transformer();
 init_logger();
 init_scope_filter2();
 init_bun_file_shim();
-import { existsSync as existsSync91, readFileSync as readFileSync66 } from "fs";
-import { join as join99 } from "path";
+import { existsSync as existsSync92, readFileSync as readFileSync67 } from "fs";
+import { join as join100 } from "path";
 import { homedir as homedir20 } from "os";
 function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd = process.cwd();
   return [
-    { path: join99(homedir20(), ".claude.json"), scope: "user" },
-    { path: join99(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join99(cwd, ".mcp.json"), scope: "project" },
-    { path: join99(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join100(homedir20(), ".claude.json"), scope: "user" },
+    { path: join100(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join100(cwd, ".mcp.json"), scope: "project" },
+    { path: join100(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync91(filePath)) {
+  if (!existsSync92(filePath)) {
     return null;
   }
   try {
@@ -128163,11 +128580,11 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   const cwd = process.cwd();
-  for (const { path: path21 } of paths) {
-    if (!existsSync91(path21))
+  for (const { path: path22 } of paths) {
+    if (!existsSync92(path22))
       continue;
     try {
-      const content = readFileSync66(path21, "utf-8");
+      const content = readFileSync67(path22, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -128192,30 +128609,30 @@ async function loadMcpConfigs(disabledMcps = []) {
   const paths = getMcpConfigPaths();
   const disabledSet = new Set(disabledMcps);
   const cwd = process.cwd();
-  for (const { path: path21, scope } of paths) {
-    const config = await loadMcpConfigFile(path21);
+  for (const { path: path22, scope } of paths) {
+    const config = await loadMcpConfigFile(path22);
     if (!config?.mcpServers)
       continue;
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
       if (disabledSet.has(name)) {
-        log(`Skipping MCP "${name}" (in disabled_mcps)`, { path: path21 });
+        log(`Skipping MCP "${name}" (in disabled_mcps)`, { path: path22 });
         continue;
       }
       if (!shouldLoadMcpServer(serverConfig, cwd)) {
         log(`Skipping MCP server "${name}" because local scope does not match cwd`, {
-          path: path21,
+          path: path22,
           projectPath: serverConfig.projectPath,
           cwd
         });
         continue;
       }
       if (serverConfig.disabled) {
-        log(`Disabling MCP server "${name}"`, { path: path21 });
+        log(`Disabling MCP server "${name}"`, { path: path22 });
         delete servers[name];
         const existingIndex = loadedServers.findIndex((s) => s.name === name);
         if (existingIndex !== -1) {
           loadedServers.splice(existingIndex, 1);
-          log(`Removed previously loaded MCP server "${name}"`, { path: path21 });
+          log(`Removed previously loaded MCP server "${name}"`, { path: path22 });
         }
         continue;
       }
@@ -128227,7 +128644,7 @@ async function loadMcpConfigs(disabledMcps = []) {
           loadedServers.splice(existingIndex, 1);
         }
         loadedServers.push({ name, scope, config: transformed });
-        log(`Loaded MCP server "${name}" from ${scope}`, { path: path21 });
+        log(`Loaded MCP server "${name}" from ${scope}`, { path: path22 });
       } catch (error) {
         log(`Failed to transform MCP server "${name}"`, error);
       }
@@ -130007,6 +130424,8 @@ Each exploration prompt should include four fields: **CONTEXT** (what task, whic
 
 After firing exploration agents, keep the returned background task IDs (\`bg_...\`) for result collection and continuation session IDs (\`ses_...\`) for follow-ups. Continue only with non-overlapping preparation: setting up files, reading known-path files, drafting questions. If no non-overlapping work exists, end your response and wait for the completion notification; then use \`background_output(task_id="bg_...")\`, not \`task(task_id="ses_...")\`, to collect results.
 
+System reminders are input-only signals from the harness. Never write, quote, simulate, or pre-emptively emit \`<system-reminder>\` blocks yourself, and never call \`background_output\` merely because you imagined such a reminder. Only collect a background task after an actual harness-provided completion notification arrives.
+
 Stop searching when you have enough context to proceed confidently, when the same information keeps appearing across sources, when two iterations yield no new useful data, or when you found a direct answer.
 
 ### Tool persistence
@@ -134516,7 +134935,7 @@ createHephaestusAgent2.mode = MODE10;
 // src/agents/builtin-agents/resolve-file-uri.ts
 init_contains_path2();
 init_logger();
-import { existsSync as existsSync92, readFileSync as readFileSync67 } from "fs";
+import { existsSync as existsSync93, readFileSync as readFileSync68 } from "fs";
 import { homedir as homedir21 } from "os";
 import { isAbsolute as isAbsolute18, resolve as resolve25 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
@@ -134540,11 +134959,11 @@ function resolvePromptAppend(promptAppend, configDir) {
     });
     return `[WARNING: Path rejected: ${promptAppend} (resolved outside project root ${projectRoot}; file:// prompts must reside within the project boundary)]`;
   }
-  if (!existsSync92(filePath)) {
+  if (!existsSync93(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync67(filePath, "utf8");
+    return readFileSync68(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -135820,7 +136239,7 @@ function buildAvailableSkills(discoveredSkills, browserProvider, disabledSkills,
     location: "plugin"
   }));
   const discoveredAvailable = discoveredSkills.filter((s) => {
-    if (builtinSkillNames.has(s.name) || disabledSkills?.has(s.name))
+    if (disabledSkills?.has(s.name))
       return false;
     if (agentName && s.definition.agent && s.definition.agent !== agentName)
       return false;
@@ -135830,7 +136249,10 @@ function buildAvailableSkills(discoveredSkills, browserProvider, disabledSkills,
     description: skill2.definition.description ?? "",
     location: mapScopeToLocation(skill2.scope)
   }));
-  return [...builtinAvailable, ...discoveredAvailable];
+  const skillMap = new Map;
+  builtinAvailable.forEach((skill2) => skillMap.set(skill2.name, skill2));
+  discoveredAvailable.forEach((skill2) => skillMap.set(skill2.name, skill2));
+  return Array.from(skillMap.values());
 }
 
 // src/agents/builtin-agents/general-agents.ts
@@ -136705,7 +137127,7 @@ function buildPlanDemoteConfig(prometheusConfig, planOverride) {
 }
 
 // src/shared/host-skill-config.ts
-function toStringArray(value) {
+function toStringArray2(value) {
   if (!Array.isArray(value))
     return [];
   return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
@@ -136714,10 +137136,7 @@ function adaptHostSkillConfig(value) {
   if (!value || typeof value !== "object")
     return;
   const hostSkillConfig = value;
-  const sources = [
-    ...toStringArray(hostSkillConfig.paths),
-    ...toStringArray(hostSkillConfig.urls)
-  ];
+  const sources = toStringArray2(hostSkillConfig.paths);
   if (sources.length === 0)
     return;
   return { sources };
@@ -136762,7 +137181,7 @@ async function applyAgentConfig(params) {
     discoverOpencodeProjectSkills(params.ctx.directory),
     includeClaudeSkillsForAwareness ? discoverGlobalAgentsSkills() : Promise.resolve([])
   ]);
-  const allDiscoveredSkills = [
+  const allDiscoveredSkills = deduplicateSkillsByName([
     ...discoveredConfigSourceSkills,
     ...discoveredHostConfigSkills,
     ...discoveredOpencodeProjectSkills,
@@ -136771,7 +137190,7 @@ async function applyAgentConfig(params) {
     ...discoveredOpencodeGlobalSkills,
     ...discoveredUserSkills,
     ...discoveredGlobalAgentsSkills
-  ];
+  ]);
   const browserProvider = params.pluginConfig.browser_automation_engine?.provider ?? "playwright";
   const currentModel = params.config.model;
   const disabledSkills = new Set(params.pluginConfig.disabled_skills ?? []);
@@ -136944,6 +137363,7 @@ async function applyAgentConfig(params) {
     setDefaultAgentForSort(params.config.default_agent ?? configuredDefaultAgent);
   }
   const agentResult = params.config.agent;
+  clearRegisteredAgentNames();
   for (const name of Object.keys(agentResult)) {
     registerAgentName(name);
   }
@@ -136959,8 +137379,8 @@ init_model_sanitizer();
 init_file_utils2();
 init_shared();
 init_logger();
-import { promises as fs22 } from "fs";
-import { join as join100, basename as basename16 } from "path";
+import { promises as fs23 } from "fs";
+import { join as join101, basename as basename16 } from "path";
 
 // src/features/claude-code-command-loader/loader-cache.ts
 var commandLoaderCache = new Map;
@@ -136968,13 +137388,13 @@ var commandLoaderCache = new Map;
 // src/features/claude-code-command-loader/loader.ts
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
-    await fs22.access(commandsDir);
+    await fs23.access(commandsDir);
   } catch {
     return [];
   }
   let realPath;
   try {
-    realPath = await fs22.realpath(commandsDir);
+    realPath = await fs23.realpath(commandsDir);
   } catch (error) {
     log(`Failed to resolve command directory: ${commandsDir}`, error);
     return [];
@@ -136985,7 +137405,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
   visited.add(realPath);
   let entries;
   try {
-    entries = await fs22.readdir(commandsDir, { withFileTypes: true });
+    entries = await fs23.readdir(commandsDir, { withFileTypes: true });
   } catch (error) {
     log(`Failed to read command directory: ${commandsDir}`, error);
     return [];
@@ -136997,7 +137417,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join100(commandsDir, entry.name);
+      const subDirPath = join101(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands2.push(...subCommands);
@@ -137005,11 +137425,11 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join100(commandsDir, entry.name);
+    const commandPath = join101(commandsDir, entry.name);
     const baseCommandName = basename16(entry.name, ".md");
     const commandName = prefix ? `${prefix}/${baseCommandName}` : baseCommandName;
     try {
-      const content = await fs22.readFile(commandPath, "utf-8");
+      const content = await fs23.readFile(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -137064,12 +137484,12 @@ function commandsToRecord(commands2) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join100(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join101(getClaudeConfigDir(), "commands");
   const commands2 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands2);
 }
 async function loadProjectCommands(directory) {
-  const projectCommandsDir = join100(directory ?? process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join101(directory ?? process.cwd(), ".claude", "commands");
   const commands2 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands2);
 }
@@ -137220,13 +137640,13 @@ var grep_app = {
 };
 
 // src/mcp/ast-grep.ts
-import { existsSync as existsSync93 } from "fs";
+import { existsSync as existsSync94 } from "fs";
 import { dirname as dirname36, resolve as resolve26 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/mcp/cli-suffix.ts
-function normalizeCliPath(path21) {
-  return path21.replaceAll("\\", "/");
+function normalizeCliPath(path22) {
+  return path22.replaceAll("\\", "/");
 }
 function hasCliSuffix(candidatePath, suffix) {
   return normalizeCliPath(candidatePath).endsWith(normalizeCliPath(suffix));
@@ -137320,11 +137740,11 @@ function getModuleDirectory(moduleUrl) {
 }
 function createFallbackCandidate(resolveExecutable) {
   const runtime6 = resolveJavaScriptRuntime(resolveExecutable);
-  const path21 = resolve26(PACKAGE_REL, DIST_CLI_REL);
-  return { command: [runtime6.command, path21, "mcp"], path: path21, exists: runtime6.available, runtimeAvailable: runtime6.available };
+  const path22 = resolve26(PACKAGE_REL, DIST_CLI_REL);
+  return { command: [runtime6.command, path22, "mcp"], path: path22, exists: runtime6.available, runtimeAvailable: runtime6.available };
 }
 function resolveAstGrepCommand(options = {}) {
-  const pathExists = options.exists ?? existsSync93;
+  const pathExists = options.exists ?? existsSync94;
   const resolveExecutable = options.resolveExecutable ?? resolveRuntimeExecutable;
   const candidates = [];
   const seenPaths = new Set;
@@ -137360,7 +137780,7 @@ function createAstGrepMcpConfig(options = {}) {
 }
 
 // src/mcp/lsp.ts
-import { existsSync as existsSync94 } from "fs";
+import { existsSync as existsSync95 } from "fs";
 import { dirname as dirname37, resolve as resolve27 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var SUBMODULE_REL = "packages/lsp-tools-mcp";
@@ -137449,7 +137869,7 @@ function createBootstrapCandidate(root, resolveExecutable) {
   };
 }
 function resolveLspCommand(options = {}) {
-  const pathExists = options.exists ?? existsSync94;
+  const pathExists = options.exists ?? existsSync95;
   const resolveExecutable = options.resolveExecutable ?? resolveRuntimeExecutable;
   const candidates = [];
   const seenPaths = new Set;
@@ -137981,11 +138401,25 @@ async function createSkillContext(args) {
     return true;
   });
   const includeClaudeSkills = pluginConfig.claude_code?.skills !== false;
-  const [configSourceSkills, userSkills, globalSkills, projectSkills, opencodeProjectSkills, agentsProjectSkills, agentsGlobalSkills] = await Promise.all([
+  const hostSkillConfig = adaptHostSkillConfig(readOpencodeConfigSkills(directory));
+  const [
+    configSourceSkills,
+    hostConfigSkills,
+    userSkills,
+    globalSkills,
+    projectSkills,
+    opencodeProjectSkills,
+    agentsProjectSkills,
+    agentsGlobalSkills
+  ] = await Promise.all([
     discoverConfigSourceSkills({
       config: pluginConfig.skills,
       configDir: directory
     }),
+    discoverConfigSourceSkills({
+      config: hostSkillConfig,
+      configDir: directory
+    }),
     includeClaudeSkills ? discoverUserClaudeSkills() : Promise.resolve([]),
     discoverOpencodeGlobalSkills(),
     includeClaudeSkills ? discoverProjectClaudeSkills(directory) : Promise.resolve([]),
@@ -137993,7 +138427,12 @@ async function createSkillContext(args) {
     discoverProjectAgentsSkills(directory),
     discoverGlobalAgentsSkills()
   ]);
-  const filteredConfigSourceSkills = filterProviderGatedSkills(configSourceSkills, browserProvider);
+  const configSkillsHostWins = new Map;
+  for (const skill2 of configSourceSkills)
+    configSkillsHostWins.set(skill2.name, skill2);
+  for (const skill2 of hostConfigSkills)
+    configSkillsHostWins.set(skill2.name, skill2);
+  const filteredConfigSourceSkills = filterProviderGatedSkills(Array.from(configSkillsHostWins.values()), browserProvider);
   const filteredUserSkills = filterProviderGatedSkills(userSkills, browserProvider);
   const filteredGlobalSkills = filterProviderGatedSkills(globalSkills, browserProvider);
   const filteredProjectSkills = filterProviderGatedSkills(projectSkills, browserProvider);
@@ -138434,7 +138873,7 @@ async function loadTeamSpec(teamName, config, projectRoot, options) {
 
 // src/features/team-mode/team-runtime/create.ts
 import { access as access4, mkdir as mkdir5 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 init_paths();
 init_store();
 init_team_session_registry();
@@ -138708,7 +139147,7 @@ async function findExistingRuntime(spec, leadSessionId, config) {
   }
 }
 async function createMemberWorktree(memberWorktreePath, projectRoot) {
-  const absolutePath = path21.isAbsolute(memberWorktreePath) ? memberWorktreePath : path21.resolve(projectRoot, memberWorktreePath);
+  const absolutePath = path22.isAbsolute(memberWorktreePath) ? memberWorktreePath : path22.resolve(projectRoot, memberWorktreePath);
   await mkdir5(absolutePath, { recursive: true });
   return absolutePath;
 }
@@ -138979,6 +139418,29 @@ var TeamCreateArgsSchema = z41.object({
     ctx.addIssue({ code: "custom", message: "Provide exactly one of teamName or inline_spec." });
   }
 });
+var TeamCreateInlineMemberToolSchema = tool.schema.object({
+  name: tool.schema.string().optional().describe("Member name, kebab-case or natural text; normalized before team creation."),
+  kind: tool.schema.enum(["category", "subagent_type"]).optional().describe("Member kind. Use category for category-routed workers, or subagent_type for a specific eligible agent."),
+  category: tool.schema.string().optional().describe("Required for category members unless a fallback category can be inferred. Examples: quick, unspecified-low, unspecified-high, deep, ultrabrain, visual-engineering, writing, artistry, git, data-analysis."),
+  subagent_type: tool.schema.string().optional().describe("Required for subagent_type members. Eligible examples: sisyphus, atlas, sisyphus-junior."),
+  prompt: tool.schema.string().optional().describe("Task prompt for this member. Category members need a concrete work prompt."),
+  systemPrompt: tool.schema.string().optional().describe("Legacy alias for prompt; normalized before team creation."),
+  loadSkills: tool.schema.array(tool.schema.string()).optional().describe("Optional skills to load for this member."),
+  role: tool.schema.string().optional().describe("Optional natural-language role used to build a prompt when prompt is omitted."),
+  description: tool.schema.string().optional().describe("Optional natural-language description used to build a prompt when prompt is omitted.")
+});
+var TeamCreateInlineSpecToolSchema = tool.schema.union([
+  tool.schema.object({
+    name: tool.schema.string().describe("Team name, kebab-case or natural text; normalized before team creation."),
+    description: tool.schema.string().optional().describe("Optional team description."),
+    leadAgentId: tool.schema.string().optional().describe("Optional member name to use as team lead."),
+    lead: TeamCreateInlineMemberToolSchema.optional().describe("Optional explicit lead member."),
+    members: tool.schema.array(TeamCreateInlineMemberToolSchema).describe("Team members; members must be a flat array, not an object or nested groups. Provide 1-8 members."),
+    teamAllowedPaths: tool.schema.array(tool.schema.string()).optional().describe("Optional paths the team may access."),
+    sessionPermission: tool.schema.string().optional().describe("Optional session permission policy.")
+  }),
+  tool.schema.string().describe("JSON string containing the same inline team spec object.")
+]);
 var TeamDeleteArgsSchema = z41.object({ teamRunId: z41.string().min(1), force: z41.boolean().optional() });
 var TeamShutdownRequestArgsSchema = z41.object({ teamRunId: z41.string().min(1), targetMemberName: z41.string().min(1) });
 var TeamApproveShutdownArgsSchema = z41.object({ teamRunId: z41.string().min(1), memberName: z41.string().min(1) });
@@ -139013,8 +139475,8 @@ function parseTeamCreateArgs(rawArgs) {
   }
   return result.data;
 }
-function formatZodIssuePath(path22) {
-  return path22.length > 0 ? path22.join(".") : "<root>";
+function formatZodIssuePath(path23) {
+  return path23.length > 0 ? path23.join(".") : "<root>";
 }
 function formatTeamSpecIssues(error) {
   return error.issues.slice(0, 5).map((issue) => `${formatZodIssuePath(issue.path)}: ${issue.message}`).join("; ");
@@ -139077,7 +139539,7 @@ function createTeamCreateTool(config, client, bgMgr, tmuxMgr, executorConfig, de
     description: "Create a team run from a named or inline team spec.",
     args: {
       teamName: tool.schema.string().optional().describe("Named team spec to load. Provide exactly one of teamName or inline_spec."),
-      inline_spec: tool.schema.unknown().optional().describe("Inline team spec object or JSON string. Provide exactly one of teamName or inline_spec."),
+      inline_spec: TeamCreateInlineSpecToolSchema.optional().describe('Inline team spec object or JSON string. Provide exactly one of teamName or inline_spec; members must be a flat array, e.g. { name: "project-analysis-team", members: [{ name: "structure-analyst", category: "quick", prompt: "Analyze project structure." }] }.'),
       leadSessionId: tool.schema.string().optional().describe("Optional non-empty session ID override. Usually omit this and let team_create use the current session.")
     },
     async execute(rawArgs, toolContext) {
@@ -139187,7 +139649,7 @@ init_store();
 // src/features/team-mode/team-tasklist/list.ts
 init_logger();
 import { readdir as readdir8, readFile as readFile10 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 
 // src/features/team-mode/team-registry/index.ts
 init_paths();
@@ -139206,7 +139668,7 @@ async function listTasks(teamRunId, config, filter) {
   for (const entry of entries) {
     if (entry.isDirectory() || entry.name.startsWith(".") || !entry.name.endsWith(".json"))
       continue;
-    const taskPath = path22.join(tasksDirectory, entry.name);
+    const taskPath = path23.join(tasksDirectory, entry.name);
     try {
       const taskContent = await readFile10(taskPath, "utf8");
       const parsedTask = TaskSchema.safeParse(JSON.parse(taskContent));
@@ -139238,7 +139700,7 @@ async function listTasks(teamRunId, config, filter) {
 // src/features/team-mode/team-runtime/status.ts
 init_paths();
 import { readdir as readdir9 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 function getPrimaryModelKey(bgMgr, leadSessionId) {
   if (!bgMgr || !leadSessionId)
     return;
@@ -139289,10 +139751,10 @@ async function aggregateStatus(teamRunId, config, bgMgr) {
   const concurrencyCounts = resolveConcurrencyCounts(teamBackgroundManager, runtimeState.leadSessionId);
   const teamRunIdSpecific = teamBackgroundManager?.listTasksByParentSession?.(runtimeState.leadSessionId ?? teamRunId)?.length;
   const baseDir = resolveBaseDir(config);
-  const claimsDir = path23.join(getTasksDir(baseDir, teamRunId), "claims");
+  const claimsDir = path24.join(getTasksDir(baseDir, teamRunId), "claims");
   const staleLockEntries = await readdir9(claimsDir, { withFileTypes: true }).catch(() => []);
   const staleLockPaths = await Promise.all(staleLockEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".lock")).map(async (entry) => {
-    const lockPath = path23.join(claimsDir, entry.name);
+    const lockPath = path24.join(claimsDir, entry.name);
     return await detectStaleLock(lockPath, 300000) ? lockPath : undefined;
   }));
   return {
@@ -139391,7 +139853,7 @@ function createTeamListTool(config, client, deps = defaultDeps7) {
 
 // src/features/team-mode/team-tasklist/claim.ts
 import { access as access5, mkdir as mkdir6 } from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 init_locks();
 init_types2();
 
@@ -139405,11 +139867,11 @@ function canClaim(task, allTasks) {
 
 // src/features/team-mode/team-tasklist/get.ts
 import { readFile as readFile11 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 init_types2();
 async function getTask(teamRunId, taskId, config) {
   const tasksDirectory = getTasksDir(resolveBaseDir(config), teamRunId);
-  const taskContent = await readFile11(path24.join(tasksDirectory, `${taskId}.json`), "utf8");
+  const taskContent = await readFile11(path25.join(tasksDirectory, `${taskId}.json`), "utf8");
   return TaskSchema.parse(JSON.parse(taskContent));
 }
 
@@ -139448,9 +139910,9 @@ class BlockedByError extends Error {
 async function claimTask(teamRunId, taskId, memberName, config) {
   const baseDirectory = resolveBaseDir(config);
   const tasksDirectory = getTasksDir(baseDirectory, teamRunId);
-  const claimsDirectory = path25.join(tasksDirectory, "claims");
-  const taskPath = path25.join(tasksDirectory, `${taskId}.json`);
-  const claimLockPath = path25.join(claimsDirectory, `${taskId}.lock`);
+  const claimsDirectory = path26.join(tasksDirectory, "claims");
+  const taskPath = path26.join(tasksDirectory, `${taskId}.json`);
+  const claimLockPath = path26.join(claimsDirectory, `${taskId}.lock`);
   await mkdir6(claimsDirectory, { recursive: true, mode: 448 });
   const task = await getTask(teamRunId, taskId, config);
   if (task.status !== "pending") {
@@ -139489,7 +139951,7 @@ async function claimTask(teamRunId, taskId, memberName, config) {
 }
 // src/features/team-mode/team-tasklist/store.ts
 import { mkdir as mkdir7, readFile as readFile12 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 init_locks();
 init_types2();
 var HIGH_WATERMARK_FILE = ".highwatermark";
@@ -139506,9 +139968,9 @@ async function readHighWatermark(watermarkPath) {
 async function createTask(teamRunId, taskInput, config) {
   const tasksDirectory = getTasksDir(resolveBaseDir(config), teamRunId);
   await mkdir7(tasksDirectory, { recursive: true, mode: 448 });
-  await mkdir7(path26.join(tasksDirectory, "claims"), { recursive: true, mode: 448 });
-  return withLock(path26.join(tasksDirectory, ".lock"), async () => {
-    const watermarkPath = path26.join(tasksDirectory, HIGH_WATERMARK_FILE);
+  await mkdir7(path27.join(tasksDirectory, "claims"), { recursive: true, mode: 448 });
+  return withLock(path27.join(tasksDirectory, ".lock"), async () => {
+    const watermarkPath = path27.join(tasksDirectory, HIGH_WATERMARK_FILE);
     const nextTaskId = await readHighWatermark(watermarkPath) + 1;
     await atomicWrite(watermarkPath, String(nextTaskId));
     const now = Date.now();
@@ -139519,13 +139981,13 @@ async function createTask(teamRunId, taskInput, config) {
       createdAt: now,
       updatedAt: now
     });
-    await atomicWrite(path26.join(tasksDirectory, `${task.id}.json`), `${JSON.stringify(task, null, 2)}
+    await atomicWrite(path27.join(tasksDirectory, `${task.id}.json`), `${JSON.stringify(task, null, 2)}
 `);
     return task;
   }, { ownerTag: `create-task:${teamRunId}` });
 }
 // src/features/team-mode/team-tasklist/update.ts
-import path27 from "path";
+import path28 from "path";
 init_locks();
 init_types2();
 var ALLOWED_TRANSITIONS = {
@@ -139574,7 +140036,7 @@ async function updateTaskStatus(teamRunId, taskId, newStatus, memberName, config
     updatedAt: Date.now()
   });
   const tasksDirectory = getTasksDir(resolveBaseDir(config), teamRunId);
-  await atomicWrite(path27.join(tasksDirectory, `${taskId}.json`), `${JSON.stringify(updatedTask, null, 2)}
+  await atomicWrite(path28.join(tasksDirectory, `${taskId}.json`), `${JSON.stringify(updatedTask, null, 2)}
 `);
   return updatedTask;
 }
@@ -140306,8 +140768,8 @@ init_agent_display_names();
 // src/plugin/ultrawork-db-model-override.ts
 init_data_path();
 init_shared();
-import { join as join101 } from "path";
-import { existsSync as existsSync95 } from "fs";
+import { join as join102 } from "path";
+import { existsSync as existsSync96 } from "fs";
 async function importBunSqlite() {
   if (typeof globalThis.Bun === "undefined") {
     return null;
@@ -140320,7 +140782,7 @@ async function importBunSqlite() {
   }
 }
 function getDbPath() {
-  return join101(getDataDir(), "opencode", "opencode.db");
+  return join102(getDataDir(), "opencode", "opencode.db");
 }
 var MAX_MICROTASK_RETRIES = 10;
 function tryUpdateMessageModel(db, messageId, targetModel, variant) {
@@ -140403,7 +140865,7 @@ function scheduleDeferredModelOverride(messageId, targetModel, variant) {
       return;
     }
     const dbPath = getDbPath();
-    if (!existsSync95(dbPath)) {
+    if (!existsSync96(dbPath)) {
       log("[ultrawork-db-override] DB not found, skipping deferred override");
       return;
     }
@@ -140762,11 +141224,17 @@ init_model_normalization();
 var ASSISTANT_PREFILL_RECOVERY_TEXT = "[internal] Continue from the previous assistant state.";
 var ASSISTANT_PREFILL_UNSUPPORTED_PROVIDERS = new Set([
   "anthropic",
-  "google-vertex-anthropic"
+  "aws-bedrock-anthropic",
+  "github-copilot",
+  "github-copilot-enterprise",
+  "google-vertex-anthropic",
+  "opencode",
+  "opencode-go",
+  "opencode-zen-proxy",
+  "vercel"
 ]);
 var ASSISTANT_PREFILL_UNSUPPORTED_MODEL_PREFIXES = [
-  "claude-opus-4-7",
-  "claude-opus-4-6",
+  "claude-opus-4",
   "claude-sonnet-4-6",
   "claude-mythos"
 ];
@@ -140817,15 +141285,26 @@ function findLastUserModel(messages) {
   }
   return;
 }
+function normalizeAssistantPrefillModelID(modelID) {
+  const normalizedModelID = normalizeModelID(modelID.toLowerCase());
+  return normalizedModelID.split(/[/.~:@]+/).find((segment) => segment.startsWith("claude-")) ?? normalizedModelID;
+}
+function hasAnthropicModelNamespace(modelID) {
+  const normalizedModelID = normalizeModelID(modelID.toLowerCase());
+  return /(?:^|[/.~:@])anthropic(?:$|[/.~:@])/.test(normalizedModelID);
+}
+function providerCanExposeUnsupportedAssistantPrefill(providerID, modelID) {
+  return ASSISTANT_PREFILL_UNSUPPORTED_PROVIDERS.has(providerID) || hasAnthropicModelNamespace(modelID);
+}
 function shouldRepairAssistantPrefillForModel(model) {
   if (!model) {
     return false;
   }
   const providerID = model.providerID.toLowerCase();
-  if (!ASSISTANT_PREFILL_UNSUPPORTED_PROVIDERS.has(providerID)) {
+  if (!providerCanExposeUnsupportedAssistantPrefill(providerID, model.modelID)) {
     return false;
   }
-  const modelID = normalizeModelID(model.modelID.toLowerCase());
+  const modelID = normalizeAssistantPrefillModelID(model.modelID);
   return ASSISTANT_PREFILL_UNSUPPORTED_MODEL_PREFIXES.some((prefix) => modelID.startsWith(prefix));
 }
 function isCompactionContinuationPart(part) {
@@ -140886,9 +141365,10 @@ async function runMessagesTransformHookSafely(hookName, handler, input, output)
   try {
     await Promise.resolve(handler(input, output));
   } catch (error) {
+    const hookError = error instanceof Error ? error : new Error(String(error));
     log("[messages-transform] hook execution failed", {
       hook: hookName,
-      error
+      error: hookError
     });
   }
 }
@@ -140930,19 +141410,19 @@ init_session_tools_store();
 // src/features/team-mode/team-mailbox/ack.ts
 init_paths();
 import { mkdir as mkdir8, rename as rename3 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 async function ackMessages(teamRunId, memberName, messageIds, config) {
   const baseDir = resolveBaseDir(config);
   const inboxDir = getInboxDir(baseDir, teamRunId, memberName);
-  const processedDir = path28.join(inboxDir, "processed");
+  const processedDir = path29.join(inboxDir, "processed");
   await mkdir8(processedDir, { recursive: true, mode: 448 });
   for (const messageId of messageIds) {
     const messageFileName = `${messageId}.json`;
     const sourcePaths = [
-      path28.join(inboxDir, messageFileName),
-      path28.join(inboxDir, `.delivering-${messageFileName}`)
+      path29.join(inboxDir, messageFileName),
+      path29.join(inboxDir, `.delivering-${messageFileName}`)
     ];
-    const targetPath = path28.join(processedDir, messageFileName);
+    const targetPath = path29.join(processedDir, messageFileName);
     for (const sourcePath of sourcePaths) {
       try {
         await rename3(sourcePath, targetPath);
@@ -141514,6 +141994,33 @@ function normalizeSessionStatusToIdle(input) {
 
 // src/plugin/event.ts
 init_event_session_id();
+
+// src/plugin/user-abort-interrupted-recovery-guard.ts
+var USER_ABORT_ERROR_NAMES = new Set(["MessageAbortedError", "AbortError"]);
+function createUserAbortInterruptedRecoveryGuard() {
+  const abortedSessions = new Set;
+  return {
+    noteSessionError(sessionID, errorName) {
+      if (!errorName || !USER_ABORT_ERROR_NAMES.has(errorName)) {
+        return false;
+      }
+      abortedSessions.add(sessionID);
+      return true;
+    },
+    shouldSkipRecovery(sessionID) {
+      const shouldSkip = abortedSessions.has(sessionID);
+      if (shouldSkip) {
+        abortedSessions.delete(sessionID);
+      }
+      return shouldSkip;
+    },
+    clear(sessionID) {
+      abortedSessions.delete(sessionID);
+    }
+  };
+}
+
+// src/plugin/event.ts
 function isRecord26(value) {
   return typeof value === "object" && value !== null;
 }
@@ -141598,6 +142105,7 @@ function createEventHandler2(args) {
   const lastKnownModelBySession = new Map;
   const modelFallbackContinuationsInFlight = new Set;
   const lastDispatchedModelFallbackContinuationKeys = new Map;
+  const userAbortInterruptedRecoveryGuard = createUserAbortInterruptedRecoveryGuard();
   const resolveFallbackProviderID = (sessionID, providerHint) => {
     const normalizedProviderHint = providerHint?.trim();
     if (normalizedProviderHint) {
@@ -141651,7 +142159,6 @@ function createEventHandler2(args) {
     await runEventHookSafely("sessionNotification", hooks2.sessionNotification, input);
     await runEventHookSafely("todoContinuationEnforcer", hooks2.todoContinuationEnforcer?.handler, input);
     await runEventHookSafely("unstableAgentBabysitter", hooks2.unstableAgentBabysitter?.event, input);
-    await runEventHookSafely("contextWindowMonitor", hooks2.contextWindowMonitor?.event, input);
     await runEventHookSafely("preemptiveCompaction", hooks2.preemptiveCompaction?.event, input);
     await runEventHookSafely("directoryAgentsInjector", hooks2.directoryAgentsInjector?.event, input);
     await runEventHookSafely("directoryReadmeInjector", hooks2.directoryReadmeInjector?.event, input);
@@ -141713,6 +142220,10 @@ function createEventHandler2(args) {
     if (!sessionID || !hooks2.sessionRecovery?.handleInterruptedToolResultsOnIdle) {
       return false;
     }
+    if (userAbortInterruptedRecoveryGuard.shouldSkipRecovery(sessionID)) {
+      log("[event] interrupted tool recovery skipped after user abort", { sessionID });
+      return false;
+    }
     return hooks2.sessionRecovery.handleInterruptedToolResultsOnIdle(sessionID);
   };
   const dispatchIdleOnlyHooks = async (input) => {
@@ -141872,10 +142383,6 @@ function createEventHandler2(args) {
         const emittedAt = recentSyntheticIdles.get(sessionID);
         if (emittedAt !== undefined && now - emittedAt < DEDUP_WINDOW_MS2) {
           recentSyntheticIdles.delete(sessionID);
-          const lastAnyIdleAt = recentAnyIdles.get(sessionID);
-          if (lastAnyIdleAt === emittedAt) {
-            recentAnyIdles.delete(sessionID);
-          }
         }
       }
       const recovered = await recoverInterruptedToolResultsOnIdleEvent(input);
@@ -141964,6 +142471,7 @@ function createEventHandler2(args) {
         lastKnownModelBySession.delete(sessionID);
         modelFallbackContinuationsInFlight.delete(sessionID);
         lastDispatchedModelFallbackContinuationKeys.delete(sessionID);
+        userAbortInterruptedRecoveryGuard.clear(sessionID);
         if (modelFallback) {
           clearPendingModelFallback(modelFallback, sessionID);
           clearSessionFallbackChain(modelFallback, sessionID);
@@ -142042,6 +142550,10 @@ function createEventHandler2(args) {
           lastKnownModelBySession.set(sessionID, { providerID, modelID });
           setSessionModel(sessionID, { providerID, modelID });
         }
+        userAbortInterruptedRecoveryGuard.clear(sessionID);
+      }
+      if (sessionID && role === "assistant") {
+        userAbortInterruptedRecoveryGuard.noteSessionError(sessionID, extractErrorName3(info?.error));
       }
       if (sessionID && role === "assistant" && !isRuntimeFallbackEnabled && isModelFallbackEnabled) {
         try {
@@ -142157,6 +142669,9 @@ function createEventHandler2(args) {
         const errorName = extractErrorName3(error);
         const errorMessage = extractErrorMessage3(error);
         const errorInfo = { name: errorName, message: errorMessage };
+        if (sessionID) {
+          userAbortInterruptedRecoveryGuard.noteSessionError(sessionID, errorName);
+        }
         if (hooks2.sessionRecovery?.isRecoverableError(error)) {
           const messageInfo = {
             id: props?.messageID,
@@ -142356,7 +142871,6 @@ function createToolExecuteAfterHandler3(args) {
       await hooks2.toolOutputTruncator?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.claudeCodeHooks?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.preemptiveCompaction?.["tool.execute.after"]?.(hookInput, output);
-      await hooks2.contextWindowMonitor?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.commentChecker?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.directoryAgentsInjector?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.directoryReadmeInjector?.["tool.execute.after"]?.(hookInput, output);
@@ -142656,9 +143170,9 @@ function createPluginInterface(args) {
 }
 
 // src/plugin-config.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import { homedir as homedir22 } from "os";
-import * as path29 from "path";
+import * as path30 from "path";
 init_shared();
 init_plugin_identity();
 
@@ -142788,22 +143302,22 @@ function resolveHomeDirectory() {
   return process.env.HOME ?? process.env.USERPROFILE ?? homedir22();
 }
 function resolveConfigPathAfterLegacyMigration(detectedPath) {
-  if (!path29.basename(detectedPath).startsWith(LEGACY_CONFIG_BASENAME)) {
+  if (!path30.basename(detectedPath).startsWith(LEGACY_CONFIG_BASENAME)) {
     return detectedPath;
   }
   const migrated = migrateLegacyConfigFile(detectedPath);
-  const canonicalPath = path29.join(path29.dirname(detectedPath), `${CONFIG_BASENAME}${path29.extname(detectedPath)}`);
-  if (migrated || fs23.existsSync(canonicalPath)) {
+  const canonicalPath = path30.join(path30.dirname(detectedPath), `${CONFIG_BASENAME}${path30.extname(detectedPath)}`);
+  if (migrated || fs24.existsSync(canonicalPath)) {
     return canonicalPath;
   }
   return detectedPath;
 }
 function loadExplicitGitMasterOverrides(configPath) {
   try {
-    if (!fs23.existsSync(configPath)) {
+    if (!fs24.existsSync(configPath)) {
       return;
     }
-    const content = fs23.readFileSync(configPath, "utf-8");
+    const content = fs24.readFileSync(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const gitMaster = rawConfig.git_master;
     if (gitMaster && typeof gitMaster === "object" && !Array.isArray(gitMaster)) {
@@ -142860,8 +143374,8 @@ function parseConfigPartially(rawConfig) {
 }
 function loadConfigFromPath2(configPath, _ctx) {
   try {
-    if (fs23.existsSync(configPath)) {
-      const content = fs23.readFileSync(configPath, "utf-8");
+    if (fs24.existsSync(configPath)) {
+      const content = fs24.readFileSync(configPath, "utf-8");
       const rawConfig = parseJsonc(content);
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -142996,7 +143510,7 @@ function loadPluginConfig(directory, ctx) {
     stopDirectory
   });
   const canonicalAncestorPathsNearestFirst = ancestorConfigPathsNearestFirst.map((ancestorPath) => {
-    const opencodeDir = path29.dirname(ancestorPath);
+    const opencodeDir = path30.dirname(ancestorPath);
     const ancestorDetected = detectPluginConfigFile(opencodeDir, {
       basenames: [CONFIG_BASENAME],
       legacyBasenames: [LEGACY_CONFIG_BASENAME]
@@ -143037,8 +143551,8 @@ function loadPluginConfig(directory, ctx) {
     const ancestorConfig = loadConfigFromPath2(ancestorPath, ctx);
     const ancestorOverrides = loadExplicitGitMasterOverrides(ancestorPath);
     if (ancestorConfig?.agent_definitions) {
-      const ancestorBasePath = path29.dirname(ancestorPath);
-      const ancestorDir = path29.dirname(ancestorBasePath);
+      const ancestorBasePath = path30.dirname(ancestorPath);
+      const ancestorDir = path30.dirname(ancestorBasePath);
       ancestorConfig.agent_definitions = resolveAgentDefinitionPaths(ancestorConfig.agent_definitions, ancestorBasePath, ancestorDir);
     }
     if (ancestorConfig) {