oh-my-opencode 2.1.4 → 2.1.6

package/dist/index.js

@@ -205,19 +205,19 @@ var require_utils = __commonJS((exports) => {
       return exports.escapeLast(input, char, idx - 1);
     return `${input.slice(0, idx)}\\${input.slice(idx)}`;
   };
-  exports.removePrefix = (input, state = {}) => {
+  exports.removePrefix = (input, state2 = {}) => {
     let output = input;
     if (output.startsWith("./")) {
       output = output.slice(2);
-      state.prefix = "./";
+      state2.prefix = "./";
     }
     return output;
   };
-  exports.wrapOutput = (input, state = {}, options = {}) => {
+  exports.wrapOutput = (input, state2 = {}, options = {}) => {
     const prepend = options.contains ? "" : "^";
     const append = options.contains ? "" : "$";
     let output = `${prepend}(?:${input})${append}`;
-    if (state.negated === true) {
+    if (state2.negated === true) {
       output = `(?:^(?!${output}).*$)`;
     }
     return output;
@@ -488,7 +488,7 @@ var require_scan = __commonJS((exports, module) => {
         base = utils.removeBackslashes(base);
       }
     }
-    const state = {
+    const state2 = {
       prefix,
       input,
       start,
@@ -503,11 +503,11 @@ var require_scan = __commonJS((exports, module) => {
       negatedExtglob
     };
     if (opts.tokens === true) {
-      state.maxDepth = 0;
+      state2.maxDepth = 0;
       if (!isPathSeparator(code)) {
         tokens.push(token);
       }
-      state.tokens = tokens;
+      state2.tokens = tokens;
     }
     if (opts.parts === true || opts.tokens === true) {
       let prevIndex;
@@ -523,7 +523,7 @@ var require_scan = __commonJS((exports, module) => {
             tokens[idx].value = value;
           }
           depth(tokens[idx]);
-          state.maxDepth += tokens[idx].depth;
+          state2.maxDepth += tokens[idx].depth;
         }
         if (idx !== 0 || value !== "") {
           parts.push(value);
@@ -536,13 +536,13 @@ var require_scan = __commonJS((exports, module) => {
         if (opts.tokens) {
           tokens[tokens.length - 1].value = value;
           depth(tokens[tokens.length - 1]);
-          state.maxDepth += tokens[tokens.length - 1].depth;
+          state2.maxDepth += tokens[tokens.length - 1].depth;
         }
       }
-      state.slashes = slashes;
-      state.parts = parts;
+      state2.slashes = slashes;
+      state2.parts = parts;
     }
-    return state;
+    return state2;
   };
   module.exports = scan;
 });
@@ -616,7 +616,7 @@ var require_parse = __commonJS((exports, module) => {
     if (typeof opts.noext === "boolean") {
       opts.noextglob = opts.noext;
     }
-    const state = {
+    const state2 = {
       input,
       index: -1,
       start: 0,
@@ -633,57 +633,57 @@ var require_parse = __commonJS((exports, module) => {
       globstar: false,
       tokens
     };
-    input = utils.removePrefix(input, state);
+    input = utils.removePrefix(input, state2);
     len = input.length;
     const extglobs = [];
     const braces = [];
     const stack = [];
     let prev = bos;
     let value;
-    const eos = () => state.index === len - 1;
-    const peek = state.peek = (n = 1) => input[state.index + n];
-    const advance = state.advance = () => input[++state.index] || "";
-    const remaining = () => input.slice(state.index + 1);
+    const eos = () => state2.index === len - 1;
+    const peek = state2.peek = (n = 1) => input[state2.index + n];
+    const advance = state2.advance = () => input[++state2.index] || "";
+    const remaining = () => input.slice(state2.index + 1);
     const consume = (value2 = "", num = 0) => {
-      state.consumed += value2;
-      state.index += num;
+      state2.consumed += value2;
+      state2.index += num;
     };
     const append = (token) => {
-      state.output += token.output != null ? token.output : token.value;
+      state2.output += token.output != null ? token.output : token.value;
       consume(token.value);
     };
     const negate = () => {
       let count = 1;
       while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
         advance();
-        state.start++;
+        state2.start++;
         count++;
       }
       if (count % 2 === 0) {
         return false;
       }
-      state.negated = true;
-      state.start++;
+      state2.negated = true;
+      state2.start++;
       return true;
     };
     const increment = (type) => {
-      state[type]++;
+      state2[type]++;
       stack.push(type);
     };
     const decrement = (type) => {
-      state[type]--;
+      state2[type]--;
       stack.pop();
     };
     const push = (tok) => {
       if (prev.type === "globstar") {
-        const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+        const isBrace = state2.braces > 0 && (tok.type === "comma" || tok.type === "brace");
         const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
         if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
-          state.output = state.output.slice(0, -prev.output.length);
+          state2.output = state2.output.slice(0, -prev.output.length);
           prev.type = "star";
           prev.value = "*";
           prev.output = star;
-          state.output += prev.output;
+          state2.output += prev.output;
         }
       }
       if (extglobs.length && tok.type !== "paren") {
@@ -703,11 +703,11 @@ var require_parse = __commonJS((exports, module) => {
     const extglobOpen = (type, value2) => {
       const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
       token.prev = prev;
-      token.parens = state.parens;
-      token.output = state.output;
+      token.parens = state2.parens;
+      token.output = state2.output;
       const output = (opts.capture ? "(" : "") + token.open;
       increment("parens");
-      push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+      push({ type, value: value2, output: state2.output ? "" : ONE_CHAR });
       push({ type: "paren", extglob: true, value: advance(), output });
       extglobs.push(token);
     };
@@ -727,7 +727,7 @@ var require_parse = __commonJS((exports, module) => {
           output = token.close = `)${expression})${extglobStar})`;
         }
         if (token.prev.type === "bos") {
-          state.negatedExtglob = true;
+          state2.negatedExtglob = true;
         }
       }
       push({ type: "paren", extglob: true, value, output });
@@ -770,11 +770,11 @@ var require_parse = __commonJS((exports, module) => {
         }
       }
       if (output === input && opts.contains === true) {
-        state.output = input;
-        return state;
+        state2.output = input;
+        return state2;
       }
-      state.output = utils.wrapOutput(output, state, options);
-      return state;
+      state2.output = utils.wrapOutput(output, state2, options);
+      return state2;
     }
     while (!eos()) {
       value = advance();
@@ -798,7 +798,7 @@ var require_parse = __commonJS((exports, module) => {
         let slashes = 0;
         if (match && match[0].length > 2) {
           slashes = match[0].length;
-          state.index += slashes;
+          state2.index += slashes;
           if (slashes % 2 !== 0) {
             value += "\\";
           }
@@ -808,12 +808,12 @@ var require_parse = __commonJS((exports, module) => {
         } else {
           value += advance();
         }
-        if (state.brackets === 0) {
+        if (state2.brackets === 0) {
           push({ type: "text", value });
           continue;
         }
       }
-      if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+      if (state2.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
         if (opts.posix !== false && value === ":") {
           const inner = prev.value.slice(1);
           if (inner.includes("[")) {
@@ -825,7 +825,7 @@ var require_parse = __commonJS((exports, module) => {
               const posix = POSIX_REGEX_SOURCE[rest2];
               if (posix) {
                 prev.value = pre + posix;
-                state.backtrack = true;
+                state2.backtrack = true;
                 advance();
                 if (!bos.output && tokens.indexOf(prev) === 1) {
                   bos.output = ONE_CHAR;
@@ -848,14 +848,14 @@ var require_parse = __commonJS((exports, module) => {
         append({ value });
         continue;
       }
-      if (state.quotes === 1 && value !== '"') {
+      if (state2.quotes === 1 && value !== '"') {
         value = utils.escapeRegex(value);
         prev.value += value;
         append({ value });
         continue;
       }
       if (value === '"') {
-        state.quotes = state.quotes === 1 ? 0 : 1;
+        state2.quotes = state2.quotes === 1 ? 0 : 1;
         if (opts.keepQuotes === true) {
           push({ type: "text", value });
         }
@@ -867,15 +867,15 @@ var require_parse = __commonJS((exports, module) => {
         continue;
       }
       if (value === ")") {
-        if (state.parens === 0 && opts.strictBrackets === true) {
+        if (state2.parens === 0 && opts.strictBrackets === true) {
           throw new SyntaxError(syntaxError("opening", "("));
         }
         const extglob = extglobs[extglobs.length - 1];
-        if (extglob && state.parens === extglob.parens + 1) {
+        if (extglob && state2.parens === extglob.parens + 1) {
           extglobClose(extglobs.pop());
           continue;
         }
-        push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+        push({ type: "paren", value, output: state2.parens ? ")" : "\\)" });
         decrement("parens");
         continue;
       }
@@ -896,7 +896,7 @@ var require_parse = __commonJS((exports, module) => {
           push({ type: "text", value, output: `\\${value}` });
           continue;
         }
-        if (state.brackets === 0) {
+        if (state2.brackets === 0) {
           if (opts.strictBrackets === true) {
             throw new SyntaxError(syntaxError("opening", "["));
           }
@@ -914,14 +914,14 @@ var require_parse = __commonJS((exports, module) => {
           continue;
         }
         const escaped = utils.escapeRegex(prev.value);
-        state.output = state.output.slice(0, -prev.value.length);
+        state2.output = state2.output.slice(0, -prev.value.length);
         if (opts.literalBrackets === true) {
-          state.output += escaped;
+          state2.output += escaped;
           prev.value = escaped;
           continue;
         }
         prev.value = `(${capture}${escaped}|${prev.value})`;
-        state.output += prev.value;
+        state2.output += prev.value;
         continue;
       }
       if (value === "{" && opts.nobrace !== true) {
@@ -930,8 +930,8 @@ var require_parse = __commonJS((exports, module) => {
           type: "brace",
           value,
           output: "(",
-          outputIndex: state.output.length,
-          tokensIndex: state.tokens.length
+          outputIndex: state2.output.length,
+          tokensIndex: state2.tokens.length
         };
         braces.push(open);
         push(open);
@@ -957,16 +957,16 @@ var require_parse = __commonJS((exports, module) => {
             }
           }
           output = expandRange(range, opts);
-          state.backtrack = true;
+          state2.backtrack = true;
         }
         if (brace.comma !== true && brace.dots !== true) {
-          const out = state.output.slice(0, brace.outputIndex);
-          const toks = state.tokens.slice(brace.tokensIndex);
+          const out = state2.output.slice(0, brace.outputIndex);
+          const toks = state2.tokens.slice(brace.tokensIndex);
           brace.value = brace.output = "\\{";
           value = output = "\\}";
-          state.output = out;
+          state2.output = out;
           for (const t of toks) {
-            state.output += t.output || t.value;
+            state2.output += t.output || t.value;
           }
         }
         push({ type: "brace", value, output });
@@ -992,10 +992,10 @@ var require_parse = __commonJS((exports, module) => {
         continue;
       }
       if (value === "/") {
-        if (prev.type === "dot" && state.index === state.start + 1) {
-          state.start = state.index + 1;
-          state.consumed = "";
-          state.output = "";
+        if (prev.type === "dot" && state2.index === state2.start + 1) {
+          state2.start = state2.index + 1;
+          state2.consumed = "";
+          state2.output = "";
           tokens.pop();
           prev = bos;
           continue;
@@ -1004,7 +1004,7 @@ var require_parse = __commonJS((exports, module) => {
         continue;
       }
       if (value === ".") {
-        if (state.braces > 0 && prev.type === "dot") {
+        if (state2.braces > 0 && prev.type === "dot") {
           if (prev.value === ".")
             prev.output = DOT_LITERAL;
           const brace = braces[braces.length - 1];
@@ -1014,7 +1014,7 @@ var require_parse = __commonJS((exports, module) => {
           brace.dots = true;
           continue;
         }
-        if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+        if (state2.braces + state2.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
           push({ type: "text", value, output: DOT_LITERAL });
           continue;
         }
@@ -1050,7 +1050,7 @@ var require_parse = __commonJS((exports, module) => {
             continue;
           }
         }
-        if (opts.nonegate !== true && state.index === 0) {
+        if (opts.nonegate !== true && state2.index === 0) {
           negate();
           continue;
         }
@@ -1064,7 +1064,7 @@ var require_parse = __commonJS((exports, module) => {
           push({ type: "plus", value, output: PLUS_LITERAL });
           continue;
         }
-        if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+        if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state2.parens > 0) {
           push({ type: "plus", value });
           continue;
         }
@@ -1086,7 +1086,7 @@ var require_parse = __commonJS((exports, module) => {
         const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
         if (match) {
           value += match[0];
-          state.index += match[0].length;
+          state2.index += match[0].length;
         }
         push({ type: "text", value });
         continue;
@@ -1096,8 +1096,8 @@ var require_parse = __commonJS((exports, module) => {
         prev.star = true;
         prev.value += value;
         prev.output = star;
-        state.backtrack = true;
-        state.globstar = true;
+        state2.backtrack = true;
+        state2.globstar = true;
         consume(value);
         continue;
       }
@@ -1119,14 +1119,14 @@ var require_parse = __commonJS((exports, module) => {
           push({ type: "star", value, output: "" });
           continue;
         }
-        const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+        const isBrace = state2.braces > 0 && (prior.type === "comma" || prior.type === "brace");
         const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
         if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
           push({ type: "star", value, output: "" });
           continue;
         }
         while (rest.slice(0, 3) === "/**") {
-          const after = input[state.index + 4];
+          const after = input[state2.index + 4];
           if (after && after !== "/") {
             break;
           }
@@ -1137,31 +1137,31 @@ var require_parse = __commonJS((exports, module) => {
           prev.type = "globstar";
           prev.value += value;
           prev.output = globstar(opts);
-          state.output = prev.output;
-          state.globstar = true;
+          state2.output = prev.output;
+          state2.globstar = true;
           consume(value);
           continue;
         }
         if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
-          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          state2.output = state2.output.slice(0, -(prior.output + prev.output).length);
           prior.output = `(?:${prior.output}`;
           prev.type = "globstar";
           prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
           prev.value += value;
-          state.globstar = true;
-          state.output += prior.output + prev.output;
+          state2.globstar = true;
+          state2.output += prior.output + prev.output;
           consume(value);
           continue;
         }
         if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
           const end = rest[1] !== undefined ? "|$" : "";
-          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          state2.output = state2.output.slice(0, -(prior.output + prev.output).length);
           prior.output = `(?:${prior.output}`;
           prev.type = "globstar";
           prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
           prev.value += value;
-          state.output += prior.output + prev.output;
-          state.globstar = true;
+          state2.output += prior.output + prev.output;
+          state2.globstar = true;
           consume(value + advance());
           push({ type: "slash", value: "/", output: "" });
           continue;
@@ -1170,18 +1170,18 @@ var require_parse = __commonJS((exports, module) => {
           prev.type = "globstar";
           prev.value += value;
           prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-          state.output = prev.output;
-          state.globstar = true;
+          state2.output = prev.output;
+          state2.globstar = true;
           consume(value + advance());
           push({ type: "slash", value: "/", output: "" });
           continue;
         }
-        state.output = state.output.slice(0, -prev.output.length);
+        state2.output = state2.output.slice(0, -prev.output.length);
         prev.type = "globstar";
         prev.output = globstar(opts);
         prev.value += value;
-        state.output += prev.output;
-        state.globstar = true;
+        state2.output += prev.output;
+        state2.globstar = true;
         consume(value);
         continue;
       }
@@ -1199,55 +1199,55 @@ var require_parse = __commonJS((exports, module) => {
         push(token);
         continue;
       }
-      if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+      if (state2.index === state2.start || prev.type === "slash" || prev.type === "dot") {
         if (prev.type === "dot") {
-          state.output += NO_DOT_SLASH;
+          state2.output += NO_DOT_SLASH;
           prev.output += NO_DOT_SLASH;
         } else if (opts.dot === true) {
-          state.output += NO_DOTS_SLASH;
+          state2.output += NO_DOTS_SLASH;
           prev.output += NO_DOTS_SLASH;
         } else {
-          state.output += nodot;
+          state2.output += nodot;
           prev.output += nodot;
         }
         if (peek() !== "*") {
-          state.output += ONE_CHAR;
+          state2.output += ONE_CHAR;
           prev.output += ONE_CHAR;
         }
       }
       push(token);
     }
-    while (state.brackets > 0) {
+    while (state2.brackets > 0) {
       if (opts.strictBrackets === true)
         throw new SyntaxError(syntaxError("closing", "]"));
-      state.output = utils.escapeLast(state.output, "[");
+      state2.output = utils.escapeLast(state2.output, "[");
       decrement("brackets");
     }
-    while (state.parens > 0) {
+    while (state2.parens > 0) {
       if (opts.strictBrackets === true)
         throw new SyntaxError(syntaxError("closing", ")"));
-      state.output = utils.escapeLast(state.output, "(");
+      state2.output = utils.escapeLast(state2.output, "(");
       decrement("parens");
     }
-    while (state.braces > 0) {
+    while (state2.braces > 0) {
       if (opts.strictBrackets === true)
         throw new SyntaxError(syntaxError("closing", "}"));
-      state.output = utils.escapeLast(state.output, "{");
+      state2.output = utils.escapeLast(state2.output, "{");
       decrement("braces");
     }
     if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
       push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
     }
-    if (state.backtrack === true) {
-      state.output = "";
-      for (const token of state.tokens) {
-        state.output += token.output != null ? token.output : token.value;
+    if (state2.backtrack === true) {
+      state2.output = "";
+      for (const token of state2.tokens) {
+        state2.output += token.output != null ? token.output : token.value;
         if (token.suffix) {
-          state.output += token.suffix;
+          state2.output += token.suffix;
         }
       }
     }
-    return state;
+    return state2;
   };
   parse.fastpaths = (input, options) => {
     const opts = { ...options };
@@ -1271,7 +1271,7 @@ var require_parse = __commonJS((exports, module) => {
     const nodot = opts.dot ? NO_DOTS : NO_DOT;
     const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
     const capture = opts.capture ? "" : "?:";
-    const state = { negated: false, prefix: "" };
+    const state2 = { negated: false, prefix: "" };
     let star = opts.bash === true ? ".*?" : STAR;
     if (opts.capture) {
       star = `(${star})`;
@@ -1310,7 +1310,7 @@ var require_parse = __commonJS((exports, module) => {
         }
       }
     };
-    const output = utils.removePrefix(input, state);
+    const output = utils.removePrefix(input, state2);
     let source = create(output);
     if (source && opts.strictSlashes !== true) {
       source += `${SLASH_LITERAL}?`;
@@ -1332,9 +1332,9 @@ var require_picomatch = __commonJS((exports, module) => {
       const fns = glob.map((input) => picomatch(input, options, returnState));
       const arrayMatcher = (str) => {
         for (const isMatch of fns) {
-          const state2 = isMatch(str);
-          if (state2)
-            return state2;
+          const state3 = isMatch(str);
+          if (state3)
+            return state3;
         }
         return false;
       };
@@ -1347,7 +1347,7 @@ var require_picomatch = __commonJS((exports, module) => {
     const opts = options || {};
     const posix = opts.windows;
     const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
-    const state = regex.state;
+    const state2 = regex.state;
     delete regex.state;
     let isIgnored = () => false;
     if (opts.ignore) {
@@ -1356,7 +1356,7 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     const matcher = (input, returnObject = false) => {
       const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
-      const result = { glob, state, regex, posix, input, output, match, isMatch };
+      const result = { glob, state: state2, regex, posix, input, output, match, isMatch };
       if (typeof opts.onResult === "function") {
         opts.onResult(result);
       }
@@ -1377,7 +1377,7 @@ var require_picomatch = __commonJS((exports, module) => {
       return returnObject ? result : true;
     };
     if (returnState) {
-      matcher.state = state;
+      matcher.state = state2;
     }
     return matcher;
   };
@@ -1416,20 +1416,20 @@ var require_picomatch = __commonJS((exports, module) => {
     return parse(pattern, { ...options, fastpaths: false });
   };
   picomatch.scan = (input, options) => scan(input, options);
-  picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+  picomatch.compileRe = (state2, options, returnOutput = false, returnState = false) => {
     if (returnOutput === true) {
-      return state.output;
+      return state2.output;
     }
     const opts = options || {};
     const prepend = opts.contains ? "" : "^";
     const append = opts.contains ? "" : "$";
-    let source = `${prepend}(?:${state.output})${append}`;
-    if (state && state.negated === true) {
+    let source = `${prepend}(?:${state2.output})${append}`;
+    if (state2 && state2.negated === true) {
       source = `^(?!${source}).*$`;
     }
     const regex = picomatch.toRegex(source, options);
     if (returnState === true) {
-      regex.state = state;
+      regex.state = state2;
     }
     return regex;
   };
@@ -3534,6 +3534,28 @@ ${CONTEXT_REMINDER}
 }
 // src/hooks/session-notification.ts
 import { platform } from "os";
+// src/features/claude-code-session-state/state.ts
+var sessionErrorState = new Map;
+var sessionInterruptState = new Map;
+var subagentSessions = new Set;
+var sessionFirstMessageProcessed = new Set;
+var currentSessionID;
+var currentSessionTitle;
+var mainSessionID;
+function setCurrentSession(id, title) {
+  currentSessionID = id;
+  currentSessionTitle = title;
+}
+function setMainSession(id) {
+  mainSessionID = id;
+}
+function getCurrentSessionTitle() {
+  return currentSessionTitle;
+}
+function getMainSessionID() {
+  return mainSessionID;
+}
+// src/hooks/session-notification.ts
 function detectPlatform() {
   const p = platform();
   if (p === "darwin" || p === "linux" || p === "win32")
@@ -3700,6 +3722,8 @@ function createSessionNotification(ctx, config = {}) {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
+      if (subagentSessions.has(sessionID))
+        return;
       if (notifiedSessions.has(sessionID))
         return;
       if (pendingTimers.has(sessionID))
@@ -5260,28 +5284,28 @@ function truncateToolResult(partPath) {
 
 // src/hooks/anthropic-auto-compact/executor.ts
 function getOrCreateRetryState(autoCompactState, sessionID) {
-  let state = autoCompactState.retryStateBySession.get(sessionID);
-  if (!state) {
-    state = { attempt: 0, lastAttemptTime: 0 };
-    autoCompactState.retryStateBySession.set(sessionID, state);
+  let state2 = autoCompactState.retryStateBySession.get(sessionID);
+  if (!state2) {
+    state2 = { attempt: 0, lastAttemptTime: 0 };
+    autoCompactState.retryStateBySession.set(sessionID, state2);
   }
-  return state;
+  return state2;
 }
 function getOrCreateFallbackState(autoCompactState, sessionID) {
-  let state = autoCompactState.fallbackStateBySession.get(sessionID);
-  if (!state) {
-    state = { revertAttempt: 0 };
-    autoCompactState.fallbackStateBySession.set(sessionID, state);
+  let state2 = autoCompactState.fallbackStateBySession.get(sessionID);
+  if (!state2) {
+    state2 = { revertAttempt: 0 };
+    autoCompactState.fallbackStateBySession.set(sessionID, state2);
   }
-  return state;
+  return state2;
 }
 function getOrCreateTruncateState(autoCompactState, sessionID) {
-  let state = autoCompactState.truncateStateBySession.get(sessionID);
-  if (!state) {
-    state = { truncateAttempt: 0 };
-    autoCompactState.truncateStateBySession.set(sessionID, state);
+  let state2 = autoCompactState.truncateStateBySession.get(sessionID);
+  if (!state2) {
+    state2 = { truncateAttempt: 0 };
+    autoCompactState.truncateStateBySession.set(sessionID, state2);
   }
-  return state;
+  return state2;
 }
 async function getLastMessagePair(sessionID, client, directory) {
   try {
@@ -5811,25 +5835,25 @@ function createThinkModeHook() {
   return {
     "chat.params": async (output, sessionID) => {
       const promptText = extractPromptText(output.parts);
-      const state = {
+      const state2 = {
         requested: false,
         modelSwitched: false,
         thinkingConfigInjected: false
       };
       if (!detectThinkKeyword(promptText)) {
-        thinkModeState.set(sessionID, state);
+        thinkModeState.set(sessionID, state2);
         return;
       }
-      state.requested = true;
+      state2.requested = true;
       const currentModel = output.message.model;
       if (!currentModel) {
-        thinkModeState.set(sessionID, state);
+        thinkModeState.set(sessionID, state2);
         return;
       }
-      state.providerID = currentModel.providerID;
-      state.modelID = currentModel.modelID;
+      state2.providerID = currentModel.providerID;
+      state2.modelID = currentModel.modelID;
       if (isAlreadyHighVariant(currentModel.modelID)) {
-        thinkModeState.set(sessionID, state);
+        thinkModeState.set(sessionID, state2);
         return;
       }
       const highVariant = getHighVariant(currentModel.modelID);
@@ -5839,7 +5863,7 @@ function createThinkModeHook() {
           providerID: currentModel.providerID,
           modelID: highVariant
         };
-        state.modelSwitched = true;
+        state2.modelSwitched = true;
         log("Think mode: model switched to high variant", {
           sessionID,
           from: currentModel.modelID,
@@ -5848,14 +5872,14 @@ function createThinkModeHook() {
       }
       if (thinkingConfig) {
         Object.assign(output.message, thinkingConfig);
-        state.thinkingConfigInjected = true;
+        state2.thinkingConfigInjected = true;
         log("Think mode: thinking config injected", {
           sessionID,
           provider: currentModel.providerID,
           config: thinkingConfig
         });
       }
-      thinkModeState.set(sessionID, state);
+      thinkModeState.set(sessionID, state2);
     },
     event: async ({ event }) => {
       if (event.type === "session.deleted") {
@@ -6551,13 +6575,13 @@ setInterval(() => {
 }, CACHE_TTL);
 
 // src/hooks/claude-code-hooks/index.ts
-var sessionFirstMessageProcessed = new Set;
-var sessionErrorState = new Map;
-var sessionInterruptState = new Map;
+var sessionFirstMessageProcessed2 = new Set;
+var sessionErrorState2 = new Map;
+var sessionInterruptState2 = new Map;
 function createClaudeCodeHooksHook(ctx, config = {}) {
   return {
     "chat.message": async (input, output) => {
-      const interruptState = sessionInterruptState.get(input.sessionID);
+      const interruptState = sessionInterruptState2.get(input.sessionID);
       if (interruptState?.interrupted) {
         log("chat.message hook skipped - session interrupted", { sessionID: input.sessionID });
         return;
@@ -6572,7 +6596,7 @@ function createClaudeCodeHooksHook(ctx, config = {}) {
         type: p.type,
         text: p.text
       }));
-      const interruptStateBeforeHooks = sessionInterruptState.get(input.sessionID);
+      const interruptStateBeforeHooks = sessionInterruptState2.get(input.sessionID);
       if (interruptStateBeforeHooks?.interrupted) {
         log("chat.message hooks skipped - interrupted during preparation", { sessionID: input.sessionID });
         return;
@@ -6584,8 +6608,8 @@ function createClaudeCodeHooksHook(ctx, config = {}) {
         });
         parentSessionId = sessionInfo.data?.parentID;
       } catch {}
-      const isFirstMessage = !sessionFirstMessageProcessed.has(input.sessionID);
-      sessionFirstMessageProcessed.add(input.sessionID);
+      const isFirstMessage = !sessionFirstMessageProcessed2.has(input.sessionID);
+      sessionFirstMessageProcessed2.add(input.sessionID);
       if (isFirstMessage) {
         log("Skipping UserPromptSubmit hooks on first message for title generation", { sessionID: input.sessionID });
         return;
@@ -6602,7 +6626,7 @@ function createClaudeCodeHooksHook(ctx, config = {}) {
         if (result.block) {
           throw new Error(result.reason ?? "Hook blocked the prompt");
         }
-        const interruptStateAfterHooks = sessionInterruptState.get(input.sessionID);
+        const interruptStateAfterHooks = sessionInterruptState2.get(input.sessionID);
         if (interruptStateAfterHooks?.interrupted) {
           log("chat.message injection skipped - interrupted during hooks", { sessionID: input.sessionID });
           return;
@@ -6722,7 +6746,7 @@ ${result.message}`;
         const props = event.properties;
         const sessionID = props?.sessionID;
         if (sessionID) {
-          sessionErrorState.set(sessionID, {
+          sessionErrorState2.set(sessionID, {
             hasError: true,
             errorMessage: String(props?.error ?? "Unknown error")
           });
@@ -6733,9 +6757,9 @@ ${result.message}`;
         const props = event.properties;
         const sessionInfo = props?.info;
         if (sessionInfo?.id) {
-          sessionErrorState.delete(sessionInfo.id);
-          sessionInterruptState.delete(sessionInfo.id);
-          sessionFirstMessageProcessed.delete(sessionInfo.id);
+          sessionErrorState2.delete(sessionInfo.id);
+          sessionInterruptState2.delete(sessionInfo.id);
+          sessionFirstMessageProcessed2.delete(sessionInfo.id);
         }
         return;
       }
@@ -6746,9 +6770,9 @@ ${result.message}`;
           return;
         const claudeConfig = await loadClaudeHooksConfig();
         const extendedConfig = await loadPluginExtendedConfig();
-        const errorStateBefore = sessionErrorState.get(sessionID);
+        const errorStateBefore = sessionErrorState2.get(sessionID);
         const endedWithErrorBefore = errorStateBefore?.hasError === true;
-        const interruptStateBefore = sessionInterruptState.get(sessionID);
+        const interruptStateBefore = sessionInterruptState2.get(sessionID);
         const interruptedBefore = interruptStateBefore?.interrupted === true;
         let parentSessionId;
         try {
@@ -6764,9 +6788,9 @@ ${result.message}`;
             cwd: ctx.directory
           };
           const stopResult = await executeStopHooks(stopCtx, claudeConfig, extendedConfig);
-          const errorStateAfter = sessionErrorState.get(sessionID);
+          const errorStateAfter = sessionErrorState2.get(sessionID);
           const endedWithErrorAfter = errorStateAfter?.hasError === true;
-          const interruptStateAfter = sessionInterruptState.get(sessionID);
+          const interruptStateAfter = sessionInterruptState2.get(sessionID);
           const interruptedAfter = interruptStateAfter?.interrupted === true;
           const shouldBypass = endedWithErrorBefore || endedWithErrorAfter || interruptedBefore || interruptedAfter;
           if (shouldBypass && stopResult.block) {
@@ -6784,8 +6808,8 @@ ${result.message}`;
             log("Stop hook returned block", { sessionID, reason: stopResult.reason });
           }
         }
-        sessionErrorState.delete(sessionID);
-        sessionInterruptState.delete(sessionID);
+        sessionErrorState2.delete(sessionID);
+        sessionInterruptState2.delete(sessionID);
       }
     }
   };
@@ -7601,12 +7625,12 @@ function loadAgentUsageState(sessionID) {
     return null;
   }
 }
-function saveAgentUsageState(state) {
+function saveAgentUsageState(state2) {
   if (!existsSync21(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
-  const filePath = getStoragePath4(state.sessionID);
-  writeFileSync9(filePath, JSON.stringify(state, null, 2));
+  const filePath = getStoragePath4(state2.sessionID);
+  writeFileSync9(filePath, JSON.stringify(state2, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
@@ -7621,21 +7645,21 @@ function createAgentUsageReminderHook(_ctx) {
   function getOrCreateState(sessionID) {
     if (!sessionStates.has(sessionID)) {
       const persisted = loadAgentUsageState(sessionID);
-      const state = persisted ?? {
+      const state2 = persisted ?? {
         sessionID,
         agentUsed: false,
         reminderCount: 0,
         updatedAt: Date.now()
       };
-      sessionStates.set(sessionID, state);
+      sessionStates.set(sessionID, state2);
     }
     return sessionStates.get(sessionID);
   }
   function markAgentUsed(sessionID) {
-    const state = getOrCreateState(sessionID);
-    state.agentUsed = true;
-    state.updatedAt = Date.now();
-    saveAgentUsageState(state);
+    const state2 = getOrCreateState(sessionID);
+    state2.agentUsed = true;
+    state2.updatedAt = Date.now();
+    saveAgentUsageState(state2);
   }
   function resetState(sessionID) {
     sessionStates.delete(sessionID);
@@ -7651,14 +7675,14 @@ function createAgentUsageReminderHook(_ctx) {
     if (!TARGET_TOOLS.has(toolLower)) {
       return;
     }
-    const state = getOrCreateState(sessionID);
-    if (state.agentUsed) {
+    const state2 = getOrCreateState(sessionID);
+    if (state2.agentUsed) {
       return;
     }
     output.output += REMINDER_MESSAGE;
-    state.reminderCount++;
-    state.updatedAt = Date.now();
-    saveAgentUsageState(state);
+    state2.reminderCount++;
+    state2.updatedAt = Date.now();
+    saveAgentUsageState(state2);
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -7873,15 +7897,15 @@ function loadInteractiveBashSessionState(sessionID) {
     return null;
   }
 }
-function saveInteractiveBashSessionState(state) {
+function saveInteractiveBashSessionState(state2) {
   if (!existsSync22(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
-  const filePath = getStoragePath5(state.sessionID);
+  const filePath = getStoragePath5(state2.sessionID);
   const serialized = {
-    sessionID: state.sessionID,
-    tmuxSessions: Array.from(state.tmuxSessions),
-    updatedAt: state.updatedAt
+    sessionID: state2.sessionID,
+    tmuxSessions: Array.from(state2.tmuxSessions),
+    updatedAt: state2.updatedAt
   };
   writeFileSync10(filePath, JSON.stringify(serialized, null, 2));
 }
@@ -7979,20 +8003,20 @@ function createInteractiveBashSessionHook(_ctx) {
   function getOrCreateState(sessionID) {
     if (!sessionStates.has(sessionID)) {
       const persisted = loadInteractiveBashSessionState(sessionID);
-      const state = persisted ?? {
+      const state2 = persisted ?? {
         sessionID,
         tmuxSessions: new Set,
         updatedAt: Date.now()
       };
-      sessionStates.set(sessionID, state);
+      sessionStates.set(sessionID, state2);
     }
     return sessionStates.get(sessionID);
   }
   function isOmoSession(sessionName) {
     return sessionName !== null && sessionName.startsWith(OMO_SESSION_PREFIX);
   }
-  async function killAllTrackedSessions(state) {
-    for (const sessionName of state.tmuxSessions) {
+  async function killAllTrackedSessions(state2) {
+    for (const sessionName of state2.tmuxSessions) {
       try {
         const proc = Bun.spawn(["tmux", "kill-session", "-t", sessionName], {
           stdout: "ignore",
@@ -8014,7 +8038,7 @@ function createInteractiveBashSessionHook(_ctx) {
     const tmuxCommand = args.tmux_command;
     const tokens = tokenizeCommand(tmuxCommand);
     const subCommand = findSubcommand(tokens);
-    const state = getOrCreateState(sessionID);
+    const state2 = getOrCreateState(sessionID);
     let stateChanged = false;
     const toolOutput = output?.output ?? "";
     if (toolOutput.startsWith("Error:")) {
@@ -8025,22 +8049,22 @@ function createInteractiveBashSessionHook(_ctx) {
     const isKillServer = subCommand === "kill-server";
     const sessionName = extractSessionNameFromTokens(tokens, subCommand);
     if (isNewSession && isOmoSession(sessionName)) {
-      state.tmuxSessions.add(sessionName);
+      state2.tmuxSessions.add(sessionName);
       stateChanged = true;
     } else if (isKillSession && isOmoSession(sessionName)) {
-      state.tmuxSessions.delete(sessionName);
+      state2.tmuxSessions.delete(sessionName);
       stateChanged = true;
     } else if (isKillServer) {
-      state.tmuxSessions.clear();
+      state2.tmuxSessions.clear();
       stateChanged = true;
     }
     if (stateChanged) {
-      state.updatedAt = Date.now();
-      saveInteractiveBashSessionState(state);
+      state2.updatedAt = Date.now();
+      saveInteractiveBashSessionState(state2);
     }
     const isSessionOperation = isNewSession || isKillSession || isKillServer;
     if (isSessionOperation) {
-      const reminder = buildSessionReminderMessage(Array.from(state.tmuxSessions));
+      const reminder = buildSessionReminderMessage(Array.from(state2.tmuxSessions));
       if (reminder) {
         output.output += reminder;
       }
@@ -8052,8 +8076,8 @@ function createInteractiveBashSessionHook(_ctx) {
       const sessionInfo = props?.info;
       const sessionID = sessionInfo?.id;
       if (sessionID) {
-        const state = getOrCreateState(sessionID);
-        await killAllTrackedSessions(state);
+        const state2 = getOrCreateState(sessionID);
+        await killAllTrackedSessions(state2);
         sessionStates.delete(sessionID);
         clearInteractiveBashSessionState(sessionID);
       }
@@ -8249,8 +8273,8 @@ async function generatePKCEPair() {
     method: pkce.method
   };
 }
-function encodeState(state) {
-  const json = JSON.stringify(state);
+function encodeState(state2) {
+  const json = JSON.stringify(state2);
   return Buffer.from(json, "utf8").toString("base64url");
 }
 function decodeState(encoded) {
@@ -8268,7 +8292,7 @@ function decodeState(encoded) {
 }
 async function buildAuthURL(projectId, clientId = ANTIGRAVITY_CLIENT_ID, port = ANTIGRAVITY_CALLBACK_PORT) {
   const pkce = await generatePKCEPair();
-  const state = {
+  const state2 = {
     verifier: pkce.verifier,
     projectId
   };
@@ -8278,7 +8302,7 @@ async function buildAuthURL(projectId, clientId = ANTIGRAVITY_CLIENT_ID, port =
   url.searchParams.set("redirect_uri", redirectUri);
   url.searchParams.set("response_type", "code");
   url.searchParams.set("scope", ANTIGRAVITY_SCOPES.join(" "));
-  url.searchParams.set("state", encodeState(state));
+  url.searchParams.set("state", encodeState(state2));
   url.searchParams.set("code_challenge", pkce.challenge);
   url.searchParams.set("code_challenge_method", "S256");
   url.searchParams.set("access_type", "offline");
@@ -8354,7 +8378,7 @@ function startCallbackServer(timeoutMs = 5 * 60 * 1000) {
       const url = new URL(request.url);
       if (url.pathname === "/oauth-callback") {
         const code = url.searchParams.get("code") || "";
-        const state = url.searchParams.get("state") || "";
+        const state2 = url.searchParams.get("state") || "";
         const error = url.searchParams.get("error") || undefined;
         let responseBody;
         if (code && !error) {
@@ -8365,7 +8389,7 @@ function startCallbackServer(timeoutMs = 5 * 60 * 1000) {
         setTimeout(() => {
           cleanup();
           if (resolveCallback) {
-            resolveCallback({ code, state, error });
+            resolveCallback({ code, state: state2, error });
           }
         }, 100);
         return new Response(responseBody, {
@@ -9781,8 +9805,8 @@ async function createGoogleAntigravityAuthPlugin({
                   }
                   return { type: "failed" };
                 }
-                const state = decodeState(result.state);
-                if (state.verifier !== verifier) {
+                const state2 = decodeState(result.state);
+                if (state2.verifier !== verifier) {
                   if (process.env.ANTIGRAVITY_DEBUG === "1") {
                     console.error("[antigravity-plugin] PKCE verifier mismatch");
                   }
@@ -10152,27 +10176,6 @@ async function loadMcpConfigs() {
   }
   return { servers, loadedServers };
 }
-// src/features/claude-code-session-state/state.ts
-var sessionErrorState2 = new Map;
-var sessionInterruptState2 = new Map;
-var subagentSessions = new Set;
-var sessionFirstMessageProcessed2 = new Set;
-var currentSessionID;
-var currentSessionTitle;
-var mainSessionID;
-function setCurrentSession(id, title) {
-  currentSessionID = id;
-  currentSessionTitle = title;
-}
-function setMainSession(id) {
-  mainSessionID = id;
-}
-function getCurrentSessionTitle() {
-  return currentSessionTitle;
-}
-function getMainSessionID() {
-  return mainSessionID;
-}
 // src/features/terminal/title.ts
 var STATUS_ICONS = {
   ready: "",
@@ -23711,11 +23714,11 @@ tool.schema = exports_external;
 
 // src/tools/lsp/tools.ts
 var lsp_hover = tool({
-  description: "Get type information, documentation, and signature for a symbol at a specific position in a file. Use this when you need to understand what a variable, function, class, or any identifier represents.",
+  description: "Get type info, docs, and signature for a symbol at position.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
-    line: tool.schema.number().min(1).describe("Line number (1-based)"),
-    character: tool.schema.number().min(0).describe("Character position (0-based)")
+    filePath: tool.schema.string(),
+    line: tool.schema.number().min(1).describe("1-based"),
+    character: tool.schema.number().min(0).describe("0-based")
   },
   execute: async (args, context) => {
     try {
@@ -23731,11 +23734,11 @@ var lsp_hover = tool({
   }
 });
 var lsp_goto_definition = tool({
-  description: "Jump to the source definition of a symbol (variable, function, class, type, import, etc.). Use this when you need to find WHERE something is defined.",
+  description: "Jump to symbol definition. Find WHERE something is defined.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
-    line: tool.schema.number().min(1).describe("Line number (1-based)"),
-    character: tool.schema.number().min(0).describe("Character position (0-based)")
+    filePath: tool.schema.string(),
+    line: tool.schema.number().min(1).describe("1-based"),
+    character: tool.schema.number().min(0).describe("0-based")
   },
   execute: async (args, context) => {
     try {
@@ -23761,11 +23764,11 @@ var lsp_goto_definition = tool({
   }
 });
 var lsp_find_references = tool({
-  description: "Find ALL usages/references of a symbol across the entire workspace. Use this when you need to understand the impact of changing something.",
+  description: "Find ALL usages/references of a symbol across the entire workspace.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
-    line: tool.schema.number().min(1).describe("Line number (1-based)"),
-    character: tool.schema.number().min(0).describe("Character position (0-based)"),
+    filePath: tool.schema.string(),
+    line: tool.schema.number().min(1).describe("1-based"),
+    character: tool.schema.number().min(0).describe("0-based"),
     includeDeclaration: tool.schema.boolean().optional().describe("Include the declaration itself")
   },
   execute: async (args, context) => {
@@ -23794,9 +23797,9 @@ var lsp_find_references = tool({
   }
 });
 var lsp_document_symbols = tool({
-  description: "Get a hierarchical outline of all symbols (classes, functions, methods, variables, types, constants) in a single file. Use this to quickly understand a file's structure.",
+  description: "Get hierarchical outline of all symbols in a file.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file")
+    filePath: tool.schema.string()
   },
   execute: async (args, context) => {
     try {
@@ -23828,11 +23831,11 @@ var lsp_document_symbols = tool({
   }
 });
 var lsp_workspace_symbols = tool({
-  description: "Search for symbols by name across the ENTIRE workspace/project. Use this when you know (or partially know) a symbol's name but don't know which file it's in.",
+  description: "Search symbols by name across ENTIRE workspace.",
   args: {
-    filePath: tool.schema.string().describe("A file path in the workspace to determine the workspace root"),
-    query: tool.schema.string().describe("The symbol name to search for (supports fuzzy matching)"),
-    limit: tool.schema.number().optional().describe("Maximum number of results to return")
+    filePath: tool.schema.string(),
+    query: tool.schema.string().describe("Symbol name (fuzzy match)"),
+    limit: tool.schema.number().optional().describe("Max results")
   },
   execute: async (args, context) => {
     try {
@@ -23861,9 +23864,9 @@ var lsp_workspace_symbols = tool({
   }
 });
 var lsp_diagnostics = tool({
-  description: "Get all errors, warnings, and hints for a file from the language server. Use this to check if code has type errors, syntax issues, or linting problems BEFORE running the build.",
+  description: "Get errors, warnings, hints from language server BEFORE running build.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
+    filePath: tool.schema.string(),
     severity: tool.schema.enum(["error", "warning", "information", "hint", "all"]).optional().describe("Filter by severity level")
   },
   execute: async (args, context) => {
@@ -23901,7 +23904,7 @@ var lsp_diagnostics = tool({
   }
 });
 var lsp_servers = tool({
-  description: "List all available LSP servers and check if they are installed. Use this to see what language support is available.",
+  description: "List available LSP servers and installation status.",
   args: {},
   execute: async (_args, context) => {
     try {
@@ -23923,11 +23926,11 @@ var lsp_servers = tool({
   }
 });
 var lsp_prepare_rename = tool({
-  description: "Check if a symbol at a specific position can be renamed. Use this BEFORE attempting to rename to validate the operation and get the current symbol name.",
+  description: "Check if rename is valid. Use BEFORE lsp_rename.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
-    line: tool.schema.number().min(1).describe("Line number (1-based)"),
-    character: tool.schema.number().min(0).describe("Character position (0-based)")
+    filePath: tool.schema.string(),
+    line: tool.schema.number().min(1).describe("1-based"),
+    character: tool.schema.number().min(0).describe("0-based")
   },
   execute: async (args, context) => {
     try {
@@ -23943,12 +23946,12 @@ var lsp_prepare_rename = tool({
   }
 });
 var lsp_rename = tool({
-  description: "Rename a symbol across the entire workspace. This APPLIES the rename to all files. Use lsp_prepare_rename first to check if rename is possible.",
+  description: "Rename symbol across entire workspace. APPLIES changes to all files.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
-    line: tool.schema.number().min(1).describe("Line number (1-based)"),
-    character: tool.schema.number().min(0).describe("Character position (0-based)"),
-    newName: tool.schema.string().describe("The new name for the symbol")
+    filePath: tool.schema.string(),
+    line: tool.schema.number().min(1).describe("1-based"),
+    character: tool.schema.number().min(0).describe("0-based"),
+    newName: tool.schema.string().describe("New symbol name")
   },
   execute: async (args, context) => {
     try {
@@ -23965,13 +23968,13 @@ var lsp_rename = tool({
   }
 });
 var lsp_code_actions = tool({
-  description: "Get available code actions for a range in the file. Code actions include quick fixes, refactorings (extract, inline, rewrite), and source actions (organize imports, fix all). Use this to discover what automated changes the language server can perform.",
+  description: "Get available quick fixes, refactorings, and source actions (organize imports, fix all).",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to the file"),
-    startLine: tool.schema.number().min(1).describe("Start line number (1-based)"),
-    startCharacter: tool.schema.number().min(0).describe("Start character position (0-based)"),
-    endLine: tool.schema.number().min(1).describe("End line number (1-based)"),
-    endCharacter: tool.schema.number().min(0).describe("End character position (0-based)"),
+    filePath: tool.schema.string(),
+    startLine: tool.schema.number().min(1).describe("1-based"),
+    startCharacter: tool.schema.number().min(0).describe("0-based"),
+    endLine: tool.schema.number().min(1).describe("1-based"),
+    endCharacter: tool.schema.number().min(0).describe("0-based"),
     kind: tool.schema.enum([
       "quickfix",
       "refactor",
@@ -23998,10 +24001,10 @@ var lsp_code_actions = tool({
   }
 });
 var lsp_code_action_resolve = tool({
-  description: "Resolve and APPLY a code action. This resolves the full details and applies the changes to files. Use after getting a code action from lsp_code_actions.",
+  description: "Resolve and APPLY a code action from lsp_code_actions.",
   args: {
-    filePath: tool.schema.string().describe("The absolute path to a file in the workspace (used to find the LSP server)"),
-    codeAction: tool.schema.string().describe("The code action JSON object as returned by lsp_code_actions (stringified)")
+    filePath: tool.schema.string(),
+    codeAction: tool.schema.string().describe("Code action JSON from lsp_code_actions")
   },
   execute: async (args, context) => {
     try {
@@ -25435,15 +25438,9 @@ var BLOCKED_TMUX_SUBCOMMANDS = [
   "pipe-pane",
   "pipep"
 ];
-var INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands for interactive terminal session management.
-
-Use session names following the pattern "omo-{name}" for automatic tracking.
+var INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands. Use "omo-{name}" session pattern.
 
-BLOCKED COMMANDS (use bash tool instead):
-- capture-pane / capturep: Use bash to read output files or pipe output
-- save-buffer / saveb: Use bash to save content to files
-- show-buffer / showb: Use bash to read buffer content
-- pipe-pane / pipep: Use bash for piping output`;
+Blocked (use bash instead): capture-pane, save-buffer, show-buffer, pipe-pane.`;
 
 // src/tools/interactive-bash/utils.ts
 var {spawn: spawn9 } = globalThis.Bun;
@@ -25581,40 +25578,11 @@ var interactive_bash = tool({
   }
 });
 // src/tools/background-task/constants.ts
-var BACKGROUND_TASK_DESCRIPTION = `Launch a background agent task that runs asynchronously.
-
-The task runs in a separate session while you continue with other work. The system will notify you when the task completes.
-
-Use this for:
-- Long-running research tasks
-- Complex analysis that doesn't need immediate results
-- Parallel workloads to maximize throughput
-
-Arguments:
-- description: Short task description (shown in status)
-- prompt: Full detailed prompt for the agent (MUST be in English for optimal LLM performance)
-- agent: Agent type to use (any agent allowed)
-
-IMPORTANT: Always write prompts in English regardless of user's language. LLMs perform significantly better with English prompts.
-
-Returns immediately with task ID and session info. Use \`background_output\` to check progress or retrieve results.`;
-var BACKGROUND_OUTPUT_DESCRIPTION = `Get output from a background task.
-
-Arguments:
-- task_id: Required task ID to get output from
-- block: If true, wait for task completion. If false (default), return current status immediately.
-- timeout: Max wait time in ms when blocking (default: 60000, max: 600000)
+var BACKGROUND_TASK_DESCRIPTION = `Run agent task in background. Returns task_id immediately; notifies on completion.
 
-The system automatically notifies when background tasks complete. You typically don't need block=true.`;
-var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s).
-
-Only works for tasks with status "running". Aborts the background session and marks the task as cancelled.
-
-Arguments:
-- taskId: Task ID to cancel (optional if all=true)
-- all: Set to true to cancel ALL running background tasks at once (default: false)
-
-**Cleanup Before Answer**: When you have gathered sufficient information and are ready to provide your final answer to the user, use \`all=true\` to cancel ALL running background tasks first, then deliver your response. This conserves resources and ensures clean workflow completion.`;
+Use \`background_output\` to get results. Prompts MUST be in English.`;
+var BACKGROUND_OUTPUT_DESCRIPTION = `Get output from background task. System notifies on completion, so block=true rarely needed.`;
+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 formatDuration(start, end) {
@@ -25885,29 +25853,11 @@ Status: ${task.status}`;
 }
 // src/tools/call-omo-agent/constants.ts
 var ALLOWED_AGENTS = ["explore", "librarian"];
-var CALL_OMO_AGENT_DESCRIPTION = `Launch a new agent to handle complex, multi-step tasks autonomously.
-
-This is a restricted version of the Task tool that only allows spawning explore and librarian agents.
+var CALL_OMO_AGENT_DESCRIPTION = `Spawn explore/librarian agent. run_in_background REQUIRED (true=async with task_id, false=sync).
 
-Available agent types:
-{agents}
+Available: {agents}
 
-When using this tool, you must specify a subagent_type parameter to select which agent type to use.
-
-**IMPORTANT: run_in_background parameter is REQUIRED**
-- \`run_in_background=true\`: Task runs asynchronously in background. Returns immediately with task_id.
-  The system will notify you when the task completes.
-  Use \`background_output\` tool with task_id to check progress (block=false returns full status info).
-- \`run_in_background=false\`: Task runs synchronously. Waits for completion and returns full result.
-
-Usage notes:
-1. Launch multiple agents concurrently whenever possible, to maximize performance
-2. When the agent is done, it will return a single message back to you
-3. Each agent invocation is stateless unless you provide a session_id
-4. Your prompt should contain a highly detailed task description for the agent to perform autonomously
-5. Clearly tell the agent whether you expect it to write code or just to do research
-6. For long-running research tasks, use run_in_background=true to avoid blocking
-7. **IMPORTANT**: Always write prompts in English regardless of user's language. LLMs perform significantly better with English prompts.`;
+Prompts MUST be in English. Use \`background_output\` for async results.`;
 // src/tools/call-omo-agent/tools.ts
 function createCallOmoAgent(ctx, backgroundManager) {
   const agentDescriptions = ALLOWED_AGENTS.map((name) => `- ${name}: Specialized agent for ${name} tasks`).join(`
@@ -26054,14 +26004,7 @@ session_id: ${sessionID}
 }
 // src/tools/look-at/constants.ts
 var MULTIMODAL_LOOKER_AGENT = "multimodal-looker";
-var LOOK_AT_DESCRIPTION = `Analyze media files (PDFs, images, diagrams) that require visual interpretation.
-
-Parameters:
-- file_path: Absolute path to the file to analyze
-- goal: What specific information to extract (be specific for better results)
-
-This tool uses a separate context window with Gemini 2.5 Flash for multimodal analysis,
-saving tokens in the main conversation while providing accurate visual interpretation.`;
+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
 function createLookAt(ctx) {
   return tool({
@@ -26200,6 +26143,7 @@ class BackgroundManager {
       throw new Error(`Failed to create background session: ${createResult.error}`);
     }
     const sessionID = createResult.data.id;
+    subagentSessions.add(sessionID);
     const task = {
       id: `bg_${crypto.randomUUID().slice(0, 8)}`,
       sessionID,
@@ -26338,6 +26282,7 @@ class BackgroundManager {
       }
       this.tasks.delete(task.id);
       this.clearNotificationsForTask(task.id);
+      subagentSessions.delete(sessionID);
     }
   }
   markForNotification(task) {
@@ -26791,7 +26736,6 @@ var OhMyOpenCodePlugin = async (ctx) => {
         const { name: _planName, ...planConfigWithoutName } = config3.agent?.plan ?? {};
         const omoPlanOverride = pluginConfig.agents?.["OmO-Plan"];
         const omoPlanBase = {
-          ...builtinAgents.OmO,
           ...planConfigWithoutName,
           description: `${config3.agent?.plan?.description ?? "Plan agent"} (OhMyOpenCode version)`,
           color: config3.agent?.plan?.color ?? "#6495ED"