oh-my-opencode 2.5.4 → 2.6.0

package/dist/index.js

@@ -574,7 +574,7 @@ var require_parse = __commonJS((exports, module) => {
   var syntaxError = (type, char) => {
     return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
-  var parse = (input, options) => {
+  var parse3 = (input, options) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected a string");
     }
@@ -723,7 +723,7 @@ var require_parse = __commonJS((exports, module) => {
           output = token.close = `)$))${extglobStar}`;
         }
         if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-          const expression = parse(rest, { ...options, fastpaths: false }).output;
+          const expression = parse3(rest, { ...options, fastpaths: false }).output;
           output = token.close = `)${expression})${extglobStar})`;
         }
         if (token.prev.type === "bos") {
@@ -1249,7 +1249,7 @@ var require_parse = __commonJS((exports, module) => {
     }
     return state2;
   };
-  parse.fastpaths = (input, options) => {
+  parse3.fastpaths = (input, options) => {
     const opts = { ...options };
     const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
     const len = input.length;
@@ -1317,13 +1317,13 @@ var require_parse = __commonJS((exports, module) => {
     }
     return source;
   };
-  module.exports = parse;
+  module.exports = parse3;
 });
 
 // node_modules/picomatch/lib/picomatch.js
 var require_picomatch = __commonJS((exports, module) => {
   var scan = require_scan();
-  var parse = require_parse();
+  var parse3 = require_parse();
   var utils = require_utils();
   var constants = require_constants();
   var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -1389,11 +1389,11 @@ var require_picomatch = __commonJS((exports, module) => {
       return { isMatch: false, output: "" };
     }
     const opts = options || {};
-    const format = opts.format || (posix ? utils.toPosixSlashes : null);
+    const format2 = opts.format || (posix ? utils.toPosixSlashes : null);
     let match = input === glob;
-    let output = match && format ? format(input) : input;
+    let output = match && format2 ? format2(input) : input;
     if (match === false) {
-      output = format ? format(input) : input;
+      output = format2 ? format2(input) : input;
       match = output === glob;
     }
     if (match === false || opts.capture === true) {
@@ -1413,7 +1413,7 @@ var require_picomatch = __commonJS((exports, module) => {
   picomatch.parse = (pattern, options) => {
     if (Array.isArray(pattern))
       return pattern.map((p) => picomatch.parse(p, options));
-    return parse(pattern, { ...options, fastpaths: false });
+    return parse3(pattern, { ...options, fastpaths: false });
   };
   picomatch.scan = (input, options) => scan(input, options);
   picomatch.compileRe = (state2, options, returnOutput = false, returnState = false) => {
@@ -1439,10 +1439,10 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     let parsed = { negated: false, fastpaths: true };
     if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-      parsed.output = parse.fastpaths(input, options);
+      parsed.output = parse3.fastpaths(input, options);
     }
     if (!parsed.output) {
-      parsed = parse(input, options);
+      parsed = parse3(input, options);
     }
     return picomatch.compileRe(parsed, options, returnOutput, returnState);
   };
@@ -3228,10 +3228,13 @@ async function getContextWindowUsage(ctx, sessionID) {
   }
 }
 async function dynamicTruncate(ctx, sessionID, output, options = {}) {
-  const { targetMaxTokens = DEFAULT_TARGET_MAX_TOKENS, preserveHeaderLines = 3 } = options;
+  const {
+    targetMaxTokens = DEFAULT_TARGET_MAX_TOKENS,
+    preserveHeaderLines = 3
+  } = options;
   const usage = await getContextWindowUsage(ctx, sessionID);
   if (!usage) {
-    return { result: output, truncated: false };
+    return truncateToTokenLimit(output, targetMaxTokens, preserveHeaderLines);
   }
   const maxOutputTokens = Math.min(usage.remainingTokens * 0.5, targetMaxTokens);
   if (maxOutputTokens <= 0) {
@@ -3292,6 +3295,884 @@ function clearConfigLoadErrors() {
 function addConfigLoadError(error) {
   configLoadErrors.push(error);
 }
+// src/shared/claude-config-dir.ts
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
+function getClaudeConfigDir() {
+  const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
+  if (envConfigDir) {
+    return envConfigDir;
+  }
+  return join5(homedir4(), ".claude");
+}
+// src/shared/jsonc-parser.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+
+// src/shared/jsonc-parser.ts
+function parseJsonc(content) {
+  const errors = [];
+  const result = parse2(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const errorMessages = errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
+    throw new SyntaxError(`JSONC parse error: ${errorMessages}`);
+  }
+  return result;
+}
+function detectConfigFile(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (existsSync4(jsoncPath)) {
+    return { format: "jsonc", path: jsoncPath };
+  }
+  if (existsSync4(jsonPath)) {
+    return { format: "json", path: jsonPath };
+  }
+  return { format: "none", path: jsonPath };
+}
 // src/agents/utils.ts
 var agentSources = {
   Sisyphus: createSisyphusAgent,
@@ -3367,8 +4248,8 @@ function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, directory
   return result;
 }
 // src/hooks/todo-continuation-enforcer.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
+import { join as join8 } from "path";
 
 // src/features/claude-code-session-state/state.ts
 var subagentSessions = new Set;
@@ -3380,14 +4261,14 @@ function getMainSessionID() {
   return mainSessionID;
 }
 // src/features/hook-message-injector/injector.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, readdirSync, writeFileSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync3, readdirSync, writeFileSync } from "fs";
+import { join as join7 } from "path";
 
 // src/features/hook-message-injector/constants.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var OPENCODE_STORAGE = getOpenCodeStorageDir();
-var MESSAGE_STORAGE = join5(OPENCODE_STORAGE, "message");
-var PART_STORAGE = join5(OPENCODE_STORAGE, "part");
+var MESSAGE_STORAGE = join6(OPENCODE_STORAGE, "message");
+var PART_STORAGE = join6(OPENCODE_STORAGE, "part");
 
 // src/features/hook-message-injector/injector.ts
 function findNearestMessageWithFields(messageDir) {
@@ -3395,7 +4276,7 @@ function findNearestMessageWithFields(messageDir) {
     const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort().reverse();
     for (const file of files) {
       try {
-        const content = readFileSync2(join6(messageDir, file), "utf-8");
+        const content = readFileSync3(join7(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -3420,16 +4301,16 @@ function generatePartId() {
   return `prt_${timestamp}${random}`;
 }
 function getOrCreateMessageDir(sessionID) {
-  if (!existsSync4(MESSAGE_STORAGE)) {
+  if (!existsSync5(MESSAGE_STORAGE)) {
     mkdirSync(MESSAGE_STORAGE, { recursive: true });
   }
-  const directPath = join6(MESSAGE_STORAGE, sessionID);
-  if (existsSync4(directPath)) {
+  const directPath = join7(MESSAGE_STORAGE, sessionID);
+  if (existsSync5(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join6(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync4(sessionPath)) {
+    const sessionPath = join7(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync5(sessionPath)) {
       return sessionPath;
     }
   }
@@ -3482,12 +4363,12 @@ function injectHookMessage(sessionID, hookContent, originalMessage) {
     sessionID
   };
   try {
-    writeFileSync(join6(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
-    const partDir = join6(PART_STORAGE, messageID);
-    if (!existsSync4(partDir)) {
+    writeFileSync(join7(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+    const partDir = join7(PART_STORAGE, messageID);
+    if (!existsSync5(partDir)) {
       mkdirSync(partDir, { recursive: true });
     }
-    writeFileSync(join6(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+    writeFileSync(join7(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
     return true;
   } catch {
     return false;
@@ -3520,14 +4401,14 @@ Incomplete tasks remain in your todo list. Continue working on the next pending
 - Mark each task complete when finished
 - Do not stop until all tasks are done`;
 function getMessageDir(sessionID) {
-  if (!existsSync5(MESSAGE_STORAGE))
+  if (!existsSync6(MESSAGE_STORAGE))
     return null;
-  const directPath = join7(MESSAGE_STORAGE, sessionID);
-  if (existsSync5(directPath))
+  const directPath = join8(MESSAGE_STORAGE, sessionID);
+  if (existsSync6(directPath))
     return directPath;
   for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-    const sessionPath = join7(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync5(sessionPath))
+    const sessionPath = join8(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync6(sessionPath))
       return sessionPath;
   }
   return null;
@@ -3883,6 +4764,130 @@ ${CONTEXT_REMINDER}
 }
 // src/hooks/session-notification.ts
 import { platform } from "os";
+
+// src/hooks/session-notification-utils.ts
+var {spawn: spawn2 } = globalThis.Bun;
+var notifySendPath = null;
+var notifySendPromise = null;
+var osascriptPath = null;
+var osascriptPromise = null;
+var powershellPath = null;
+var powershellPromise = null;
+var afplayPath = null;
+var afplayPromise = null;
+var paplayPath = null;
+var paplayPromise = null;
+var aplayPath = null;
+var aplayPromise = null;
+async function findCommand(commandName) {
+  const isWindows = process.platform === "win32";
+  const cmd = isWindows ? "where" : "which";
+  try {
+    const proc = spawn2([cmd, commandName], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return null;
+    }
+    const stdout = await new Response(proc.stdout).text();
+    const path4 = stdout.trim().split(`
+`)[0];
+    if (!path4) {
+      return null;
+    }
+    return path4;
+  } catch {
+    return null;
+  }
+}
+async function getNotifySendPath() {
+  if (notifySendPath !== null)
+    return notifySendPath;
+  if (notifySendPromise)
+    return notifySendPromise;
+  notifySendPromise = (async () => {
+    const path4 = await findCommand("notify-send");
+    notifySendPath = path4;
+    return path4;
+  })();
+  return notifySendPromise;
+}
+async function getOsascriptPath() {
+  if (osascriptPath !== null)
+    return osascriptPath;
+  if (osascriptPromise)
+    return osascriptPromise;
+  osascriptPromise = (async () => {
+    const path4 = await findCommand("osascript");
+    osascriptPath = path4;
+    return path4;
+  })();
+  return osascriptPromise;
+}
+async function getPowershellPath() {
+  if (powershellPath !== null)
+    return powershellPath;
+  if (powershellPromise)
+    return powershellPromise;
+  powershellPromise = (async () => {
+    const path4 = await findCommand("powershell");
+    powershellPath = path4;
+    return path4;
+  })();
+  return powershellPromise;
+}
+async function getAfplayPath() {
+  if (afplayPath !== null)
+    return afplayPath;
+  if (afplayPromise)
+    return afplayPromise;
+  afplayPromise = (async () => {
+    const path4 = await findCommand("afplay");
+    afplayPath = path4;
+    return path4;
+  })();
+  return afplayPromise;
+}
+async function getPaplayPath() {
+  if (paplayPath !== null)
+    return paplayPath;
+  if (paplayPromise)
+    return paplayPromise;
+  paplayPromise = (async () => {
+    const path4 = await findCommand("paplay");
+    paplayPath = path4;
+    return path4;
+  })();
+  return paplayPromise;
+}
+async function getAplayPath() {
+  if (aplayPath !== null)
+    return aplayPath;
+  if (aplayPromise)
+    return aplayPromise;
+  aplayPromise = (async () => {
+    const path4 = await findCommand("aplay");
+    aplayPath = path4;
+    return path4;
+  })();
+  return aplayPromise;
+}
+function startBackgroundCheck(platform) {
+  if (platform === "darwin") {
+    getOsascriptPath().catch(() => {});
+    getAfplayPath().catch(() => {});
+  } else if (platform === "linux") {
+    getNotifySendPath().catch(() => {});
+    getPaplayPath().catch(() => {});
+    getAplayPath().catch(() => {});
+  } else if (platform === "win32") {
+    getPowershellPath().catch(() => {});
+  }
+}
+
+// src/hooks/session-notification.ts
 function detectPlatform() {
   const p = platform();
   if (p === "darwin" || p === "linux" || p === "win32")
@@ -3904,15 +4909,25 @@ function getDefaultSoundPath(p) {
 async function sendNotification(ctx, p, title, message) {
   switch (p) {
     case "darwin": {
+      const osascriptPath2 = await getOsascriptPath();
+      if (!osascriptPath2)
+        return;
       const esTitle = title.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
       const esMessage = message.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-      await ctx.$`osascript -e ${'display notification "' + esMessage + '" with title "' + esTitle + '"'}`;
+      await ctx.$`${osascriptPath2} -e ${'display notification "' + esMessage + '" with title "' + esTitle + '"'}`.catch(() => {});
       break;
     }
-    case "linux":
-      await ctx.$`notify-send ${title} ${message} 2>/dev/null`.catch(() => {});
+    case "linux": {
+      const notifySendPath2 = await getNotifySendPath();
+      if (!notifySendPath2)
+        return;
+      await ctx.$`${notifySendPath2} ${title} ${message} 2>/dev/null`.catch(() => {});
       break;
+    }
     case "win32": {
+      const powershellPath2 = await getPowershellPath();
+      if (!powershellPath2)
+        return;
       const psTitle = title.replace(/'/g, "''");
       const psMessage = message.replace(/'/g, "''");
       const toastScript = `
@@ -3927,24 +4942,39 @@ $Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
 $Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('OpenCode')
 $Notifier.Show($Toast)
 `.trim().replace(/\n/g, "; ");
-      await ctx.$`powershell -Command ${toastScript}`.catch(() => {});
+      await ctx.$`${powershellPath2} -Command ${toastScript}`.catch(() => {});
       break;
     }
   }
 }
 async function playSound(ctx, p, soundPath) {
   switch (p) {
-    case "darwin":
-      ctx.$`afplay ${soundPath}`.catch(() => {});
+    case "darwin": {
+      const afplayPath2 = await getAfplayPath();
+      if (!afplayPath2)
+        return;
+      ctx.$`${afplayPath2} ${soundPath}`.catch(() => {});
       break;
-    case "linux":
-      ctx.$`paplay ${soundPath} 2>/dev/null`.catch(() => {
-        ctx.$`aplay ${soundPath} 2>/dev/null`.catch(() => {});
-      });
+    }
+    case "linux": {
+      const paplayPath2 = await getPaplayPath();
+      if (paplayPath2) {
+        ctx.$`${paplayPath2} ${soundPath} 2>/dev/null`.catch(() => {});
+      } else {
+        const aplayPath2 = await getAplayPath();
+        if (aplayPath2) {
+          ctx.$`${aplayPath2} ${soundPath} 2>/dev/null`.catch(() => {});
+        }
+      }
       break;
-    case "win32":
-      ctx.$`powershell -Command ${"(New-Object Media.SoundPlayer '" + soundPath + "').PlaySync()"}`.catch(() => {});
+    }
+    case "win32": {
+      const powershellPath2 = await getPowershellPath();
+      if (!powershellPath2)
+        return;
+      ctx.$`${powershellPath2} -Command ${"(New-Object Media.SoundPlayer '" + soundPath + "').PlaySync()"}`.catch(() => {});
       break;
+    }
   }
 }
 async function hasIncompleteTodos(ctx, sessionID) {
@@ -3961,6 +4991,7 @@ async function hasIncompleteTodos(ctx, sessionID) {
 function createSessionNotification(ctx, config = {}) {
   const currentPlatform = detectPlatform();
   const defaultSoundPath = getDefaultSoundPath(currentPlatform);
+  startBackgroundCheck(currentPlatform);
   const mergedConfig = {
     title: "OpenCode",
     message: "Agent is ready for input",
@@ -4118,11 +5149,11 @@ function createSessionNotification(ctx, config = {}) {
   };
 }
 // src/hooks/session-recovery/storage.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join10 } from "path";
 
 // src/hooks/session-recovery/constants.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // node_modules/xdg-basedir/index.js
 import os4 from "os";
@@ -4144,9 +5175,9 @@ if (xdgConfig) {
 }
 
 // src/hooks/session-recovery/constants.ts
-var OPENCODE_STORAGE2 = join8(xdgData ?? "", "opencode", "storage");
-var MESSAGE_STORAGE2 = join8(OPENCODE_STORAGE2, "message");
-var PART_STORAGE2 = join8(OPENCODE_STORAGE2, "part");
+var OPENCODE_STORAGE2 = join9(xdgData ?? "", "opencode", "storage");
+var MESSAGE_STORAGE2 = join9(OPENCODE_STORAGE2, "message");
+var PART_STORAGE2 = join9(OPENCODE_STORAGE2, "part");
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
 var META_TYPES = new Set(["step-start", "step-finish"]);
 var CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"]);
@@ -4158,15 +5189,15 @@ function generatePartId2() {
   return `prt_${timestamp}${random}`;
 }
 function getMessageDir2(sessionID) {
-  if (!existsSync6(MESSAGE_STORAGE2))
+  if (!existsSync7(MESSAGE_STORAGE2))
     return "";
-  const directPath = join9(MESSAGE_STORAGE2, sessionID);
-  if (existsSync6(directPath)) {
+  const directPath = join10(MESSAGE_STORAGE2, sessionID);
+  if (existsSync7(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync3(MESSAGE_STORAGE2)) {
-    const sessionPath = join9(MESSAGE_STORAGE2, dir, sessionID);
-    if (existsSync6(sessionPath)) {
+    const sessionPath = join10(MESSAGE_STORAGE2, dir, sessionID);
+    if (existsSync7(sessionPath)) {
       return sessionPath;
     }
   }
@@ -4174,14 +5205,14 @@ function getMessageDir2(sessionID) {
 }
 function readMessages(sessionID) {
   const messageDir = getMessageDir2(sessionID);
-  if (!messageDir || !existsSync6(messageDir))
+  if (!messageDir || !existsSync7(messageDir))
     return [];
   const messages = [];
   for (const file of readdirSync3(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync3(join9(messageDir, file), "utf-8");
+      const content = readFileSync4(join10(messageDir, file), "utf-8");
       messages.push(JSON.parse(content));
     } catch {
       continue;
@@ -4196,15 +5227,15 @@ function readMessages(sessionID) {
   });
 }
 function readParts(messageID) {
-  const partDir = join9(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir))
+  const partDir = join10(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir))
     return [];
   const parts = [];
   for (const file of readdirSync3(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync3(join9(partDir, file), "utf-8");
+      const content = readFileSync4(join10(partDir, file), "utf-8");
       parts.push(JSON.parse(content));
     } catch {
       continue;
@@ -4234,8 +5265,8 @@ function messageHasContent(messageID) {
   return parts.some(hasContent);
 }
 function injectTextPart(sessionID, messageID, text) {
-  const partDir = join9(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir)) {
+  const partDir = join10(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir)) {
     mkdirSync2(partDir, { recursive: true });
   }
   const partId = generatePartId2();
@@ -4248,7 +5279,7 @@ function injectTextPart(sessionID, messageID, text) {
     synthetic: true
   };
   try {
-    writeFileSync2(join9(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync2(join10(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
@@ -4310,38 +5341,62 @@ function findMessagesWithOrphanThinking(sessionID) {
   }
   return result;
 }
+function findLastThinkingContent(sessionID, beforeMessageID) {
+  const messages = readMessages(sessionID);
+  const currentIndex = messages.findIndex((m) => m.id === beforeMessageID);
+  if (currentIndex === -1)
+    return "";
+  for (let i = currentIndex - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant")
+      continue;
+    const parts = readParts(msg.id);
+    for (const part of parts) {
+      if (THINKING_TYPES.has(part.type)) {
+        const thinking = part.thinking;
+        const reasoning = part.text;
+        const content = thinking || reasoning;
+        if (content && content.trim().length > 0) {
+          return content;
+        }
+      }
+    }
+  }
+  return "";
+}
 function prependThinkingPart(sessionID, messageID) {
-  const partDir = join9(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir)) {
+  const partDir = join10(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir)) {
     mkdirSync2(partDir, { recursive: true });
   }
+  const previousThinking = findLastThinkingContent(sessionID, messageID);
   const partId = `prt_0000000000_thinking`;
   const part = {
     id: partId,
     sessionID,
     messageID,
     type: "thinking",
-    thinking: "",
+    thinking: previousThinking || "[Continuing from previous reasoning]",
     synthetic: true
   };
   try {
-    writeFileSync2(join9(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
+    writeFileSync2(join10(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function stripThinkingParts(messageID) {
-  const partDir = join9(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir))
+  const partDir = join10(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir))
     return false;
   let anyRemoved = false;
   for (const file of readdirSync3(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const filePath = join9(partDir, file);
-      const content = readFileSync3(filePath, "utf-8");
+      const filePath = join10(partDir, file);
+      const content = readFileSync4(filePath, "utf-8");
       const part = JSON.parse(content);
       if (THINKING_TYPES.has(part.type)) {
         unlinkSync(filePath);
@@ -4354,16 +5409,16 @@ function stripThinkingParts(messageID) {
   return anyRemoved;
 }
 function replaceEmptyTextParts(messageID, replacementText) {
-  const partDir = join9(PART_STORAGE2, messageID);
-  if (!existsSync6(partDir))
+  const partDir = join10(PART_STORAGE2, messageID);
+  if (!existsSync7(partDir))
     return false;
   let anyReplaced = false;
   for (const file of readdirSync3(partDir)) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const filePath = join9(partDir, file);
-      const content = readFileSync3(filePath, "utf-8");
+      const filePath = join10(partDir, file);
+      const content = readFileSync4(filePath, "utf-8");
       const part = JSON.parse(content);
       if (part.type === "text") {
         const textPart = part;
@@ -4637,21 +5692,21 @@ function createSessionRecoveryHook(ctx, options) {
   };
 }
 // src/hooks/comment-checker/cli.ts
-var {spawn: spawn3 } = globalThis.Bun;
+var {spawn: spawn4 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
-import { dirname, join as join11 } from "path";
-import { existsSync as existsSync8 } from "fs";
+import { dirname, join as join12 } from "path";
+import { existsSync as existsSync9 } from "fs";
 import * as fs3 from "fs";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/hooks/comment-checker/downloader.ts
-var {spawn: spawn2 } = globalThis.Bun;
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
+var {spawn: spawn3 } = globalThis.Bun;
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
 import { createRequire } from "module";
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join10(tmpdir2(), "comment-checker-debug.log");
+var DEBUG_FILE = join11(tmpdir2(), "comment-checker-debug.log");
 function debugLog(...args) {
   if (DEBUG) {
     const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -4669,15 +5724,15 @@ var PLATFORM_MAP = {
 };
 function getCacheDir() {
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join10(homedir4(), ".cache");
-  return join10(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join11(homedir5(), ".cache");
+  return join11(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join10(getCacheDir(), getBinaryName());
-  return existsSync7(binaryPath) ? binaryPath : null;
+  const binaryPath = join11(getCacheDir(), getBinaryName());
+  return existsSync8(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -4690,7 +5745,7 @@ function getPackageVersion() {
 }
 async function extractTarGz(archivePath, destDir) {
   debugLog("Extracting tar.gz:", archivePath, "to", destDir);
-  const proc = spawn2(["tar", "-xzf", archivePath, "-C", destDir], {
+  const proc = spawn3(["tar", "-xzf", archivePath, "-C", destDir], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -4702,10 +5757,10 @@ async function extractTarGz(archivePath, destDir) {
 }
 async function extractZip(archivePath, destDir) {
   debugLog("Extracting zip:", archivePath, "to", destDir);
-  const proc = process.platform === "win32" ? spawn2(["powershell", "-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], {
+  const proc = process.platform === "win32" ? spawn3(["powershell", "-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], {
     stdout: "pipe",
     stderr: "pipe"
-  }) : spawn2(["unzip", "-o", archivePath, "-d", destDir], {
+  }) : spawn3(["unzip", "-o", archivePath, "-d", destDir], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -4724,8 +5779,8 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join10(cacheDir, binaryName);
-  if (existsSync7(binaryPath)) {
+  const binaryPath = join11(cacheDir, binaryName);
+  if (existsSync8(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
@@ -4736,14 +5791,14 @@ async function downloadCommentChecker() {
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
-    if (!existsSync7(cacheDir)) {
+    if (!existsSync8(cacheDir)) {
       mkdirSync3(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join10(cacheDir, assetName);
+    const archivePath = join11(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -4752,10 +5807,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync7(archivePath)) {
+    if (existsSync8(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync7(binaryPath)) {
+    if (process.platform !== "win32" && existsSync8(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -4779,7 +5834,7 @@ async function ensureCommentCheckerBinary() {
 
 // src/hooks/comment-checker/cli.ts
 var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE2 = join11(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE2 = join12(tmpdir3(), "comment-checker-debug.log");
 function debugLog2(...args) {
   if (DEBUG2) {
     const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -4796,8 +5851,8 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join11(cliDir, "bin", binaryName);
-    if (existsSync8(binaryPath)) {
+    const binaryPath = join12(cliDir, "bin", binaryName);
+    if (existsSync9(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -4823,7 +5878,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync8(syncPath)) {
+    if (syncPath && existsSync9(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -4857,14 +5912,14 @@ async function runCommentChecker(input, cliPath) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync8(binaryPath)) {
+  if (!existsSync9(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
   const jsonInput = JSON.stringify(input);
   debugLog2("running comment-checker with input:", jsonInput.substring(0, 200));
   try {
-    const proc = spawn3([binaryPath], {
+    const proc = spawn4([binaryPath], {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe"
@@ -4891,11 +5946,11 @@ async function runCommentChecker(input, cliPath) {
 
 // src/hooks/comment-checker/index.ts
 import * as fs4 from "fs";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE3 = join12(tmpdir4(), "comment-checker-debug.log");
+var DEBUG_FILE3 = join13(tmpdir4(), "comment-checker-debug.log");
 function debugLog3(...args) {
   if (DEBUG3) {
     const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
@@ -4971,7 +6026,7 @@ function createCommentCheckerHooks() {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync9(cliPath)) {
+        if (!cliPath || !existsSync10(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -5043,35 +6098,35 @@ function createToolOutputTruncatorHook(ctx, options) {
   };
 }
 // src/hooks/directory-agents-injector/index.ts
-import { existsSync as existsSync11, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname2, join as join15, resolve as resolve2 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname2, join as join16, resolve as resolve2 } from "path";
 
 // src/hooks/directory-agents-injector/storage.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   writeFileSync as writeFileSync3,
   unlinkSync as unlinkSync3
 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
-import { join as join13 } from "path";
-var OPENCODE_STORAGE3 = join13(xdgData ?? "", "opencode", "storage");
-var AGENTS_INJECTOR_STORAGE = join13(OPENCODE_STORAGE3, "directory-agents");
+import { join as join14 } from "path";
+var OPENCODE_STORAGE3 = join14(xdgData ?? "", "opencode", "storage");
+var AGENTS_INJECTOR_STORAGE = join14(OPENCODE_STORAGE3, "directory-agents");
 var AGENTS_FILENAME = "AGENTS.md";
 
 // src/hooks/directory-agents-injector/storage.ts
 function getStoragePath(sessionID) {
-  return join14(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join15(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync10(filePath))
+  if (!existsSync11(filePath))
     return new Set;
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -5079,7 +6134,7 @@ function loadInjectedPaths(sessionID) {
   }
 }
 function saveInjectedPaths(sessionID, paths) {
-  if (!existsSync10(AGENTS_INJECTOR_STORAGE)) {
+  if (!existsSync11(AGENTS_INJECTOR_STORAGE)) {
     mkdirSync4(AGENTS_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
@@ -5091,7 +6146,7 @@ function saveInjectedPaths(sessionID, paths) {
 }
 function clearInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync10(filePath)) {
+  if (existsSync11(filePath)) {
     unlinkSync3(filePath);
   }
 }
@@ -5118,8 +6173,8 @@ function createDirectoryAgentsInjectorHook(ctx) {
     const found = [];
     let current = startDir;
     while (true) {
-      const agentsPath = join15(current, AGENTS_FILENAME);
-      if (existsSync11(agentsPath)) {
+      const agentsPath = join16(current, AGENTS_FILENAME);
+      if (existsSync12(agentsPath)) {
         found.push(agentsPath);
       }
       if (current === ctx.directory)
@@ -5145,7 +6200,7 @@ function createDirectoryAgentsInjectorHook(ctx) {
       if (cache.has(agentsDir))
         continue;
       try {
-        const content = readFileSync5(agentsPath, "utf-8");
+        const content = readFileSync6(agentsPath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -5215,35 +6270,35 @@ ${result}${truncationNotice}`;
   };
 }
 // src/hooks/directory-readme-injector/index.ts
-import { existsSync as existsSync13, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname3, join as join18, resolve as resolve3 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname3, join as join19, resolve as resolve3 } from "path";
 
 // src/hooks/directory-readme-injector/storage.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync4,
   unlinkSync as unlinkSync4
 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
-import { join as join16 } from "path";
-var OPENCODE_STORAGE4 = join16(xdgData ?? "", "opencode", "storage");
-var README_INJECTOR_STORAGE = join16(OPENCODE_STORAGE4, "directory-readme");
+import { join as join17 } from "path";
+var OPENCODE_STORAGE4 = join17(xdgData ?? "", "opencode", "storage");
+var README_INJECTOR_STORAGE = join17(OPENCODE_STORAGE4, "directory-readme");
 var README_FILENAME = "README.md";
 
 // src/hooks/directory-readme-injector/storage.ts
 function getStoragePath2(sessionID) {
-  return join17(README_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join18(README_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync12(filePath))
+  if (!existsSync13(filePath))
     return new Set;
   try {
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     const data = JSON.parse(content);
     return new Set(data.injectedPaths);
   } catch {
@@ -5251,7 +6306,7 @@ function loadInjectedPaths2(sessionID) {
   }
 }
 function saveInjectedPaths2(sessionID, paths) {
-  if (!existsSync12(README_INJECTOR_STORAGE)) {
+  if (!existsSync13(README_INJECTOR_STORAGE)) {
     mkdirSync5(README_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
@@ -5263,7 +6318,7 @@ function saveInjectedPaths2(sessionID, paths) {
 }
 function clearInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync12(filePath)) {
+  if (existsSync13(filePath)) {
     unlinkSync4(filePath);
   }
 }
@@ -5290,8 +6345,8 @@ function createDirectoryReadmeInjectorHook(ctx) {
     const found = [];
     let current = startDir;
     while (true) {
-      const readmePath = join18(current, README_FILENAME);
-      if (existsSync13(readmePath)) {
+      const readmePath = join19(current, README_FILENAME);
+      if (existsSync14(readmePath)) {
         found.push(readmePath);
       }
       if (current === ctx.directory)
@@ -5317,7 +6372,7 @@ function createDirectoryReadmeInjectorHook(ctx) {
       if (cache.has(readmeDir))
         continue;
       try {
-        const content = readFileSync7(readmePath, "utf-8");
+        const content = readFileSync8(readmePath, "utf-8");
         const { result, truncated } = await truncator.truncate(sessionID, content);
         const truncationNotice = truncated ? `
 
@@ -5503,127 +6558,693 @@ function parseAnthropicTokenLimitError(err) {
       if (isTokenLimitError(jsonStr)) {
         textSources.push(jsonStr);
       }
-    } catch {}
-  }
-  const combinedText = textSources.join(" ");
-  if (!isTokenLimitError(combinedText))
-    return null;
-  if (typeof responseBody === "string") {
-    try {
-      const jsonPatterns = [
-        /data:\s*(\{[\s\S]*?\})\s*$/m,
-        /(\{"type"\s*:\s*"error"[\s\S]*?\})/,
-        /(\{[\s\S]*?"error"[\s\S]*?\})/
-      ];
-      for (const pattern of jsonPatterns) {
-        const dataMatch = responseBody.match(pattern);
-        if (dataMatch) {
-          try {
-            const jsonData = JSON.parse(dataMatch[1]);
-            const message = jsonData.error?.message || "";
-            const tokens = extractTokensFromMessage(message);
-            if (tokens) {
-              return {
-                currentTokens: tokens.current,
-                maxTokens: tokens.max,
-                requestId: jsonData.request_id,
-                errorType: jsonData.error?.type || "token_limit_exceeded"
-              };
+    } catch {}
+  }
+  const combinedText = textSources.join(" ");
+  if (!isTokenLimitError(combinedText))
+    return null;
+  if (typeof responseBody === "string") {
+    try {
+      const jsonPatterns = [
+        /data:\s*(\{[\s\S]*?\})\s*$/m,
+        /(\{"type"\s*:\s*"error"[\s\S]*?\})/,
+        /(\{[\s\S]*?"error"[\s\S]*?\})/
+      ];
+      for (const pattern of jsonPatterns) {
+        const dataMatch = responseBody.match(pattern);
+        if (dataMatch) {
+          try {
+            const jsonData = JSON.parse(dataMatch[1]);
+            const message = jsonData.error?.message || "";
+            const tokens = extractTokensFromMessage(message);
+            if (tokens) {
+              return {
+                currentTokens: tokens.current,
+                maxTokens: tokens.max,
+                requestId: jsonData.request_id,
+                errorType: jsonData.error?.type || "token_limit_exceeded"
+              };
+            }
+          } catch {}
+        }
+      }
+      const bedrockJson = JSON.parse(responseBody);
+      if (typeof bedrockJson.message === "string" && isTokenLimitError(bedrockJson.message)) {
+        return {
+          currentTokens: 0,
+          maxTokens: 0,
+          errorType: "bedrock_input_too_long"
+        };
+      }
+    } catch {}
+  }
+  for (const text of textSources) {
+    const tokens = extractTokensFromMessage(text);
+    if (tokens) {
+      return {
+        currentTokens: tokens.current,
+        maxTokens: tokens.max,
+        errorType: "token_limit_exceeded"
+      };
+    }
+  }
+  if (combinedText.toLowerCase().includes("non-empty content")) {
+    return {
+      currentTokens: 0,
+      maxTokens: 0,
+      errorType: "non-empty content",
+      messageIndex: extractMessageIndex2(combinedText)
+    };
+  }
+  if (isTokenLimitError(combinedText)) {
+    return {
+      currentTokens: 0,
+      maxTokens: 0,
+      errorType: "token_limit_exceeded_unknown"
+    };
+  }
+  return null;
+}
+
+// src/hooks/anthropic-auto-compact/types.ts
+var RETRY_CONFIG = {
+  maxAttempts: 2,
+  initialDelayMs: 2000,
+  backoffFactor: 2,
+  maxDelayMs: 30000
+};
+var FALLBACK_CONFIG = {
+  maxRevertAttempts: 3,
+  minMessagesRequired: 2
+};
+var TRUNCATE_CONFIG = {
+  maxTruncateAttempts: 20,
+  minOutputSizeToTruncate: 500,
+  targetTokenRatio: 0.5,
+  charsPerToken: 4
+};
+
+// src/hooks/anthropic-auto-compact/pruning-deduplication.ts
+import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { join as join20 } from "path";
+
+// src/hooks/anthropic-auto-compact/pruning-types.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens2(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+// src/hooks/anthropic-auto-compact/pruning-deduplication.ts
+var MESSAGE_STORAGE3 = join20(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
+function createToolSignature(toolName, input) {
+  const sortedInput = sortObject(input);
+  return `${toolName}::${JSON.stringify(sortedInput)}`;
+}
+function sortObject(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(sortObject);
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = sortObject(obj[key]);
+  }
+  return sorted;
+}
+function getMessageDir3(sessionID) {
+  if (!existsSync15(MESSAGE_STORAGE3))
+    return null;
+  const directPath = join20(MESSAGE_STORAGE3, sessionID);
+  if (existsSync15(directPath))
+    return directPath;
+  for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
+    const sessionPath = join20(MESSAGE_STORAGE3, dir, sessionID);
+    if (existsSync15(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
+function readMessages2(sessionID) {
+  const messageDir = getMessageDir3(sessionID);
+  if (!messageDir)
+    return [];
+  const messages = [];
+  try {
+    const files = readdirSync4(messageDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const content = readFileSync9(join20(messageDir, file), "utf-8");
+      const data = JSON.parse(content);
+      if (data.parts) {
+        messages.push(data);
+      }
+    }
+  } catch {
+    return [];
+  }
+  return messages;
+}
+function executeDeduplication(sessionID, state2, config, protectedTools) {
+  if (!config.enabled)
+    return 0;
+  const messages = readMessages2(sessionID);
+  const signatures = new Map;
+  let currentTurn = 0;
+  for (const msg of messages) {
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        currentTurn++;
+        continue;
+      }
+      if (part.type !== "tool" || !part.callID || !part.tool)
+        continue;
+      if (protectedTools.has(part.tool))
+        continue;
+      if (config.protectedTools?.includes(part.tool))
+        continue;
+      if (state2.toolIdsToPrune.has(part.callID))
+        continue;
+      const signature = createToolSignature(part.tool, part.state?.input);
+      if (!signatures.has(signature)) {
+        signatures.set(signature, []);
+      }
+      signatures.get(signature).push({
+        toolName: part.tool,
+        signature,
+        callID: part.callID,
+        turn: currentTurn
+      });
+      if (!state2.toolSignatures.has(signature)) {
+        state2.toolSignatures.set(signature, []);
+      }
+      state2.toolSignatures.get(signature).push({
+        toolName: part.tool,
+        signature,
+        callID: part.callID,
+        turn: currentTurn
+      });
+    }
+  }
+  let prunedCount = 0;
+  let tokensSaved = 0;
+  for (const [signature, calls] of signatures) {
+    if (calls.length > 1) {
+      const toPrune = calls.slice(0, -1);
+      for (const call of toPrune) {
+        state2.toolIdsToPrune.add(call.callID);
+        prunedCount++;
+        const output = findToolOutput(messages, call.callID);
+        if (output) {
+          tokensSaved += estimateTokens2(output);
+        }
+        log("[pruning-deduplication] pruned duplicate", {
+          tool: call.toolName,
+          callID: call.callID,
+          turn: call.turn,
+          signature: signature.substring(0, 100)
+        });
+      }
+    }
+  }
+  log("[pruning-deduplication] complete", {
+    prunedCount,
+    tokensSaved,
+    uniqueSignatures: signatures.size
+  });
+  return prunedCount;
+}
+function findToolOutput(messages, callID) {
+  for (const msg of messages) {
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.callID === callID && part.state?.output) {
+        return part.state.output;
+      }
+    }
+  }
+  return null;
+}
+
+// src/hooks/anthropic-auto-compact/pruning-supersede.ts
+import { existsSync as existsSync16, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
+import { join as join21 } from "path";
+var MESSAGE_STORAGE4 = join21(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
+function getMessageDir4(sessionID) {
+  if (!existsSync16(MESSAGE_STORAGE4))
+    return null;
+  const directPath = join21(MESSAGE_STORAGE4, sessionID);
+  if (existsSync16(directPath))
+    return directPath;
+  for (const dir of readdirSync5(MESSAGE_STORAGE4)) {
+    const sessionPath = join21(MESSAGE_STORAGE4, dir, sessionID);
+    if (existsSync16(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
+function readMessages3(sessionID) {
+  const messageDir = getMessageDir4(sessionID);
+  if (!messageDir)
+    return [];
+  const messages = [];
+  try {
+    const files = readdirSync5(messageDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const content = readFileSync10(join21(messageDir, file), "utf-8");
+      const data = JSON.parse(content);
+      if (data.parts) {
+        messages.push(data);
+      }
+    }
+  } catch {
+    return [];
+  }
+  return messages;
+}
+function extractFilePath(toolName, input) {
+  if (!input || typeof input !== "object")
+    return null;
+  const inputObj = input;
+  if (toolName === "write" || toolName === "edit" || toolName === "read") {
+    if (typeof inputObj.filePath === "string") {
+      return inputObj.filePath;
+    }
+  }
+  return null;
+}
+function executeSupersedeWrites(sessionID, state2, config, protectedTools) {
+  if (!config.enabled)
+    return 0;
+  const messages = readMessages3(sessionID);
+  const writesByFile = new Map;
+  const readsByFile = new Map;
+  let currentTurn = 0;
+  for (const msg of messages) {
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        currentTurn++;
+        continue;
+      }
+      if (part.type !== "tool" || !part.callID || !part.tool)
+        continue;
+      if (protectedTools.has(part.tool))
+        continue;
+      if (state2.toolIdsToPrune.has(part.callID))
+        continue;
+      const filePath = extractFilePath(part.tool, part.state?.input);
+      if (!filePath)
+        continue;
+      if (part.tool === "write" || part.tool === "edit") {
+        if (!writesByFile.has(filePath)) {
+          writesByFile.set(filePath, []);
+        }
+        writesByFile.get(filePath).push({
+          callID: part.callID,
+          tool: part.tool,
+          filePath,
+          turn: currentTurn
+        });
+        if (!state2.fileOperations.has(filePath)) {
+          state2.fileOperations.set(filePath, []);
+        }
+        state2.fileOperations.get(filePath).push({
+          callID: part.callID,
+          tool: part.tool,
+          filePath,
+          turn: currentTurn
+        });
+      } else if (part.tool === "read") {
+        if (!readsByFile.has(filePath)) {
+          readsByFile.set(filePath, []);
+        }
+        readsByFile.get(filePath).push(currentTurn);
+      }
+    }
+  }
+  let prunedCount = 0;
+  let tokensSaved = 0;
+  for (const [filePath, writes] of writesByFile) {
+    const reads = readsByFile.get(filePath) || [];
+    if (config.aggressive) {
+      for (const write of writes) {
+        const superseded = reads.some((readTurn) => readTurn > write.turn);
+        if (superseded) {
+          state2.toolIdsToPrune.add(write.callID);
+          prunedCount++;
+          const input = findToolInput(messages, write.callID);
+          if (input) {
+            tokensSaved += estimateTokens2(JSON.stringify(input));
+          }
+          log("[pruning-supersede] pruned superseded write", {
+            tool: write.tool,
+            callID: write.callID,
+            turn: write.turn,
+            filePath
+          });
+        }
+      }
+    } else {
+      if (writes.length > 1) {
+        for (const write of writes.slice(0, -1)) {
+          const superseded = reads.some((readTurn) => readTurn > write.turn);
+          if (superseded) {
+            state2.toolIdsToPrune.add(write.callID);
+            prunedCount++;
+            const input = findToolInput(messages, write.callID);
+            if (input) {
+              tokensSaved += estimateTokens2(JSON.stringify(input));
             }
-          } catch {}
+            log("[pruning-supersede] pruned superseded write (conservative)", {
+              tool: write.tool,
+              callID: write.callID,
+              turn: write.turn,
+              filePath
+            });
+          }
         }
       }
-      const bedrockJson = JSON.parse(responseBody);
-      if (typeof bedrockJson.message === "string" && isTokenLimitError(bedrockJson.message)) {
-        return {
-          currentTokens: 0,
-          maxTokens: 0,
-          errorType: "bedrock_input_too_long"
-        };
+    }
+  }
+  log("[pruning-supersede] complete", {
+    prunedCount,
+    tokensSaved,
+    filesTracked: writesByFile.size,
+    mode: config.aggressive ? "aggressive" : "conservative"
+  });
+  return prunedCount;
+}
+function findToolInput(messages, callID) {
+  for (const msg of messages) {
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.callID === callID && part.state?.input) {
+        return part.state.input;
       }
-    } catch {}
+    }
   }
-  for (const text of textSources) {
-    const tokens = extractTokensFromMessage(text);
-    if (tokens) {
-      return {
-        currentTokens: tokens.current,
-        maxTokens: tokens.max,
-        errorType: "token_limit_exceeded"
-      };
+  return null;
+}
+
+// src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
+import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join22 } from "path";
+var MESSAGE_STORAGE5 = join22(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
+function getMessageDir5(sessionID) {
+  if (!existsSync17(MESSAGE_STORAGE5))
+    return null;
+  const directPath = join22(MESSAGE_STORAGE5, sessionID);
+  if (existsSync17(directPath))
+    return directPath;
+  for (const dir of readdirSync6(MESSAGE_STORAGE5)) {
+    const sessionPath = join22(MESSAGE_STORAGE5, dir, sessionID);
+    if (existsSync17(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
+function readMessages4(sessionID) {
+  const messageDir = getMessageDir5(sessionID);
+  if (!messageDir)
+    return [];
+  const messages = [];
+  try {
+    const files = readdirSync6(messageDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const content = readFileSync11(join22(messageDir, file), "utf-8");
+      const data = JSON.parse(content);
+      if (data.parts) {
+        messages.push(data);
+      }
     }
+  } catch {
+    return [];
   }
-  if (combinedText.toLowerCase().includes("non-empty content")) {
-    return {
-      currentTokens: 0,
-      maxTokens: 0,
-      errorType: "non-empty content",
-      messageIndex: extractMessageIndex2(combinedText)
-    };
+  return messages;
+}
+function executePurgeErrors(sessionID, state2, config, protectedTools) {
+  if (!config.enabled)
+    return 0;
+  const messages = readMessages4(sessionID);
+  let currentTurn = 0;
+  for (const msg of messages) {
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        currentTurn++;
+      }
+    }
   }
-  if (isTokenLimitError(combinedText)) {
-    return {
-      currentTokens: 0,
-      maxTokens: 0,
-      errorType: "token_limit_exceeded_unknown"
-    };
+  state2.currentTurn = currentTurn;
+  let turnCounter = 0;
+  let prunedCount = 0;
+  let tokensSaved = 0;
+  for (const msg of messages) {
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      if (part.type === "step-start") {
+        turnCounter++;
+        continue;
+      }
+      if (part.type !== "tool" || !part.callID || !part.tool)
+        continue;
+      if (protectedTools.has(part.tool))
+        continue;
+      if (config.protectedTools?.includes(part.tool))
+        continue;
+      if (state2.toolIdsToPrune.has(part.callID))
+        continue;
+      if (part.state?.status !== "error")
+        continue;
+      const turnAge = currentTurn - turnCounter;
+      if (turnAge >= config.turns) {
+        state2.toolIdsToPrune.add(part.callID);
+        prunedCount++;
+        const input = part.state.input;
+        if (input) {
+          tokensSaved += estimateTokens2(JSON.stringify(input));
+        }
+        const errorInfo = {
+          callID: part.callID,
+          toolName: part.tool,
+          turn: turnCounter,
+          errorAge: turnAge
+        };
+        state2.erroredTools.set(part.callID, errorInfo);
+        log("[pruning-purge-errors] pruned old error", {
+          tool: part.tool,
+          callID: part.callID,
+          turn: turnCounter,
+          errorAge: turnAge,
+          threshold: config.turns
+        });
+      }
+    }
+  }
+  log("[pruning-purge-errors] complete", {
+    prunedCount,
+    tokensSaved,
+    currentTurn,
+    threshold: config.turns
+  });
+  return prunedCount;
+}
+
+// src/hooks/anthropic-auto-compact/pruning-storage.ts
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
+import { join as join23 } from "path";
+var MESSAGE_STORAGE6 = join23(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
+function getMessageDir6(sessionID) {
+  if (!existsSync18(MESSAGE_STORAGE6))
+    return null;
+  const directPath = join23(MESSAGE_STORAGE6, sessionID);
+  if (existsSync18(directPath))
+    return directPath;
+  for (const dir of readdirSync7(MESSAGE_STORAGE6)) {
+    const sessionPath = join23(MESSAGE_STORAGE6, dir, sessionID);
+    if (existsSync18(sessionPath))
+      return sessionPath;
   }
   return null;
 }
+async function applyPruning(sessionID, state2) {
+  const messageDir = getMessageDir6(sessionID);
+  if (!messageDir) {
+    log("[pruning-storage] message dir not found", { sessionID });
+    return 0;
+  }
+  let totalTokensSaved = 0;
+  let filesModified = 0;
+  try {
+    const files = readdirSync7(messageDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const filePath = join23(messageDir, file);
+      const content = readFileSync12(filePath, "utf-8");
+      const data = JSON.parse(content);
+      if (!data.parts)
+        continue;
+      let modified = false;
+      for (const part of data.parts) {
+        if (part.type !== "tool" || !part.callID)
+          continue;
+        if (!state2.toolIdsToPrune.has(part.callID))
+          continue;
+        if (part.state?.input) {
+          const inputStr = JSON.stringify(part.state.input);
+          totalTokensSaved += estimateTokens2(inputStr);
+          part.state.input = { __pruned: true, reason: "DCP" };
+          modified = true;
+        }
+        if (part.state?.output) {
+          totalTokensSaved += estimateTokens2(part.state.output);
+          part.state.output = "[Content pruned by Dynamic Context Pruning]";
+          modified = true;
+        }
+      }
+      if (modified) {
+        writeFileSync5(filePath, JSON.stringify(data, null, 2), "utf-8");
+        filesModified++;
+      }
+    }
+  } catch (error) {
+    log("[pruning-storage] error applying pruning", {
+      sessionID,
+      error: String(error)
+    });
+  }
+  log("[pruning-storage] applied pruning", {
+    sessionID,
+    filesModified,
+    totalTokensSaved
+  });
+  return totalTokensSaved;
+}
 
-// src/hooks/anthropic-auto-compact/types.ts
-var RETRY_CONFIG = {
-  maxAttempts: 2,
-  initialDelayMs: 2000,
-  backoffFactor: 2,
-  maxDelayMs: 30000
-};
-var FALLBACK_CONFIG = {
-  maxRevertAttempts: 3,
-  minMessagesRequired: 2
-};
-var TRUNCATE_CONFIG = {
-  maxTruncateAttempts: 20,
-  minOutputSizeToTruncate: 500,
-  targetTokenRatio: 0.5,
-  charsPerToken: 4
-};
+// src/hooks/anthropic-auto-compact/pruning-executor.ts
+var DEFAULT_PROTECTED_TOOLS = new Set([
+  "task",
+  "todowrite",
+  "todoread",
+  "lsp_rename",
+  "lsp_code_action_resolve",
+  "session_read",
+  "session_write",
+  "session_search"
+]);
+function createPruningState() {
+  return {
+    toolIdsToPrune: new Set,
+    currentTurn: 0,
+    fileOperations: new Map,
+    toolSignatures: new Map,
+    erroredTools: new Map
+  };
+}
+async function executeDynamicContextPruning(sessionID, config, client) {
+  const state2 = createPruningState();
+  const protectedTools = new Set([
+    ...DEFAULT_PROTECTED_TOOLS,
+    ...config.protected_tools || []
+  ]);
+  log("[pruning-executor] starting DCP", {
+    sessionID,
+    notification: config.notification,
+    turnProtection: config.turn_protection
+  });
+  let dedupCount = 0;
+  let supersedeCount = 0;
+  let purgeCount = 0;
+  if (config.strategies?.deduplication?.enabled !== false) {
+    dedupCount = executeDeduplication(sessionID, state2, { enabled: true }, protectedTools);
+  }
+  if (config.strategies?.supersede_writes?.enabled !== false) {
+    supersedeCount = executeSupersedeWrites(sessionID, state2, {
+      enabled: true,
+      aggressive: config.strategies?.supersede_writes?.aggressive || false
+    }, protectedTools);
+  }
+  if (config.strategies?.purge_errors?.enabled !== false) {
+    purgeCount = executePurgeErrors(sessionID, state2, {
+      enabled: true,
+      turns: config.strategies?.purge_errors?.turns || 5
+    }, protectedTools);
+  }
+  const totalPruned = state2.toolIdsToPrune.size;
+  const tokensSaved = await applyPruning(sessionID, state2);
+  log("[pruning-executor] DCP complete", {
+    totalPruned,
+    tokensSaved,
+    deduplication: dedupCount,
+    supersede: supersedeCount,
+    purge: purgeCount
+  });
+  const result = {
+    itemsPruned: totalPruned,
+    totalTokensSaved: tokensSaved,
+    strategies: {
+      deduplication: dedupCount,
+      supersedeWrites: supersedeCount,
+      purgeErrors: purgeCount
+    }
+  };
+  if (config.notification !== "off" && totalPruned > 0) {
+    const message = config.notification === "detailed" ? `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens). Dedup: ${dedupCount}, Supersede: ${supersedeCount}, Purge: ${purgeCount}` : `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens)`;
+    await client.tui.showToast({
+      body: {
+        title: "Dynamic Context Pruning",
+        message,
+        variant: "success",
+        duration: 3000
+      }
+    }).catch(() => {});
+  }
+  return result;
+}
 
 // src/hooks/anthropic-auto-compact/storage.ts
-import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join19 } from "path";
-var OPENCODE_STORAGE5 = join19(xdgData ?? "", "opencode", "storage");
-if (process.platform === "darwin" && !existsSync14(OPENCODE_STORAGE5)) {
-  const localShare = join19(homedir5(), ".local", "share", "opencode", "storage");
-  if (existsSync14(localShare)) {
+import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join24 } from "path";
+var OPENCODE_STORAGE5 = join24(xdgData ?? "", "opencode", "storage");
+if (process.platform === "darwin" && !existsSync19(OPENCODE_STORAGE5)) {
+  const localShare = join24(homedir6(), ".local", "share", "opencode", "storage");
+  if (existsSync19(localShare)) {
     OPENCODE_STORAGE5 = localShare;
   }
 }
-var MESSAGE_STORAGE3 = join19(OPENCODE_STORAGE5, "message");
-var PART_STORAGE3 = join19(OPENCODE_STORAGE5, "part");
+var MESSAGE_STORAGE7 = join24(OPENCODE_STORAGE5, "message");
+var PART_STORAGE3 = join24(OPENCODE_STORAGE5, "part");
 var TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";
-function getMessageDir3(sessionID) {
-  if (!existsSync14(MESSAGE_STORAGE3))
+function getMessageDir7(sessionID) {
+  if (!existsSync19(MESSAGE_STORAGE7))
     return "";
-  const directPath = join19(MESSAGE_STORAGE3, sessionID);
-  if (existsSync14(directPath)) {
+  const directPath = join24(MESSAGE_STORAGE7, sessionID);
+  if (existsSync19(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
-    const sessionPath = join19(MESSAGE_STORAGE3, dir, sessionID);
-    if (existsSync14(sessionPath)) {
+  for (const dir of readdirSync8(MESSAGE_STORAGE7)) {
+    const sessionPath = join24(MESSAGE_STORAGE7, dir, sessionID);
+    if (existsSync19(sessionPath)) {
       return sessionPath;
     }
   }
   return "";
 }
 function getMessageIds(sessionID) {
-  const messageDir = getMessageDir3(sessionID);
-  if (!messageDir || !existsSync14(messageDir))
+  const messageDir = getMessageDir7(sessionID);
+  if (!messageDir || !existsSync19(messageDir))
     return [];
   const messageIds = [];
-  for (const file of readdirSync4(messageDir)) {
+  for (const file of readdirSync8(messageDir)) {
     if (!file.endsWith(".json"))
       continue;
     const messageId = file.replace(".json", "");
@@ -5635,15 +7256,15 @@ function findToolResultsBySize(sessionID) {
   const messageIds = getMessageIds(sessionID);
   const results = [];
   for (const messageID of messageIds) {
-    const partDir = join19(PART_STORAGE3, messageID);
-    if (!existsSync14(partDir))
+    const partDir = join24(PART_STORAGE3, messageID);
+    if (!existsSync19(partDir))
       continue;
-    for (const file of readdirSync4(partDir)) {
+    for (const file of readdirSync8(partDir)) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const partPath = join19(partDir, file);
-        const content = readFileSync8(partPath, "utf-8");
+        const partPath = join24(partDir, file);
+        const content = readFileSync13(partPath, "utf-8");
         const part = JSON.parse(content);
         if (part.type === "tool" && part.state?.output && !part.truncated) {
           results.push({
@@ -5667,7 +7288,7 @@ function findLargestToolResult(sessionID) {
 }
 function truncateToolResult(partPath) {
   try {
-    const content = readFileSync8(partPath, "utf-8");
+    const content = readFileSync13(partPath, "utf-8");
     const part = JSON.parse(content);
     if (!part.state?.output) {
       return { success: false };
@@ -5681,7 +7302,7 @@ function truncateToolResult(partPath) {
       part.state.time = { start: Date.now() };
     }
     part.state.time.compacted = Date.now();
-    writeFileSync5(partPath, JSON.stringify(part, null, 2));
+    writeFileSync6(partPath, JSON.stringify(part, null, 2));
     return { success: true, toolName, originalSize };
   } catch {
     return { success: false };
@@ -5763,6 +7384,14 @@ function getOrCreateTruncateState(autoCompactState, sessionID) {
   }
   return state2;
 }
+function getOrCreateDcpState(autoCompactState, sessionID) {
+  let state2 = autoCompactState.dcpStateBySession.get(sessionID);
+  if (!state2) {
+    state2 = { attempted: false, itemsPruned: 0 };
+    autoCompactState.dcpStateBySession.set(sessionID, state2);
+  }
+  return state2;
+}
 async function getLastMessagePair(sessionID, client, directory) {
   try {
     const resp = await client.session.messages({
@@ -5835,6 +7464,7 @@ function clearSessionState(autoCompactState, sessionID) {
   autoCompactState.retryStateBySession.delete(sessionID);
   autoCompactState.fallbackStateBySession.delete(sessionID);
   autoCompactState.truncateStateBySession.delete(sessionID);
+  autoCompactState.dcpStateBySession.delete(sessionID);
   autoCompactState.emptyContentAttemptBySession.delete(sessionID);
   autoCompactState.compactionInProgress.delete(sessionID);
 }
@@ -6085,6 +7715,45 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
         }).catch(() => {});
       }
     }
+    const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
+    if (experimental?.dcp_on_compaction_failure && !dcpState.attempted) {
+      dcpState.attempted = true;
+      log("[auto-compact] attempting DCP after summarize failed", { sessionID });
+      const dcpConfig = experimental.dynamic_context_pruning ?? {
+        enabled: true,
+        notification: "detailed",
+        protected_tools: ["task", "todowrite", "todoread", "lsp_rename", "lsp_code_action_resolve"]
+      };
+      try {
+        const pruningResult = await executeDynamicContextPruning(sessionID, dcpConfig, client);
+        if (pruningResult.itemsPruned > 0) {
+          dcpState.itemsPruned = pruningResult.itemsPruned;
+          log("[auto-compact] DCP successful, retrying compaction", {
+            itemsPruned: pruningResult.itemsPruned,
+            tokensSaved: pruningResult.totalTokensSaved
+          });
+          await client.tui.showToast({
+            body: {
+              title: "Dynamic Context Pruning",
+              message: `Pruned ${pruningResult.itemsPruned} items (~${Math.round(pruningResult.totalTokensSaved / 1000)}k tokens). Retrying compaction...`,
+              variant: "success",
+              duration: 3000
+            }
+          }).catch(() => {});
+          retryState.attempt = 0;
+          setTimeout(() => {
+            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
+          }, 500);
+          return;
+        } else {
+          log("[auto-compact] DCP did not prune any items, continuing to revert", { sessionID });
+        }
+      } catch (error) {
+        log("[auto-compact] DCP failed, continuing to revert", {
+          error: String(error)
+        });
+      }
+    }
     const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
     if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
       const pair = await getLastMessagePair(sessionID, client, directory);
@@ -6157,6 +7826,7 @@ function createAutoCompactState() {
     retryStateBySession: new Map,
     fallbackStateBySession: new Map,
     truncateStateBySession: new Map,
+    dcpStateBySession: new Map,
     emptyContentAttemptBySession: new Map,
     compactionInProgress: new Set
   };
@@ -6174,6 +7844,7 @@ function createAnthropicAutoCompactHook(ctx, options) {
         autoCompactState.retryStateBySession.delete(sessionInfo.id);
         autoCompactState.fallbackStateBySession.delete(sessionInfo.id);
         autoCompactState.truncateStateBySession.delete(sessionInfo.id);
+        autoCompactState.dcpStateBySession.delete(sessionInfo.id);
         autoCompactState.emptyContentAttemptBySession.delete(sessionInfo.id);
         autoCompactState.compactionInProgress.delete(sessionInfo.id);
       }
@@ -6255,8 +7926,8 @@ function createAnthropicAutoCompactHook(ctx, options) {
   };
 }
 // src/hooks/preemptive-compaction/index.ts
-import { existsSync as existsSync15, readdirSync as readdirSync5 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync9 } from "fs";
+import { join as join25 } from "path";
 
 // src/hooks/preemptive-compaction/constants.ts
 var DEFAULT_THRESHOLD = 0.85;
@@ -6269,15 +7940,15 @@ var CLAUDE_DEFAULT_CONTEXT_LIMIT = 200000;
 function isSupportedModel(modelID) {
   return CLAUDE_MODEL_PATTERN.test(modelID);
 }
-function getMessageDir4(sessionID) {
-  if (!existsSync15(MESSAGE_STORAGE))
+function getMessageDir8(sessionID) {
+  if (!existsSync20(MESSAGE_STORAGE))
     return null;
-  const directPath = join20(MESSAGE_STORAGE, sessionID);
-  if (existsSync15(directPath))
+  const directPath = join25(MESSAGE_STORAGE, sessionID);
+  if (existsSync20(directPath))
     return directPath;
-  for (const dir of readdirSync5(MESSAGE_STORAGE)) {
-    const sessionPath = join20(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync15(sessionPath))
+  for (const dir of readdirSync9(MESSAGE_STORAGE)) {
+    const sessionPath = join25(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync20(sessionPath))
       return sessionPath;
   }
   return null;
@@ -6371,7 +8042,7 @@ function createPreemptiveCompactionHook(ctx, options) {
       state2.compactionInProgress.delete(sessionID);
       setTimeout(async () => {
         try {
-          const messageDir = getMessageDir4(sessionID);
+          const messageDir = getMessageDir8(sessionID);
           const storedMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
           await ctx.client.session.promptAsync({
             path: { id: sessionID },
@@ -6427,7 +8098,7 @@ function createPreemptiveCompactionHook(ctx, options) {
           return;
         const lastAssistant = assistants[assistants.length - 1];
         if (!lastAssistant.providerID || !lastAssistant.modelID) {
-          const messageDir = getMessageDir4(sessionID);
+          const messageDir = getMessageDir8(sessionID);
           const storedMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
           if (storedMessage?.model?.providerID && storedMessage?.model?.modelID) {
             lastAssistant.providerID = storedMessage.model.providerID;
@@ -6761,9 +8432,8 @@ function createThinkModeHook() {
   };
 }
 // src/hooks/claude-code-hooks/config.ts
-import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
-import { existsSync as existsSync16 } from "fs";
+import { join as join26 } from "path";
+import { existsSync as existsSync21 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -6787,13 +8457,13 @@ function normalizeHooksConfig(raw) {
   return result;
 }
 function getClaudeSettingsPaths(customPath) {
-  const home = homedir6();
+  const claudeConfigDir = getClaudeConfigDir();
   const paths = [
-    join21(home, ".claude", "settings.json"),
-    join21(process.cwd(), ".claude", "settings.json"),
-    join21(process.cwd(), ".claude", "settings.local.json")
+    join26(claudeConfigDir, "settings.json"),
+    join26(process.cwd(), ".claude", "settings.json"),
+    join26(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync16(customPath)) {
+  if (customPath && existsSync21(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -6818,7 +8488,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync16(settingsPath)) {
+    if (existsSync21(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -6835,15 +8505,15 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join22 } from "path";
-var USER_CONFIG_PATH = join22(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
+import { join as join27 } from "path";
+var USER_CONFIG_PATH = join27(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join22(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join27(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path5) {
-  if (!existsSync17(path5)) {
+  if (!existsSync22(path5)) {
     return null;
   }
   try {
@@ -7023,16 +8693,16 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
 }
 
 // src/hooks/claude-code-hooks/transcript.ts
-import { join as join23 } from "path";
-import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync18, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
-import { homedir as homedir8, tmpdir as tmpdir5 } from "os";
+import { join as join28 } from "path";
+import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync23, writeFileSync as writeFileSync7, unlinkSync as unlinkSync5 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join23(homedir8(), ".claude", "transcripts");
+var TRANSCRIPT_DIR = join28(getClaudeConfigDir(), "transcripts");
 function getTranscriptPath(sessionId) {
-  return join23(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join28(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync18(TRANSCRIPT_DIR)) {
+  if (!existsSync23(TRANSCRIPT_DIR)) {
     mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
   }
 }
@@ -7119,8 +8789,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join23(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-    writeFileSync6(tempPath, entries.join(`
+    const tempPath = join28(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync7(tempPath, entries.join(`
 `) + `
 `);
     return tempPath;
@@ -7139,8 +8809,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join23(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync6(tempPath, JSON.stringify(currentEntry) + `
+      const tempPath = join28(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync7(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
     } catch {
@@ -7351,11 +9021,10 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 }
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join24 } from "path";
-import { homedir as homedir9 } from "os";
-var TODO_DIR = join24(homedir9(), ".claude", "todos");
+import { join as join29 } from "path";
+var TODO_DIR = join29(getClaudeConfigDir(), "todos");
 function getTodoPath(sessionId) {
-  return join24(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join29(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -7779,23 +9448,23 @@ ${result.message}`;
   };
 }
 // src/hooks/rules-injector/index.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { homedir as homedir10 } from "os";
+import { readFileSync as readFileSync15 } from "fs";
+import { homedir as homedir8 } from "os";
 import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync19,
-  readdirSync as readdirSync6,
+  existsSync as existsSync24,
+  readdirSync as readdirSync10,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join26, relative } from "path";
+import { dirname as dirname4, join as join31, relative } from "path";
 
 // src/hooks/rules-injector/constants.ts
-import { join as join25 } from "path";
-var OPENCODE_STORAGE6 = join25(xdgData ?? "", "opencode", "storage");
-var RULES_INJECTOR_STORAGE = join25(OPENCODE_STORAGE6, "rules-injector");
+import { join as join30 } from "path";
+var OPENCODE_STORAGE6 = join30(xdgData ?? "", "opencode", "storage");
+var RULES_INJECTOR_STORAGE = join30(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -7822,8 +9491,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join26(current, marker);
-      if (existsSync19(markerPath)) {
+      const markerPath = join31(current, marker);
+      if (existsSync24(markerPath)) {
         return current;
       }
     }
@@ -7835,12 +9504,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync19(dir))
+  if (!existsSync24(dir))
     return;
   try {
-    const entries = readdirSync6(dir, { withFileTypes: true });
+    const entries = readdirSync10(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join26(dir, entry.name);
+      const fullPath = join31(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -7866,7 +9535,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join26(currentDir, parent, subdir);
+      const ruleDir = join31(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -7890,7 +9559,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
     currentDir = parentDir;
     distance++;
   }
-  const userRuleDir = join26(homeDir, USER_RULE_DIR);
+  const userRuleDir = join31(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -8079,22 +9748,22 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync9,
-  writeFileSync as writeFileSync7,
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync8,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join27 } from "path";
+import { join as join32 } from "path";
 function getStoragePath3(sessionID) {
-  return join27(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join32(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync20(filePath))
+  if (!existsSync25(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -8105,7 +9774,7 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync20(RULES_INJECTOR_STORAGE)) {
+  if (!existsSync25(RULES_INJECTOR_STORAGE)) {
     mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
@@ -8114,11 +9783,11 @@ function saveInjectedRules(sessionID, data) {
     injectedRealPaths: [...data.realPaths],
     updatedAt: Date.now()
   };
-  writeFileSync7(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
+  writeFileSync8(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync20(filePath)) {
+  if (existsSync25(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -8148,14 +9817,14 @@ function createRulesInjectorHook(ctx) {
       return;
     const projectRoot = findProjectRoot(resolved);
     const cache2 = getSessionCache(sessionID);
-    const home = homedir10();
+    const home = homedir8();
     const ruleFileCandidates = findRuleFiles(projectRoot, home, resolved);
     const toInject = [];
     for (const candidate of ruleFileCandidates) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
         continue;
       try {
-        const rawContent = readFileSync10(candidate.path, "utf-8");
+        const rawContent = readFileSync15(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
         const matchResult = shouldApplyRule(metadata, resolved, projectRoot);
         if (!matchResult.applies)
@@ -8559,11 +10228,11 @@ v${latestVersion} available. Restart OpenCode to apply.` : `OpenCode is now on S
       if (props?.info?.parentID)
         return;
       hasChecked = true;
-      setTimeout(() => {
+      setTimeout(async () => {
         const cachedVersion = getCachedVersion();
         const localDevVersion = getLocalDevVersion(ctx.directory);
         const displayVersion = localDevVersion ?? cachedVersion;
-        showConfigErrorsIfAny(ctx).catch(() => {});
+        await showConfigErrorsIfAny(ctx);
         if (localDevVersion) {
           if (showStartupToast) {
             showLocalDevToast(ctx, displayVersion, isSisyphusEnabled).catch(() => {});
@@ -8693,18 +10362,18 @@ async function showLocalDevToast(ctx, version, isSisyphusEnabled) {
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
-  writeFileSync as writeFileSync10,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync11,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join32 } from "path";
+import { join as join37 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
-import { join as join31 } from "path";
-var OPENCODE_STORAGE7 = join31(xdgData ?? "", "opencode", "storage");
-var AGENT_USAGE_REMINDER_STORAGE = join31(OPENCODE_STORAGE7, "agent-usage-reminder");
+import { join as join36 } from "path";
+var OPENCODE_STORAGE7 = join36(xdgData ?? "", "opencode", "storage");
+var AGENT_USAGE_REMINDER_STORAGE = join36(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -8749,29 +10418,29 @@ ALWAYS prefer: Multiple parallel background_task calls > Direct tool calls
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath4(sessionID) {
-  return join32(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join37(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync23(filePath))
+  if (!existsSync28(filePath))
     return null;
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync18(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveAgentUsageState(state2) {
-  if (!existsSync23(AGENT_USAGE_REMINDER_STORAGE)) {
+  if (!existsSync28(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state2.sessionID);
-  writeFileSync10(filePath, JSON.stringify(state2, null, 2));
+  writeFileSync11(filePath, JSON.stringify(state2, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync23(filePath)) {
+  if (existsSync28(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -8873,12 +10542,23 @@ TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 3. Always Use Plan agent with gathered context to create detailed work breakdown
 4. Execute with continuous verification against original requirements
 
+## TDD (if test infrastructure exists)
+
+1. Write spec (requirements)
+2. Write tests (failing)
+3. RED: tests fail
+4. Implement minimal code
+5. GREEN: tests pass
+6. Refactor if needed (must stay green)
+7. Next feature, repeat
+
 ## ZERO TOLERANCE FAILURES
 - **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
 - **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
 - **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
 - **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
 - **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
+- **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests.
 
 THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
 
@@ -9066,18 +10746,18 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync24,
+  existsSync as existsSync29,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync14,
-  writeFileSync as writeFileSync11,
+  readFileSync as readFileSync19,
+  writeFileSync as writeFileSync12,
   unlinkSync as unlinkSync8
 } from "fs";
-import { join as join34 } from "path";
+import { join as join39 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
-import { join as join33 } from "path";
-var OPENCODE_STORAGE8 = join33(xdgData ?? "", "opencode", "storage");
-var INTERACTIVE_BASH_SESSION_STORAGE = join33(OPENCODE_STORAGE8, "interactive-bash-session");
+import { join as join38 } from "path";
+var OPENCODE_STORAGE8 = join38(xdgData ?? "", "opencode", "storage");
+var INTERACTIVE_BASH_SESSION_STORAGE = join38(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -9089,14 +10769,14 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath5(sessionID) {
-  return join34(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join39(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync24(filePath))
+  if (!existsSync29(filePath))
     return null;
   try {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync19(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -9108,7 +10788,7 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync24(INTERACTIVE_BASH_SESSION_STORAGE)) {
+  if (!existsSync29(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state2.sessionID);
@@ -9117,11 +10797,11 @@ function saveInteractiveBashSessionState(state2) {
     tmuxSessions: Array.from(state2.tmuxSessions),
     updatedAt: state2.updatedAt
   };
-  writeFileSync11(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync12(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (existsSync24(filePath)) {
+  if (existsSync29(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -9365,6 +11045,89 @@ function createEmptyMessageSanitizerHook() {
     }
   };
 }
+// src/hooks/thinking-block-validator/index.ts
+function isExtendedThinkingModel(modelID) {
+  if (!modelID)
+    return false;
+  const lower = modelID.toLowerCase();
+  if (lower.includes("thinking") || lower.endsWith("-high")) {
+    return true;
+  }
+  return lower.includes("claude-sonnet-4") || lower.includes("claude-opus-4") || lower.includes("claude-3");
+}
+function hasToolParts(parts) {
+  if (!parts || parts.length === 0)
+    return false;
+  return parts.some((part) => {
+    const type = part.type;
+    return type === "tool" || type === "tool_use";
+  });
+}
+function startsWithThinkingBlock(parts) {
+  if (!parts || parts.length === 0)
+    return false;
+  const firstPart = parts[0];
+  const type = firstPart.type;
+  return type === "thinking" || type === "reasoning";
+}
+function findPreviousThinkingContent(messages, currentIndex) {
+  for (let i = currentIndex - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.info.role !== "assistant")
+      continue;
+    if (!msg.parts)
+      continue;
+    for (const part of msg.parts) {
+      const type = part.type;
+      if (type === "thinking" || type === "reasoning") {
+        const thinking = part.thinking || part.text;
+        if (thinking && typeof thinking === "string" && thinking.trim().length > 0) {
+          return thinking;
+        }
+      }
+    }
+  }
+  return "";
+}
+function prependThinkingBlock(message, thinkingContent) {
+  if (!message.parts) {
+    message.parts = [];
+  }
+  const thinkingPart = {
+    type: "thinking",
+    id: `prt_0000000000_synthetic_thinking`,
+    sessionID: message.info.sessionID || "",
+    messageID: message.info.id,
+    thinking: thinkingContent,
+    synthetic: true
+  };
+  message.parts.unshift(thinkingPart);
+}
+function createThinkingBlockValidatorHook() {
+  return {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const { messages } = output;
+      if (!messages || messages.length === 0) {
+        return;
+      }
+      const lastUserMessage = messages.findLast((m) => m.info.role === "user");
+      const modelID = lastUserMessage?.info?.modelID || "";
+      if (!isExtendedThinkingModel(modelID)) {
+        return;
+      }
+      for (let i = 0;i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.info.role !== "assistant")
+          continue;
+        if (hasToolParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
+          const previousThinking = findPreviousThinkingContent(messages, i);
+          const thinkingContent = previousThinking || "[Continuing from previous reasoning]";
+          prependThinkingBlock(msg, thinkingContent);
+        }
+      }
+    }
+  };
+}
 // src/auth/antigravity/constants.ts
 var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var ANTIGRAVITY_CLIENT_SECRET = "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";
@@ -11065,22 +12828,21 @@ async function createGoogleAntigravityAuthPlugin({
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync25, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join35, basename } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync11, readFileSync as readFileSync20 } from "fs";
+import { join as join40, basename } from "path";
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync25(commandsDir)) {
+  if (!existsSync30(commandsDir)) {
     return [];
   }
-  const entries = readdirSync7(commandsDir, { withFileTypes: true });
+  const entries = readdirSync11(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join35(commandsDir, entry.name);
+    const commandPath = join40(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
-      const content = readFileSync15(commandPath, "utf-8");
+      const content = readFileSync20(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -11120,99 +12882,29 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join35(homedir12(), ".claude", "commands");
+  const userCommandsDir = join40(getClaudeConfigDir(), "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join35(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join40(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join35(homedir12(), ".config", "opencode", "command");
+  const { homedir: homedir10 } = __require("os");
+  const opencodeCommandsDir = join40(homedir10(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join35(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join40(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
-// src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync16 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join36 } from "path";
-function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync26(skillsDir)) {
-    return [];
-  }
-  const entries = readdirSync8(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    const skillPath = join36(skillsDir, entry.name);
-    if (!entry.isDirectory() && !entry.isSymbolicLink())
-      continue;
-    const resolvedPath = resolveSymlink(skillPath);
-    const skillMdPath = join36(resolvedPath, "SKILL.md");
-    if (!existsSync26(skillMdPath))
-      continue;
-    try {
-      const content = readFileSync16(skillMdPath, "utf-8");
-      const { data, body } = parseFrontmatter(content);
-      const skillName = data.name || entry.name;
-      const originalDescription = data.description || "";
-      const formattedDescription = `(${scope} - Skill) ${originalDescription}`;
-      const wrappedTemplate = `<skill-instruction>
-Base directory for this skill: ${resolvedPath}/
-File references (@path) in this skill are relative to this directory.
-
-${body.trim()}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`;
-      const definition = {
-        name: skillName,
-        description: formattedDescription,
-        template: wrappedTemplate,
-        model: sanitizeModelField(data.model)
-      };
-      skills.push({
-        name: skillName,
-        path: resolvedPath,
-        definition,
-        scope
-      });
-    } catch {
-      continue;
-    }
-  }
-  return skills;
-}
-function loadUserSkillsAsCommands() {
-  const userSkillsDir = join36(homedir13(), ".claude", "skills");
-  const skills = loadSkillsFromDir(userSkillsDir, "user");
-  return skills.reduce((acc, skill) => {
-    acc[skill.name] = skill.definition;
-    return acc;
-  }, {});
-}
-function loadProjectSkillsAsCommands() {
-  const projectSkillsDir = join36(process.cwd(), ".claude", "skills");
-  const skills = loadSkillsFromDir(projectSkillsDir, "project");
-  return skills.reduce((acc, skill) => {
-    acc[skill.name] = skill.definition;
-    return acc;
-  }, {});
-}
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync27, readdirSync as readdirSync9, readFileSync as readFileSync17 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join37, basename as basename2 } from "path";
+import { existsSync as existsSync31, readdirSync as readdirSync12, readFileSync as readFileSync21 } from "fs";
+import { join as join41, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -11226,18 +12918,18 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync27(agentsDir)) {
+  if (!existsSync31(agentsDir)) {
     return [];
   }
-  const entries = readdirSync9(agentsDir, { withFileTypes: true });
+  const entries = readdirSync12(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join37(agentsDir, entry.name);
+    const agentPath = join41(agentsDir, entry.name);
     const agentName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync17(agentPath, "utf-8");
+      const content = readFileSync21(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -11264,7 +12956,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join37(homedir14(), ".claude", "agents");
+  const userAgentsDir = join41(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -11273,7 +12965,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join37(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join41(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -11282,9 +12974,8 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync28 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join38 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { join as join42 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -11350,16 +13041,16 @@ function transformMcpServer(name, server) {
 
 // src/features/claude-code-mcp-loader/loader.ts
 function getMcpConfigPaths() {
-  const home = homedir15();
+  const claudeConfigDir = getClaudeConfigDir();
   const cwd = process.cwd();
   return [
-    { path: join38(home, ".claude", ".mcp.json"), scope: "user" },
-    { path: join38(cwd, ".mcp.json"), scope: "project" },
-    { path: join38(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join42(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join42(cwd, ".mcp.json"), scope: "project" },
+    { path: join42(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync28(filePath)) {
+  if (!existsSync32(filePath)) {
     return null;
   }
   try {
@@ -11399,6 +13090,363 @@ async function loadMcpConfigs() {
   }
   return { servers, loadedServers };
 }
+// src/features/claude-code-plugin-loader/loader.ts
+import { existsSync as existsSync33, readdirSync as readdirSync13, readFileSync as readFileSync22 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join43, basename as basename3 } from "path";
+var CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
+function getPluginsBaseDir() {
+  if (process.env.CLAUDE_PLUGINS_HOME) {
+    return process.env.CLAUDE_PLUGINS_HOME;
+  }
+  return join43(homedir10(), ".claude", "plugins");
+}
+function getInstalledPluginsPath() {
+  return join43(getPluginsBaseDir(), "installed_plugins.json");
+}
+function resolvePluginPath(path8, pluginRoot) {
+  return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
+}
+function resolvePluginPaths(obj, pluginRoot) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj === "string") {
+    return resolvePluginPath(obj, pluginRoot);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolvePluginPaths(item, pluginRoot));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = resolvePluginPaths(value, pluginRoot);
+    }
+    return result;
+  }
+  return obj;
+}
+function loadInstalledPlugins() {
+  const dbPath = getInstalledPluginsPath();
+  if (!existsSync33(dbPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync22(dbPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    log("Failed to load installed plugins database", error);
+    return null;
+  }
+}
+function getClaudeSettingsPath() {
+  if (process.env.CLAUDE_SETTINGS_PATH) {
+    return process.env.CLAUDE_SETTINGS_PATH;
+  }
+  return join43(homedir10(), ".claude", "settings.json");
+}
+function loadClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!existsSync33(settingsPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync22(settingsPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    log("Failed to load Claude settings", error);
+    return null;
+  }
+}
+function loadPluginManifest(installPath) {
+  const manifestPath = join43(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync33(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync22(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    log(`Failed to load plugin manifest from ${manifestPath}`, error);
+    return null;
+  }
+}
+function derivePluginNameFromKey(pluginKey) {
+  const atIndex = pluginKey.indexOf("@");
+  if (atIndex > 0) {
+    return pluginKey.substring(0, atIndex);
+  }
+  return pluginKey;
+}
+function isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugins) {
+  if (overrideEnabledPlugins && pluginKey in overrideEnabledPlugins) {
+    return overrideEnabledPlugins[pluginKey];
+  }
+  if (settingsEnabledPlugins && pluginKey in settingsEnabledPlugins) {
+    return settingsEnabledPlugins[pluginKey];
+  }
+  return true;
+}
+function discoverInstalledPlugins(options) {
+  const db = loadInstalledPlugins();
+  const settings = loadClaudeSettings();
+  const plugins = [];
+  const errors = [];
+  if (!db || !db.plugins) {
+    return { plugins, errors };
+  }
+  const settingsEnabledPlugins = settings?.enabledPlugins;
+  const overrideEnabledPlugins = options?.enabledPluginsOverride;
+  for (const [pluginKey, installations] of Object.entries(db.plugins)) {
+    if (!installations || installations.length === 0)
+      continue;
+    if (!isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugins)) {
+      log(`Plugin disabled: ${pluginKey}`);
+      continue;
+    }
+    const installation = installations[0];
+    const { installPath, scope, version } = installation;
+    if (!existsSync33(installPath)) {
+      errors.push({
+        pluginKey,
+        installPath,
+        error: "Plugin installation path does not exist"
+      });
+      continue;
+    }
+    const manifest = loadPluginManifest(installPath);
+    const pluginName = manifest?.name || derivePluginNameFromKey(pluginKey);
+    const loadedPlugin = {
+      name: pluginName,
+      version: version || manifest?.version || "unknown",
+      scope,
+      installPath,
+      pluginKey,
+      manifest: manifest ?? undefined
+    };
+    if (existsSync33(join43(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join43(installPath, "commands");
+    }
+    if (existsSync33(join43(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join43(installPath, "agents");
+    }
+    if (existsSync33(join43(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join43(installPath, "skills");
+    }
+    const hooksPath = join43(installPath, "hooks", "hooks.json");
+    if (existsSync33(hooksPath)) {
+      loadedPlugin.hooksPath = hooksPath;
+    }
+    const mcpPath = join43(installPath, ".mcp.json");
+    if (existsSync33(mcpPath)) {
+      loadedPlugin.mcpPath = mcpPath;
+    }
+    plugins.push(loadedPlugin);
+    log(`Discovered plugin: ${pluginName}@${version} (${scope})`, { installPath, hasManifest: !!manifest });
+  }
+  return { plugins, errors };
+}
+function loadPluginCommands(plugins) {
+  const commands = {};
+  for (const plugin2 of plugins) {
+    if (!plugin2.commandsDir || !existsSync33(plugin2.commandsDir))
+      continue;
+    const entries = readdirSync13(plugin2.commandsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!isMarkdownFile(entry))
+        continue;
+      const commandPath = join43(plugin2.commandsDir, entry.name);
+      const commandName = basename3(entry.name, ".md");
+      const namespacedName = `${plugin2.name}:${commandName}`;
+      try {
+        const content = readFileSync22(commandPath, "utf-8");
+        const { data, body } = parseFrontmatter(content);
+        const wrappedTemplate = `<command-instruction>
+${body.trim()}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+        const formattedDescription = `(plugin: ${plugin2.name}) ${data.description || ""}`;
+        commands[namespacedName] = {
+          name: namespacedName,
+          description: formattedDescription,
+          template: wrappedTemplate,
+          agent: data.agent,
+          model: sanitizeModelField(data.model, "claude-code"),
+          subtask: data.subtask,
+          argumentHint: data["argument-hint"]
+        };
+        log(`Loaded plugin command: ${namespacedName}`, { path: commandPath });
+      } catch (error) {
+        log(`Failed to load plugin command: ${commandPath}`, error);
+      }
+    }
+  }
+  return commands;
+}
+function loadPluginSkillsAsCommands(plugins) {
+  const skills = {};
+  for (const plugin2 of plugins) {
+    if (!plugin2.skillsDir || !existsSync33(plugin2.skillsDir))
+      continue;
+    const entries = readdirSync13(plugin2.skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith("."))
+        continue;
+      const skillPath = join43(plugin2.skillsDir, entry.name);
+      if (!entry.isDirectory() && !entry.isSymbolicLink())
+        continue;
+      const resolvedPath = resolveSymlink(skillPath);
+      const skillMdPath = join43(resolvedPath, "SKILL.md");
+      if (!existsSync33(skillMdPath))
+        continue;
+      try {
+        const content = readFileSync22(skillMdPath, "utf-8");
+        const { data, body } = parseFrontmatter(content);
+        const skillName = data.name || entry.name;
+        const namespacedName = `${plugin2.name}:${skillName}`;
+        const originalDescription = data.description || "";
+        const formattedDescription = `(plugin: ${plugin2.name} - Skill) ${originalDescription}`;
+        const wrappedTemplate = `<skill-instruction>
+Base directory for this skill: ${resolvedPath}/
+File references (@path) in this skill are relative to this directory.
+
+${body.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+        skills[namespacedName] = {
+          name: namespacedName,
+          description: formattedDescription,
+          template: wrappedTemplate,
+          model: sanitizeModelField(data.model)
+        };
+        log(`Loaded plugin skill: ${namespacedName}`, { path: resolvedPath });
+      } catch (error) {
+        log(`Failed to load plugin skill: ${skillPath}`, error);
+      }
+    }
+  }
+  return skills;
+}
+function parseToolsConfig2(toolsStr) {
+  if (!toolsStr)
+    return;
+  const tools2 = toolsStr.split(",").map((t) => t.trim()).filter(Boolean);
+  if (tools2.length === 0)
+    return;
+  const result = {};
+  for (const tool of tools2) {
+    result[tool.toLowerCase()] = true;
+  }
+  return result;
+}
+function loadPluginAgents(plugins) {
+  const agents = {};
+  for (const plugin2 of plugins) {
+    if (!plugin2.agentsDir || !existsSync33(plugin2.agentsDir))
+      continue;
+    const entries = readdirSync13(plugin2.agentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!isMarkdownFile(entry))
+        continue;
+      const agentPath = join43(plugin2.agentsDir, entry.name);
+      const agentName = basename3(entry.name, ".md");
+      const namespacedName = `${plugin2.name}:${agentName}`;
+      try {
+        const content = readFileSync22(agentPath, "utf-8");
+        const { data, body } = parseFrontmatter(content);
+        const name = data.name || agentName;
+        const originalDescription = data.description || "";
+        const formattedDescription = `(plugin: ${plugin2.name}) ${originalDescription}`;
+        const config = {
+          description: formattedDescription,
+          mode: "subagent",
+          prompt: body.trim()
+        };
+        const toolsConfig = parseToolsConfig2(data.tools);
+        if (toolsConfig) {
+          config.tools = toolsConfig;
+        }
+        agents[namespacedName] = config;
+        log(`Loaded plugin agent: ${namespacedName}`, { path: agentPath });
+      } catch (error) {
+        log(`Failed to load plugin agent: ${agentPath}`, error);
+      }
+    }
+  }
+  return agents;
+}
+async function loadPluginMcpServers(plugins) {
+  const servers = {};
+  for (const plugin2 of plugins) {
+    if (!plugin2.mcpPath || !existsSync33(plugin2.mcpPath))
+      continue;
+    try {
+      const content = await Bun.file(plugin2.mcpPath).text();
+      let config = JSON.parse(content);
+      config = resolvePluginPaths(config, plugin2.installPath);
+      config = expandEnvVarsInObject(config);
+      if (!config.mcpServers)
+        continue;
+      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        if (serverConfig.disabled) {
+          log(`Skipping disabled MCP server "${name}" from plugin ${plugin2.name}`);
+          continue;
+        }
+        try {
+          const transformed = transformMcpServer(name, serverConfig);
+          const namespacedName = `${plugin2.name}:${name}`;
+          servers[namespacedName] = transformed;
+          log(`Loaded plugin MCP server: ${namespacedName}`, { path: plugin2.mcpPath });
+        } catch (error) {
+          log(`Failed to transform plugin MCP server "${name}"`, error);
+        }
+      }
+    } catch (error) {
+      log(`Failed to load plugin MCP config: ${plugin2.mcpPath}`, error);
+    }
+  }
+  return servers;
+}
+function loadPluginHooksConfigs(plugins) {
+  const configs = [];
+  for (const plugin2 of plugins) {
+    if (!plugin2.hooksPath || !existsSync33(plugin2.hooksPath))
+      continue;
+    try {
+      const content = readFileSync22(plugin2.hooksPath, "utf-8");
+      let config = JSON.parse(content);
+      config = resolvePluginPaths(config, plugin2.installPath);
+      configs.push(config);
+      log(`Loaded plugin hooks config from ${plugin2.name}`, { path: plugin2.hooksPath });
+    } catch (error) {
+      log(`Failed to load plugin hooks config: ${plugin2.hooksPath}`, error);
+    }
+  }
+  return configs;
+}
+async function loadAllPluginComponents(options) {
+  const { plugins, errors } = discoverInstalledPlugins(options);
+  const commands = loadPluginCommands(plugins);
+  const skills = loadPluginSkillsAsCommands(plugins);
+  const agents = loadPluginAgents(plugins);
+  const mcpServers = await loadPluginMcpServers(plugins);
+  const hooksConfigs = loadPluginHooksConfigs(plugins);
+  log(`Loaded ${plugins.length} plugins with ${Object.keys(commands).length} commands, ${Object.keys(skills).length} skills, ${Object.keys(agents).length} agents, ${Object.keys(mcpServers).length} MCP servers`);
+  return {
+    commands,
+    skills,
+    agents,
+    mcpServers,
+    hooksConfigs,
+    plugins,
+    errors
+  };
+}
 // src/tools/lsp/constants.ts
 var SYMBOL_KIND_MAP = {
   1: "File",
@@ -11694,14 +13742,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
-import { join as join39 } from "path";
-import { homedir as homedir16 } from "os";
+import { existsSync as existsSync34, readFileSync as readFileSync23 } from "fs";
+import { join as join44 } from "path";
+import { homedir as homedir11 } from "os";
 function loadJsonFile(path8) {
-  if (!existsSync29(path8))
+  if (!existsSync34(path8))
     return null;
   try {
-    return JSON.parse(readFileSync18(path8, "utf-8"));
+    return JSON.parse(readFileSync23(path8, "utf-8"));
   } catch {
     return null;
   }
@@ -11709,9 +13757,9 @@ function loadJsonFile(path8) {
 function getConfigPaths2() {
   const cwd = process.cwd();
   return {
-    project: join39(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join39(homedir16(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join39(homedir16(), ".config", "opencode", "opencode.json")
+    project: join44(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join44(homedir11(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join44(homedir11(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -11807,21 +13855,21 @@ function isServerInstalled(command) {
   const pathSeparator = isWindows2 ? ";" : ":";
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
-    if (existsSync29(join39(p, cmd)) || existsSync29(join39(p, cmd + ext))) {
+    if (existsSync34(join44(p, cmd)) || existsSync34(join44(p, cmd + ext))) {
       return true;
     }
   }
   const cwd = process.cwd();
   const additionalPaths = [
-    join39(cwd, "node_modules", ".bin", cmd),
-    join39(cwd, "node_modules", ".bin", cmd + ext),
-    join39(homedir16(), ".config", "opencode", "bin", cmd),
-    join39(homedir16(), ".config", "opencode", "bin", cmd + ext),
-    join39(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd),
-    join39(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
+    join44(cwd, "node_modules", ".bin", cmd),
+    join44(cwd, "node_modules", ".bin", cmd + ext),
+    join44(homedir11(), ".config", "opencode", "bin", cmd),
+    join44(homedir11(), ".config", "opencode", "bin", cmd + ext),
+    join44(homedir11(), ".config", "opencode", "node_modules", ".bin", cmd),
+    join44(homedir11(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
   ];
   for (const p of additionalPaths) {
-    if (existsSync29(p)) {
+    if (existsSync34(p)) {
       return true;
     }
   }
@@ -11870,8 +13918,8 @@ function getAllServers() {
   return result;
 }
 // src/tools/lsp/client.ts
-var {spawn: spawn4 } = globalThis.Bun;
-import { readFileSync as readFileSync19 } from "fs";
+var {spawn: spawn5 } = globalThis.Bun;
+import { readFileSync as readFileSync24 } from "fs";
 import { extname, resolve as resolve5 } from "path";
 class LSPServerManager {
   static instance;
@@ -12037,7 +14085,7 @@ class LSPClient {
     this.server = server;
   }
   async start() {
-    this.proc = spawn4(this.server.command, {
+    this.proc = spawn5(this.server.command, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
@@ -12301,7 +14349,7 @@ ${msg}`);
     const absPath = resolve5(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync19(absPath, "utf-8");
+    const text = readFileSync24(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -12416,16 +14464,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve6 } from "path";
-import { existsSync as existsSync30, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve6(filePath);
-  if (!existsSync30(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync35(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync30(__require("path").join(dir, marker))) {
+      if (existsSync35(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -12583,7 +14631,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync20(filePath, "utf-8");
+    let content = readFileSync25(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -12608,7 +14656,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync12(filePath, lines.join(`
+    writeFileSync13(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -12639,7 +14687,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync12(filePath, "", "utf-8");
+            writeFileSync13(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -12649,8 +14697,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync20(oldPath, "utf-8");
-            writeFileSync12(newPath, content, "utf-8");
+            const content = readFileSync25(oldPath, "utf-8");
+            writeFileSync13(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -12759,7 +14807,7 @@ __export(exports_external, {
   pipe: () => pipe,
   partialRecord: () => partialRecord,
   parseAsync: () => parseAsync2,
-  parse: () => parse3,
+  parse: () => parse5,
   overwrite: () => _overwrite,
   optional: () => optional,
   object: () => object,
@@ -12949,7 +14997,7 @@ __export(exports_core2, {
   regexes: () => exports_regexes,
   prettifyError: () => prettifyError,
   parseAsync: () => parseAsync,
-  parse: () => parse,
+  parse: () => parse3,
   locales: () => exports_locales,
   isValidJWT: () => isValidJWT,
   isValidBase64URL: () => isValidBase64URL,
@@ -14048,7 +16096,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
   }
   return result.value;
 };
-var parse = /* @__PURE__ */ _parse($ZodRealError);
+var parse3 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -16566,10 +18614,10 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       throw new Error("implement() must be called with a function");
     }
     return function(...args) {
-      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+      const parsedArgs = inst._def.input ? parse3(inst._def.input, args) : args;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse(inst._def.output, result);
+        return parse3(inst._def.output, result);
       }
       return result;
     };
@@ -23078,13 +25126,13 @@ function _stringbool(Classes, _params) {
   });
   return codec;
 }
-function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
+function _stringFormat(Class2, format2, fnOrRegex, _params = {}) {
   const params = normalizeParams(_params);
   const def = {
     ...normalizeParams(_params),
     check: "string_format",
     type: "string",
-    format,
+    format: format2,
     fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
     ...params
   };
@@ -23146,13 +25194,13 @@ class JSONSchemaGenerator {
           case "string": {
             const json = _json;
             json.type = "string";
-            const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+            const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
             if (typeof minimum === "number")
               json.minLength = minimum;
             if (typeof maximum === "number")
               json.maxLength = maximum;
-            if (format) {
-              json.format = formatMap[format] ?? format;
+            if (format2) {
+              json.format = formatMap[format2] ?? format2;
               if (json.format === "")
                 delete json.format;
             }
@@ -23175,8 +25223,8 @@ class JSONSchemaGenerator {
           }
           case "number": {
             const json = _json;
-            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-            if (typeof format === "string" && format.includes("int"))
+            const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+            if (typeof format2 === "string" && format2.includes("int"))
               json.type = "integer";
             else
               json.type = "number";
@@ -23977,7 +26025,7 @@ var ZodRealError = $constructor("ZodError", initializer2, {
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse3 = /* @__PURE__ */ _parse(ZodRealError);
+var parse5 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -24011,7 +26059,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     reg.add(inst, meta);
     return inst;
   };
-  inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
+  inst.parse = (data, params) => parse5(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse2(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -24276,8 +26324,8 @@ var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat"
   $ZodCustomStringFormat.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
-function stringFormat(format, fnOrRegex, _params = {}) {
-  return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+function stringFormat(format2, fnOrRegex, _params = {}) {
+  return _stringFormat(ZodCustomStringFormat, format2, fnOrRegex, _params);
 }
 function hostname2(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", exports_regexes.hostname, _params);
@@ -24287,11 +26335,11 @@ function hex2(_params) {
 }
 function hash(alg, params) {
   const enc = params?.enc ?? "hex";
-  const format = `${alg}_${enc}`;
-  const regex = exports_regexes[format];
+  const format2 = `${alg}_${enc}`;
+  const regex = exports_regexes[format2];
   if (!regex)
-    throw new Error(`Unrecognized hash format: ${format}`);
-  return _stringFormat(ZodCustomStringFormat, format, regex, params);
+    throw new Error(`Unrecognized hash format: ${format2}`);
+  return _stringFormat(ZodCustomStringFormat, format2, regex, params);
 }
 var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   $ZodNumber.init(inst, def);
@@ -25350,14 +27398,14 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname6, join as join41 } from "path";
-import { existsSync as existsSync32, statSync as statSync4 } from "fs";
+import { dirname as dirname6, join as join46 } from "path";
+import { existsSync as existsSync37, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
-var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync31, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
-import { join as join40 } from "path";
-import { homedir as homedir17 } from "os";
+var {spawn: spawn6 } = globalThis.Bun;
+import { existsSync as existsSync36, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
+import { join as join45 } from "path";
+import { homedir as homedir12 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -25382,26 +27430,26 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join40(homedir17(), "AppData", "Local");
-    return join40(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join45(homedir12(), "AppData", "Local");
+    return join45(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join40(homedir17(), ".cache");
-  return join40(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join45(homedir12(), ".cache");
+  return join45(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join40(getCacheDir3(), getBinaryName3());
-  return existsSync31(binaryPath) ? binaryPath : null;
+  const binaryPath = join45(getCacheDir3(), getBinaryName3());
+  return existsSync36(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
-  const proc = process.platform === "win32" ? spawn5([
+  const proc = process.platform === "win32" ? spawn6([
     "powershell",
     "-command",
     `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`
-  ], { stdout: "pipe", stderr: "pipe" }) : spawn5(["unzip", "-o", archivePath, "-d", destDir], { stdout: "pipe", stderr: "pipe" });
+  ], { stdout: "pipe", stderr: "pipe" }) : spawn6(["unzip", "-o", archivePath, "-d", destDir], { stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
     const stderr = await new Response(proc.stderr).text();
@@ -25420,8 +27468,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join40(cacheDir, binaryName);
-  if (existsSync31(binaryPath)) {
+  const binaryPath = join45(cacheDir, binaryName);
+  if (existsSync36(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -25429,21 +27477,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync31(cacheDir)) {
+    if (!existsSync36(cacheDir)) {
       mkdirSync10(cacheDir, { recursive: true });
     }
     const response2 = await fetch(downloadUrl, { redirect: "follow" });
     if (!response2.ok) {
       throw new Error(`HTTP ${response2.status}: ${response2.statusText}`);
     }
-    const archivePath = join40(cacheDir, assetName);
+    const archivePath = join45(cacheDir, assetName);
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync31(archivePath)) {
+    if (existsSync36(archivePath)) {
       unlinkSync9(archivePath);
     }
-    if (process.platform !== "win32" && existsSync31(binaryPath)) {
+    if (process.platform !== "win32" && existsSync36(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -25494,8 +27542,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname6(cliPkgPath);
-    const sgPath = join41(cliDir, binaryName);
-    if (existsSync32(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join46(cliDir, binaryName);
+    if (existsSync37(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -25506,8 +27554,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join41(pkgDir, astGrepName);
-      if (existsSync32(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join46(pkgDir, astGrepName);
+      if (existsSync37(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -25515,7 +27563,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path8 of homebrewPaths) {
-      if (existsSync32(path8) && isValidBinary(path8)) {
+      if (existsSync37(path8) && isValidBinary(path8)) {
         return path8;
       }
     }
@@ -25570,12 +27618,12 @@ var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
-var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync33 } from "fs";
+var {spawn: spawn7 } = globalThis.Bun;
+import { existsSync as existsSync38 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync33(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync38(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -25583,7 +27631,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync33(syncPath)) {
+    if (syncPath && existsSync38(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -25617,14 +27665,14 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync33(cliPath) && cliPath !== "sg") {
+  if (!existsSync38(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
     }
   }
   const timeout = DEFAULT_TIMEOUT_MS;
-  const proc = spawn6([cliPath, ...args], {
+  const proc = spawn7([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -25878,27 +27926,27 @@ var ast_grep_replace = tool({
   }
 });
 // src/tools/grep/cli.ts
-var {spawn: spawn7 } = globalThis.Bun;
+var {spawn: spawn8 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync35 } from "fs";
-import { join as join43, dirname as dirname7 } from "path";
+import { existsSync as existsSync40 } from "fs";
+import { join as join48, dirname as dirname7 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync10 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync14 } from "fs";
+import { join as join47 } from "path";
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join42(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join47(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join42(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join47(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync34(rgPath) ? rgPath : null;
+  return existsSync39(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -25921,13 +27969,13 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join43(execDir, rgName),
-    join43(execDir, "bin", rgName),
-    join43(execDir, "..", "bin", rgName),
-    join43(execDir, "..", "libexec", rgName)
+    join48(execDir, rgName),
+    join48(execDir, "bin", rgName),
+    join48(execDir, "..", "bin", rgName),
+    join48(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync35(candidate)) {
+    if (existsSync40(candidate)) {
       return candidate;
     }
   }
@@ -26073,7 +28121,7 @@ async function runRg(options) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn7([cli.path, ...args], {
+  const proc = spawn8([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -26175,7 +28223,7 @@ var grep = tool({
 });
 
 // src/tools/glob/cli.ts
-var {spawn: spawn8 } = globalThis.Bun;
+var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/glob/constants.ts
 var DEFAULT_TIMEOUT_MS3 = 60000;
@@ -26232,7 +28280,7 @@ async function runRgFiles(options) {
     args.push(...paths);
   }
   const cwd = paths[0] || ".";
-  const proc = spawn8([cli.path, ...args], {
+  const proc = spawn9([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe",
     cwd: isRg ? undefined : cwd
@@ -26330,22 +28378,21 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync36, readdirSync as readdirSync11, readFileSync as readFileSync21 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join44, basename as basename3, dirname as dirname8 } from "path";
+import { existsSync as existsSync41, readdirSync as readdirSync15, readFileSync as readFileSync26 } from "fs";
+import { join as join49, basename as basename4, dirname as dirname8 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync36(commandsDir)) {
+  if (!existsSync41(commandsDir)) {
     return [];
   }
-  const entries = readdirSync11(commandsDir, { withFileTypes: true });
+  const entries = readdirSync15(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join44(commandsDir, entry.name);
-    const commandName = basename3(entry.name, ".md");
+    const commandPath = join49(commandsDir, entry.name);
+    const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync21(commandPath, "utf-8");
+      const content = readFileSync26(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -26370,10 +28417,11 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands;
 }
 function discoverCommandsSync() {
-  const userCommandsDir = join44(homedir18(), ".claude", "commands");
-  const projectCommandsDir = join44(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join44(homedir18(), ".config", "opencode", "command");
-  const opencodeProjectDir = join44(process.cwd(), ".opencode", "command");
+  const { homedir: homedir13 } = __require("os");
+  const userCommandsDir = join49(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join49(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join49(homedir13(), ".config", "opencode", "command");
+  const opencodeProjectDir = join49(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -26457,7 +28505,7 @@ Commands are loaded from (priority order, highest wins):
 - .opencode/command/ (opencode-project - OpenCode project-specific commands)
 - ./.claude/commands/ (project - Claude Code project-specific commands)
 - ~/.config/opencode/command/ (opencode - OpenCode global commands)
-- ~/.claude/commands/ (user - Claude Code global commands)
+- $CLAUDE_CONFIG_DIR/commands/ or ~/.claude/commands/ (user - Claude Code global commands)
 
 Each command is a markdown file with:
 - YAML frontmatter: description, argument-hint, model, agent, subtask (optional)
@@ -26497,13 +28545,12 @@ Try a different command name.`;
   }
 });
 // src/tools/session-manager/constants.ts
-import { join as join45 } from "path";
-import { homedir as homedir19 } from "os";
+import { join as join50 } from "path";
 var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE4 = join45(OPENCODE_STORAGE9, "message");
-var PART_STORAGE4 = join45(OPENCODE_STORAGE9, "part");
-var TODO_DIR2 = join45(homedir19(), ".claude", "todos");
-var TRANSCRIPT_DIR2 = join45(homedir19(), ".claude", "transcripts");
+var MESSAGE_STORAGE8 = join50(OPENCODE_STORAGE9, "message");
+var PART_STORAGE4 = join50(OPENCODE_STORAGE9, "part");
+var TODO_DIR2 = join50(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join50(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
 
 Returns a list of available session IDs with metadata including message count, date range, and agents used.
@@ -26576,18 +28623,18 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync37, readdirSync as readdirSync12, readFileSync as readFileSync22 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync42, readdirSync as readdirSync16, readFileSync as readFileSync27 } from "fs";
+import { join as join51 } from "path";
 function getAllSessions() {
-  if (!existsSync37(MESSAGE_STORAGE4))
+  if (!existsSync42(MESSAGE_STORAGE8))
     return [];
   const sessions = [];
   function scanDirectory(dir) {
     try {
-      for (const entry of readdirSync12(dir, { withFileTypes: true })) {
+      for (const entry of readdirSync16(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
-          const sessionPath = join46(dir, entry.name);
-          const files = readdirSync12(sessionPath);
+          const sessionPath = join51(dir, entry.name);
+          const files = readdirSync16(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
           } else {
@@ -26599,37 +28646,37 @@ function getAllSessions() {
       return;
     }
   }
-  scanDirectory(MESSAGE_STORAGE4);
+  scanDirectory(MESSAGE_STORAGE8);
   return [...new Set(sessions)];
 }
-function getMessageDir5(sessionID) {
-  if (!existsSync37(MESSAGE_STORAGE4))
+function getMessageDir9(sessionID) {
+  if (!existsSync42(MESSAGE_STORAGE8))
     return "";
-  const directPath = join46(MESSAGE_STORAGE4, sessionID);
-  if (existsSync37(directPath)) {
+  const directPath = join51(MESSAGE_STORAGE8, sessionID);
+  if (existsSync42(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync12(MESSAGE_STORAGE4)) {
-    const sessionPath = join46(MESSAGE_STORAGE4, dir, sessionID);
-    if (existsSync37(sessionPath)) {
+  for (const dir of readdirSync16(MESSAGE_STORAGE8)) {
+    const sessionPath = join51(MESSAGE_STORAGE8, dir, sessionID);
+    if (existsSync42(sessionPath)) {
       return sessionPath;
     }
   }
   return "";
 }
 function sessionExists(sessionID) {
-  return getMessageDir5(sessionID) !== "";
+  return getMessageDir9(sessionID) !== "";
 }
 function readSessionMessages(sessionID) {
-  const messageDir = getMessageDir5(sessionID);
-  if (!messageDir || !existsSync37(messageDir))
+  const messageDir = getMessageDir9(sessionID);
+  if (!messageDir || !existsSync42(messageDir))
     return [];
   const messages = [];
-  for (const file2 of readdirSync12(messageDir)) {
+  for (const file2 of readdirSync16(messageDir)) {
     if (!file2.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync22(join46(messageDir, file2), "utf-8");
+      const content = readFileSync27(join51(messageDir, file2), "utf-8");
       const meta = JSON.parse(content);
       const parts = readParts2(meta.id);
       messages.push({
@@ -26652,15 +28699,15 @@ function readSessionMessages(sessionID) {
   });
 }
 function readParts2(messageID) {
-  const partDir = join46(PART_STORAGE4, messageID);
-  if (!existsSync37(partDir))
+  const partDir = join51(PART_STORAGE4, messageID);
+  if (!existsSync42(partDir))
     return [];
   const parts = [];
-  for (const file2 of readdirSync12(partDir)) {
+  for (const file2 of readdirSync16(partDir)) {
     if (!file2.endsWith(".json"))
       continue;
     try {
-      const content = readFileSync22(join46(partDir, file2), "utf-8");
+      const content = readFileSync27(join51(partDir, file2), "utf-8");
       parts.push(JSON.parse(content));
     } catch {
       continue;
@@ -26669,12 +28716,12 @@ function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 function readSessionTodos(sessionID) {
-  if (!existsSync37(TODO_DIR2))
+  if (!existsSync42(TODO_DIR2))
     return [];
-  const todoFiles = readdirSync12(TODO_DIR2).filter((f) => f.includes(sessionID) && f.endsWith(".json"));
+  const todoFiles = readdirSync16(TODO_DIR2).filter((f) => f.includes(sessionID) && f.endsWith(".json"));
   for (const file2 of todoFiles) {
     try {
-      const content = readFileSync22(join46(TODO_DIR2, file2), "utf-8");
+      const content = readFileSync27(join51(TODO_DIR2, file2), "utf-8");
       const data = JSON.parse(content);
       if (Array.isArray(data)) {
         return data.map((item) => ({
@@ -26691,13 +28738,13 @@ function readSessionTodos(sessionID) {
   return [];
 }
 function readSessionTranscript(sessionID) {
-  if (!existsSync37(TRANSCRIPT_DIR2))
+  if (!existsSync42(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join46(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync37(transcriptFile))
+  const transcriptFile = join51(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync42(transcriptFile))
     return 0;
   try {
-    const content = readFileSync22(transcriptFile, "utf-8");
+    const content = readFileSync27(transcriptFile, "utf-8");
     return content.trim().split(`
 `).filter(Boolean).length;
   } catch {
@@ -26991,14 +29038,14 @@ var INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands. Use "omo-{name}" sess
 Blocked (use bash instead): capture-pane, save-buffer, show-buffer, pipe-pane.`;
 
 // src/tools/interactive-bash/utils.ts
-var {spawn: spawn9 } = globalThis.Bun;
+var {spawn: spawn10 } = globalThis.Bun;
 var tmuxPath = null;
 var initPromise3 = null;
 async function findTmuxPath() {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
   try {
-    const proc = spawn9([cmd, "tmux"], {
+    const proc = spawn10([cmd, "tmux"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -27012,7 +29059,7 @@ async function findTmuxPath() {
     if (!path8) {
       return null;
     }
-    const verifyProc = spawn9([path8, "-V"], {
+    const verifyProc = spawn10([path8, "-V"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -27126,8 +29173,8 @@ var interactive_bash = tool({
   }
 });
 // src/tools/background-task/tools.ts
-import { existsSync as existsSync38, readdirSync as readdirSync13 } from "fs";
-import { join as join47 } from "path";
+import { existsSync as existsSync43, readdirSync as readdirSync17 } from "fs";
+import { join as join52 } from "path";
 
 // src/tools/background-task/constants.ts
 var BACKGROUND_TASK_DESCRIPTION = `Run agent task in background. Returns task_id immediately; notifies on completion.
@@ -27137,15 +29184,15 @@ var BACKGROUND_OUTPUT_DESCRIPTION = `Get output from background task. System not
 var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s). Use all=true to cancel ALL before final answer.`;
 
 // src/tools/background-task/tools.ts
-function getMessageDir6(sessionID) {
-  if (!existsSync38(MESSAGE_STORAGE))
+function getMessageDir10(sessionID) {
+  if (!existsSync43(MESSAGE_STORAGE))
     return null;
-  const directPath = join47(MESSAGE_STORAGE, sessionID);
-  if (existsSync38(directPath))
+  const directPath = join52(MESSAGE_STORAGE, sessionID);
+  if (existsSync43(directPath))
     return directPath;
-  for (const dir of readdirSync13(MESSAGE_STORAGE)) {
-    const sessionPath = join47(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync38(sessionPath))
+  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
+    const sessionPath = join52(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync43(sessionPath))
       return sessionPath;
   }
   return null;
@@ -27176,7 +29223,7 @@ function createBackgroundTask(manager) {
         return `\u274C Agent parameter is required. Please specify which agent to use (e.g., "explore", "librarian", "build", etc.)`;
       }
       try {
-        const messageDir = getMessageDir6(toolContext.sessionID);
+        const messageDir = getMessageDir10(toolContext.sessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
         const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID ? { providerID: prevMessage.model.providerID, modelID: prevMessage.model.modelID } : undefined;
         const task = await manager.launch({
@@ -27575,7 +29622,8 @@ session_id: ${sessionID}
 var MULTIMODAL_LOOKER_AGENT = "multimodal-looker";
 var LOOK_AT_DESCRIPTION = `Analyze media files (PDFs, images, diagrams) via Gemini 2.5 Flash in separate context. Saves main context tokens.`;
 // src/tools/look-at/tools.ts
-import { extname as extname3, basename as basename4 } from "path";
+import { extname as extname3, basename as basename5 } from "path";
+import { pathToFileURL } from "url";
 function inferMimeType(filePath) {
   const ext = extname3(filePath).toLowerCase();
   const mimeTypes = {
@@ -27609,7 +29657,7 @@ function createLookAt(ctx) {
     async execute(args, toolContext) {
       log(`[look_at] Analyzing file: ${args.file_path}, goal: ${args.goal}`);
       const mimeType = inferMimeType(args.file_path);
-      const filename = basename4(args.file_path);
+      const filename = basename5(args.file_path);
       const prompt = `Analyze this file and extract the requested information.
 
 Goal: ${args.goal}
@@ -27643,7 +29691,7 @@ If the requested information is not found, clearly state what is missing.`;
           },
           parts: [
             { type: "text", text: prompt },
-            { type: "file", mime: mimeType, url: `file://${args.file_path}`, filename }
+            { type: "file", mime: mimeType, url: pathToFileURL(args.file_path).href, filename }
           ]
         }
       });
@@ -27702,17 +29750,17 @@ var builtinTools = {
   session_info
 };
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync39, readdirSync as readdirSync14 } from "fs";
-import { join as join48 } from "path";
-function getMessageDir7(sessionID) {
-  if (!existsSync39(MESSAGE_STORAGE))
+import { existsSync as existsSync44, readdirSync as readdirSync18 } from "fs";
+import { join as join53 } from "path";
+function getMessageDir11(sessionID) {
+  if (!existsSync44(MESSAGE_STORAGE))
     return null;
-  const directPath = join48(MESSAGE_STORAGE, sessionID);
-  if (existsSync39(directPath))
+  const directPath = join53(MESSAGE_STORAGE, sessionID);
+  if (existsSync44(directPath))
     return directPath;
-  for (const dir of readdirSync14(MESSAGE_STORAGE)) {
-    const sessionPath = join48(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync39(sessionPath))
+  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
+    const sessionPath = join53(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync44(sessionPath))
       return sessionPath;
   }
   return null;
@@ -27924,6 +29972,7 @@ class BackgroundManager {
     this.pollingInterval = setInterval(() => {
       this.pollRunningTasks();
     }, 2000);
+    this.pollingInterval.unref();
   }
   stopPolling() {
     if (this.pollingInterval) {
@@ -27931,6 +29980,11 @@ class BackgroundManager {
       this.pollingInterval = undefined;
     }
   }
+  cleanup() {
+    this.stopPolling();
+    this.tasks.clear();
+    this.notifications.clear();
+  }
   notifyParentSession(task) {
     const duration3 = this.formatDuration(task.startedAt, task.completedAt);
     log("[background-agent] notifyParentSession called for task:", task.id);
@@ -27949,7 +30003,7 @@ class BackgroundManager {
     log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
     setTimeout(async () => {
       try {
-        const messageDir = getMessageDir7(task.parentSessionID);
+        const messageDir = getMessageDir11(task.parentSessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
         const modelContext = task.parentModel ?? prevMessage?.model;
         const modelField = modelContext?.providerID && modelContext?.modelID ? { providerID: modelContext.providerID, modelID: modelContext.modelID } : undefined;
@@ -28150,7 +30204,8 @@ var HookNameSchema = exports_external.enum([
   "agent-usage-reminder",
   "non-interactive-env",
   "interactive-bash-session",
-  "empty-message-sanitizer"
+  "empty-message-sanitizer",
+  "thinking-block-validator"
 ]);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
@@ -28183,7 +30238,9 @@ var ClaudeCodeConfigSchema = exports_external.object({
   commands: exports_external.boolean().optional(),
   skills: exports_external.boolean().optional(),
   agents: exports_external.boolean().optional(),
-  hooks: exports_external.boolean().optional()
+  hooks: exports_external.boolean().optional(),
+  plugins: exports_external.boolean().optional(),
+  plugins_override: exports_external.record(exports_external.string(), exports_external.boolean()).optional()
 });
 var SisyphusAgentConfigSchema = exports_external.object({
   disabled: exports_external.boolean().optional(),
@@ -28191,12 +30248,45 @@ var SisyphusAgentConfigSchema = exports_external.object({
   planner_enabled: exports_external.boolean().optional(),
   replace_plan: exports_external.boolean().optional()
 });
+var DynamicContextPruningConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  notification: exports_external.enum(["off", "minimal", "detailed"]).default("detailed"),
+  turn_protection: exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    turns: exports_external.number().min(1).max(10).default(3)
+  }).optional(),
+  protected_tools: exports_external.array(exports_external.string()).default([
+    "task",
+    "todowrite",
+    "todoread",
+    "lsp_rename",
+    "lsp_code_action_resolve",
+    "session_read",
+    "session_write",
+    "session_search"
+  ]),
+  strategies: exports_external.object({
+    deduplication: exports_external.object({
+      enabled: exports_external.boolean().default(true)
+    }).optional(),
+    supersede_writes: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      aggressive: exports_external.boolean().default(false)
+    }).optional(),
+    purge_errors: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      turns: exports_external.number().min(1).max(20).default(5)
+    }).optional()
+  }).optional()
+});
 var ExperimentalConfigSchema = exports_external.object({
   aggressive_truncation: exports_external.boolean().optional(),
   auto_resume: exports_external.boolean().optional(),
   preemptive_compaction: exports_external.boolean().optional(),
   preemptive_compaction_threshold: exports_external.number().min(0.5).max(0.95).optional(),
-  truncate_all_tool_outputs: exports_external.boolean().default(true)
+  truncate_all_tool_outputs: exports_external.boolean().default(true),
+  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
+  dcp_on_compaction_failure: exports_external.boolean().optional()
 });
 var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
@@ -28340,28 +30430,13 @@ function loadConfigFromPath2(configPath, ctx) {
   try {
     if (fs7.existsSync(configPath)) {
       const content = fs7.readFileSync(configPath, "utf-8");
-      const rawConfig = JSON.parse(content);
+      const rawConfig = parseJsonc(content);
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
       if (!result.success) {
         const errorMsg = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
         log(`Config validation error in ${configPath}:`, result.error.issues);
         addConfigLoadError({ path: configPath, error: `Validation error: ${errorMsg}` });
-        const errorList = result.error.issues.map((issue2) => `\u2022 ${issue2.path.join(".")}: ${issue2.message}`).join(`
-`);
-        ctx.client.tui.showToast({
-          body: {
-            title: "\u274C OhMyOpenCode: Config Validation Failed",
-            message: `Failed to load ${configPath}
-
-Validation errors:
-${errorList}
-
-Config will be ignored. Please fix the errors above.`,
-            variant: "error",
-            duration: 1e4
-          }
-        }).catch(() => {});
         return null;
       }
       log(`Config loaded from ${configPath}`, { agents: result.data.agents });
@@ -28371,21 +30446,6 @@ Config will be ignored. Please fix the errors above.`,
     const errorMsg = err instanceof Error ? err.message : String(err);
     log(`Error loading config from ${configPath}:`, err);
     addConfigLoadError({ path: configPath, error: errorMsg });
-    const hint = err instanceof SyntaxError ? `
-
-Hint: Check for syntax errors in your JSON file (missing commas, quotes, brackets, etc.)` : "";
-    ctx.client.tui.showToast({
-      body: {
-        title: "\u274C OhMyOpenCode: Config Load Failed",
-        message: `Failed to load ${configPath}
-
-Error: ${errorMsg}${hint}
-
-Config will be ignored. Please fix the error above.`,
-        variant: "error",
-        duration: 1e4
-      }
-    }).catch(() => {});
   }
   return null;
 }
@@ -28416,8 +30476,12 @@ function mergeConfigs(base, override) {
   };
 }
 function loadPluginConfig(directory, ctx) {
-  const userConfigPath = path8.join(getUserConfigDir(), "opencode", "oh-my-opencode.json");
-  const projectConfigPath = path8.join(directory, ".opencode", "oh-my-opencode.json");
+  const userBasePath = path8.join(getUserConfigDir(), "opencode", "oh-my-opencode");
+  const userDetected = detectConfigFile(userBasePath);
+  const userConfigPath = userDetected.format !== "none" ? userDetected.path : userBasePath + ".json";
+  const projectBasePath = path8.join(directory, ".opencode", "oh-my-opencode");
+  const projectDetected = detectConfigFile(projectBasePath);
+  const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : projectBasePath + ".json";
   let config3 = loadConfigFromPath2(userConfigPath, ctx) ?? {};
   const projectConfig = loadConfigFromPath2(projectConfigPath, ctx);
   if (projectConfig) {
@@ -28478,6 +30542,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const nonInteractiveEnv = isHookEnabled("non-interactive-env") ? createNonInteractiveEnvHook(ctx) : null;
   const interactiveBashSession = isHookEnabled("interactive-bash-session") ? createInteractiveBashSessionHook(ctx) : null;
   const emptyMessageSanitizer = isHookEnabled("empty-message-sanitizer") ? createEmptyMessageSanitizerHook() : null;
+  const thinkingBlockValidator = isHookEnabled("thinking-block-validator") ? createThinkingBlockValidatorHook() : null;
   const backgroundManager = new BackgroundManager(ctx);
   const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? createTodoContinuationEnforcer(ctx, { backgroundManager }) : null;
   if (sessionRecovery && todoContinuationEnforcer) {
@@ -28504,6 +30569,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await keywordDetector?.["chat.message"]?.(input, output);
     },
     "experimental.chat.messages.transform": async (input, output) => {
+      await thinkingBlockValidator?.["experimental.chat.messages.transform"]?.(input, output);
       await emptyMessageSanitizer?.["experimental.chat.messages.transform"]?.(input, output);
     },
     config: async (config3) => {
@@ -28523,14 +30589,27 @@ var OhMyOpenCodePlugin = async (ctx) => {
           }
         }
       }
+      const pluginComponents = pluginConfig.claude_code?.plugins ?? true ? await loadAllPluginComponents({
+        enabledPluginsOverride: pluginConfig.claude_code?.plugins_override
+      }) : { commands: {}, skills: {}, agents: {}, mcpServers: {}, hooksConfigs: [], plugins: [], errors: [] };
+      if (pluginComponents.plugins.length > 0) {
+        log(`Loaded ${pluginComponents.plugins.length} Claude Code plugins`, {
+          plugins: pluginComponents.plugins.map((p) => `${p.name}@${p.version}`)
+        });
+      }
+      if (pluginComponents.errors.length > 0) {
+        log(`Plugin load errors`, { errors: pluginComponents.errors });
+      }
       const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents, ctx.directory, config3.model);
       const userAgents = pluginConfig.claude_code?.agents ?? true ? loadUserAgents() : {};
       const projectAgents = pluginConfig.claude_code?.agents ?? true ? loadProjectAgents() : {};
+      const pluginAgents = pluginComponents.agents;
       const isSisyphusEnabled = pluginConfig.sisyphus_agent?.disabled !== true;
       const builderEnabled = pluginConfig.sisyphus_agent?.default_builder_enabled ?? false;
       const plannerEnabled = pluginConfig.sisyphus_agent?.planner_enabled ?? true;
       const replacePlan = pluginConfig.sisyphus_agent?.replace_plan ?? true;
       if (isSisyphusEnabled && builtinAgents.Sisyphus) {
+        config3.default_agent = "Sisyphus";
         const agentConfig = {
           Sisyphus: builtinAgents.Sisyphus
         };
@@ -28567,6 +30646,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
           ...Object.fromEntries(Object.entries(builtinAgents).filter(([k]) => k !== "Sisyphus")),
           ...userAgents,
           ...projectAgents,
+          ...pluginAgents,
           ...filteredConfigAgents,
           build: { ...config3.agent?.build, mode: "subagent" },
           ...replacePlan ? { plan: { ...config3.agent?.plan, mode: "subagent" } } : {}
@@ -28576,6 +30656,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
           ...builtinAgents,
           ...userAgents,
           ...projectAgents,
+          ...pluginAgents,
           ...config3.agent
         };
       }
@@ -28611,23 +30692,21 @@ var OhMyOpenCodePlugin = async (ctx) => {
       config3.mcp = {
         ...config3.mcp,
         ...createBuiltinMcps(pluginConfig.disabled_mcps),
-        ...mcpResult.servers
+        ...mcpResult.servers,
+        ...pluginComponents.mcpServers
       };
       const userCommands = pluginConfig.claude_code?.commands ?? true ? loadUserCommands() : {};
       const opencodeGlobalCommands = loadOpencodeGlobalCommands();
       const systemCommands = config3.command ?? {};
       const projectCommands = pluginConfig.claude_code?.commands ?? true ? loadProjectCommands() : {};
       const opencodeProjectCommands = loadOpencodeProjectCommands();
-      const userSkills = pluginConfig.claude_code?.skills ?? true ? loadUserSkillsAsCommands() : {};
-      const projectSkills = pluginConfig.claude_code?.skills ?? true ? loadProjectSkillsAsCommands() : {};
       config3.command = {
         ...userCommands,
-        ...userSkills,
         ...opencodeGlobalCommands,
         ...systemCommands,
         ...projectCommands,
-        ...projectSkills,
-        ...opencodeProjectCommands
+        ...opencodeProjectCommands,
+        ...pluginComponents.commands
       };
     },
     event: async (input) => {