oh-my-opencode 3.8.0 → 3.8.1

package/dist/index.js

@@ -56624,6 +56624,7 @@ async function handleUpdate(args, config3, ctx, context) {
   }
 }
 // src/tools/hashline-edit/validation.ts
+var MISMATCH_CONTEXT = 2;
 var LINE_REF_EXTRACT_PATTERN = /([0-9]+#[ZPMQVRWSNKTXJBYH]{2}|[0-9]+:[0-9a-fA-F]{2,})/;
 function normalizeLineRef(ref) {
   const trimmed = ref.trim();
@@ -56665,7 +56666,58 @@ function validateLineRef(lines, ref) {
   const content = lines[line - 1];
   const currentHash = computeLineHash(line, content);
   if (currentHash !== hash2) {
-    throw new Error(`Hash mismatch at line ${line}. Expected hash: ${hash2}, current hash: ${currentHash}. ` + `Line content may have changed. Current content: "${content}"`);
+    throw new HashlineMismatchError([{ line, expected: hash2 }], lines);
+  }
+}
+
+class HashlineMismatchError extends Error {
+  mismatches;
+  fileLines;
+  remaps;
+  constructor(mismatches, fileLines) {
+    super(HashlineMismatchError.formatMessage(mismatches, fileLines));
+    this.mismatches = mismatches;
+    this.fileLines = fileLines;
+    this.name = "HashlineMismatchError";
+    const remaps = new Map;
+    for (const mismatch of mismatches) {
+      const actual = computeLineHash(mismatch.line, fileLines[mismatch.line - 1] ?? "");
+      remaps.set(`${mismatch.line}#${mismatch.expected}`, `${mismatch.line}#${actual}`);
+    }
+    this.remaps = remaps;
+  }
+  static formatMessage(mismatches, fileLines) {
+    const mismatchByLine = new Map;
+    for (const mismatch of mismatches)
+      mismatchByLine.set(mismatch.line, mismatch);
+    const displayLines = new Set;
+    for (const mismatch of mismatches) {
+      const low = Math.max(1, mismatch.line - MISMATCH_CONTEXT);
+      const high = Math.min(fileLines.length, mismatch.line + MISMATCH_CONTEXT);
+      for (let line = low;line <= high; line++)
+        displayLines.add(line);
+    }
+    const sortedLines = [...displayLines].sort((a, b) => a - b);
+    const output = [];
+    output.push(`${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since last read. ` + "Use updated LINE#ID references below (>>> marks changed lines).");
+    output.push("");
+    let previousLine = -1;
+    for (const line of sortedLines) {
+      if (previousLine !== -1 && line > previousLine + 1) {
+        output.push("    ...");
+      }
+      previousLine = line;
+      const content = fileLines[line - 1] ?? "";
+      const hash2 = computeLineHash(line, content);
+      const prefix = `${line}#${hash2}:${content}`;
+      if (mismatchByLine.has(line)) {
+        output.push(`>>> ${prefix}`);
+      } else {
+        output.push(`    ${prefix}`);
+      }
+    }
+    return output.join(`
+`);
   }
 }
 function validateLineRefs(lines, refs) {
@@ -56673,24 +56725,30 @@ function validateLineRefs(lines, refs) {
   for (const ref of refs) {
     const { line, hash: hash2 } = parseLineRef(ref);
     if (line < 1 || line > lines.length) {
-      mismatches.push(`Line number ${line} out of bounds (file has ${lines.length} lines)`);
-      continue;
+      throw new Error(`Line number ${line} out of bounds (file has ${lines.length} lines)`);
     }
     const content = lines[line - 1];
     const currentHash = computeLineHash(line, content);
     if (currentHash !== hash2) {
-      mismatches.push(`line ${line}: expected ${hash2}, current ${currentHash} (${line}#${currentHash}) content: "${content}"`);
+      mismatches.push({ line, expected: hash2 });
     }
   }
   if (mismatches.length > 0) {
-    throw new Error(`Hash mismatches:
-- ${mismatches.join(`
-- `)}`);
+    throw new HashlineMismatchError(mismatches, lines);
   }
 }
-// src/tools/hashline-edit/edit-operations.ts
+// src/tools/hashline-edit/edit-text-normalization.ts
 var HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*\d+#[A-Z]{2}:/;
 var DIFF_PLUS_RE = /^[+-](?![+-])/;
+function equalsIgnoringWhitespace(a, b) {
+  if (a === b)
+    return true;
+  return a.replace(/\s+/g, "") === b.replace(/\s+/g, "");
+}
+function leadingWhitespace(text) {
+  const match = text.match(/^\s*/);
+  return match ? match[0] : "";
+}
 function stripLinePrefixes(lines) {
   let hashPrefixCount = 0;
   let diffPlusCount = 0;
@@ -56720,14 +56778,12 @@ function stripLinePrefixes(lines) {
     return line;
   });
 }
-function equalsIgnoringWhitespace(a, b) {
-  if (a === b)
-    return true;
-  return a.replace(/\s+/g, "") === b.replace(/\s+/g, "");
-}
-function leadingWhitespace(text) {
-  const match = text.match(/^\s*/);
-  return match ? match[0] : "";
+function toNewLines(input) {
+  if (Array.isArray(input)) {
+    return stripLinePrefixes(input);
+  }
+  return stripLinePrefixes(input.split(`
+`));
 }
 function restoreLeadingIndent(templateLine, line) {
   if (line.length === 0)
@@ -56740,13 +56796,31 @@ function restoreLeadingIndent(templateLine, line) {
   return `${templateIndent}${line}`;
 }
 function stripInsertAnchorEcho(anchorLine, newLines) {
-  if (newLines.length <= 1)
+  if (newLines.length === 0)
     return newLines;
   if (equalsIgnoringWhitespace(newLines[0], anchorLine)) {
     return newLines.slice(1);
   }
   return newLines;
 }
+function stripInsertBeforeEcho(anchorLine, newLines) {
+  if (newLines.length <= 1)
+    return newLines;
+  if (equalsIgnoringWhitespace(newLines[newLines.length - 1], anchorLine)) {
+    return newLines.slice(0, -1);
+  }
+  return newLines;
+}
+function stripInsertBoundaryEcho(afterLine, beforeLine, newLines) {
+  let out = newLines;
+  if (out.length > 0 && equalsIgnoringWhitespace(out[0], afterLine)) {
+    out = out.slice(1);
+  }
+  if (out.length > 0 && equalsIgnoringWhitespace(out[out.length - 1], beforeLine)) {
+    out = out.slice(0, -1);
+  }
+  return out;
+}
 function stripRangeBoundaryEcho(lines, startLine, endLine, newLines) {
   const replacedCount = endLine - startLine + 1;
   if (newLines.length <= 1 || newLines.length <= replacedCount) {
@@ -56763,13 +56837,8 @@ function stripRangeBoundaryEcho(lines, startLine, endLine, newLines) {
   }
   return out;
 }
-function toNewLines(input) {
-  if (Array.isArray(input)) {
-    return stripLinePrefixes(input);
-  }
-  return stripLinePrefixes(input.split(`
-`));
-}
+
+// src/tools/hashline-edit/edit-operations.ts
 function applySetLine(lines, anchor, newText) {
   validateLineRef(lines, anchor);
   const { line } = parseLineRef(anchor);
@@ -56805,9 +56874,39 @@ function applyInsertAfter(lines, anchor, text) {
   const { line } = parseLineRef(anchor);
   const result = [...lines];
   const newLines = stripInsertAnchorEcho(lines[line - 1], toNewLines(text));
+  if (newLines.length === 0) {
+    throw new Error(`insert_after requires non-empty text for ${anchor}`);
+  }
   result.splice(line, 0, ...newLines);
   return result;
 }
+function applyInsertBefore(lines, anchor, text) {
+  validateLineRef(lines, anchor);
+  const { line } = parseLineRef(anchor);
+  const result = [...lines];
+  const newLines = stripInsertBeforeEcho(lines[line - 1], toNewLines(text));
+  if (newLines.length === 0) {
+    throw new Error(`insert_before requires non-empty text for ${anchor}`);
+  }
+  result.splice(line - 1, 0, ...newLines);
+  return result;
+}
+function applyInsertBetween(lines, afterAnchor, beforeAnchor, text) {
+  validateLineRef(lines, afterAnchor);
+  validateLineRef(lines, beforeAnchor);
+  const { line: afterLine } = parseLineRef(afterAnchor);
+  const { line: beforeLine } = parseLineRef(beforeAnchor);
+  if (beforeLine <= afterLine) {
+    throw new Error(`insert_between requires after_line (${afterLine}) < before_line (${beforeLine})`);
+  }
+  const result = [...lines];
+  const newLines = stripInsertBoundaryEcho(lines[afterLine - 1], lines[beforeLine - 1], toNewLines(text));
+  if (newLines.length === 0) {
+    throw new Error(`insert_between requires non-empty text for ${afterAnchor}..${beforeAnchor}`);
+  }
+  result.splice(beforeLine - 1, 0, ...newLines);
+  return result;
+}
 function getEditLineNumber(edit) {
   switch (edit.type) {
     case "set_line":
@@ -56816,17 +56915,61 @@ function getEditLineNumber(edit) {
       return parseLineRef(edit.end_line).line;
     case "insert_after":
       return parseLineRef(edit.line).line;
+    case "insert_before":
+      return parseLineRef(edit.line).line;
+    case "insert_between":
+      return parseLineRef(edit.before_line).line;
     case "replace":
       return Number.NEGATIVE_INFINITY;
     default:
       return Number.POSITIVE_INFINITY;
   }
 }
-function applyHashlineEdits(content, edits) {
+function normalizeEditPayload(payload) {
+  return toNewLines(payload).join(`
+`);
+}
+function dedupeEdits(edits) {
+  const seen = new Set;
+  const deduped = [];
+  let deduplicatedEdits = 0;
+  for (const edit of edits) {
+    const key = (() => {
+      switch (edit.type) {
+        case "set_line":
+          return `set_line|${edit.line}|${normalizeEditPayload(edit.text)}`;
+        case "replace_lines":
+          return `replace_lines|${edit.start_line}|${edit.end_line}|${normalizeEditPayload(edit.text)}`;
+        case "insert_after":
+          return `insert_after|${edit.line}|${normalizeEditPayload(edit.text)}`;
+        case "insert_before":
+          return `insert_before|${edit.line}|${normalizeEditPayload(edit.text)}`;
+        case "insert_between":
+          return `insert_between|${edit.after_line}|${edit.before_line}|${normalizeEditPayload(edit.text)}`;
+        case "replace":
+          return `replace|${edit.old_text}|${normalizeEditPayload(edit.new_text)}`;
+      }
+    })();
+    if (seen.has(key)) {
+      deduplicatedEdits += 1;
+      continue;
+    }
+    seen.add(key);
+    deduped.push(edit);
+  }
+  return { edits: deduped, deduplicatedEdits };
+}
+function applyHashlineEditsWithReport(content, edits) {
   if (edits.length === 0) {
-    return content;
+    return {
+      content,
+      noopEdits: 0,
+      deduplicatedEdits: 0
+    };
   }
-  const sortedEdits = [...edits].sort((a, b) => getEditLineNumber(b) - getEditLineNumber(a));
+  const dedupeResult = dedupeEdits(edits);
+  const sortedEdits = [...dedupeResult.edits].sort((a, b) => getEditLineNumber(b) - getEditLineNumber(a));
+  let noopEdits = 0;
   let result = content;
   let lines = result.split(`
 `);
@@ -56838,6 +56981,10 @@ function applyHashlineEdits(content, edits) {
         return [edit.start_line, edit.end_line];
       case "insert_after":
         return [edit.line];
+      case "insert_before":
+        return [edit.line];
+      case "insert_between":
+        return [edit.after_line, edit.before_line];
       case "replace":
         return [];
       default:
@@ -56856,7 +57003,36 @@ function applyHashlineEdits(content, edits) {
         break;
       }
       case "insert_after": {
-        lines = applyInsertAfter(lines, edit.line, edit.text);
+        const next = applyInsertAfter(lines, edit.line, edit.text);
+        if (next.join(`
+`) === lines.join(`
+`)) {
+          noopEdits += 1;
+          break;
+        }
+        lines = next;
+        break;
+      }
+      case "insert_before": {
+        const next = applyInsertBefore(lines, edit.line, edit.text);
+        if (next.join(`
+`) === lines.join(`
+`)) {
+          noopEdits += 1;
+          break;
+        }
+        lines = next;
+        break;
+      }
+      case "insert_between": {
+        const next = applyInsertBetween(lines, edit.after_line, edit.before_line, edit.text);
+        if (next.join(`
+`) === lines.join(`
+`)) {
+          noopEdits += 1;
+          break;
+        }
+        lines = next;
         break;
       }
       case "replace": {
@@ -56867,16 +57043,61 @@ function applyHashlineEdits(content, edits) {
         }
         const replacement = Array.isArray(edit.new_text) ? edit.new_text.join(`
 `) : edit.new_text;
-        result = result.replaceAll(edit.old_text, replacement);
+        const replaced = result.replaceAll(edit.old_text, replacement);
+        if (replaced === result) {
+          noopEdits += 1;
+          break;
+        }
+        result = replaced;
         lines = result.split(`
 `);
         break;
       }
     }
   }
-  return lines.join(`
-`);
+  return {
+    content: lines.join(`
+`),
+    noopEdits,
+    deduplicatedEdits: dedupeResult.deduplicatedEdits
+  };
 }
+// src/tools/hashline-edit/tool-description.ts
+var HASHLINE_EDIT_DESCRIPTION = `Edit files using LINE#ID format for precise, safe modifications.
+
+WORKFLOW:
+1. Read the file and copy exact LINE#ID anchors.
+2. Submit one edit call with all related operations for that file.
+3. If more edits are needed after success, use the latest anchors from read/edit output.
+4. Use anchors as "LINE#ID" only (never include trailing ":content").
+
+VALIDATION:
+- Payload shape: { "filePath": string, "edits": [...], "delete"?: boolean, "rename"?: string }
+- Each edit must be one of: set_line, replace_lines, insert_after, insert_before, insert_between, replace
+- text/new_text must contain plain replacement text only (no LINE#ID prefixes, no diff + markers)
+
+LINE#ID FORMAT (CRITICAL - READ CAREFULLY):
+Each line reference must be in "LINE#ID" format where:
+- LINE: 1-based line number
+- ID: Two CID letters from the set ZPMQVRWSNKTXJBYH
+
+OPERATION TYPES:
+1. set_line
+2. replace_lines
+3. insert_after
+4. insert_before
+5. insert_between
+6. replace
+
+FILE MODES:
+- delete=true deletes file and requires edits=[] with no rename
+- rename moves final content to a new path and removes old path
+
+CONTENT FORMAT:
+- text/new_text can be a string (single line) or string[] (multi-line, preferred).
+- If you pass a multi-line string, it is split by real newline characters.
+- Literal "\\n" is preserved as text.`;
+
 // src/tools/hashline-edit/tools.ts
 function resolveToolCallID2(ctx) {
   if (typeof ctx.callID === "string" && ctx.callID.trim() !== "")
@@ -56918,62 +57139,11 @@ function generateDiff(oldContent, newContent, filePath) {
 }
 function createHashlineEditTool() {
   return tool({
-    description: `Edit files using LINE#ID format for precise, safe modifications.
-
-WORKFLOW:
-1. Read the file and copy exact LINE#ID anchors.
-2. Submit one edit call with all related operations for that file.
-3. If more edits are needed after success, use the latest anchors from read/edit output.
-4. Use anchors as "LINE#ID" only (never include trailing ":content").
-
-VALIDATION:
-- Payload shape: { "filePath": string, "edits": [...] }
-- Each edit must be one of: set_line, replace_lines, insert_after, replace
-- text/new_text must contain plain replacement text only (no LINE#ID prefixes, no diff + markers)
-
-LINE#ID FORMAT (CRITICAL - READ CAREFULLY):
-Each line reference must be in "LINE#ID" format where:
-- LINE: 1-based line number
-- ID: Two CID letters from the set ZPMQVRWSNKTXJBYH
-- Example: "5#VK" means line 5 with hash id "VK"
-- WRONG: "2#aa" (invalid characters) - will fail!
-- CORRECT: "2#VK"
-
-GETTING HASHES:
-Use the read tool - it returns lines in "LINE#ID:content" format.
-Successful edit output also includes updated file content in "LINE#ID:content" format.
-
-FOUR OPERATION TYPES:
-
-1. set_line: Replace a single line
-   { "type": "set_line", "line": "5#VK", "text": "const y = 2" }
-
-2. replace_lines: Replace a range of lines
-   { "type": "replace_lines", "start_line": "5#VK", "end_line": "7#NP", "text": ["new", "content"] }
-
-3. insert_after: Insert lines after a specific line
-   { "type": "insert_after", "line": "5#VK", "text": "console.log('hi')" }
-
-4. replace: Simple text replacement (no hash validation)
-   { "type": "replace", "old_text": "foo", "new_text": "bar" }
-
-HASH MISMATCH HANDLING:
-If the hash doesn't match the current content, the edit fails with a hash mismatch error. This prevents editing stale content.
-
-SEQUENTIAL EDITS (ANTI-FLAKE):
-- Always copy anchors exactly from the latest read/edit output.
-- Never infer or guess hashes.
-- For related edits, prefer batching them in one call.
-
-BOTTOM-UP APPLICATION:
-Edits are applied from bottom to top (highest line numbers first) to preserve line number references.
-
-CONTENT FORMAT:
-- text/new_text can be a string (single line) or string[] (multi-line, preferred).
-- If you pass a multi-line string, it is split by real newline characters.
-- Literal "\\n" is preserved as text.`,
+    description: HASHLINE_EDIT_DESCRIPTION,
     args: {
       filePath: tool.schema.string().describe("Absolute path to the file to edit"),
+      delete: tool.schema.boolean().optional().describe("Delete file instead of editing"),
+      rename: tool.schema.string().optional().describe("Rename output file path after edits"),
       edits: tool.schema.array(tool.schema.union([
         tool.schema.object({
           type: tool.schema.literal("set_line"),
@@ -56991,44 +57161,73 @@ CONTENT FORMAT:
           line: tool.schema.string().describe("Line reference in LINE#ID format"),
           text: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string())]).describe("Content to insert after the line (string or string[] for multiline)")
         }),
+        tool.schema.object({
+          type: tool.schema.literal("insert_before"),
+          line: tool.schema.string().describe("Line reference in LINE#ID format"),
+          text: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string())]).describe("Content to insert before the line (string or string[] for multiline)")
+        }),
+        tool.schema.object({
+          type: tool.schema.literal("insert_between"),
+          after_line: tool.schema.string().describe("After line in LINE#ID format"),
+          before_line: tool.schema.string().describe("Before line in LINE#ID format"),
+          text: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string())]).describe("Content to insert between anchor lines (string or string[] for multiline)")
+        }),
         tool.schema.object({
           type: tool.schema.literal("replace"),
           old_text: tool.schema.string().describe("Text to find"),
           new_text: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string())]).describe("Replacement text (string or string[] for multiline)")
         })
-      ])).describe("Array of edit operations to apply")
+      ])).describe("Array of edit operations to apply (empty when delete=true)")
     },
     execute: async (args, context) => {
       try {
         const metadataContext = context;
         const filePath = args.filePath;
-        const { edits } = args;
-        if (!edits || !Array.isArray(edits) || edits.length === 0) {
+        const { edits, delete: deleteMode, rename } = args;
+        if (deleteMode && rename) {
+          return "Error: delete and rename cannot be used together";
+        }
+        if (!deleteMode && (!edits || !Array.isArray(edits) || edits.length === 0)) {
           return "Error: edits parameter must be a non-empty array";
         }
+        if (deleteMode && edits.length > 0) {
+          return "Error: delete mode requires edits to be an empty array";
+        }
         const file2 = Bun.file(filePath);
         const exists = await file2.exists();
         if (!exists) {
           return `Error: File not found: ${filePath}`;
         }
+        if (deleteMode) {
+          await Bun.file(filePath).delete();
+          return `Successfully deleted ${filePath}`;
+        }
         const oldContent = await file2.text();
-        const newContent = applyHashlineEdits(oldContent, edits);
+        const applyResult = applyHashlineEditsWithReport(oldContent, edits);
+        const newContent = applyResult.content;
         await Bun.write(filePath, newContent);
-        const diff = generateDiff(oldContent, newContent, filePath);
+        if (rename && rename !== filePath) {
+          await Bun.write(rename, newContent);
+          await Bun.file(filePath).delete();
+        }
+        const effectivePath = rename && rename !== filePath ? rename : filePath;
+        const diff = generateDiff(oldContent, newContent, effectivePath);
         const newHashlined = toHashlineContent(newContent);
-        const unifiedDiff = generateUnifiedDiff(oldContent, newContent, filePath);
+        const unifiedDiff = generateUnifiedDiff(oldContent, newContent, effectivePath);
         const { additions, deletions } = countLineDiffs(oldContent, newContent);
         const meta = {
-          title: filePath,
+          title: effectivePath,
           metadata: {
-            filePath,
-            path: filePath,
-            file: filePath,
+            filePath: effectivePath,
+            path: effectivePath,
+            file: effectivePath,
             diff: unifiedDiff,
+            noopEdits: applyResult.noopEdits,
+            deduplicatedEdits: applyResult.deduplicatedEdits,
             filediff: {
-              file: filePath,
-              path: filePath,
-              filePath,
+              file: effectivePath,
+              path: effectivePath,
+              filePath: effectivePath,
               before: oldContent,
               after: newContent,
               additions,
@@ -57043,7 +57242,8 @@ CONTENT FORMAT:
         if (callID) {
           storeToolMetadata(context.sessionID, callID, meta);
         }
-        return `Successfully applied ${edits.length} edit(s) to ${filePath}
+        return `Successfully applied ${edits.length} edit(s) to ${effectivePath}
+No-op edits: ${applyResult.noopEdits}, deduplicated edits: ${applyResult.deduplicatedEdits}
 
 ${diff}
 
@@ -57690,56 +57890,430 @@ class ConcurrencyManager {
         return;
       }
     }
-    const current = this.counts.get(model) ?? 0;
-    if (current > 0) {
-      this.counts.set(model, current - 1);
-    }
-  }
-  cancelWaiters(model) {
-    const queue = this.queues.get(model);
-    if (queue) {
-      for (const entry of queue) {
-        if (!entry.settled) {
-          entry.settled = true;
-          entry.rawReject(new Error(`Concurrency queue cancelled for model: ${model}`));
-        }
-      }
-      this.queues.delete(model);
+    const current = this.counts.get(model) ?? 0;
+    if (current > 0) {
+      this.counts.set(model, current - 1);
+    }
+  }
+  cancelWaiters(model) {
+    const queue = this.queues.get(model);
+    if (queue) {
+      for (const entry of queue) {
+        if (!entry.settled) {
+          entry.settled = true;
+          entry.rawReject(new Error(`Concurrency queue cancelled for model: ${model}`));
+        }
+      }
+      this.queues.delete(model);
+    }
+  }
+  clear() {
+    for (const [model] of this.queues) {
+      this.cancelWaiters(model);
+    }
+    this.counts.clear();
+    this.queues.clear();
+  }
+  getCount(model) {
+    return this.counts.get(model) ?? 0;
+  }
+  getQueueLength(model) {
+    return this.queues.get(model)?.length ?? 0;
+  }
+}
+
+// src/features/background-agent/constants.ts
+var TASK_TTL_MS = 30 * 60 * 1000;
+var MIN_STABILITY_TIME_MS2 = 10 * 1000;
+var DEFAULT_STALE_TIMEOUT_MS = 180000;
+var DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600000;
+var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
+var MIN_IDLE_TIME_MS = 5000;
+var POLLING_INTERVAL_MS = 3000;
+var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
+
+// src/features/background-agent/duration-formatter.ts
+function formatDuration3(start, end) {
+  const duration3 = (end ?? new Date).getTime() - start.getTime();
+  const seconds = Math.floor(duration3 / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+// src/features/background-agent/error-classifier.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function isAbortedSessionError(error45) {
+  const message = getErrorText(error45);
+  return message.toLowerCase().includes("aborted");
+}
+function getErrorText(error45) {
+  if (!error45)
+    return "";
+  if (typeof error45 === "string")
+    return error45;
+  if (error45 instanceof Error) {
+    return `${error45.name}: ${error45.message}`;
+  }
+  if (typeof error45 === "object" && error45 !== null) {
+    if ("message" in error45 && typeof error45.message === "string") {
+      return error45.message;
+    }
+    if ("name" in error45 && typeof error45.name === "string") {
+      return error45.name;
+    }
+  }
+  return "";
+}
+function extractErrorName2(error45) {
+  if (isRecord4(error45) && typeof error45["name"] === "string")
+    return error45["name"];
+  if (error45 instanceof Error)
+    return error45.name;
+  return;
+}
+function extractErrorMessage(error45) {
+  if (!error45)
+    return;
+  if (typeof error45 === "string")
+    return error45;
+  if (error45 instanceof Error)
+    return error45.message;
+  if (isRecord4(error45)) {
+    const dataRaw = error45["data"];
+    const candidates = [
+      error45,
+      dataRaw,
+      error45["error"],
+      isRecord4(dataRaw) ? dataRaw["error"] : undefined,
+      error45["cause"]
+    ];
+    for (const candidate of candidates) {
+      if (typeof candidate === "string" && candidate.length > 0)
+        return candidate;
+      if (isRecord4(candidate) && typeof candidate["message"] === "string" && candidate["message"].length > 0) {
+        return candidate["message"];
+      }
+    }
+  }
+  try {
+    return JSON.stringify(error45);
+  } catch {
+    return String(error45);
+  }
+}
+function getSessionErrorMessage(properties) {
+  const errorRaw = properties["error"];
+  if (!isRecord4(errorRaw))
+    return;
+  const dataRaw = errorRaw["data"];
+  if (isRecord4(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/fallback-retry-handler.ts
+function tryFallbackRetry(args) {
+  const { task, errorInfo, source, concurrencyManager, client: client2, idleDeferralTimers, queuesByKey, processKey } = args;
+  const fallbackChain = task.fallbackChain;
+  const canRetry = shouldRetryError(errorInfo) && fallbackChain && fallbackChain.length > 0 && hasMoreFallbacks(fallbackChain, task.attemptCount ?? 0);
+  if (!canRetry)
+    return false;
+  const attemptCount = task.attemptCount ?? 0;
+  const providerModelsCache = readProviderModelsCache();
+  const connectedProviders = providerModelsCache?.connected ?? readConnectedProvidersCache();
+  const connectedSet = connectedProviders ? new Set(connectedProviders.map((p) => p.toLowerCase())) : null;
+  const isReachable = (entry) => {
+    if (!connectedSet)
+      return true;
+    return entry.providers.some((p) => connectedSet.has(p.toLowerCase()));
+  };
+  let selectedAttemptCount = attemptCount;
+  let nextFallback;
+  while (fallbackChain && selectedAttemptCount < fallbackChain.length) {
+    const candidate = getNextFallback(fallbackChain, selectedAttemptCount);
+    if (!candidate)
+      break;
+    selectedAttemptCount++;
+    if (!isReachable(candidate)) {
+      log("[background-agent] Skipping unreachable fallback:", {
+        taskId: task.id,
+        source,
+        model: candidate.model,
+        providers: candidate.providers
+      });
+      continue;
+    }
+    nextFallback = candidate;
+    break;
+  }
+  if (!nextFallback)
+    return false;
+  const providerID = selectFallbackProvider(nextFallback.providers, task.model?.providerID);
+  log("[background-agent] Retryable error, attempting fallback:", {
+    taskId: task.id,
+    source,
+    errorName: errorInfo.name,
+    errorMessage: errorInfo.message?.slice(0, 100),
+    attemptCount: selectedAttemptCount,
+    nextModel: `${providerID}/${nextFallback.model}`
+  });
+  if (task.concurrencyKey) {
+    concurrencyManager.release(task.concurrencyKey);
+    task.concurrencyKey = undefined;
+  }
+  if (task.sessionID) {
+    client2.session.abort({ path: { id: task.sessionID } }).catch(() => {});
+  }
+  const idleTimer = idleDeferralTimers.get(task.id);
+  if (idleTimer) {
+    clearTimeout(idleTimer);
+    idleDeferralTimers.delete(task.id);
+  }
+  task.attemptCount = selectedAttemptCount;
+  const transformedModelId = transformModelForProvider(providerID, nextFallback.model);
+  task.model = {
+    providerID,
+    modelID: transformedModelId,
+    variant: nextFallback.variant
+  };
+  task.status = "pending";
+  task.sessionID = undefined;
+  task.startedAt = undefined;
+  task.queuedAt = new Date;
+  task.error = undefined;
+  const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
+  const queue = queuesByKey.get(key) ?? [];
+  const retryInput = {
+    description: task.description,
+    prompt: task.prompt,
+    agent: task.agent,
+    parentSessionID: task.parentSessionID,
+    parentMessageID: task.parentMessageID,
+    parentModel: task.parentModel,
+    parentAgent: task.parentAgent,
+    parentTools: task.parentTools,
+    model: task.model,
+    fallbackChain: task.fallbackChain,
+    category: task.category,
+    isUnstableAgent: task.isUnstableAgent
+  };
+  queue.push({ task, input: retryInput });
+  queuesByKey.set(key, queue);
+  processKey(key);
+  return true;
+}
+
+// src/features/background-agent/process-cleanup.ts
+function registerProcessSignal(signal, handler, exitAfter) {
+  const listener = () => {
+    handler();
+    if (exitAfter) {
+      process.exitCode = 0;
+      setTimeout(() => process.exit(), 6000).unref();
+    }
+  };
+  process.on(signal, listener);
+  return listener;
+}
+var cleanupManagers = new Set;
+var cleanupRegistered = false;
+var cleanupHandlers = new Map;
+function registerManagerForCleanup(manager) {
+  cleanupManagers.add(manager);
+  if (cleanupRegistered)
+    return;
+  cleanupRegistered = true;
+  const cleanupAll = () => {
+    for (const m of cleanupManagers) {
+      try {
+        m.shutdown();
+      } catch (error45) {
+        log("[background-agent] Error during shutdown cleanup:", error45);
+      }
+    }
+  };
+  const registerSignal = (signal, exitAfter) => {
+    const listener = registerProcessSignal(signal, cleanupAll, exitAfter);
+    cleanupHandlers.set(signal, listener);
+  };
+  registerSignal("SIGINT", true);
+  registerSignal("SIGTERM", true);
+  if (process.platform === "win32") {
+    registerSignal("SIGBREAK", true);
+  }
+  registerSignal("beforeExit", false);
+  registerSignal("exit", false);
+}
+function unregisterManagerForCleanup(manager) {
+  cleanupManagers.delete(manager);
+  if (cleanupManagers.size > 0)
+    return;
+  for (const [signal, listener] of cleanupHandlers.entries()) {
+    process.off(signal, listener);
+  }
+  cleanupHandlers.clear();
+  cleanupRegistered = false;
+}
+
+// src/features/background-agent/compaction-aware-message-resolver.ts
+import { readdirSync as readdirSync18, readFileSync as readFileSync42 } from "fs";
+import { join as join74 } from "path";
+function isCompactionAgent(agent) {
+  return agent?.trim().toLowerCase() === "compaction";
+}
+function hasFullAgentAndModel(message) {
+  return !!message.agent && !isCompactionAgent(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
+}
+function hasPartialAgentOrModel(message) {
+  const hasAgent = !!message.agent && !isCompactionAgent(message.agent);
+  const hasModel = !!message.model?.providerID && !!message.model?.modelID;
+  return hasAgent || hasModel;
+}
+function findNearestMessageExcludingCompaction(messageDir) {
+  try {
+    const files = readdirSync18(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
+    for (const file2 of files) {
+      try {
+        const content = readFileSync42(join74(messageDir, file2), "utf-8");
+        const parsed = JSON.parse(content);
+        if (hasFullAgentAndModel(parsed)) {
+          return parsed;
+        }
+      } catch {
+        continue;
+      }
+    }
+    for (const file2 of files) {
+      try {
+        const content = readFileSync42(join74(messageDir, file2), "utf-8");
+        const parsed = JSON.parse(content);
+        if (hasPartialAgentOrModel(parsed)) {
+          return parsed;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+// src/features/background-agent/manager.ts
+import { join as join75 } from "path";
+
+// src/features/background-agent/task-poller.ts
+function pruneStaleTasksAndNotifications(args) {
+  const { tasks, notifications, onTaskPruned } = args;
+  const now = Date.now();
+  for (const [taskId, task] of tasks.entries()) {
+    const timestamp2 = task.status === "pending" ? task.queuedAt?.getTime() : task.startedAt?.getTime();
+    if (!timestamp2)
+      continue;
+    const age = now - timestamp2;
+    if (age <= TASK_TTL_MS)
+      continue;
+    const errorMessage = task.status === "pending" ? "Task timed out while queued (30 minutes)" : "Task timed out after 30 minutes";
+    onTaskPruned(taskId, task, errorMessage);
+  }
+  for (const [sessionID, queued] of notifications.entries()) {
+    if (queued.length === 0) {
+      notifications.delete(sessionID);
+      continue;
+    }
+    const validNotifications = queued.filter((task) => {
+      if (!task.startedAt)
+        return false;
+      const age = now - task.startedAt.getTime();
+      return age <= TASK_TTL_MS;
+    });
+    if (validNotifications.length === 0) {
+      notifications.delete(sessionID);
+    } else if (validNotifications.length !== queued.length) {
+      notifications.set(sessionID, validNotifications);
+    }
+  }
+}
+async function checkAndInterruptStaleTasks(args) {
+  const { tasks, client: client2, config: config3, concurrencyManager, notifyParentSession, sessionStatuses } = args;
+  const staleTimeoutMs = config3?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS;
+  const now = Date.now();
+  const messageStalenessMs = config3?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS;
+  for (const task of tasks) {
+    if (task.status !== "running")
+      continue;
+    const startedAt = task.startedAt;
+    const sessionID = task.sessionID;
+    if (!startedAt || !sessionID)
+      continue;
+    const sessionStatus = sessionStatuses?.[sessionID]?.type;
+    const sessionIsRunning = sessionStatus !== undefined && sessionStatus !== "idle";
+    const runtime = now - startedAt.getTime();
+    if (!task.progress?.lastUpdate) {
+      if (sessionIsRunning)
+        continue;
+      if (runtime <= messageStalenessMs)
+        continue;
+      const staleMinutes2 = Math.round(runtime / 60000);
+      task.status = "cancelled";
+      task.error = `Stale timeout (no activity for ${staleMinutes2}min since start)`;
+      task.completedAt = new Date;
+      if (task.concurrencyKey) {
+        concurrencyManager.release(task.concurrencyKey);
+        task.concurrencyKey = undefined;
+      }
+      client2.session.abort({ path: { id: sessionID } }).catch(() => {});
+      log(`[background-agent] Task ${task.id} interrupted: no progress since start`);
+      try {
+        await notifyParentSession(task);
+      } catch (err) {
+        log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err });
+      }
+      continue;
+    }
+    if (sessionIsRunning)
+      continue;
+    if (runtime < MIN_RUNTIME_BEFORE_STALE_MS)
+      continue;
+    const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime();
+    if (timeSinceLastUpdate <= staleTimeoutMs)
+      continue;
+    if (task.status !== "running")
+      continue;
+    const staleMinutes = Math.round(timeSinceLastUpdate / 60000);
+    task.status = "cancelled";
+    task.error = `Stale timeout (no activity for ${staleMinutes}min)`;
+    task.completedAt = new Date;
+    if (task.concurrencyKey) {
+      concurrencyManager.release(task.concurrencyKey);
+      task.concurrencyKey = undefined;
     }
-  }
-  clear() {
-    for (const [model] of this.queues) {
-      this.cancelWaiters(model);
+    client2.session.abort({ path: { id: sessionID } }).catch(() => {});
+    log(`[background-agent] Task ${task.id} interrupted: stale timeout`);
+    try {
+      await notifyParentSession(task);
+    } catch (err) {
+      log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err });
     }
-    this.counts.clear();
-    this.queues.clear();
-  }
-  getCount(model) {
-    return this.counts.get(model) ?? 0;
-  }
-  getQueueLength(model) {
-    return this.queues.get(model)?.length ?? 0;
   }
 }
 
-// src/features/background-agent/constants.ts
-var TASK_TTL_MS = 30 * 60 * 1000;
-var MIN_STABILITY_TIME_MS2 = 10 * 1000;
-var DEFAULT_STALE_TIMEOUT_MS = 180000;
-var DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600000;
-var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
-var MIN_IDLE_TIME_MS = 5000;
-var POLLING_INTERVAL_MS = 3000;
-var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
-
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync63, readFileSync as readFileSync42, readdirSync as readdirSync18 } from "fs";
-import { join as join74 } from "path";
-
 class BackgroundManager {
-  static cleanupManagers = new Set;
-  static cleanupRegistered = false;
-  static cleanupHandlers = new Map;
   tasks;
   notifications;
   pendingByParent;
@@ -58219,8 +58793,8 @@ class BackgroundManager {
       if (!assistantError)
         return;
       const errorInfo = {
-        name: this.extractErrorName(assistantError),
-        message: this.extractErrorMessage(assistantError)
+        name: extractErrorName2(assistantError),
+        message: extractErrorMessage(assistantError)
       };
       this.tryFallbackRetry(task, errorInfo, "message.updated");
     }
@@ -58308,7 +58882,7 @@ class BackgroundManager {
         return;
       const errorObj = props?.error;
       const errorName = errorObj?.name;
-      const errorMessage = props ? this.getSessionErrorMessage(props) : undefined;
+      const errorMessage = props ? getSessionErrorMessage(props) : undefined;
       const errorInfo = { name: errorName, message: errorMessage };
       if (this.tryFallbackRetry(task, errorInfo, "session.error"))
         return;
@@ -58412,93 +58986,21 @@ class BackgroundManager {
     }
   }
   tryFallbackRetry(task, errorInfo, source) {
-    const fallbackChain = task.fallbackChain;
-    const canRetry = shouldRetryError(errorInfo) && fallbackChain && fallbackChain.length > 0 && hasMoreFallbacks(fallbackChain, task.attemptCount ?? 0);
-    if (!canRetry)
-      return false;
-    const attemptCount = task.attemptCount ?? 0;
-    const providerModelsCache = readProviderModelsCache();
-    const connectedProviders = providerModelsCache?.connected ?? readConnectedProvidersCache();
-    const connectedSet = connectedProviders ? new Set(connectedProviders.map((p) => p.toLowerCase())) : null;
-    const isReachable = (entry) => {
-      if (!connectedSet)
-        return true;
-      return entry.providers.some((p) => connectedSet.has(p.toLowerCase()));
-    };
-    let selectedAttemptCount = attemptCount;
-    let nextFallback;
-    while (fallbackChain && selectedAttemptCount < fallbackChain.length) {
-      const candidate = getNextFallback(fallbackChain, selectedAttemptCount);
-      if (!candidate)
-        break;
-      selectedAttemptCount++;
-      if (!isReachable(candidate)) {
-        log("[background-agent] Skipping unreachable fallback:", {
-          taskId: task.id,
-          source,
-          model: candidate.model,
-          providers: candidate.providers
-        });
-        continue;
-      }
-      nextFallback = candidate;
-      break;
-    }
-    if (!nextFallback)
-      return false;
-    const providerID = selectFallbackProvider(nextFallback.providers, task.model?.providerID);
-    log("[background-agent] Retryable error, attempting fallback:", {
-      taskId: task.id,
+    const previousSessionID = task.sessionID;
+    const result = tryFallbackRetry({
+      task,
+      errorInfo,
       source,
-      errorName: errorInfo.name,
-      errorMessage: errorInfo.message?.slice(0, 100),
-      attemptCount: selectedAttemptCount,
-      nextModel: `${providerID}/${nextFallback.model}`
+      concurrencyManager: this.concurrencyManager,
+      client: this.client,
+      idleDeferralTimers: this.idleDeferralTimers,
+      queuesByKey: this.queuesByKey,
+      processKey: (key) => this.processKey(key)
     });
-    if (task.concurrencyKey) {
-      this.concurrencyManager.release(task.concurrencyKey);
-      task.concurrencyKey = undefined;
-    }
-    if (task.sessionID) {
-      this.client.session.abort({ path: { id: task.sessionID } }).catch(() => {});
-      subagentSessions.delete(task.sessionID);
-    }
-    const idleTimer = this.idleDeferralTimers.get(task.id);
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      this.idleDeferralTimers.delete(task.id);
+    if (result && previousSessionID) {
+      subagentSessions.delete(previousSessionID);
     }
-    task.attemptCount = selectedAttemptCount;
-    const transformedModelId = transformModelForProvider(providerID, nextFallback.model);
-    task.model = {
-      providerID,
-      modelID: transformedModelId,
-      variant: nextFallback.variant
-    };
-    task.status = "pending";
-    task.sessionID = undefined;
-    task.startedAt = undefined;
-    task.queuedAt = new Date;
-    task.error = undefined;
-    const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
-    const queue = this.queuesByKey.get(key) ?? [];
-    const retryInput = {
-      description: task.description,
-      prompt: task.prompt,
-      agent: task.agent,
-      parentSessionID: task.parentSessionID,
-      parentMessageID: task.parentMessageID,
-      parentModel: task.parentModel,
-      parentAgent: task.parentAgent,
-      parentTools: task.parentTools,
-      model: task.model,
-      fallbackChain: task.fallbackChain,
-      category: task.category
-    };
-    queue.push({ task, input: retryInput });
-    this.queuesByKey.set(key, queue);
-    this.processKey(key);
-    return true;
+    return result;
   }
   markForNotification(task) {
     const queue = this.notifications.get(task.parentSessionID) ?? [];
@@ -58648,40 +59150,10 @@ class BackgroundManager {
     }
   }
   registerProcessCleanup() {
-    BackgroundManager.cleanupManagers.add(this);
-    if (BackgroundManager.cleanupRegistered)
-      return;
-    BackgroundManager.cleanupRegistered = true;
-    const cleanupAll = () => {
-      for (const manager of BackgroundManager.cleanupManagers) {
-        try {
-          manager.shutdown();
-        } catch (error45) {
-          log("[background-agent] Error during shutdown cleanup:", error45);
-        }
-      }
-    };
-    const registerSignal = (signal, exitAfter) => {
-      const listener = registerProcessSignal(signal, cleanupAll, exitAfter);
-      BackgroundManager.cleanupHandlers.set(signal, listener);
-    };
-    registerSignal("SIGINT", true);
-    registerSignal("SIGTERM", true);
-    if (process.platform === "win32") {
-      registerSignal("SIGBREAK", true);
-    }
-    registerSignal("beforeExit", false);
-    registerSignal("exit", false);
+    registerManagerForCleanup(this);
   }
   unregisterProcessCleanup() {
-    BackgroundManager.cleanupManagers.delete(this);
-    if (BackgroundManager.cleanupManagers.size > 0)
-      return;
-    for (const [signal, listener] of BackgroundManager.cleanupHandlers.entries()) {
-      process.off(signal, listener);
-    }
-    BackgroundManager.cleanupHandlers.clear();
-    BackgroundManager.cleanupRegistered = false;
+    unregisterManagerForCleanup(this);
   }
   getRunningTasks() {
     return Array.from(this.tasks.values()).filter((t) => t.status === "running");
@@ -58723,7 +59195,7 @@ class BackgroundManager {
     return true;
   }
   async notifyParentSession(task) {
-    const duration3 = this.formatDuration(task.startedAt ?? new Date, task.completedAt);
+    const duration3 = formatDuration3(task.startedAt ?? new Date, task.completedAt);
     log("[background-agent] notifyParentSession called for task:", task.id);
     const toastManager = getTaskToastManager();
     if (toastManager) {
@@ -58787,7 +59259,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           if (isCompactionAgent(info?.agent)) {
             continue;
           }
-          const normalizedTools = this.isRecord(info?.tools) ? normalizePromptTools(info.tools) : undefined;
+          const normalizedTools = isRecord4(info?.tools) ? normalizePromptTools(info.tools) : undefined;
           if (info?.agent || info?.model || info?.modelID && info?.providerID || normalizedTools) {
             agent = info?.agent ?? task.parentAgent;
             model = info?.model ?? (info?.providerID && info?.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
@@ -58796,13 +59268,13 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           }
         }
       } catch (error45) {
-        if (this.isAbortedSessionError(error45)) {
+        if (isAbortedSessionError(error45)) {
           log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
             taskId: task.id,
             parentSessionID: task.parentSessionID
           });
         }
-        const messageDir = getMessageDir2(task.parentSessionID);
+        const messageDir = join75(MESSAGE_STORAGE, task.parentSessionID);
         const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir) : null;
         agent = currentMessage?.agent ?? task.parentAgent;
         model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
@@ -58831,7 +59303,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           noReply: !allComplete
         });
       } catch (error45) {
-        if (this.isAbortedSessionError(error45)) {
+        if (isAbortedSessionError(error45)) {
           log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
             taskId: task.id,
             parentSessionID: task.parentSessionID
@@ -58867,91 +59339,10 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
   }
   formatDuration(start, end) {
-    const duration3 = (end ?? new Date).getTime() - start.getTime();
-    const seconds = Math.floor(duration3 / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-    } else if (minutes > 0) {
-      return `${minutes}m ${seconds % 60}s`;
-    }
-    return `${seconds}s`;
+    return formatDuration3(start, end);
   }
   isAbortedSessionError(error45) {
-    const message = this.getErrorText(error45);
-    return message.toLowerCase().includes("aborted");
-  }
-  getErrorText(error45) {
-    if (!error45)
-      return "";
-    if (typeof error45 === "string")
-      return error45;
-    if (error45 instanceof Error) {
-      return `${error45.name}: ${error45.message}`;
-    }
-    if (typeof error45 === "object" && error45 !== null) {
-      if ("message" in error45 && typeof error45.message === "string") {
-        return error45.message;
-      }
-      if ("name" in error45 && typeof error45.name === "string") {
-        return error45.name;
-      }
-    }
-    return "";
-  }
-  extractErrorName(error45) {
-    if (this.isRecord(error45) && typeof error45["name"] === "string")
-      return error45["name"];
-    if (error45 instanceof Error)
-      return error45.name;
-    return;
-  }
-  extractErrorMessage(error45) {
-    if (!error45)
-      return;
-    if (typeof error45 === "string")
-      return error45;
-    if (error45 instanceof Error)
-      return error45.message;
-    if (this.isRecord(error45)) {
-      const dataRaw = error45["data"];
-      const candidates = [
-        error45,
-        dataRaw,
-        error45["error"],
-        this.isRecord(dataRaw) ? dataRaw["error"] : undefined,
-        error45["cause"]
-      ];
-      for (const candidate of candidates) {
-        if (typeof candidate === "string" && candidate.length > 0)
-          return candidate;
-        if (this.isRecord(candidate) && typeof candidate["message"] === "string" && candidate["message"].length > 0) {
-          return candidate["message"];
-        }
-      }
-    }
-    try {
-      return JSON.stringify(error45);
-    } catch {
-      return String(error45);
-    }
-  }
-  isRecord(value) {
-    return typeof value === "object" && value !== null;
-  }
-  getSessionErrorMessage(properties) {
-    const errorRaw = properties["error"];
-    if (!this.isRecord(errorRaw))
-      return;
-    const dataRaw = errorRaw["data"];
-    if (this.isRecord(dataRaw)) {
-      const message2 = dataRaw["message"];
-      if (typeof message2 === "string")
-        return message2;
-    }
-    const message = errorRaw["message"];
-    return typeof message === "string" ? message : undefined;
+    return isAbortedSessionError(error45);
   }
   hasRunningTasks() {
     for (const task of this.tasks.values()) {
@@ -58961,17 +59352,12 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     return false;
   }
   pruneStaleTasksAndNotifications() {
-    const now = Date.now();
-    for (const [taskId, task] of this.tasks.entries()) {
-      const wasPending = task.status === "pending";
-      const timestamp2 = task.status === "pending" ? task.queuedAt?.getTime() : task.startedAt?.getTime();
-      if (!timestamp2) {
-        continue;
-      }
-      const age = now - timestamp2;
-      if (age > TASK_TTL_MS) {
-        const errorMessage = task.status === "pending" ? "Task timed out while queued (30 minutes)" : "Task timed out after 30 minutes";
-        log("[background-agent] Pruning stale task:", { taskId, status: task.status, age: Math.round(age / 1000) + "s" });
+    pruneStaleTasksAndNotifications({
+      tasks: this.tasks,
+      notifications: this.notifications,
+      onTaskPruned: (taskId, task, errorMessage) => {
+        const wasPending = task.status === "pending";
+        log("[background-agent] Pruning stale task:", { taskId, status: task.status, age: Math.round(((wasPending ? task.queuedAt?.getTime() : task.startedAt?.getTime()) ? Date.now() - (wasPending ? task.queuedAt.getTime() : task.startedAt.getTime()) : 0) / 1000) + "s" });
         task.status = "error";
         task.error = errorMessage;
         task.completedAt = new Date;
@@ -59004,86 +59390,17 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           SessionCategoryRegistry.remove(task.sessionID);
         }
       }
-    }
-    for (const [sessionID, notifications] of this.notifications.entries()) {
-      if (notifications.length === 0) {
-        this.notifications.delete(sessionID);
-        continue;
-      }
-      const validNotifications = notifications.filter((task) => {
-        if (!task.startedAt)
-          return false;
-        const age = now - task.startedAt.getTime();
-        return age <= TASK_TTL_MS;
-      });
-      if (validNotifications.length === 0) {
-        this.notifications.delete(sessionID);
-      } else if (validNotifications.length !== notifications.length) {
-        this.notifications.set(sessionID, validNotifications);
-      }
-    }
+    });
   }
   async checkAndInterruptStaleTasks(allStatuses = {}) {
-    const staleTimeoutMs = this.config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS;
-    const messageStalenessMs = this.config?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS;
-    const now = Date.now();
-    for (const task of this.tasks.values()) {
-      if (task.status !== "running")
-        continue;
-      const startedAt = task.startedAt;
-      const sessionID = task.sessionID;
-      if (!startedAt || !sessionID)
-        continue;
-      const sessionStatus = allStatuses[sessionID]?.type;
-      const sessionIsRunning = sessionStatus !== undefined && sessionStatus !== "idle";
-      const runtime = now - startedAt.getTime();
-      if (!task.progress?.lastUpdate) {
-        if (sessionIsRunning)
-          continue;
-        if (runtime <= messageStalenessMs)
-          continue;
-        const staleMinutes2 = Math.round(runtime / 60000);
-        task.status = "cancelled";
-        task.error = `Stale timeout (no activity for ${staleMinutes2}min since start)`;
-        task.completedAt = new Date;
-        if (task.concurrencyKey) {
-          this.concurrencyManager.release(task.concurrencyKey);
-          task.concurrencyKey = undefined;
-        }
-        this.client.session.abort({ path: { id: sessionID } }).catch(() => {});
-        log(`[background-agent] Task ${task.id} interrupted: no progress since start`);
-        try {
-          await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task));
-        } catch (err) {
-          log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err });
-        }
-        continue;
-      }
-      if (sessionIsRunning)
-        continue;
-      if (runtime < MIN_RUNTIME_BEFORE_STALE_MS)
-        continue;
-      const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime();
-      if (timeSinceLastUpdate <= staleTimeoutMs)
-        continue;
-      if (task.status !== "running")
-        continue;
-      const staleMinutes = Math.round(timeSinceLastUpdate / 60000);
-      task.status = "cancelled";
-      task.error = `Stale timeout (no activity for ${staleMinutes}min)`;
-      task.completedAt = new Date;
-      if (task.concurrencyKey) {
-        this.concurrencyManager.release(task.concurrencyKey);
-        task.concurrencyKey = undefined;
-      }
-      this.client.session.abort({ path: { id: sessionID } }).catch(() => {});
-      log(`[background-agent] Task ${task.id} interrupted: stale timeout`);
-      try {
-        await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task));
-      } catch (err) {
-        log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err });
-      }
-    }
+    await checkAndInterruptStaleTasks({
+      tasks: this.tasks.values(),
+      client: this.client,
+      config: this.config,
+      concurrencyManager: this.concurrencyManager,
+      notifyParentSession: (task) => this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task)),
+      sessionStatuses: allStatuses
+    });
   }
   async pollRunningTasks() {
     if (this.pollingInFlight)
@@ -59201,71 +59518,6 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     return current;
   }
 }
-function registerProcessSignal(signal, handler, exitAfter) {
-  const listener = () => {
-    handler();
-    if (exitAfter) {
-      process.exitCode = 0;
-      setTimeout(() => process.exit(), 6000);
-    }
-  };
-  process.on(signal, listener);
-  return listener;
-}
-function getMessageDir2(sessionID) {
-  if (!existsSync63(MESSAGE_STORAGE))
-    return null;
-  const directPath = join74(MESSAGE_STORAGE, sessionID);
-  if (existsSync63(directPath))
-    return directPath;
-  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
-    const sessionPath = join74(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync63(sessionPath))
-      return sessionPath;
-  }
-  return null;
-}
-function isCompactionAgent(agent) {
-  return agent?.trim().toLowerCase() === "compaction";
-}
-function hasFullAgentAndModel(message) {
-  return !!message.agent && !isCompactionAgent(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
-}
-function hasPartialAgentOrModel(message) {
-  const hasAgent = !!message.agent && !isCompactionAgent(message.agent);
-  const hasModel = !!message.model?.providerID && !!message.model?.modelID;
-  return hasAgent || hasModel;
-}
-function findNearestMessageExcludingCompaction(messageDir) {
-  try {
-    const files = readdirSync18(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
-    for (const file2 of files) {
-      try {
-        const content = readFileSync42(join74(messageDir, file2), "utf-8");
-        const parsed = JSON.parse(content);
-        if (hasFullAgentAndModel(parsed)) {
-          return parsed;
-        }
-      } catch {
-        continue;
-      }
-    }
-    for (const file2 of files) {
-      try {
-        const content = readFileSync42(join74(messageDir, file2), "utf-8");
-        const parsed = JSON.parse(content);
-        if (hasPartialAgentOrModel(parsed)) {
-          return parsed;
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
 // src/features/background-agent/state.ts
 class TaskStateManager {
   tasks = new Map;
@@ -63265,11 +63517,11 @@ class StreamableHTTPClientTransport {
 }
 
 // src/features/mcp-oauth/storage.ts
-import { chmodSync as chmodSync2, existsSync as existsSync64, mkdirSync as mkdirSync15, readFileSync as readFileSync43, unlinkSync as unlinkSync10, writeFileSync as writeFileSync20 } from "fs";
-import { dirname as dirname21, join as join75 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync63, mkdirSync as mkdirSync15, readFileSync as readFileSync43, unlinkSync as unlinkSync10, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname21, join as join76 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join75(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join76(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -63306,7 +63558,7 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync64(filePath)) {
+  if (!existsSync63(filePath)) {
     return null;
   }
   try {
@@ -63320,7 +63572,7 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname21(filePath);
-    if (!existsSync64(dir)) {
+    if (!existsSync63(dir)) {
       mkdirSync15(dir, { recursive: true });
     }
     writeFileSync20(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
@@ -63472,7 +63724,7 @@ async function getOrRegisterClient(options) {
   }
 }
 function parseRegistrationResponse(data) {
-  if (!isRecord4(data))
+  if (!isRecord5(data))
     return null;
   const clientId = data.client_id;
   if (typeof clientId !== "string" || clientId.length === 0)
@@ -63483,7 +63735,7 @@ function parseRegistrationResponse(data) {
   }
   return { clientId };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -65680,6 +65932,20 @@ function buildAntiPatternsSection() {
 ${patterns.join(`
 `)}`;
 }
+function buildDeepParallelSection(model, categories2) {
+  const isNonClaude = !model.toLowerCase().includes("claude");
+  const hasDeepCategory = categories2.some((c) => c.name === "deep");
+  if (!isNonClaude || !hasDeepCategory)
+    return "";
+  return `### Deep Parallel Delegation
+
+For implementation tasks, actively decompose and delegate to \`deep\` category agents in parallel.
+
+1. Break the implementation into independent work units
+2. Maximize parallel deep agents \u2014 spawn one per independent unit (\`run_in_background=true\`)
+3. Give each agent a GOAL, not step-by-step instructions \u2014 deep agents explore and solve autonomously
+4. Collect results, integrate, verify coherence`;
+}
 
 // src/agents/sisyphus.ts
 var MODE = "primary";
@@ -65791,7 +66057,7 @@ Should I proceed with [recommendation], or would you prefer differently?
 \`\`\`
 </Task_Management>`;
 }
-function buildDynamicSisyphusPrompt(availableAgents, availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false) {
+function buildDynamicSisyphusPrompt(model, availableAgents, availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false) {
   const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills);
   const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills);
   const exploreSection = buildExploreSection(availableAgents);
@@ -65801,6 +66067,7 @@ function buildDynamicSisyphusPrompt(availableAgents, availableTools = [], availa
   const oracleSection = buildOracleSection(availableAgents);
   const hardBlocks = buildHardBlocksSection();
   const antiPatterns = buildAntiPatternsSection();
+  const deepParallelSection = buildDeepParallelSection(model, availableCategories);
   const taskManagementSection = buildTaskManagementSection(useTaskSystem);
   const todoHookNote = useTaskSystem ? "YOUR TASK CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TASK CONTINUATION])" : "YOUR TODO CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TODO CONTINUATION])";
   return `<Role>
@@ -65993,6 +66260,8 @@ STOP searching when:
 
 ${categorySkillsGuide}
 
+${deepParallelSection}
+
 ${delegationTable}
 
 ### Delegation Prompt Structure (MANDATORY - ALL 6 sections):
@@ -66172,7 +66441,7 @@ function createSisyphusAgent(model, availableAgents, availableToolNames, availab
   const tools = availableToolNames ? categorizeTools(availableToolNames) : [];
   const skills2 = availableSkills ?? [];
   const categories2 = availableCategories ?? [];
-  const prompt = availableAgents ? buildDynamicSisyphusPrompt(availableAgents, tools, skills2, categories2, useTaskSystem) : buildDynamicSisyphusPrompt([], tools, skills2, categories2, useTaskSystem);
+  const prompt = availableAgents ? buildDynamicSisyphusPrompt(model, availableAgents, tools, skills2, categories2, useTaskSystem) : buildDynamicSisyphusPrompt(model, [], tools, skills2, categories2, useTaskSystem);
   const permission = {
     question: "allow",
     call_omo_agent: "deny"
@@ -68839,7 +69108,7 @@ function buildAgent(source, model, categories2, gitMasterConfig, browserProvider
 }
 
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync65, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync64, readFileSync as readFileSync44 } from "fs";
 import { homedir as homedir13 } from "os";
 import { isAbsolute as isAbsolute9, resolve as resolve10 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
@@ -68854,7 +69123,7 @@ function resolvePromptAppend(promptAppend, configDir) {
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
-  if (!existsSync65(filePath)) {
+  if (!existsSync64(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
@@ -69179,7 +69448,7 @@ function maybeCreateAtlasConfig(input) {
 function sanitizeMarkdownTableCell(value) {
   return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function parseRegisteredAgentSummaries(input) {
@@ -69187,7 +69456,7 @@ function parseRegisteredAgentSummaries(input) {
     return [];
   const result = [];
   for (const item of input) {
-    if (!isRecord5(item))
+    if (!isRecord6(item))
       continue;
     const name = typeof item.name === "string" ? item.name : undefined;
     if (!name)
@@ -71420,8 +71689,8 @@ function createSisyphusJuniorAgentWithOverrides(override, systemDefaultModel, us
 }
 createSisyphusJuniorAgentWithOverrides.mode = MODE10;
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync66, readdirSync as readdirSync19, readFileSync as readFileSync45 } from "fs";
-import { join as join76, basename as basename8 } from "path";
+import { existsSync as existsSync65, readdirSync as readdirSync19, readFileSync as readFileSync45 } from "fs";
+import { join as join77, basename as basename8 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -71435,7 +71704,7 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync66(agentsDir)) {
+  if (!existsSync65(agentsDir)) {
     return [];
   }
   const entries = readdirSync19(agentsDir, { withFileTypes: true });
@@ -71443,7 +71712,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join76(agentsDir, entry.name);
+    const agentPath = join77(agentsDir, entry.name);
     const agentName = basename8(entry.name, ".md");
     try {
       const content = readFileSync45(agentPath, "utf-8");
@@ -71473,7 +71742,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join76(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join77(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -71482,7 +71751,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents(directory) {
-  const projectAgentsDir = join76(directory ?? process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join77(directory ?? process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -71742,7 +72011,7 @@ async function applyAgentConfig(params) {
 }
 // src/features/claude-code-command-loader/loader.ts
 import { promises as fs19 } from "fs";
-import { join as join77, basename as basename9 } from "path";
+import { join as join78, basename as basename9 } from "path";
 init_logger();
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
@@ -71773,7 +72042,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join77(commandsDir, entry.name);
+      const subDirPath = join78(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands3.push(...subCommands);
@@ -71781,7 +72050,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join77(commandsDir, entry.name);
+    const commandPath = join78(commandsDir, entry.name);
     const baseCommandName = basename9(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -71828,23 +72097,23 @@ function commandsToRecord(commands3) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join77(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join78(getClaudeConfigDir(), "commands");
   const commands3 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands3);
 }
 async function loadProjectCommands(directory) {
-  const projectCommandsDir = join77(directory ?? process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join78(directory ?? process.cwd(), ".claude", "commands");
   const commands3 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands3);
 }
 async function loadOpencodeGlobalCommands() {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeCommandsDir = join77(configDir, "command");
+  const opencodeCommandsDir = join78(configDir, "command");
   const commands3 = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands3);
 }
 async function loadOpencodeProjectCommands(directory) {
-  const opencodeProjectDir = join77(directory ?? process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join78(directory ?? process.cwd(), ".opencode", "command");
   const commands3 = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands3);
 }
@@ -71903,8 +72172,8 @@ function remapCommandAgentFields(commands3) {
   }
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync67, readFileSync as readFileSync46 } from "fs";
-import { join as join78 } from "path";
+import { existsSync as existsSync66, readFileSync as readFileSync46 } from "fs";
+import { join as join79 } from "path";
 import { homedir as homedir14 } from "os";
 
 // src/features/claude-code-mcp-loader/transformer.ts
@@ -71946,14 +72215,14 @@ function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd = process.cwd();
   return [
-    { path: join78(homedir14(), ".claude.json"), scope: "user" },
-    { path: join78(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join78(cwd, ".mcp.json"), scope: "project" },
-    { path: join78(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join79(homedir14(), ".claude.json"), scope: "user" },
+    { path: join79(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join79(cwd, ".mcp.json"), scope: "project" },
+    { path: join79(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync67(filePath)) {
+  if (!existsSync66(filePath)) {
     return null;
   }
   try {
@@ -71968,7 +72237,7 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path11 } of paths) {
-    if (!existsSync67(path11))
+    if (!existsSync66(path11))
       continue;
     try {
       const content = readFileSync46(path11, "utf-8");
@@ -72145,21 +72414,21 @@ init_logger();
 
 // src/features/claude-code-plugin-loader/discovery.ts
 init_logger();
-import { existsSync as existsSync68, readFileSync as readFileSync47 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync47 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join79 } from "path";
+import { join as join80 } from "path";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join79(homedir15(), ".claude", "plugins");
+  return join80(homedir15(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join79(getPluginsBaseDir(), "installed_plugins.json");
+  return join80(getPluginsBaseDir(), "installed_plugins.json");
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync68(dbPath)) {
+  if (!existsSync67(dbPath)) {
     return null;
   }
   try {
@@ -72174,11 +72443,11 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join79(homedir15(), ".claude", "settings.json");
+  return join80(homedir15(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync68(settingsPath)) {
+  if (!existsSync67(settingsPath)) {
     return null;
   }
   try {
@@ -72190,8 +72459,8 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join79(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync68(manifestPath)) {
+  const manifestPath = join80(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync67(manifestPath)) {
     return null;
   }
   try {
@@ -72239,7 +72508,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version2 } = installation;
-    if (!existsSync68(installPath)) {
+    if (!existsSync67(installPath)) {
       errors3.push({
         pluginKey,
         installPath,
@@ -72257,21 +72526,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync68(join79(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join79(installPath, "commands");
+    if (existsSync67(join80(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join80(installPath, "commands");
     }
-    if (existsSync68(join79(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join79(installPath, "agents");
+    if (existsSync67(join80(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join80(installPath, "agents");
     }
-    if (existsSync68(join79(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join79(installPath, "skills");
+    if (existsSync67(join80(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join80(installPath, "skills");
     }
-    const hooksPath = join79(installPath, "hooks", "hooks.json");
-    if (existsSync68(hooksPath)) {
+    const hooksPath = join80(installPath, "hooks", "hooks.json");
+    if (existsSync67(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join79(installPath, ".mcp.json");
-    if (existsSync68(mcpPath)) {
+    const mcpPath = join80(installPath, ".mcp.json");
+    if (existsSync67(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -72284,19 +72553,19 @@ function discoverInstalledPlugins(options) {
 }
 
 // src/features/claude-code-plugin-loader/command-loader.ts
-import { existsSync as existsSync69, readdirSync as readdirSync20, readFileSync as readFileSync48 } from "fs";
-import { basename as basename10, join as join80 } from "path";
+import { existsSync as existsSync68, readdirSync as readdirSync20, readFileSync as readFileSync48 } from "fs";
+import { basename as basename10, join as join81 } from "path";
 init_logger();
 function loadPluginCommands(plugins) {
   const commands3 = {};
   for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync69(plugin.commandsDir))
+    if (!plugin.commandsDir || !existsSync68(plugin.commandsDir))
       continue;
     const entries = readdirSync20(plugin.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join80(plugin.commandsDir, entry.name);
+      const commandPath = join81(plugin.commandsDir, entry.name);
       const commandName = basename10(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
@@ -72331,24 +72600,24 @@ $ARGUMENTS
 }
 
 // src/features/claude-code-plugin-loader/skill-loader.ts
-import { existsSync as existsSync70, readdirSync as readdirSync21, readFileSync as readFileSync49 } from "fs";
-import { join as join81 } from "path";
+import { existsSync as existsSync69, readdirSync as readdirSync21, readFileSync as readFileSync49 } from "fs";
+import { join as join82 } from "path";
 init_logger();
 function loadPluginSkillsAsCommands(plugins) {
   const skills2 = {};
   for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync70(plugin.skillsDir))
+    if (!plugin.skillsDir || !existsSync69(plugin.skillsDir))
       continue;
     const entries = readdirSync21(plugin.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join81(plugin.skillsDir, entry.name);
+      const skillPath = join82(plugin.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join81(resolvedPath, "SKILL.md");
-      if (!existsSync70(skillMdPath))
+      const skillMdPath = join82(resolvedPath, "SKILL.md");
+      if (!existsSync69(skillMdPath))
         continue;
       try {
         const content = readFileSync49(skillMdPath, "utf-8");
@@ -72386,8 +72655,8 @@ $ARGUMENTS
 }
 
 // src/features/claude-code-plugin-loader/agent-loader.ts
-import { existsSync as existsSync71, readdirSync as readdirSync22, readFileSync as readFileSync50 } from "fs";
-import { basename as basename11, join as join82 } from "path";
+import { existsSync as existsSync70, readdirSync as readdirSync22, readFileSync as readFileSync50 } from "fs";
+import { basename as basename11, join as join83 } from "path";
 init_logger();
 function parseToolsConfig2(toolsStr) {
   if (!toolsStr)
@@ -72404,13 +72673,13 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync71(plugin.agentsDir))
+    if (!plugin.agentsDir || !existsSync70(plugin.agentsDir))
       continue;
     const entries = readdirSync22(plugin.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join82(plugin.agentsDir, entry.name);
+      const agentPath = join83(plugin.agentsDir, entry.name);
       const agentName = basename11(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
@@ -72438,7 +72707,7 @@ function loadPluginAgents(plugins) {
 }
 
 // src/features/claude-code-plugin-loader/mcp-server-loader.ts
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 init_logger();
 
 // src/features/claude-code-plugin-loader/plugin-path-resolver.ts
@@ -72469,7 +72738,7 @@ function resolvePluginPaths(obj, pluginRoot) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync72(plugin.mcpPath))
+    if (!plugin.mcpPath || !existsSync71(plugin.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin.mcpPath).text();
@@ -72501,11 +72770,11 @@ async function loadPluginMcpServers(plugins) {
 
 // src/features/claude-code-plugin-loader/hook-loader.ts
 init_logger();
-import { existsSync as existsSync73, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync72, readFileSync as readFileSync51 } from "fs";
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync73(plugin.hooksPath))
+    if (!plugin.hooksPath || !existsSync72(plugin.hooksPath))
       continue;
     try {
       const content = readFileSync51(plugin.hooksPath, "utf-8");
@@ -72933,11 +73202,11 @@ async function createTools(args) {
 }
 
 // src/plugin/chat-params.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function buildChatParamsInput(raw) {
-  if (!isRecord6(raw))
+  if (!isRecord7(raw))
     return null;
   const sessionID = raw.sessionID;
   const agent = raw.agent;
@@ -72946,16 +73215,16 @@ function buildChatParamsInput(raw) {
   const message = raw.message;
   if (typeof sessionID !== "string")
     return null;
-  if (!isRecord6(model))
+  if (!isRecord7(model))
     return null;
-  if (!isRecord6(provider))
+  if (!isRecord7(provider))
     return null;
-  if (!isRecord6(message))
+  if (!isRecord7(message))
     return null;
   let agentName;
   if (typeof agent === "string") {
     agentName = agent;
-  } else if (isRecord6(agent)) {
+  } else if (isRecord7(agent)) {
     const name = agent.name;
     if (typeof name === "string") {
       agentName = name;
@@ -72982,12 +73251,12 @@ function buildChatParamsInput(raw) {
   };
 }
 function isChatParamsOutput(raw) {
-  if (!isRecord6(raw))
+  if (!isRecord7(raw))
     return false;
-  if (!isRecord6(raw.options)) {
+  if (!isRecord7(raw.options)) {
     raw.options = {};
   }
-  return isRecord6(raw.options);
+  return isRecord7(raw.options);
 }
 function createChatParamsHandler(args) {
   return async (input, output) => {
@@ -73003,20 +73272,20 @@ function createChatParamsHandler(args) {
 // src/plugin/chat-headers.ts
 var INTERNAL_MARKER_CACHE_LIMIT = 1000;
 var internalMarkerCache = new Map;
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function buildChatHeadersInput(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   const sessionID = raw.sessionID;
   const provider = raw.provider;
   const message = raw.message;
   if (typeof sessionID !== "string")
     return null;
-  if (!isRecord7(provider) || typeof provider.id !== "string")
+  if (!isRecord8(provider) || typeof provider.id !== "string")
     return null;
-  if (!isRecord7(message))
+  if (!isRecord8(message))
     return null;
   return {
     sessionID,
@@ -73028,12 +73297,12 @@ function buildChatHeadersInput(raw) {
   };
 }
 function isChatHeadersOutput(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return false;
-  if (!isRecord7(raw.headers)) {
+  if (!isRecord8(raw.headers)) {
     raw.headers = {};
   }
-  return isRecord7(raw.headers);
+  return isRecord8(raw.headers);
 }
 function isCopilotProvider(providerID) {
   return providerID === "github-copilot" || providerID === "github-copilot-enterprise";
@@ -73049,7 +73318,7 @@ async function hasInternalMarker(client2, sessionID, messageID) {
       path: { id: sessionID, messageID }
     });
     const data = response.data;
-    if (!isRecord7(data) || !Array.isArray(data.parts)) {
+    if (!isRecord8(data) || !Array.isArray(data.parts)) {
       internalMarkerCache.set(cacheKey, false);
       if (internalMarkerCache.size > INTERNAL_MARKER_CACHE_LIMIT) {
         internalMarkerCache.clear();
@@ -73057,7 +73326,7 @@ async function hasInternalMarker(client2, sessionID, messageID) {
       return false;
     }
     const hasMarker = data.parts.some((part) => {
-      if (!isRecord7(part) || part.type !== "text" || typeof part.text !== "string") {
+      if (!isRecord8(part) || part.type !== "text" || typeof part.text !== "string") {
         return false;
       }
       return part.text.includes(OMO_INTERNAL_INITIATOR_MARKER);
@@ -73111,10 +73380,10 @@ function clearSessionModel(sessionID) {
 
 // src/plugin/ultrawork-db-model-override.ts
 import { Database } from "bun:sqlite";
-import { join as join83 } from "path";
-import { existsSync as existsSync74 } from "fs";
+import { join as join84 } from "path";
+import { existsSync as existsSync73 } from "fs";
 function getDbPath() {
-  return join83(getDataDir(), "opencode", "opencode.db");
+  return join84(getDataDir(), "opencode", "opencode.db");
 }
 var MAX_MICROTASK_RETRIES = 10;
 function tryUpdateMessageModel(db, messageId, targetModel, variant) {
@@ -73191,7 +73460,7 @@ function retryViaMicrotask(db, messageId, targetModel, variant, attempt) {
 function scheduleDeferredModelOverride(messageId, targetModel, variant) {
   queueMicrotask(() => {
     const dbPath = getDbPath();
-    if (!existsSync74(dbPath)) {
+    if (!existsSync73(dbPath)) {
       log("[ultrawork-db-override] DB not found, skipping deferred override");
       return;
     }
@@ -73459,36 +73728,36 @@ function pruneRecentSyntheticIdles(args) {
 }
 
 // src/plugin/event.ts
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null;
 }
 function normalizeFallbackModelID(modelID) {
   return modelID.replace(/-thinking$/i, "").replace(/-max$/i, "").replace(/-high$/i, "");
 }
-function extractErrorName2(error45) {
-  if (isRecord8(error45) && typeof error45.name === "string")
+function extractErrorName3(error45) {
+  if (isRecord9(error45) && typeof error45.name === "string")
     return error45.name;
   if (error45 instanceof Error)
     return error45.name;
   return;
 }
-function extractErrorMessage(error45) {
+function extractErrorMessage2(error45) {
   if (!error45)
     return "";
   if (typeof error45 === "string")
     return error45;
   if (error45 instanceof Error)
     return error45.message;
-  if (isRecord8(error45)) {
+  if (isRecord9(error45)) {
     const candidates = [
       error45,
       error45.data,
       error45.error,
-      isRecord8(error45.data) ? error45.data.error : undefined,
+      isRecord9(error45.data) ? error45.data.error : undefined,
       error45.cause
     ];
     for (const candidate of candidates) {
-      if (isRecord8(candidate) && typeof candidate.message === "string" && candidate.message.length > 0) {
+      if (isRecord9(candidate) && typeof candidate.message === "string" && candidate.message.length > 0) {
         return candidate.message;
       }
     }
@@ -73645,8 +73914,8 @@ function createEventHandler2(args) {
             if (lastHandled === assistantMessageID) {
               return;
             }
-            const errorName = extractErrorName2(assistantError);
-            const errorMessage = extractErrorMessage(assistantError);
+            const errorName = extractErrorName3(assistantError);
+            const errorMessage = extractErrorMessage2(assistantError);
             const errorInfo = { name: errorName, message: errorMessage };
             if (shouldRetryError(errorInfo)) {
               let agentName = agent ?? getSessionAgent(sessionID);
@@ -73730,8 +73999,8 @@ function createEventHandler2(args) {
       try {
         const sessionID = props?.sessionID;
         const error45 = props?.error;
-        const errorName = extractErrorName2(error45);
-        const errorMessage = extractErrorMessage(error45);
+        const errorName = extractErrorName3(error45);
+        const errorMessage = extractErrorMessage2(error45);
         const errorInfo = { name: errorName, message: errorMessage };
         if (hooks2.sessionRecovery?.isRecoverableError(error45)) {
           const messageInfo = {