oh-my-opencode 3.8.5 → 3.9.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" },
@@ -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;
 }
@@ -18545,6 +18565,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 +18658,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 +18708,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 +18717,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 +19255,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 +19495,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 +20225,7 @@ function createSessionNotification(ctx, config = {}) {
     idleConfirmationDelay: 1500,
     skipIfIncompleteTodos: true,
     maxTrackedSessions: 100,
+    enforceMainSessionFilter: true,
     ...config
   };
   const scheduler = createIdleNotificationScheduler({
@@ -20135,9 +20258,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 +34651,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 +35347,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 +35396,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 +35424,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 +36034,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 +36053,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 +36074,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 +36107,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 }) => {
@@ -38165,7 +38178,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 +38498,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 +38565,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"
@@ -39000,12 +39075,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 +40313,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 +40633,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 +40657,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 +40666,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 +40737,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 +40785,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 +40866,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 +41024,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 +41032,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 +41052,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 });
+      if (inFlightSessions.has(sessionID)) {
+        log(`[${HOOK_NAME3}] Skipped: handler in flight`, { 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
+      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 +41199,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 +41231,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 +41299,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 +41314,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 +42395,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 +42419,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 +42460,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 +42472,7 @@ Starting Work Session
 Plan: {plan-name}
 Session ID: {session_id}
 Started: {timestamp}
+Worktree: {worktree_path}
 
 Reading plan and beginning execution...
 \`\`\`
@@ -42337,6 +42481,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 +45983,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 +45999,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 +46206,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 +46256,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 +46309,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 +46321,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 +46353,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 +46375,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 +46392,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 +46405,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 +46416,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 +46437,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 +46451,8 @@ ${contextInfo}`;
       }
       log(`[${HOOK_NAME6}] Context injected`, {
         sessionID: input.sessionID,
-        hasExistingState: !!existingState
+        hasExistingState: !!existingState,
+        worktreePath
       });
     }
   };
@@ -46496,6 +46704,7 @@ async function injectBoulderContinuation(input) {
     remaining,
     total,
     agent,
+    worktreePath,
     backgroundManager,
     sessionState
   } = input;
@@ -46504,9 +46713,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 +46737,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 +46762,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 +46790,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;
@@ -46606,17 +46827,15 @@ function createAtlasEventHandler(input) {
       const lastAgentKey = getAgentConfigKey(lastAgent ?? "");
       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
+          requiredAgent
         });
         return;
       }
@@ -46625,7 +46844,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 +46861,7 @@ function createAtlasEventHandler(input) {
           remaining,
           total: progress.total,
           agent: boulderState.agent,
+          worktreePath: boulderState.worktree_path,
           backgroundManager,
           sessionState: state3
         });
@@ -47125,12 +47344,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 +47774,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 +47818,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 +48030,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 +48083,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()
 });
@@ -48066,7 +48326,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(),
@@ -50019,9 +50279,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 +50290,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 +50299,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 +50400,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",
@@ -50168,7 +50428,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 +50464,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();
@@ -51301,7 +51561,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 +51648,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;
   }
@@ -53470,7 +53730,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 +53817,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 +53935,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"
       });
@@ -54250,6 +54510,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 +54558,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 +54567,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 +54601,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)}`;
       }
@@ -55062,47 +55338,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();
@@ -56173,6 +56555,7 @@ async function resolveCategoryExecution(args, executorCtx, inheritedModel, syste
         agentToUse: "",
         categoryModel: undefined,
         categoryPromptAppend: undefined,
+        maxPromptTokens: undefined,
         modelInfo: undefined,
         actualModel: undefined,
         isUnstableAgent: false,
@@ -56189,6 +56572,7 @@ Available categories: ${allCategoryNames}`
       agentToUse: "",
       categoryModel: undefined,
       categoryPromptAppend: undefined,
+      maxPromptTokens: undefined,
       modelInfo: undefined,
       actualModel: undefined,
       isUnstableAgent: false,
@@ -56222,6 +56606,7 @@ Available categories: ${allCategoryNames}`
           agentToUse: "",
           categoryModel: undefined,
           categoryPromptAppend: undefined,
+          maxPromptTokens: undefined,
           modelInfo: undefined,
           actualModel: undefined,
           isUnstableAgent: false,
@@ -56247,6 +56632,7 @@ Available categories: ${allCategoryNames}`
       agentToUse: "",
       categoryModel: undefined,
       categoryPromptAppend: undefined,
+      maxPromptTokens: undefined,
       modelInfo: undefined,
       actualModel: undefined,
       isUnstableAgent: false,
@@ -56268,6 +56654,7 @@ Available categories: ${categoryNames.join(", ")}`
     agentToUse: SISYPHUS_JUNIOR_AGENT2,
     categoryModel,
     categoryPromptAppend,
+    maxPromptTokens: resolved.config.max_prompt_tokens,
     modelInfo,
     actualModel,
     isUnstableAgent,
@@ -56477,7 +56864,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 +56898,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 +56911,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 +56925,11 @@ function createDelegateTask(options) {
         if (isUnstableAgent && isRunInBackgroundExplicitlyFalse) {
           const systemContent2 = buildSystemContent({
             skillContent,
+            skillContents,
             categoryPromptAppend,
             agentName: agentToUse,
+            maxPromptTokens,
+            model: categoryModel,
             availableCategories,
             availableSkills
           });
@@ -56554,8 +56946,11 @@ function createDelegateTask(options) {
       }
       const systemContent = buildSystemContent({
         skillContent,
+        skillContents,
         categoryPromptAppend,
         agentName: agentToUse,
+        maxPromptTokens,
+        model: categoryModel,
         availableCategories,
         availableSkills
       });
@@ -57356,14 +57751,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 +58148,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 +58761,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 +58805,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 +58879,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 +58953,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 +59063,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;
@@ -58591,7 +59375,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, {
@@ -59307,6 +60093,7 @@ async function checkAndInterruptStaleTasks(args) {
 class BackgroundManager {
   tasks;
   notifications;
+  pendingNotifications;
   pendingByParent;
   client;
   directory;
@@ -59328,6 +60115,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 +60681,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 +60715,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 +60763,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 +61086,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 +61275,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();
@@ -63834,7 +64658,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 +64717,7 @@ function createParser(callbacks) {
   }
   return { feed, reset };
 }
-function splitLines(chunk) {
+function splitLines2(chunk) {
   const lines = [];
   let incompleteLine = "", searchIndex = 0;
   for (;searchIndex < chunk.length; ) {
@@ -66834,7 +67658,7 @@ For implementation tasks, actively decompose and delegate to \`deep\` category a
 }
 
 // src/agents/sisyphus.ts
-var MODE = "primary";
+var MODE = "all";
 function buildTaskManagementSection(useTaskSystem) {
   if (useTaskSystem) {
     return `<Task_Management>
@@ -69544,7 +70368,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 +70409,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 +70666,7 @@ var momusPromptMetadata = {
 };
 
 // src/agents/hephaestus.ts
-var MODE9 = "primary";
+var MODE9 = "all";
 function buildTodoDisciplineSection(useTaskSystem) {
   if (useTaskSystem) {
     return `## Task Discipline (NON-NEGOTIABLE)
@@ -70452,25 +71271,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>`;
@@ -71412,6 +72216,7 @@ function remapAgentKeysToDisplayNames(agents) {
     const displayName = AGENT_DISPLAY_NAMES[key];
     if (displayName && displayName !== key) {
       result[displayName] = value;
+      result[key] = value;
     } else {
       result[key] = value;
     }
@@ -73701,6 +74506,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 +74561,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 +74571,9 @@ async function applyAgentConfig(params) {
   } else {
     params.config.agent = {
       ...builtinAgents,
-      ...userAgents,
-      ...projectAgents,
-      ...pluginAgents,
+      ...filterDisabledAgents(userAgents),
+      ...filterDisabledAgents(projectAgents),
+      ...filterDisabledAgents(pluginAgents),
       ...configAgent
     };
   }
@@ -74719,6 +75526,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 +75538,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
@@ -75313,11 +76122,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 +76138,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 +76209,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);