drizzy-agent 0.7.3 → 0.8.0

package/dist/index.js

@@ -11572,7 +11572,7 @@ var require_parse2 = __commonJS((exports, module) => {
   var resolveCommand = require_resolveCommand();
   var escape2 = require_escape();
   var readShebang = require_readShebang();
-  var isWin = process.platform === "win32";
+  var isWin2 = process.platform === "win32";
   var isExecutableRegExp = /\.(?:com|exe)$/i;
   var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
   function detectShebang(parsed) {
@@ -11586,7 +11586,7 @@ var require_parse2 = __commonJS((exports, module) => {
     return parsed.file;
   }
   function parseNonShell(parsed) {
-    if (!isWin) {
+    if (!isWin2) {
       return parsed;
     }
     const commandFile = detectShebang(parsed);
@@ -11627,7 +11627,7 @@ var require_parse2 = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/enoent.js
 var require_enoent = __commonJS((exports, module) => {
-  var isWin = process.platform === "win32";
+  var isWin2 = process.platform === "win32";
   function notFoundError(original, syscall) {
     return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
       code: "ENOENT",
@@ -11638,7 +11638,7 @@ var require_enoent = __commonJS((exports, module) => {
     });
   }
   function hookChildProcess(cp, parsed) {
-    if (!isWin) {
+    if (!isWin2) {
       return;
     }
     const originalEmit = cp.emit;
@@ -11653,13 +11653,13 @@ var require_enoent = __commonJS((exports, module) => {
     };
   }
   function verifyENOENT(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
+    if (isWin2 && status === 1 && !parsed.file) {
       return notFoundError(parsed.original, "spawn");
     }
     return null;
   }
   function verifyENOENTSync(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
+    if (isWin2 && status === 1 && !parsed.file) {
       return notFoundError(parsed.original, "spawnSync");
     }
     return null;
@@ -16727,6 +16727,7 @@ var AGENT_MODEL_DEFAULTS = {
   librarian: {
     chain: [
       { providers: GEMINI_PROVIDERS, model: "gemini-3-flash" },
+      { providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.4-mini", variant: "low" },
       { providers: ["opencode"], model: "glm-4.7" },
       { providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-5" },
       { providers: ["opencode"], model: "minimax-m2.5-free", alwaysAvailable: true },
@@ -16743,6 +16744,7 @@ var AGENT_MODEL_DEFAULTS = {
   explore: {
     chain: [
       { providers: ["github-copilot"], model: "grok-code-fast-1" },
+      { providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.4-mini", variant: "low" },
       { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
       { providers: ["opencode"], model: "minimax-m2.5-free", alwaysAvailable: true },
       { providers: ["opencode"], model: "gpt-5-nano", alwaysAvailable: true }
@@ -16953,6 +16955,46 @@ function excludeFallbackEntries(chain, models) {
   const excludedModels = new Set(models);
   return chain.filter((entry) => !excludedModels.has(entry.model));
 }
+
+// src/shared/user-message-variant.ts
+function getModelRecord(message) {
+  const model = message["model"];
+  if (typeof model !== "object" || model === null) {
+    return;
+  }
+  return model;
+}
+function getOrCreateModelRecord(message) {
+  const existingModel = getModelRecord(message);
+  if (existingModel) {
+    return existingModel;
+  }
+  const model = {};
+  message["model"] = model;
+  return model;
+}
+function getUserMessageVariant(message) {
+  const model = getModelRecord(message);
+  if (typeof model?.["variant"] === "string") {
+    return model["variant"];
+  }
+  return typeof message["variant"] === "string" ? message["variant"] : undefined;
+}
+function setUserMessageVariant(message, variant) {
+  const model = getOrCreateModelRecord(message);
+  model["variant"] = variant;
+  delete message["variant"];
+}
+function clearUserMessageVariant(message) {
+  const model = getModelRecord(message);
+  if (model) {
+    delete model["variant"];
+  }
+  delete message["variant"];
+}
+function getInputVariant(input) {
+  return input.model?.variant ?? input.variant;
+}
 // src/shared/session-cursor.ts
 var sessionCursors = new Map;
 function buildMessageKey(message, index) {
@@ -17692,7 +17734,7 @@ function convertSDKMessageToStoredMessage(msg) {
     return null;
   const providerID = info.model?.providerID ?? info.providerID;
   const modelID = info.model?.modelID ?? info.modelID;
-  const variant = info.model?.variant;
+  const variant = info.model?.variant ?? info.variant;
   if (!info.agent && !providerID && !modelID) {
     return null;
   }
@@ -18276,11 +18318,31 @@ function parseModelSuggestion(error) {
   }
   return null;
 }
+function normalizePromptBody(body) {
+  if (typeof body.variant !== "string") {
+    return body;
+  }
+  const { variant, model, ...rest } = body;
+  return {
+    ...rest,
+    model: {
+      ...model ?? {},
+      variant
+    }
+  };
+}
+function normalizePromptArgs(args) {
+  return {
+    ...args,
+    body: normalizePromptBody(args.body)
+  };
+}
 async function promptWithModelSuggestionRetry(client, args, options = {}) {
+  const normalizedArgs = normalizePromptArgs(args);
   const timeoutMs = options.timeoutMs ?? PROMPT_TIMEOUT_MS;
-  const timeoutContext = createPromptTimeoutContext(args, timeoutMs);
+  const timeoutContext = createPromptTimeoutContext(normalizedArgs, timeoutMs);
   const promptPromise = client.session.promptAsync({
-    ...args,
+    ...normalizedArgs,
     signal: timeoutContext.signal
   });
   try {
@@ -18298,12 +18360,13 @@ async function promptWithModelSuggestionRetry(client, args, options = {}) {
   }
 }
 async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
+  const normalizedArgs = normalizePromptArgs(args);
   const timeoutMs = options.timeoutMs ?? PROMPT_TIMEOUT_MS;
   try {
-    const timeoutContext = createPromptTimeoutContext(args, timeoutMs);
+    const timeoutContext = createPromptTimeoutContext(normalizedArgs, timeoutMs);
     try {
       await client.session.prompt({
-        ...args,
+        ...normalizedArgs,
         signal: timeoutContext.signal
       });
       if (timeoutContext.wasTimedOut()) {
@@ -18319,7 +18382,7 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
     }
   } catch (error) {
     const suggestion = parseModelSuggestion(error);
-    if (!suggestion || !args.body.model) {
+    if (!suggestion || !normalizedArgs.body.model) {
       throw error;
     }
     log("[model-suggestion-retry] Model not found, retrying with suggestion", {
@@ -18327,12 +18390,13 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
       suggested: suggestion.suggestion
     });
     const retryArgs = {
-      ...args,
+      ...normalizedArgs,
       body: {
-        ...args.body,
+        ...normalizedArgs.body,
         model: {
           providerID: suggestion.providerID,
-          modelID: suggestion.suggestion
+          modelID: suggestion.suggestion,
+          ...normalizedArgs.body.model.variant ? { variant: normalizedArgs.body.model.variant } : {}
         }
       }
     };
@@ -35644,7 +35708,7 @@ async function processApplyPatchEditsWithCli(sessionID, edits, output, cliPath,
         hook_event_name: "PostToolUse",
         tool_input: {
           file_path: edit.filePath,
-          old_string: edit.before,
+          ...edit.before !== undefined ? { old_string: edit.before } : {},
           new_string: edit.after
         }
       };
@@ -35662,6 +35726,871 @@ function isCliPathUsable(cliPath) {
   return Boolean(cliPath && existsSync27(cliPath));
 }
 
+// src/hooks/comment-checker/apply-patch-edits.ts
+import { existsSync as existsSync28, readFileSync as readFileSync18 } from "fs";
+// node_modules/diff/libesm/util/string.js
+function hasOnlyWinLineEndings(string4) {
+  return string4.includes(`\r
+`) && !string4.startsWith(`
+`) && !string4.match(/[^\r]\n/);
+}
+function hasOnlyUnixLineEndings(string4) {
+  return !string4.includes(`\r
+`) && string4.includes(`
+`);
+}
+
+// node_modules/diff/libesm/patch/line-endings.js
+function unixToWin(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map((p) => unixToWin(p));
+  }
+  return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line, i2) => {
+    var _a2;
+    return line.startsWith("\\") || line.endsWith("\r") || ((_a2 = hunk.lines[i2 + 1]) === null || _a2 === undefined ? undefined : _a2.startsWith("\\")) ? line : line + "\r";
+  }) })) });
+}
+function winToUnix(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map((p) => winToUnix(p));
+  }
+  return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line) => line.endsWith("\r") ? line.substring(0, line.length - 1) : line) })) });
+}
+function isUnix(patch) {
+  if (!Array.isArray(patch)) {
+    patch = [patch];
+  }
+  return !patch.some((index) => index.hunks.some((hunk) => hunk.lines.some((line) => !line.startsWith("\\") && line.endsWith("\r"))));
+}
+function isWin(patch) {
+  if (!Array.isArray(patch)) {
+    patch = [patch];
+  }
+  return patch.some((index) => index.hunks.some((hunk) => hunk.lines.some((line) => line.endsWith("\r")))) && patch.every((index) => index.hunks.every((hunk) => hunk.lines.every((line, i2) => {
+    var _a2;
+    return line.startsWith("\\") || line.endsWith("\r") || ((_a2 = hunk.lines[i2 + 1]) === null || _a2 === undefined ? undefined : _a2.startsWith("\\"));
+  })));
+}
+
+// node_modules/diff/libesm/patch/parse.js
+function parsePatch(uniDiff) {
+  const diffstr = uniDiff.split(/\n/), list = [];
+  let i2 = 0;
+  function parseIndex() {
+    const index = {};
+    list.push(index);
+    while (i2 < diffstr.length) {
+      const line = diffstr[i2];
+      if (/^(---|\+\+\+|@@)\s/.test(line)) {
+        break;
+      }
+      const headerMatch = /^(?:Index:|diff(?: -r \w+)+)\s+/.exec(line);
+      if (headerMatch) {
+        index.index = line.substring(headerMatch[0].length).trim();
+      }
+      i2++;
+    }
+    parseFileHeader(index);
+    parseFileHeader(index);
+    index.hunks = [];
+    while (i2 < diffstr.length) {
+      const line = diffstr[i2];
+      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
+        break;
+      } else if (/^@@/.test(line)) {
+        index.hunks.push(parseHunk());
+      } else if (line) {
+        throw new Error("Unknown line " + (i2 + 1) + " " + JSON.stringify(line));
+      } else {
+        i2++;
+      }
+    }
+  }
+  function parseFileHeader(index) {
+    const fileHeaderMatch = /^(---|\+\+\+)\s+/.exec(diffstr[i2]);
+    if (fileHeaderMatch) {
+      const prefix = fileHeaderMatch[1], data = diffstr[i2].substring(3).trim().split("\t", 2), header = (data[1] || "").trim();
+      let fileName = data[0].replace(/\\\\/g, "\\");
+      if (fileName.startsWith('"') && fileName.endsWith('"')) {
+        fileName = fileName.substr(1, fileName.length - 2);
+      }
+      if (prefix === "---") {
+        index.oldFileName = fileName;
+        index.oldHeader = header;
+      } else {
+        index.newFileName = fileName;
+        index.newHeader = header;
+      }
+      i2++;
+    }
+  }
+  function parseHunk() {
+    var _a2;
+    const chunkHeaderIndex = i2, chunkHeaderLine = diffstr[i2++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    const hunk = {
+      oldStart: +chunkHeader[1],
+      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
+      newStart: +chunkHeader[3],
+      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
+      lines: []
+    };
+    if (hunk.oldLines === 0) {
+      hunk.oldStart += 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart += 1;
+    }
+    let addCount = 0, removeCount = 0;
+    for (;i2 < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a2 = diffstr[i2]) === null || _a2 === undefined ? undefined : _a2.startsWith("\\"))); i2++) {
+      const operation = diffstr[i2].length == 0 && i2 != diffstr.length - 1 ? " " : diffstr[i2][0];
+      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
+        hunk.lines.push(diffstr[i2]);
+        if (operation === "+") {
+          addCount++;
+        } else if (operation === "-") {
+          removeCount++;
+        } else if (operation === " ") {
+          addCount++;
+          removeCount++;
+        }
+      } else {
+        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i2]}`);
+      }
+    }
+    if (!addCount && hunk.newLines === 1) {
+      hunk.newLines = 0;
+    }
+    if (!removeCount && hunk.oldLines === 1) {
+      hunk.oldLines = 0;
+    }
+    if (addCount !== hunk.newLines) {
+      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    if (removeCount !== hunk.oldLines) {
+      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    return hunk;
+  }
+  while (i2 < diffstr.length) {
+    parseIndex();
+  }
+  return list;
+}
+
+// node_modules/diff/libesm/util/distance-iterator.js
+function distance_iterator_default(start, minLine, maxLine) {
+  let wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
+  return function iterator() {
+    if (wantForward && !forwardExhausted) {
+      if (backwardExhausted) {
+        localOffset++;
+      } else {
+        wantForward = false;
+      }
+      if (start + localOffset <= maxLine) {
+        return start + localOffset;
+      }
+      forwardExhausted = true;
+    }
+    if (!backwardExhausted) {
+      if (!forwardExhausted) {
+        wantForward = true;
+      }
+      if (minLine <= start - localOffset) {
+        return start - localOffset++;
+      }
+      backwardExhausted = true;
+      return iterator();
+    }
+    return;
+  };
+}
+
+// node_modules/diff/libesm/patch/apply.js
+function applyPatch(source, patch, options = {}) {
+  let patches;
+  if (typeof patch === "string") {
+    patches = parsePatch(patch);
+  } else if (Array.isArray(patch)) {
+    patches = patch;
+  } else {
+    patches = [patch];
+  }
+  if (patches.length > 1) {
+    throw new Error("applyPatch only works with a single input.");
+  }
+  return applyStructuredPatch(source, patches[0], options);
+}
+function applyStructuredPatch(source, patch, options = {}) {
+  if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
+    if (hasOnlyWinLineEndings(source) && isUnix(patch)) {
+      patch = unixToWin(patch);
+    } else if (hasOnlyUnixLineEndings(source) && isWin(patch)) {
+      patch = winToUnix(patch);
+    }
+  }
+  const lines = source.split(`
+`), hunks = patch.hunks, compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent), fuzzFactor = options.fuzzFactor || 0;
+  let minLine = 0;
+  if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
+    throw new Error("fuzzFactor must be a non-negative integer");
+  }
+  if (!hunks.length) {
+    return source;
+  }
+  let prevLine = "", removeEOFNL = false, addEOFNL = false;
+  for (let i2 = 0;i2 < hunks[hunks.length - 1].lines.length; i2++) {
+    const line = hunks[hunks.length - 1].lines[i2];
+    if (line[0] == "\\") {
+      if (prevLine[0] == "+") {
+        removeEOFNL = true;
+      } else if (prevLine[0] == "-") {
+        addEOFNL = true;
+      }
+    }
+    prevLine = line;
+  }
+  if (removeEOFNL) {
+    if (addEOFNL) {
+      if (!fuzzFactor && lines[lines.length - 1] == "") {
+        return false;
+      }
+    } else if (lines[lines.length - 1] == "") {
+      lines.pop();
+    } else if (!fuzzFactor) {
+      return false;
+    }
+  } else if (addEOFNL) {
+    if (lines[lines.length - 1] != "") {
+      lines.push("");
+    } else if (!fuzzFactor) {
+      return false;
+    }
+  }
+  function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI = 0, lastContextLineMatched = true, patchedLines = [], patchedLinesLength = 0) {
+    let nConsecutiveOldContextLines = 0;
+    let nextContextLineMustMatch = false;
+    for (;hunkLinesI < hunkLines.length; hunkLinesI++) {
+      const hunkLine = hunkLines[hunkLinesI], operation = hunkLine.length > 0 ? hunkLine[0] : " ", content = hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine;
+      if (operation === "-") {
+        if (compareLine(toPos + 1, lines[toPos], operation, content)) {
+          toPos++;
+          nConsecutiveOldContextLines = 0;
+        } else {
+          if (!maxErrors || lines[toPos] == null) {
+            return null;
+          }
+          patchedLines[patchedLinesLength] = lines[toPos];
+          return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
+        }
+      }
+      if (operation === "+") {
+        if (!lastContextLineMatched) {
+          return null;
+        }
+        patchedLines[patchedLinesLength] = content;
+        patchedLinesLength++;
+        nConsecutiveOldContextLines = 0;
+        nextContextLineMustMatch = true;
+      }
+      if (operation === " ") {
+        nConsecutiveOldContextLines++;
+        patchedLines[patchedLinesLength] = lines[toPos];
+        if (compareLine(toPos + 1, lines[toPos], operation, content)) {
+          patchedLinesLength++;
+          lastContextLineMatched = true;
+          nextContextLineMustMatch = false;
+          toPos++;
+        } else {
+          if (nextContextLineMustMatch || !maxErrors) {
+            return null;
+          }
+          return lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength);
+        }
+      }
+    }
+    patchedLinesLength -= nConsecutiveOldContextLines;
+    toPos -= nConsecutiveOldContextLines;
+    patchedLines.length = patchedLinesLength;
+    return {
+      patchedLines,
+      oldLineLastI: toPos - 1
+    };
+  }
+  const resultLines = [];
+  let prevHunkOffset = 0;
+  for (let i2 = 0;i2 < hunks.length; i2++) {
+    const hunk = hunks[i2];
+    let hunkResult;
+    const maxLine = lines.length - hunk.oldLines + fuzzFactor;
+    let toPos;
+    for (let maxErrors = 0;maxErrors <= fuzzFactor; maxErrors++) {
+      toPos = hunk.oldStart + prevHunkOffset - 1;
+      const iterator = distance_iterator_default(toPos, minLine, maxLine);
+      for (;toPos !== undefined; toPos = iterator()) {
+        hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
+        if (hunkResult) {
+          break;
+        }
+      }
+      if (hunkResult) {
+        break;
+      }
+    }
+    if (!hunkResult) {
+      return false;
+    }
+    for (let i3 = minLine;i3 < toPos; i3++) {
+      resultLines.push(lines[i3]);
+    }
+    for (let i3 = 0;i3 < hunkResult.patchedLines.length; i3++) {
+      const line = hunkResult.patchedLines[i3];
+      resultLines.push(line);
+    }
+    minLine = hunkResult.oldLineLastI + 1;
+    prevHunkOffset = toPos + 1 - hunk.oldStart;
+  }
+  for (let i2 = minLine;i2 < lines.length; i2++) {
+    resultLines.push(lines[i2]);
+  }
+  return resultLines.join(`
+`);
+}
+
+// node_modules/diff/libesm/patch/reverse.js
+function reversePatch(structuredPatch) {
+  if (Array.isArray(structuredPatch)) {
+    return structuredPatch.map((patch) => reversePatch(patch)).reverse();
+  }
+  return Object.assign(Object.assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map((hunk) => {
+    return {
+      oldLines: hunk.newLines,
+      oldStart: hunk.newStart,
+      newLines: hunk.oldLines,
+      newStart: hunk.oldStart,
+      lines: hunk.lines.map((l) => {
+        if (l.startsWith("-")) {
+          return `+${l.slice(1)}`;
+        }
+        if (l.startsWith("+")) {
+          return `-${l.slice(1)}`;
+        }
+        return l;
+      })
+    };
+  }) });
+}
+
+// node_modules/diff/libesm/diff/base.js
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a2;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a2 = options.timeout) !== null && _a2 !== undefined ? _a2 : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = undefined;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = undefined;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec2() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(undefined);
+          }
+          if (!execEditLength()) {
+            exec2();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path5, added, removed, oldPosInc, options) {
+    const last = path5.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path5.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path5.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i2 = 0;i2 < array2.length; i2++) {
+      if (array2[i2]) {
+        ret.push(array2[i2]);
+      }
+    }
+    return ret;
+  }
+  castInput(value, options) {
+    return value;
+  }
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (;componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i2) {
+            const oldValue = oldTokens[oldPos + i2];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+}
+
+// node_modules/diff/libesm/diff/line.js
+class LineDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes(`
+`)) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes(`
+`)) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith(`
+`)) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith(`
+`)) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+}
+var lineDiff = new LineDiff;
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, `
+`);
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i2 = 0;i2 < linesAndNewlines.length; i2++) {
+    const line = linesAndNewlines[i2];
+    if (i2 % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/patch/create.js
+var INCLUDE_HEADERS = {
+  includeIndex: true,
+  includeUnderline: true,
+  includeFileHeaders: true
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i2 = 0;i2 < diff.length; i2++) {
+      const current = diff[i2], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i2 - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i2 < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i2 = 0;i2 < hunk.lines.length; i2++) {
+        if (hunk.lines[i2].endsWith(`
+`)) {
+          hunk.lines[i2] = hunk.lines[i2].slice(0, -1);
+        } else {
+          hunk.lines.splice(i2 + 1, 0, "\");
+          i2++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch, headerOptions) {
+  if (!headerOptions) {
+    headerOptions = INCLUDE_HEADERS;
+  }
+  if (Array.isArray(patch)) {
+    if (patch.length > 1 && !headerOptions.includeFileHeaders) {
+      throw new Error("Cannot omit file headers on a multi-file patch. " + "(The result would be unparseable; how would a tool trying to apply " + "the patch know which changes are to which file?)");
+    }
+    return patch.map((p) => formatPatch(p, headerOptions)).join(`
+`);
+  }
+  const ret = [];
+  if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  if (headerOptions.includeUnderline) {
+    ret.push("===================================================================");
+  }
+  if (headerOptions.includeFileHeaders) {
+    ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "\t" + patch.oldHeader));
+    ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "\t" + patch.newHeader));
+  }
+  for (let i2 = 0;i2 < patch.hunks.length; i2++) {
+    const hunk = patch.hunks[i2];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join(`
+`) + `
+`;
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
+  }
+  if (!(options === null || options === undefined ? undefined : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj, options === null || options === undefined ? undefined : options.headerOptions);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(undefined);
+      } else {
+        callback(formatPatch(patchObj, options.headerOptions));
+      }
+    } }));
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith(`
+`);
+  const result = text.split(`
+`).map((line) => line + `
+`);
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+// src/hooks/comment-checker/apply-patch-edits.ts
+function normalizePatchFilePath(filePath) {
+  if (!filePath || filePath === "/dev/null") {
+    return;
+  }
+  return filePath.replace(/^[ab]\//, "");
+}
+function getFilePathFromPatch(patch) {
+  if (!patch) {
+    return;
+  }
+  try {
+    const parsedPatch = parsePatch(patch)[0];
+    return normalizePatchFilePath(parsedPatch?.newFileName) ?? normalizePatchFilePath(parsedPatch?.oldFileName);
+  } catch {
+    return;
+  }
+}
+function reconstructBeforeContent(after, patch) {
+  if (!patch) {
+    return;
+  }
+  try {
+    const parsedPatch = parsePatch(patch)[0];
+    if (!parsedPatch) {
+      return;
+    }
+    const reversedPatch = reversePatch(parsedPatch);
+    const reconstructed = applyPatch(after, reversedPatch);
+    return typeof reconstructed === "string" ? reconstructed : undefined;
+  } catch {
+    return;
+  }
+}
+function resolveCurrentFilePath(file2) {
+  return file2.movePath ?? file2.filePath ?? getFilePathFromPatch(file2.patch);
+}
+function resolveApplyPatchEdits(files, debugLog3) {
+  const edits = [];
+  for (const file2 of files) {
+    if (file2.type === "delete") {
+      continue;
+    }
+    const filePath = resolveCurrentFilePath(file2);
+    if (!filePath) {
+      debugLog3("apply_patch metadata missing file path, skipping file");
+      continue;
+    }
+    if (typeof file2.after === "string") {
+      edits.push({
+        filePath,
+        after: file2.after,
+        ...typeof file2.before === "string" ? { before: file2.before } : {}
+      });
+      continue;
+    }
+    if (!existsSync28(filePath)) {
+      debugLog3("apply_patch output file missing on disk, skipping file", { filePath });
+      continue;
+    }
+    const after = readFileSync18(filePath, "utf8");
+    const before = typeof file2.before === "string" ? file2.before : reconstructBeforeContent(after, file2.patch);
+    edits.push({
+      filePath,
+      after,
+      ...typeof before === "string" ? { before } : {}
+    });
+  }
+  return edits;
+}
+
 // src/hooks/comment-checker/pending-calls.ts
 var pendingCalls = new Map;
 var PENDING_CALL_TTL = 60000;
@@ -35761,10 +36690,11 @@ function createCommentCheckerHooks(config2) {
       }
       const ApplyPatchMetadataSchema = zod_default.object({
         files: zod_default.array(zod_default.object({
-          filePath: zod_default.string(),
+          filePath: zod_default.string().optional(),
           movePath: zod_default.string().optional(),
-          before: zod_default.string(),
-          after: zod_default.string(),
+          before: zod_default.string().optional(),
+          after: zod_default.string().optional(),
+          patch: zod_default.string().optional(),
           type: zod_default.string().optional()
         }))
       });
@@ -35774,11 +36704,7 @@ function createCommentCheckerHooks(config2) {
           debugLog3("apply_patch metadata schema mismatch, skipping");
           return;
         }
-        const edits = parsed.data.files.filter((f) => f.type !== "delete").map((f) => ({
-          filePath: f.movePath ?? f.filePath,
-          before: f.before,
-          after: f.after
-        }));
+        const edits = resolveApplyPatchEdits(parsed.data.files, debugLog3);
         if (edits.length === 0) {
           debugLog3("apply_patch had no editable files, skipping");
           return;
@@ -35859,11 +36785,11 @@ function createToolOutputTruncatorHook(ctx, options) {
   };
 }
 // src/hooks/directory-agents-injector/injector.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { dirname as dirname3 } from "path";
 
 // src/hooks/directory-agents-injector/finder.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { dirname as dirname2, isAbsolute as isAbsolute2, join as join31, resolve as resolve2 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
@@ -35886,7 +36812,7 @@ function findAgentsMdUp(input) {
     const isRootDir = current === input.rootDir;
     if (!isRootDir) {
       const agentsPath = join31(current, AGENTS_FILENAME);
-      if (existsSync28(agentsPath)) {
+      if (existsSync29(agentsPath)) {
         found.push(agentsPath);
       }
     }
@@ -35904,9 +36830,9 @@ function findAgentsMdUp(input) {
 
 // src/shared/session-injected-paths.ts
 import {
-  existsSync as existsSync29,
+  existsSync as existsSync30,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync8
 } from "fs";
@@ -35915,10 +36841,10 @@ function createInjectedPathsStorage(storageDir) {
   const getStoragePath = (sessionID) => join32(storageDir, `${sessionID}.json`);
   const loadInjectedPaths = (sessionID) => {
     const filePath = getStoragePath(sessionID);
-    if (!existsSync29(filePath))
+    if (!existsSync30(filePath))
       return new Set;
     try {
-      const content = readFileSync18(filePath, "utf-8");
+      const content = readFileSync19(filePath, "utf-8");
       const data = JSON.parse(content);
       return new Set(data.injectedPaths);
     } catch {
@@ -35926,7 +36852,7 @@ function createInjectedPathsStorage(storageDir) {
     }
   };
   const saveInjectedPaths = (sessionID, paths) => {
-    if (!existsSync29(storageDir)) {
+    if (!existsSync30(storageDir)) {
       mkdirSync7(storageDir, { recursive: true });
     }
     const data = {
@@ -35938,7 +36864,7 @@ function createInjectedPathsStorage(storageDir) {
   };
   const clearInjectedPaths = (sessionID) => {
     const filePath = getStoragePath(sessionID);
-    if (existsSync29(filePath)) {
+    if (existsSync30(filePath)) {
       unlinkSync3(filePath);
     }
   };
@@ -35976,7 +36902,7 @@ async function processFilePathForAgentsInjection(input) {
     if (cache.has(agentsDir))
       continue;
     try {
-      const content = readFileSync19(agentsPath, "utf-8");
+      const content = readFileSync20(agentsPath, "utf-8");
       const { result, truncated } = await input.truncator.truncate(input.sessionID, content);
       const truncationNotice = truncated ? `
 
@@ -36037,11 +36963,11 @@ function createDirectoryAgentsInjectorHook(ctx, modelCacheState) {
   };
 }
 // src/hooks/directory-readme-injector/injector.ts
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { dirname as dirname5 } from "path";
 
 // src/hooks/directory-readme-injector/finder.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { dirname as dirname4, isAbsolute as isAbsolute3, join as join34, resolve as resolve3 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
@@ -36062,7 +36988,7 @@ function findReadmeMdUp(input) {
   let current = input.startDir;
   while (true) {
     const readmePath = join34(current, README_FILENAME);
-    if (existsSync30(readmePath)) {
+    if (existsSync31(readmePath)) {
       found.push(readmePath);
     }
     if (current === input.rootDir)
@@ -36104,7 +37030,7 @@ async function processFilePathForReadmeInjection(input) {
     if (cache.has(readmeDir))
       continue;
     try {
-      const content = readFileSync20(readmePath, "utf-8");
+      const content = readFileSync21(readmePath, "utf-8");
       const { result, truncated } = await input.truncator.truncate(input.sessionID, content);
       const truncationNotice = truncated ? `
 
@@ -36419,14 +37345,14 @@ function incrementEmptyContentAttempt(autoCompactState, sessionID) {
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/tool-result-storage.ts
-import { existsSync as existsSync32, readdirSync as readdirSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync33, readdirSync as readdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync9 } from "fs";
 import { join as join35 } from "path";
 
 // src/hooks/anthropic-context-window-limit-recovery/message-storage-directory.ts
-import { existsSync as existsSync31, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync10 } from "fs";
 function getMessageIds(sessionID) {
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync31(messageDir))
+  if (!messageDir || !existsSync32(messageDir))
     return [];
   const messageIds = [];
   for (const file2 of readdirSync10(messageDir)) {
@@ -36449,14 +37375,14 @@ function findToolResultsBySize(sessionID) {
   const results = [];
   for (const messageID of messageIds) {
     const partDir = join35(PART_STORAGE, messageID);
-    if (!existsSync32(partDir))
+    if (!existsSync33(partDir))
       continue;
     for (const file2 of readdirSync11(partDir)) {
       if (!file2.endsWith(".json"))
         continue;
       try {
         const partPath = join35(partDir, file2);
-        const content = readFileSync21(partPath, "utf-8");
+        const content = readFileSync22(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type === "tool" && part.state?.output && !part.truncated) {
           results.push({
@@ -36483,7 +37409,7 @@ function truncateToolResult(partPath) {
     return { success: false };
   }
   try {
-    const content = readFileSync21(partPath, "utf-8");
+    const content = readFileSync22(partPath, "utf-8");
     const part = JSON.parse(content);
     if (!part.state?.output) {
       return { success: false };
@@ -37250,7 +38176,7 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync22 } from "fs";
+import { readdirSync as readdirSync12, readFileSync as readFileSync23 } from "fs";
 import { join as join36 } from "path";
 
 // src/hooks/anthropic-context-window-limit-recovery/pruning-types.ts
@@ -37287,7 +38213,7 @@ function readMessages2(sessionID) {
   try {
     const files = readdirSync12(messageDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const content = readFileSync22(join36(messageDir, file2), "utf-8");
+      const content = readFileSync23(join36(messageDir, file2), "utf-8");
       const data = JSON.parse(content);
       if (data.parts) {
         messages.push(data);
@@ -37392,7 +38318,7 @@ function findToolOutput(messages, callID) {
 }
 
 // src/hooks/anthropic-context-window-limit-recovery/pruning-tool-output-truncation.ts
-import { existsSync as existsSync33, readdirSync as readdirSync13, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync34, readdirSync as readdirSync13, readFileSync as readFileSync24 } from "fs";
 import { join as join37 } from "path";
 init_logger();
 function getPartStorage() {
@@ -37422,14 +38348,14 @@ async function truncateToolOutputsByCallId(sessionID, callIds, client) {
   let truncatedCount = 0;
   for (const messageID of messageIds) {
     const partDir = join37(getPartStorage(), messageID);
-    if (!existsSync33(partDir))
+    if (!existsSync34(partDir))
       continue;
     for (const file2 of readdirSync13(partDir)) {
       if (!file2.endsWith(".json"))
         continue;
       const partPath = join37(partDir, file2);
       try {
-        const content = readFileSync23(partPath, "utf-8");
+        const content = readFileSync24(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type !== "tool" || !part.callID)
           continue;
@@ -37812,7 +38738,7 @@ function createThinkModeHook() {
         return;
       }
       state3.requested = true;
-      if (typeof output.message.variant === "string") {
+      if (getUserMessageVariant(output.message) !== undefined) {
         thinkModeState.set(sessionID, state3);
         return;
       }
@@ -37827,7 +38753,7 @@ function createThinkModeHook() {
         thinkModeState.set(sessionID, state3);
         return;
       }
-      output.message.variant = "high";
+      setUserMessageVariant(output.message, "high");
       state3.modelSwitched = false;
       state3.variantSet = true;
       log("Think mode: variant set to high", { sessionID });
@@ -38240,9 +39166,9 @@ function createModelFallbackHook(args) {
         modelID: fallback.modelID
       };
       if (fallback.variant !== undefined) {
-        output.message["variant"] = fallback.variant;
+        setUserMessageVariant(output.message, fallback.variant);
       } else {
-        delete output.message["variant"];
+        clearUserMessageVariant(output.message);
       }
       if (toast) {
         const key = `${sessionID}:${fallback.providerID}/${fallback.modelID}:${fallback.variant ?? ""}`;
@@ -38279,7 +39205,7 @@ function createModelFallbackHook(args) {
 }
 // src/hooks/claude-code-hooks/config.ts
 import { join as join38 } from "path";
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -38309,7 +39235,7 @@ function getClaudeSettingsPaths(customPath) {
     join38(process.cwd(), ".claude", "settings.json"),
     join38(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync34(customPath)) {
+  if (customPath && existsSync35(customPath)) {
     paths.unshift(customPath);
   }
   return [...new Set(paths)];
@@ -38334,7 +39260,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync34(settingsPath)) {
+    if (existsSync35(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -38352,14 +39278,14 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 
 // src/hooks/claude-code-hooks/config-loader.ts
 init_logger();
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import { join as join39 } from "path";
 var USER_CONFIG_PATH = join39(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
 function getProjectConfigPath() {
   return join39(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path5) {
-  if (!existsSync35(path5)) {
+  if (!existsSync36(path5)) {
     return null;
   }
   try {
@@ -38586,7 +39512,7 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 
 // src/hooks/claude-code-hooks/transcript.ts
 import { join as join40 } from "path";
-import { mkdirSync as mkdirSync8, appendFileSync as appendFileSync5, existsSync as existsSync36, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
+import { mkdirSync as mkdirSync8, appendFileSync as appendFileSync5, existsSync as existsSync37, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
 var TRANSCRIPT_DIR = join40(getClaudeConfigDir(), "transcripts");
@@ -38594,7 +39520,7 @@ function getTranscriptPath(sessionId) {
   return join40(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync36(TRANSCRIPT_DIR)) {
+  if (!existsSync37(TRANSCRIPT_DIR)) {
     mkdirSync8(TRANSCRIPT_DIR, { recursive: true });
   }
 }
@@ -39529,9 +40455,9 @@ function getRuleInjectionFilePath(output) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync37,
+  existsSync as existsSync38,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync25,
   writeFileSync as writeFileSync11,
   unlinkSync as unlinkSync5
 } from "fs";
@@ -39567,10 +40493,10 @@ function getStoragePath(sessionID) {
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync37(filePath))
+  if (!existsSync38(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync24(filePath, "utf-8");
+    const content = readFileSync25(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -39581,7 +40507,7 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync37(RULES_INJECTOR_STORAGE)) {
+  if (!existsSync38(RULES_INJECTOR_STORAGE)) {
     mkdirSync9(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
@@ -39594,7 +40520,7 @@ function saveInjectedRules(sessionID, data) {
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync37(filePath)) {
+  if (existsSync38(filePath)) {
     unlinkSync5(filePath);
   }
 }
@@ -39616,12 +40542,12 @@ function createSessionCacheStore() {
 }
 
 // src/hooks/rules-injector/injector.ts
-import { readFileSync as readFileSync25, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync26, statSync as statSync4 } from "fs";
 import { homedir as homedir8 } from "os";
 import { relative as relative2, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/project-root-finder.ts
-import { existsSync as existsSync38, statSync as statSync2 } from "fs";
+import { existsSync as existsSync39, statSync as statSync2 } from "fs";
 import { dirname as dirname6, join as join44 } from "path";
 function findProjectRoot(startPath) {
   let current;
@@ -39634,7 +40560,7 @@ function findProjectRoot(startPath) {
   while (true) {
     for (const marker of PROJECT_MARKERS) {
       const markerPath = join44(current, marker);
-      if (existsSync38(markerPath)) {
+      if (existsSync39(markerPath)) {
         return current;
       }
     }
@@ -39646,11 +40572,11 @@ function findProjectRoot(startPath) {
   }
 }
 // src/hooks/rules-injector/rule-file-finder.ts
-import { existsSync as existsSync40, statSync as statSync3 } from "fs";
+import { existsSync as existsSync41, statSync as statSync3 } from "fs";
 import { dirname as dirname7, join as join46 } from "path";
 
 // src/hooks/rules-injector/rule-file-scanner.ts
-import { existsSync as existsSync39, readdirSync as readdirSync14, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync40, readdirSync as readdirSync14, realpathSync as realpathSync2 } from "fs";
 import { join as join45 } from "path";
 function isGitHubInstructionsDir(dir) {
   return dir.includes(".github/instructions") || dir.endsWith(".github/instructions");
@@ -39662,7 +40588,7 @@ function isValidRuleFile(fileName, dir) {
   return RULE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync39(dir))
+  if (!existsSync40(dir))
     return;
   try {
     const entries = readdirSync14(dir, { withFileTypes: true });
@@ -39721,7 +40647,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   if (projectRoot) {
     for (const ruleFile of PROJECT_RULE_FILES) {
       const filePath = join46(projectRoot, ruleFile);
-      if (existsSync40(filePath)) {
+      if (existsSync41(filePath)) {
         try {
           const stat = statSync3(filePath);
           if (stat.isFile()) {
@@ -39936,7 +40862,7 @@ function getCachedParsedRule(filePath, realPath) {
     if (cached2 && cached2.mtimeMs === stat.mtimeMs && cached2.size === stat.size) {
       return { metadata: cached2.metadata, body: cached2.body };
     }
-    const rawContent = readFileSync25(filePath, "utf-8");
+    const rawContent = readFileSync26(filePath, "utf-8");
     const { metadata, body } = parseRuleFrontmatter(rawContent);
     parsedRuleCache.set(realPath, {
       mtimeMs: stat.mtimeMs,
@@ -39946,7 +40872,7 @@ function getCachedParsedRule(filePath, realPath) {
     });
     return { metadata, body };
   } catch {
-    const rawContent = readFileSync25(filePath, "utf-8");
+    const rawContent = readFileSync26(filePath, "utf-8");
     return parseRuleFrontmatter(rawContent);
   }
 }
@@ -40444,7 +41370,7 @@ function spawnWithWindowsHide(command, options) {
   return wrapNodeProcess(proc);
 }
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 init_logger();
 var BUN_INSTALL_TIMEOUT_SECONDS = 60;
 var BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000;
@@ -40472,7 +41398,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "inherit";
   const cacheDir = getOpenCodeCacheDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync46(packageJsonPath)) {
+  if (!existsSync47(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -40861,9 +41787,9 @@ v${latestVersion} available. Restart OpenCode to apply.` : "DrizzyAgent is activ
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync48,
+  existsSync as existsSync49,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync34,
   writeFileSync as writeFileSync14,
   unlinkSync as unlinkSync8
 } from "fs";
@@ -40921,17 +41847,17 @@ function getStoragePath2(sessionID) {
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync48(filePath))
+  if (!existsSync49(filePath))
     return null;
   try {
-    const content = readFileSync33(filePath, "utf-8");
+    const content = readFileSync34(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveAgentUsageState(state3) {
-  if (!existsSync48(AGENT_USAGE_REMINDER_STORAGE)) {
+  if (!existsSync49(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync10(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath2(state3.sessionID);
@@ -40939,7 +41865,7 @@ function saveAgentUsageState(state3) {
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync48(filePath)) {
+  if (existsSync49(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -42032,10 +42958,7 @@ function extractPromptText2(parts) {
 // src/hooks/keyword-detector/hook.ts
 function createKeywordDetectorHook(ctx, _collector) {
   function getRuntimeVariant(input, message) {
-    if (typeof message["variant"] === "string") {
-      return message["variant"];
-    }
-    return typeof input.variant === "string" ? input.variant : undefined;
+    return getUserMessageVariant(message) ?? getInputVariant(input);
   }
   return {
     "chat.message": async (input, output) => {
@@ -42215,9 +43138,9 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync49,
+  existsSync as existsSync50,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   writeFileSync as writeFileSync15,
   unlinkSync as unlinkSync9
 } from "fs";
@@ -42241,10 +43164,10 @@ function getStoragePath3(sessionID) {
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync49(filePath))
+  if (!existsSync50(filePath))
     return null;
   try {
-    const content = readFileSync34(filePath, "utf-8");
+    const content = readFileSync35(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -42256,7 +43179,7 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state3) {
-  if (!existsSync49(INTERACTIVE_BASH_SESSION_STORAGE)) {
+  if (!existsSync50(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync11(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath3(state3.sessionID);
@@ -42269,7 +43192,7 @@ function saveInteractiveBashSessionState(state3) {
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync49(filePath)) {
+  if (existsSync50(filePath)) {
     unlinkSync9(filePath);
   }
 }
@@ -42666,18 +43589,18 @@ var DEFAULT_MAX_ITERATIONS = 100;
 var DEFAULT_COMPLETION_PROMISE = "DONE";
 var ULTRAWORK_VERIFICATION_PROMISE = "VERIFIED";
 // src/hooks/ralph-loop/storage.ts
-import { existsSync as existsSync50, readFileSync as readFileSync35, writeFileSync as writeFileSync16, unlinkSync as unlinkSync10, mkdirSync as mkdirSync12 } from "fs";
+import { existsSync as existsSync51, readFileSync as readFileSync36, writeFileSync as writeFileSync16, unlinkSync as unlinkSync10, mkdirSync as mkdirSync12 } from "fs";
 import { dirname as dirname10, join as join56 } from "path";
 function getStateFilePath(directory, customPath) {
   return customPath ? join56(directory, customPath) : join56(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync50(filePath)) {
+  if (!existsSync51(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync35(filePath, "utf-8");
+    const content = readFileSync36(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -42719,7 +43642,7 @@ function writeState(directory, state3, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname10(filePath);
-    if (!existsSync50(dir)) {
+    if (!existsSync51(dir)) {
       mkdirSync12(dir, { recursive: true });
     }
     const sessionIdLine = state3.session_id ? `session_id: "${state3.session_id}"
@@ -42757,7 +43680,7 @@ ${state3.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync50(filePath)) {
+    if (existsSync51(filePath)) {
       unlinkSync10(filePath);
     }
     return true;
@@ -43086,7 +44009,7 @@ async function handleDetectedCompletion(ctx, input) {
 
 // src/hooks/ralph-loop/completion-promise-detector.ts
 init_logger();
-import { existsSync as existsSync51, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync37 } from "fs";
 function escapeRegex2(str2) {
   return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -43097,9 +44020,9 @@ function detectCompletionInTranscript(transcriptPath, promise2, startedAt) {
   if (!transcriptPath)
     return false;
   try {
-    if (!existsSync51(transcriptPath))
+    if (!existsSync52(transcriptPath))
       return false;
-    const content = readFileSync36(transcriptPath, "utf-8");
+    const content = readFileSync37(transcriptPath, "utf-8");
     const pattern = buildPromisePattern(promise2);
     const lines = content.split(`
 `).filter((line) => line.trim());
@@ -43888,7 +44811,7 @@ function findSlashCommandPartIndex(parts) {
   return -1;
 }
 // src/hooks/auto-slash-command/executor.ts
-import { existsSync as existsSync53, readdirSync as readdirSync15, readFileSync as readFileSync39 } from "fs";
+import { existsSync as existsSync54, readdirSync as readdirSync15, readFileSync as readFileSync40 } from "fs";
 import { join as join61, basename as basename4, dirname as dirname13 } from "path";
 // src/features/builtin-commands/templates/init-deep.ts
 var INIT_DEEP_TEMPLATE = `# /init-deep
@@ -45601,7 +46524,7 @@ function builtinToLoadedSkill(builtin) {
 }
 
 // src/features/opencode-skill-loader/merger/config-skill-entry-loader.ts
-import { existsSync as existsSync52, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync38 } from "fs";
 import { dirname as dirname11, isAbsolute as isAbsolute4, resolve as resolve5 } from "path";
 import { homedir as homedir12 } from "os";
 function resolveFilePath5(from, configDir) {
@@ -45620,9 +46543,9 @@ function resolveFilePath5(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync52(filePath))
+    if (!existsSync53(filePath))
       return null;
-    const content = readFileSync37(filePath, "utf-8");
+    const content = readFileSync38(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -47992,10 +48915,10 @@ async function getAllSkills(options) {
   return allSkills;
 }
 // src/features/opencode-skill-loader/loaded-skill-template-extractor.ts
-import { readFileSync as readFileSync38 } from "fs";
+import { readFileSync as readFileSync39 } from "fs";
 function extractSkillTemplate(skill) {
   if (skill.path) {
-    const content = readFileSync38(skill.path, "utf-8");
+    const content = readFileSync39(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -48703,7 +49626,7 @@ async function discoverConfigSourceSkills(options) {
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync53(commandsDir)) {
+  if (!existsSync54(commandsDir)) {
     return [];
   }
   const entries = readdirSync15(commandsDir, { withFileTypes: true });
@@ -48714,7 +49637,7 @@ function discoverCommandsFromDir(commandsDir, scope) {
     const commandPath = join61(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync39(commandPath, "utf-8");
+      const content = readFileSync40(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -49151,18 +50074,18 @@ var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 var PLANNER_PLANS_DIR = ".drizzy/plans";
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync54, readFileSync as readFileSync40, writeFileSync as writeFileSync17, mkdirSync as mkdirSync13, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync55, readFileSync as readFileSync41, writeFileSync as writeFileSync17, mkdirSync as mkdirSync13, readdirSync as readdirSync16 } from "fs";
 import { dirname as dirname14, join as join62, basename as basename5 } from "path";
 function getBoulderFilePath(directory) {
   return join62(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync54(filePath)) {
+  if (!existsSync55(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync40(filePath, "utf-8");
+    const content = readFileSync41(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -49179,7 +50102,7 @@ function writeBoulderState(directory, state3) {
   const filePath = getBoulderFilePath(directory);
   try {
     const dir = dirname14(filePath);
-    if (!existsSync54(dir)) {
+    if (!existsSync55(dir)) {
       mkdirSync13(dir, { recursive: true });
     }
     writeFileSync17(filePath, JSON.stringify(state3, null, 2), "utf-8");
@@ -49206,7 +50129,7 @@ function appendSessionId(directory, sessionId) {
 function clearBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
   try {
-    if (existsSync54(filePath)) {
+    if (existsSync55(filePath)) {
       const { unlinkSync: unlinkSync11 } = __require("fs");
       unlinkSync11(filePath);
     }
@@ -49217,7 +50140,7 @@ function clearBoulderState(directory) {
 }
 function findPlannerPlans(directory) {
   const plansDir = join62(directory, PLANNER_PLANS_DIR);
-  if (!existsSync54(plansDir)) {
+  if (!existsSync55(plansDir)) {
     return [];
   }
   try {
@@ -49232,11 +50155,11 @@ function findPlannerPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync54(planPath)) {
+  if (!existsSync55(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync40(planPath, "utf-8");
+    const content = readFileSync41(planPath, "utf-8");
     const uncheckedMatches = content.match(/^\s*[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^\s*[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
@@ -53177,7 +54100,7 @@ function createRuntimeFallbackHook(ctx, options) {
   };
 }
 // src/hooks/write-existing-file-guard/hook.ts
-import { existsSync as existsSync56, realpathSync as realpathSync4 } from "fs";
+import { existsSync as existsSync57, realpathSync as realpathSync4 } from "fs";
 import { basename as basename6, dirname as dirname15, isAbsolute as isAbsolute8, join as join64, normalize, relative as relative6, resolve as resolve8 } from "path";
 var MAX_TRACKED_SESSIONS = 256;
 var MAX_TRACKED_PATHS_PER_SESSION = 1024;
@@ -53199,7 +54122,7 @@ function isPathInsideDirectory(pathToCheck, directory) {
 }
 function toCanonicalPath(absolutePath) {
   let canonicalPath = absolutePath;
-  if (existsSync56(absolutePath)) {
+  if (existsSync57(absolutePath)) {
     try {
       canonicalPath = realpathSync4.native(absolutePath);
     } catch {
@@ -53207,7 +54130,7 @@ function toCanonicalPath(absolutePath) {
     }
   } else {
     const absoluteDir = dirname15(absolutePath);
-    const resolvedDir = existsSync56(absoluteDir) ? realpathSync4.native(absoluteDir) : absoluteDir;
+    const resolvedDir = existsSync57(absoluteDir) ? realpathSync4.native(absoluteDir) : absoluteDir;
     canonicalPath = join64(resolvedDir, basename6(absolutePath));
   }
   return normalize(canonicalPath);
@@ -53308,7 +54231,7 @@ function createWriteExistingFileGuardHook(ctx) {
         return;
       }
       if (toolName === "read") {
-        if (!existsSync56(resolvedPath) || !input.sessionID) {
+        if (!existsSync57(resolvedPath) || !input.sessionID) {
           return;
         }
         registerReadPermission(input.sessionID, canonicalPath);
@@ -53318,7 +54241,7 @@ function createWriteExistingFileGuardHook(ctx) {
       if (argsRecord && "overwrite" in argsRecord) {
         delete argsRecord.overwrite;
       }
-      if (!existsSync56(resolvedPath)) {
+      if (!existsSync57(resolvedPath)) {
         return;
       }
       const isCoderPath2 = canonicalPath.includes("/.drizzy/");
@@ -54125,7 +55048,7 @@ function createAnthropicEffortHook() {
       const { model, message } = input;
       if (!model?.modelID || !model?.providerID)
         return;
-      if (message.variant !== "max")
+      if (message.model?.variant !== "max")
         return;
       if (!isClaudeProvider(model.providerID, model.modelID))
         return;
@@ -54401,13 +55324,13 @@ var DEFAULT_MAX_SYMBOLS = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
 var DEFAULT_MAX_DIRECTORY_FILES = 50;
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync57, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync58, readFileSync as readFileSync43 } from "fs";
 import { join as join65 } from "path";
 function loadJsonFile(path12) {
-  if (!existsSync57(path12))
+  if (!existsSync58(path12))
     return null;
   try {
-    return parseJsonc(readFileSync42(path12, "utf-8"));
+    return parseJsonc(readFileSync43(path12, "utf-8"));
   } catch {
     return null;
   }
@@ -54487,7 +55410,7 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { delimiter, join as join67 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
@@ -54510,7 +55433,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync58(cmd))
+    if (existsSync59(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -54531,14 +55454,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync58(join67(p, cmd + suffix))) {
+      if (existsSync59(join67(p, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync58(join67(base, cmd + suffix))) {
+      if (existsSync59(join67(base, cmd + suffix))) {
         return true;
       }
     }
@@ -54596,13 +55519,13 @@ function getLanguageId(ext) {
 init_logger();
 var {spawn: bunSpawn2 } = globalThis.Bun;
 import { spawn as nodeSpawn2 } from "child_process";
-import { existsSync as existsSync59, statSync as statSync7 } from "fs";
+import { existsSync as existsSync60, statSync as statSync7 } from "fs";
 function shouldUseNodeSpawn() {
   return process.platform === "win32";
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync59(cwd)) {
+    if (!existsSync60(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
     const stats = statSync7(cwd);
@@ -54734,7 +55657,7 @@ function spawnProcess(command, options) {
   return proc;
 }
 // src/tools/lsp/lsp-client.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 import { extname as extname3, resolve as resolve9 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
@@ -55006,7 +55929,7 @@ class LSPClient extends LSPClientConnection {
   async openFile(filePath) {
     const absPath = resolve9(filePath);
     const uri = pathToFileURL2(absPath).href;
-    const text = readFileSync43(absPath, "utf-8");
+    const text = readFileSync44(absPath, "utf-8");
     if (!this.openedFiles.has(absPath)) {
       const ext = extname3(absPath);
       const languageId = getLanguageId(ext);
@@ -55347,9 +56270,9 @@ var lspManager = LSPServerManager.getInstance();
 // src/tools/lsp/lsp-client-wrapper.ts
 import { extname as extname4, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { existsSync as existsSync60, statSync as statSync8 } from "fs";
+import { existsSync as existsSync61, statSync as statSync8 } from "fs";
 function isDirectoryPath(filePath) {
-  if (!existsSync60(filePath)) {
+  if (!existsSync61(filePath)) {
     return false;
   }
   return statSync8(filePath).isDirectory();
@@ -55359,14 +56282,14 @@ function uriToPath(uri) {
 }
 function findWorkspaceRoot(filePath) {
   let dir = resolve10(filePath);
-  if (!existsSync60(dir) || !isDirectoryPath(dir)) {
+  if (!existsSync61(dir) || !isDirectoryPath(dir)) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync60(__require("path").join(dir, marker))) {
+      if (existsSync61(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -55541,10 +56464,10 @@ function formatApplyResult(result) {
 `);
 }
 // src/tools/lsp/workspace-edit.ts
-import { readFileSync as readFileSync44, writeFileSync as writeFileSync18 } from "fs";
+import { readFileSync as readFileSync45, writeFileSync as writeFileSync18 } from "fs";
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync44(filePath, "utf-8");
+    let content = readFileSync45(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -55610,7 +56533,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync44(oldPath, "utf-8");
+            const content = readFileSync45(oldPath, "utf-8");
             writeFileSync18(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
@@ -68093,7 +69016,7 @@ var lsp_symbols = tool({
 import { resolve as resolve12 } from "path";
 
 // src/tools/lsp/directory-diagnostics.ts
-import { existsSync as existsSync61, lstatSync as lstatSync2, readdirSync as readdirSync17 } from "fs";
+import { existsSync as existsSync62, lstatSync as lstatSync2, readdirSync as readdirSync17 } from "fs";
 import { extname as extname5, join as join68, resolve as resolve11 } from "path";
 var SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 function collectFilesWithExtension(dir, extension, maxFiles) {
@@ -68139,7 +69062,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     throw new Error(`Extension must start with a dot (e.g., ".ts", not "${extension}"). ` + `Use ".${extension}" instead.`);
   }
   const absDir = resolve11(directory);
-  if (!existsSync61(absDir)) {
+  if (!existsSync62(absDir)) {
     throw new Error(`Directory does not exist: ${absDir}`);
   }
   const serverResult = findServerForExtension(extension);
@@ -68342,10 +69265,10 @@ var DEFAULT_MAX_MATCHES = 500;
 // src/tools/ast-grep/sg-cli-path.ts
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname16, join as join70 } from "path";
-import { existsSync as existsSync63, statSync as statSync9 } from "fs";
+import { existsSync as existsSync64, statSync as statSync9 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
-import { existsSync as existsSync62 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import { join as join69 } from "path";
 import { homedir as homedir13 } from "os";
 import { createRequire as createRequire3 } from "module";
@@ -68396,7 +69319,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
   const binaryPath = join69(cacheDir, binaryName);
-  if (existsSync62(binaryPath)) {
+  if (existsSync63(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -68459,7 +69382,7 @@ function findSgCliPathSync() {
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDirectory = dirname16(cliPackageJsonPath);
     const sgPath = join70(cliDirectory, binaryName);
-    if (existsSync63(sgPath) && isValidBinary(sgPath)) {
+    if (existsSync64(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -68471,7 +69394,7 @@ function findSgCliPathSync() {
       const packageDirectory = dirname16(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join70(packageDirectory, astGrepBinaryName);
-      if (existsSync63(binaryPath) && isValidBinary(binaryPath)) {
+      if (existsSync64(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -68479,7 +69402,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path12 of homebrewPaths) {
-      if (existsSync63(path12) && isValidBinary(path12)) {
+      if (existsSync64(path12) && isValidBinary(path12)) {
         return path12;
       }
     }
@@ -68503,14 +69426,14 @@ function setSgCliPath(path12) {
 }
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn10 } = globalThis.Bun;
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 
 // src/tools/ast-grep/cli-binary-path-resolution.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise3 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync64(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync65(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise3) {
@@ -68518,7 +69441,7 @@ async function getAstGrepPath() {
   }
   initPromise3 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync64(syncPath)) {
+    if (syncPath && existsSync65(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -68617,7 +69540,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!cliPath || !existsSync65(cliPath)) {
+  if (!cliPath || !existsSync66(cliPath)) {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -68871,12 +69794,12 @@ import { resolve as resolve13 } from "path";
 var {spawn: spawn11 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import { join as join72, dirname as dirname17 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync66, readdirSync as readdirSync18 } from "fs";
+import { existsSync as existsSync67, readdirSync as readdirSync18 } from "fs";
 import { join as join71 } from "path";
 function findFileRecursive(dir, filename) {
   try {
@@ -68940,7 +69863,7 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync66(rgPath)) {
+  if (existsSync67(rgPath)) {
     return rgPath;
   }
   ensureCacheDir(installDir);
@@ -68955,7 +69878,7 @@ async function downloadAndInstallRipgrep() {
       await extractZip2(archivePath, installDir);
     }
     ensureExecutable(rgPath);
-    if (!existsSync66(rgPath)) {
+    if (!existsSync67(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
@@ -68967,7 +69890,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync66(rgPath) ? rgPath : null;
+  return existsSync67(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -68998,7 +69921,7 @@ function getOpenCodeBundledRg() {
     join72(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync67(candidate)) {
+    if (existsSync68(candidate)) {
       return candidate;
     }
   }
@@ -69637,10 +70560,10 @@ Use this when a task matches an available skill's or command's description.
 // src/tools/skill/tools.ts
 import { dirname as dirname19 } from "path";
 // src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync68, readdirSync as readdirSync19, readFileSync as readFileSync45 } from "fs";
+import { existsSync as existsSync69, readdirSync as readdirSync19, readFileSync as readFileSync46 } from "fs";
 import { basename as basename7, join as join73 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync68(commandsDir))
+  if (!existsSync69(commandsDir))
     return [];
   const entries = readdirSync19(commandsDir, { withFileTypes: true });
   const commands3 = [];
@@ -69650,7 +70573,7 @@ function discoverCommandsFromDir2(commandsDir, scope) {
     const commandPath = join73(commandsDir, entry.name);
     const commandName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync45(commandPath, "utf-8");
+      const content = readFileSync46(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -70105,7 +71028,7 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync69 } from "fs";
+import { existsSync as existsSync70 } from "fs";
 import { readdir, readFile } from "fs/promises";
 import { join as join75 } from "path";
 var sdkClient = null;
@@ -70126,7 +71049,7 @@ async function getMainSessions(options) {
       return [];
     }
   }
-  if (!existsSync69(SESSION_STORAGE))
+  if (!existsSync70(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -70167,7 +71090,7 @@ async function getAllSessions() {
       return [];
     }
   }
-  if (!existsSync69(MESSAGE_STORAGE))
+  if (!existsSync70(MESSAGE_STORAGE))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -70236,7 +71159,7 @@ async function readSessionMessages(sessionID) {
     }
   }
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync69(messageDir))
+  if (!messageDir || !existsSync70(messageDir))
     return [];
   const messages = [];
   try {
@@ -70272,7 +71195,7 @@ async function readSessionMessages(sessionID) {
 }
 async function readParts2(messageID) {
   const partDir = join75(PART_STORAGE, messageID);
-  if (!existsSync69(partDir))
+  if (!existsSync70(partDir))
     return [];
   const parts = [];
   try {
@@ -70307,7 +71230,7 @@ async function readSessionTodos(sessionID) {
       return [];
     }
   }
-  if (!existsSync69(TODO_DIR2))
+  if (!existsSync70(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR2);
@@ -70334,10 +71257,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync69(TRANSCRIPT_DIR2))
+  if (!existsSync70(TRANSCRIPT_DIR2))
     return 0;
   const transcriptFile = join75(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync69(transcriptFile))
+  if (!existsSync70(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -72186,7 +73109,7 @@ async function resolveMultimodalLookerAgentMetadata(ctx) {
 
 // src/tools/look-at/image-converter.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync70, mkdtempSync, readFileSync as readFileSync46, rmSync as rmSync3, unlinkSync as unlinkSync11, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync71, mkdtempSync, readFileSync as readFileSync47, rmSync as rmSync3, unlinkSync as unlinkSync11, writeFileSync as writeFileSync19 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { dirname as dirname20, join as join76 } from "path";
 var SUPPORTED_FORMATS = new Set([
@@ -72226,7 +73149,7 @@ function needsConversion(mimeType) {
   return mimeType.startsWith("image/");
 }
 function convertImageToJpeg(inputPath, mimeType) {
-  if (!existsSync70(inputPath)) {
+  if (!existsSync71(inputPath)) {
     throw new Error(`File not found: ${inputPath}`);
   }
   const tempDir = mkdtempSync(join76(tmpdir6(), "opencode-img-"));
@@ -72240,7 +73163,7 @@ function convertImageToJpeg(inputPath, mimeType) {
           encoding: "utf-8",
           timeout: CONVERSION_TIMEOUT_MS
         });
-        if (existsSync70(outputPath)) {
+        if (existsSync71(outputPath)) {
           log(`[image-converter] Converted using sips: ${outputPath}`);
           return outputPath;
         }
@@ -72255,7 +73178,7 @@ function convertImageToJpeg(inputPath, mimeType) {
         encoding: "utf-8",
         timeout: CONVERSION_TIMEOUT_MS
       });
-      if (existsSync70(outputPath)) {
+      if (existsSync71(outputPath)) {
         log(`[image-converter] Converted using ImageMagick: ${outputPath}`);
         return outputPath;
       }
@@ -72268,7 +73191,7 @@ function convertImageToJpeg(inputPath, mimeType) {
 ` + `  RHEL/CentOS: sudo yum install ImageMagick`);
   } catch (error92) {
     try {
-      if (existsSync70(outputPath)) {
+      if (existsSync71(outputPath)) {
         unlinkSync11(outputPath);
       }
     } catch {}
@@ -72282,11 +73205,11 @@ function convertImageToJpeg(inputPath, mimeType) {
 function cleanupConvertedImage(filePath) {
   try {
     const tempDirectory = dirname20(filePath);
-    if (existsSync70(filePath)) {
+    if (existsSync71(filePath)) {
       unlinkSync11(filePath);
       log(`[image-converter] Cleaned up temporary file: ${filePath}`);
     }
-    if (existsSync70(tempDirectory)) {
+    if (existsSync71(tempDirectory)) {
       rmSync3(tempDirectory, { recursive: true, force: true });
       log(`[image-converter] Cleaned up temporary directory: ${tempDirectory}`);
     }
@@ -72306,14 +73229,14 @@ function convertBase64ImageToJpeg(base64Data, mimeType) {
     log(`[image-converter] Converting Base64 ${mimeType} to JPEG`);
     const outputPath = convertImageToJpeg(inputPath, mimeType);
     tempFiles.push(outputPath);
-    const convertedBuffer = readFileSync46(outputPath);
+    const convertedBuffer = readFileSync47(outputPath);
     const convertedBase64 = convertedBuffer.toString("base64");
     log(`[image-converter] Base64 conversion successful`);
     return { base64: convertedBase64, tempFiles };
   } catch (error92) {
     tempFiles.forEach((file3) => {
       try {
-        if (existsSync70(file3))
+        if (existsSync71(file3))
           unlinkSync11(file3);
       } catch {}
     });
@@ -72476,8 +73399,12 @@ Original error: ${createResult.error}`;
                 { type: "text", text: prompt },
                 filePart
               ],
-              ...agentModel ? { model: { providerID: agentModel.providerID, modelID: agentModel.modelID } } : {},
-              ...agentVariant ? { variant: agentVariant } : {}
+              ...agentModel || agentVariant ? {
+                model: {
+                  ...agentModel ? { providerID: agentModel.providerID, modelID: agentModel.modelID } : {},
+                  ...agentVariant ? { variant: agentVariant } : {}
+                }
+              } : {}
             }
           });
         } catch (promptError) {
@@ -73692,8 +74619,12 @@ async function executeSyncContinuation(args, ctx, executorCtx, deps = syncContin
       path: { id: args.session_id },
       body: {
         ...resumeAgent !== undefined ? { agent: resumeAgent } : {},
-        ...resumeModel !== undefined ? { model: resumeModel } : {},
-        ...resumeVariant !== undefined ? { variant: resumeVariant } : {},
+        ...resumeModel !== undefined || resumeVariant !== undefined ? {
+          model: {
+            ...resumeModel ?? {},
+            ...resumeVariant !== undefined ? { variant: resumeVariant } : {}
+          }
+        } : {},
         tools,
         parts: [{ type: "text", text: effectivePrompt }]
       }
@@ -74070,8 +75001,13 @@ async function sendSyncPrompt(client2, input, deps = sendSyncPromptDeps) {
       system: input.systemContent,
       tools,
       parts: [createInternalAgentTextPart(effectivePrompt)],
-      ...input.categoryModel ? { model: { providerID: input.categoryModel.providerID, modelID: input.categoryModel.modelID } } : {},
-      ...input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}
+      ...input.categoryModel ? {
+        model: {
+          providerID: input.categoryModel.providerID,
+          modelID: input.categoryModel.modelID,
+          ...input.categoryModel.variant ? { variant: input.categoryModel.variant } : {}
+        }
+      } : {}
     }
   };
   try {
@@ -74981,7 +75917,7 @@ var TaskDeleteInputSchema = exports_external.object({
 
 // src/features/claude-tasks/storage.ts
 import { join as join77, dirname as dirname21, basename as basename9, isAbsolute as isAbsolute9 } from "path";
-import { existsSync as existsSync71, mkdirSync as mkdirSync14, readFileSync as readFileSync47, writeFileSync as writeFileSync20, renameSync as renameSync2, unlinkSync as unlinkSync12, readdirSync as readdirSync20 } from "fs";
+import { existsSync as existsSync72, mkdirSync as mkdirSync14, readFileSync as readFileSync48, writeFileSync as writeFileSync20, renameSync as renameSync2, unlinkSync as unlinkSync12, readdirSync as readdirSync20 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 function getTaskDir(config4 = {}) {
   const tasksConfig = config4.coder?.tasks;
@@ -75009,16 +75945,16 @@ function resolveTaskListId(config4 = {}) {
   return sanitizePathSegment(basename9(process.cwd()));
 }
 function ensureDir(dirPath) {
-  if (!existsSync71(dirPath)) {
+  if (!existsSync72(dirPath)) {
     mkdirSync14(dirPath, { recursive: true });
   }
 }
 function readJsonSafe(filePath, schema2) {
   try {
-    if (!existsSync71(filePath)) {
+    if (!existsSync72(filePath)) {
       return null;
     }
-    const content = readFileSync47(filePath, "utf-8");
+    const content = readFileSync48(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = schema2.safeParse(parsed);
     if (!result.success) {
@@ -75038,7 +75974,7 @@ function writeJsonAtomic(filePath, data) {
     renameSync2(tempPath, filePath);
   } catch (error92) {
     try {
-      if (existsSync71(tempPath)) {
+      if (existsSync72(tempPath)) {
         unlinkSync12(tempPath);
       }
     } catch {}
@@ -75060,7 +75996,7 @@ function acquireLock(dirPath) {
   };
   const isStale = () => {
     try {
-      const lockContent = readFileSync47(lockPath, "utf-8");
+      const lockContent = readFileSync48(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -75098,9 +76034,9 @@ function acquireLock(dirPath) {
     acquired: true,
     release: () => {
       try {
-        if (!existsSync71(lockPath))
+        if (!existsSync72(lockPath))
           return;
-        const lockContent = readFileSync47(lockPath, "utf-8");
+        const lockContent = readFileSync48(lockPath, "utf-8");
         const lockData = JSON.parse(lockContent);
         if (lockData.id !== lockId)
           return;
@@ -75324,7 +76260,7 @@ Returns null if the task does not exist or the file is invalid.`,
 }
 // src/tools/task/task-list.ts
 import { join as join80 } from "path";
-import { existsSync as existsSync72, readdirSync as readdirSync21 } from "fs";
+import { existsSync as existsSync73, readdirSync as readdirSync21 } from "fs";
 function createTaskList(config4) {
   return tool({
     description: `List all active tasks with summary information.
@@ -75335,7 +76271,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
     args: {},
     execute: async () => {
       const taskDir = getTaskDir(config4);
-      if (!existsSync72(taskDir)) {
+      if (!existsSync73(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
       const files = readdirSync21(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
@@ -76105,445 +77041,6 @@ function applyHashlineEditsWithReport(content, edits) {
     deduplicatedEdits: dedupeResult.deduplicatedEdits
   };
 }
-// node_modules/diff/libesm/diff/base.js
-class Diff {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a2;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a2 = options.timeout) !== null && _a2 !== undefined ? _a2 : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = undefined;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = undefined;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
-    };
-    if (callback) {
-      (function exec2() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(undefined);
-          }
-          if (!execEditLength()) {
-            exec2();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  }
-  addToPath(path12, added, removed, oldPosInc, options) {
-    const last = path12.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path12.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path12.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array3) {
-    const ret = [];
-    for (let i2 = 0;i2 < array3.length; i2++) {
-      if (array3[i2]) {
-        ret.push(array3[i2]);
-      }
-    }
-    return ret;
-  }
-  castInput(value, options) {
-    return value;
-  }
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (;componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i2) {
-            const oldValue = oldTokens[oldPos + i2];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
-        }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
-    }
-    return components;
-  }
-}
-
-// node_modules/diff/libesm/diff/line.js
-class LineDiff extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes(`
-`)) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes(`
-`)) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith(`
-`)) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith(`
-`)) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
-  }
-}
-var lineDiff = new LineDiff;
-function diffLines(oldStr, newStr, options) {
-  return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, `
-`);
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i2 = 0;i2 < linesAndNewlines.length; i2++) {
-    const line = linesAndNewlines[i2];
-    if (i2 % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
-  }
-  return retLines;
-}
-
-// node_modules/diff/libesm/patch/create.js
-var INCLUDE_HEADERS = {
-  includeIndex: true,
-  includeUnderline: true,
-  includeFileHeaders: true
-};
-function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  let optionsObj;
-  if (!options) {
-    optionsObj = {};
-  } else if (typeof options === "function") {
-    optionsObj = { callback: options };
-  } else {
-    optionsObj = options;
-  }
-  if (typeof optionsObj.context === "undefined") {
-    optionsObj.context = 4;
-  }
-  const context = optionsObj.context;
-  if (optionsObj.newlineIsToken) {
-    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
-  }
-  if (!optionsObj.callback) {
-    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
-  } else {
-    const { callback } = optionsObj;
-    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
-      const patch = diffLinesResultToPatch(diff);
-      callback(patch);
-    } }));
-  }
-  function diffLinesResultToPatch(diff) {
-    if (!diff) {
-      return;
-    }
-    diff.push({ value: "", lines: [] });
-    function contextLines(lines) {
-      return lines.map(function(entry) {
-        return " " + entry;
-      });
-    }
-    const hunks = [];
-    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-    for (let i2 = 0;i2 < diff.length; i2++) {
-      const current = diff[i2], lines = current.lines || splitLines(current.value);
-      current.lines = lines;
-      if (current.added || current.removed) {
-        if (!oldRangeStart) {
-          const prev = diff[i2 - 1];
-          oldRangeStart = oldLine;
-          newRangeStart = newLine;
-          if (prev) {
-            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
-            oldRangeStart -= curRange.length;
-            newRangeStart -= curRange.length;
-          }
-        }
-        for (const line of lines) {
-          curRange.push((current.added ? "+" : "-") + line);
-        }
-        if (current.added) {
-          newLine += lines.length;
-        } else {
-          oldLine += lines.length;
-        }
-      } else {
-        if (oldRangeStart) {
-          if (lines.length <= context * 2 && i2 < diff.length - 2) {
-            for (const line of contextLines(lines)) {
-              curRange.push(line);
-            }
-          } else {
-            const contextSize = Math.min(lines.length, context);
-            for (const line of contextLines(lines.slice(0, contextSize))) {
-              curRange.push(line);
-            }
-            const hunk = {
-              oldStart: oldRangeStart,
-              oldLines: oldLine - oldRangeStart + contextSize,
-              newStart: newRangeStart,
-              newLines: newLine - newRangeStart + contextSize,
-              lines: curRange
-            };
-            hunks.push(hunk);
-            oldRangeStart = 0;
-            newRangeStart = 0;
-            curRange = [];
-          }
-        }
-        oldLine += lines.length;
-        newLine += lines.length;
-      }
-    }
-    for (const hunk of hunks) {
-      for (let i2 = 0;i2 < hunk.lines.length; i2++) {
-        if (hunk.lines[i2].endsWith(`
-`)) {
-          hunk.lines[i2] = hunk.lines[i2].slice(0, -1);
-        } else {
-          hunk.lines.splice(i2 + 1, 0, "\");
-          i2++;
-        }
-      }
-    }
-    return {
-      oldFileName,
-      newFileName,
-      oldHeader,
-      newHeader,
-      hunks
-    };
-  }
-}
-function formatPatch(patch, headerOptions) {
-  if (!headerOptions) {
-    headerOptions = INCLUDE_HEADERS;
-  }
-  if (Array.isArray(patch)) {
-    if (patch.length > 1 && !headerOptions.includeFileHeaders) {
-      throw new Error("Cannot omit file headers on a multi-file patch. " + "(The result would be unparseable; how would a tool trying to apply " + "the patch know which changes are to which file?)");
-    }
-    return patch.map((p) => formatPatch(p, headerOptions)).join(`
-`);
-  }
-  const ret = [];
-  if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
-    ret.push("Index: " + patch.oldFileName);
-  }
-  if (headerOptions.includeUnderline) {
-    ret.push("===================================================================");
-  }
-  if (headerOptions.includeFileHeaders) {
-    ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "\t" + patch.oldHeader));
-    ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "\t" + patch.newHeader));
-  }
-  for (let i2 = 0;i2 < patch.hunks.length; i2++) {
-    const hunk = patch.hunks[i2];
-    if (hunk.oldLines === 0) {
-      hunk.oldStart -= 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart -= 1;
-    }
-    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-    for (const line of hunk.lines) {
-      ret.push(line);
-    }
-  }
-  return ret.join(`
-`) + `
-`;
-}
-function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  if (typeof options === "function") {
-    options = { callback: options };
-  }
-  if (!(options === null || options === undefined ? undefined : options.callback)) {
-    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-    if (!patchObj) {
-      return;
-    }
-    return formatPatch(patchObj, options === null || options === undefined ? undefined : options.headerOptions);
-  } else {
-    const { callback } = options;
-    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
-      if (!patchObj) {
-        callback(undefined);
-      } else {
-        callback(formatPatch(patchObj, options.headerOptions));
-      }
-    } }));
-  }
-}
-function splitLines(text) {
-  const hasTrailingNl = text.endsWith(`
-`);
-  const result = text.split(`
-`).map((line) => line + `
-`);
-  if (hasTrailingNl) {
-    result.pop();
-  } else {
-    result.push(result.pop().slice(0, -1));
-  }
-  return result;
-}
 // src/tools/hashline-edit/diff-utils.ts
 function generateUnifiedDiff(oldContent, newContent, filePath) {
   return createTwoFilesPatch(filePath, filePath, oldContent, newContent, undefined, undefined, { context: 3 });
@@ -77870,7 +78367,7 @@ function unregisterManagerForCleanup(manager) {
 }
 
 // src/features/background-agent/compaction-aware-message-resolver.ts
-import { readdirSync as readdirSync22, readFileSync as readFileSync48 } from "fs";
+import { readdirSync as readdirSync22, readFileSync as readFileSync49 } from "fs";
 import { join as join82 } from "path";
 function isCompactionAgent3(agent) {
   return agent?.trim().toLowerCase() === "compaction";
@@ -77890,13 +78387,14 @@ function convertSessionMessageToStoredMessage(message) {
   }
   const providerID = info.model?.providerID ?? info.providerID;
   const modelID = info.model?.modelID ?? info.modelID;
+  const variant = info.model?.variant ?? info.variant;
   return {
     ...info.agent ? { agent: info.agent } : {},
     ...providerID && modelID ? {
       model: {
         providerID,
         modelID,
-        ...info.model?.variant ? { variant: info.model.variant } : {}
+        ...variant ? { variant } : {}
       }
     } : {},
     ...info.tools ? { tools: info.tools } : {}
@@ -77950,7 +78448,7 @@ function findNearestMessageExcludingCompaction(messageDir, sessionID) {
     const messages = [];
     for (const file3 of files) {
       try {
-        const content = readFileSync48(join82(messageDir, file3), "utf-8");
+        const content = readFileSync49(join82(messageDir, file3), "utf-8");
         messages.push(JSON.parse(content));
       } catch {
         continue;
@@ -78514,8 +79012,12 @@ class BackgroundManager {
       path: { id: sessionID },
       body: {
         agent: input.agent,
-        ...launchModel ? { model: launchModel } : {},
-        ...launchVariant ? { variant: launchVariant } : {},
+        ...launchModel || launchVariant ? {
+          model: {
+            ...launchModel ?? {},
+            ...launchVariant ? { variant: launchVariant } : {}
+          }
+        } : {},
         system: input.skillContent,
         tools: (() => {
           const tools = {
@@ -78722,12 +79224,16 @@ class BackgroundManager {
     });
     const resumeModel = existingTask.model ? { providerID: existingTask.model.providerID, modelID: existingTask.model.modelID } : undefined;
     const resumeVariant = existingTask.model?.variant;
-    this.client.session.promptAsync({
+    promptWithModelSuggestionRetry(this.client, {
       path: { id: existingTask.sessionID },
       body: {
         agent: existingTask.agent,
-        ...resumeModel ? { model: resumeModel } : {},
-        ...resumeVariant ? { variant: resumeVariant } : {},
+        ...resumeModel || resumeVariant ? {
+          model: {
+            ...resumeModel ?? {},
+            ...resumeVariant ? { variant: resumeVariant } : {}
+          }
+        } : {},
         tools: (() => {
           const tools = {
             task: false,
@@ -83405,7 +83911,7 @@ class StreamableHTTPClientTransport {
 }
 
 // src/features/mcp-oauth/storage.ts
-import { chmodSync as chmodSync2, existsSync as existsSync73, mkdirSync as mkdirSync15, readFileSync as readFileSync49, unlinkSync as unlinkSync13, writeFileSync as writeFileSync21 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync74, mkdirSync as mkdirSync15, readFileSync as readFileSync50, unlinkSync as unlinkSync13, writeFileSync as writeFileSync21 } from "fs";
 import { dirname as dirname22, join as join84 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
@@ -83446,11 +83952,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync73(filePath)) {
+  if (!existsSync74(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync49(filePath, "utf-8");
+    const content = readFileSync50(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -83460,7 +83966,7 @@ function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
     const dir = dirname22(filePath);
-    if (!existsSync73(dir)) {
+    if (!existsSync74(dir)) {
       mkdirSync15(dir, { recursive: true });
     }
     writeFileSync21(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
@@ -91370,7 +91876,7 @@ function createGptcoderAgent2(model, availableAgents, availableToolNames, availa
 }
 createGptcoderAgent2.mode = MODE10;
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync74, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync75, readFileSync as readFileSync51 } from "fs";
 import { homedir as homedir14 } from "os";
 import { isAbsolute as isAbsolute10, resolve as resolve16 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
@@ -91385,11 +91891,11 @@ function resolvePromptAppend(promptAppend, configDir) {
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
-  if (!existsSync74(filePath)) {
+  if (!existsSync75(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync50(filePath, "utf8");
+    return readFileSync51(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -93210,7 +93716,7 @@ async function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, dir
   return result;
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync75, readdirSync as readdirSync23, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync76, readdirSync as readdirSync23, readFileSync as readFileSync52 } from "fs";
 import { join as join85, basename as basename10 } from "path";
 function parseToolsConfig2(toolsStr) {
   if (!toolsStr)
@@ -93225,7 +93731,7 @@ function parseToolsConfig2(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync75(agentsDir)) {
+  if (!existsSync76(agentsDir)) {
     return [];
   }
   const entries = readdirSync23(agentsDir, { withFileTypes: true });
@@ -93236,7 +93742,7 @@ function loadAgentsFromDir(agentsDir, scope) {
     const agentPath = join85(agentsDir, entry.name);
     const agentName = basename10(entry.name, ".md");
     try {
-      const content = readFileSync51(agentPath, "utf-8");
+      const content = readFileSync52(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -95872,7 +96378,7 @@ function remapCommandAgentFields(commands3) {
   }
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync76, readFileSync as readFileSync52 } from "fs";
+import { existsSync as existsSync77, readFileSync as readFileSync53 } from "fs";
 import { join as join87 } from "path";
 import { homedir as homedir15 } from "os";
 init_logger();
@@ -95887,7 +96393,7 @@ function getMcpConfigPaths() {
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync76(filePath)) {
+  if (!existsSync77(filePath)) {
     return null;
   }
   try {
@@ -95902,10 +96408,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path12 } of paths) {
-    if (!existsSync76(path12))
+    if (!existsSync77(path12))
       continue;
     try {
-      const content = readFileSync52(path12, "utf-8");
+      const content = readFileSync53(path12, "utf-8");
       const config4 = JSON.parse(content);
       if (!config4?.mcpServers)
         continue;
@@ -96585,7 +97091,7 @@ function buildChatParamsInput(raw) {
   const providerID = model.providerID;
   const modelID = model.modelID;
   const providerId = provider.id;
-  const variant = message.variant;
+  const variant = getUserMessageVariant(message);
   if (typeof providerID !== "string")
     return null;
   if (typeof modelID !== "string")
@@ -96597,7 +97103,7 @@ function buildChatParamsInput(raw) {
     agent: { name: agentName },
     model: { providerID, modelID },
     provider: { id: providerId },
-    message: typeof variant === "string" ? { variant } : {}
+    message: typeof variant === "string" ? { model: { variant } } : {}
   };
 }
 function isChatParamsOutput(raw) {
@@ -96726,7 +97232,7 @@ function createChatHeadersHandler(args) {
 // src/plugin/ultrawork-db-model-override.ts
 import { Database } from "bun:sqlite";
 import { join as join88 } from "path";
-import { existsSync as existsSync77 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 function getDbPath() {
   return join88(getDataDir(), "opencode", "opencode.db");
 }
@@ -96737,7 +97243,7 @@ function tryUpdateMessageModel(db, messageId, targetModel, variant) {
   if (result.changes === 0)
     return false;
   if (variant) {
-    db.prepare(`UPDATE message SET data = json_set(data, '$.variant', ?, '$.thinking', ?) WHERE id = ?`).run(variant, variant, messageId);
+    db.prepare(`UPDATE message SET data = json_remove(json_set(data, '$.model.variant', ?, '$.thinking', ?), '$.variant') WHERE id = ?`).run(variant, variant, messageId);
   }
   return true;
 }
@@ -96805,7 +97311,7 @@ function retryViaMicrotask(db, messageId, targetModel, variant, attempt) {
 function scheduleDeferredModelOverride(messageId, targetModel, variant) {
   queueMicrotask(() => {
     const dbPath = getDbPath();
-    if (!existsSync77(dbPath)) {
+    if (!existsSync78(dbPath)) {
       log("[ultrawork-db-override] DB not found, skipping deferred override");
       return;
     }
@@ -96913,7 +97419,7 @@ function resolveUltraworkOverride(pluginConfig, inputAgentName, output, sessionI
 function applyResolvedUltraworkOverride(args) {
   const { override, validatedVariant, output, inputAgentName, tui } = args;
   if (validatedVariant) {
-    output.message["variant"] = validatedVariant;
+    setUserMessageVariant(output.message, validatedVariant);
     output.message["thinking"] = validatedVariant;
   }
   if (!override.providerID || !override.modelID)
@@ -96926,7 +97432,7 @@ function applyResolvedUltraworkOverride(args) {
   const messageId = output.message["id"];
   if (!messageId) {
     log("[ultrawork-model-override] No message ID found, falling back to direct mutation");
-    output.message.model = targetModel;
+    output.message.model = validatedVariant ? { ...targetModel, variant: validatedVariant } : targetModel;
     return;
   }
   const fromModel = output.message.model?.modelID ?? "unknown";