@bman654/clodex 1.0.0 → 1.0.3

package/dist/cli.js

@@ -202,7 +202,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "1.0.0",
+  version: "1.0.3",
   publishConfig: {
     access: "public"
   },
@@ -256,6 +256,7 @@ var package_default = {
     "node-forge": "1.4.0",
     open: "11.0.0",
     picocolors: "1.1.1",
+    tweakcc: "4.3.0",
     undici: "7.28.0",
     ws: "8.21.0"
   },
@@ -7091,13 +7092,24 @@ function translateMessages(messages, npm, openAiPromptCacheBreakpoints = false)
   }
   return out;
 }
-function stripNullInputs(input) {
+function sanitizeToolInput(input, requiredProps) {
   const out = {};
   for (const [k, v] of Object.entries(input)) {
-    if (v !== null) out[k] = v;
+    if (v === null) continue;
+    if (Array.isArray(v) && v.length === 0 && !requiredProps?.has(k)) continue;
+    out[k] = v;
   }
   return out;
 }
+function toolRequiredProps(tools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [name, t] of Object.entries(tools ?? {})) {
+    const schema = t.inputSchema?.jsonSchema;
+    const required = Array.isArray(schema?.required) ? schema.required : [];
+    map.set(name, new Set(required.filter((r) => typeof r === "string")));
+  }
+  return map;
+}
 function translateTools(anthropicTools) {
   if (!anthropicTools?.length) return void 0;
   const tools = {};
@@ -7207,13 +7219,17 @@ function forwardAbortSignal(source, target) {
   source.addEventListener("abort", forward, { once: true });
   return () => source.removeEventListener("abort", forward);
 }
-async function writeAnthropicStream(stream, modelId, write, log12, observer) {
+async function writeAnthropicStream(stream, modelId, write, log12, observer, tools) {
   const messageId = "msg_" + Date.now();
+  const requiredProps = toolRequiredProps(tools);
   let blockIndex = -1;
   let started = false;
   let openType = null;
   let pendingThinkingSig;
   const idToBlock = /* @__PURE__ */ new Map();
+  const toolJsonBuffer = /* @__PURE__ */ new Map();
+  const flushedTools = /* @__PURE__ */ new Set();
+  let openToolId = null;
   let finishReason = "end_turn";
   let usage = {
     input_tokens: 0,
@@ -7253,8 +7269,20 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer) {
       });
       pendingThinkingSig = void 0;
     }
+    if (openType === "tool" && openToolId !== null && !flushedTools.has(openToolId)) {
+      const buffered = toolJsonBuffer.get(openToolId);
+      if (buffered) {
+        emit("content_block_delta", {
+          type: "content_block_delta",
+          index: blockIndex,
+          delta: { type: "input_json_delta", partial_json: buffered }
+        });
+      }
+      flushedTools.add(openToolId);
+    }
     if (openType) emit("content_block_stop", { type: "content_block_stop", index: blockIndex });
     openType = null;
+    openToolId = null;
   };
   const openBlock = (type, contentBlock) => {
     ensureStart();
@@ -7316,32 +7344,45 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer) {
           input: {}
         });
         idToBlock.set(part.id ?? "", blockIndex);
+        openToolId = part.id ?? "";
         break;
       }
-      case "tool-input-delta":
-        emit("content_block_delta", {
-          type: "content_block_delta",
-          index: idToBlock.get(part.id ?? "") ?? blockIndex,
-          delta: { type: "input_json_delta", partial_json: part.delta ?? part.text ?? "" }
-        });
+      case "tool-input-delta": {
+        const id = part.id ?? "";
+        toolJsonBuffer.set(id, (toolJsonBuffer.get(id) ?? "") + (part.delta ?? part.text ?? ""));
         break;
+      }
       case "tool-input-end":
         break;
       case "tool-call": {
         finishReason = "tool_use";
-        if (!idToBlock.has(part.toolCallId ?? "") && openType !== "tool") {
+        const id = part.toolCallId ?? "";
+        if (idToBlock.has(id)) {
+          if (!flushedTools.has(id)) {
+            const json = part.input !== void 0 && part.input !== null ? JSON.stringify(sanitizeToolInput(part.input, requiredProps.get(part.toolName ?? ""))) : toolJsonBuffer.get(id) ?? "";
+            if (json) {
+              emit("content_block_delta", {
+                type: "content_block_delta",
+                index: idToBlock.get(id) ?? blockIndex,
+                delta: { type: "input_json_delta", partial_json: json }
+              });
+            }
+            flushedTools.add(id);
+          }
+        } else if (openType !== "tool") {
           const sig = grabRoundTripSignature(part);
           openBlock("tool", {
             type: "tool_use",
-            id: encodeToolUseId(part.toolCallId ?? "", sig),
+            id: encodeToolUseId(id, sig),
             name: part.toolName,
             input: {}
           });
           emit("content_block_delta", {
             type: "content_block_delta",
             index: blockIndex,
-            delta: { type: "input_json_delta", partial_json: JSON.stringify(stripNullInputs(part.input ?? {})) }
+            delta: { type: "input_json_delta", partial_json: JSON.stringify(sanitizeToolInput(part.input ?? {}, requiredProps.get(part.toolName ?? ""))) }
           });
+          flushedTools.add(id);
         }
         break;
       }
@@ -7406,7 +7447,7 @@ async function streamAnthropicResponse(model, params, modelId, write, log12, obs
     }
   })();
   try {
-    await writeAnthropicStream(watchedStream, modelId, write, log12, { ...observer, abortSignal });
+    await writeAnthropicStream(watchedStream, modelId, write, log12, { ...observer, abortSignal }, params.tools);
   } finally {
     stopForwardingAbort();
     clearTimeout(idleTimer);
@@ -7497,6 +7538,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       if (!generateAbort.signal.aborted) generateAbort.abort();
     }
   }
+  const requiredProps = toolRequiredProps(params.tools);
   return {
     id: "msg_" + Date.now(),
     type: "message",
@@ -7508,7 +7550,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
         type: "tool_use",
         id: encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc)),
         name: tc.toolName,
-        input: stripNullInputs(tc.input)
+        input: sanitizeToolInput(tc.input ?? {}, requiredProps.get(tc.toolName))
       }))
     ],
     stop_reason: finishReason === "tool-calls" ? "tool_use" : "end_turn",
@@ -10516,14 +10558,12 @@ function planLaunchWizard(opts) {
 }
 
 // src/patcher.ts
-import { spawn } from "child_process";
 import { createHash as createHash5 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync6,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync7,
-  rmSync,
   statSync as statSync2,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync5,
@@ -10531,313 +10571,189 @@ import {
   closeSync as closeSync3,
   realpathSync
 } from "fs";
-import { homedir as homedir2, tmpdir } from "os";
+import { homedir as homedir2 } from "os";
 import { basename, join as join6 } from "path";
 import pc12 from "picocolors";
 import * as p11 from "@clack/prompts";
 
-// src/patch-script-template.ts
-var CLODEX_CONFIG_START = "// clodex:config:start";
-var CLODEX_CONFIG_END = "// clodex:config:end";
-var TEMPLATE = String.raw`/**
- * clodex patch — inject custom Claude Code model aliases (tweakcc adhoc-patch script).
- * Generated by clodex; do not edit. See clodex patch --help.
- */
-
-// clodex:config:start
-const MODEL_CONFIG = {};
-// clodex:config:end
-
-// ---- derive helpers --------------------------------------------------------
-// alias -> model id (only for entries that define an alias)
-const ALIAS_TO_ID = {};
-// The name Claude Code knows a model by: its alias when it has one, else its
-// canonical id. This single value is used for the Agent-tool enum, the
-// known-alias validator, the /model picker value, and the context-window table,
-// so the name the binary validates == the name it sends upstream == the name
-// the proxy echoes back == the key its context window is stored under.
-const IDENTITIES = [];
-// identity -> human label for the /model picker (falls back at use site)
-const DISPLAY_BY_IDENTITY = {};
-// lowercased alias AND id -> context-window tokens (only for models that set it)
-const CONTEXT_BY_KEY = {};
-for (const [id, value] of Object.entries(MODEL_CONFIG)) {
-  const spec = value && typeof value === "object" ? value : { alias: value };
-  if (spec.alias !== undefined) {
-    const a = String(spec.alias).trim().toLowerCase();
-    if (!/^[a-z0-9][a-z0-9._-]*(\[1m\])?$/.test(a)) {
-      throw new Error('clodex patch: alias "' + spec.alias + '" is not a safe lowercase alias');
-    }
-    ALIAS_TO_ID[a] = String(id);
-    IDENTITIES.push(a);
-    if (spec.display) DISPLAY_BY_IDENTITY[a] = String(spec.display);
-  } else {
-    IDENTITIES.push(String(id));
-    if (spec.display) DISPLAY_BY_IDENTITY[String(id)] = String(spec.display);
+// src/patch-transforms.ts
+var PatchApplyError = class extends Error {
+  results;
+  constructor(message, results) {
+    super(message);
+    this.name = "PatchApplyError";
+    this.results = results;
   }
-
-  if (spec.context !== undefined) {
-    const n = Number(spec.context);
-    if (!Number.isInteger(n) || n <= 0) {
-      throw new Error('clodex patch: context for "' + id + '" must be a positive integer, got ' + spec.context);
+};
+function formatPatchSiteLine(result) {
+  return "  " + result.status.padEnd(4) + " " + result.name + (result.extra ? " \u2014 " + result.extra : "");
+}
+function applyClodexPatches(source, config) {
+  let js = source;
+  const MODEL_CONFIG = config;
+  const ALIAS_TO_ID = {};
+  const IDENTITIES = [];
+  const DISPLAY_BY_IDENTITY = {};
+  const CONTEXT_BY_KEY = {};
+  const report = [];
+  const fail = (message) => {
+    throw new PatchApplyError(message, report);
+  };
+  for (const [id, value] of Object.entries(MODEL_CONFIG)) {
+    const spec = value && typeof value === "object" ? value : { alias: value };
+    if (spec.alias !== void 0) {
+      const a = String(spec.alias).trim().toLowerCase();
+      if (!/^[a-z0-9][a-z0-9._-]*(\[1m\])?$/.test(a)) {
+        fail('clodex patch: alias "' + spec.alias + '" is not a safe lowercase alias');
+      }
+      ALIAS_TO_ID[a] = String(id);
+      IDENTITIES.push(a);
+      if (spec.display) DISPLAY_BY_IDENTITY[a] = String(spec.display);
+    } else {
+      IDENTITIES.push(String(id));
+      if (spec.display) DISPLAY_BY_IDENTITY[String(id)] = String(spec.display);
     }
-    // A [1m] suffix hard-codes 1M upstream (and sends the context-1m beta header
-    // + raises the media cap). An explicit context on a [1m] model would win via
-    // PATCH 7 while those side effects silently stayed on — so reject it.
-    if (/\[1m\]/i.test(String(spec.alias ?? "")) || /\[1m\]/i.test(id)) {
-      throw new Error(
-        'clodex patch: "' + id + '" sets context but keeps the [1m] suffix — drop the suffix from both the id and the alias'
-      );
+    if (spec.context !== void 0) {
+      const n = Number(spec.context);
+      if (!Number.isInteger(n) || n <= 0) {
+        fail('clodex patch: context for "' + id + '" must be a positive integer, got ' + spec.context);
+      }
+      if (/\[1m\]/i.test(String(spec.alias ?? "")) || /\[1m\]/i.test(id)) {
+        fail(
+          'clodex patch: "' + id + '" sets context but keeps the [1m] suffix \u2014 drop the suffix from both the id and the alias'
+        );
+      }
+      if (spec.alias !== void 0) CONTEXT_BY_KEY[String(spec.alias).trim().toLowerCase()] = n;
+      CONTEXT_BY_KEY[String(id).trim().toLowerCase()] = n;
     }
-    if (spec.alias !== undefined) CONTEXT_BY_KEY[String(spec.alias).trim().toLowerCase()] = n;
-    CONTEXT_BY_KEY[String(id).trim().toLowerCase()] = n;
-  }
-}
-const ALIASES = Object.keys(ALIAS_TO_ID);
-const MODELS = Object.keys(MODEL_CONFIG);
-if (MODELS.length === 0) throw new Error("clodex patch: MODEL_CONFIG is empty");
-
-/** Picker/description label for an identity; falls back to the old wording. */
-function displayFor(identity, fallbackId) {
-  return DISPLAY_BY_IDENTITY[identity] || "Custom model (" + fallbackId + ")";
-}
-
-const reEsc = (s) => s.replace(/[.*+?^$\{\}()|[\]\\]/g, "\\$&");
-const q = (s) => JSON.stringify(s); // safe JS string literal
-
-// ---- reporting -------------------------------------------------------------
-const report = [];
-function log(status, name, extra) {
-  report.push({ status, name });
-  const line = "  " + status.padEnd(4) + " " + name + (extra ? " — " + extra : "");
-  // NOTE: tweakcc reads this script's STDOUT as the JSON result, so every
-  // diagnostic MUST go to stderr — a stray stdout write corrupts the output.
-  console.error(line);
-}
-
-/**
- * Apply exactly one regex replacement.
- *  - marker: if present in js, treat as already-patched -> SKIP.
- *  - expects exactly one match; 0 -> FAIL, >1 -> FAIL (ambiguous).
- *  - fn(match, ...groups) returns the replacement text.
- *  - required: on FAIL, throw (aborts the whole adhoc-patch).
- */
-function applyOnce(name, regex, fn, { marker, required, noopIsSkip } = {}) {
-  if (marker && js.includes(marker)) { log("SKIP", name, "already patched"); return; }
-  const g = new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : regex.flags + "g");
-  const matches = js.match(g);
-  const count = matches ? matches.length : 0;
-  if (count === 0) {
-    log("FAIL", name, "anchor not found");
-    if (required) throw new Error("clodex patch: required patch failed: " + name);
-    return;
   }
-  if (count > 1) {
-    log("FAIL", name, "anchor matched " + count + " times (expected 1)");
-    if (required) throw new Error("clodex patch: ambiguous anchor: " + name);
-    return;
+  const ALIASES = Object.keys(ALIAS_TO_ID);
+  const MODELS = Object.keys(MODEL_CONFIG);
+  if (MODELS.length === 0) fail("clodex patch: MODEL_CONFIG is empty");
+  function displayFor(identity, fallbackId) {
+    return DISPLAY_BY_IDENTITY[identity] || "Custom model (" + fallbackId + ")";
   }
-  const before = js;
-  js = js.replace(regex, fn);
-  if (js === before) {
-    // For array-extend / append patches, "no change" means the aliases are
-    // already present (anchor matched, but fn had nothing new to add) -> SKIP.
-    if (noopIsSkip) { log("SKIP", name, "already patched"); return; }
-    log("FAIL", name, "replacement made no change");
-    if (required) throw new Error(name);
-    return;
+  const reEsc = (s) => s.replace(/[.*+?^$\{\}()|[\]\\]/g, "\\$&");
+  const q = (s) => JSON.stringify(s);
+  function log12(status, name, extra) {
+    report.push(extra === void 0 ? { status, name } : { status, name, extra });
   }
-  log("OK", name);
-}
-
-/** Insert missing identities just before the closing bracket of a JS array literal string. */
-function extendAliasArray(arrLiteral) {
-  const toAdd = IDENTITIES.filter((a) => !new RegExp('"' + reEsc(a) + '"').test(arrLiteral));
-  if (toAdd.length === 0) return arrLiteral; // idempotent
-  return arrLiteral.replace(/\]\s*$/, "," + toAdd.map(q).join(",") + "]");
-}
-
-console.error("clodex patch: injecting model names [" + IDENTITIES.join(", ") + "]");
-
-// ---------------------------------------------------------------------------
-// PATCH 1 — Agent/subagent tool 'model' zod enum.
-// Anchor: .enum([ "sonnet",...,"fable" ]).optional().describe( — the array
-// begins with the built-in aliases and is immediately followed by
-// .optional().describe(. We append our identities (alias when defined, else
-// the canonical id) inside the enum so the tool accepts them — this is the same
-// enum subagent/skill 'model:' frontmatter is validated against, which is why
-// the short alias has to be the value that lands here.
-// (This same .describe( is patched by PATCH 4 below.)
-// ---------------------------------------------------------------------------
-applyOnce(
-  "PATCH 1: Agent tool model enum",
-  /\.enum\((\["sonnet","opus","haiku"(?:,"[^"]+")*\])\)\.optional\(\)\.describe\(/,
-  (_m, arr) => ".enum(" + extendAliasArray(arr) + ").optional().describe(",
-  { required: true, noopIsSkip: true }
-);
-
-// ---------------------------------------------------------------------------
-// PATCH 3 — known-alias validator list (drives "is this a known alias?").
-// Anchor: the master list literal, matched loosely as
-// ["sonnet","opus","haiku","fable", ...anything... ,"opusplan"] so it
-// tolerates new built-ins being added in the middle. Appending our identities
-// makes them recognized as first-class aliases everywhere the gate runs.
-// ---------------------------------------------------------------------------
-applyOnce(
-  "PATCH 3: known-alias validator list",
-  /\["sonnet","opus","haiku","fable"(?:,"[^"]+")*,"opusplan"(?:,"[^"]+")*\]/,
-  (m) => extendAliasArray(m),
-  { required: true, noopIsSkip: true }
-);
-
-// ---------------------------------------------------------------------------
-// PATCH 6 — alias resolver switch (IDENTITY mapping).
-// Anchor: case"best":{ ... } (the case"best":{ is unique). We inject
-// case"<alias>":return"<alias>"; right after it (before the switch's
-// default:return null).
-//
-// The mapping is deliberately an identity, NOT alias -> canonical id: the alias
-// IS the model's identity everywhere else in the patched binary (enum,
-// validator, picker, context table), and the MITM proxy resolves short alias
-// names as request model ids and echoes request bodies unrewritten. Resolving
-// to the canonical id here would make Claude Code send one name and look its
-// context window up under another — the exact mismatch that stopped auto-compact
-// from firing and killed agents with "Prompt is too long". The case still has to
-// EXIST (rather than be skipped) so the resolver returns the name instead of
-// falling through to default:return null.
-// Only aliases not already present are inserted, so a rerun (or a config
-// edit) tops up cleanly rather than duplicating cases.
-// ---------------------------------------------------------------------------
-{
-  const missing = ALIASES.filter((a) => !new RegExp("case" + reEsc(q(a)) + ":return").test(js));
-  const cases = missing.map((a) => "case" + q(a) + ":return " + q(a) + ";").join("");
-  if (ALIASES.length === 0) {
-    log("SKIP", "PATCH 6: alias resolver switch", "no aliases configured");
-  } else {
-    applyOnce(
-      "PATCH 6: alias resolver switch",
-      /(case"best":\{[^{}]*\})/,
-      (m) => m + cases,
-      { required: true, noopIsSkip: true }
-    );
+  function applyOnce(name, regex, fn, { marker, required, noopIsSkip } = {}) {
+    if (marker && js.includes(marker)) {
+      log12("SKIP", name, "already patched");
+      return;
+    }
+    const g = new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : regex.flags + "g");
+    const matches = js.match(g);
+    const count = matches ? matches.length : 0;
+    if (count === 0) {
+      log12("FAIL", name, "anchor not found");
+      if (required) fail("clodex patch: required patch failed: " + name);
+      return;
+    }
+    if (count > 1) {
+      log12("FAIL", name, "anchor matched " + count + " times (expected 1)");
+      if (required) fail("clodex patch: ambiguous anchor: " + name);
+      return;
+    }
+    const before = js;
+    js = js.replace(regex, fn);
+    if (js === before) {
+      if (noopIsSkip) {
+        log12("SKIP", name, "already patched");
+        return;
+      }
+      log12("FAIL", name, "replacement made no change");
+      if (required) fail(name);
+      return;
+    }
+    log12("OK", name);
   }
-}
-
-// ---------------------------------------------------------------------------
-// PATCH 5 — interactive /model picker.
-// The picker is assembled through a single choke-point function; we insert,
-// right after its loop, a snippet that appends our custom
-// {value,label,description} entries — with a runtime .some() dedupe guard so
-// it is safe even if the function runs over the same array twice. Only
-// aliases not already injected are added, so reruns top up cleanly.
-// ---------------------------------------------------------------------------
-{
-  const missing = ALIASES.filter((a) => !new RegExp("value:" + reEsc(q(a))).test(js));
-  const entries = missing
-    .map(
-      // ASCII only: tweakcc's script->JSON->repack path double-encodes any
-      // non-ASCII byte.
+  function extendAliasArray(arrLiteral) {
+    const toAdd = IDENTITIES.filter((a) => !new RegExp('"' + reEsc(a) + '"').test(arrLiteral));
+    if (toAdd.length === 0) return arrLiteral;
+    return arrLiteral.replace(/\]\s*$/, "," + toAdd.map(q).join(",") + "]");
+  }
+  applyOnce(
+    "PATCH 1: Agent tool model enum",
+    /\.enum\((\["sonnet","opus","haiku"(?:,"[^"]+")*\])\)\.optional\(\)\.describe\(/,
+    (_m, arr) => ".enum(" + extendAliasArray(arr) + ").optional().describe(",
+    { required: true, noopIsSkip: true }
+  );
+  applyOnce(
+    "PATCH 3: known-alias validator list",
+    /\["sonnet","opus","haiku","fable"(?:,"[^"]+")*,"opusplan"(?:,"[^"]+")*\]/,
+    (m) => extendAliasArray(m),
+    { required: true, noopIsSkip: true }
+  );
+  {
+    const missing = ALIASES.filter((a) => !new RegExp("case" + reEsc(q(a)) + ":return").test(js));
+    const cases = missing.map((a) => "case" + q(a) + ":return " + q(a) + ";").join("");
+    if (ALIASES.length === 0) {
+      log12("SKIP", "PATCH 6: alias resolver switch", "no aliases configured");
+    } else {
+      applyOnce(
+        "PATCH 6: alias resolver switch",
+        /(case"best":\{[^{}]*\})/,
+        (m) => m + cases,
+        { required: true, noopIsSkip: true }
+      );
+    }
+  }
+  {
+    const missing = ALIASES.filter((a) => !new RegExp("value:" + reEsc(q(a))).test(js));
+    const entries = missing.map(
       // value = the alias (the name the user types and the binary sends);
       // description = the real model label, e.g. "GPT-5.6 Sol (OpenAI (ChatGPT))".
+      // (tweakcc's writeContent round-trips utf8 faithfully — verified — so the
+      // old adhoc-patch ASCII-only constraint no longer applies.)
       (a) => "{value:" + q(a) + ",label:" + q(a.charAt(0).toUpperCase() + a.slice(1)) + ",description:" + q(displayFor(a, ALIAS_TO_ID[a])) + "}"
-    )
-    .join(",");
-  const inject = missing.length
-    ? "[" + entries + "].forEach(function(_o){if(!e.some(function(_i){return _i.value===_o.value}))e.push(_o)});"
-    : "";
-  if (ALIASES.length === 0) {
-    log("SKIP", "PATCH 5: model picker options", "no aliases configured");
-  } else {
-    applyOnce(
-      "PATCH 5: model picker options",
-      /(\?\[[\w$]+,r\]:\[r\];for\(let [\w$]+ of [\w$]+\)[\w$]+\(e,[\w$]+,t\);)/,
-      (m) => m + inject,
-      { required: false, noopIsSkip: true }
-    );
+    ).join(",");
+    const inject = missing.length ? "[" + entries + "].forEach(function(_o){if(!e.some(function(_i){return _i.value===_o.value}))e.push(_o)});" : "";
+    if (ALIASES.length === 0) {
+      log12("SKIP", "PATCH 5: model picker options", "no aliases configured");
+    } else {
+      applyOnce(
+        "PATCH 5: model picker options",
+        /(\?\[[\w$]+,r\]:\[r\];for\(let [\w$]+ of [\w$]+\)[\w$]+\(e,[\w$]+,t\);)/,
+        (m) => m + inject,
+        { required: false, noopIsSkip: true }
+      );
+    }
   }
-}
-
-// ---------------------------------------------------------------------------
-// PATCH 4 — Agent tool 'model' parameter description text.
-// Append the available model names (with their real labels) before the closing
-// backtick so the model knows which extra names it may request and what they
-// actually are. Best-effort (cosmetic). The text is spliced into a backtick
-// template literal, so backticks and interpolation openers are stripped.
-// ---------------------------------------------------------------------------
-{
-  const safe = (s) => String(s).replace(/\`/g, "'").replace(/\$\{/g, "(");
-  const listing = IDENTITIES.map(function (i) {
-    const d = DISPLAY_BY_IDENTITY[i];
-    return d ? safe(i) + " = " + safe(d) : safe(i);
-  }).join("; ");
-  applyOnce(
-    "PATCH 4: Agent tool model description",
-    /(describe\(\`Optional model override for this agent[^\`]*?)(\`\))/,
-    (_m, body, close) =>
-      body.includes("Additional custom models")
-        ? body + close
-        : body + " Additional custom models: " + listing + "." + close,
-    { required: false, noopIsSkip: true }
-  );
-}
-
-// ---------------------------------------------------------------------------
-// PATCH 7 — per-model context window.
-//
-// Claude Code funnels EVERY context-window consumer (autocompact threshold,
-// /context, the countdown, statusline, cost/usage records, subagent budgets)
-// through one resolver function. We inject a baked table lookup at the TOP of
-// that resolver, so it wins over the 200k clamp and the global
-// CLAUDE_CODE_MAX_CONTEXT_TOKENS env override. Lookup is on the raw,
-// lowercased model string — alias and id are both in the table, so it hits
-// pre- or post-alias-resolution.
-//
-// Anchor: the resolver's exact body shape. Identifiers are wildcarded (they
-// churn per build); the (e,t) arity + 3-statement shape matches once.
-// ---------------------------------------------------------------------------
-if (Object.keys(CONTEXT_BY_KEY).length) {
-  const MARKER = "/*ccpatch:ctx*/";
-  const SNIPPET =
-    MARKER + 'var _ccw=(' + JSON.stringify(CONTEXT_BY_KEY) + ')[String(e||"").trim().toLowerCase()];if(_ccw!==void 0)return _ccw;';
-
-  if (js.includes(MARKER)) {
-    // Re-patching an already-patched binary: refresh the baked table in place
-    // so a MODEL_CONFIG edit takes effect without a restore first.
-    applyOnce(
-      "PATCH 7: per-model context window (refresh)",
-      /\/\*ccpatch:ctx\*\/var _ccw=\(\{[^{}]*\}\)\[[^\]]*\];if\(_ccw!==void 0\)return _ccw;/,
-      () => SNIPPET,
-      { required: true, noopIsSkip: true }
-    );
-  } else {
+  {
+    const safe = (s) => String(s).replace(/`/g, "'").replace(/\$\{/g, "(");
+    const listing = IDENTITIES.map(function(i) {
+      const d = DISPLAY_BY_IDENTITY[i];
+      return d ? safe(i) + " = " + safe(d) : safe(i);
+    }).join("; ");
     applyOnce(
-      "PATCH 7: per-model context window",
-      /(function [\w$]+\(e,t\)\{)(let [\w$]+=[\w$]+\(\);if\([\w$]+!==void 0\)return [\w$]+;if\([\w$]+\(e,t\)\)return [\w$]+;return [\w$]+\(e,t\)\})/,
-      (_m, head, body) => head + SNIPPET + body,
-      { required: true }
+      "PATCH 4: Agent tool model description",
+      /(describe\(`Optional model override for this agent[^`]*?)(`\))/,
+      (_m, body, close) => body.includes("Additional custom models") ? body + close : body + " Additional custom models: " + listing + "." + close,
+      { required: false, noopIsSkip: true }
     );
   }
-}
-
-// ---------------------------------------------------------------------------
-const failed = report.filter((r) => r.status === "FAIL");
-const ok = report.filter((r) => r.status === "OK").length;
-const skip = report.filter((r) => r.status === "SKIP").length;
-console.error("clodex patch: " + ok + " applied, " + skip + " skipped, " + failed.length + " failed");
-if (failed.length) console.error("clodex patch: FAILED patches: " + failed.map((f) => f.name).join("; "));
-
-return js;
-`;
-function renderPatchScript(config) {
-  const start = TEMPLATE.indexOf(CLODEX_CONFIG_START);
-  const end = TEMPLATE.indexOf(CLODEX_CONFIG_END);
-  if (start < 0 || end < 0 || end < start) {
-    throw new Error("clodex patch: config markers missing from patch script template");
+  if (Object.keys(CONTEXT_BY_KEY).length) {
+    const MARKER = "/*ccpatch:ctx*/";
+    const SNIPPET = MARKER + "var _ccw=(" + JSON.stringify(CONTEXT_BY_KEY) + ')[String(e||"").trim().toLowerCase()];if(_ccw!==void 0)return _ccw;';
+    if (js.includes(MARKER)) {
+      applyOnce(
+        "PATCH 7: per-model context window (refresh)",
+        /\/\*ccpatch:ctx\*\/var _ccw=\(\{[^{}]*\}\)\[[^\]]*\];if\(_ccw!==void 0\)return _ccw;/,
+        () => SNIPPET,
+        { required: true, noopIsSkip: true }
+      );
+    } else {
+      applyOnce(
+        "PATCH 7: per-model context window",
+        /(function [\w$]+\(e,t\)\{)(let [\w$]+=[\w$]+\(\);if\([\w$]+!==void 0\)return [\w$]+;if\([\w$]+\(e,t\)\)return [\w$]+;return [\w$]+\(e,t\)\})/,
+        (_m, head, body) => head + SNIPPET + body,
+        { required: true }
+      );
+    }
   }
-  const block = `${CLODEX_CONFIG_START}
-const MODEL_CONFIG = ${JSON.stringify(config, null, 2)};
-${CLODEX_CONFIG_END}`;
-  return TEMPLATE.slice(0, start) + block + TEMPLATE.slice(end + CLODEX_CONFIG_END.length);
+  return { content: js, results: report };
 }
 
 // src/patcher.ts
@@ -10988,29 +10904,16 @@ function pristineBackupPath(version, binaryPath) {
   const tag = version.replace(/[^\w.-]+/g, "_") || basename(binaryPath);
   return join6(backupDir(), `claude-${tag}.orig`);
 }
-function runTweakcc(binaryPath, scriptPath) {
-  return new Promise((resolve2, reject) => {
-    const child = spawn(
-      "npx",
-      ["-y", "tweakcc", "adhoc-patch", "--path", binaryPath, "--script", `@${scriptPath}`, "--confirm-possible-dangerous-patch"],
-      {
-        stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, TWEAKCC_CC_INSTALLATION_PATH: binaryPath }
-      }
-    );
-    let output = "";
-    child.stdout.on("data", (chunk) => {
-      output += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      output += String(chunk);
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve2({ code: code ?? 1, output }));
-  });
-}
-function summarizePatchOutput(output) {
-  return output.split(/\r?\n/).filter((line) => /^\s*(OK|SKIP|FAIL)\s{2,}/.test(line) || /^clodex patch:/.test(line.trim())).map((line) => line.trimEnd());
+function summarizePatchResults(results) {
+  const lines = results.map(formatPatchSiteLine);
+  const ok = results.filter((r) => r.status === "OK").length;
+  const skip = results.filter((r) => r.status === "SKIP").length;
+  const failed = results.filter((r) => r.status === "FAIL");
+  lines.push(`clodex patch: ${ok} applied, ${skip} skipped, ${failed.length} failed`);
+  if (failed.length) {
+    lines.push(`clodex patch: FAILED patches: ${failed.map((f) => f.name).join("; ")}`);
+  }
+  return lines;
 }
 async function applyPatch(binaryPath, version, desired, configHash, opts) {
   const backup = pristineBackupPath(version, binaryPath);
@@ -11024,41 +10927,48 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     copyFileSync2(binaryPath, backup);
   }
   copyFileSync2(backup, join6(backupDir(), "native-binary.backup"));
-  const scriptPath = join6(tmpdir(), `clodex-patch-${process.pid}-${Date.now()}.js`);
-  writeFileSync5(scriptPath, renderPatchScript(desired.config), { encoding: "utf8", mode: 384 });
+  const { tryDetectInstallation, readContent, writeContent } = await import("tweakcc");
+  let results;
   try {
-    const result = await runTweakcc(binaryPath, scriptPath);
-    if (opts.trace) {
-      process.stderr.write(result.output);
-    }
-    if (result.code !== 0) {
-      return {
-        ok: false,
-        message: `tweakcc adhoc-patch failed (exit ${result.code}). Re-run with --trace for full output.`,
-        detailLines: summarizePatchOutput(result.output)
-      };
+    const installation = await tryDetectInstallation({ path: binaryPath });
+    const source = await readContent(installation);
+    const patched = applyClodexPatches(source, desired.config);
+    results = patched.results;
+    await writeContent(installation, patched.content);
+  } catch (err) {
+    const detailLines = err instanceof PatchApplyError ? summarizePatchResults(err.results) : [];
+    if (opts.trace && detailLines.length) {
+      process.stderr.write(`${detailLines.join("\n")}
+`);
     }
-    const manifest = {
-      binaryPath,
-      claudeVersion: version,
-      configHash,
-      patchedSize: statSync2(binaryPath).size,
-      patchedSha256: sha256File(binaryPath),
-      backupPath: backup,
-      patchedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writePatchManifest(manifest);
-    const modelCount = Object.keys(desired.config).length;
-    const aliasCount = Object.values(desired.config).filter((entry) => entry.alias).length;
-    const windowCount = Object.values(desired.config).filter((entry) => entry.context).length;
     return {
-      ok: true,
-      message: `Patched claude ${version}: ${modelCount} model${modelCount === 1 ? "" : "s"}, ${aliasCount} alias${aliasCount === 1 ? "" : "es"}, ${windowCount} context window${windowCount === 1 ? "" : "s"}.`,
-      detailLines: summarizePatchOutput(result.output)
+      ok: false,
+      message: `Patch failed: ${err instanceof Error ? err.message : String(err)}`,
+      detailLines
     };
-  } finally {
-    rmSync(scriptPath, { force: true });
   }
+  if (opts.trace) {
+    process.stderr.write(`${summarizePatchResults(results).join("\n")}
+`);
+  }
+  const manifest = {
+    binaryPath,
+    claudeVersion: version,
+    configHash,
+    patchedSize: statSync2(binaryPath).size,
+    patchedSha256: sha256File(binaryPath),
+    backupPath: backup,
+    patchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writePatchManifest(manifest);
+  const modelCount = Object.keys(desired.config).length;
+  const aliasCount = Object.values(desired.config).filter((entry) => entry.alias).length;
+  const windowCount = Object.values(desired.config).filter((entry) => entry.context).length;
+  return {
+    ok: true,
+    message: `Patched claude ${version}: ${modelCount} model${modelCount === 1 ? "" : "s"}, ${aliasCount} alias${aliasCount === 1 ? "" : "es"}, ${windowCount} context window${windowCount === 1 ? "" : "s"}.`,
+    detailLines: summarizePatchResults(results)
+  };
 }
 async function runPatchCommand(opts = {}) {
   const resolved = resolveClaudeBinaryForPatch();
@@ -11609,7 +11519,7 @@ ${pc13.bold("Usage:")}
 
 ${pc13.bold("Options:")}
   --restore    Restore the pristine (unpatched) Claude Code binary
-  --trace      Show the underlying tweakcc output
+  --trace      Show per-patch-site results (OK/SKIP/FAIL)
 
 ${pc13.bold("Behavior:")}
   The patch map is built automatically from your clodex favorites and aliases