oh-my-opencode 3.8.5 → 3.10.0

package/dist/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -5248,10 +5266,10 @@ WHY THIS FORMAT IS MANDATORY:
 `, PLAN_AGENT_NAMES, PLAN_FAMILY_NAMES;
 var init_constants = __esm(() => {
   DEFAULT_CATEGORIES = {
-    "visual-engineering": { model: "google/gemini-3-pro", variant: "high" },
+    "visual-engineering": { model: "google/gemini-3.1-pro", variant: "high" },
     ultrabrain: { model: "openai/gpt-5.3-codex", variant: "xhigh" },
     deep: { model: "openai/gpt-5.3-codex", variant: "medium" },
-    artistry: { model: "google/gemini-3-pro", variant: "high" },
+    artistry: { model: "google/gemini-3.1-pro", variant: "high" },
     quick: { model: "anthropic/claude-haiku-4-5" },
     "unspecified-low": { model: "anthropic/claude-sonnet-4-6" },
     "unspecified-high": { model: "anthropic/claude-opus-4-6", variant: "max" },
@@ -8167,7 +8185,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve10.call(this, root, ref);
+    let _sch = resolve13.call(this, root, ref);
     if (_sch === undefined) {
       const schema2 = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -8194,7 +8212,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve10(root, ref) {
+  function resolve13(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -8724,7 +8742,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve10(baseURI, relativeURI, options) {
+  function resolve13(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -8952,7 +8970,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize: normalize2,
-    resolve: resolve10,
+    resolve: resolve13,
     resolveComponent,
     equal,
     serialize,
@@ -11833,12 +11851,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve10, reject) {
+      return new Promise(function(resolve13, reject) {
         isexe(path11, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve10(is);
+            resolve13(is);
           }
         });
       });
@@ -11900,27 +11918,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve10, reject) => {
+    const step = (i2) => new Promise((resolve13, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve10(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve13(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path11.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve10(subStep(p, i2, 0));
+      resolve13(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve10, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve13, reject) => {
       if (ii === pathExt.length)
-        return resolve10(step(i2 + 1));
+        return resolve13(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve10(p + ext);
+            return resolve13(p + ext);
         }
-        return resolve10(subStep(p, i2, ii + 1));
+        return resolve13(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -12239,7 +12257,7 @@ var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = 900;
 var COUNTDOWN_GRACE_PERIOD_MS = 500;
 var ABORT_WINDOW_MS = 3000;
-var CONTINUATION_COOLDOWN_MS = 30000;
+var CONTINUATION_COOLDOWN_MS = 5000;
 var MAX_CONSECUTIVE_FAILURES = 5;
 var FAILURE_RESET_WINDOW_MS = 5 * 60 * 1000;
 // src/features/run-continuation-state/constants.ts
@@ -17101,14 +17119,15 @@ var AGENT_MODEL_REQUIREMENTS = {
   },
   hephaestus: {
     fallbackChain: [
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.3-codex", variant: "medium" }
+      { providers: ["openai", "venice", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
+      { providers: ["github-copilot"], model: "gpt-5.2", variant: "medium" }
     ],
-    requiresProvider: ["openai", "github-copilot", "opencode"]
+    requiresProvider: ["openai", "github-copilot", "venice", "opencode"]
   },
   oracle: {
     fallbackChain: [
       { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" },
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" }
     ]
   },
@@ -17141,7 +17160,7 @@ var AGENT_MODEL_REQUIREMENTS = {
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
       { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
       { providers: ["opencode"], model: "kimi-k2.5-free" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro" }
     ]
   },
   metis: {
@@ -17149,14 +17168,14 @@ var AGENT_MODEL_REQUIREMENTS = {
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
       { providers: ["opencode"], model: "kimi-k2.5-free" },
       { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" }
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
     ]
   },
   momus: {
     fallbackChain: [
       { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "medium" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" }
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
     ]
   },
   atlas: {
@@ -17170,33 +17189,33 @@ var AGENT_MODEL_REQUIREMENTS = {
 var CATEGORY_MODEL_REQUIREMENTS = {
   "visual-engineering": {
     fallbackChain: [
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" },
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
       { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" }
     ]
   },
   ultrabrain: {
     fallbackChain: [
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.3-codex", variant: "xhigh" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" },
+      { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "xhigh" },
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" }
     ]
   },
   deep: {
     fallbackChain: [
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
+      { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" }
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
     ],
     requiresModel: "gpt-5.3-codex"
   },
   artistry: {
     fallbackChain: [
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "high" },
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
       { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
     ],
-    requiresModel: "gemini-3-pro"
+    requiresModel: "gemini-3.1-pro"
   },
   quick: {
     fallbackChain: [
@@ -17208,7 +17227,7 @@ var CATEGORY_MODEL_REQUIREMENTS = {
   "unspecified-low": {
     fallbackChain: [
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
+      { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
       { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }
     ]
   },
@@ -17216,11 +17235,12 @@ var CATEGORY_MODEL_REQUIREMENTS = {
     fallbackChain: [
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
       { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro" }
     ]
   },
   writing: {
     fallbackChain: [
+      { providers: ["opencode"], model: "kimi-k2.5-free" },
       { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
       { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" }
     ]
@@ -17684,10 +17704,10 @@ function isModelCacheAvailable() {
 // src/shared/provider-model-id-transform.ts
 function transformModelForProvider(provider, model) {
   if (provider === "github-copilot") {
-    return model.replace("claude-opus-4-6", "claude-opus-4.6").replace("claude-sonnet-4-6", "claude-sonnet-4.6").replace("claude-sonnet-4-5", "claude-sonnet-4.5").replace("claude-haiku-4-5", "claude-haiku-4.5").replace("claude-sonnet-4", "claude-sonnet-4").replace(/gemini-3-pro(?!-)/g, "gemini-3-pro-preview").replace(/gemini-3-flash(?!-)/g, "gemini-3-flash-preview");
+    return model.replace("claude-opus-4-6", "claude-opus-4.6").replace("claude-sonnet-4-6", "claude-sonnet-4.6").replace("claude-sonnet-4-5", "claude-sonnet-4.5").replace("claude-haiku-4-5", "claude-haiku-4.5").replace("claude-sonnet-4", "claude-sonnet-4").replace(/gemini-3\.1-pro(?!-)/g, "gemini-3.1-pro-preview").replace(/gemini-3-flash(?!-)/g, "gemini-3-flash-preview");
   }
   if (provider === "google") {
-    return model.replace(/gemini-3-pro(?!-)/g, "gemini-3-pro-preview").replace(/gemini-3-flash(?!-)/g, "gemini-3-flash-preview");
+    return model.replace(/gemini-3\.1-pro(?!-)/g, "gemini-3.1-pro-preview").replace(/gemini-3-flash(?!-)/g, "gemini-3-flash-preview");
   }
   return model;
 }
@@ -18012,8 +18032,10 @@ function isAnyProviderConnected(providers, availableModels) {
 }
 // src/features/hook-message-injector/injector.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync, writeFileSync as writeFileSync4 } from "fs";
+import { randomBytes } from "crypto";
 import { join as join12 } from "path";
 init_logger();
+var processPrefix = randomBytes(4).toString("hex");
 function convertSDKMessageToStoredMessage(msg) {
   const info = msg.info;
   if (!info)
@@ -18545,6 +18567,42 @@ async function enforceMainPaneWidth(mainPaneId, windowWidth, mainPaneSizeOrOptio
 }
 // src/shared/model-suggestion-retry.ts
 init_logger();
+
+// src/shared/prompt-timeout-context.ts
+var PROMPT_TIMEOUT_MS = 120000;
+function createPromptTimeoutContext(args, timeoutMs) {
+  const timeoutController = new AbortController;
+  let timeoutID = null;
+  let timedOut = false;
+  const abortOnUpstreamSignal = () => {
+    timeoutController.abort(args.signal?.reason);
+  };
+  if (args.signal) {
+    if (args.signal.aborted) {
+      timeoutController.abort(args.signal.reason);
+    } else {
+      args.signal.addEventListener("abort", abortOnUpstreamSignal, { once: true });
+    }
+  }
+  timeoutID = setTimeout(() => {
+    timedOut = true;
+    timeoutController.abort(new Error(`prompt timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  return {
+    signal: timeoutController.signal,
+    wasTimedOut: () => timedOut,
+    cleanup: () => {
+      if (timeoutID !== null) {
+        clearTimeout(timeoutID);
+      }
+      if (args.signal) {
+        args.signal.removeEventListener("abort", abortOnUpstreamSignal);
+      }
+    }
+  };
+}
+
+// src/shared/model-suggestion-retry.ts
 function extractMessage(error) {
   if (typeof error === "string")
     return error;
@@ -18602,24 +18660,47 @@ function parseModelSuggestion(error) {
   }
   return null;
 }
-async function promptWithModelSuggestionRetry(client, args) {
-  const promptPromise = client.session.promptAsync(args);
-  let timeoutID = null;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutID = setTimeout(() => {
-      reject(new Error("promptAsync timed out after 120000ms"));
-    }, 120000);
+async function promptWithModelSuggestionRetry(client, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? PROMPT_TIMEOUT_MS;
+  const timeoutContext = createPromptTimeoutContext(args, timeoutMs);
+  const promptPromise = client.session.promptAsync({
+    ...args,
+    signal: timeoutContext.signal
   });
   try {
-    await Promise.race([promptPromise, timeoutPromise]);
+    await promptPromise;
+    if (timeoutContext.wasTimedOut()) {
+      throw new Error(`promptAsync timed out after ${timeoutMs}ms`);
+    }
+  } catch (error) {
+    if (timeoutContext.wasTimedOut()) {
+      throw new Error(`promptAsync timed out after ${timeoutMs}ms`);
+    }
+    throw error;
   } finally {
-    if (timeoutID !== null)
-      clearTimeout(timeoutID);
+    timeoutContext.cleanup();
   }
 }
-async function promptSyncWithModelSuggestionRetry(client, args) {
+async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? PROMPT_TIMEOUT_MS;
   try {
-    await client.session.prompt(args);
+    const timeoutContext = createPromptTimeoutContext(args, timeoutMs);
+    try {
+      await client.session.prompt({
+        ...args,
+        signal: timeoutContext.signal
+      });
+      if (timeoutContext.wasTimedOut()) {
+        throw new Error(`prompt timed out after ${timeoutMs}ms`);
+      }
+    } catch (error) {
+      if (timeoutContext.wasTimedOut()) {
+        throw new Error(`prompt timed out after ${timeoutMs}ms`);
+      }
+      throw error;
+    } finally {
+      timeoutContext.cleanup();
+    }
   } catch (error) {
     const suggestion = parseModelSuggestion(error);
     if (!suggestion || !args.body.model) {
@@ -18629,7 +18710,7 @@ async function promptSyncWithModelSuggestionRetry(client, args) {
       original: `${suggestion.providerID}/${suggestion.modelID}`,
       suggested: suggestion.suggestion
     });
-    await client.session.prompt({
+    const retryArgs = {
       ...args,
       body: {
         ...args.body,
@@ -18638,7 +18719,24 @@ async function promptSyncWithModelSuggestionRetry(client, args) {
           modelID: suggestion.suggestion
         }
       }
-    });
+    };
+    const timeoutContext = createPromptTimeoutContext(retryArgs, timeoutMs);
+    try {
+      await client.session.prompt({
+        ...retryArgs,
+        signal: timeoutContext.signal
+      });
+      if (timeoutContext.wasTimedOut()) {
+        throw new Error(`prompt timed out after ${timeoutMs}ms`);
+      }
+    } catch (retryError) {
+      if (timeoutContext.wasTimedOut()) {
+        throw new Error(`prompt timed out after ${timeoutMs}ms`);
+      }
+      throw retryError;
+    } finally {
+      timeoutContext.cleanup();
+    }
   }
 }
 // src/shared/opencode-server-auth.ts
@@ -19159,9 +19257,31 @@ function isLastAssistantMessageAborted(messages) {
   return errorName === "MessageAbortedError" || errorName === "AbortError";
 }
 
+// src/hooks/todo-continuation-enforcer/pending-question-detection.ts
+init_logger();
+function hasUnansweredQuestion(messages) {
+  if (!messages || messages.length === 0)
+    return false;
+  for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+    const msg = messages[i2];
+    const role = msg.info?.role ?? msg.role;
+    if (role === "user")
+      return false;
+    if (role === "assistant" && msg.parts) {
+      const hasQuestion = msg.parts.some((part) => (part.type === "tool_use" || part.type === "tool-invocation") && (part.name === "question" || part.toolName === "question"));
+      if (hasQuestion) {
+        log(`[${HOOK_NAME}] Detected pending question tool in last assistant message`);
+        return true;
+      }
+      return false;
+    }
+  }
+  return false;
+}
+
 // src/hooks/todo-continuation-enforcer/todo.ts
 function getIncompleteCount(todos) {
-  return todos.filter((todo) => todo.status !== "completed" && todo.status !== "cancelled").length;
+  return todos.filter((todo) => todo.status !== "completed" && todo.status !== "cancelled" && todo.status !== "blocked" && todo.status !== "deleted").length;
 }
 
 // src/hooks/todo-continuation-enforcer/countdown.ts
@@ -19377,6 +19497,10 @@ async function handleSessionIdle(args) {
       log(`[${HOOK_NAME}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
       return;
     }
+    if (hasUnansweredQuestion(messages)) {
+      log(`[${HOOK_NAME}] Skipped: pending question awaiting user response`, { sessionID });
+      return;
+    }
   } catch (error) {
     log(`[${HOOK_NAME}] Messages fetch failed, continuing`, { sessionID, error: String(error) });
   }
@@ -20103,6 +20227,7 @@ function createSessionNotification(ctx, config = {}) {
     idleConfirmationDelay: 1500,
     skipIfIncompleteTodos: true,
     maxTrackedSessions: 100,
+    enforceMainSessionFilter: true,
     ...config
   };
   const scheduler = createIdleNotificationScheduler({
@@ -20135,9 +20260,11 @@ function createSessionNotification(ctx, config = {}) {
   const shouldNotifyForSession = (sessionID) => {
     if (subagentSessions.has(sessionID))
       return false;
-    const mainSessionID = getMainSessionID();
-    if (mainSessionID && sessionID !== mainSessionID)
-      return false;
+    if (mergedConfig.enforceMainSessionFilter) {
+      const mainSessionID = getMainSessionID();
+      if (mainSessionID && sessionID !== mainSessionID)
+        return false;
+    }
     return true;
   };
   const getEventToolName = (properties) => {
@@ -34526,7 +34653,7 @@ var TRUNCATE_CONFIG = {
 function getOrCreateRetryState(autoCompactState, sessionID) {
   let state2 = autoCompactState.retryStateBySession.get(sessionID);
   if (!state2) {
-    state2 = { attempt: 0, lastAttemptTime: 0 };
+    state2 = { attempt: 0, lastAttemptTime: 0, firstAttemptTime: 0 };
     autoCompactState.retryStateBySession.set(sessionID, state2);
   }
   return state2;
@@ -35222,8 +35349,26 @@ function resolveCompactionModel(pluginConfig, sessionID, originalProviderID, ori
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/summarize-retry-strategy.ts
+var SUMMARIZE_RETRY_TOTAL_TIMEOUT_MS = 120000;
 async function runSummarizeRetryStrategy(params) {
   const retryState = getOrCreateRetryState(params.autoCompactState, params.sessionID);
+  const now = Date.now();
+  if (retryState.firstAttemptTime === 0) {
+    retryState.firstAttemptTime = now;
+  }
+  const elapsedTimeMs = now - retryState.firstAttemptTime;
+  if (elapsedTimeMs >= SUMMARIZE_RETRY_TOTAL_TIMEOUT_MS) {
+    clearSessionState(params.autoCompactState, params.sessionID);
+    await params.client.tui.showToast({
+      body: {
+        title: "Auto Compact Timed Out",
+        message: "Compaction retries exceeded the timeout window. Please start a new session.",
+        variant: "error",
+        duration: 5000
+      }
+    }).catch(() => {});
+    return;
+  }
   if (params.errorType?.includes("non-empty content")) {
     const attempt = getEmptyContentAttempt(params.autoCompactState, params.sessionID);
     if (attempt < 3) {
@@ -35253,6 +35398,7 @@ async function runSummarizeRetryStrategy(params) {
   }
   if (Date.now() - retryState.lastAttemptTime > 300000) {
     retryState.attempt = 0;
+    retryState.firstAttemptTime = Date.now();
     params.autoCompactState.truncateStateBySession.delete(params.sessionID);
   }
   if (retryState.attempt < RETRY_CONFIG.maxAttempts) {
@@ -35280,8 +35426,21 @@ async function runSummarizeRetryStrategy(params) {
         });
         return;
       } catch {
+        const remainingTimeMs = SUMMARIZE_RETRY_TOTAL_TIMEOUT_MS - (Date.now() - retryState.firstAttemptTime);
+        if (remainingTimeMs <= 0) {
+          clearSessionState(params.autoCompactState, params.sessionID);
+          await params.client.tui.showToast({
+            body: {
+              title: "Auto Compact Timed Out",
+              message: "Compaction retries exceeded the timeout window. Please start a new session.",
+              variant: "error",
+              duration: 5000
+            }
+          }).catch(() => {});
+          return;
+        }
         const delay3 = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, retryState.attempt - 1);
-        const cappedDelay = Math.min(delay3, RETRY_CONFIG.maxDelayMs);
+        const cappedDelay = Math.min(delay3, RETRY_CONFIG.maxDelayMs, remainingTimeMs);
         setTimeout(() => {
           runSummarizeRetryStrategy(params);
         }, cappedDelay);
@@ -35877,24 +36036,11 @@ function extractModelPrefix(modelID) {
 function normalizeModelID(modelID) {
   return modelID.replace(/\.(\d+)/g, "-$1");
 }
-function resolveProvider(providerID, modelID) {
-  if (providerID === "github-copilot") {
-    const modelLower = modelID.toLowerCase();
-    if (modelLower.includes("claude"))
-      return "anthropic";
-    if (modelLower.includes("gemini"))
-      return "google";
-    if (modelLower.includes("gpt") || modelLower.includes("o1") || modelLower.includes("o3")) {
-      return "openai";
-    }
-  }
-  return providerID;
-}
 var HIGH_VARIANT_MAP = {
   "claude-sonnet-4-6": "claude-sonnet-4-6-high",
   "claude-opus-4-6": "claude-opus-4-6-high",
-  "gemini-3-pro": "gemini-3-pro-high",
-  "gemini-3-pro-low": "gemini-3-pro-high",
+  "gemini-3-1-pro": "gemini-3-1-pro-high",
+  "gemini-3-1-pro-low": "gemini-3-1-pro-high",
   "gemini-3-flash": "gemini-3-flash-high",
   "gpt-5": "gpt-5-high",
   "gpt-5-mini": "gpt-5-mini-high",
@@ -35909,74 +36055,10 @@ var HIGH_VARIANT_MAP = {
   "gpt-5-2": "gpt-5-2-high",
   "gpt-5-2-chat-latest": "gpt-5-2-chat-latest-high",
   "gpt-5-2-pro": "gpt-5-2-pro-high",
-  "antigravity-gemini-3-pro": "antigravity-gemini-3-pro-high",
+  "antigravity-gemini-3-1-pro": "antigravity-gemini-3-1-pro-high",
   "antigravity-gemini-3-flash": "antigravity-gemini-3-flash-high"
 };
 var ALREADY_HIGH = new Set(Object.values(HIGH_VARIANT_MAP));
-var THINKING_CONFIGS = {
-  anthropic: {
-    thinking: {
-      type: "enabled",
-      budgetTokens: 64000
-    },
-    maxTokens: 128000
-  },
-  "google-vertex-anthropic": {
-    thinking: {
-      type: "enabled",
-      budgetTokens: 64000
-    },
-    maxTokens: 128000
-  },
-  "amazon-bedrock": {
-    reasoningConfig: {
-      type: "enabled",
-      budgetTokens: 32000
-    },
-    maxTokens: 64000
-  },
-  google: {
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          thinkingLevel: "HIGH"
-        }
-      }
-    }
-  },
-  "google-vertex": {
-    providerOptions: {
-      "google-vertex": {
-        thinkingConfig: {
-          thinkingLevel: "HIGH"
-        }
-      }
-    }
-  },
-  openai: {
-    reasoning_effort: "high"
-  },
-  "zai-coding-plan": {
-    providerOptions: {
-      "zai-coding-plan": {
-        extra_body: {
-          thinking: {
-            type: "disabled"
-          }
-        }
-      }
-    }
-  }
-};
-var THINKING_CAPABLE_MODELS = {
-  anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
-  "google-vertex-anthropic": ["claude-sonnet-4", "claude-opus-4", "claude-3"],
-  "amazon-bedrock": ["claude", "anthropic"],
-  google: ["gemini-2", "gemini-3"],
-  "google-vertex": ["gemini-2", "gemini-3"],
-  openai: ["gpt-5", "o1", "o3"],
-  "zai-coding-plan": ["glm"]
-};
 function getHighVariant(modelID) {
   const normalized = normalizeModelID(modelID);
   const { prefix, base } = extractModelPrefix(normalized);
@@ -35994,65 +36076,28 @@ function isAlreadyHighVariant(modelID) {
   const { base } = extractModelPrefix(normalized);
   return ALREADY_HIGH.has(base) || base.endsWith("-high");
 }
-function isThinkingProvider(provider) {
-  return provider in THINKING_CONFIGS;
-}
-function getThinkingConfig(providerID, modelID) {
-  const normalized = normalizeModelID(modelID);
-  const { base } = extractModelPrefix(normalized);
-  if (isAlreadyHighVariant(normalized)) {
-    return null;
-  }
-  const resolvedProvider = resolveProvider(providerID, modelID);
-  if (!isThinkingProvider(resolvedProvider)) {
-    return null;
-  }
-  const config2 = THINKING_CONFIGS[resolvedProvider];
-  const capablePatterns = THINKING_CAPABLE_MODELS[resolvedProvider];
-  const baseLower = base.toLowerCase();
-  const isCapable = capablePatterns.some((pattern) => baseLower.includes(pattern.toLowerCase()));
-  return isCapable ? config2 : null;
-}
 // src/hooks/think-mode/hook.ts
 var thinkModeState = new Map;
 function createThinkModeHook() {
-  function isDisabledThinkingConfig(config2) {
-    const thinkingConfig = config2.thinking;
-    if (typeof thinkingConfig === "object" && thinkingConfig !== null && "type" in thinkingConfig && thinkingConfig.type === "disabled") {
-      return true;
-    }
-    const providerOptions = config2.providerOptions;
-    if (typeof providerOptions !== "object" || providerOptions === null) {
-      return false;
-    }
-    return Object.values(providerOptions).some((providerConfig) => {
-      if (typeof providerConfig !== "object" || providerConfig === null) {
-        return false;
-      }
-      const providerConfigMap = providerConfig;
-      const extraBody = providerConfigMap.extra_body;
-      if (typeof extraBody !== "object" || extraBody === null) {
-        return false;
-      }
-      const extraBodyMap = extraBody;
-      const extraThinking = extraBodyMap.thinking;
-      return typeof extraThinking === "object" && extraThinking !== null && extraThinking.type === "disabled";
-    });
-  }
   return {
-    "chat.params": async (output, sessionID) => {
+    "chat.message": async (input, output) => {
       const promptText = extractPromptText(output.parts);
+      const sessionID = input.sessionID;
       const state3 = {
         requested: false,
         modelSwitched: false,
-        thinkingConfigInjected: false
+        variantSet: false
       };
       if (!detectThinkKeyword(promptText)) {
         thinkModeState.set(sessionID, state3);
         return;
       }
       state3.requested = true;
-      const currentModel = output.message.model;
+      if (typeof output.message.variant === "string") {
+        thinkModeState.set(sessionID, state3);
+        return;
+      }
+      const currentModel = input.model;
       if (!currentModel) {
         thinkModeState.set(sessionID, state3);
         return;
@@ -36064,50 +36109,20 @@ function createThinkModeHook() {
         return;
       }
       const highVariant = getHighVariant(currentModel.modelID);
-      const thinkingConfig = getThinkingConfig(currentModel.providerID, currentModel.modelID);
       if (highVariant) {
         output.message.model = {
           providerID: currentModel.providerID,
           modelID: highVariant
         };
+        output.message.variant = "high";
         state3.modelSwitched = true;
+        state3.variantSet = true;
         log("Think mode: model switched to high variant", {
           sessionID,
           from: currentModel.modelID,
           to: highVariant
         });
       }
-      if (thinkingConfig) {
-        const messageData = output.message;
-        const agentThinking = messageData.thinking;
-        const agentProviderOptions = messageData.providerOptions;
-        const agentDisabledThinking = agentThinking?.type === "disabled";
-        const agentHasCustomProviderOptions = Boolean(agentProviderOptions);
-        if (agentDisabledThinking) {
-          log("Think mode: skipping - agent has thinking disabled", {
-            sessionID,
-            provider: currentModel.providerID
-          });
-        } else if (agentHasCustomProviderOptions) {
-          log("Think mode: skipping - agent has custom providerOptions", {
-            sessionID,
-            provider: currentModel.providerID
-          });
-        } else if (!isDisabledThinkingConfig(thinkingConfig)) {
-          Object.assign(output.message, thinkingConfig);
-          state3.thinkingConfigInjected = true;
-          log("Think mode: thinking config injected", {
-            sessionID,
-            provider: currentModel.providerID,
-            config: thinkingConfig
-          });
-        } else {
-          log("Think mode: skipping disabled thinking config", {
-            sessionID,
-            provider: currentModel.providerID
-          });
-        }
-      }
       thinkModeState.set(sessionID, state3);
     },
     event: async ({ event }) => {
@@ -36652,6 +36667,76 @@ function isHookCommandDisabled(eventType, command, config2) {
   });
 }
 
+// src/hooks/claude-code-hooks/execute-http-hook.ts
+var DEFAULT_HTTP_HOOK_TIMEOUT_S = 30;
+var ALLOWED_SCHEMES = new Set(["http:", "https:"]);
+function interpolateEnvVars(value, allowedEnvVars) {
+  const allowedSet = new Set(allowedEnvVars);
+  return value.replace(/\$\{(\w+)\}|\$(\w+)/g, (_match, bracedVar, bareVar) => {
+    const varName = bracedVar ?? bareVar;
+    if (allowedSet.has(varName)) {
+      return process.env[varName] ?? "";
+    }
+    return "";
+  });
+}
+function resolveHeaders(hook) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (!hook.headers)
+    return headers;
+  const allowedEnvVars = hook.allowedEnvVars ?? [];
+  for (const [key, value] of Object.entries(hook.headers)) {
+    headers[key] = interpolateEnvVars(value, allowedEnvVars);
+  }
+  return headers;
+}
+async function executeHttpHook(hook, stdin) {
+  try {
+    const parsed = new URL(hook.url);
+    if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+      return {
+        exitCode: 1,
+        stderr: `HTTP hook URL scheme "${parsed.protocol}" is not allowed. Only http: and https: are permitted.`
+      };
+    }
+  } catch {
+    return { exitCode: 1, stderr: `HTTP hook URL is invalid: ${hook.url}` };
+  }
+  const timeoutS = hook.timeout ?? DEFAULT_HTTP_HOOK_TIMEOUT_S;
+  const headers = resolveHeaders(hook);
+  try {
+    const response = await fetch(hook.url, {
+      method: "POST",
+      headers,
+      body: stdin,
+      signal: AbortSignal.timeout(timeoutS * 1000)
+    });
+    if (!response.ok) {
+      return {
+        exitCode: 1,
+        stderr: `HTTP hook returned status ${response.status}: ${response.statusText}`,
+        stdout: await response.text().catch(() => "")
+      };
+    }
+    const body = await response.text();
+    if (!body) {
+      return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed.exitCode === "number") {
+        return { exitCode: parsed.exitCode, stdout: body, stderr: "" };
+      }
+    } catch {}
+    return { exitCode: 0, stdout: body, stderr: "" };
+  } catch (error45) {
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    return { exitCode: 1, stderr: `HTTP hook error: ${message}` };
+  }
+}
+
 // src/hooks/claude-code-hooks/plugin-config.ts
 var isWindows = process.platform === "win32";
 var DEFAULT_CONFIG = {
@@ -36659,6 +36744,19 @@ var DEFAULT_CONFIG = {
   zshPath: "/bin/zsh"
 };
 
+// src/hooks/claude-code-hooks/dispatch-hook.ts
+function getHookIdentifier(hook) {
+  if (hook.type === "http")
+    return hook.url;
+  return hook.command.split("/").pop() || hook.command;
+}
+async function dispatchHook(hook, stdinJson, cwd) {
+  if (hook.type === "http") {
+    return executeHttpHook(hook, stdinJson);
+  }
+  return executeHookCommand(hook.command, stdinJson, cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+}
+
 // src/hooks/claude-code-hooks/user-prompt-submit.ts
 var USER_PROMPT_SUBMIT_TAG_OPEN = "<user-prompt-submit-hook>";
 var USER_PROMPT_SUBMIT_TAG_CLOSE = "</user-prompt-submit-hook>";
@@ -36693,13 +36791,14 @@ async function executeUserPromptSubmitHooks(ctx, config2, extendedConfig) {
     if (!matcher.hooks || matcher.hooks.length === 0)
       continue;
     for (const hook of matcher.hooks) {
-      if (hook.type !== "command")
+      if (hook.type !== "command" && hook.type !== "http")
         continue;
-      if (isHookCommandDisabled("UserPromptSubmit", hook.command, extendedConfig ?? null)) {
-        log("UserPromptSubmit hook command skipped (disabled by config)", { command: hook.command });
+      const hookName = getHookIdentifier(hook);
+      if (isHookCommandDisabled("UserPromptSubmit", hookName, extendedConfig ?? null)) {
+        log("UserPromptSubmit hook command skipped (disabled by config)", { command: hookName });
         continue;
       }
-      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd);
       if (result.stdout) {
         const output = result.stdout.trim();
         if (output.startsWith(USER_PROMPT_SUBMIT_TAG_OPEN)) {
@@ -36976,16 +37075,16 @@ async function executePreCompactHooks(ctx, config2, extendedConfig) {
     if (!matcher.hooks || matcher.hooks.length === 0)
       continue;
     for (const hook of matcher.hooks) {
-      if (hook.type !== "command")
+      if (hook.type !== "command" && hook.type !== "http")
         continue;
-      if (isHookCommandDisabled("PreCompact", hook.command, extendedConfig ?? null)) {
-        log("PreCompact hook command skipped (disabled by config)", { command: hook.command });
+      const hookName = getHookIdentifier(hook);
+      if (isHookCommandDisabled("PreCompact", hookName, extendedConfig ?? null)) {
+        log("PreCompact hook command skipped (disabled by config)", { command: hookName });
         continue;
       }
-      const hookName = hook.command.split("/").pop() || hook.command;
       if (!firstHookName)
         firstHookName = hookName;
-      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd);
       if (result.exitCode === 2) {
         log("PreCompact hook blocked", { hookName, stderr: result.stderr });
         continue;
@@ -37083,13 +37182,14 @@ async function executeStopHooks(ctx, config2, extendedConfig) {
     if (!matcher.hooks || matcher.hooks.length === 0)
       continue;
     for (const hook of matcher.hooks) {
-      if (hook.type !== "command")
+      if (hook.type !== "command" && hook.type !== "http")
         continue;
-      if (isHookCommandDisabled("Stop", hook.command, extendedConfig ?? null)) {
-        log("Stop hook command skipped (disabled by config)", { command: hook.command });
+      const hookName = getHookIdentifier(hook);
+      if (isHookCommandDisabled("Stop", hookName, extendedConfig ?? null)) {
+        log("Stop hook command skipped (disabled by config)", { command: hookName });
         continue;
       }
-      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd);
       if (result.exitCode === 2) {
         const reason = result.stderr || result.stdout || "Blocked by stop hook";
         return {
@@ -37238,16 +37338,16 @@ async function executePostToolUseHooks(ctx, config2, extendedConfig) {
       if (!matcher.hooks || matcher.hooks.length === 0)
         continue;
       for (const hook of matcher.hooks) {
-        if (hook.type !== "command")
+        if (hook.type !== "command" && hook.type !== "http")
           continue;
-        if (isHookCommandDisabled("PostToolUse", hook.command, extendedConfig ?? null)) {
-          log("PostToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName });
+        const hookName = getHookIdentifier(hook);
+        if (isHookCommandDisabled("PostToolUse", hookName, extendedConfig ?? null)) {
+          log("PostToolUse hook command skipped (disabled by config)", { command: hookName, toolName: ctx.toolName });
           continue;
         }
-        const hookName = hook.command.split("/").pop() || hook.command;
         if (!firstHookName)
           firstHookName = hookName;
-        const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+        const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd);
         if (result.stdout) {
           messages.push(result.stdout);
         }
@@ -37475,16 +37575,16 @@ async function executePreToolUseHooks(ctx, config2, extendedConfig) {
     if (!matcher.hooks || matcher.hooks.length === 0)
       continue;
     for (const hook of matcher.hooks) {
-      if (hook.type !== "command")
+      if (hook.type !== "command" && hook.type !== "http")
         continue;
-      if (isHookCommandDisabled("PreToolUse", hook.command, extendedConfig ?? null)) {
-        log("PreToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName });
+      const hookName = getHookIdentifier(hook);
+      if (isHookCommandDisabled("PreToolUse", hookName, extendedConfig ?? null)) {
+        log("PreToolUse hook command skipped (disabled by config)", { command: hookName, toolName: ctx.toolName });
         continue;
       }
-      const hookName = hook.command.split("/").pop() || hook.command;
       if (!firstHookName)
         firstHookName = hookName;
-      const result = await executeHookCommand(hook.command, JSON.stringify(stdinData), ctx.cwd, { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath });
+      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd);
       if (result.exitCode === 2) {
         return {
           decision: "deny",
@@ -38165,7 +38265,11 @@ function createBackgroundNotificationHook(manager) {
   const eventHandler = async ({ event }) => {
     manager.handleEvent(event);
   };
+  const chatMessageHandler = async (input, output) => {
+    manager.injectPendingNotificationsIntoChatMessage(output, input.sessionID);
+  };
   return {
+    "chat.message": chatMessageHandler,
     event: eventHandler
   };
 }
@@ -38481,6 +38585,64 @@ function getConfigContext() {
 function getConfigDir() {
   return getConfigContext().paths.configDir;
 }
+// src/shared/spawn-with-windows-hide.ts
+var {spawn: bunSpawn } = globalThis.Bun;
+import { spawn as nodeSpawn } from "child_process";
+import { Readable } from "stream";
+function toReadableStream(stream) {
+  if (!stream) {
+    return;
+  }
+  return Readable.toWeb(stream);
+}
+function wrapNodeProcess(proc) {
+  let resolveExited;
+  let exitCode = null;
+  const exited = new Promise((resolve5) => {
+    resolveExited = resolve5;
+  });
+  proc.on("exit", (code) => {
+    exitCode = code ?? 1;
+    resolveExited(exitCode);
+  });
+  proc.on("error", () => {
+    if (exitCode === null) {
+      exitCode = 1;
+      resolveExited(1);
+    }
+  });
+  return {
+    get exitCode() {
+      return exitCode;
+    },
+    exited,
+    stdout: toReadableStream(proc.stdout),
+    stderr: toReadableStream(proc.stderr),
+    kill(signal) {
+      try {
+        if (!signal) {
+          proc.kill();
+          return;
+        }
+        proc.kill(signal);
+      } catch {}
+    }
+  };
+}
+function spawnWithWindowsHide(command, options) {
+  if (process.platform !== "win32") {
+    return bunSpawn(command, options);
+  }
+  const [cmd, ...args] = command;
+  const proc = nodeSpawn(cmd, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [options.stdin ?? "pipe", options.stdout ?? "pipe", options.stderr ?? "pipe"],
+    windowsHide: true,
+    shell: true
+  });
+  return wrapNodeProcess(proc);
+}
 // src/cli/config-manager/bun-install.ts
 var BUN_INSTALL_TIMEOUT_SECONDS = 60;
 var BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000;
@@ -38490,7 +38652,7 @@ async function runBunInstall() {
 }
 async function runBunInstallWithDetails() {
   try {
-    const proc = Bun.spawn(["bun", "install"], {
+    const proc = spawnWithWindowsHide(["bun", "install"], {
       cwd: getConfigDir(),
       stdout: "inherit",
       stderr: "inherit"
@@ -38932,6 +39094,16 @@ function clearAgentUsageState(sessionID) {
 }
 
 // src/hooks/agent-usage-reminder/hook.ts
+var ORCHESTRATOR_AGENTS = new Set([
+  "sisyphus",
+  "sisyphus-junior",
+  "atlas",
+  "hephaestus",
+  "prometheus"
+]);
+function isOrchestratorAgent(agentName) {
+  return ORCHESTRATOR_AGENTS.has(getAgentConfigKey(agentName));
+}
 function createAgentUsageReminderHook(_ctx) {
   const sessionStates = new Map;
   function getOrCreateState(sessionID) {
@@ -38959,6 +39131,10 @@ function createAgentUsageReminderHook(_ctx) {
   }
   const toolExecuteAfter = async (input, output) => {
     const { tool, sessionID } = input;
+    const agent = getSessionAgent(sessionID);
+    if (agent && !isOrchestratorAgent(agent)) {
+      return;
+    }
     const toolLower = tool.toLowerCase();
     if (AGENT_TOOLS.has(toolLower)) {
       markAgentUsed(sessionID);
@@ -39000,12 +39176,9 @@ function createAgentUsageReminderHook(_ctx) {
 function extractModelName(model) {
   return model.includes("/") ? model.split("/").pop() ?? model : model;
 }
-var GPT_MODEL_PREFIXES = ["gpt-", "gpt4", "o1", "o3", "o4"];
 function isGptModel(model) {
-  if (model.startsWith("openai/") || model.startsWith("github-copilot/gpt-"))
-    return true;
   const modelName = extractModelName(model).toLowerCase();
-  return GPT_MODEL_PREFIXES.some((prefix) => modelName.startsWith(prefix));
+  return modelName.includes("gpt");
 }
 var GEMINI_PROVIDERS = ["google/", "google-vertex/"];
 function isGeminiModel(model) {
@@ -40241,7 +40414,7 @@ function isOmoSession(sessionName) {
 async function killAllTrackedSessions(state3) {
   for (const sessionName of state3.tmuxSessions) {
     try {
-      const proc = Bun.spawn(["tmux", "kill-session", "-t", sessionName], {
+      const proc = spawnWithWindowsHide(["tmux", "kill-session", "-t", sessionName], {
         stdout: "ignore",
         stderr: "ignore"
       });
@@ -40561,6 +40734,7 @@ function readState(directory, customPath) {
       active: isActive,
       iteration: iterationNum,
       max_iterations: Number(data.max_iterations) || DEFAULT_MAX_ITERATIONS,
+      message_count_at_start: typeof data.message_count_at_start === "number" ? data.message_count_at_start : typeof data.message_count_at_start === "string" && data.message_count_at_start.trim() !== "" ? Number(data.message_count_at_start) : undefined,
       completion_promise: stripQuotes(data.completion_promise) || DEFAULT_COMPLETION_PROMISE,
       started_at: stripQuotes(data.started_at) || new Date().toISOString(),
       prompt: body.trim(),
@@ -40584,6 +40758,8 @@ function writeState(directory, state3, customPath) {
     const ultraworkLine = state3.ultrawork !== undefined ? `ultrawork: ${state3.ultrawork}
 ` : "";
     const strategyLine = state3.strategy ? `strategy: "${state3.strategy}"
+` : "";
+    const messageCountAtStartLine = typeof state3.message_count_at_start === "number" ? `message_count_at_start: ${state3.message_count_at_start}
 ` : "";
     const content = `---
 active: ${state3.active}
@@ -40591,7 +40767,7 @@ iteration: ${state3.iteration}
 max_iterations: ${state3.max_iterations}
 completion_promise: "${state3.completion_promise}"
 started_at: "${state3.started_at}"
-${sessionIdLine}${ultraworkLine}${strategyLine}---
+${sessionIdLine}${ultraworkLine}${strategyLine}${messageCountAtStartLine}---
 ${state3.prompt}
 `;
     writeFileSync16(filePath, content, "utf-8");
@@ -40662,6 +40838,7 @@ function createLoopStateController(options) {
         active: true,
         iteration: 1,
         max_iterations: loopOptions?.maxIterations ?? config2?.default_max_iterations ?? DEFAULT_MAX_ITERATIONS,
+        message_count_at_start: loopOptions?.messageCountAtStart,
         completion_promise: loopOptions?.completionPromise ?? DEFAULT_COMPLETION_PROMISE,
         ultrawork: loopOptions?.ultrawork,
         strategy: loopOptions?.strategy ?? config2?.default_strategy ?? "continue",
@@ -40709,6 +40886,17 @@ function createLoopStateController(options) {
         return null;
       }
       return state3;
+    },
+    setMessageCountAtStart(sessionID, messageCountAtStart) {
+      const state3 = readState(directory, stateDir);
+      if (!state3 || state3.session_id !== sessionID) {
+        return null;
+      }
+      state3.message_count_at_start = messageCountAtStart;
+      if (!writeState(directory, state3, stateDir)) {
+        return null;
+      }
+      return state3;
     }
   };
 }
@@ -40779,12 +40967,13 @@ async function detectCompletionInSessionMessages(ctx, options) {
     const messagesResponse = response;
     const responseData = typeof messagesResponse === "object" && messagesResponse !== null && "data" in messagesResponse ? messagesResponse.data : undefined;
     const messageArray = Array.isArray(messagesResponse) ? messagesResponse : Array.isArray(responseData) ? responseData : [];
-    const assistantMessages = messageArray.filter((msg) => msg.info?.role === "assistant");
+    const scopedMessages = typeof options.sinceMessageIndex === "number" && options.sinceMessageIndex >= 0 && options.sinceMessageIndex < messageArray.length ? messageArray.slice(options.sinceMessageIndex) : messageArray;
+    const assistantMessages = scopedMessages.filter((msg) => msg.info?.role === "assistant");
     if (assistantMessages.length === 0)
       return false;
     const pattern = buildPromisePattern(options.promise);
-    const recentAssistants = assistantMessages.slice(-3);
-    for (const assistant of recentAssistants) {
+    for (let index = assistantMessages.length - 1;index >= 0; index -= 1) {
+      const assistant = assistantMessages[index];
       if (!assistant.parts)
         continue;
       let responseText = "";
@@ -40936,14 +41125,6 @@ async function continueIteration(ctx, state3, options) {
     if (!newSessionID) {
       return;
     }
-    const boundState = options.loopState.setSessionID(newSessionID);
-    if (!boundState) {
-      log(`[${HOOK_NAME3}] Failed to bind loop state to new session`, {
-        previousSessionID: options.previousSessionID,
-        newSessionID
-      });
-      return;
-    }
     await injectContinuationPrompt(ctx, {
       sessionID: newSessionID,
       inheritFromSessionID: options.previousSessionID,
@@ -40952,6 +41133,14 @@ async function continueIteration(ctx, state3, options) {
       apiTimeoutMs: options.apiTimeoutMs
     });
     await selectSessionInTui(ctx.client, newSessionID);
+    const boundState = options.loopState.setSessionID(newSessionID);
+    if (!boundState) {
+      log(`[${HOOK_NAME3}] Failed to bind loop state to new session`, {
+        previousSessionID: options.previousSessionID,
+        newSessionID
+      });
+      return;
+    }
     return;
   }
   await injectContinuationPrompt(ctx, {
@@ -40964,106 +41153,117 @@ async function continueIteration(ctx, state3, options) {
 
 // src/hooks/ralph-loop/ralph-loop-event-handler.ts
 function createRalphLoopEventHandler(ctx, options) {
+  const inFlightSessions = new Set;
   return async ({ event }) => {
     const props = event.properties;
     if (event.type === "session.idle") {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
-      if (options.sessionRecovery.isRecovering(sessionID)) {
-        log(`[${HOOK_NAME3}] Skipped: in recovery`, { sessionID });
-        return;
-      }
-      const state3 = options.loopState.getState();
-      if (!state3 || !state3.active) {
+      if (inFlightSessions.has(sessionID)) {
+        log(`[${HOOK_NAME3}] Skipped: handler in flight`, { sessionID });
         return;
       }
-      if (state3.session_id && state3.session_id !== sessionID) {
-        if (options.checkSessionExists) {
-          try {
-            const exists = await options.checkSessionExists(state3.session_id);
-            if (!exists) {
-              options.loopState.clear();
-              log(`[${HOOK_NAME3}] Cleared orphaned state from deleted session`, {
-                orphanedSessionId: state3.session_id,
-                currentSessionId: sessionID
+      inFlightSessions.add(sessionID);
+      try {
+        if (options.sessionRecovery.isRecovering(sessionID)) {
+          log(`[${HOOK_NAME3}] Skipped: in recovery`, { sessionID });
+          return;
+        }
+        const state3 = options.loopState.getState();
+        if (!state3 || !state3.active) {
+          return;
+        }
+        if (state3.session_id && state3.session_id !== sessionID) {
+          if (options.checkSessionExists) {
+            try {
+              const exists = await options.checkSessionExists(state3.session_id);
+              if (!exists) {
+                options.loopState.clear();
+                log(`[${HOOK_NAME3}] Cleared orphaned state from deleted session`, {
+                  orphanedSessionId: state3.session_id,
+                  currentSessionId: sessionID
+                });
+                return;
+              }
+            } catch (err) {
+              log(`[${HOOK_NAME3}] Failed to check session existence`, {
+                sessionId: state3.session_id,
+                error: String(err)
               });
-              return;
             }
-          } catch (err) {
-            log(`[${HOOK_NAME3}] Failed to check session existence`, {
-              sessionId: state3.session_id,
-              error: String(err)
-            });
           }
+          return;
         }
-        return;
-      }
-      const transcriptPath = options.getTranscriptPath(sessionID);
-      const completionViaTranscript = detectCompletionInTranscript(transcriptPath, state3.completion_promise);
-      const completionViaApi = completionViaTranscript ? false : await detectCompletionInSessionMessages(ctx, {
-        sessionID,
-        promise: state3.completion_promise,
-        apiTimeoutMs: options.apiTimeoutMs,
-        directory: options.directory
-      });
-      if (completionViaTranscript || completionViaApi) {
-        log(`[${HOOK_NAME3}] Completion detected!`, {
+        const transcriptPath = options.getTranscriptPath(sessionID);
+        const completionViaTranscript = detectCompletionInTranscript(transcriptPath, state3.completion_promise);
+        const completionViaApi = completionViaTranscript ? false : await detectCompletionInSessionMessages(ctx, {
           sessionID,
-          iteration: state3.iteration,
           promise: state3.completion_promise,
-          detectedVia: completionViaTranscript ? "transcript_file" : "session_messages_api"
+          apiTimeoutMs: options.apiTimeoutMs,
+          directory: options.directory,
+          sinceMessageIndex: state3.message_count_at_start
         });
-        options.loopState.clear();
-        const title = state3.ultrawork ? "ULTRAWORK LOOP COMPLETE!" : "Ralph Loop Complete!";
-        const message = state3.ultrawork ? `JUST ULW ULW! Task completed after ${state3.iteration} iteration(s)` : `Task completed after ${state3.iteration} iteration(s)`;
-        await ctx.client.tui?.showToast?.({ body: { title, message, variant: "success", duration: 5000 } }).catch(() => {});
-        return;
-      }
-      if (state3.iteration >= state3.max_iterations) {
-        log(`[${HOOK_NAME3}] Max iterations reached`, {
+        if (completionViaTranscript || completionViaApi) {
+          log(`[${HOOK_NAME3}] Completion detected!`, {
+            sessionID,
+            iteration: state3.iteration,
+            promise: state3.completion_promise,
+            detectedVia: completionViaTranscript ? "transcript_file" : "session_messages_api"
+          });
+          options.loopState.clear();
+          const title = state3.ultrawork ? "ULTRAWORK LOOP COMPLETE!" : "Ralph Loop Complete!";
+          const message = state3.ultrawork ? `JUST ULW ULW! Task completed after ${state3.iteration} iteration(s)` : `Task completed after ${state3.iteration} iteration(s)`;
+          await ctx.client.tui?.showToast?.({ body: { title, message, variant: "success", duration: 5000 } }).catch(() => {});
+          return;
+        }
+        if (state3.iteration >= state3.max_iterations) {
+          log(`[${HOOK_NAME3}] Max iterations reached`, {
+            sessionID,
+            iteration: state3.iteration,
+            max: state3.max_iterations
+          });
+          options.loopState.clear();
+          await ctx.client.tui?.showToast?.({
+            body: { title: "Ralph Loop Stopped", message: `Max iterations (${state3.max_iterations}) reached without completion`, variant: "warning", duration: 5000 }
+          }).catch(() => {});
+          return;
+        }
+        const newState = options.loopState.incrementIteration();
+        if (!newState) {
+          log(`[${HOOK_NAME3}] Failed to increment iteration`, { sessionID });
+          return;
+        }
+        log(`[${HOOK_NAME3}] Continuing loop`, {
           sessionID,
-          iteration: state3.iteration,
-          max: state3.max_iterations
+          iteration: newState.iteration,
+          max: newState.max_iterations
         });
-        options.loopState.clear();
         await ctx.client.tui?.showToast?.({
-          body: { title: "Ralph Loop Stopped", message: `Max iterations (${state3.max_iterations}) reached without completion`, variant: "warning", duration: 5000 }
+          body: {
+            title: "Ralph Loop",
+            message: `Iteration ${newState.iteration}/${newState.max_iterations}`,
+            variant: "info",
+            duration: 2000
+          }
         }).catch(() => {});
-        return;
-      }
-      const newState = options.loopState.incrementIteration();
-      if (!newState) {
-        log(`[${HOOK_NAME3}] Failed to increment iteration`, { sessionID });
-        return;
-      }
-      log(`[${HOOK_NAME3}] Continuing loop`, {
-        sessionID,
-        iteration: newState.iteration,
-        max: newState.max_iterations
-      });
-      await ctx.client.tui?.showToast?.({
-        body: {
-          title: "Ralph Loop",
-          message: `Iteration ${newState.iteration}/${newState.max_iterations}`,
-          variant: "info",
-          duration: 2000
+        try {
+          await continueIteration(ctx, newState, {
+            previousSessionID: sessionID,
+            directory: options.directory,
+            apiTimeoutMs: options.apiTimeoutMs,
+            loopState: options.loopState
+          });
+        } catch (err) {
+          log(`[${HOOK_NAME3}] Failed to inject continuation`, {
+            sessionID,
+            error: String(err)
+          });
         }
-      }).catch(() => {});
-      try {
-        await continueIteration(ctx, newState, {
-          previousSessionID: sessionID,
-          directory: options.directory,
-          apiTimeoutMs: options.apiTimeoutMs,
-          loopState: options.loopState
-        });
-      } catch (err) {
-        log(`[${HOOK_NAME3}] Failed to inject continuation`, {
-          sessionID,
-          error: String(err)
-        });
+        return;
+      } finally {
+        inFlightSessions.delete(sessionID);
       }
-      return;
     }
     if (event.type === "session.deleted") {
       const sessionInfo = props?.info;
@@ -41100,6 +41300,16 @@ function createRalphLoopEventHandler(ctx, options) {
 
 // src/hooks/ralph-loop/ralph-loop-hook.ts
 var DEFAULT_API_TIMEOUT = 5000;
+function getMessageCountFromResponse(messagesResponse) {
+  if (Array.isArray(messagesResponse)) {
+    return messagesResponse.length;
+  }
+  if (typeof messagesResponse === "object" && messagesResponse !== null && "data" in messagesResponse) {
+    const data = messagesResponse.data;
+    return Array.isArray(data) ? data.length : 0;
+  }
+  return 0;
+}
 function createRalphLoopHook(ctx, options) {
   const config2 = options?.config;
   const stateDir = config2?.state_dir;
@@ -41122,7 +41332,20 @@ function createRalphLoopHook(ctx, options) {
   });
   return {
     event,
-    startLoop: loopState.startLoop,
+    startLoop: (sessionID, prompt, loopOptions) => {
+      const startSuccess = loopState.startLoop(sessionID, prompt, loopOptions);
+      if (!startSuccess || typeof loopOptions?.messageCountAtStart === "number") {
+        return startSuccess;
+      }
+      ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory }
+      }).then((messagesResponse) => {
+        const messageCountAtStart = getMessageCountFromResponse(messagesResponse);
+        loopState.setMessageCountAtStart(sessionID, messageCountAtStart);
+      }).catch(() => {});
+      return startSuccess;
+    },
     cancelLoop: loopState.cancelLoop,
     getState: loopState.getState
   };
@@ -41177,12 +41400,12 @@ var TOAST_MESSAGE2 = [
 ].join(`
 `);
 var SISYPHUS_DISPLAY = getAgentDisplayName("sisyphus");
-function showToast2(ctx, sessionID) {
+function showToast2(ctx, sessionID, variant) {
   ctx.client.tui.showToast({
     body: {
       title: TOAST_TITLE2,
       message: TOAST_MESSAGE2,
-      variant: "error",
+      variant,
       duration: 1e4
     }
   }).catch((error45) => {
@@ -41192,14 +41415,18 @@ function showToast2(ctx, sessionID) {
     });
   });
 }
-function createNoHephaestusNonGptHook(ctx) {
+function createNoHephaestusNonGptHook(ctx, options) {
   return {
     "chat.message": async (input, output) => {
       const rawAgent = input.agent ?? getSessionAgent(input.sessionID) ?? "";
       const agentKey = getAgentConfigKey(rawAgent);
       const modelID = input.model?.modelID;
+      const allowNonGptModel = options?.allowNonGptModel === true;
       if (agentKey === "hephaestus" && modelID && !isGptModel(modelID)) {
-        showToast2(ctx, input.sessionID);
+        showToast2(ctx, input.sessionID, allowNonGptModel ? "warning" : "error");
+        if (allowNonGptModel) {
+          return;
+        }
         input.agent = SISYPHUS_DISPLAY;
         if (output?.message) {
           output.message.agent = SISYPHUS_DISPLAY;
@@ -42269,6 +42496,15 @@ $ARGUMENTS
 // src/features/builtin-commands/templates/start-work.ts
 var START_WORK_TEMPLATE = `You are starting a Sisyphus work session.
 
+## ARGUMENTS
+
+- \`/start-work [plan-name] [--worktree <path>]\`
+  - \`plan-name\` (optional): name or partial match of the plan to start
+  - \`--worktree <path>\` (optional): absolute path to an existing git worktree to work in
+    - If specified and valid: hook pre-sets worktree_path in boulder.json
+    - If specified but invalid: you must run \`git worktree add <path> <branch>\` first
+    - If omitted: you MUST choose or create a worktree (see Worktree Setup below)
+
 ## WHAT TO DO
 
 1. **Find available plans**: Search for Prometheus-generated plan files at \`.sisyphus/plans/\`
@@ -42284,17 +42520,24 @@ var START_WORK_TEMPLATE = `You are starting a Sisyphus work session.
      - If ONE plan: auto-select it
      - If MULTIPLE plans: show list with timestamps, ask user to select
 
-4. **Create/Update boulder.json**:
+4. **Worktree Setup** (when \`worktree_path\` not already set in boulder.json):
+   1. \`git worktree list --porcelain\` \u2014 see available worktrees
+   2. Create: \`git worktree add <absolute-path> <branch-or-HEAD>\`
+   3. Update boulder.json to add \`"worktree_path": "<absolute-path>"\`
+   4. All work happens inside that worktree directory
+
+5. **Create/Update boulder.json**:
    \`\`\`json
    {
      "active_plan": "/absolute/path/to/plan.md",
      "started_at": "ISO_TIMESTAMP",
      "session_ids": ["session_id_1", "session_id_2"],
-     "plan_name": "plan-name"
+     "plan_name": "plan-name",
+     "worktree_path": "/absolute/path/to/git/worktree"
    }
    \`\`\`
 
-5. **Read the plan file** and start executing tasks according to atlas workflow
+6. **Read the plan file** and start executing tasks according to atlas workflow
 
 ## OUTPUT FORMAT
 
@@ -42318,6 +42561,7 @@ Resuming Work Session
 Active Plan: {plan-name}
 Progress: {completed}/{total} tasks
 Sessions: {count} (appending current session)
+Worktree: {worktree_path}
 
 Reading plan and continuing from last incomplete task...
 \`\`\`
@@ -42329,6 +42573,7 @@ Starting Work Session
 Plan: {plan-name}
 Session ID: {session_id}
 Started: {timestamp}
+Worktree: {worktree_path}
 
 Reading plan and beginning execution...
 \`\`\`
@@ -42337,6 +42582,7 @@ Reading plan and beginning execution...
 
 - The session_id is injected by the hook - use it directly
 - Always update boulder.json BEFORE starting work
+- Always set worktree_path in boulder.json before executing any tasks
 - Read the FULL plan file before delegating any tasks
 - Follow atlas delegation protocols (7-section format)`;
 
@@ -45838,8 +46084,8 @@ function getPlanProgress(planPath) {
   }
   try {
     const content = readFileSync35(planPath, "utf-8");
-    const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
-    const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
+    const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
+    const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
     const completed = checkedMatches.length;
     return {
@@ -45854,13 +46100,14 @@ function getPlanProgress(planPath) {
 function getPlanName(planPath) {
   return basename3(planPath, ".md");
 }
-function createBoulderState(planPath, sessionId, agent) {
+function createBoulderState(planPath, sessionId, agent, worktreePath) {
   return {
     active_plan: planPath,
     started_at: new Date().toISOString(),
     session_ids: [sessionId],
     plan_name: getPlanName(planPath),
-    ...agent !== undefined ? { agent } : {}
+    ...agent !== undefined ? { agent } : {},
+    ...worktreePath !== undefined ? { worktree_path: worktreePath } : {}
   };
 }
 // src/hooks/prometheus-md-only/agent-resolution.ts
@@ -46060,19 +46307,48 @@ to continue: task(session_id="${sessionId}", prompt="...")`;
   };
 }
 // src/hooks/start-work/start-work-hook.ts
+import { statSync as statSync6 } from "fs";
 init_logger();
-var HOOK_NAME6 = "start-work";
-var KEYWORD_PATTERN = /\b(ultrawork|ulw)\b/gi;
-function extractUserRequestPlanName(promptText) {
-  const userRequestMatch = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
-  if (!userRequestMatch)
+
+// src/hooks/start-work/worktree-detector.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function detectWorktreePath(directory) {
+  try {
+    return execFileSync2("git", ["rev-parse", "--show-toplevel"], {
+      cwd: directory,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
     return null;
-  const rawArg = userRequestMatch[1].trim();
+  }
+}
+
+// src/hooks/start-work/parse-user-request.ts
+var KEYWORD_PATTERN = /\b(ultrawork|ulw)\b/gi;
+var WORKTREE_FLAG_PATTERN = /--worktree(?:\s+(\S+))?/;
+function parseUserRequest(promptText) {
+  const match = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
+  if (!match)
+    return { planName: null, explicitWorktreePath: null };
+  let rawArg = match[1].trim();
   if (!rawArg)
-    return null;
+    return { planName: null, explicitWorktreePath: null };
+  const worktreeMatch = rawArg.match(WORKTREE_FLAG_PATTERN);
+  const explicitWorktreePath = worktreeMatch ? worktreeMatch[1] ?? null : null;
+  if (worktreeMatch) {
+    rawArg = rawArg.replace(worktreeMatch[0], "").trim();
+  }
   const cleanedArg = rawArg.replace(KEYWORD_PATTERN, "").trim();
-  return cleanedArg || null;
+  return {
+    planName: cleanedArg || null,
+    explicitWorktreePath
+  };
 }
+
+// src/hooks/start-work/start-work-hook.ts
+var HOOK_NAME6 = "start-work";
 function findPlanByName(plans, requestedName) {
   const lowerName = requestedName.toLowerCase();
   const exactMatch = plans.find((p) => getPlanName(p).toLowerCase() === lowerName);
@@ -46081,29 +46357,48 @@ function findPlanByName(plans, requestedName) {
   const partialMatch = plans.find((p) => getPlanName(p).toLowerCase().includes(lowerName));
   return partialMatch || null;
 }
+var MODEL_DECIDES_WORKTREE_BLOCK = `
+## Worktree Setup Required
+
+No worktree specified. Before starting work, you MUST choose or create one:
+
+1. \`git worktree list --porcelain\` \u2014 list existing worktrees
+2. Create if needed: \`git worktree add <absolute-path> <branch-or-HEAD>\`
+3. Update \`.sisyphus/boulder.json\` \u2014 add \`"worktree_path": "<absolute-path>"\`
+4. Work exclusively inside that worktree directory`;
+function resolveWorktreeContext(explicitWorktreePath) {
+  if (explicitWorktreePath === null) {
+    return { worktreePath: undefined, block: MODEL_DECIDES_WORKTREE_BLOCK };
+  }
+  const validatedPath = detectWorktreePath(explicitWorktreePath);
+  if (validatedPath) {
+    return { worktreePath: validatedPath, block: `
+**Worktree**: ${validatedPath}` };
+  }
+  return {
+    worktreePath: undefined,
+    block: `
+**Worktree** (needs setup): \`git worktree add ${explicitWorktreePath} <branch>\`, then add \`"worktree_path"\` to boulder.json`
+  };
+}
 function createStartWorkHook(ctx) {
   return {
     "chat.message": async (input, output) => {
       const parts = output.parts;
       const promptText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
 `).trim() || "";
-      const isStartWorkCommand = promptText.includes("<session-context>");
-      if (!isStartWorkCommand) {
+      if (!promptText.includes("<session-context>"))
         return;
-      }
-      log(`[${HOOK_NAME6}] Processing start-work command`, {
-        sessionID: input.sessionID
-      });
+      log(`[${HOOK_NAME6}] Processing start-work command`, { sessionID: input.sessionID });
       updateSessionAgent(input.sessionID, "atlas");
       const existingState = readBoulderState(ctx.directory);
       const sessionId = input.sessionID;
       const timestamp2 = new Date().toISOString();
+      const { planName: explicitPlanName, explicitWorktreePath } = parseUserRequest(promptText);
+      const { worktreePath, block: worktreeBlock } = resolveWorktreeContext(explicitWorktreePath);
       let contextInfo = "";
-      const explicitPlanName = extractUserRequestPlanName(promptText);
       if (explicitPlanName) {
-        log(`[${HOOK_NAME6}] Explicit plan name requested: ${explicitPlanName}`, {
-          sessionID: input.sessionID
-        });
+        log(`[${HOOK_NAME6}] Explicit plan name requested: ${explicitPlanName}`, { sessionID: input.sessionID });
         const allPlans = findPrometheusPlans(ctx.directory);
         const matchedPlan = findPlanByName(allPlans, explicitPlanName);
         if (matchedPlan) {
@@ -46115,10 +46410,9 @@ function createStartWorkHook(ctx) {
 The requested plan "${getPlanName(matchedPlan)}" has been completed.
 All ${progress.total} tasks are done. Create a new plan with: /plan "your task"`;
           } else {
-            if (existingState) {
+            if (existingState)
               clearBoulderState(ctx.directory);
-            }
-            const newState = createBoulderState(matchedPlan, sessionId, "atlas");
+            const newState = createBoulderState(matchedPlan, sessionId, "atlas", worktreePath);
             writeBoulderState(ctx.directory, newState);
             contextInfo = `
 ## Auto-Selected Plan
@@ -46128,6 +46422,7 @@ All ${progress.total} tasks are done. Create a new plan with: /plan "your task"`
 **Progress**: ${progress.completed}/${progress.total} tasks
 **Session ID**: ${sessionId}
 **Started**: ${timestamp2}
+${worktreeBlock}
 
 boulder.json has been created. Read the plan and begin execution.`;
           }
@@ -46159,7 +46454,19 @@ No incomplete plans available. Create a new plan with: /plan "your task"`;
       } else if (existingState) {
         const progress = getPlanProgress(existingState.active_plan);
         if (!progress.isComplete) {
-          appendSessionId(ctx.directory, sessionId);
+          const effectiveWorktree = worktreePath ?? existingState.worktree_path;
+          if (worktreePath !== undefined) {
+            const updatedSessions = existingState.session_ids.includes(sessionId) ? existingState.session_ids : [...existingState.session_ids, sessionId];
+            writeBoulderState(ctx.directory, {
+              ...existingState,
+              worktree_path: worktreePath,
+              session_ids: updatedSessions
+            });
+          } else {
+            appendSessionId(ctx.directory, sessionId);
+          }
+          const worktreeDisplay = effectiveWorktree ? `
+**Worktree**: ${effectiveWorktree}` : worktreeBlock;
           contextInfo = `
 ## Active Work Session Found
 
@@ -46169,6 +46476,7 @@ No incomplete plans available. Create a new plan with: /plan "your task"`;
 **Progress**: ${progress.completed}/${progress.total} tasks completed
 **Sessions**: ${existingState.session_ids.length + 1} (current session appended)
 **Started**: ${existingState.started_at}
+${worktreeDisplay}
 
 The current session (${sessionId}) has been added to session_ids.
 Read the plan file and continue from the first unchecked task.`;
@@ -46185,7 +46493,6 @@ Looking for new plans...`;
         const incompletePlans = plans.filter((p) => !getPlanProgress(p).isComplete);
         if (plans.length === 0) {
           contextInfo += `
-
 ## No Plans Found
 
 No Prometheus plan files found at .sisyphus/plans/
@@ -46199,7 +46506,7 @@ All ${plans.length} plan(s) are complete. Create a new plan with: /plan "your ta
         } else if (incompletePlans.length === 1) {
           const planPath = incompletePlans[0];
           const progress = getPlanProgress(planPath);
-          const newState = createBoulderState(planPath, sessionId, "atlas");
+          const newState = createBoulderState(planPath, sessionId, "atlas", worktreePath);
           writeBoulderState(ctx.directory, newState);
           contextInfo += `
 
@@ -46210,13 +46517,13 @@ All ${plans.length} plan(s) are complete. Create a new plan with: /plan "your ta
 **Progress**: ${progress.completed}/${progress.total} tasks
 **Session ID**: ${sessionId}
 **Started**: ${timestamp2}
+${worktreeBlock}
 
 boulder.json has been created. Read the plan and begin execution.`;
         } else {
           const planList = incompletePlans.map((p, i2) => {
             const progress = getPlanProgress(p);
-            const stat = __require("fs").statSync(p);
-            const modified = new Date(stat.mtimeMs).toISOString();
+            const modified = new Date(statSync6(p).mtimeMs).toISOString();
             return `${i2 + 1}. [${getPlanName(p)}] - Modified: ${modified} - Progress: ${progress.completed}/${progress.total}`;
           }).join(`
 `);
@@ -46231,6 +46538,7 @@ Session ID: ${sessionId}
 ${planList}
 
 Ask the user which plan to work on. Present the options above and wait for their response.
+${worktreeBlock}
 </system-reminder>`;
         }
       }
@@ -46244,7 +46552,8 @@ ${contextInfo}`;
       }
       log(`[${HOOK_NAME6}] Context injected`, {
         sessionID: input.sessionID,
-        hasExistingState: !!existingState
+        hasExistingState: !!existingState,
+        worktreePath
       });
     }
   };
@@ -46496,6 +46805,7 @@ async function injectBoulderContinuation(input) {
     remaining,
     total,
     agent,
+    worktreePath,
     backgroundManager,
     sessionState
   } = input;
@@ -46504,9 +46814,12 @@ async function injectBoulderContinuation(input) {
     log(`[${HOOK_NAME7}] Skipped injection: background tasks running`, { sessionID });
     return;
   }
+  const worktreeContext = worktreePath ? `
+
+[Worktree: ${worktreePath}]` : "";
   const prompt = BOULDER_CONTINUATION_PROMPT.replace(/{PLAN_NAME}/g, planName) + `
 
-[Status: ${total - remaining}/${total} completed, ${remaining} remaining]`;
+[Status: ${total - remaining}/${total} completed, ${remaining} remaining]` + worktreeContext;
   try {
     log(`[${HOOK_NAME7}] Injecting boulder continuation`, { sessionID, planName, remaining });
     const promptContext = await resolveRecentPromptContextForSession(ctx, sessionID);
@@ -46525,6 +46838,7 @@ async function injectBoulderContinuation(input) {
     log(`[${HOOK_NAME7}] Boulder continuation injected`, { sessionID });
   } catch (err) {
     sessionState.promptFailureCount += 1;
+    sessionState.lastFailureAt = Date.now();
     log(`[${HOOK_NAME7}] Boulder continuation failed`, {
       sessionID,
       error: String(err),
@@ -46549,6 +46863,7 @@ async function getLastAgentFromSession(sessionID, client) {
 
 // src/hooks/atlas/event-handler.ts
 var CONTINUATION_COOLDOWN_MS2 = 5000;
+var FAILURE_BACKOFF_MS = 5 * 60 * 1000;
 function createAtlasEventHandler(input) {
   const { ctx, options, sessions, getState } = input;
   return async ({ event }) => {
@@ -46576,17 +46891,24 @@ function createAtlasEventHandler(input) {
         return;
       }
       const state3 = getState(sessionID);
+      const now = Date.now();
       if (state3.lastEventWasAbortError) {
         state3.lastEventWasAbortError = false;
         log(`[${HOOK_NAME7}] Skipped: abort error immediately before idle`, { sessionID });
         return;
       }
       if (state3.promptFailureCount >= 2) {
-        log(`[${HOOK_NAME7}] Skipped: continuation disabled after repeated prompt failures`, {
-          sessionID,
-          promptFailureCount: state3.promptFailureCount
-        });
-        return;
+        const timeSinceLastFailure = state3.lastFailureAt !== undefined ? now - state3.lastFailureAt : Number.POSITIVE_INFINITY;
+        if (timeSinceLastFailure < FAILURE_BACKOFF_MS) {
+          log(`[${HOOK_NAME7}] Skipped: continuation in backoff after repeated failures`, {
+            sessionID,
+            promptFailureCount: state3.promptFailureCount,
+            backoffRemaining: FAILURE_BACKOFF_MS - timeSinceLastFailure
+          });
+          return;
+        }
+        state3.promptFailureCount = 0;
+        state3.lastFailureAt = undefined;
       }
       const backgroundManager = options?.backgroundManager;
       const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
@@ -46602,21 +46924,21 @@ function createAtlasEventHandler(input) {
         log(`[${HOOK_NAME7}] Skipped: continuation stopped for session`, { sessionID });
         return;
       }
+      const sessionAgent = getSessionAgent(sessionID);
       const lastAgent = await getLastAgentFromSession(sessionID, ctx.client);
-      const lastAgentKey = getAgentConfigKey(lastAgent ?? "");
+      const effectiveAgent = sessionAgent ?? lastAgent;
+      const lastAgentKey = getAgentConfigKey(effectiveAgent ?? "");
       const requiredAgent = getAgentConfigKey(boulderState.agent ?? "atlas");
       const lastAgentMatchesRequired = lastAgentKey === requiredAgent;
-      const boulderAgentWasNotExplicitlySet = boulderState.agent === undefined;
       const boulderAgentDefaultsToAtlas = requiredAgent === "atlas";
       const lastAgentIsSisyphus = lastAgentKey === "sisyphus";
-      const allowSisyphusWhenDefaultAtlas = boulderAgentWasNotExplicitlySet && boulderAgentDefaultsToAtlas && lastAgentIsSisyphus;
-      const agentMatches = lastAgentMatchesRequired || allowSisyphusWhenDefaultAtlas;
+      const allowSisyphusForAtlasBoulder = boulderAgentDefaultsToAtlas && lastAgentIsSisyphus;
+      const agentMatches = lastAgentMatchesRequired || allowSisyphusForAtlasBoulder;
       if (!agentMatches) {
         log(`[${HOOK_NAME7}] Skipped: last agent does not match boulder agent`, {
           sessionID,
-          lastAgent: lastAgent ?? "unknown",
-          requiredAgent,
-          boulderAgentExplicitlySet: boulderState.agent !== undefined
+          lastAgent: effectiveAgent ?? "unknown",
+          requiredAgent
         });
         return;
       }
@@ -46625,7 +46947,6 @@ function createAtlasEventHandler(input) {
         log(`[${HOOK_NAME7}] Boulder complete`, { sessionID, plan: boulderState.plan_name });
         return;
       }
-      const now = Date.now();
       if (state3.lastContinuationInjectedAt && now - state3.lastContinuationInjectedAt < CONTINUATION_COOLDOWN_MS2) {
         log(`[${HOOK_NAME7}] Skipped: continuation cooldown active`, {
           sessionID,
@@ -46643,6 +46964,7 @@ function createAtlasEventHandler(input) {
           remaining,
           total: progress.total,
           agent: boulderState.agent,
+          worktreePath: boulderState.worktree_path,
           backgroundManager,
           sessionState: state3
         });
@@ -47125,12 +47447,36 @@ function createQuestionLabelTruncatorHook() {
 // src/hooks/stop-continuation-guard/hook.ts
 init_logger();
 var HOOK_NAME8 = "stop-continuation-guard";
-function createStopContinuationGuardHook(ctx) {
+function createStopContinuationGuardHook(ctx, options) {
   const stoppedSessions = new Set;
   const stop = (sessionID) => {
     stoppedSessions.add(sessionID);
     setContinuationMarkerSource(ctx.directory, sessionID, "stop", "stopped", "continuation stopped");
     log(`[${HOOK_NAME8}] Continuation stopped for session`, { sessionID });
+    const backgroundManager = options?.backgroundManager;
+    if (!backgroundManager) {
+      return;
+    }
+    const cancellableTasks = backgroundManager.getAllDescendantTasks(sessionID).filter((task) => task.status === "running" || task.status === "pending");
+    if (cancellableTasks.length === 0) {
+      return;
+    }
+    Promise.allSettled(cancellableTasks.map(async (task) => {
+      await backgroundManager.cancelTask(task.id, {
+        source: "stop-continuation",
+        reason: "Continuation stopped via /stop-continuation",
+        abortSession: task.status === "running",
+        skipNotification: true
+      });
+    })).then((results) => {
+      const cancelledCount = results.filter((result) => result.status === "fulfilled").length;
+      const failedCount = results.length - cancelledCount;
+      log(`[${HOOK_NAME8}] Cancelled background tasks for stopped session`, {
+        sessionID,
+        cancelledCount,
+        failedCount
+      });
+    });
   };
   const isStopped = (sessionID) => {
     return stoppedSessions.has(sessionID);
@@ -47531,10 +47877,24 @@ function createUnstableAgentBabysitterHook(ctx, options) {
 // src/hooks/preemptive-compaction.ts
 init_logger();
 var DEFAULT_ACTUAL_LIMIT = 200000;
+var PREEMPTIVE_COMPACTION_TIMEOUT_MS = 120000;
 function getAnthropicActualLimit3(modelCacheState) {
   return (modelCacheState?.anthropicContext1MEnabled ?? false) || process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : DEFAULT_ACTUAL_LIMIT;
 }
 var PREEMPTIVE_COMPACTION_THRESHOLD = 0.78;
+function withTimeout2(promise2, timeoutMs, errorMessage) {
+  let timeoutID;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutID = setTimeout(() => {
+      reject(new Error(errorMessage));
+    }, timeoutMs);
+  });
+  return Promise.race([promise2, timeoutPromise]).finally(() => {
+    if (timeoutID !== undefined) {
+      clearTimeout(timeoutID);
+    }
+  });
+}
 function isAnthropicProvider2(providerID) {
   return providerID === "anthropic" || providerID === "google-vertex-anthropic";
 }
@@ -47561,11 +47921,11 @@ function createPreemptiveCompactionHook(ctx, pluginConfig, modelCacheState) {
     compactionInProgress.add(sessionID);
     try {
       const { providerID: targetProviderID, modelID: targetModelID } = resolveCompactionModel(pluginConfig, sessionID, cached2.providerID, modelID);
-      await ctx.client.session.summarize({
+      await withTimeout2(ctx.client.session.summarize({
         path: { id: sessionID },
         body: { providerID: targetProviderID, modelID: targetModelID, auto: true },
         query: { directory: ctx.directory }
-      });
+      }), PREEMPTIVE_COMPACTION_TIMEOUT_MS, `Compaction summarize timed out after ${PREEMPTIVE_COMPACTION_TIMEOUT_MS}ms`);
       compactedSessions.add(sessionID);
     } catch (error45) {
       log("[preemptive-compaction] Compaction failed", { sessionID, error: String(error45) });
@@ -47773,7 +48133,9 @@ var AgentOverridesSchema = exports_external.object({
   build: AgentOverrideConfigSchema.optional(),
   plan: AgentOverrideConfigSchema.optional(),
   sisyphus: AgentOverrideConfigSchema.optional(),
-  hephaestus: AgentOverrideConfigSchema.optional(),
+  hephaestus: AgentOverrideConfigSchema.extend({
+    allow_non_gpt_model: exports_external.boolean().optional()
+  }).optional(),
   "sisyphus-junior": AgentOverrideConfigSchema.optional(),
   "OpenCode-Builder": AgentOverrideConfigSchema.optional(),
   prometheus: AgentOverrideConfigSchema.optional(),
@@ -47824,6 +48186,7 @@ var CategoryConfigSchema = exports_external.object({
   textVerbosity: exports_external.enum(["low", "medium", "high"]).optional(),
   tools: exports_external.record(exports_external.string(), exports_external.boolean()).optional(),
   prompt_append: exports_external.string().optional(),
+  max_prompt_tokens: exports_external.number().int().positive().optional(),
   is_unstable_agent: exports_external.boolean().optional(),
   disable: exports_external.boolean().optional()
 });
@@ -47959,7 +48322,8 @@ var HookNameSchema = exports_external.enum([
   "runtime-fallback",
   "write-existing-file-guard",
   "anthropic-effort",
-  "hashline-read-enhancer"
+  "hashline-read-enhancer",
+  "read-image-resizer"
 ]);
 // src/config/schema/notification.ts
 var NotificationConfigSchema = exports_external.object({
@@ -48066,7 +48430,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   new_task_system_enabled: exports_external.boolean().optional(),
   default_run_agent: exports_external.string().optional(),
   disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
-  disabled_agents: exports_external.array(BuiltinAgentNameSchema).optional(),
+  disabled_agents: exports_external.array(exports_external.string()).optional(),
   disabled_skills: exports_external.array(BuiltinSkillNameSchema).optional(),
   disabled_hooks: exports_external.array(exports_external.string()).optional(),
   disabled_commands: exports_external.array(BuiltinCommandNameSchema).optional(),
@@ -49535,6 +49899,511 @@ ${JSON_ERROR_REMINDER}`;
     }
   };
 }
+// src/tools/look-at/mime-type-inference.ts
+import { extname as extname2 } from "path";
+function inferMimeTypeFromBase64(base64Data) {
+  if (base64Data.startsWith("data:")) {
+    const match = base64Data.match(/^data:([^;]+);/);
+    if (match)
+      return match[1];
+  }
+  try {
+    const cleanData = base64Data.replace(/^data:[^;]+;base64,/, "");
+    const header = atob(cleanData.slice(0, 16));
+    if (header.startsWith("\x89PNG"))
+      return "image/png";
+    if (header.startsWith("\xFF\xD8\xFF"))
+      return "image/jpeg";
+    if (header.startsWith("GIF8"))
+      return "image/gif";
+    if (header.startsWith("RIFF") && header.includes("WEBP"))
+      return "image/webp";
+    if (header.startsWith("%PDF"))
+      return "application/pdf";
+  } catch {}
+  return "image/png";
+}
+function inferMimeTypeFromFilePath(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  const mimeTypes = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".mp4": "video/mp4",
+    ".mpeg": "video/mpeg",
+    ".mpg": "video/mpeg",
+    ".mov": "video/mov",
+    ".avi": "video/avi",
+    ".flv": "video/x-flv",
+    ".webm": "video/webm",
+    ".wmv": "video/wmv",
+    ".3gpp": "video/3gpp",
+    ".3gp": "video/3gpp",
+    ".wav": "audio/wav",
+    ".mp3": "audio/mp3",
+    ".aiff": "audio/aiff",
+    ".aac": "audio/aac",
+    ".ogg": "audio/ogg",
+    ".flac": "audio/flac",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".md": "text/md",
+    ".html": "text/html",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".js": "text/javascript",
+    ".py": "text/x-python"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
+function extractBase64Data(imageData) {
+  if (imageData.startsWith("data:")) {
+    const commaIndex = imageData.indexOf(",");
+    if (commaIndex !== -1) {
+      return imageData.slice(commaIndex + 1);
+    }
+  }
+  return imageData;
+}
+
+// src/hooks/read-image-resizer/image-dimensions.ts
+var HEADER_BYTES = 32768;
+var HEADER_BASE64_CHARS = Math.ceil(HEADER_BYTES / 3) * 4;
+function toImageDimensions(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height)) {
+    return null;
+  }
+  if (width <= 0 || height <= 0) {
+    return null;
+  }
+  return { width, height };
+}
+function parsePngDimensions(buffer) {
+  if (buffer.length < 24) {
+    return null;
+  }
+  const isPngSignature = buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10;
+  if (!isPngSignature || buffer.toString("ascii", 12, 16) !== "IHDR") {
+    return null;
+  }
+  const width = buffer.readUInt32BE(16);
+  const height = buffer.readUInt32BE(20);
+  return toImageDimensions(width, height);
+}
+function parseGifDimensions(buffer) {
+  if (buffer.length < 10) {
+    return null;
+  }
+  if (buffer.toString("ascii", 0, 4) !== "GIF8") {
+    return null;
+  }
+  const width = buffer.readUInt16LE(6);
+  const height = buffer.readUInt16LE(8);
+  return toImageDimensions(width, height);
+}
+function parseJpegDimensions(buffer) {
+  if (buffer.length < 4 || buffer[0] !== 255 || buffer[1] !== 216) {
+    return null;
+  }
+  let offset = 2;
+  while (offset < buffer.length) {
+    if (buffer[offset] !== 255) {
+      offset += 1;
+      continue;
+    }
+    while (offset < buffer.length && buffer[offset] === 255) {
+      offset += 1;
+    }
+    if (offset >= buffer.length) {
+      return null;
+    }
+    const marker = buffer[offset];
+    offset += 1;
+    if (marker === 217 || marker === 218) {
+      break;
+    }
+    if (offset + 1 >= buffer.length) {
+      return null;
+    }
+    const segmentLength = buffer.readUInt16BE(offset);
+    if (segmentLength < 2) {
+      return null;
+    }
+    if ((marker === 192 || marker === 194) && offset + 7 < buffer.length) {
+      const height = buffer.readUInt16BE(offset + 3);
+      const width = buffer.readUInt16BE(offset + 5);
+      return toImageDimensions(width, height);
+    }
+    offset += segmentLength;
+  }
+  return null;
+}
+function readUInt24LE(buffer, offset) {
+  return buffer[offset] | buffer[offset + 1] << 8 | buffer[offset + 2] << 16;
+}
+function parseWebpDimensions(buffer) {
+  if (buffer.length < 16) {
+    return null;
+  }
+  if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WEBP") {
+    return null;
+  }
+  const chunkType = buffer.toString("ascii", 12, 16);
+  if (chunkType === "VP8 ") {
+    if (buffer[23] !== 157 || buffer[24] !== 1 || buffer[25] !== 42) {
+      return null;
+    }
+    const width = buffer.readUInt16LE(26) & 16383;
+    const height = buffer.readUInt16LE(28) & 16383;
+    return toImageDimensions(width, height);
+  }
+  if (chunkType === "VP8L") {
+    if (buffer.length < 25 || buffer[20] !== 47) {
+      return null;
+    }
+    const bits = buffer.readUInt32LE(21);
+    const width = (bits & 16383) + 1;
+    const height = (bits >>> 14 & 16383) + 1;
+    return toImageDimensions(width, height);
+  }
+  if (chunkType === "VP8X") {
+    const width = readUInt24LE(buffer, 24) + 1;
+    const height = readUInt24LE(buffer, 27) + 1;
+    return toImageDimensions(width, height);
+  }
+  return null;
+}
+function parseImageDimensions(base64DataUrl, mimeType) {
+  try {
+    if (!base64DataUrl || !mimeType) {
+      return null;
+    }
+    const rawBase64 = extractBase64Data(base64DataUrl);
+    if (!rawBase64) {
+      return null;
+    }
+    const headerBase64 = rawBase64.length > HEADER_BASE64_CHARS ? rawBase64.slice(0, HEADER_BASE64_CHARS) : rawBase64;
+    const buffer = Buffer.from(headerBase64, "base64");
+    if (buffer.length === 0) {
+      return null;
+    }
+    const normalizedMime = mimeType.toLowerCase();
+    if (normalizedMime === "image/png") {
+      return parsePngDimensions(buffer);
+    }
+    if (normalizedMime === "image/gif") {
+      return parseGifDimensions(buffer);
+    }
+    if (normalizedMime === "image/jpeg" || normalizedMime === "image/jpg") {
+      return parseJpegDimensions(buffer);
+    }
+    if (normalizedMime === "image/webp") {
+      return parseWebpDimensions(buffer);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks/read-image-resizer/image-resizer.ts
+var ANTHROPIC_MAX_LONG_EDGE = 1568;
+var ANTHROPIC_MAX_FILE_SIZE = 5 * 1024 * 1024;
+function resolveSharpFactory(sharpModule) {
+  if (typeof sharpModule === "function") {
+    return sharpModule;
+  }
+  if (!sharpModule || typeof sharpModule !== "object") {
+    return null;
+  }
+  const defaultExport = Reflect.get(sharpModule, "default");
+  return typeof defaultExport === "function" ? defaultExport : null;
+}
+function resolveSharpFormat(mimeType) {
+  const normalizedMime = mimeType.toLowerCase();
+  if (normalizedMime === "image/png") {
+    return "png";
+  }
+  if (normalizedMime === "image/gif") {
+    return "gif";
+  }
+  if (normalizedMime === "image/webp") {
+    return "webp";
+  }
+  return "jpeg";
+}
+function canAdjustQuality(format2) {
+  return format2 === "jpeg" || format2 === "webp";
+}
+function toDimensions(metadata) {
+  const { width, height } = metadata;
+  if (!width || !height) {
+    return null;
+  }
+  return { width, height };
+}
+async function renderResizedBuffer(args) {
+  const { sharpFactory, inputBuffer, target, format: format2, quality } = args;
+  return sharpFactory(inputBuffer).resize(target.width, target.height, { fit: "inside" }).toFormat(format2, quality ? { quality } : undefined).toBuffer();
+}
+function getErrorMessage3(error45) {
+  return error45 instanceof Error ? error45.message : String(error45);
+}
+function calculateTargetDimensions(width, height, maxLongEdge = ANTHROPIC_MAX_LONG_EDGE) {
+  if (width <= 0 || height <= 0 || maxLongEdge <= 0) {
+    return null;
+  }
+  const longEdge = Math.max(width, height);
+  if (longEdge <= maxLongEdge) {
+    return null;
+  }
+  if (width >= height) {
+    return {
+      width: maxLongEdge,
+      height: Math.max(1, Math.floor(height * maxLongEdge / width))
+    };
+  }
+  return {
+    width: Math.max(1, Math.floor(width * maxLongEdge / height)),
+    height: maxLongEdge
+  };
+}
+async function resizeImage(base64DataUrl, mimeType, target) {
+  try {
+    const sharpModuleName = "sharp";
+    const sharpModule = await import(sharpModuleName).catch(() => null);
+    if (!sharpModule) {
+      log("[read-image-resizer] sharp unavailable, skipping resize");
+      return null;
+    }
+    const sharpFactory = resolveSharpFactory(sharpModule);
+    if (!sharpFactory) {
+      log("[read-image-resizer] sharp import has unexpected shape");
+      return null;
+    }
+    const rawBase64 = extractBase64Data(base64DataUrl);
+    if (!rawBase64) {
+      return null;
+    }
+    const inputBuffer = Buffer.from(rawBase64, "base64");
+    if (inputBuffer.length === 0) {
+      return null;
+    }
+    const original = toDimensions(await sharpFactory(inputBuffer).metadata());
+    if (!original) {
+      return null;
+    }
+    const format2 = resolveSharpFormat(mimeType);
+    let resizedBuffer = await renderResizedBuffer({
+      sharpFactory,
+      inputBuffer,
+      target,
+      format: format2
+    });
+    if (resizedBuffer.length > ANTHROPIC_MAX_FILE_SIZE && canAdjustQuality(format2)) {
+      for (const quality of [80, 60, 40]) {
+        resizedBuffer = await renderResizedBuffer({
+          sharpFactory,
+          inputBuffer,
+          target,
+          format: format2,
+          quality
+        });
+        if (resizedBuffer.length <= ANTHROPIC_MAX_FILE_SIZE) {
+          break;
+        }
+      }
+    }
+    const resized = toDimensions(await sharpFactory(resizedBuffer).metadata());
+    if (!resized) {
+      return null;
+    }
+    return {
+      resizedDataUrl: `data:${mimeType};base64,${resizedBuffer.toString("base64")}`,
+      original,
+      resized
+    };
+  } catch (error45) {
+    log("[read-image-resizer] resize failed", {
+      error: getErrorMessage3(error45),
+      mimeType,
+      target
+    });
+    return null;
+  }
+}
+
+// src/shared/session-model-state.ts
+var sessionModels = new Map;
+function setSessionModel(sessionID, model) {
+  sessionModels.set(sessionID, model);
+}
+function getSessionModel(sessionID) {
+  return sessionModels.get(sessionID);
+}
+function clearSessionModel(sessionID) {
+  sessionModels.delete(sessionID);
+}
+
+// src/hooks/read-image-resizer/hook.ts
+var SUPPORTED_IMAGE_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+var TOKEN_DIVISOR = 750;
+function isReadTool2(toolName) {
+  return toolName.toLowerCase() === "read";
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function isImageAttachmentRecord(value) {
+  const filename = value.filename;
+  return typeof value.mime === "string" && typeof value.url === "string" && (typeof filename === "undefined" || typeof filename === "string");
+}
+function extractImageAttachments(output) {
+  const attachmentsValue = output.attachments;
+  if (!Array.isArray(attachmentsValue)) {
+    return [];
+  }
+  const attachments = [];
+  for (const attachmentValue of attachmentsValue) {
+    const attachmentRecord = asRecord2(attachmentValue);
+    if (!attachmentRecord) {
+      continue;
+    }
+    const mime = attachmentRecord.mime;
+    const url2 = attachmentRecord.url;
+    if (typeof mime !== "string" || typeof url2 !== "string") {
+      continue;
+    }
+    const normalizedMime = mime.toLowerCase();
+    if (!SUPPORTED_IMAGE_MIMES.has(normalizedMime)) {
+      continue;
+    }
+    attachmentRecord.mime = normalizedMime;
+    attachmentRecord.url = url2;
+    if (isImageAttachmentRecord(attachmentRecord)) {
+      attachments.push(attachmentRecord);
+    }
+  }
+  return attachments;
+}
+function calculateTokens(width, height) {
+  return Math.ceil(width * height / TOKEN_DIVISOR);
+}
+function formatResizeAppendix(entries) {
+  const header = entries.some((entry) => entry.status === "resized") ? "[Image Resize Info]" : "[Image Info]";
+  const lines = [`
+
+${header}`];
+  for (const entry of entries) {
+    if (entry.status === "unknown-dims" || !entry.originalDims) {
+      lines.push(`- ${entry.filename}: dimensions could not be parsed`);
+      continue;
+    }
+    const original = entry.originalDims;
+    const originalText = `${original.width}x${original.height}`;
+    const originalTokens = calculateTokens(original.width, original.height);
+    if (entry.status === "within-limits") {
+      lines.push(`- ${entry.filename}: ${originalText} (within limits, tokens: ${originalTokens})`);
+      continue;
+    }
+    if (entry.status === "resize-skipped") {
+      lines.push(`- ${entry.filename}: ${originalText} (resize skipped, tokens: ${originalTokens})`);
+      continue;
+    }
+    if (!entry.resizedDims) {
+      lines.push(`- ${entry.filename}: ${originalText} (resize skipped, tokens: ${originalTokens})`);
+      continue;
+    }
+    const resized = entry.resizedDims;
+    const resizedText = `${resized.width}x${resized.height}`;
+    const resizedTokens = calculateTokens(resized.width, resized.height);
+    lines.push(`- ${entry.filename}: ${originalText} -> ${resizedText} (resized, tokens: ${originalTokens} -> ${resizedTokens})`);
+  }
+  return lines.join(`
+`);
+}
+function resolveFilename(attachment, index) {
+  if (attachment.filename && attachment.filename.trim().length > 0) {
+    return attachment.filename;
+  }
+  return `image-${index + 1}`;
+}
+function createReadImageResizerHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (!isReadTool2(input.tool)) {
+        return;
+      }
+      const sessionModel = getSessionModel(input.sessionID);
+      if (sessionModel?.providerID !== "anthropic") {
+        return;
+      }
+      if (typeof output.output !== "string") {
+        return;
+      }
+      const outputRecord = output;
+      const attachments = extractImageAttachments(outputRecord);
+      if (attachments.length === 0) {
+        return;
+      }
+      const entries = [];
+      for (const [index, attachment] of attachments.entries()) {
+        const filename = resolveFilename(attachment, index);
+        try {
+          const originalDims = parseImageDimensions(attachment.url, attachment.mime);
+          if (!originalDims) {
+            entries.push({ filename, originalDims: null, resizedDims: null, status: "unknown-dims" });
+            continue;
+          }
+          const targetDims = calculateTargetDimensions(originalDims.width, originalDims.height);
+          if (!targetDims) {
+            entries.push({
+              filename,
+              originalDims,
+              resizedDims: null,
+              status: "within-limits"
+            });
+            continue;
+          }
+          const resizedResult = await resizeImage(attachment.url, attachment.mime, targetDims);
+          if (!resizedResult) {
+            entries.push({
+              filename,
+              originalDims,
+              resizedDims: null,
+              status: "resize-skipped"
+            });
+            continue;
+          }
+          attachment.url = resizedResult.resizedDataUrl;
+          entries.push({
+            filename,
+            originalDims: resizedResult.original,
+            resizedDims: resizedResult.resized,
+            status: "resized"
+          });
+        } catch (error45) {
+          log("[read-image-resizer] attachment processing failed", {
+            error: error45 instanceof Error ? error45.message : String(error45),
+            filename
+          });
+          entries.push({ filename, originalDims: null, resizedDims: null, status: "unknown-dims" });
+        }
+      }
+      if (entries.length === 0) {
+        return;
+      }
+      output.output += formatResizeAppendix(entries);
+    }
+  };
+}
 // src/hooks/anthropic-effort/hook.ts
 var OPUS_4_6_PATTERN = /claude-opus-4[-.]6/i;
 function normalizeModelID2(modelID) {
@@ -50019,9 +50888,9 @@ function getLanguageId(ext) {
 }
 // src/tools/lsp/lsp-process.ts
 init_logger();
-var {spawn: bunSpawn } = globalThis.Bun;
-import { spawn as nodeSpawn } from "child_process";
-import { existsSync as existsSync51, statSync as statSync6 } from "fs";
+var {spawn: bunSpawn2 } = globalThis.Bun;
+import { spawn as nodeSpawn2 } from "child_process";
+import { existsSync as existsSync51, statSync as statSync7 } from "fs";
 function shouldUseNodeSpawn() {
   return process.platform === "win32";
 }
@@ -50030,7 +50899,7 @@ function validateCwd(cwd) {
     if (!existsSync51(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
-    const stats = statSync6(cwd);
+    const stats = statSync7(cwd);
     if (!stats.isDirectory()) {
       return { valid: false, error: `Path is not a directory: ${cwd}` };
     }
@@ -50039,7 +50908,7 @@ function validateCwd(cwd) {
     return { valid: false, error: `Cannot access working directory: ${cwd} (${err instanceof Error ? err.message : String(err)})` };
   }
 }
-function wrapNodeProcess(proc) {
+function wrapNodeProcess2(proc) {
   let resolveExited;
   let exitCode = null;
   const exitedPromise = new Promise((resolve8) => {
@@ -50140,16 +51009,16 @@ function spawnProcess(command, options) {
   if (shouldUseNodeSpawn()) {
     const [cmd, ...args] = command;
     log("[LSP] Using Node.js child_process on Windows to avoid Bun spawn segfault");
-    const proc2 = nodeSpawn(cmd, args, {
+    const proc2 = nodeSpawn2(cmd, args, {
       cwd: options.cwd,
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
       shell: true
     });
-    return wrapNodeProcess(proc2);
+    return wrapNodeProcess2(proc2);
   }
-  const proc = bunSpawn(command, {
+  const proc = bunSpawn2(command, {
     stdin: "pipe",
     stdout: "pipe",
     stderr: "pipe",
@@ -50160,7 +51029,7 @@ function spawnProcess(command, options) {
 }
 // src/tools/lsp/lsp-client.ts
 import { readFileSync as readFileSync38 } from "fs";
-import { extname as extname2, resolve as resolve8 } from "path";
+import { extname as extname3, resolve as resolve8 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/tools/lsp/lsp-client-connection.ts
@@ -50168,7 +51037,7 @@ import { pathToFileURL } from "url";
 
 // src/tools/lsp/lsp-client-transport.ts
 var import_node = __toESM(require_main(), 1);
-import { Readable, Writable } from "stream";
+import { Readable as Readable2, Writable } from "stream";
 init_logger();
 
 class LSPClientTransport {
@@ -50204,7 +51073,7 @@ class LSPClientTransport {
 stderr: ${stderr}` : ""));
     }
     const stdoutReader = this.proc.stdout.getReader();
-    const nodeReadable = new Readable({
+    const nodeReadable = new Readable2({
       async read() {
         try {
           const { done, value } = await stdoutReader.read();
@@ -50425,7 +51294,7 @@ class LSPClient extends LSPClientConnection {
     const uri = pathToFileURL2(absPath).href;
     const text = readFileSync38(absPath, "utf-8");
     if (!this.openedFiles.has(absPath)) {
-      const ext = extname2(absPath);
+      const ext = extname3(absPath);
       const languageId = getLanguageId(ext);
       const version2 = 1;
       this.sendNotification("textDocument/didOpen", {
@@ -50762,7 +51631,7 @@ class LSPServerManager {
 }
 var lspManager = LSPServerManager.getInstance();
 // src/tools/lsp/lsp-client-wrapper.ts
-import { extname as extname3, resolve as resolve9 } from "path";
+import { extname as extname4, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { existsSync as existsSync52 } from "fs";
 function findWorkspaceRoot(filePath) {
@@ -50823,7 +51692,7 @@ function formatServerLookupError(result) {
 }
 async function withLspClient(filePath, fn) {
   const absPath = resolve9(filePath);
-  const ext = extname3(absPath);
+  const ext = extname4(absPath);
   const result = findServerForExtension(ext);
   if (result.status !== "found") {
     throw new Error(formatServerLookupError(result));
@@ -51301,7 +52170,7 @@ var DEFAULT_MAX_MATCHES = 500;
 // src/tools/ast-grep/sg-cli-path.ts
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname16, join as join63 } from "path";
-import { existsSync as existsSync54, statSync as statSync7 } from "fs";
+import { existsSync as existsSync54, statSync as statSync8 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 import { existsSync as existsSync53 } from "fs";
@@ -51388,7 +52257,7 @@ async function ensureAstGrepBinary() {
 // src/tools/ast-grep/sg-cli-path.ts
 function isValidBinary(filePath) {
   try {
-    return statSync7(filePath).size > 1e4;
+    return statSync8(filePath).size > 1e4;
   } catch {
     return false;
   }
@@ -51823,6 +52692,9 @@ ${hint}`;
   });
   return { ast_grep_search, ast_grep_replace };
 }
+// src/tools/grep/tools.ts
+import { resolve as resolve10 } from "path";
+
 // src/tools/grep/cli.ts
 var {spawn: spawn11 } = globalThis.Bun;
 
@@ -52333,10 +53205,12 @@ function createGrepTools(ctx) {
       output_mode: tool.schema.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts per file.'),
       head_limit: tool.schema.number().optional().describe("Limit output to first N entries. 0 or omitted means no limit.")
     },
-    execute: async (args) => {
+    execute: async (args, context) => {
       try {
         const globs = args.include ? [args.include] : undefined;
-        const searchPath = args.path ?? ctx.directory;
+        const runtimeCtx = context;
+        const dir = typeof runtimeCtx.directory === "string" ? runtimeCtx.directory : ctx.directory;
+        const searchPath = args.path ? resolve10(dir, args.path) : dir;
         const paths = [searchPath];
         const outputMode = args.output_mode ?? "files_with_matches";
         const headLimit = args.head_limit ?? 0;
@@ -52365,7 +53239,11 @@ function createGrepTools(ctx) {
   });
   return { grep };
 }
+// src/tools/glob/tools.ts
+import { resolve as resolve12 } from "path";
+
 // src/tools/glob/cli.ts
+import { resolve as resolve11 } from "path";
 var {spawn: spawn12 } = globalThis.Bun;
 
 // src/tools/glob/constants.ts
@@ -52450,10 +53328,9 @@ async function runRgFilesInternal(options, resolvedCli) {
   let cwd;
   if (isRg) {
     const args = buildRgArgs2(options);
-    const paths = options.paths?.length ? options.paths : ["."];
-    args.push(...paths);
+    cwd = options.paths?.[0] || ".";
+    args.push(".");
     command = [cli.path, ...args];
-    cwd = undefined;
   } else if (isWindows2) {
     command = buildPowerShellCommand(options);
     cwd = undefined;
@@ -52500,7 +53377,7 @@ async function runRgFilesInternal(options, resolvedCli) {
       }
       let filePath;
       if (isRg) {
-        filePath = line;
+        filePath = cwd ? resolve11(cwd, line) : line;
       } else if (isWindows2) {
         filePath = line.trim();
       } else {
@@ -52555,14 +53432,15 @@ function createGlobTools(ctx) {
       pattern: tool.schema.string().describe("The glob pattern to match files against"),
       path: tool.schema.string().optional().describe("The directory to search in. If not specified, the current working directory will be used. " + 'IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - ' + "simply omit it for the default behavior. Must be a valid directory path if provided.")
     },
-    execute: async (args) => {
+    execute: async (args, context) => {
       try {
         const cli = await resolveGrepCliWithAutoInstall();
-        const searchPath = args.path ?? ctx.directory;
-        const paths = [searchPath];
+        const runtimeCtx = context;
+        const dir = typeof runtimeCtx.directory === "string" ? runtimeCtx.directory : ctx.directory;
+        const searchPath = args.path ? resolve12(dir, args.path) : dir;
         const result = await runRgFiles({
           pattern: args.pattern,
-          paths
+          paths: [searchPath]
         }, cli);
         return formatGlobResult(result);
       } catch (e) {
@@ -53470,7 +54348,7 @@ async function searchInSession(sessionID, query, caseSensitive = false, maxResul
 // src/tools/session-manager/tools.ts
 var SEARCH_TIMEOUT_MS = 60000;
 var MAX_SESSIONS_TO_SCAN = 50;
-function withTimeout2(promise2, ms, operation) {
+function withTimeout3(promise2, ms, operation) {
   return Promise.race([
     promise2,
     new Promise((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms))
@@ -53557,7 +54435,7 @@ function createSessionManagerTools(ctx) {
           }
           return allResults.slice(0, resultLimit);
         };
-        const results = await withTimeout2(searchOperation(), SEARCH_TIMEOUT_MS, "Search");
+        const results = await withTimeout3(searchOperation(), SEARCH_TIMEOUT_MS, "Search");
         return formatSearchResults(results);
       } catch (e) {
         return `Error: ${e instanceof Error ? e.message : String(e)}`;
@@ -53675,7 +54553,7 @@ tmux capture-pane -p -t ${sessionName} -S -1000
 
 The Bash tool can execute these commands directly. Do NOT retry with interactive_bash.`;
       }
-      const proc = Bun.spawn([tmuxPath2, ...parts], {
+      const proc = spawnWithWindowsHide([tmuxPath2, ...parts], {
         stdout: "pipe",
         stderr: "pipe"
       });
@@ -53893,10 +54771,10 @@ init_logger();
 
 // src/tools/background-task/delay.ts
 function delay3(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 // src/tools/background-task/session-messages.ts
-function getErrorMessage3(value) {
+function getErrorMessage4(value) {
   if (Array.isArray(value))
     return null;
   if (value.error === undefined || value.error === null)
@@ -54049,7 +54927,7 @@ async function formatFullSession(task, client2, options) {
   const messagesResult = await client2.session.messages({
     path: { id: task.sessionID }
   });
-  const errorMessage = getErrorMessage3(messagesResult);
+  const errorMessage = getErrorMessage4(messagesResult);
   if (errorMessage) {
     return `Error fetching messages: ${errorMessage}`;
   }
@@ -54147,7 +55025,7 @@ async function formatTaskResult(task, client2) {
   const messagesResult = await client2.session.messages({
     path: { id: task.sessionID }
   });
-  const errorMessage = getErrorMessage3(messagesResult);
+  const errorMessage = getErrorMessage4(messagesResult);
   if (errorMessage) {
     return `Error fetching messages: ${errorMessage}`;
   }
@@ -54250,6 +55128,14 @@ function formatResolvedTitle(task) {
   const label = task.agent === SISYPHUS_JUNIOR_AGENT && task.category ? task.category : task.agent;
   return `${label} - ${task.description}`;
 }
+function isTaskActiveStatus(status) {
+  return status === "pending" || status === "running";
+}
+function appendTimeoutNote(output, timeoutMs) {
+  return `${output}
+
+> **Timed out waiting** after ${timeoutMs}ms. Task is still running; showing latest available output.`;
+}
 function createBackgroundOutput(manager, client2) {
   return tool({
     description: BACKGROUND_OUTPUT_DESCRIPTION,
@@ -54290,7 +55176,8 @@ function createBackgroundOutput(manager, client2) {
         const timeoutMs = Math.min(args.timeout ?? 60000, 600000);
         const fullSession = args.full_session ?? true;
         let resolvedTask = task;
-        if (shouldBlock && (task.status === "pending" || task.status === "running")) {
+        let didTimeoutWhileActive = false;
+        if (shouldBlock && isTaskActiveStatus(task.status)) {
           const startTime = Date.now();
           while (Date.now() - startTime < timeoutMs) {
             await delay3(1000);
@@ -54298,27 +55185,33 @@ function createBackgroundOutput(manager, client2) {
             if (!currentTask) {
               return `Task was deleted: ${args.task_id}`;
             }
-            if (currentTask.status !== "pending" && currentTask.status !== "running") {
-              resolvedTask = currentTask;
+            resolvedTask = currentTask;
+            if (!isTaskActiveStatus(currentTask.status)) {
               break;
             }
           }
-          const finalCheck = manager.getTask(args.task_id);
-          if (finalCheck) {
-            resolvedTask = finalCheck;
+          if (isTaskActiveStatus(resolvedTask.status)) {
+            const finalCheck = manager.getTask(args.task_id);
+            if (finalCheck) {
+              resolvedTask = finalCheck;
+            }
+          }
+          if (isTaskActiveStatus(resolvedTask.status)) {
+            didTimeoutWhileActive = true;
           }
         }
-        const isActive = resolvedTask.status === "pending" || resolvedTask.status === "running";
+        const isActive = isTaskActiveStatus(resolvedTask.status);
         const includeThinking = isActive || (args.include_thinking ?? false);
         const includeToolResults = isActive || (args.include_tool_results ?? false);
         if (fullSession) {
-          return await formatFullSession(resolvedTask, client2, {
+          const output = await formatFullSession(resolvedTask, client2, {
             includeThinking,
             messageLimit: args.message_limit,
             sinceMessageId: args.since_message_id,
             includeToolResults,
             thinkingMaxChars: args.thinking_max_chars
           });
+          return didTimeoutWhileActive ? appendTimeoutNote(output, timeoutMs) : output;
         }
         if (resolvedTask.status === "completed") {
           return await formatTaskResult(resolvedTask, client2);
@@ -54326,7 +55219,8 @@ function createBackgroundOutput(manager, client2) {
         if (resolvedTask.status === "error" || resolvedTask.status === "cancelled" || resolvedTask.status === "interrupt") {
           return formatTaskStatus(resolvedTask);
         }
-        return formatTaskStatus(resolvedTask);
+        const statusOutput = formatTaskStatus(resolvedTask);
+        return didTimeoutWhileActive ? appendTimeoutNote(statusOutput, timeoutMs) : statusOutput;
       } catch (error45) {
         return `Error getting output: ${error45 instanceof Error ? error45.message : String(error45)}`;
       }
@@ -54482,7 +55376,7 @@ Task ID: ${task.id}`;
 
 Task ID: ${task.id}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, WAIT_FOR_SESSION_INTERVAL_MS));
+      await new Promise((resolve13) => setTimeout(resolve13, WAIT_FOR_SESSION_INTERVAL_MS));
       sessionId = manager.getTask(task.id)?.sessionID;
     }
     await toolContext.metadata?.({
@@ -54575,7 +55469,7 @@ async function waitForCompletion(sessionID, toolContext, ctx) {
       log(`[call_omo_agent] Aborted by user`);
       throw new Error("Task aborted.");
     }
-    await new Promise((resolve10) => setTimeout(resolve10, POLL_INTERVAL_MS));
+    await new Promise((resolve13) => setTimeout(resolve13, POLL_INTERVAL_MS));
     const statusResult = await ctx.client.session.status();
     const allStatuses = normalizeSDKResponse(statusResult, {});
     const sessionStatus = allStatuses[sessionID];
@@ -54822,77 +55716,6 @@ function validateArgs(args) {
   return null;
 }
 
-// src/tools/look-at/mime-type-inference.ts
-import { extname as extname4 } from "path";
-function inferMimeTypeFromBase64(base64Data) {
-  if (base64Data.startsWith("data:")) {
-    const match = base64Data.match(/^data:([^;]+);/);
-    if (match)
-      return match[1];
-  }
-  try {
-    const cleanData = base64Data.replace(/^data:[^;]+;base64,/, "");
-    const header = atob(cleanData.slice(0, 16));
-    if (header.startsWith("\x89PNG"))
-      return "image/png";
-    if (header.startsWith("\xFF\xD8\xFF"))
-      return "image/jpeg";
-    if (header.startsWith("GIF8"))
-      return "image/gif";
-    if (header.startsWith("RIFF") && header.includes("WEBP"))
-      return "image/webp";
-    if (header.startsWith("%PDF"))
-      return "application/pdf";
-  } catch {}
-  return "image/png";
-}
-function inferMimeTypeFromFilePath(filePath) {
-  const ext = extname4(filePath).toLowerCase();
-  const mimeTypes = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".webp": "image/webp",
-    ".heic": "image/heic",
-    ".heif": "image/heif",
-    ".mp4": "video/mp4",
-    ".mpeg": "video/mpeg",
-    ".mpg": "video/mpeg",
-    ".mov": "video/mov",
-    ".avi": "video/avi",
-    ".flv": "video/x-flv",
-    ".webm": "video/webm",
-    ".wmv": "video/wmv",
-    ".3gpp": "video/3gpp",
-    ".3gp": "video/3gpp",
-    ".wav": "audio/wav",
-    ".mp3": "audio/mp3",
-    ".aiff": "audio/aiff",
-    ".aac": "audio/aac",
-    ".ogg": "audio/ogg",
-    ".flac": "audio/flac",
-    ".pdf": "application/pdf",
-    ".txt": "text/plain",
-    ".csv": "text/csv",
-    ".md": "text/md",
-    ".html": "text/html",
-    ".json": "application/json",
-    ".xml": "application/xml",
-    ".js": "text/javascript",
-    ".py": "text/x-python"
-  };
-  return mimeTypes[ext] || "application/octet-stream";
-}
-function extractBase64Data(imageData) {
-  if (imageData.startsWith("data:")) {
-    const commaIndex = imageData.indexOf(",");
-    if (commaIndex !== -1) {
-      return imageData.slice(commaIndex + 1);
-    }
-  }
-  return imageData;
-}
-
 // src/tools/look-at/multimodal-agent-metadata.ts
 function isObject4(value) {
   return typeof value === "object" && value !== null;
@@ -55062,47 +55885,153 @@ init_logger();
 
 // src/tools/delegate-task/prompt-builder.ts
 init_constants();
+
+// src/tools/delegate-task/token-limiter.ts
+var CHARACTERS_PER_TOKEN = 4;
+function estimateTokenCount(text) {
+  if (!text) {
+    return 0;
+  }
+  return Math.ceil(text.length / CHARACTERS_PER_TOKEN);
+}
+function truncateToTokenBudget(content, maxTokens) {
+  if (!content || maxTokens <= 0) {
+    return "";
+  }
+  const maxCharacters = maxTokens * CHARACTERS_PER_TOKEN;
+  if (content.length <= maxCharacters) {
+    return content;
+  }
+  const sliced = content.slice(0, maxCharacters);
+  const lastNewline = sliced.lastIndexOf(`
+`);
+  if (lastNewline > 0) {
+    return `${sliced.slice(0, lastNewline)}
+[TRUNCATED]`;
+  }
+  return `${sliced}
+[TRUNCATED]`;
+}
+function joinSystemParts(parts) {
+  const filtered = parts.filter((part) => part.trim().length > 0);
+  if (filtered.length === 0) {
+    return;
+  }
+  return filtered.join(`
+
+`);
+}
+function reduceSegmentToFitBudget(content, overflowTokens) {
+  if (overflowTokens <= 0 || !content) {
+    return content;
+  }
+  const currentTokens = estimateTokenCount(content);
+  const nextBudget = Math.max(0, currentTokens - overflowTokens);
+  return truncateToTokenBudget(content, nextBudget);
+}
+function buildSystemContentWithTokenLimit(input, maxTokens) {
+  const skillParts = input.skillContents?.length ? [...input.skillContents] : input.skillContent ? [input.skillContent] : [];
+  const categoryPromptAppend = input.categoryPromptAppend ?? "";
+  const agentsContext = input.agentsContext ?? input.planAgentPrepend ?? "";
+  if (maxTokens === undefined) {
+    return joinSystemParts([agentsContext, ...skillParts, categoryPromptAppend]);
+  }
+  let nextSkills = [...skillParts];
+  let nextCategoryPromptAppend = categoryPromptAppend;
+  let nextAgentsContext = agentsContext;
+  const buildCurrentContent = () => joinSystemParts([nextAgentsContext, ...nextSkills, nextCategoryPromptAppend]);
+  let systemContent = buildCurrentContent();
+  if (!systemContent) {
+    return;
+  }
+  let overflowTokens = estimateTokenCount(systemContent) - maxTokens;
+  if (overflowTokens > 0) {
+    for (let index = 0;index < nextSkills.length && overflowTokens > 0; index += 1) {
+      const skill2 = nextSkills[index];
+      const reducedSkill = reduceSegmentToFitBudget(skill2, overflowTokens);
+      nextSkills[index] = reducedSkill;
+      systemContent = buildCurrentContent();
+      if (!systemContent) {
+        return;
+      }
+      overflowTokens = estimateTokenCount(systemContent) - maxTokens;
+    }
+    nextSkills = nextSkills.filter((skill2) => skill2.trim().length > 0);
+    systemContent = buildCurrentContent();
+    if (!systemContent) {
+      return;
+    }
+    overflowTokens = estimateTokenCount(systemContent) - maxTokens;
+  }
+  if (overflowTokens > 0 && nextCategoryPromptAppend) {
+    nextCategoryPromptAppend = reduceSegmentToFitBudget(nextCategoryPromptAppend, overflowTokens);
+    systemContent = buildCurrentContent();
+    if (!systemContent) {
+      return;
+    }
+    overflowTokens = estimateTokenCount(systemContent) - maxTokens;
+  }
+  if (overflowTokens > 0 && nextAgentsContext) {
+    nextAgentsContext = reduceSegmentToFitBudget(nextAgentsContext, overflowTokens);
+    systemContent = buildCurrentContent();
+    if (!systemContent) {
+      return;
+    }
+  }
+  if (!systemContent) {
+    return;
+  }
+  return truncateToTokenBudget(systemContent, maxTokens);
+}
+
+// src/tools/delegate-task/prompt-builder.ts
+var FREE_OR_LOCAL_PROMPT_TOKEN_LIMIT = 24000;
+function usesFreeOrLocalModel(model) {
+  if (!model) {
+    return false;
+  }
+  const provider = model.providerID.toLowerCase();
+  const modelId = model.modelID.toLowerCase();
+  return provider.includes("local") || provider === "ollama" || provider === "lmstudio" || modelId.includes("free");
+}
 function buildSystemContent(input) {
   const {
     skillContent,
+    skillContents,
     categoryPromptAppend,
+    agentsContext,
+    maxPromptTokens,
+    model,
     agentName,
     availableCategories,
     availableSkills
   } = input;
   const planAgentPrepend = isPlanAgent(agentName) ? buildPlanAgentSystemPrepend(availableCategories, availableSkills) : "";
-  if (!skillContent && !categoryPromptAppend && !planAgentPrepend) {
-    return;
-  }
-  const parts = [];
-  if (planAgentPrepend) {
-    parts.push(planAgentPrepend);
-  }
-  if (skillContent) {
-    parts.push(skillContent);
-  }
-  if (categoryPromptAppend) {
-    parts.push(categoryPromptAppend);
-  }
-  return parts.join(`
-
-`) || undefined;
+  const effectiveMaxPromptTokens = maxPromptTokens ?? (usesFreeOrLocalModel(model) ? FREE_OR_LOCAL_PROMPT_TOKEN_LIMIT : undefined);
+  return buildSystemContentWithTokenLimit({
+    skillContent,
+    skillContents,
+    categoryPromptAppend,
+    agentsContext: agentsContext ?? planAgentPrepend,
+    planAgentPrepend
+  }, effectiveMaxPromptTokens);
 }
 
 // src/tools/delegate-task/skill-resolver.ts
 async function resolveSkillContent2(skills2, options) {
   if (skills2.length === 0) {
-    return { content: undefined, error: null };
+    return { content: undefined, contents: [], error: null };
   }
   const { resolved, notFound } = await resolveMultipleSkillsAsync(skills2, options);
   if (notFound.length > 0) {
     const allSkills = await discoverSkills({ includeClaudeCodePaths: true, directory: options?.directory });
     const available = allSkills.map((s) => s.name).join(", ");
-    return { content: undefined, error: `Skills not found: ${notFound.join(", ")}. Available: ${available}` };
+    return { content: undefined, contents: [], error: `Skills not found: ${notFound.join(", ")}. Available: ${available}` };
   }
-  return { content: Array.from(resolved.values()).join(`
+  const contents = Array.from(resolved.values());
+  return { content: contents.join(`
 
-`), error: null };
+`), contents, error: null };
 }
 // src/tools/delegate-task/parent-context-resolver.ts
 init_logger();
@@ -55292,7 +56221,7 @@ async function pollSyncSession(ctx, client2, input) {
 
 Session ID: ${input.sessionID}`;
     }
-    await new Promise((resolve10) => setTimeout(resolve10, syncTiming.POLL_INTERVAL_MS));
+    await new Promise((resolve13) => setTimeout(resolve13, syncTiming.POLL_INTERVAL_MS));
     pollCount++;
     let statusResult;
     try {
@@ -55554,7 +56483,7 @@ async function executeUnstableAgentTask(args, ctx, executorCtx, parentContext, a
 
 Task ID: ${task.id}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, timing.WAIT_FOR_SESSION_INTERVAL_MS));
+      await new Promise((resolve13) => setTimeout(resolve13, timing.WAIT_FOR_SESSION_INTERVAL_MS));
       const updated = manager.getTask(task.id);
       sessionID = updated?.sessionID;
     }
@@ -55595,7 +56524,7 @@ Task ID: ${task.id}`;
 
 Session ID: ${sessionID}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, timingCfg.POLL_INTERVAL_MS));
+      await new Promise((resolve13) => setTimeout(resolve13, timingCfg.POLL_INTERVAL_MS));
       const currentTask = manager.getTask(task.id);
       if (currentTask && (currentTask.status === "interrupt" || currentTask.status === "error" || currentTask.status === "cancelled")) {
         terminalStatus = { status: currentTask.status, error: currentTask.error };
@@ -55724,7 +56653,7 @@ async function executeBackgroundTask(args, ctx, executorCtx, parentContext, agen
 
 Task ID: ${task.id}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, timing.WAIT_FOR_SESSION_INTERVAL_MS));
+      await new Promise((resolve13) => setTimeout(resolve13, timing.WAIT_FOR_SESSION_INTERVAL_MS));
       const updated = manager.getTask(task.id);
       sessionId = updated?.sessionID;
     }
@@ -56173,6 +57102,7 @@ async function resolveCategoryExecution(args, executorCtx, inheritedModel, syste
         agentToUse: "",
         categoryModel: undefined,
         categoryPromptAppend: undefined,
+        maxPromptTokens: undefined,
         modelInfo: undefined,
         actualModel: undefined,
         isUnstableAgent: false,
@@ -56189,6 +57119,7 @@ Available categories: ${allCategoryNames}`
       agentToUse: "",
       categoryModel: undefined,
       categoryPromptAppend: undefined,
+      maxPromptTokens: undefined,
       modelInfo: undefined,
       actualModel: undefined,
       isUnstableAgent: false,
@@ -56222,6 +57153,7 @@ Available categories: ${allCategoryNames}`
           agentToUse: "",
           categoryModel: undefined,
           categoryPromptAppend: undefined,
+          maxPromptTokens: undefined,
           modelInfo: undefined,
           actualModel: undefined,
           isUnstableAgent: false,
@@ -56247,6 +57179,7 @@ Available categories: ${allCategoryNames}`
       agentToUse: "",
       categoryModel: undefined,
       categoryPromptAppend: undefined,
+      maxPromptTokens: undefined,
       modelInfo: undefined,
       actualModel: undefined,
       isUnstableAgent: false,
@@ -56268,6 +57201,7 @@ Available categories: ${categoryNames.join(", ")}`
     agentToUse: SISYPHUS_JUNIOR_AGENT2,
     categoryModel,
     categoryPromptAppend,
+    maxPromptTokens: resolved.config.max_prompt_tokens,
     modelInfo,
     actualModel,
     isUnstableAgent,
@@ -56477,7 +57411,7 @@ function createDelegateTask(options) {
         throw new Error(`Invalid arguments: load_skills=null is not allowed. Pass [] if no skills needed.`);
       }
       const runInBackground = args.run_in_background === true;
-      const { content: skillContent, error: skillError } = await resolveSkillContent2(args.load_skills, {
+      const { content: skillContent, contents: skillContents, error: skillError } = await resolveSkillContent2(args.load_skills, {
         gitMasterConfig: options.gitMasterConfig,
         browserProvider: options.browserProvider,
         disabledSkills: options.disabledSkills,
@@ -56511,6 +57445,7 @@ function createDelegateTask(options) {
       let actualModel;
       let isUnstableAgent = false;
       let fallbackChain;
+      let maxPromptTokens;
       if (args.category) {
         const resolution = await resolveCategoryExecution(args, options, inheritedModel, systemDefaultModel);
         if (resolution.error) {
@@ -56523,6 +57458,7 @@ function createDelegateTask(options) {
         actualModel = resolution.actualModel;
         isUnstableAgent = resolution.isUnstableAgent;
         fallbackChain = resolution.fallbackChain;
+        maxPromptTokens = resolution.maxPromptTokens;
         const isRunInBackgroundExplicitlyFalse = args.run_in_background === false || args.run_in_background === "false";
         log("[task] unstable agent detection", {
           category: args.category,
@@ -56536,8 +57472,11 @@ function createDelegateTask(options) {
         if (isUnstableAgent && isRunInBackgroundExplicitlyFalse) {
           const systemContent2 = buildSystemContent({
             skillContent,
+            skillContents,
             categoryPromptAppend,
             agentName: agentToUse,
+            maxPromptTokens,
+            model: categoryModel,
             availableCategories,
             availableSkills
           });
@@ -56554,8 +57493,11 @@ function createDelegateTask(options) {
       }
       const systemContent = buildSystemContent({
         skillContent,
+        skillContents,
         categoryPromptAppend,
         agentName: agentToUse,
+        maxPromptTokens,
+        model: categoryModel,
         availableCategories,
         availableSkills
       });
@@ -57356,14 +58298,19 @@ function normalizeEditPayload(payload) {
   return toNewLines(payload).join(`
 `);
 }
+function canonicalAnchor(anchor) {
+  if (!anchor)
+    return "";
+  return normalizeLineRef(anchor);
+}
 function buildDedupeKey(edit) {
   switch (edit.op) {
     case "replace":
-      return `replace|${edit.pos}|${edit.end ?? ""}|${normalizeEditPayload(edit.lines)}`;
+      return `replace|${canonicalAnchor(edit.pos)}|${edit.end ? canonicalAnchor(edit.end) : ""}|${normalizeEditPayload(edit.lines)}`;
     case "append":
-      return `append|${edit.pos ?? ""}|${normalizeEditPayload(edit.lines)}`;
+      return `append|${canonicalAnchor(edit.pos)}|${normalizeEditPayload(edit.lines)}`;
     case "prepend":
-      return `prepend|${edit.pos ?? ""}|${normalizeEditPayload(edit.lines)}`;
+      return `prepend|${canonicalAnchor(edit.pos)}|${normalizeEditPayload(edit.lines)}`;
     default:
       return JSON.stringify(edit);
   }
@@ -57748,66 +58695,448 @@ function applyHashlineEditsWithReport(content, edits) {
     deduplicatedEdits: dedupeResult.deduplicatedEdits
   };
 }
-// src/tools/hashline-edit/diff-utils.ts
-function generateUnifiedDiff(oldContent, newContent, filePath) {
-  const oldLines = oldContent.split(`
-`);
-  const newLines = newContent.split(`
+// node_modules/diff/libesm/diff/base.js
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== undefined ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = undefined;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = undefined;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec2() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(undefined);
+          }
+          if (!execEditLength()) {
+            exec2();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path11, added, removed, oldPosInc, options) {
+    const last = path11.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path11.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path11.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i2 = 0;i2 < array2.length; i2++) {
+      if (array2[i2]) {
+        ret.push(array2[i2]);
+      }
+    }
+    return ret;
+  }
+  castInput(value, options) {
+    return value;
+  }
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (;componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i2) {
+            const oldValue = oldTokens[oldPos + i2];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+}
+
+// node_modules/diff/libesm/diff/line.js
+class LineDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes(`
+`)) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes(`
+`)) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith(`
+`)) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith(`
+`)) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+}
+var lineDiff = new LineDiff;
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, `
 `);
-  const maxLines = Math.max(oldLines.length, newLines.length);
-  let diff = `--- ${filePath}
-+++ ${filePath}
-`;
-  let inHunk = false;
-  let oldStart = 1;
-  let newStart = 1;
-  let oldCount = 0;
-  let newCount = 0;
-  let hunkLines = [];
-  for (let i2 = 0;i2 < maxLines; i2++) {
-    const oldLine = oldLines[i2] ?? "";
-    const newLine = newLines[i2] ?? "";
-    if (oldLine !== newLine) {
-      if (!inHunk) {
-        oldStart = i2 + 1;
-        newStart = i2 + 1;
-        oldCount = 0;
-        newCount = 0;
-        hunkLines = [];
-        inHunk = true;
-      }
-      if (oldLines[i2] !== undefined) {
-        hunkLines.push(`-${oldLine}`);
-        oldCount++;
-      }
-      if (newLines[i2] !== undefined) {
-        hunkLines.push(`+${newLine}`);
-        newCount++;
-      }
-    } else if (inHunk) {
-      hunkLines.push(` ${oldLine}`);
-      oldCount++;
-      newCount++;
-      if (hunkLines.length > 6) {
-        diff += `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
-`;
-        diff += hunkLines.join(`
-`) + `
-`;
-        inHunk = false;
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i2 = 0;i2 < linesAndNewlines.length; i2++) {
+    const line = linesAndNewlines[i2];
+    if (i2 % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/patch/create.js
+var INCLUDE_HEADERS = {
+  includeIndex: true,
+  includeUnderline: true,
+  includeFileHeaders: true
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i2 = 0;i2 < diff.length; i2++) {
+      const current = diff[i2], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i2 - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i2 < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i2 = 0;i2 < hunk.lines.length; i2++) {
+        if (hunk.lines[i2].endsWith(`
+`)) {
+          hunk.lines[i2] = hunk.lines[i2].slice(0, -1);
+        } else {
+          hunk.lines.splice(i2 + 1, 0, "\");
+          i2++;
+        }
       }
     }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
   }
-  if (inHunk && hunkLines.length > 0) {
-    diff += `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
-`;
-    diff += hunkLines.join(`
+}
+function formatPatch(patch, headerOptions) {
+  if (!headerOptions) {
+    headerOptions = INCLUDE_HEADERS;
+  }
+  if (Array.isArray(patch)) {
+    if (patch.length > 1 && !headerOptions.includeFileHeaders) {
+      throw new Error("Cannot omit file headers on a multi-file patch. " + "(The result would be unparseable; how would a tool trying to apply " + "the patch know which changes are to which file?)");
+    }
+    return patch.map((p) => formatPatch(p, headerOptions)).join(`
+`);
+  }
+  const ret = [];
+  if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  if (headerOptions.includeUnderline) {
+    ret.push("===================================================================");
+  }
+  if (headerOptions.includeFileHeaders) {
+    ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "\t" + patch.oldHeader));
+    ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "\t" + patch.newHeader));
+  }
+  for (let i2 = 0;i2 < patch.hunks.length; i2++) {
+    const hunk = patch.hunks[i2];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join(`
 `) + `
 `;
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
   }
-  return diff || `--- ${filePath}
-+++ ${filePath}
-`;
+  if (!(options === null || options === undefined ? undefined : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj, options === null || options === undefined ? undefined : options.headerOptions);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(undefined);
+      } else {
+        callback(formatPatch(patchObj, options.headerOptions));
+      }
+    } }));
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith(`
+`);
+  const result = text.split(`
+`).map((line) => line + `
+`);
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+// src/tools/hashline-edit/diff-utils.ts
+function generateUnifiedDiff(oldContent, newContent, filePath) {
+  return createTwoFilesPatch(filePath, filePath, oldContent, newContent, undefined, undefined, { context: 3 });
 }
 function countLineDiffs(oldContent, newContent) {
   const oldLines = oldContent.split(`
@@ -57979,7 +59308,7 @@ function resolveToolCallID2(ctx) {
 function canCreateFromMissingFile(edits) {
   if (edits.length === 0)
     return false;
-  return edits.every((edit) => edit.op === "append" || edit.op === "prepend");
+  return edits.every((edit) => (edit.op === "append" || edit.op === "prepend") && !edit.pos);
 }
 function buildSuccessMeta(effectivePath, beforeContent, afterContent, noopEdits, deduplicatedEdits) {
   const unifiedDiff = generateUnifiedDiff(beforeContent, afterContent, effectivePath);
@@ -58023,16 +59352,16 @@ async function executeHashlineEditTool(args, context) {
     const metadataContext = context;
     const filePath = args.filePath;
     const { delete: deleteMode, rename } = args;
-    if (!deleteMode && (!args.edits || !Array.isArray(args.edits) || args.edits.length === 0)) {
-      return "Error: edits parameter must be a non-empty array";
-    }
-    const edits = deleteMode ? [] : normalizeHashlineEdits(args.edits);
     if (deleteMode && rename) {
       return "Error: delete and rename cannot be used together";
     }
-    if (deleteMode && edits.length > 0) {
+    if (deleteMode && args.edits.length > 0) {
       return "Error: delete mode requires edits to be an empty array";
     }
+    if (!deleteMode && (!args.edits || !Array.isArray(args.edits) || args.edits.length === 0)) {
+      return "Error: edits parameter must be a non-empty array";
+    }
+    const edits = deleteMode ? [] : normalizeHashlineEdits(args.edits);
     const file2 = Bun.file(filePath);
     const exists = await file2.exists();
     if (!exists && !deleteMode && !canCreateFromMissingFile(edits)) {
@@ -58097,7 +59426,7 @@ WORKFLOW:
 VALIDATION:
   Payload shape: { "filePath": string, "edits": [...], "delete"?: boolean, "rename"?: string }
   Each edit must be one of: replace, append, prepend
-  Edit shape: { "op": "replace"|"append"|"prepend", "pos"?: "LINE#ID", "end"?: "LINE#ID", "lines"?: string|string[]|null }
+  Edit shape: { "op": "replace"|"append"|"prepend", "pos"?: "LINE#ID", "end"?: "LINE#ID", "lines": string|string[]|null }
   lines must contain plain replacement text only (no LINE#ID prefixes, no diff + markers)
   CRITICAL: all operations validate against the same pre-edit file snapshot and apply bottom-up. Refs/tags are interpreted against the last-read version of the file.
 
@@ -58171,7 +59500,7 @@ function createHashlineEditTool() {
         ]).describe("Hashline edit operation mode"),
         pos: tool.schema.string().optional().describe("Primary anchor in LINE#ID format"),
         end: tool.schema.string().optional().describe("Range end anchor in LINE#ID format"),
-        lines: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string()), tool.schema.null()]).optional().describe("Replacement or inserted lines. null/[] deletes with replace")
+        lines: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string()), tool.schema.null()]).describe("Replacement or inserted lines. null/[] deletes with replace")
       })).describe("Array of edit operations to apply (empty when delete=true)")
     },
     execute: async (args, context) => executeHashlineEditTool(args, context)
@@ -58281,7 +59610,9 @@ function createSessionHooks(args) {
   const prometheusMdOnly = isHookEnabled("prometheus-md-only") ? safeHook("prometheus-md-only", () => createPrometheusMdOnlyHook(ctx)) : null;
   const sisyphusJuniorNotepad = isHookEnabled("sisyphus-junior-notepad") ? safeHook("sisyphus-junior-notepad", () => createSisyphusJuniorNotepadHook(ctx)) : null;
   const noSisyphusGpt = isHookEnabled("no-sisyphus-gpt") ? safeHook("no-sisyphus-gpt", () => createNoSisyphusGptHook(ctx)) : null;
-  const noHephaestusNonGpt = isHookEnabled("no-hephaestus-non-gpt") ? safeHook("no-hephaestus-non-gpt", () => createNoHephaestusNonGptHook(ctx)) : null;
+  const noHephaestusNonGpt = isHookEnabled("no-hephaestus-non-gpt") ? safeHook("no-hephaestus-non-gpt", () => createNoHephaestusNonGptHook(ctx, {
+    allowNonGptModel: pluginConfig.agents?.hephaestus?.allow_non_gpt_model
+  })) : null;
   const questionLabelTruncator = isHookEnabled("question-label-truncator") ? safeHook("question-label-truncator", () => createQuestionLabelTruncatorHook()) : null;
   const taskResumeInfo = isHookEnabled("task-resume-info") ? safeHook("task-resume-info", () => createTaskResumeInfoHook()) : null;
   const anthropicEffort = isHookEnabled("anthropic-effort") ? safeHook("anthropic-effort", () => createAnthropicEffortHook()) : null;
@@ -58344,8 +59675,9 @@ function createToolGuardHooks(args) {
   const rulesInjector = isHookEnabled("rules-injector") ? safeHook("rules-injector", () => createRulesInjectorHook(ctx, modelCacheState)) : null;
   const tasksTodowriteDisabler = isHookEnabled("tasks-todowrite-disabler") ? safeHook("tasks-todowrite-disabler", () => createTasksTodowriteDisablerHook({ experimental: pluginConfig.experimental })) : null;
   const writeExistingFileGuard = isHookEnabled("write-existing-file-guard") ? safeHook("write-existing-file-guard", () => createWriteExistingFileGuardHook(ctx)) : null;
-  const hashlineReadEnhancer = isHookEnabled("hashline-read-enhancer") ? safeHook("hashline-read-enhancer", () => createHashlineReadEnhancerHook(ctx, { hashline_edit: { enabled: pluginConfig.hashline_edit ?? true } })) : null;
+  const hashlineReadEnhancer = isHookEnabled("hashline-read-enhancer") ? safeHook("hashline-read-enhancer", () => createHashlineReadEnhancerHook(ctx, { hashline_edit: { enabled: pluginConfig.hashline_edit ?? false } })) : null;
   const jsonErrorRecovery = isHookEnabled("json-error-recovery") ? safeHook("json-error-recovery", () => createJsonErrorRecoveryHook(ctx)) : null;
+  const readImageResizer = isHookEnabled("read-image-resizer") ? safeHook("read-image-resizer", () => createReadImageResizerHook(ctx)) : null;
   return {
     commentChecker,
     toolOutputTruncator,
@@ -58356,7 +59688,8 @@ function createToolGuardHooks(args) {
     tasksTodowriteDisabler,
     writeExistingFileGuard,
     hashlineReadEnhancer,
-    jsonErrorRecovery
+    jsonErrorRecovery,
+    readImageResizer
   };
 }
 
@@ -58372,6 +59705,7 @@ var CONTEXT_SEPARATOR = `
 ---
 
 `;
+var registrationCounter = 0;
 
 class ContextCollector {
   sessions = new Map;
@@ -58386,7 +59720,7 @@ class ContextCollector {
       source: options.source,
       content: options.content,
       priority: options.priority ?? "normal",
-      timestamp: Date.now(),
+      registrationOrder: ++registrationCounter,
       metadata: options.metadata
     };
     sessionMap.set(key, entry);
@@ -58425,7 +59759,7 @@ class ContextCollector {
       const priorityDiff = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
       if (priorityDiff !== 0)
         return priorityDiff;
-      return a.timestamp - b.timestamp;
+      return a.registrationOrder - b.registrationOrder;
     });
   }
 }
@@ -58486,7 +59820,7 @@ function createContextInjectorMessagesTransformHook(collector) {
         return;
       }
       const syntheticPart = {
-        id: `synthetic_hook_${Date.now()}`,
+        id: `synthetic_hook_${sessionID}`,
         messageID: lastUserMessage.info.id,
         sessionID: lastUserMessage.info.sessionID ?? "",
         type: "text",
@@ -58591,7 +59925,9 @@ function createContinuationHooks(args) {
     sessionRecovery
   } = args;
   const safeHook = (hookName, factory) => safeCreateHook(hookName, factory, { enabled: safeHookEnabled });
-  const stopContinuationGuard = isHookEnabled("stop-continuation-guard") ? safeHook("stop-continuation-guard", () => createStopContinuationGuardHook(ctx)) : null;
+  const stopContinuationGuard = isHookEnabled("stop-continuation-guard") ? safeHook("stop-continuation-guard", () => createStopContinuationGuardHook(ctx, {
+    backgroundManager
+  })) : null;
   const compactionContextInjector = isHookEnabled("compaction-context-injector") ? safeHook("compaction-context-injector", () => createCompactionContextInjector(backgroundManager)) : null;
   const compactionTodoPreserver = isHookEnabled("compaction-todo-preserver") ? safeHook("compaction-todo-preserver", () => createCompactionTodoPreserverHook(ctx)) : null;
   const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? safeHook("todo-continuation-enforcer", () => createTodoContinuationEnforcer(ctx, {
@@ -58779,14 +60115,14 @@ class ConcurrencyManager {
       this.counts.set(model, current + 1);
       return;
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve13, reject) => {
       const queue = this.queues.get(model) ?? [];
       const entry = {
         resolve: () => {
           if (entry.settled)
             return;
           entry.settled = true;
-          resolve10();
+          resolve13();
         },
         rawReject: reject,
         settled: false
@@ -59307,6 +60643,7 @@ async function checkAndInterruptStaleTasks(args) {
 class BackgroundManager {
   tasks;
   notifications;
+  pendingNotifications;
   pendingByParent;
   client;
   directory;
@@ -59328,6 +60665,7 @@ class BackgroundManager {
   constructor(ctx, config3, options) {
     this.tasks = new Map;
     this.notifications = new Map;
+    this.pendingNotifications = new Map;
     this.pendingByParent = new Map;
     this.client = ctx.client;
     this.directory = ctx.directory;
@@ -59893,6 +61231,7 @@ class BackgroundManager {
       for (const descendant of this.getAllDescendantTasks(sessionID)) {
         tasksToCancel.set(descendant.id, descendant);
       }
+      this.pendingNotifications.delete(sessionID);
       if (tasksToCancel.size === 0)
         return;
       for (const task of tasksToCancel.values()) {
@@ -59926,6 +61265,11 @@ class BackgroundManager {
           subagentSessions.delete(task.sessionID);
         }
       }
+      for (const task of tasksToCancel.values()) {
+        if (task.parentSessionID) {
+          this.pendingNotifications.delete(task.parentSessionID);
+        }
+      }
       SessionCategoryRegistry.remove(sessionID);
     }
     if (event.type === "session.status") {
@@ -59969,6 +61313,34 @@ class BackgroundManager {
   clearNotifications(sessionID) {
     this.notifications.delete(sessionID);
   }
+  queuePendingNotification(sessionID, notification2) {
+    if (!sessionID)
+      return;
+    const existingNotifications = this.pendingNotifications.get(sessionID) ?? [];
+    existingNotifications.push(notification2);
+    this.pendingNotifications.set(sessionID, existingNotifications);
+  }
+  injectPendingNotificationsIntoChatMessage(output, sessionID) {
+    const pendingNotifications = this.pendingNotifications.get(sessionID);
+    if (!pendingNotifications || pendingNotifications.length === 0) {
+      return;
+    }
+    this.pendingNotifications.delete(sessionID);
+    const notificationContent = pendingNotifications.join(`
+
+`);
+    const firstTextPartIndex = output.parts.findIndex((part) => part.type === "text");
+    if (firstTextPartIndex === -1) {
+      output.parts.unshift(createInternalAgentTextPart(notificationContent));
+      return;
+    }
+    const originalText = output.parts[firstTextPartIndex].text ?? "";
+    output.parts[firstTextPartIndex].text = `${notificationContent}
+
+---
+
+${originalText}`;
+  }
   async validateSessionHasOutput(sessionID) {
     try {
       const response = await this.client.session.messages({
@@ -60264,6 +61636,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
             taskId: task.id,
             parentSessionID: task.parentSessionID
           });
+          this.queuePendingNotification(task.parentSessionID, notification2);
         } else {
           log("[background-agent] Failed to send notification:", error45);
         }
@@ -60452,6 +61825,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     this.concurrencyManager.clear();
     this.tasks.clear();
     this.notifications.clear();
+    this.pendingNotifications.clear();
     this.pendingByParent.clear();
     this.notificationQueueByParent.clear();
     this.queuesByKey.clear();
@@ -62003,7 +63377,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve10) => setTimeout(resolve10, pollInterval));
+        await new Promise((resolve13) => setTimeout(resolve13, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error45) {
@@ -62015,7 +63389,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve13, reject) => {
       const earlyReject = (error45) => {
         reject(error45);
       };
@@ -62093,7 +63467,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve10(parseResult.data);
+            resolve13(parseResult.data);
           }
         } catch (error45) {
           reject(error45);
@@ -62284,12 +63658,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve13, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve10, interval);
+      const timeoutId = setTimeout(resolve13, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -63027,8 +64401,8 @@ async function random(size) {
   const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
   let result = "";
   while (result.length < size) {
-    const randomBytes = await getRandomValues(size - result.length);
-    for (const randomByte of randomBytes) {
+    const randomBytes2 = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes2) {
       if (randomByte < evenDistCutoff) {
         result += mask[randomByte % mask.length];
       }
@@ -63834,7 +65208,7 @@ function createParser(callbacks) {
   const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
   let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
   function feed(newChunk) {
-    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines2(`${incompleteLine}${chunk}`);
     for (const line of complete)
       parseLine(line);
     incompleteLine = incomplete, isFirstChunk = false;
@@ -63893,7 +65267,7 @@ function createParser(callbacks) {
   }
   return { feed, reset };
 }
-function splitLines(chunk) {
+function splitLines2(chunk) {
   const lines = [];
   let incompleteLine = "", searchIndex = 0;
   for (;searchIndex < chunk.length; ) {
@@ -64533,10 +65907,10 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
 import { spawn as spawn13 } from "child_process";
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
 import { createServer } from "http";
 function generateCodeVerifier() {
-  return randomBytes(32).toString("base64url");
+  return randomBytes2(32).toString("base64url");
 }
 function generateCodeChallenge(verifier) {
   return createHash2("sha256").update(verifier).digest("base64url");
@@ -64559,7 +65933,7 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve13, reject) => {
     let timeoutId;
     const server = createServer((request, response) => {
       clearTimeout(timeoutId);
@@ -64585,7 +65959,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server.close();
-      resolve10({ code, state: state3 });
+      resolve13({ code, state: state3 });
     });
     timeoutId = setTimeout(() => {
       server.close();
@@ -64621,7 +65995,7 @@ function openBrowser(url2) {
 async function runAuthorizationCodeRedirect(options) {
   const verifier = generateCodeVerifier();
   const challenge = generateCodeChallenge(verifier);
-  const state3 = randomBytes(16).toString("hex");
+  const state3 = randomBytes2(16).toString("hex");
   const authorizationUrl = buildAuthorizationUrl(options.authorizationEndpoint, {
     clientId: options.clientId,
     redirectUri: options.redirectUri,
@@ -65037,7 +66411,7 @@ class StdioClientTransport {
     if (this._process) {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve13, reject) => {
       this._process = import_cross_spawn.default(this._serverParams.command, this._serverParams.args ?? [], {
         env: {
           ...getDefaultEnvironment(),
@@ -65053,7 +66427,7 @@ class StdioClientTransport {
         this.onerror?.(error45);
       });
       this._process.on("spawn", () => {
-        resolve10();
+        resolve13();
       });
       this._process.on("close", (_code) => {
         this._process = undefined;
@@ -65100,20 +66474,20 @@ class StdioClientTransport {
     if (this._process) {
       const processToClose = this._process;
       this._process = undefined;
-      const closePromise = new Promise((resolve10) => {
+      const closePromise = new Promise((resolve13) => {
         processToClose.once("close", () => {
-          resolve10();
+          resolve13();
         });
       });
       try {
         processToClose.stdin?.end();
       } catch {}
-      await Promise.race([closePromise, new Promise((resolve10) => setTimeout(resolve10, 2000).unref())]);
+      await Promise.race([closePromise, new Promise((resolve13) => setTimeout(resolve13, 2000).unref())]);
       if (processToClose.exitCode === null) {
         try {
           processToClose.kill("SIGTERM");
         } catch {}
-        await Promise.race([closePromise, new Promise((resolve10) => setTimeout(resolve10, 2000).unref())]);
+        await Promise.race([closePromise, new Promise((resolve13) => setTimeout(resolve13, 2000).unref())]);
       }
       if (processToClose.exitCode === null) {
         try {
@@ -65124,15 +66498,15 @@ class StdioClientTransport {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve13) => {
       if (!this._process?.stdin) {
         throw new Error("Not connected");
       }
       const json3 = serializeMessage(message);
       if (this._process.stdin.write(json3)) {
-        resolve10();
+        resolve13();
       } else {
-        this._process.stdin.once("drain", resolve10);
+        this._process.stdin.once("drain", resolve13);
       }
     });
   }
@@ -66225,7 +67599,7 @@ class TmuxSessionManager {
       } catch (err) {
         log("[tmux-session-manager] session status check error", { error: String(err) });
       }
-      await new Promise((resolve10) => setTimeout(resolve10, SESSION_READY_POLL_INTERVAL_MS));
+      await new Promise((resolve13) => setTimeout(resolve13, SESSION_READY_POLL_INTERVAL_MS));
     }
     log("[tmux-session-manager] session ready timeout", {
       sessionId,
@@ -66480,6 +67854,134 @@ Before responding, enumerate in your head:
 Then ACTUALLY CALL those tools using the JSON tool schema. Produce the tool_use blocks. Execute.
 </TOOL_CALL_MANDATE>`;
 }
+function buildGeminiToolGuide() {
+  return `<GEMINI_TOOL_GUIDE>
+## Tool Usage Guide \u2014 WHEN and HOW to Call Each Tool
+
+You have access to tools via function calling. This guide defines WHEN to call each one.
+**Violating these patterns = failed response.**
+
+### Reading & Search (ALWAYS parallelizable \u2014 call multiple simultaneously)
+
+| Tool | When to Call | Parallel? |
+|---|---|---|
+| \`Read\` | Before making ANY claim about file contents. Before editing any file. | \uFFFD Yes \u2014 read multiple files at once |
+| \`Grep\` | Finding patterns, imports, usages across codebase. BEFORE claiming "X is used in Y". | \u2705 Yes \u2014 run multiple greps at once |
+| \`Glob\` | Finding files by name/extension pattern. BEFORE claiming "file X exists". | \u2705 Yes \u2014 run multiple globs at once |
+| \`AstGrepSearch\` | Finding code patterns with AST awareness (structural matches). | \u2705 Yes |
+
+### Code Intelligence (parallelizable on different files)
+
+| Tool | When to Call | Parallel? |
+|---|---|---|
+| \`LspDiagnostics\` | **AFTER EVERY edit.** BEFORE claiming task is done. MANDATORY. | \u2705 Yes \u2014 different files |
+| \`LspGotoDefinition\` | Finding where a symbol is defined. | \u2705 Yes |
+| \`LspFindReferences\` | Finding all usages of a symbol across workspace. | \u2705 Yes |
+| \`LspSymbols\` | Getting file outline or searching workspace symbols. | \u2705 Yes |
+
+### Editing (SEQUENTIAL \u2014 must Read first)
+
+| Tool | When to Call | Parallel? |
+|---|---|---|
+| \`Edit\` | Modifying existing files. MUST Read file first to get LINE#ID anchors. | \u274C After Read |
+| \`Write\` | Creating NEW files only. Or full file overwrite. | \u274C Sequential |
+
+### Execution & Delegation
+
+| Tool | When to Call | Parallel? |
+|---|---|---|
+| \`Bash\` | Running tests, builds, git commands. | \u274C Usually sequential |
+| \`Task\` | ANY non-trivial implementation. Research via explore/librarian. | \u2705 Fire multiple in background |
+
+### Correct Sequences (MANDATORY \u2014 follow these exactly):
+
+1. **Answer about code**: Read \u2192 (analyze) \u2192 Answer
+2. **Edit code**: Read \u2192 Edit \u2192 LspDiagnostics \u2192 Report
+3. **Find something**: Grep/Glob (parallel) \u2192 Read results \u2192 Report
+4. **Implement feature**: Task(delegate) \u2192 Verify results \u2192 Report
+5. **Debug**: Read error \u2192 Read file \u2192 Grep related \u2192 Fix \u2192 LspDiagnostics
+
+### PARALLEL RULES:
+
+- **Independent reads/searches**: ALWAYS call simultaneously in ONE response
+- **Dependent operations**: Call sequentially (Edit AFTER Read, LspDiagnostics AFTER Edit)
+- **Background agents**: ALWAYS \`run_in_background=true\`, continue working
+</GEMINI_TOOL_GUIDE>`;
+}
+function buildGeminiToolCallExamples() {
+  return `<GEMINI_TOOL_CALL_EXAMPLES>
+## Correct Tool Calling Patterns \u2014 Follow These Examples
+
+### Example 1: User asks about code \u2192 Read FIRST, then answer
+**User**: "How does the auth middleware work?"
+**CORRECT**:
+\`\`\`
+\u2192 Call Read(filePath="/src/middleware/auth.ts")
+\u2192 Call Read(filePath="/src/config/auth.ts")  // parallel with above
+\u2192 (After reading) Answer based on ACTUAL file contents
+\`\`\`
+**WRONG**:
+\`\`\`
+\u2192 "The auth middleware likely validates JWT tokens by..." \u2190 HALLUCINATION. You didn't read the file.
+\`\`\`
+
+### Example 2: User asks to edit code \u2192 Read, Edit, Verify
+**User**: "Fix the type error in user.ts"
+**CORRECT**:
+\`\`\`
+\u2192 Call Read(filePath="/src/models/user.ts")
+\u2192 Call LspDiagnostics(filePath="/src/models/user.ts")  // parallel with Read
+\u2192 (After reading) Call Edit with LINE#ID anchors
+\u2192 Call LspDiagnostics(filePath="/src/models/user.ts")  // verify fix
+\u2192 Report: "Fixed. Diagnostics clean."
+\`\`\`
+**WRONG**:
+\`\`\`
+\u2192 Call Edit without reading first \u2190 No LINE#ID anchors = WILL FAIL
+\u2192 Skip LspDiagnostics after edit \u2190 UNVERIFIED
+\`\`\`
+
+### Example 3: User asks to find something \u2192 Search in parallel
+**User**: "Where is the database connection configured?"
+**CORRECT**:
+\`\`\`
+\u2192 Call Grep(pattern="database|connection|pool", path="/src")  // fires simultaneously
+\u2192 Call Glob(pattern="**/*database*")                          // fires simultaneously
+\u2192 Call Glob(pattern="**/*db*")                                 // fires simultaneously
+\u2192 (After results) Read the most relevant files
+\u2192 Report findings with file paths
+\`\`\`
+
+### Example 4: User asks to implement a feature \u2192 DELEGATE
+**User**: "Add a new /health endpoint to the API"
+**CORRECT**:
+\`\`\`
+\u2192 Call Task(category="quick", load_skills=["typescript-programmer"], prompt="...")
+\u2192 (After agent completes) Read changed files to verify
+\u2192 Call LspDiagnostics on changed files
+\u2192 Report
+\`\`\`
+**WRONG**:
+\`\`\`
+\u2192 Write the code yourself \u2190 YOU ARE AN ORCHESTRATOR, NOT AN IMPLEMENTER
+\`\`\`
+
+### Example 5: Investigation \u2260 Implementation
+**User**: "Look into why the tests are failing"
+**CORRECT**:
+\`\`\`
+\u2192 Call Bash(command="npm test")  // see actual failures
+\u2192 Call Read on failing test files
+\u2192 Call Read on source files under test
+\u2192 Report: "Tests fail because X. Root cause: Y. Proposed fix: Z."
+\u2192 STOP \u2014 wait for user to say "fix it"
+\`\`\`
+**WRONG**:
+\`\`\`
+\u2192 Start editing source files immediately \u2190 "look into" \u2260 "fix"
+\`\`\`
+</GEMINI_TOOL_CALL_EXAMPLES>`;
+}
 function buildGeminiDelegationOverride() {
   return `<GEMINI_DELEGATION_OVERRIDE>
 ## DELEGATION IS MANDATORY \u2014 YOU ARE NOT AN IMPLEMENTER
@@ -66781,12 +68283,11 @@ Briefly announce "Consulting Oracle for [reason]" before invocation.
 
 ### Oracle Background Task Policy:
 
-**You MUST collect Oracle results before your final answer. No exceptions.**
+**Collect Oracle results before your final answer. No exceptions.**
 
-- Oracle may take several minutes. This is normal and expected.
-- When Oracle is running and you finish your own exploration/analysis, your next action is \`background_output(task_id="...")\` on Oracle \u2014 NOT delivering a final answer.
-- Oracle catches blind spots you cannot see \u2014 its value is HIGHEST when you think you don't need it.
-- **NEVER** cancel Oracle. **NEVER** use \`background_cancel(all=true)\` when Oracle is running. Cancel disposable tasks (explore, librarian) individually by taskId instead.
+- Oracle takes minutes. When done with your own work: **end your response** \u2014 wait for the \`<system-reminder>\`.
+- Do NOT poll \`background_output\` on a running Oracle. The notification will come.
+- Never cancel Oracle.
 </Oracle_Usage>`;
 }
 function buildHardBlocksSection() {
@@ -66795,8 +68296,8 @@ function buildHardBlocksSection() {
     "- Commit without explicit request \u2014 **Never**",
     "- Speculate about unread code \u2014 **Never**",
     "- Leave code in broken state after failures \u2014 **Never**",
-    "- `background_cancel(all=true)` when Oracle is running \u2014 **Never.** Cancel tasks individually by taskId.",
-    "- Delivering final answer before collecting Oracle result \u2014 **Never.** Always `background_output` Oracle first."
+    "- `background_cancel(all=true)` \u2014 **Never.** Always cancel individually by taskId.",
+    "- Delivering final answer before collecting Oracle result \u2014 **Never.**"
   ];
   return `## Hard Blocks (NEVER violate)
 
@@ -66810,14 +68311,29 @@ function buildAntiPatternsSection() {
     '- **Testing**: Deleting failing tests to "pass"',
     "- **Search**: Firing agents for single-line typos or obvious syntax errors",
     "- **Debugging**: Shotgun debugging, random changes",
-    "- **Background Tasks**: `background_cancel(all=true)` \u2014 always cancel individually by taskId",
-    "- **Oracle**: Skipping Oracle results when Oracle was launched \u2014 ALWAYS collect via `background_output`"
+    "- **Background Tasks**: Polling `background_output` on running tasks \u2014 end response and wait for notification",
+    "- **Oracle**: Delivering answer without collecting Oracle results"
   ];
   return `## Anti-Patterns (BLOCKING violations)
 
 ${patterns.join(`
 `)}`;
 }
+function buildNonClaudePlannerSection(model) {
+  const isNonClaude = !model.toLowerCase().includes("claude");
+  if (!isNonClaude)
+    return "";
+  return `### Plan Agent Dependency (Non-Claude)
+
+Multi-step task? **ALWAYS consult Plan Agent first.** Do NOT start implementation without a plan.
+
+- Single-file fix or trivial change \u2192 proceed directly
+- Anything else (2+ steps, unclear scope, architecture) \u2192 \`task(subagent_type="plan", ...)\` FIRST
+- Use \`session_id\` to resume the same Plan Agent \u2014 ask follow-up questions aggressively
+- If ANY part of the task is ambiguous, ask Plan Agent before guessing
+
+Plan Agent returns a structured work breakdown with parallel execution opportunities. Follow it.`;
+}
 function buildDeepParallelSection(model, categories2) {
   const isNonClaude = !model.toLowerCase().includes("claude");
   const hasDeepCategory = categories2.some((c) => c.name === "deep");
@@ -66825,16 +68341,17 @@ function buildDeepParallelSection(model, categories2) {
     return "";
   return `### Deep Parallel Delegation
 
-For implementation tasks, actively decompose and delegate to \`deep\` category agents in parallel.
+Delegate EVERY independent unit to a \`deep\` agent in parallel (\`run_in_background=true\`).
+If a task decomposes into 4 independent units, spawn 4 agents simultaneously \u2014 not 1 at a time.
 
-1. Break the implementation into independent work units
-2. Maximize parallel deep agents \u2014 spawn one per independent unit (\`run_in_background=true\`)
-3. Give each agent a GOAL, not step-by-step instructions \u2014 deep agents explore and solve autonomously
-4. Collect results, integrate, verify coherence`;
+1. Decompose the implementation into independent work units
+2. Assign one \`deep\` agent per unit \u2014 all via \`run_in_background=true\`
+3. Give each agent a clear GOAL with success criteria, not step-by-step instructions
+4. Collect all results, integrate, verify coherence across units`;
 }
 
 // src/agents/sisyphus.ts
-var MODE = "primary";
+var MODE = "all";
 function buildTaskManagementSection(useTaskSystem) {
   if (useTaskSystem) {
     return `<Task_Management>
@@ -66954,6 +68471,7 @@ function buildDynamicSisyphusPrompt(model, availableAgents, availableTools = [],
   const hardBlocks = buildHardBlocksSection();
   const antiPatterns = buildAntiPatternsSection();
   const deepParallelSection = buildDeepParallelSection(model, availableCategories);
+  const nonClaudePlannerSection = buildNonClaudePlannerSection(model);
   const taskManagementSection = buildTaskManagementSection(useTaskSystem);
   const todoHookNote = useTaskSystem ? "YOUR TASK CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TASK CONTINUATION])" : "YOUR TODO CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TODO CONTINUATION])";
   return `<Role>
@@ -67110,7 +68628,7 @@ task(subagent_type="explore", run_in_background=true, load_skills=[], descriptio
 // Reference Grep (external)
 task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find JWT security docs", prompt="I'm implementing JWT auth and need current security best practices to choose token storage (httpOnly cookies vs localStorage) and set expiration policy. Find: OWASP auth guidelines, recommended token lifetimes, refresh token rotation strategies, common JWT vulnerabilities. Skip 'what is JWT' tutorials \u2014 production security guidance only.")
 task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find Express auth patterns", prompt="I'm building Express auth middleware and need production-quality patterns to structure my middleware chain. Find how established Express apps (1000+ stars) handle: middleware ordering, token refresh, role-based access control, auth error propagation. Skip basic tutorials \u2014 I need battle-tested patterns with proper error handling.")
-// Continue working immediately. Collect with background_output when needed.
+// Continue working immediately. System notifies on completion \u2014 collect with background_output then.
 
 // WRONG: Sequential or blocking
 result = task(..., run_in_background=false)  // Never wait synchronously for explore/librarian
@@ -67118,10 +68636,10 @@ result = task(..., run_in_background=false)  // Never wait synchronously for exp
 
 ### Background Result Collection:
 1. Launch parallel agents \u2192 receive task_ids
-2. Continue immediate work (explore, librarian results)
-3. When results needed: \`background_output(task_id="...")\`
-4. **If Oracle is running**: STOP all other output. Follow Oracle Completion Protocol in <Oracle_Usage>.
-5. Cleanup: Cancel disposable tasks (explore, librarian) individually via \`background_cancel(taskId="...")\`. Never use \`background_cancel(all=true)\`.
+2. Continue immediate work
+3. System sends \`<system-reminder>\` on each task completion \u2014 then call \`background_output(task_id="...")\`
+4. Need results not yet ready? **End your response.** The notification will trigger your next turn.
+5. Cleanup: Cancel disposable tasks individually via \`background_cancel(taskId="...")\`
 
 ### Search Stop Conditions
 
@@ -67145,6 +68663,8 @@ STOP searching when:
 
 ${categorySkillsGuide}
 
+${nonClaudePlannerSection}
+
 ${deepParallelSection}
 
 ${delegationTable}
@@ -67258,9 +68778,8 @@ If verification fails:
 3. Report: "Done. Note: found N pre-existing lint errors unrelated to my changes."
 
 ### Before Delivering Final Answer:
-- **If Oracle is running**: STOP. Follow Oracle Completion Protocol in <Oracle_Usage>. Do NOT deliver any answer.
-- Cancel disposable background tasks (explore, librarian) individually via \`background_cancel(taskId="...")\`.
-- **Never use \`background_cancel(all=true)\`.**
+- If Oracle is running: **end your response** and wait for the completion notification first.
+- Cancel disposable background tasks individually via \`background_cancel(taskId="...")\`.
 </Behavior_Instructions>
 
 ${oracleSection}
@@ -67333,10 +68852,16 @@ function createSisyphusAgent(model, availableAgents, availableToolNames, availab
 ${buildGeminiIntentGateEnforcement()}
 
 ${buildGeminiToolMandate()}`);
-    prompt += `
-` + buildGeminiDelegationOverride();
-    prompt += `
-` + buildGeminiVerificationOverride();
+    prompt = prompt.replace("</tool_usage_rules>", `</tool_usage_rules>
+
+${buildGeminiToolGuide()}
+
+${buildGeminiToolCallExamples()}`);
+    prompt = prompt.replace("<Constraints>", `${buildGeminiDelegationOverride()}
+
+${buildGeminiVerificationOverride()}
+
+<Constraints>`);
   }
   const permission = {
     question: "allow",
@@ -69544,7 +71069,7 @@ ${agentRows.join(`
 }
 
 // src/agents/atlas/agent.ts
-var MODE7 = "primary";
+var MODE7 = "all";
 function getAtlasPromptSource(model) {
   if (model && isGptModel(model)) {
     return "gpt";
@@ -69585,18 +71110,13 @@ function buildDynamicOrchestratorPrompt(ctx) {
   return basePrompt.replace("{CATEGORY_SECTION}", categorySection).replace("{AGENT_SECTION}", agentSection).replace("{DECISION_MATRIX}", decisionMatrix).replace("{SKILLS_SECTION}", skillsSection).replace("{{CATEGORY_SKILLS_DELEGATION_GUIDE}}", categorySkillsGuide);
 }
 function createAtlasAgent(ctx) {
-  const restrictions = createAgentToolRestrictions([
-    "task",
-    "call_omo_agent"
-  ]);
   const baseConfig = {
     description: "Orchestrates work via task() to complete ALL tasks in a todo list until fully done. (Atlas - OhMyOpenCode)",
     mode: MODE7,
     ...ctx.model ? { model: ctx.model } : {},
     temperature: 0.1,
     prompt: buildDynamicOrchestratorPrompt(ctx),
-    color: "#10B981",
-    ...restrictions
+    color: "#10B981"
   };
   return baseConfig;
 }
@@ -69847,7 +71367,7 @@ var momusPromptMetadata = {
 };
 
 // src/agents/hephaestus.ts
-var MODE9 = "primary";
+var MODE9 = "all";
 function buildTodoDisciplineSection(useTaskSystem) {
   if (useTaskSystem) {
     return `## Task Discipline (NON-NEGOTIABLE)
@@ -70377,7 +71897,7 @@ function buildAgent(source, model, categories2, gitMasterConfig, browserProvider
 // src/agents/builtin-agents/resolve-file-uri.ts
 import { existsSync as existsSync64, readFileSync as readFileSync44 } from "fs";
 import { homedir as homedir13 } from "os";
-import { isAbsolute as isAbsolute9, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute9, resolve as resolve13 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
   if (!promptAppend.startsWith("file://"))
     return promptAppend;
@@ -70386,7 +71906,7 @@ function resolvePromptAppend(promptAppend, configDir) {
   try {
     const decoded = decodeURIComponent(encoded);
     const expanded = decoded.startsWith("~/") ? decoded.replace(/^~\//, `${homedir13()}/`) : decoded;
-    filePath = isAbsolute9(expanded) ? expanded : resolve10(configDir ?? process.cwd(), expanded);
+    filePath = isAbsolute9(expanded) ? expanded : resolve13(configDir ?? process.cwd(), expanded);
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
@@ -70452,25 +71972,10 @@ function applyOverrides(config3, override, mergedCategories, directory) {
 
 // src/agents/env-context.ts
 function createEnvContext() {
-  const now = new Date;
   const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
   const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-  const dateStr = now.toLocaleDateString(locale, {
-    weekday: "short",
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-  });
-  const timeStr = now.toLocaleTimeString(locale, {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: true
-  });
   return `
 <omo-env>
-  Current date: ${dateStr}
-  Current time: ${timeStr}
   Timezone: ${timezone}
   Locale: ${locale}
 </omo-env>`;
@@ -73701,6 +75206,8 @@ async function applyAgentConfig(params) {
     key,
     value ? migrateAgentConfig(value) : value
   ]));
+  const disabledAgentNames = new Set((migratedDisabledAgents ?? []).map((a) => a.toLowerCase()));
+  const filterDisabledAgents = (agents) => Object.fromEntries(Object.entries(agents).filter(([name]) => !disabledAgentNames.has(name.toLowerCase())));
   const isSisyphusEnabled = params.pluginConfig.sisyphus_agent?.disabled !== true;
   const builderEnabled = params.pluginConfig.sisyphus_agent?.default_builder_enabled ?? false;
   const plannerEnabled = params.pluginConfig.sisyphus_agent?.planner_enabled ?? true;
@@ -73754,9 +75261,9 @@ async function applyAgentConfig(params) {
     params.config.agent = {
       ...agentConfig,
       ...Object.fromEntries(Object.entries(builtinAgents).filter(([key]) => key !== "sisyphus")),
-      ...userAgents,
-      ...projectAgents,
-      ...pluginAgents,
+      ...filterDisabledAgents(userAgents),
+      ...filterDisabledAgents(projectAgents),
+      ...filterDisabledAgents(pluginAgents),
       ...filteredConfigAgents,
       build: { ...migratedBuild, mode: "subagent", hidden: true },
       ...planDemoteConfig ? { plan: planDemoteConfig } : {}
@@ -73764,9 +75271,9 @@ async function applyAgentConfig(params) {
   } else {
     params.config.agent = {
       ...builtinAgents,
-      ...userAgents,
-      ...projectAgents,
-      ...pluginAgents,
+      ...filterDisabledAgents(userAgents),
+      ...filterDisabledAgents(projectAgents),
+      ...filterDisabledAgents(pluginAgents),
       ...configAgent
     };
   }
@@ -74719,6 +76226,7 @@ function applyToolConfig(params) {
 function createConfigHandler(deps) {
   const { ctx, pluginConfig, modelCacheState } = deps;
   return async (config3) => {
+    const formatterConfig = config3.formatter;
     applyProviderConfig({ config: config3, modelCacheState });
     const pluginComponents = await loadPluginComponents({ pluginConfig });
     const agentResult = await applyAgentConfig({
@@ -74730,6 +76238,7 @@ function createConfigHandler(deps) {
     applyToolConfig({ config: config3, pluginConfig, agentResult });
     await applyMcpConfig({ config: config3, pluginConfig, pluginComponents });
     await applyCommandConfig({ config: config3, pluginConfig, ctx, pluginComponents });
+    config3.formatter = formatterConfig;
     log("[config-handler] config handler applied", {
       agentCount: Object.keys(agentResult).length,
       commandCount: Object.keys(config3.command ?? {}).length
@@ -74921,7 +76430,7 @@ function createToolRegistry(args) {
     task_list: createTaskList(pluginConfig),
     task_update: createTaskUpdateTool(pluginConfig, ctx)
   } : {};
-  const hashlineEnabled = pluginConfig.hashline_edit ?? true;
+  const hashlineEnabled = pluginConfig.hashline_edit ?? false;
   const hashlineToolsRecord = hashlineEnabled ? { edit: createHashlineEditTool() } : {};
   const allTools = {
     ...builtinTools,
@@ -75140,15 +76649,6 @@ function createChatHeadersHandler(args) {
   };
 }
 
-// src/shared/session-model-state.ts
-var sessionModels = new Map;
-function setSessionModel(sessionID, model) {
-  sessionModels.set(sessionID, model);
-}
-function clearSessionModel(sessionID) {
-  sessionModels.delete(sessionID);
-}
-
 // src/plugin/ultrawork-db-model-override.ts
 import { Database } from "bun:sqlite";
 import { join as join84 } from "path";
@@ -75313,11 +76813,11 @@ function applyUltraworkModelOverrideOnMessage(pluginConfig, inputAgentName, outp
   const override = resolveUltraworkOverride(pluginConfig, inputAgentName, output, sessionID);
   if (!override)
     return;
+  if (override.variant) {
+    output.message["variant"] = override.variant;
+    output.message["thinking"] = override.variant;
+  }
   if (!override.providerID || !override.modelID) {
-    if (override.variant) {
-      output.message["variant"] = override.variant;
-      output.message["thinking"] = override.variant;
-    }
     return;
   }
   const targetModel = { providerID: override.providerID, modelID: override.modelID };
@@ -75329,10 +76829,6 @@ function applyUltraworkModelOverrideOnMessage(pluginConfig, inputAgentName, outp
   if (!messageId) {
     log("[ultrawork-model-override] No message ID found, falling back to direct mutation");
     output.message.model = targetModel;
-    if (override.variant) {
-      output.message["variant"] = override.variant;
-      output.message["thinking"] = override.variant;
-    }
     return;
   }
   const fromModel = output.message.model?.modelID ?? "unknown";
@@ -75404,8 +76900,10 @@ function createChatMessageHandler3(args) {
       setSessionModel(input.sessionID, input.model);
     }
     await hooks2.stopContinuationGuard?.["chat.message"]?.(input);
+    await hooks2.backgroundNotificationHook?.["chat.message"]?.(input, output);
     await hooks2.runtimeFallback?.["chat.message"]?.(input, output);
     await hooks2.keywordDetector?.["chat.message"]?.(input, output);
+    await hooks2.thinkMode?.["chat.message"]?.(input, output);
     await hooks2.claudeCodeHooks?.["chat.message"]?.(input, output);
     await hooks2.autoSlashCommand?.["chat.message"]?.(input, output);
     await hooks2.noSisyphusGpt?.["chat.message"]?.(input, output);
@@ -75856,6 +77354,7 @@ function createToolExecuteAfterHandler3(args) {
     await hooks2.delegateTaskRetry?.["tool.execute.after"]?.(input, output);
     await hooks2.atlasHook?.["tool.execute.after"]?.(input, output);
     await hooks2.taskResumeInfo?.["tool.execute.after"]?.(input, output);
+    await hooks2.readImageResizer?.["tool.execute.after"]?.(input, output);
     await hooks2.hashlineReadEnhancer?.["tool.execute.after"]?.(input, output);
     await hooks2.jsonErrorRecovery?.["tool.execute.after"]?.(input, output);
   };