CC 2.1.97 compatibility + new patches

src/defaultSettings.ts

@@ -719,6 +719,8 @@ export const DEFAULT_SETTINGS: Settings = {
     enableVoiceMode: false,
     enableVoiceConciseOutput: true,
     enableChannelsMode: false,
+    disableGarnetLoom: false,
+    enableMaxAgentTurnsOverride: false,
   },
   toolsets: [],
   defaultToolset: null,

src/patches/agentsMd.ts

@@ -67,10 +67,19 @@ export const writeAgentsMd = (
 
   const fsPattern = /([$\w]+(?:\(\))?)\.(?:readFileSync|existsSync|statSync)/;
   const fsMatch = funcMatch[0].match(fsPattern);
+
   if (!fsMatch) {
-    console.error('patch: agentsMd: failed to find fs expression in function');
-    return null;
+    // CC 2.1.97+: reading and processing are split into separate functions.
+    // The content processor (sa_) has "Skipping non-text file" but no fs calls.
+    // Check if the feature is already built into this CC version.
+    if (file.includes('didReroute') && file.includes('AGENTS.md')) {
+      // CC 2.1.97+ already has AGENTS.md fallback built in — no patch needed
+      return file;
+    }
+    // Otherwise, patch the async reader function.
+    return writeAgentsMdAsync(file, altNames);
   }
+
   const fsExpr = fsMatch[1];
 
   const altNamesJson = JSON.stringify(altNames);
@@ -119,3 +128,123 @@ export const writeAgentsMd = (
 
   return newFile;
 };
+
+/**
+ * CC 2.1.97+ variant: the file reading function is async and split from processing.
+ *
+ * Structure:
+ * ```
+ * async function yP4(q,K,_){
+ *   try {
+ *     let Y = await X8().readFile(q, {encoding:"utf-8"});
+ *     return sa_(Y, q, K, _);
+ *   } catch(z) {
+ *     return ta_(z, q), {info:null, includePaths:[]};
+ *   }
+ * }
+ * ```
+ *
+ * We patch the catch block to try alternative filenames when ENOENT + CLAUDE.md.
+ */
+const writeAgentsMdAsync = (
+  file: string,
+  altNames: string[]
+): string | null => {
+  const infoNullStr = '{info:null,includePaths:[]}';
+
+  // Find the async reader function by locating {info:null,includePaths:[]}
+  // near a readFile call
+  let infoNullIdx = -1;
+  let searchStart = 0;
+  while (true) {
+    const idx = file.indexOf(infoNullStr, searchStart);
+    if (idx === -1) break;
+
+    const lookback = file.slice(Math.max(0, idx - 500), idx);
+    if (lookback.includes('.readFile')) {
+      infoNullIdx = idx;
+      break;
+    }
+    searchStart = idx + 1;
+  }
+
+  if (infoNullIdx === -1) {
+    console.error(
+      'patch: agentsMd: failed to find async CLAUDE.md reader function (2.1.97+)'
+    );
+    return null;
+  }
+
+  const lookback = file.slice(Math.max(0, infoNullIdx - 500), infoNullIdx);
+
+  // Find the async function definition
+  const asyncFuncPattern =
+    /async function ([$\w]+)\(([$\w]+),([$\w]+),([$\w]+)\)\{/g;
+  const funcMatches = Array.from(lookback.matchAll(asyncFuncPattern));
+  if (funcMatches.length === 0) {
+    console.error(
+      'patch: agentsMd: failed to find async function definition (2.1.97+)'
+    );
+    return null;
+  }
+  const lastFunc = funcMatches[funcMatches.length - 1];
+  const funcName = lastFunc[1];
+  const pathParam = lastFunc[2];
+  const typeParam = lastFunc[3];
+  const resolvedParam = lastFunc[4];
+
+  // Find the catch variable
+  const catchPattern = /catch\(([$\w]+)\)\{/g;
+  const catchMatches = Array.from(lookback.matchAll(catchPattern));
+  if (catchMatches.length === 0) {
+    console.error('patch: agentsMd: failed to find catch block (2.1.97+)');
+    return null;
+  }
+  const catchVar = catchMatches[catchMatches.length - 1][1];
+
+  // Step 1: Add didReroute parameter to the function signature
+  const sigStr = `async function ${funcName}(${pathParam},${typeParam},${resolvedParam})`;
+  const sigIdx = file.indexOf(sigStr);
+  if (sigIdx === -1) {
+    console.error(
+      'patch: agentsMd: failed to locate function signature for injection (2.1.97+)'
+    );
+    return null;
+  }
+  const closingParenIdx = sigIdx + sigStr.length - 1;
+  let newFile =
+    file.slice(0, closingParenIdx) +
+    ',didReroute' +
+    file.slice(closingParenIdx);
+
+  showDiff(file, newFile, ',didReroute', closingParenIdx, closingParenIdx);
+
+  // Step 2: Inject fallback in the catch block before {info:null,...}
+  // The catch block is: catch(z){return ta_(z,q),{info:null,includePaths:[]}}
+  // We inject before the return statement.
+  const catchBlockStr = `catch(${catchVar}){`;
+  const catchBlockIdx = newFile.indexOf(catchBlockStr, sigIdx);
+  if (catchBlockIdx === -1) {
+    console.error(
+      'patch: agentsMd: failed to locate catch block for injection (2.1.97+)'
+    );
+    return null;
+  }
+  const returnIdx = catchBlockIdx + catchBlockStr.length;
+
+  const altNamesJson = JSON.stringify(altNames);
+  const fallback =
+    `if(${catchVar}&&${catchVar}.code==="ENOENT"&&!didReroute` +
+    `&&(${pathParam}.endsWith("/CLAUDE.md")||${pathParam}.endsWith("\\\\CLAUDE.md")))` +
+    `{for(let alt of ${altNamesJson})` +
+    `{try{let altPath=${pathParam}.slice(0,-9)+alt;` +
+    `let r=await ${funcName}(altPath,${typeParam},${resolvedParam},true);` +
+    `if(r.info)return r}catch(e){}}}`;
+
+  const oldFile = newFile;
+  newFile = newFile.slice(0, returnIdx) + fallback + newFile.slice(returnIdx);
+
+  showDiff(oldFile, newFile, fallback, returnIdx, returnIdx);
+
+  return newFile;
+};

src/patches/autoAcceptPlanMode.ts

@@ -47,9 +47,11 @@ export const writeAutoAcceptPlanMode = (oldFile: string): string | null => {
 
   // Look for onChange handler after Ready to code
   const afterReady = oldFile.slice(readyIdx, readyIdx + 3000);
-  const onChangeMatch = afterReady.match(
-    /onChange:\([$\w]+\)=>([$\w]+)\([$\w]+\),onCancel/
-  );
+  // CC ≥2.1.97: onChange:J6,onCancel (direct reference)
+  // CC <2.1.97: onChange:(X)=>FUNC(X),onCancel (arrow wrapper)
+  const onChangeMatch =
+    afterReady.match(/onChange:([$\w]+),onCancel/) ||
+    afterReady.match(/onChange:\([$\w]+\)=>([$\w]+)\([$\w]+\),onCancel/);
   if (!onChangeMatch) {
     console.error('patch: autoAcceptPlanMode: failed to find onChange handler');
     return null;
@@ -67,8 +69,10 @@ export const writeAutoAcceptPlanMode = (oldFile: string): string | null => {
 
   // Match the end of the "Exit plan mode?" conditional and the start of
   // the "Ready to code?" return.
+  // CC ≥2.1.97: wrapper changed from Fragment to Box (u) with props
+  // CC <2.1.97: wrapper is Fragment with null
   const pattern =
-    /(\}\}\)\)\)\);)(return [$\w]+\.default\.createElement\([$\w]+\.default\.Fragment,null,[$\w]+\.default\.createElement\([$\w]+,\{color:"planMode",title:"Ready to code\?")/;
+    /(\}\}\)\)\)\);)(return [$\w]+\.default\.createElement\((?:[$\w]+\.default\.Fragment,null|[$\w]+,\{[^}]*\}),[$\w]+\.default\.createElement\([$\w]+,\{color:"planMode",title:"Ready to code\?")/;
 
   const match = oldFile.match(pattern);
   if (!match || match.index === undefined) {

src/patches/contextLimit.ts

@@ -1,11 +1,51 @@
-// Please see the note about writing patches in ./index
+import { showDiff } from './index';
 
-import { globalReplace } from './index';
+/**
+ * Replaces the hardcoded default context limit (200K) with an env var override.
+ *
+ * The context window function determines the token limit for each model:
+ * ```
+ * function TV(q,K){
+ *   if(Cf(q))return 1e6;                      // [1m] models → 1M
+ *   if(K?.includes(ni)&&U01(q))return 1e6;     // SDK beta + supported model → 1M
+ *   if(cZ8(q))return 1e6;                      // coral_reef_sonnet experiment → 1M
+ *   return eN1                                  // default: eN1 = 200000
+ * }
+ * ```
+ *
+ * We patch the final `return eN1` to read from CLAUDE_CODE_CONTEXT_LIMIT env var,
+ * falling back to the original eN1 value if unset.
+ *
+ * ```diff
+ * -  return eN1
+ * +  return Number(process.env.CLAUDE_CODE_CONTEXT_LIMIT??eN1)
+ * ```
+ */
+export const writeContextLimit = (file: string): string | null => {
+  // Find the context window function by its unique structure:
+  // three 1e6 returns (for special models) then a variable return (default)
+  const pattern =
+    /function ([$\w]+)\(([$\w]+),([$\w]+)\)\{if\([$\w]+\(\2\)\)return 1e6;if\(\3\?\.includes\([$\w]+\)&&[$\w]+\(\2\)\)return 1e6;if\([$\w]+\(\2\)\)return 1e6;return ([$\w]+)\}/;
 
-export const writeContextLimit = (oldFile: string): string | null => {
-  return globalReplace(
-    oldFile,
-    /\b200000\b/,
-    '(+process.env.CLAUDE_CODE_CONTEXT_LIMIT||200000)'
-  );
+  const match = file.match(pattern);
+  if (!match || match.index === undefined) {
+    console.error(
+      'patch: contextLimit: failed to find context window function'
+    );
+    return null;
+  }
+
+  const defaultVar = match[4];
+  const oldStr = `return ${defaultVar}}`;
+  const newStr = `return Number(process.env.CLAUDE_CODE_CONTEXT_LIMIT??${defaultVar})}`;
+
+  const replaceStart = match.index + match[0].length - oldStr.length;
+  const newFile =
+    file.slice(0, replaceStart) +
+    newStr +
+    file.slice(replaceStart + oldStr.length);
+
+  showDiff(file, newFile, newStr, replaceStart, replaceStart + oldStr.length);
+
+  return newFile;
 };

src/patches/garnetLoom.ts

@@ -0,0 +1,66 @@
+import { showDiff } from './index';
+
+// ======
+
+/**
+ * Disable tengu_garnet_loom — prevents auto-downgrade of Opus to Sonnet
+ *
+ * CC 2.1.97 has a feature gate `tengu_garnet_loom` that, when enabled server-side,
+ * auto-downgrades Opus subagents to Sonnet when context is under 200K tokens.
+ *
+ * The pattern in the subagent model resolver:
+ *   if(!Y && Jz(j).includes("opus") && R8("tengu_garnet_loom",!1)){
+ *       let H=$5("sonnet"); return O(H,"sonnet")
+ *   }
+ *
+ * This patch forces the R8("tengu_garnet_loom") check to always return false,
+ * ensuring Opus stays Opus regardless of what GrowthBook says.
+ */
+export const writeDisableGarnetLoom = (oldFile: string): string | null => {
+  // Pattern: R8("tengu_garnet_loom",!1)
+  // This appears in the subagent model resolver function
+  const pattern = /R8\("tengu_garnet_loom",!1\)/;
+
+  const match = oldFile.match(pattern);
+  if (!match || match.index === undefined) {
+    // Try generic feature gate check function names
+    const altPattern = /([$\w]+)\("tengu_garnet_loom",![01]\)/;
+    const altMatch = oldFile.match(altPattern);
+    if (!altMatch || altMatch.index === undefined) {
+      console.error(
+        'patch: garnetLoom: failed to find tengu_garnet_loom feature gate check'
+      );
+      return null;
+    }
+
+    // Replace the entire check with false
+    const replacement = '!1';
+    const newFile =
+      oldFile.slice(0, altMatch.index) +
+      replacement +
+      oldFile.slice(altMatch.index + altMatch[0].length);
+    showDiff(
+      oldFile,
+      newFile,
+      replacement,
+      altMatch.index,
+      altMatch.index + altMatch[0].length
+    );
+    return newFile;
+  }
+
+  // Replace R8("tengu_garnet_loom",!1) with !1 (always false = never downgrade)
+  const replacement = '!1';
+  const newFile =
+    oldFile.slice(0, match.index) +
+    replacement +
+    oldFile.slice(match.index + match[0].length);
+  showDiff(
+    oldFile,
+    newFile,
+    replacement,
+    match.index,
+    match.index + match[0].length
+  );
+  return newFile;
+};

src/patches/helpers.ts

@@ -333,6 +333,35 @@ export const findBoxComponent = (fileContents: string): string | undefined => {
     return boxDisplayNameMatch[1];
   }
 
+  // Method 4: Find Box by createElement usage near known anchor (CC 2.1.97+)
+  // In 2.1.97, ink-box is no longer used via createElement directly in most code.
+  // Instead, a Box wrapper component is assigned to a short local variable (e.g. `u`)
+  // and used as createElement(u, {flexDirection:...}). We find it by locating a known
+  // anchor (the "Claude Code" bold text in the header) and checking which variable
+  // is used with flexDirection props nearby.
+  const headerAnchor = fileContents.match(
+    /createElement\([$\w]+,\{bold:!0\},"Claude Code"\)/
+  );
+  if (headerAnchor && headerAnchor.index !== undefined) {
+    const searchStart = Math.max(0, headerAnchor.index - 2000);
+    const searchEnd = Math.min(fileContents.length, headerAnchor.index + 2000);
+    const region = fileContents.slice(searchStart, searchEnd);
+    const boxUsage = region.match(
+      /createElement\(([$\w]+),\{(?:flexDirection|gap|marginBottom)/
+    );
+    if (boxUsage) {
+      return boxUsage[1];
+    }
+  }
+
+  // Method 4b: Fallback — find Box wrapper by border prop destructuring
+  const borderBoxPattern =
+    /function ([$\w]+)\([$\w]+\)\{.{0,200}borderColor:[$\w]+,borderTopColor:[$\w]+,borderBottomColor:[$\w]+,borderLeftColor:[$\w]+,borderRightColor:[$\w]+,backgroundColor:[$\w]+,children:[$\w]+,ref:[$\w]+/;
+  const borderBoxMatch = fileContents.match(borderBoxPattern);
+  if (borderBoxMatch) {
+    return borderBoxMatch[1];
+  }
+
   console.error(
     'patch: findBoxComponent: failed to find Box component (neither ink-box createElement nor displayName found)'
   );