oh-my-opencode 3.17.6 → 3.17.8

package/dist/index.js

@@ -4446,6 +4446,56 @@ var require_picomatch2 = __commonJS((exports, module) => {
   module.exports = picomatch;
 });
 
+// src/agents/types.ts
+function extractModelName(model) {
+  return model.includes("/") ? model.split("/").pop() ?? model : model;
+}
+function isGptModel(model) {
+  const modelName = extractModelName(model).toLowerCase();
+  return modelName.includes("gpt");
+}
+function isGptNativeSisyphusModel(model) {
+  const modelName = extractModelName(model).toLowerCase();
+  return GPT_NATIVE_SISYPHUS_RE.test(modelName);
+}
+function isGpt5_5Model(model) {
+  const modelName = extractModelName(model).toLowerCase();
+  return modelName.includes("gpt-5.5") || modelName.includes("gpt-5-5");
+}
+function isGpt5_3CodexModel(model) {
+  const modelName = extractModelName(model).toLowerCase();
+  return modelName.includes("gpt-5.3-codex") || modelName.includes("gpt-5-3-codex");
+}
+function isClaudeOpus47Model(model) {
+  const modelName = extractModelName(model).toLowerCase().replaceAll(".", "-");
+  return modelName.includes("claude-opus-4-7");
+}
+function isKimiK2Model(model) {
+  const modelName = extractModelName(model).toLowerCase();
+  if (modelName.includes("kimi"))
+    return true;
+  if (/k2[-.]?p[56]/.test(modelName))
+    return true;
+  return false;
+}
+function isGlmModel(model) {
+  const modelName = extractModelName(model).toLowerCase();
+  return modelName.includes("glm");
+}
+function isGeminiModel(model) {
+  if (GEMINI_PROVIDERS.some((prefix) => model.startsWith(prefix)))
+    return true;
+  if (model.startsWith("github-copilot/") && extractModelName(model).toLowerCase().startsWith("gemini"))
+    return true;
+  const modelName = extractModelName(model).toLowerCase();
+  return modelName.startsWith("gemini-");
+}
+var GPT_NATIVE_SISYPHUS_RE, GEMINI_PROVIDERS;
+var init_types = __esm(() => {
+  GPT_NATIVE_SISYPHUS_RE = /gpt-5[.-](?:[4-9]|\d{2,})/i;
+  GEMINI_PROVIDERS = ["google/", "google-vertex/"];
+});
+
 // src/hooks/ralph-loop/constants.ts
 var HOOK_NAME3 = "ralph-loop", DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md", DEFAULT_MAX_ITERATIONS = 100, ULTRAWORK_MAX_ITERATIONS = 500, DEFAULT_COMPLETION_PROMISE = "DONE", ULTRAWORK_VERIFICATION_PROMISE = "VERIFIED";
 var init_constants = () => {};
@@ -8035,6 +8085,12 @@ var init_kimi_categories = __esm(() => {
 });
 
 // src/tools/delegate-task/openai-categories.ts
+function resolveDeepCategoryPromptAppend(model) {
+  if (model && isGpt5_5Model(model)) {
+    return DEEP_CATEGORY_PROMPT_APPEND_GPT_5_5;
+  }
+  return DEEP_CATEGORY_PROMPT_APPEND;
+}
 var ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
 You are working on DEEP LOGICAL REASONING / COMPLEX ARCHITECTURE tasks.
 
@@ -8074,6 +8130,26 @@ Genuinely independent tasks = flag and refuse, require separate delegations.
 Approach: explore extensively, understand deeply, then act decisively. Prefer comprehensive solutions over quick patches. If the goal is unclear, make reasonable assumptions and proceed.
 
 Minimal status updates. Focus on results, not play-by-play. Report completion with summary of changes.
+</Category_Context>`, DEEP_CATEGORY_PROMPT_APPEND_GPT_5_5 = `<Category_Context name="deep">
+You are operating in DEEP mode. This is the category reserved for goal-oriented autonomous work on hairy problems that reward thorough exploration and comprehensive solutions.
+
+The orchestrator chose this category because the task benefits from depth over speed. You should feel empowered to spend the time needed: five to fifteen minutes of silent exploration before the first edit is normal and correct. Rushing to implementation on a deep task is a failure mode, not a feature.
+
+# How deep mode adjusts the base behavior
+
+**Exploration budget: generous.** Read the files you need, trace dependencies both directions, fire 2-5 explore/librarian sub-agents in parallel for broader questions. Build a complete mental model before the first \`apply_patch\`. Exploration here is an investment, not overhead.
+
+**Goal, not plan.** You receive a GOAL describing the desired outcome. You figure out HOW to achieve it. The orchestrator deliberately did not hand you a step-by-step plan; producing one and asking for approval is not what was asked. Execute.
+
+**Atomic task treatment.** When the goal contains numbered steps or phases, treat them as sub-steps of ONE task and execute them all in this turn. Splitting them across turns is wrong unless they reveal an architectural blocker that requires the user's input. If the "steps" turn out to be genuinely independent tasks that should have been separate delegations, flag that in your final message and refuse the ones beyond scope.
+
+**Root cause bias.** Prefer root-cause fixes over symptom fixes. A null check around \`foo()\` is a symptom fix; fixing whatever causes \`foo()\` to return unexpected values is the root fix. Trace at least two levels up before settling on an answer. In deep mode, you have permission (and the expectation) to do the deeper fix.
+
+**Ambition scaled to context.** For brand-new greenfield work, be ambitious. Choose strong defaults, avoid AI-slop aesthetics, produce something you would be proud to hand to another senior engineer. For changes in an existing codebase, be surgical and respect the existing patterns; depth does not mean invasiveness.
+
+**Completion bar: full delivery.** "Simplified version", "proof of concept", and "you can extend this later" are not acceptable deliveries for a deep task. The orchestrator routed here specifically for a complete solution. If you hit a genuine blocker (missing secret, design decision only the user can make, three materially different attempts all failed), document it and return; otherwise, finish the task.
+
+**Status cadence: sparse.** The user is not on the other side of this conversation; the orchestrator is, and they will synthesize your progress. Send commentary only at meaningful phase transitions (starting exploration, starting implementation, starting verification, hitting a genuine blocker). Do not narrate every tool call; silence during focused work is expected.
 </Category_Context>`, QUICK_CATEGORY_PROMPT_APPEND = `<Category_Context>
 You are working on SMALL / QUICK tasks.
 
@@ -8125,6 +8201,7 @@ EXPECTED OUTPUT:
 If your prompt lacks this structure, REWRITE IT before delegating.
 </Caller_Warning>`, OPENAI_CATEGORIES;
 var init_openai_categories = __esm(() => {
+  init_types();
   OPENAI_CATEGORIES = [
     {
       name: "ultrabrain",
@@ -8136,7 +8213,8 @@ var init_openai_categories = __esm(() => {
       name: "deep",
       config: { model: "openai/gpt-5.5", variant: "medium" },
       description: "Goal-oriented autonomous problem-solving. Thorough research before action. For hairy problems requiring deep understanding.",
-      promptAppend: DEEP_CATEGORY_PROMPT_APPEND
+      promptAppend: DEEP_CATEGORY_PROMPT_APPEND,
+      resolvePromptAppend: resolveDeepCategoryPromptAppend
     },
     {
       name: "quick",
@@ -8151,7 +8229,7 @@ var init_openai_categories = __esm(() => {
 function buildCategoryRecord(selector) {
   return Object.fromEntries(BUILTIN_CATEGORIES.map((definition) => [definition.name, selector(definition)]));
 }
-var BUILTIN_CATEGORIES, DEFAULT_CATEGORIES, CATEGORY_PROMPT_APPENDS, CATEGORY_DESCRIPTIONS;
+var BUILTIN_CATEGORIES, DEFAULT_CATEGORIES, CATEGORY_PROMPT_APPENDS, CATEGORY_DESCRIPTIONS, CATEGORY_PROMPT_APPEND_RESOLVERS;
 var init_builtin_categories = __esm(() => {
   init_anthropic_categories();
   init_google_categories();
@@ -8166,6 +8244,7 @@ var init_builtin_categories = __esm(() => {
   DEFAULT_CATEGORIES = buildCategoryRecord((definition) => definition.config);
   CATEGORY_PROMPT_APPENDS = buildCategoryRecord((definition) => definition.promptAppend);
   CATEGORY_DESCRIPTIONS = buildCategoryRecord((definition) => definition.description);
+  CATEGORY_PROMPT_APPEND_RESOLVERS = Object.fromEntries(BUILTIN_CATEGORIES.filter((definition) => definition.resolvePromptAppend !== undefined).map((definition) => [definition.name, definition.resolvePromptAppend]));
 });
 
 // src/tools/delegate-task/constants.ts
@@ -15921,6 +16000,41 @@ function normalizeSDKResponse(response, fallback, options) {
 // src/shared/dynamic-truncator.ts
 var CHARS_PER_TOKEN_ESTIMATE = 4;
 var DEFAULT_TARGET_MAX_TOKENS = 50000;
+var usageCacheByClient = new WeakMap;
+function createModelCacheKey(modelCacheState) {
+  if (!modelCacheState) {
+    return "default";
+  }
+  const cachedLimits = modelCacheState.modelContextLimitsCache ? [...modelCacheState.modelContextLimitsCache.entries()].sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([modelKey, limit]) => `${modelKey}:${limit}`).join(",") : "";
+  return `${modelCacheState.anthropicContext1MEnabled ? "1m" : "200k"}|${cachedLimits}`;
+}
+function getUsageCache(client, modelCacheState) {
+  let cacheByModelState = usageCacheByClient.get(client);
+  if (!cacheByModelState) {
+    cacheByModelState = new Map;
+    usageCacheByClient.set(client, cacheByModelState);
+  }
+  const modelCacheKey = createModelCacheKey(modelCacheState);
+  let cache = cacheByModelState.get(modelCacheKey);
+  if (!cache) {
+    cache = new Map;
+    cacheByModelState.set(modelCacheKey, cache);
+  }
+  return cache;
+}
+function invalidateContextWindowUsageCache(ctx, sessionID) {
+  const cacheByModelState = usageCacheByClient.get(ctx.client);
+  if (!cacheByModelState) {
+    return;
+  }
+  for (const cache of cacheByModelState.values()) {
+    if (sessionID) {
+      cache.delete(sessionID);
+    } else {
+      cache.clear();
+    }
+  }
+}
 function estimateTokens(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
 }
@@ -15982,6 +16096,16 @@ function truncateToTokenLimit(output, maxTokens, preserveHeaderLines = 3) {
   };
 }
 async function getContextWindowUsage(ctx, sessionID, modelCacheState) {
+  const cache = getUsageCache(ctx.client, modelCacheState);
+  const cached = cache.get(sessionID);
+  if (cached) {
+    return cached;
+  }
+  const usagePromise = fetchContextWindowUsage(ctx, sessionID, modelCacheState);
+  cache.set(sessionID, usagePromise);
+  return usagePromise;
+}
+async function fetchContextWindowUsage(ctx, sessionID, modelCacheState) {
   try {
     const response = await ctx.client.session.messages({
       path: { id: sessionID }
@@ -66161,7 +66285,9 @@ var RETRYABLE_MESSAGE_PATTERNS = [
   "502",
   "504",
   "429",
-  "529"
+  "529",
+  "403",
+  "forbidden"
 ];
 var STOP_MESSAGE_PATTERNS = [
   "quota will reset after",
@@ -66541,14 +66667,12 @@ async function handleSessionIdle(args) {
     return;
   }
   if (!todos || todos.length === 0) {
-    sessionStateStore.resetContinuationProgress(sessionID);
     sessionStateStore.resetContinuationProgress(sessionID);
     log(`[${HOOK_NAME}] No todos`, { sessionID });
     return;
   }
   const incompleteCount = getIncompleteCount(todos);
   if (incompleteCount === 0) {
-    sessionStateStore.resetContinuationProgress(sessionID);
     sessionStateStore.resetContinuationProgress(sessionID);
     log(`[${HOOK_NAME}] All todos complete`, { sessionID, total: todos.length });
     return;
@@ -71652,17 +71776,21 @@ function createModelFallbackStateController(input) {
   function setSessionFallbackChain(sessionID, fallbackChain) {
     if (!sessionID)
       return;
-    sessionFallbackChains.set(sessionID, fallbackChain?.length ? fallbackChain : []);
+    sessionFallbackChains.set(sessionID, fallbackChain?.length ? [...fallbackChain] : []);
   }
   function clearSessionFallbackChain(sessionID) {
     sessionFallbackChains.delete(sessionID);
   }
+  function getSessionFallbackChain(sessionID) {
+    const fallbackChain = sessionFallbackChains.get(sessionID);
+    return fallbackChain ? [...fallbackChain] : undefined;
+  }
   function setPendingModelFallback(sessionID, agentName, currentProviderID, currentModelID) {
     const agentKey = getAgentConfigKey(agentName);
     const requirements = AGENT_MODEL_REQUIREMENTS[agentKey];
     const fallbackChain = sessionFallbackChains.get(sessionID) ?? requirements?.fallbackChain;
     if (!fallbackChain?.length) {
-      log("[model-fallback] No fallback chain for agent: " + agentName + " (key: " + agentKey + ")");
+      log(`[model-fallback] No fallback chain for agent: ${agentName} (key: ${agentKey})`);
       return false;
     }
     const existing = pendingModelFallbacks.get(sessionID);
@@ -71674,21 +71802,21 @@ function createModelFallbackStateController(input) {
         attemptCount: 0,
         pending: true
       });
-      log("[model-fallback] Set pending fallback for session: " + sessionID + ", agent: " + agentName);
+      log(`[model-fallback] Set pending fallback for session: ${sessionID}, agent: ${agentName}`);
       return true;
     }
     if (existing.pending) {
-      log("[model-fallback] Pending fallback already armed for session: " + sessionID);
+      log(`[model-fallback] Pending fallback already armed for session: ${sessionID}`);
       return false;
     }
     existing.providerID = currentProviderID;
     existing.modelID = currentModelID;
     existing.pending = true;
     if (existing.attemptCount >= existing.fallbackChain.length) {
-      log("[model-fallback] Fallback chain exhausted for session: " + sessionID);
+      log(`[model-fallback] Fallback chain exhausted for session: ${sessionID}`);
       return false;
     }
-    log("[model-fallback] Re-armed pending fallback for session: " + sessionID);
+    log(`[model-fallback] Re-armed pending fallback for session: ${sessionID}`);
     return true;
   }
   function getNextFallback2(sessionID) {
@@ -71698,7 +71826,7 @@ function createModelFallbackStateController(input) {
     const fallback = getNextReachableFallback(sessionID, state3);
     if (fallback)
       return fallback;
-    log("[model-fallback] No more fallbacks for session: " + sessionID);
+    log(`[model-fallback] No more fallbacks for session: ${sessionID}`);
     pendingModelFallbacks.delete(sessionID);
     return null;
   }
@@ -71720,6 +71848,7 @@ function createModelFallbackStateController(input) {
   return {
     lastToastKey,
     setSessionFallbackChain,
+    getSessionFallbackChain,
     clearSessionFallbackChain,
     setPendingModelFallback,
     getNextFallback: getNextFallback2,
@@ -71761,6 +71890,7 @@ function createModelFallbackHook(args) {
   return {
     lastToastKey: controller.lastToastKey,
     setSessionFallbackChain: controller.setSessionFallbackChain,
+    getSessionFallbackChain: controller.getSessionFallbackChain,
     clearSessionFallbackChain: controller.clearSessionFallbackChain,
     setPendingModelFallback: controller.setPendingModelFallback,
     getNextFallback: controller.getNextFallback,
@@ -74072,13 +74202,6 @@ function readPackageVersion(packageJsonPath) {
   return pkg.version ?? null;
 }
 function getCachedVersion() {
-  for (const candidate of INSTALLED_PACKAGE_JSON_CANDIDATES) {
-    try {
-      if (fs12.existsSync(candidate)) {
-        return readPackageVersion(candidate);
-      }
-    } catch {}
-  }
   try {
     const currentDir = path10.dirname(fileURLToPath3(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
@@ -74088,6 +74211,13 @@ function getCachedVersion() {
   } catch (err) {
     log("[auto-update-checker] Failed to resolve version from current directory:", err);
   }
+  for (const candidate of INSTALLED_PACKAGE_JSON_CANDIDATES) {
+    try {
+      if (fs12.existsSync(candidate)) {
+        return readPackageVersion(candidate);
+      }
+    } catch {}
+  }
   try {
     const execDir = path10.dirname(fs12.realpathSync(process.execPath));
     const pkgPath = findPackageJsonUp(execDir);
@@ -75101,54 +75231,8 @@ function createAgentUsageReminderHook(_ctx) {
     event: eventHandler
   };
 }
-// src/agents/types.ts
-function extractModelName(model) {
-  return model.includes("/") ? model.split("/").pop() ?? model : model;
-}
-function isGptModel(model) {
-  const modelName = extractModelName(model).toLowerCase();
-  return modelName.includes("gpt");
-}
-var GPT_NATIVE_SISYPHUS_RE = /gpt-5[.-](?:[4-9]|\d{2,})/i;
-function isGptNativeSisyphusModel(model) {
-  const modelName = extractModelName(model).toLowerCase();
-  return GPT_NATIVE_SISYPHUS_RE.test(modelName);
-}
-function isGpt5_5Model(model) {
-  const modelName = extractModelName(model).toLowerCase();
-  return modelName.includes("gpt-5.5") || modelName.includes("gpt-5-5");
-}
-function isGpt5_3CodexModel(model) {
-  const modelName = extractModelName(model).toLowerCase();
-  return modelName.includes("gpt-5.3-codex") || modelName.includes("gpt-5-3-codex");
-}
-function isClaudeOpus47Model(model) {
-  const modelName = extractModelName(model).toLowerCase().replaceAll(".", "-");
-  return modelName.includes("claude-opus-4-7");
-}
-function isKimiK2Model(model) {
-  const modelName = extractModelName(model).toLowerCase();
-  if (modelName.includes("kimi"))
-    return true;
-  if (/k2[-.]?p[56]/.test(modelName))
-    return true;
-  return false;
-}
-var GEMINI_PROVIDERS = ["google/", "google-vertex/"];
-function isGlmModel(model) {
-  const modelName = extractModelName(model).toLowerCase();
-  return modelName.includes("glm");
-}
-function isGeminiModel(model) {
-  if (GEMINI_PROVIDERS.some((prefix) => model.startsWith(prefix)))
-    return true;
-  if (model.startsWith("github-copilot/") && extractModelName(model).toLowerCase().startsWith("gemini"))
-    return true;
-  const modelName = extractModelName(model).toLowerCase();
-  return modelName.startsWith("gemini-");
-}
-
 // src/hooks/keyword-detector/ultrawork/source-detector.ts
+init_types();
 function isPlannerAgent(agentName) {
   if (!agentName)
     return false;
@@ -78005,6 +78089,7 @@ function createRalphLoopHook(ctx, options) {
   };
 }
 // src/hooks/no-sisyphus-gpt/hook.ts
+init_types();
 init_agent_display_names();
 var TOAST_TITLE = "NEVER Use Sisyphus with GPT";
 var TOAST_MESSAGE = [
@@ -78060,6 +78145,7 @@ function createNoSisyphusGptHook(ctx) {
   };
 }
 // src/hooks/no-hephaestus-non-gpt/hook.ts
+init_types();
 init_agent_display_names();
 var TOAST_TITLE2 = "NEVER Use Hephaestus with Non-GPT";
 var TOAST_MESSAGE2 = [
@@ -87912,7 +87998,10 @@ function findMessageByID(messages, messageID) {
   return messages.find((message) => message.info?.id === messageID);
 }
 async function resolveNoTextTailFromSession(args) {
-  const { client, sessionID, messageID, directory } = args;
+  const { client, sessionID, messageID, directory, parts } = args;
+  if (Array.isArray(parts)) {
+    return isStepOnlyNoTextParts(parts);
+  }
   try {
     const response = await client.session.messages({
       path: { id: sessionID },
@@ -88039,7 +88128,8 @@ function createPostCompactionDegradationMonitor(args) {
       client,
       sessionID: info.sessionID,
       messageID: info.id,
-      directory
+      directory,
+      parts: info.parts
     });
     if (!isNoTextTail) {
       postCompactionNoTextStreak.set(info.sessionID, 0);
@@ -88203,7 +88293,8 @@ function createPreemptiveCompactionHook(ctx, pluginConfig, modelCacheState) {
       compactedSessions.delete(info.sessionID);
       await postCompactionMonitor.onAssistantMessageUpdated({
         sessionID: info.sessionID,
-        id: info.id
+        id: info.id,
+        parts: info.parts
       });
     }
   };
@@ -88800,7 +88891,7 @@ function classifyErrorType(error) {
   if (errorName?.includes("providermodelnotfounderror") || errorName?.includes("modelnotfounderror") || errorName?.includes("unknownerror") && /model\s+not\s+found/i.test(message)) {
     return "model_not_found";
   }
-  if (errorName?.includes("quotaexceeded") || errorName?.includes("insufficientquota") || errorName?.includes("billingerror") || /quota.?exceeded/i.test(message) || /subscription.*quota/i.test(message) || /insufficient.?quota/i.test(message) || /billing.?(?:hard.?)?limit/i.test(message) || /exhausted\s+your\s+capacity/i.test(message) || /out\s+of\s+credits?/i.test(message) || /payment.?required/i.test(message) || /usage\s+limit/i.test(message)) {
+  if (errorName?.includes("quotaexceeded") || errorName?.includes("insufficientquota") || errorName?.includes("billingerror") || /quota.?exceeded/i.test(message) || /subscription.*quota/i.test(message) || /insufficient.?(?:quota|balance|funds?)/i.test(message) || /billing.?(?:hard.?)?limit/i.test(message) || /exhausted\s+your\s+capacity/i.test(message) || /out\s+of\s+credits?/i.test(message) || /payment.?required/i.test(message) || /usage\s+limit/i.test(message)) {
     return "quota_exceeded";
   }
   return;
@@ -88828,8 +88919,7 @@ function isRetryableError(error, retryOnErrors) {
     return true;
   }
   if (errorType === "quota_exceeded") {
-    const hasAutoRetrySignal = /retrying\s+in/i.test(message);
-    return hasAutoRetrySignal;
+    return true;
   }
   if (statusCode && retryOnErrors.includes(statusCode)) {
     return true;
@@ -89918,6 +90008,19 @@ function extractFilePath(metadata) {
   }
   return;
 }
+function extractLineCount(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return;
+  }
+  const objectMeta = metadata;
+  const candidates = [objectMeta.lineCount, objectMeta.linesWritten, objectMeta.lines];
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) {
+      return candidate;
+    }
+  }
+  return;
+}
 async function appendWriteHashlineOutput(output) {
   if (output.output.startsWith(WRITE_SUCCESS_MARKER)) {
     return;
@@ -89926,6 +90029,11 @@ async function appendWriteHashlineOutput(output) {
   if (outputLower.startsWith("error") || outputLower.includes("failed")) {
     return;
   }
+  const metadataLineCount = extractLineCount(output.metadata);
+  if (metadataLineCount !== undefined) {
+    output.output = `${WRITE_SUCCESS_MARKER} ${metadataLineCount} lines written.`;
+    return;
+  }
   const filePath = extractFilePath(output.metadata);
   if (!filePath) {
     return;
@@ -96281,6 +96389,83 @@ async function formatFullSession(task, client2, options) {
 `);
 }
 
+// src/features/background-agent/error-classifier.ts
+function isRecord15(value) {
+  return typeof value === "object" && value !== null;
+}
+function isAbortedSessionError(error) {
+  const message = getErrorText(error);
+  return message.toLowerCase().includes("aborted");
+}
+function getErrorText(error) {
+  if (!error)
+    return "";
+  if (typeof error === "string")
+    return error;
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  if (typeof error === "object" && error !== null) {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+    if ("name" in error && typeof error.name === "string") {
+      return error.name;
+    }
+  }
+  return "";
+}
+function extractErrorName2(error) {
+  if (isRecord15(error) && typeof error["name"] === "string")
+    return error["name"];
+  if (error instanceof Error)
+    return error.name;
+  return;
+}
+function extractErrorMessage(error) {
+  if (!error)
+    return;
+  if (typeof error === "string")
+    return error;
+  if (isRecord15(error)) {
+    const dataRaw = error["data"];
+    const candidates = [
+      dataRaw,
+      isRecord15(dataRaw) ? dataRaw["error"] : undefined,
+      error["error"],
+      error["cause"],
+      error
+    ];
+    for (const candidate of candidates) {
+      if (typeof candidate === "string" && candidate.length > 0)
+        return candidate;
+      if (isRecord15(candidate) && typeof candidate["message"] === "string" && candidate["message"].length > 0) {
+        return candidate["message"];
+      }
+    }
+  }
+  if (error instanceof Error)
+    return error.message;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function getSessionErrorMessage(properties) {
+  const errorRaw = properties["error"];
+  if (!isRecord15(errorRaw))
+    return;
+  const dataRaw = errorRaw["data"];
+  if (isRecord15(dataRaw)) {
+    const message2 = dataRaw["message"];
+    if (typeof message2 === "string")
+      return message2;
+  }
+  const message = errorRaw["message"];
+  return typeof message === "string" ? message : undefined;
+}
+
 // src/tools/background-task/task-result-format.ts
 function getTimeString(value) {
   return typeof value === "string" ? value : "";
@@ -96327,6 +96512,19 @@ Session ID: ${task.sessionID}
     const timeB = getTimeString(b.info?.time);
     return timeA.localeCompare(timeB);
   });
+  const sessionError = sortedMessages.filter((message) => message.info?.role === "assistant" && message.info?.error).map((message) => extractErrorMessage(message.info?.error)).find((message) => typeof message === "string" && message.length > 0);
+  if (sessionError) {
+    return `Task Result
+
+Task ID: ${task.id}
+Description: ${task.description}
+Duration: ${formatDuration(task.startedAt ?? new Date, task.completedAt)}
+Session ID: ${task.sessionID}
+
+---
+
+Session error: ${sessionError}`;
+  }
   const newMessages = consumeNewMessages(task.sessionID, sortedMessages);
   if (newMessages.length === 0) {
     const duration2 = formatDuration(task.startedAt ?? new Date, task.completedAt);
@@ -98254,6 +98452,18 @@ async function fetchSessionMessages(client2, sessionID) {
   const rawData = messagesResult?.data ?? messagesResult;
   return Array.isArray(rawData) ? rawData : [];
 }
+function getTerminalSessionError(messages) {
+  const lastAssistant = [...messages].reverse().find((msg) => msg.info?.role === "assistant");
+  const lastUser = [...messages].reverse().find((msg) => msg.info?.role === "user");
+  if (lastUser?.info?.id && lastAssistant?.info?.id && lastAssistant.info.id <= lastUser.info.id) {
+    return null;
+  }
+  if (!lastAssistant?.info || !("error" in lastAssistant.info)) {
+    return null;
+  }
+  const errorMessage = extractErrorMessage(lastAssistant.info.error);
+  return errorMessage && errorMessage.length > 0 ? errorMessage : "Session error";
+}
 function isSessionComplete(messages) {
   let lastUser;
   let lastAssistant;
@@ -98342,6 +98552,11 @@ Session ID: ${input.sessionID}`;
     if (input.anchorMessageCount !== undefined && messages.length <= input.anchorMessageCount) {
       continue;
     }
+    const sessionError = getTerminalSessionError(messages);
+    if (sessionError) {
+      log("[task] Poll detected terminal session error", { sessionID: input.sessionID, sessionError });
+      return sessionError;
+    }
     if (isSessionComplete(messages)) {
       log("[task] Poll complete - terminal finish detected", { sessionID: input.sessionID, pollCount });
       break;
@@ -99110,7 +99325,8 @@ async function retrySyncPromptWithFallbacks(input) {
   if (!categoryModel || !fallbackChain || fallbackChain.length === 0) {
     return {
       promptError: initialError,
-      categoryModel
+      categoryModel,
+      fallbackState: undefined
     };
   }
   const fallbackState = {
@@ -99126,7 +99342,8 @@ async function retrySyncPromptWithFallbacks(input) {
     if (!nextFallback) {
       return {
         promptError: finalError,
-        categoryModel
+        categoryModel,
+        fallbackState
       };
     }
     const fallbackModel = toDelegatedModelConfig(nextFallback);
@@ -99134,7 +99351,8 @@ async function retrySyncPromptWithFallbacks(input) {
     if (!promptError) {
       return {
         promptError: null,
-        categoryModel: fallbackModel
+        categoryModel: fallbackModel,
+        fallbackState
       };
     }
     finalError = promptError;
@@ -99143,6 +99361,12 @@ async function retrySyncPromptWithFallbacks(input) {
     fallbackState.pending = true;
   }
 }
+function getNextSyncFallbackModel(sessionID, fallbackState) {
+  if (!fallbackState)
+    return null;
+  const nextFallback = getNextReachableFallback(sessionID, fallbackState);
+  return nextFallback ? toDelegatedModelConfig(nextFallback) : null;
+}
 
 // src/tools/delegate-task/sync-task.ts
 async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse, categoryModel, systemContent, modelInfo, fallbackChain, deps = syncTaskDeps) {
@@ -99181,26 +99405,50 @@ async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse
     const sessionID = createSessionResult.sessionID;
     spawnReservation?.commit();
     syncSessionID = sessionID;
-    subagentSessions.add(sessionID);
-    syncSubagentSessions.add(sessionID);
-    setSessionAgent(sessionID, agentToUse);
-    executorCtx.modelFallbackControllerAccessor?.setSessionFallbackChain(sessionID, fallbackChain);
-    if (args.category) {
-      SessionCategoryRegistry.register(sessionID, args.category);
-    }
-    if (onSyncSessionCreated) {
-      log("[task] Invoking onSyncSessionCreated callback", { sessionID, parentID: parentContext.sessionID });
-      try {
-        await onSyncSessionCreated({
-          sessionID,
-          parentID: parentContext.sessionID,
-          title: args.description
-        });
-      } catch (error) {
-        log("[task] onSyncSessionCreated callback failed", { error: String(error) });
+    const registerSyncSession = async (newSessionID) => {
+      syncSessionID = newSessionID;
+      subagentSessions.add(newSessionID);
+      syncSubagentSessions.add(newSessionID);
+      setSessionAgent(newSessionID, agentToUse);
+      executorCtx.modelFallbackControllerAccessor?.setSessionFallbackChain(newSessionID, fallbackChain);
+      if (args.category) {
+        SessionCategoryRegistry.register(newSessionID, args.category);
+      }
+      if (onSyncSessionCreated) {
+        log("[task] Invoking onSyncSessionCreated callback", { sessionID: newSessionID, parentID: parentContext.sessionID });
+        try {
+          await onSyncSessionCreated({
+            sessionID: newSessionID,
+            parentID: parentContext.sessionID,
+            title: args.description
+          });
+        } catch (error) {
+          log("[task] onSyncSessionCreated callback failed", { error: String(error) });
+        }
+        await new Promise((r) => setTimeout(r, 200));
       }
-      await new Promise((r) => setTimeout(r, 200));
-    }
+    };
+    const publishSyncMetadata = async (currentSessionID, currentModel, currentTaskId, spawnDepth) => {
+      await publishToolMetadata(ctx, {
+        title: args.description,
+        metadata: {
+          prompt: args.prompt,
+          agent: agentToUse,
+          category: args.category,
+          ...args.requested_subagent_type !== undefined ? { requested_subagent_type: args.requested_subagent_type } : {},
+          load_skills: args.load_skills,
+          description: args.description,
+          run_in_background: args.run_in_background,
+          taskId: currentSessionID,
+          sessionId: currentSessionID,
+          sync: true,
+          spawnDepth,
+          command: args.command,
+          model: resolveMetadataModel(currentModel, parentContext.model)
+        }
+      });
+    };
+    await registerSyncSession(sessionID);
     taskId = `sync_${sessionID.slice(0, 8)}`;
     const startTime = new Date;
     if (toastManager) {
@@ -99215,25 +99463,7 @@ async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse
         modelInfo
       });
     }
-    const syncTaskMeta = {
-      title: args.description,
-      metadata: {
-        prompt: args.prompt,
-        agent: agentToUse,
-        category: args.category,
-        ...args.requested_subagent_type !== undefined ? { requested_subagent_type: args.requested_subagent_type } : {},
-        load_skills: args.load_skills,
-        description: args.description,
-        run_in_background: args.run_in_background,
-        taskId: sessionID,
-        sessionId: sessionID,
-        sync: true,
-        spawnDepth: spawnContext.childDepth,
-        command: args.command,
-        model: resolveMetadataModel(categoryModel, parentContext.model)
-      }
-    };
-    await publishToolMetadata(ctx, syncTaskMeta);
+    await publishSyncMetadata(sessionID, categoryModel, taskId, spawnContext.childDepth);
     const syncPromptInput = {
       sessionID,
       agentToUse,
@@ -99244,55 +99474,106 @@ async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse
       sisyphusAgentConfig: executorCtx.sisyphusAgentConfig
     };
     let effectiveCategoryModel = categoryModel;
-    let promptError = await deps.sendSyncPrompt(client2, {
-      ...syncPromptInput,
-      categoryModel: effectiveCategoryModel
-    });
-    if (promptError) {
-      const promptResult = await retrySyncPromptWithFallbacks({
-        sessionID,
-        initialError: promptError,
-        categoryModel: effectiveCategoryModel,
-        fallbackChain,
-        sendPrompt: async (fallbackModel) => {
-          return deps.sendSyncPrompt(client2, {
-            ...syncPromptInput,
-            categoryModel: fallbackModel
+    let fallbackState = effectiveCategoryModel && fallbackChain?.length ? {
+      providerID: effectiveCategoryModel.providerID,
+      modelID: effectiveCategoryModel.modelID,
+      fallbackChain,
+      attemptCount: 0,
+      pending: true
+    } : undefined;
+    let activeSessionID = sessionID;
+    const cleanupRetrySession = (currentSessionID) => {
+      subagentSessions.delete(currentSessionID);
+      syncSubagentSessions.delete(currentSessionID);
+      executorCtx.modelFallbackControllerAccessor?.clearSessionFallbackChain(currentSessionID);
+      SessionCategoryRegistry.remove(currentSessionID);
+    };
+    try {
+      while (true) {
+        let promptError = await deps.sendSyncPrompt(client2, {
+          ...syncPromptInput,
+          sessionID: activeSessionID,
+          categoryModel: effectiveCategoryModel
+        });
+        if (promptError) {
+          const promptResult = await retrySyncPromptWithFallbacks({
+            sessionID: activeSessionID,
+            initialError: promptError,
+            categoryModel: effectiveCategoryModel,
+            fallbackChain,
+            sendPrompt: async (fallbackModel) => {
+              return deps.sendSyncPrompt(client2, {
+                ...syncPromptInput,
+                sessionID: activeSessionID,
+                categoryModel: fallbackModel
+              });
+            }
           });
+          promptError = promptResult.promptError;
+          effectiveCategoryModel = promptResult.categoryModel;
+          fallbackState = promptResult.fallbackState ?? fallbackState;
+          if (promptError) {
+            return promptError;
+          }
         }
-      });
-      promptError = promptResult.promptError;
-      effectiveCategoryModel = promptResult.categoryModel;
-      if (promptError) {
-        return promptError;
-      }
-    }
-    try {
-      const pollError = await deps.pollSyncSession(ctx, client2, {
-        sessionID,
-        agentToUse,
-        toastManager,
-        taskId
-      }, syncPollTimeoutMs);
-      if (pollError) {
-        return pollError;
-      }
-      const result = await deps.fetchSyncResult(client2, sessionID);
-      if (!result.ok) {
-        return result.error;
-      }
-      const duration = formatDuration2(startTime);
-      const actualModelStr = effectiveCategoryModel ? `${effectiveCategoryModel.providerID}/${effectiveCategoryModel.modelID}` : undefined;
-      const parentModelStr = parentContext.model ? `${parentContext.model.providerID}/${parentContext.model.modelID}` : undefined;
-      let modelRoutingNote = "";
-      if (actualModelStr && parentModelStr && actualModelStr !== parentModelStr) {
-        modelRoutingNote = `
+        const pollError = await deps.pollSyncSession(ctx, client2, {
+          sessionID: activeSessionID,
+          agentToUse,
+          toastManager,
+          taskId
+        }, syncPollTimeoutMs);
+        if (pollError) {
+          const nextFallbackModel = shouldRetryError({ message: pollError }) ? getNextSyncFallbackModel(activeSessionID, fallbackState) : null;
+          if (!nextFallbackModel) {
+            return pollError;
+          }
+          cleanupRetrySession(activeSessionID);
+          const retrySessionResult = await deps.createSyncSession(client2, {
+            parentSessionID: parentContext.sessionID,
+            agentToUse,
+            description: args.description,
+            defaultDirectory: directory
+          });
+          if (!retrySessionResult.ok) {
+            return retrySessionResult.error;
+          }
+          activeSessionID = retrySessionResult.sessionID;
+          effectiveCategoryModel = nextFallbackModel;
+          await registerSyncSession(activeSessionID);
+          if (toastManager && taskId) {
+            toastManager.addTask({
+              id: taskId,
+              sessionID: activeSessionID,
+              description: args.description,
+              agent: agentToUse,
+              isBackground: false,
+              category: args.category,
+              skills: args.load_skills,
+              modelInfo
+            });
+          }
+          if (taskId) {
+            await publishSyncMetadata(activeSessionID, effectiveCategoryModel, taskId, spawnContext.childDepth);
+          }
+          continue;
+        }
+        const result = await deps.fetchSyncResult(client2, activeSessionID);
+        if (!result.ok) {
+          return result.error;
+        }
+        const duration = formatDuration2(startTime);
+        const actualModelStr = effectiveCategoryModel ? `${effectiveCategoryModel.providerID}/${effectiveCategoryModel.modelID}` : undefined;
+        const parentModelStr = parentContext.model ? `${parentContext.model.providerID}/${parentContext.model.modelID}` : undefined;
+        let modelRoutingNote = "";
+        if (actualModelStr && parentModelStr && actualModelStr !== parentModelStr) {
+          modelRoutingNote = `
 \u26A0\uFE0F  Model routing: parent used ${parentModelStr}, this subagent used ${actualModelStr} (via category: ${args.category ?? "unknown"})`;
-      } else if (actualModelStr) {
-        modelRoutingNote = `
+        } else if (actualModelStr) {
+          modelRoutingNote = `
 Model: ${actualModelStr}${args.category ? ` (category: ${args.category})` : ""}`;
-      }
-      return `Task completed in ${duration}.
+        }
+        await publishSyncMetadata(activeSessionID, effectiveCategoryModel, taskId, spawnContext.childDepth);
+        return `Task completed in ${duration}.
 
 Agent: ${agentToUse}${args.category ? ` (category: ${args.category})` : ""}${modelRoutingNote}
 
@@ -99301,11 +99582,12 @@ Agent: ${agentToUse}${args.category ? ` (category: ${args.category})` : ""}${mod
 ${result.textContent || "(No text output)"}
 
 ${buildTaskMetadataBlock({
-        sessionId: sessionID,
-        taskId: sessionID,
-        agent: agentToUse,
-        category: args.category
-      })}`;
+          sessionId: activeSessionID,
+          taskId: activeSessionID,
+          agent: agentToUse,
+          category: args.category
+        })}`;
+      }
     } finally {
       if (toastManager && taskId !== undefined) {
         toastManager.removeTask(taskId);
@@ -99384,6 +99666,7 @@ function resolveCategoryConfig(categoryName, options) {
 }
 
 // src/tools/delegate-task/category-resolver.ts
+init_constants2();
 init_plugin_identity();
 
 // src/tools/delegate-task/available-models.ts
@@ -99608,6 +99891,19 @@ function applyCategoryParams(base, config2) {
     result.thinking = config2.thinking;
   return result;
 }
+function resolveCategoryPromptAppendForModel(categoryName, actualModel, staticPromptAppend, userPromptAppend) {
+  const dynamicResolver = CATEGORY_PROMPT_APPEND_RESOLVERS[categoryName];
+  if (!dynamicResolver) {
+    return staticPromptAppend || undefined;
+  }
+  const dynamicBase = dynamicResolver(actualModel);
+  if (!userPromptAppend) {
+    return dynamicBase || undefined;
+  }
+  return dynamicBase ? `${dynamicBase}
+
+${userPromptAppend}` : userPromptAppend;
+}
 async function resolveCategoryExecution(args, executorCtx, inheritedModel, systemDefaultModel) {
   const { client: client2, userCategories, sisyphusJuniorModel } = executorCtx;
   const categoryName = args.category;
@@ -99737,7 +100033,7 @@ Available categories: ${allCategoryNames}`
     const parsedModel = parseModelString(actualModel);
     categoryModel = parsedModel ?? undefined;
   }
-  const categoryPromptAppend = resolved.promptAppend || undefined;
+  const categoryPromptAppend = resolveCategoryPromptAppendForModel(args.category, actualModel, resolved.promptAppend, userCategories?.[args.category]?.prompt_append);
   if (!categoryModel && !actualModel && !isModelResolutionSkipped) {
     const categoryNames = Object.keys(enabledCategories);
     return {
@@ -103445,6 +103741,43 @@ function formatDuration3(start, end) {
 }
 
 // src/features/background-agent/background-task-notification-template.ts
+function formatAttemptModel(attempt) {
+  if (attempt.providerID && attempt.modelID) {
+    return `${attempt.providerID}/${attempt.modelID}`;
+  }
+  if (attempt.modelID) {
+    return attempt.modelID;
+  }
+  if (attempt.providerID) {
+    return attempt.providerID;
+  }
+  return "unknown-model";
+}
+function formatAttemptTimeline(task) {
+  if (!task.attempts || task.attempts.length <= 1) {
+    return "";
+  }
+  const lines = task.attempts.map((attempt) => {
+    const attemptLines = [
+      `  - Attempt ${attempt.attemptNumber} \u2014 ${attempt.status.toUpperCase()} \u2014 ${formatAttemptModel(attempt)} \u2014 ${attempt.sessionID ?? "unknown"}`
+    ];
+    if (attempt.status !== "completed" && attempt.error) {
+      attemptLines.push(`    Error: ${attempt.error}`);
+    }
+    return attemptLines.join(`
+`);
+  }).join(`
+`);
+  return `Background task attempts:
+${lines}`;
+}
+function formatTaskSummaryLine(task) {
+  const baseLine = `- \`${task.id}\`: ${task.description || task.id}`;
+  const statusSuffix = task.status === "completed" ? "" : ` [${task.status.toUpperCase()}]${task.error ? ` - ${task.error}` : ""}`;
+  const timeline = formatAttemptTimeline(task);
+  return `${baseLine}${statusSuffix}${timeline ? `
+${timeline}` : ""}`;
+}
 function buildBackgroundTaskNotificationText(input) {
   const { task, duration, statusText, allComplete, remainingCount, completedTasks } = input;
   const safeDescription = (t) => t.description || t.id;
@@ -103453,9 +103786,9 @@ function buildBackgroundTaskNotificationText(input) {
   if (allComplete) {
     const succeededTasks = completedTasks.filter((t) => t.status === "completed");
     const failedTasks = completedTasks.filter((t) => t.status !== "completed");
-    const succeededText = succeededTasks.length > 0 ? succeededTasks.map((t) => `- \`${t.id}\`: ${safeDescription(t)}`).join(`
+    const succeededText = succeededTasks.length > 0 ? succeededTasks.map((t) => formatTaskSummaryLine(t)).join(`
 `) : "";
-    const failedText = failedTasks.length > 0 ? failedTasks.map((t) => `- \`${t.id}\`: ${safeDescription(t)} [${t.status.toUpperCase()}]${t.error ? ` - ${t.error}` : ""}`).join(`
+    const failedText = failedTasks.length > 0 ? failedTasks.map((t) => formatTaskSummaryLine(t)).join(`
 `) : "";
     const hasFailures = failedTasks.length > 0;
     const header = hasFailures ? `[ALL BACKGROUND TASKS FINISHED - ${failedTasks.length} FAILED]` : "[ALL BACKGROUND TASKS COMPLETE]";
@@ -103472,7 +103805,7 @@ ${failedText}
 `;
     }
     if (!body) {
-      body = `- \`${task.id}\`: ${safeDescription(task)} [${task.status.toUpperCase()}]${task.error ? ` - ${task.error}` : ""}
+      body = `${formatTaskSummaryLine(task)}
 `;
     }
     return `<system-reminder>
@@ -103499,83 +103832,6 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 </system-reminder>`;
 }
 
-// src/features/background-agent/error-classifier.ts
-function isRecord15(value) {
-  return typeof value === "object" && value !== null;
-}
-function isAbortedSessionError(error) {
-  const message = getErrorText(error);
-  return message.toLowerCase().includes("aborted");
-}
-function getErrorText(error) {
-  if (!error)
-    return "";
-  if (typeof error === "string")
-    return error;
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  if (typeof error === "object" && error !== null) {
-    if ("message" in error && typeof error.message === "string") {
-      return error.message;
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return error.name;
-    }
-  }
-  return "";
-}
-function extractErrorName2(error) {
-  if (isRecord15(error) && typeof error["name"] === "string")
-    return error["name"];
-  if (error instanceof Error)
-    return error.name;
-  return;
-}
-function extractErrorMessage(error) {
-  if (!error)
-    return;
-  if (typeof error === "string")
-    return error;
-  if (error instanceof Error)
-    return error.message;
-  if (isRecord15(error)) {
-    const dataRaw = error["data"];
-    const candidates = [
-      error,
-      dataRaw,
-      error["error"],
-      isRecord15(dataRaw) ? dataRaw["error"] : undefined,
-      error["cause"]
-    ];
-    for (const candidate of candidates) {
-      if (typeof candidate === "string" && candidate.length > 0)
-        return candidate;
-      if (isRecord15(candidate) && typeof candidate["message"] === "string" && candidate["message"].length > 0) {
-        return candidate["message"];
-      }
-    }
-  }
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
-function getSessionErrorMessage(properties) {
-  const errorRaw = properties["error"];
-  if (!isRecord15(errorRaw))
-    return;
-  const dataRaw = errorRaw["data"];
-  if (isRecord15(dataRaw)) {
-    const message2 = dataRaw["message"];
-    if (typeof message2 === "string")
-      return message2;
-  }
-  const message = errorRaw["message"];
-  return typeof message === "string" ? message : undefined;
-}
-
 // src/features/background-agent/abort-with-timeout.ts
 async function abortWithTimeout(client2, sessionID, timeoutMs = 1e4) {
   let timeoutHandle;
@@ -103603,9 +103859,138 @@ async function abortWithTimeout(client2, sessionID, timeoutMs = 1e4) {
   }
 }
 
+// src/features/background-agent/attempt-lifecycle.ts
+function toAttemptModel(model) {
+  return {
+    providerID: model?.providerID,
+    modelID: model?.modelID,
+    variant: model?.variant
+  };
+}
+function toTaskModel(attempt) {
+  if (!attempt.providerID || !attempt.modelID) {
+    return;
+  }
+  return {
+    providerID: attempt.providerID,
+    modelID: attempt.modelID,
+    ...attempt.variant ? { variant: attempt.variant } : {}
+  };
+}
+function getAttemptIndex(task, attemptID) {
+  return task.attempts?.findIndex((attempt) => attempt.attemptID === attemptID) ?? -1;
+}
+function getAttempt(task, attemptID) {
+  const index = getAttemptIndex(task, attemptID);
+  return index === -1 ? undefined : task.attempts?.[index];
+}
+function isTerminalStatus(status) {
+  return status === "completed" || status === "error" || status === "cancelled" || status === "interrupt";
+}
+function getCurrentAttempt(task) {
+  if (!task.currentAttemptID) {
+    return;
+  }
+  return getAttempt(task, task.currentAttemptID);
+}
+function ensureCurrentAttempt(task, model = task.model) {
+  const existingAttempt = getCurrentAttempt(task);
+  if (existingAttempt) {
+    return existingAttempt;
+  }
+  const attempt = {
+    attemptID: `att_${crypto.randomUUID().slice(0, 8)}`,
+    attemptNumber: (task.attempts?.length ?? 0) + 1,
+    sessionID: task.sessionID,
+    ...toAttemptModel(model),
+    status: task.status,
+    error: task.error,
+    startedAt: task.startedAt,
+    completedAt: task.completedAt
+  };
+  task.attempts = [...task.attempts ?? [], attempt];
+  task.currentAttemptID = attempt.attemptID;
+  return attempt;
+}
+function projectTaskFromCurrentAttempt(task) {
+  const currentAttempt = getCurrentAttempt(task);
+  if (!currentAttempt) {
+    return task;
+  }
+  task.status = currentAttempt.status;
+  task.sessionID = currentAttempt.sessionID;
+  task.startedAt = currentAttempt.startedAt;
+  task.completedAt = currentAttempt.completedAt;
+  task.error = currentAttempt.error;
+  task.model = toTaskModel(currentAttempt);
+  return task;
+}
+function startAttempt(task, model) {
+  const attempt = {
+    attemptID: `att_${crypto.randomUUID().slice(0, 8)}`,
+    attemptNumber: (task.attempts?.length ?? 0) + 1,
+    ...toAttemptModel(model),
+    status: "pending"
+  };
+  task.attempts = [...task.attempts ?? [], attempt];
+  task.currentAttemptID = attempt.attemptID;
+  task.status = "pending";
+  task.sessionID = undefined;
+  task.startedAt = undefined;
+  task.completedAt = undefined;
+  task.error = undefined;
+  task.model = model;
+  return attempt;
+}
+function bindAttemptSession(task, attemptID, sessionID, model) {
+  ensureCurrentAttempt(task, model);
+  if (task.currentAttemptID !== attemptID) {
+    return;
+  }
+  const attempt = getAttempt(task, attemptID);
+  if (!attempt || isTerminalStatus(attempt.status)) {
+    return;
+  }
+  attempt.sessionID = sessionID;
+  attempt.status = "running";
+  attempt.startedAt = new Date;
+  attempt.completedAt = undefined;
+  attempt.error = undefined;
+  attempt.providerID = model?.providerID ?? attempt.providerID;
+  attempt.modelID = model?.modelID ?? attempt.modelID;
+  attempt.variant = model?.variant ?? attempt.variant;
+  return getCurrentAttempt(projectTaskFromCurrentAttempt(task));
+}
+function finalizeAttempt(task, attemptID, status, error) {
+  const attempt = getAttempt(task, attemptID);
+  if (!attempt) {
+    return;
+  }
+  attempt.status = status;
+  attempt.completedAt = new Date;
+  attempt.error = error;
+  if (task.currentAttemptID === attemptID) {
+    projectTaskFromCurrentAttempt(task);
+  }
+  return attempt;
+}
+function scheduleRetryAttempt(task, failedAttemptID, nextModel, error) {
+  const failedAttempt = finalizeAttempt(task, failedAttemptID, "error", error);
+  if (!failedAttempt || task.currentAttemptID !== failedAttemptID) {
+    return;
+  }
+  return startAttempt(task, nextModel);
+}
+function findAttemptBySession(task, sessionID) {
+  return task.attempts?.find((attempt) => attempt.sessionID === sessionID);
+}
+
 // src/features/background-agent/fallback-retry-handler.ts
+function canonicalizeModelID2(modelID) {
+  return modelID.toLowerCase().replace(/\./g, "-");
+}
 async function tryFallbackRetry(args) {
-  const { task, errorInfo, source, concurrencyManager, client: client2, idleDeferralTimers, queuesByKey, processKey } = args;
+  const { task, errorInfo, source, concurrencyManager, client: client2, idleDeferralTimers, queuesByKey, processKey, onRetrying } = args;
   const fallbackChain = task.fallbackChain;
   const canRetry = shouldRetryError(errorInfo) && fallbackChain && fallbackChain.length > 0 && hasMoreFallbacks(fallbackChain, task.attemptCount ?? 0);
   if (!canRetry)
@@ -103625,6 +104010,7 @@ async function tryFallbackRetry(args) {
   };
   let selectedAttemptCount = attemptCount;
   let nextFallback;
+  let nextProviderID;
   while (fallbackChain && selectedAttemptCount < fallbackChain.length) {
     const candidate = getNextFallback(fallbackChain, selectedAttemptCount);
     if (!candidate)
@@ -103639,12 +104025,25 @@ async function tryFallbackRetry(args) {
       });
       continue;
     }
+    const candidateProviderID = selectFallbackProvider(candidate.providers, task.model?.providerID);
+    const candidateModelID = transformModelForProvider(candidateProviderID, candidate.model);
+    const isNoOpFallback = !!task.model && candidateProviderID.toLowerCase() === task.model.providerID.toLowerCase() && canonicalizeModelID2(candidateModelID) === canonicalizeModelID2(task.model.modelID);
+    if (isNoOpFallback) {
+      log("[background-agent] Skipping no-op fallback:", {
+        taskId: task.id,
+        source,
+        model: candidate.model,
+        providers: candidate.providers
+      });
+      continue;
+    }
     nextFallback = candidate;
+    nextProviderID = candidateProviderID;
     break;
   }
   if (!nextFallback)
     return false;
-  const providerID = selectFallbackProvider(nextFallback.providers, task.model?.providerID);
+  const providerID = nextProviderID ?? selectFallbackProvider(nextFallback.providers, task.model?.providerID);
   log("[background-agent] Retryable error, attempting fallback:", {
     taskId: task.id,
     source,
@@ -103663,18 +104062,34 @@ async function tryFallbackRetry(args) {
     idleDeferralTimers.delete(task.id);
   }
   const previousSessionID = task.sessionID;
-  task.attemptCount = selectedAttemptCount;
+  const previousModel = task.model;
   const transformedModelId = transformModelForProvider(providerID, nextFallback.model);
-  task.model = {
+  const nextModel = {
     providerID,
     modelID: transformedModelId,
     variant: nextFallback.variant
   };
-  task.status = "pending";
-  task.sessionID = undefined;
-  task.startedAt = undefined;
+  task.attemptCount = selectedAttemptCount;
+  const failedAttemptID = ensureCurrentAttempt(task, previousModel).attemptID;
+  const nextAttempt = failedAttemptID ? scheduleRetryAttempt(task, failedAttemptID, nextModel, errorInfo.message) : undefined;
+  if (!nextAttempt) {
+    return false;
+  }
   task.queuedAt = new Date;
-  task.error = undefined;
+  task.retryNotification = {
+    previousSessionID,
+    failedModel: previousModel ? `${previousModel.providerID}/${previousModel.modelID}` : undefined,
+    failedError: errorInfo.message,
+    nextModel: `${providerID}/${transformedModelId}`
+  };
+  onRetrying?.({
+    task,
+    source,
+    previousSessionID,
+    failedModel: task.retryNotification.failedModel,
+    failedError: errorInfo.message,
+    nextModel: `${providerID}/${transformedModelId}`
+  });
   const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
   const queue = queuesByKey.get(key) ?? [];
   const retryInput = {
@@ -103686,7 +104101,7 @@ async function tryFallbackRetry(args) {
     parentModel: task.parentModel,
     parentAgent: task.parentAgent,
     parentTools: task.parentTools,
-    model: task.model,
+    model: nextModel,
     fallbackChain: task.fallbackChain,
     category: task.category,
     isUnstableAgent: task.isUnstableAgent
@@ -103694,7 +104109,7 @@ async function tryFallbackRetry(args) {
   if (previousSessionID) {
     await abortWithTimeout(client2, previousSessionID).catch(() => {});
   }
-  queue.push({ task, input: retryInput });
+  queue.push({ task, input: retryInput, attemptID: nextAttempt.attemptID });
   queuesByKey.set(key, queue);
   processKey(key);
   return true;
@@ -104312,10 +104727,37 @@ function resolveMessagePartInfo(properties) {
   }
   return properties;
 }
+function formatAttemptModelSummary(attempt) {
+  if (!attempt?.providerID || !attempt.modelID) {
+    return;
+  }
+  return `${attempt.providerID}/${attempt.modelID}`;
+}
+function getPreviousAttempt(task, attemptID) {
+  if (!attemptID || !task.attempts || task.attempts.length === 0) {
+    return;
+  }
+  const attemptIndex = task.attempts.findIndex((attempt) => attempt.attemptID === attemptID);
+  if (attemptIndex <= 0) {
+    return;
+  }
+  return task.attempts[attemptIndex - 1];
+}
+function cloneAttempts(task) {
+  if (!task.attempts) {
+    return;
+  }
+  return task.attempts.map((attempt) => ({ ...attempt }));
+}
+function buildLocalSessionUrl(directory, sessionID) {
+  const encodedDirectory = Buffer.from(directory).toString("base64url");
+  return `http://127.0.0.1:4096/${encodedDirectory}/session/${sessionID}`;
+}
 var MAX_TASK_REMOVAL_RESCHEDULES = 6;
 
 class BackgroundManager {
   tasks;
+  tasksByParentSession;
   notifications;
   pendingNotifications;
   pendingByParent;
@@ -104340,10 +104782,12 @@ class BackgroundManager {
   rootDescendantCounts;
   preStartDescendantReservations;
   enableParentSessionNotifications;
+  modelFallbackControllerAccessor;
   taskHistory = new TaskHistory;
   cachedCircuitBreakerSettings;
   constructor(ctx, config2, options) {
     this.tasks = new Map;
+    this.tasksByParentSession = new Map;
     this.notifications = new Map;
     this.pendingNotifications = new Map;
     this.pendingByParent = new Map;
@@ -104357,6 +104801,7 @@ class BackgroundManager {
     this.rootDescendantCounts = new Map;
     this.preStartDescendantReservations = new Set;
     this.enableParentSessionNotifications = options?.enableParentSessionNotifications ?? true;
+    this.modelFallbackControllerAccessor = options?.modelFallbackControllerAccessor;
     this.registerProcessCleanup();
   }
   async abortSessionWithLogging(sessionID, reason) {
@@ -104429,6 +104874,42 @@ class BackgroundManager {
     }
     this.unregisterRootDescendant(task.rootSessionID);
   }
+  addTask(task) {
+    this.tasks.set(task.id, task);
+    if (!task.parentSessionID) {
+      return;
+    }
+    const taskIDs = this.tasksByParentSession.get(task.parentSessionID) ?? new Set;
+    taskIDs.add(task.id);
+    this.tasksByParentSession.set(task.parentSessionID, taskIDs);
+  }
+  removeTask(task) {
+    this.tasks.delete(task.id);
+    this.removeTaskFromParentIndex(task.id, task.parentSessionID);
+  }
+  updateTaskParent(task, parentSessionID) {
+    if (task.parentSessionID === parentSessionID) {
+      return;
+    }
+    this.removeTaskFromParentIndex(task.id, task.parentSessionID);
+    task.parentSessionID = parentSessionID;
+    const taskIDs = this.tasksByParentSession.get(parentSessionID) ?? new Set;
+    taskIDs.add(task.id);
+    this.tasksByParentSession.set(parentSessionID, taskIDs);
+  }
+  removeTaskFromParentIndex(taskID, parentSessionID) {
+    if (!parentSessionID) {
+      return;
+    }
+    const taskIDs = this.tasksByParentSession.get(parentSessionID);
+    if (!taskIDs) {
+      return;
+    }
+    taskIDs.delete(taskID);
+    if (taskIDs.size === 0) {
+      this.tasksByParentSession.delete(parentSessionID);
+    }
+  }
   async launch(input) {
     log("[background-agent] launch() called with:", {
       agent: input.agent,
@@ -104466,7 +104947,8 @@ class BackgroundManager {
         attemptCount: 0,
         category: input.category
       };
-      this.tasks.set(task.id, task);
+      const firstAttempt = startAttempt(task, input.model);
+      this.addTask(task);
       this.taskHistory.record(input.parentSessionID, { id: task.id, agent: input.agent, description: input.description, status: "pending", category: input.category });
       if (input.parentSessionID) {
         const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
@@ -104475,7 +104957,7 @@ class BackgroundManager {
       }
       const key = this.getConcurrencyKeyFromInput(input);
       const queue = this.queuesByKey.get(key) ?? [];
-      queue.push({ task, input });
+      queue.push({ task, input, attemptID: firstAttempt.attemptID });
       this.queuesByKey.set(key, queue);
       log("[background-agent] Task queued:", { taskId: task.id, key, queueLength: queue.length });
       const toastManager = getTaskToastManager();
@@ -104521,9 +105003,13 @@ class BackgroundManager {
         } catch (error) {
           log("[background-agent] Error starting task:", error);
           this.rollbackPreStartDescendantReservation(item.task);
-          item.task.status = "error";
-          item.task.error = error instanceof Error ? error.message : String(error);
-          item.task.completedAt = new Date;
+          if (item.task.currentAttemptID) {
+            finalizeAttempt(item.task, item.task.currentAttemptID, "error", error instanceof Error ? error.message : String(error));
+          } else {
+            item.task.status = "error";
+            item.task.error = error instanceof Error ? error.message : String(error);
+            item.task.completedAt = new Date;
+          }
           if (item.task.concurrencyKey) {
             this.concurrencyManager.release(item.task.concurrencyKey);
             item.task.concurrencyKey = undefined;
@@ -104546,6 +105032,7 @@ class BackgroundManager {
   }
   async startTask(item) {
     const { task, input } = item;
+    const attemptID = item.attemptID ?? ensureCurrentAttempt(task, input.model).attemptID;
     log("[background-agent] Starting task:", {
       taskId: task.id,
       agent: input.agent,
@@ -104615,15 +105102,49 @@ class BackgroundManager {
       this.concurrencyManager.release(concurrencyKey);
       return;
     }
-    task.status = "running";
-    task.startedAt = new Date;
-    task.sessionID = sessionID;
+    const boundAttempt = bindAttemptSession(task, attemptID, sessionID, input.model);
+    if (!boundAttempt) {
+      await this.abortSessionWithLogging(sessionID, "stale attempt binding cleanup");
+      subagentSessions.delete(sessionID);
+      if (task.rootSessionID) {
+        this.unregisterRootDescendant(task.rootSessionID);
+      }
+      this.concurrencyManager.release(concurrencyKey);
+      return;
+    }
     task.progress = {
       toolCalls: 0,
       lastUpdate: new Date
     };
     task.concurrencyKey = concurrencyKey;
     task.concurrencyGroup = concurrencyKey;
+    if (task.retryNotification) {
+      const attemptNumber = boundAttempt.attemptNumber;
+      const retrySessionUrl = buildLocalSessionUrl(parentDirectory, sessionID);
+      const previousAttempt = getPreviousAttempt(task, boundAttempt.attemptID);
+      const failedSessionID = previousAttempt?.sessionID ?? task.retryNotification.previousSessionID;
+      const failedSessionLine = failedSessionID ? `
+- Failed session: \`${failedSessionID}\`` : "";
+      const failedModel = formatAttemptModelSummary(previousAttempt) ?? task.retryNotification.failedModel;
+      const failedModelLine = failedModel ? `
+- Failed model: \`${failedModel}\`` : "";
+      const failedError = previousAttempt?.error ?? task.retryNotification.failedError;
+      const failedErrorLine = failedError ? `
+- Error: ${failedError}` : "";
+      const retryModel = formatAttemptModelSummary(boundAttempt) ?? task.retryNotification.nextModel;
+      this.queuePendingNotification(task.parentSessionID, `<system-reminder>
+[BACKGROUND TASK RETRY SESSION READY]
+**ID:** \`${task.id}\`
+**Description:** ${task.description}
+**Retry attempt:** ${attemptNumber}
+**Retry session:** \`${sessionID}\`
+**Retry link:** ${retrySessionUrl}${failedSessionLine}${failedModelLine}${failedErrorLine}${retryModel ? `
+- Model: \`${retryModel}\`` : ""}
+
+The fallback retry session is now created and can be inspected directly.
+</system-reminder>`);
+      task.retryNotification = undefined;
+    }
     this.taskHistory.record(input.parentSessionID, { id: task.id, sessionID, agent: input.agent, description: input.description, status: "running", category: input.category, startedAt: task.startedAt });
     this.startPolling();
     log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent });
@@ -104687,16 +105208,33 @@ class BackgroundManager {
         }
       }
       log("[background-agent] promptAsync error:", error);
-      const existingTask = this.findBySession(sessionID);
+      const resolvedTask = this.resolveTaskAttemptBySession(sessionID);
+      const existingTask = resolvedTask?.task;
+      if (resolvedTask && !resolvedTask.isCurrent) {
+        log("[background-agent] Ignoring prompt error from stale attempt session", {
+          sessionID,
+          currentAttemptID: resolvedTask.task.currentAttemptID,
+          attemptID: resolvedTask.attemptID
+        });
+        return;
+      }
       if (existingTask) {
-        existingTask.status = "interrupt";
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (errorMessage.includes("agent.name") || errorMessage.includes("undefined") || isAgentNotFoundError(error)) {
-          existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`;
+        const errorInfo = {
+          name: extractErrorName2(error),
+          message: extractErrorMessage(error)
+        };
+        if (await this.tryFallbackRetry(existingTask, errorInfo, "promptAsync.launch")) {
+          return;
+        }
+        const errorMessage = errorInfo.message ?? (error instanceof Error ? error.message : String(error));
+        const terminalError = errorMessage.includes("agent.name") || errorMessage.includes("undefined") || isAgentNotFoundError(error) ? `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.` : errorMessage;
+        if (existingTask.currentAttemptID) {
+          finalizeAttempt(existingTask, existingTask.currentAttemptID, "interrupt", terminalError);
         } else {
-          existingTask.error = errorMessage;
+          existingTask.status = "interrupt";
+          existingTask.error = terminalError;
+          existingTask.completedAt = new Date;
         }
-        existingTask.completedAt = new Date;
         if (existingTask.rootSessionID) {
           this.unregisterRootDescendant(existingTask.rootSessionID);
         }
@@ -104717,13 +105255,24 @@ class BackgroundManager {
     return this.tasks.get(id);
   }
   getTasksByParentSession(sessionID) {
-    const result = [];
-    for (const task of this.tasks.values()) {
-      if (task.parentSessionID === sessionID) {
-        result.push(task);
+    const taskIDs = this.tasksByParentSession.get(sessionID);
+    if (!taskIDs) {
+      const result = [];
+      for (const task of this.tasks.values()) {
+        if (task.parentSessionID === sessionID) {
+          result.push(task);
+        }
+      }
+      return result;
+    }
+    const tasks = [];
+    for (const taskID of taskIDs) {
+      const task = this.tasks.get(taskID);
+      if (task) {
+        tasks.push(task);
       }
     }
-    return result;
+    return tasks;
   }
   getAllDescendantTasks(sessionID) {
     const result = [];
@@ -104742,9 +105291,31 @@ class BackgroundManager {
       if (task.sessionID === sessionID) {
         return task;
       }
+      if (findAttemptBySession(task, sessionID)) {
+        return task;
+      }
     }
     return;
   }
+  resolveTaskAttemptBySession(sessionID) {
+    const task = this.findBySession(sessionID);
+    if (!task) {
+      return;
+    }
+    const attempt = findAttemptBySession(task, sessionID);
+    if (!attempt) {
+      return {
+        task,
+        attemptID: undefined,
+        isCurrent: task.sessionID === sessionID
+      };
+    }
+    return {
+      task,
+      attemptID: attempt.attemptID,
+      isCurrent: task.currentAttemptID === attempt.attemptID
+    };
+  }
   getConcurrencyKeyFromInput(input) {
     if (input.model) {
       return `${input.model.providerID}/${input.model.modelID}`;
@@ -104757,7 +105328,7 @@ class BackgroundManager {
       const parentChanged = input.parentSessionID !== existingTask.parentSessionID;
       if (parentChanged) {
         this.cleanupPendingByParent(existingTask);
-        existingTask.parentSessionID = input.parentSessionID;
+        this.updateTaskParent(existingTask, input.parentSessionID);
       }
       if (input.parentAgent !== undefined) {
         existingTask.parentAgent = input.parentAgent;
@@ -104801,7 +105372,7 @@ class BackgroundManager {
       concurrencyKey: input.concurrencyKey,
       concurrencyGroup
     };
-    this.tasks.set(task.id, task);
+    this.addTask(task);
     subagentSessions.add(input.sessionID);
     this.startPolling();
     this.taskHistory.record(input.parentSessionID, { id: task.id, sessionID: input.sessionID, agent: input.agent || "task", description: input.description, status: "running", startedAt: task.startedAt });
@@ -104840,7 +105411,7 @@ class BackgroundManager {
     existingTask.status = "running";
     existingTask.completedAt = undefined;
     existingTask.error = undefined;
-    existingTask.parentSessionID = input.parentSessionID;
+    this.updateTaskParent(existingTask, input.parentSessionID);
     existingTask.parentMessageID = input.parentMessageID;
     existingTask.parentModel = input.parentModel;
     existingTask.parentAgent = input.parentAgent;
@@ -104907,8 +105478,15 @@ class BackgroundManager {
       }
     }).catch(async (error) => {
       log("[background-agent] resume prompt error:", error);
+      const errorInfo = {
+        name: extractErrorName2(error),
+        message: extractErrorMessage(error)
+      };
+      if (await this.tryFallbackRetry(existingTask, errorInfo, "promptAsync.resume")) {
+        return;
+      }
       existingTask.status = "interrupt";
-      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorMessage = errorInfo.message ?? (error instanceof Error ? error.message : String(error));
       existingTask.error = errorMessage;
       existingTask.completedAt = new Date;
       if (existingTask.rootSessionID) {
@@ -104991,8 +105569,11 @@ class BackgroundManager {
       }
       if (role !== "assistant")
         return;
-      const task = this.findBySession(sessionID);
-      if (!task || task.status !== "running")
+      const resolved = this.resolveTaskAttemptBySession(sessionID);
+      if (!resolved?.isCurrent)
+        return;
+      const { task } = resolved;
+      if (task.status !== "running")
         return;
       const assistantError = info["error"];
       if (!assistantError)
@@ -105013,9 +105594,10 @@ class BackgroundManager {
       const sessionID = partInfo?.sessionID;
       if (!sessionID)
         return;
-      const task = this.findBySession(sessionID);
-      if (!task)
+      const resolved = this.resolveTaskAttemptBySession(sessionID);
+      if (!resolved?.isCurrent)
         return;
+      const { task } = resolved;
       if (this.hasOutputSignalFromPart(partInfo)) {
         this.markSessionOutputObserved(sessionID);
       }
@@ -105100,7 +105682,10 @@ class BackgroundManager {
         return;
       handleSessionIdleBackgroundEvent({
         properties: props,
-        findBySession: (id) => this.findBySession(id),
+        findBySession: (id) => {
+          const resolved = this.resolveTaskAttemptBySession(id);
+          return resolved?.isCurrent ? resolved.task : undefined;
+        },
         idleDeferralTimers: this.idleDeferralTimers,
         validateSessionHasOutput: (id) => this.validateSessionHasOutput(id),
         checkSessionTodos: (id) => this.checkSessionTodos(id),
@@ -105112,8 +105697,11 @@ class BackgroundManager {
       const sessionID = typeof props?.sessionID === "string" ? props.sessionID : undefined;
       if (!sessionID)
         return;
-      const task = this.findBySession(sessionID);
-      if (!task || task.status !== "running")
+      const resolved = this.resolveTaskAttemptBySession(sessionID);
+      if (!resolved?.isCurrent)
+        return;
+      const { task } = resolved;
+      if (task.status !== "running")
         return;
       const errorObj = props?.error;
       const errorName = errorObj?.name;
@@ -105140,9 +105728,9 @@ class BackgroundManager {
       this.clearSessionOutputObserved(sessionID);
       this.clearSessionTodoObservation(sessionID);
       const tasksToCancel = new Map;
-      const directTask = this.findBySession(sessionID);
-      if (directTask) {
-        tasksToCancel.set(directTask.id, directTask);
+      const directTask = this.resolveTaskAttemptBySession(sessionID);
+      if (directTask?.isCurrent) {
+        tasksToCancel.set(directTask.task.id, directTask.task);
       }
       for (const descendant of this.getAllDescendantTasks(sessionID)) {
         tasksToCancel.set(descendant.id, descendant);
@@ -105188,8 +105776,11 @@ class BackgroundManager {
       const status = props?.status;
       if (!sessionID || status?.type !== "retry")
         return;
-      const task = this.findBySession(sessionID);
-      if (!task || task.status !== "running")
+      const resolved = this.resolveTaskAttemptBySession(sessionID);
+      if (!resolved?.isCurrent)
+        return;
+      const { task } = resolved;
+      if (task.status !== "running")
         return;
       const errorMessage = typeof status.message === "string" ? status.message : undefined;
       const errorInfo = { name: "SessionRetry", message: errorMessage };
@@ -105203,6 +105794,12 @@ class BackgroundManager {
   }
   async handleSessionErrorEvent(args) {
     const { task, errorInfo, errorMessage, errorName } = args;
+    if (!task.fallbackChain && task.sessionID) {
+      const sessionFallbackChain = this.modelFallbackControllerAccessor?.getSessionFallbackChain(task.sessionID);
+      if (sessionFallbackChain?.length) {
+        task.fallbackChain = sessionFallbackChain;
+      }
+    }
     if (isAgentNotFoundError({ message: errorInfo.message })) {
       log("[background-agent] Skipping session.error fallback for agent-not-found (handled by prompt catch)", {
         taskId: task.id,
@@ -105222,9 +105819,13 @@ class BackgroundManager {
       hasFallbackChain: !!task.fallbackChain,
       canRetry
     });
-    task.status = "error";
-    task.error = errorMsg;
-    task.completedAt = new Date;
+    if (task.currentAttemptID) {
+      finalizeAttempt(task, task.currentAttemptID, "error", errorMsg);
+    } else {
+      task.status = "error";
+      task.error = errorMsg;
+      task.completedAt = new Date;
+    }
     if (task.rootSessionID) {
       this.unregisterRootDescendant(task.rootSessionID);
     }
@@ -105268,7 +105869,28 @@ class BackgroundManager {
       client: this.client,
       idleDeferralTimers: this.idleDeferralTimers,
       queuesByKey: this.queuesByKey,
-      processKey: (key) => this.processKey(key)
+      processKey: (key) => this.processKey(key),
+      onRetrying: ({ task: task2, source: source2 }) => {
+        const currentAttempt = getCurrentAttempt(task2);
+        const previousAttempt = getPreviousAttempt(task2, currentAttempt?.attemptID);
+        const sourceText = source2 ? ` via ${source2}` : "";
+        const failedSessionLine = previousAttempt?.sessionID ? `
+- Failed session: \`${previousAttempt.sessionID}\`` : "";
+        const failedModel = formatAttemptModelSummary(previousAttempt);
+        const failedModelLine = failedModel ? `
+- Failed model: \`${failedModel}\`` : "";
+        const failedErrorLine = previousAttempt?.error ? `
+- Error: ${previousAttempt.error}` : "";
+        const nextModel = formatAttemptModelSummary(currentAttempt);
+        this.queuePendingNotification(task2.parentSessionID, `<system-reminder>
+[BACKGROUND TASK RETRYING]
+**ID:** \`${task2.id}\`
+**Description:** ${task2.description}${sourceText}${failedSessionLine}${failedModelLine}${failedErrorLine}${nextModel ? `
+- Next model: \`${nextModel}\`` : ""}
+
+The task was re-queued on a fallback model after a retryable failure.
+</system-reminder>`);
+      }
     });
     return result.then((retried) => {
       if (retried && previousSessionID) {
@@ -105400,7 +106022,7 @@ ${originalText}`;
         }
       }
       this.clearNotificationsForTask(taskId);
-      this.tasks.delete(taskId);
+      this.removeTask(task);
       this.clearTaskHistoryWhenParentTasksGone(task.parentSessionID);
       if (task.sessionID) {
         subagentSessions.delete(task.sessionID);
@@ -105434,14 +106056,18 @@ ${originalText}`;
       log("[background-agent] Cancelled pending task:", { taskId, key });
     }
     const wasRunning = task.status === "running";
-    task.status = "cancelled";
-    task.completedAt = new Date;
+    if (task.currentAttemptID) {
+      finalizeAttempt(task, task.currentAttemptID, "cancelled", reason);
+    } else {
+      task.status = "cancelled";
+      task.completedAt = new Date;
+      if (reason) {
+        task.error = reason;
+      }
+    }
     if (wasRunning && task.rootSessionID) {
       this.unregisterRootDescendant(task.rootSessionID);
     }
-    if (reason) {
-      task.error = reason;
-    }
     this.taskHistory.record(task.parentSessionID, { id: task.id, sessionID: task.sessionID, agent: task.agent, description: task.description, status: "cancelled", category: task.category, startedAt: task.startedAt, completedAt: task.completedAt });
     if (task.concurrencyKey) {
       this.concurrencyManager.release(task.concurrencyKey);
@@ -105516,8 +106142,12 @@ ${originalText}`;
       log("[background-agent] Task already completed, skipping:", { taskId: task.id, status: task.status, source });
       return false;
     }
-    task.status = "completed";
-    task.completedAt = new Date;
+    if (task.currentAttemptID) {
+      finalizeAttempt(task, task.currentAttemptID, "completed");
+    } else {
+      task.status = "completed";
+      task.completedAt = new Date;
+    }
     this.taskHistory.record(task.parentSessionID, { id: task.id, sessionID: task.sessionID, agent: task.agent, description: task.description, status: "completed", category: task.category, startedAt: task.startedAt, completedAt: task.completedAt });
     if (task.rootSessionID) {
       this.unregisterRootDescendant(task.rootSessionID);
@@ -105563,7 +106193,8 @@ ${originalText}`;
       id: task.id,
       description: task.description,
       status: task.status,
-      error: task.error
+      error: task.error,
+      attempts: cloneAttempts(task)
     });
     const pendingSet = this.pendingByParent.get(task.parentSessionID);
     let allComplete = false;
@@ -105579,7 +106210,7 @@ ${originalText}`;
       remainingCount = Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.id !== task.id && (t.status === "running" || t.status === "pending")).length;
       allComplete = remainingCount === 0;
     }
-    const completedTasks = allComplete ? this.completedTaskSummaries.get(task.parentSessionID) ?? [{ id: task.id, description: task.description, status: task.status, error: task.error }] : [];
+    const completedTasks = allComplete ? this.completedTaskSummaries.get(task.parentSessionID) ?? [{ id: task.id, description: task.description, status: task.status, error: task.error, attempts: cloneAttempts(task) }] : [];
     if (allComplete) {
       this.completedTaskSummaries.delete(task.parentSessionID);
     }
@@ -105741,9 +106372,13 @@ ${originalText}`;
     return verifySessionExists(this.client, sessionID, this.directory);
   }
   async failCrashedTask(task, errorMessage) {
-    task.status = "error";
-    task.error = errorMessage;
-    task.completedAt = new Date;
+    if (task.currentAttemptID) {
+      finalizeAttempt(task, task.currentAttemptID, "error", errorMessage);
+    } else {
+      task.status = "error";
+      task.error = errorMessage;
+      task.completedAt = new Date;
+    }
     if (task.rootSessionID) {
       this.unregisterRootDescendant(task.rootSessionID);
     }
@@ -105911,6 +106546,7 @@ ${originalText}`;
     }
     this.concurrencyManager.clear();
     this.tasks.clear();
+    this.tasksByParentSession.clear();
     this.notifications.clear();
     this.pendingNotifications.clear();
     this.pendingByParent.clear();
@@ -111164,12 +111800,16 @@ function createModelFallbackControllerAccessor() {
   function setSessionFallbackChain2(sessionID, fallbackChain) {
     controller?.setSessionFallbackChain(sessionID, fallbackChain);
   }
+  function getSessionFallbackChain(sessionID) {
+    return controller?.getSessionFallbackChain(sessionID);
+  }
   function clearSessionFallbackChain2(sessionID) {
     controller?.clearSessionFallbackChain(sessionID);
   }
   return {
     register,
     setSessionFallbackChain: setSessionFallbackChain2,
+    getSessionFallbackChain,
     clearSessionFallbackChain: clearSessionFallbackChain2
   };
 }
@@ -114065,6 +114705,12 @@ async function loadMcpConfigs(disabledMcps = []) {
   }
   return { servers, loadedServers };
 }
+// src/agents/index.ts
+init_types();
+
+// src/agents/sisyphus.ts
+init_types();
+
 // src/agents/sisyphus/gemini.ts
 function buildGeminiToolMandate() {
   return `<TOOL_CALL_MANDATE>
@@ -115208,6 +115854,7 @@ ${antiPatterns}
 }
 
 // src/agents/gpt-apply-patch-guard.ts
+init_types();
 var GPT_APPLY_PATCH_GUIDANCE = "Use the `edit` and `write` tools for file changes. Do not use `apply_patch` on GPT models - it is unreliable here and can hang during verification.";
 function getGptApplyPatchPermission(model) {
   return isGptModel(model) ? { apply_patch: "deny" } : {};
@@ -116313,6 +116960,7 @@ ${styleBlock}`;
 }
 
 // src/agents/frontier-tool-schema-guard.ts
+init_types();
 var FRONTIER_TOOL_SCHEMA_NAMES = ["grep", "glob"];
 function isOpus47Model(model) {
   const modelName = model.includes("/") ? model.split("/").pop() ?? model : model;
@@ -116864,6 +117512,7 @@ ${buildGeminiVerificationOverride()}
 createSisyphusAgent.mode = MODE;
 
 // src/agents/oracle.ts
+init_types();
 var MODE2 = "subagent";
 var ORACLE_PROMPT_METADATA = {
   category: "advisor",
@@ -118077,6 +118726,9 @@ var metisPromptMetadata = {
   keyTrigger: "Ambiguous or complex request \u2192 consult Metis before Prometheus"
 };
 
+// src/agents/atlas/agent.ts
+init_types();
+
 // src/agents/atlas/shared-prompt.ts
 var ATLAS_DELEGATION_SYSTEM = `<delegation_system>
 ## How to Delegate
@@ -119303,6 +119955,7 @@ var atlasPromptMetadata = {
   keyTrigger: "Todo list path provided OR multiple tasks requiring multi-agent orchestration"
 };
 // src/agents/momus.ts
+init_types();
 var MODE8 = "subagent";
 var MOMUS_DEFAULT_PROMPT = `You are a **practical** work plan reviewer. Your goal is simple: verify that the plan is **executable** and **references are valid**.
 
@@ -119607,6 +120260,9 @@ var momusPromptMetadata = {
   keyTrigger: 'Work plan saved to `.sisyphus/plans/*.md` \u2192 invoke Momus with the file path as the sole prompt (e.g. `prompt=".sisyphus/plans/my-plan.md"`). Do NOT invoke Momus for inline plans or todo lists.'
 };
 
+// src/agents/hephaestus/agent.ts
+init_types();
+
 // src/agents/hephaestus/gpt.ts
 function buildTodoDisciplineSection(useTaskSystem) {
   if (useTaskSystem) {
@@ -122104,6 +122760,7 @@ No tasks on multi-step work = INCOMPLETE WORK. The user tracks your progress thr
 No todos on multi-step work = INCOMPLETE WORK. The user tracks your progress through todos.`;
 }
 // src/agents/sisyphus-junior/agent.ts
+init_types();
 var MODE11 = "subagent";
 var BLOCKED_TOOLS3 = ["task"];
 var GPT_BLOCKED_TOOLS = ["task", "apply_patch"];
@@ -124906,6 +125563,7 @@ function getGeminiPrometheusPrompt() {
 }
 
 // src/agents/prometheus/system-prompt.ts
+init_types();
 var PROMETHEUS_SYSTEM_PROMPT = `${PROMETHEUS_IDENTITY_CONSTRAINTS}
 ${PROMETHEUS_INTERVIEW_MODE}
 ${PROMETHEUS_PLAN_GENERATION}
@@ -125801,6 +126459,7 @@ function createManagers(args) {
     deps.markServerRunningInProcessFn();
   }
   const tmuxSessionManager = new deps.TmuxSessionManagerClass(ctx, tmuxConfig);
+  const modelFallbackControllerAccessor = createModelFallbackControllerAccessor();
   deps.registerManagerForCleanupFn({
     shutdown: async () => {
       await tmuxSessionManager.cleanup().catch((error) => {
@@ -125844,7 +126503,8 @@ function createManagers(args) {
         log("[create-managers] tmux cleanup error during shutdown:", error);
       });
     },
-    enableParentSessionNotifications: backgroundNotificationHookEnabled
+    enableParentSessionNotifications: backgroundNotificationHookEnabled,
+    modelFallbackControllerAccessor
   });
   deps.initTaskToastManagerFn(ctx.client);
   const skillMcpManager = new deps.SkillMcpManagerClass;
@@ -125853,7 +126513,6 @@ function createManagers(args) {
     pluginConfig,
     modelCacheState
   });
-  const modelFallbackControllerAccessor = createModelFallbackControllerAccessor();
   return {
     tmuxSessionManager,
     backgroundManager,
@@ -126994,15 +127653,13 @@ function extractErrorMessage3(error) {
     return "";
   if (typeof error === "string")
     return error;
-  if (error instanceof Error)
-    return error.message;
   if (isRecord19(error)) {
     const candidates = [
-      error,
       error.data,
-      error.error,
       isRecord19(error.data) ? error.data.error : undefined,
-      error.cause
+      error.error,
+      error.cause,
+      error
     ];
     for (const candidate of candidates) {
       if (isRecord19(candidate) && typeof candidate.message === "string" && candidate.message.length > 0) {
@@ -127010,6 +127667,8 @@ function extractErrorMessage3(error) {
       }
     }
   }
+  if (error instanceof Error)
+    return error.message;
   try {
     return JSON.stringify(error);
   } catch {
@@ -127299,6 +127958,9 @@ function createEventHandler2(args) {
       const sessionID = info?.sessionID;
       const agent = info?.agent;
       const role = info?.role;
+      if (sessionID && info?.finish === true) {
+        invalidateContextWindowUsageCache(pluginContext, sessionID);
+      }
       if (sessionID && role === "user") {
         const isCompactionMessage2 = agent ? isCompactionAgent5(agent) : false;
         if (agent && !isCompactionMessage2) {
@@ -132595,7 +133257,7 @@ class PostHog extends PostHogBackendClient {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.17.6",
+  version: "3.17.8",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -132675,17 +133337,17 @@ var package_default = {
     zod: "^4.3.0"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.17.6",
-    "oh-my-opencode-darwin-x64": "3.17.6",
-    "oh-my-opencode-darwin-x64-baseline": "3.17.6",
-    "oh-my-opencode-linux-arm64": "3.17.6",
-    "oh-my-opencode-linux-arm64-musl": "3.17.6",
-    "oh-my-opencode-linux-x64": "3.17.6",
-    "oh-my-opencode-linux-x64-baseline": "3.17.6",
-    "oh-my-opencode-linux-x64-musl": "3.17.6",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.17.6",
-    "oh-my-opencode-windows-x64": "3.17.6",
-    "oh-my-opencode-windows-x64-baseline": "3.17.6"
+    "oh-my-opencode-darwin-arm64": "3.17.8",
+    "oh-my-opencode-darwin-x64": "3.17.8",
+    "oh-my-opencode-darwin-x64-baseline": "3.17.8",
+    "oh-my-opencode-linux-arm64": "3.17.8",
+    "oh-my-opencode-linux-arm64-musl": "3.17.8",
+    "oh-my-opencode-linux-x64": "3.17.8",
+    "oh-my-opencode-linux-x64-baseline": "3.17.8",
+    "oh-my-opencode-linux-x64-musl": "3.17.8",
+    "oh-my-opencode-linux-x64-musl-baseline": "3.17.8",
+    "oh-my-opencode-windows-x64": "3.17.8",
+    "oh-my-opencode-windows-x64-baseline": "3.17.8"
   },
   overrides: {},
   trustedDependencies: [