oh-my-opencode 2.1.4 → 2.1.5

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: "",
@@ -26200,6 +26203,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 +26342,7 @@ class BackgroundManager {
       }
       this.tasks.delete(task.id);
       this.clearNotificationsForTask(task.id);
+      subagentSessions.delete(sessionID);
     }
   }
   markForNotification(task) {