codex-copilot-dx 0.6.12 → 0.6.14

package/README.md

@@ -7,7 +7,7 @@ Use [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/
 A single in-process adapter (port `2026`) exposes both APIs over one Copilot
 account by default, or over isolated Codex and Claude accounts when configured:
 
-- **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, chat models convert to Chat Completions.
+- **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, while chat models convert the text, image, and function-tool subset and explicitly reject incompatible top-level items, tools, and tool choices.
 - **Claude Code** -> Anthropic Messages API (`/v1/messages`, `/v1/messages/count_tokens`), translated to/from Chat Completions.
 - **Claude App** -> optional Claude Desktop App gateway profile using the same local Messages API plus local model discovery for the configured gateway key.
 - **PM Studio** -> optional macOS app patch that keeps the active PM profile for GPT models while routing enabled Claude models through an isolated CCDX Claude account.
@@ -118,15 +118,15 @@ discovery tries the compatible local CCDX merge first, and only exact enabled
 Anthropic model IDs use the isolated CCDX Claude profile. Neither credential is
 copied into the other application.
 
-CCDX keeps exact built-in recipes for PM Studio 2.9.7 and 2.9.10, and can also
-derive a source-bound recipe for a newer macOS build when its signed App layout,
-ASAR integrity metadata, and one exact Copilot configuration module remain
-structurally compatible. This is best-effort semantic compatibility, not a
-promise that every future PM Studio architecture can be patched. A missing or
-ambiguous module, changed request transport, unsupported integrity policy, or
-unverifiable source is rejected without modifying the App. Authorize the
-isolated Claude profile first, quit PM Studio and its updater, then run the
-one-time setup command:
+CCDX treats the local PM Studio App selected for setup as the source of truth.
+Its version and build label backup and recovery records; neither they nor the
+installation source or original signature are compatibility admission gates.
+Setup derives a source-bound recipe whenever the local ASAR integrity metadata
+and exactly one compatible Copilot configuration module can be verified. A
+missing or ambiguous module, changed request transport, or unsupported
+integrity policy is rejected without modifying the App. Authorize the isolated
+Claude profile first, quit PM Studio and its updater, then run the one-time
+setup command:
 
 ```bash
 ccdx auth login claude --reauth --github-login <personal-github-login>
@@ -142,29 +142,20 @@ ccdx pms status
 
 `ccdx pm-studio status` and `ccdx pm-studio setup` are equivalent long-form aliases.
 
-`ccdx pms setup` performs preflight, source verification, backup, staging,
-integrity, signing, and replacement work. It never starts Device Flow, the
-adapter, Codex, or PM Studio, and it does not modify PM profiles, cached model
-lists, or saved PM tokens. A structurally compatible unknown version with an
-intact vendor signature is verified locally. If the upstream release has the
-known invalid-signature shape, setup downloads only the exact stable asset from
-the fixed official GitHub repository, enforces its API-provided SHA-256 and
-size, extracts it privately, and requires the installed App to match that tree
-(apart from strictly scoped locale pruning) before any backup or staging write.
-Network, hash, tree, structure, partial-patch, running-process, space, and every
-other pre-replacement failure leave the installed App unchanged. If final
+`ccdx pms setup` performs local preflight, structural verification, backup,
+staging, integrity, signing, and replacement work. It does not access a PM
+Studio repository, release asset, PAT, or source-signing service. It never
+starts Device Flow, the adapter, Codex, or PM Studio, and it does not modify PM
+profiles, cached model lists, or saved PM tokens. Local fingerprints bind the
+recipe, backup, staged App, and installed App without deciding whether the
+original package is trusted. Structure, partial-patch, running-process, space,
+and every other pre-replacement failure leave the installed App unchanged. If final
 read-only verification after an atomic replacement detects exceptional
 filesystem drift, setup does not attempt a second automatic write: it preserves
 the verified backup, retains any diagnostic stage still present, and prints
 recovery paths. Repeating setup reuses the version/source-bound verified backup
-and is idempotent; status and repeated setup do not redownload the release.
-
-Some official PM Studio artifacts can fail macOS's vendor-signature verifier
-even though their signing metadata remains readable. CCDX does not generally
-ignore that failure: exact built-in recipes require their frozen official
-fingerprint, while compatible unknown versions require the verified official
-GitHub asset and tree comparison described above. The staged and installed
-CCDX patch must still pass strict ad-hoc signature verification and match the
+and is idempotent. The staged and installed CCDX patch must still pass strict
+ad-hoc signature verification, use the App's bundle identifier, and match the
 complete patched-tree record in the backup manifest.
 
 The patch uses split origins, not an App-wide proxy. GPT and other non-Claude
@@ -183,9 +174,9 @@ CCDX uses the PM bearer only to fetch or validate official model access; it is
 never used as the credential for the isolated Claude upstream request. Keep
 port 2026 local to the machine.
 
-Patching replaces the vendor signature with an ad-hoc signature. PM Studio's
+Patching applies an ad-hoc signature to the staged App. PM Studio's
 updater is not disabled; an official update may overwrite the patch or may
-require reinstalling the official App. Setup prints the verified backup and
+require reinstalling PM Studio. Setup prints the verified backup and
 manifest paths plus the version-matched restore procedure. Never restore a
 backup over a different PM Studio version or build.
 
@@ -202,7 +193,7 @@ BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
 ```
 
 Only when all four values match each other and the version/build recorded in the
-source-bound manifest, move the patched App aside, restore the complete vendor
+source-bound manifest, move the patched App aside, restore the complete local
 bundle, and verify it before launch:
 
 ```bash
@@ -214,12 +205,11 @@ mv "/Applications/PM Studio.app" "$PATCHED_APP"
 ccdx pms status
 ```
 
-For an official artifact with the documented upstream signature failure, the
-App-patch row from `ccdx pms status` must still classify the restored bundle as
-verified clean content rather than integrity drift. If the version check, copy,
-or both verification paths fail,
+The App-patch row from `ccdx pms status` must classify the restored bundle as
+the recorded clean local content rather than integrity drift. If the version
+check, copy, or either verification path fails,
 do not launch the restored App. Keep the moved patched bundle at `$PATCHED_APP`
-and reinstall the official PM Studio instead of applying a version-mismatched
+and reinstall PM Studio instead of applying a version-mismatched
 backup. CCDX never runs these restore commands or `sudo` automatically.
 
 To change the model used by Codex Auto-review, run:
@@ -311,7 +301,7 @@ To actively verify the protocol path through an already-running adapter, run:
 ccdx doctor --compat
 ```
 
-The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
+The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
 
 For a read-only summary of the running adapter, use:
 
@@ -448,9 +438,9 @@ Before image encoding, CCDX leaves ordinary visual history byte-for-byte unchang
 
 When expanded Responses history exceeds Copilot's 50-image request limit, the adapter removes older duplicate image occurrences first, then keeps the 50 most recent images. This applies only to the forwarded request: local history remains complete, current images are preferred over older history, and requests at or below the limit are unchanged.
 
-For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and rebuilds a replayable snapshot from recent system, developer, user, and assistant messages plus every compaction item. Only a validated snapshot becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
+For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and preserves the complete upstream compacted window as the canonical next context. Only a validated window becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
 
-Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
+Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event; bytes after that terminal are not forwarded. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
 
 Newer ChatGPT/Codex clients can advertise an `image_gen` namespace that already exists upstream. The adapter removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image inputs and screenshot optimization remain enabled.
 
@@ -466,4 +456,4 @@ npm run verify
 npm run bench:payload
 ```
 
-`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.
+`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance, linear SSE scanning, and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/scripts/benchmark.mjs

@@ -31,6 +31,65 @@ function median(values) {
     : ordered[middle];
 }
 
+function sseLinearityProbe() {
+  return runProbe(`
+    import { webStreamLines } from "./src/stream.mjs";
+
+    const chunkBytes = 16 * 1024;
+    const maxBufferBytes = 8 * 1024 * 1024;
+    const chunk = new TextEncoder().encode("x".repeat(chunkBytes));
+    const results = [];
+    for (const inputMiB of [1, 2, 4, 8]) {
+      const inputBytes = inputMiB * 1024 * 1024;
+      let remaining = inputBytes;
+      const response = {
+        body: new ReadableStream({
+          pull(controller) {
+            if (remaining === 0) {
+              controller.close();
+              return;
+            }
+            const nextBytes = Math.min(chunk.byteLength, remaining);
+            controller.enqueue(nextBytes === chunk.byteLength ? chunk : chunk.subarray(0, nextBytes));
+            remaining -= nextBytes;
+          },
+        }, { highWaterMark: 0 }),
+      };
+      const originalByteLength = Buffer.byteLength;
+      let byteLengthCalls = 0;
+      let scannedBytes = 0;
+      Buffer.byteLength = function trackedByteLength(value, ...args) {
+        const bytes = originalByteLength(value, ...args);
+        byteLengthCalls += 1;
+        scannedBytes += bytes;
+        return bytes;
+      };
+      let lines = 0;
+      let outputBytes = 0;
+      const started = performance.now();
+      try {
+        for await (const line of webStreamLines(response, { maxBufferBytes })) {
+          lines += 1;
+          outputBytes += originalByteLength(line);
+        }
+      } finally {
+        Buffer.byteLength = originalByteLength;
+      }
+      results.push({
+        input_mib: inputMiB,
+        chunks: Math.ceil(inputBytes / chunkBytes),
+        lines,
+        output_bytes: outputBytes,
+        byte_length_calls: byteLengthCalls,
+        scanned_bytes: scannedBytes,
+        scan_ratio: +(scannedBytes / inputBytes).toFixed(3),
+        elapsed_ms: +(performance.now() - started).toFixed(1),
+      });
+    }
+    process.stdout.write(JSON.stringify({ chunk_kib: chunkBytes / 1024, max_buffer_mib: 8, results }));
+  `);
+}
+
 function deterministicPixels(byteLength, initialSeed) {
   const pixels = Buffer.alloc(byteLength);
   let seed = initialSeed;
@@ -422,6 +481,7 @@ const report = {
 };
 
 if (checkMode) {
+  report.sse_linearity = sseLinearityProbe();
   report.large_token_count = {
     proxy: largeTokenCountProbe("proxy"),
     materialized_array: largeTokenCountProbe("array"),
@@ -466,6 +526,20 @@ if (checkMode) {
   if (report.tool_output_parse_cache.parse_calls !== 1) {
     failures.push(`stringified tool output parsed ${report.tool_output_parse_cache.parse_calls} times instead of once`);
   }
+  const expectedSseSizes = [1, 2, 4, 8];
+  if (report.sse_linearity.results.length !== expectedSseSizes.length
+    || report.sse_linearity.results.some((sample, index) => sample.input_mib !== expectedSseSizes[index])) {
+    failures.push("SSE linearity probe did not cover 1/2/4/8 MiB inputs");
+  }
+  for (const sample of report.sse_linearity.results) {
+    const inputBytes = sample.input_mib * 1024 * 1024;
+    if (sample.lines !== 1 || sample.output_bytes !== inputBytes) {
+      failures.push(`SSE parser changed the ${sample.input_mib}MiB fragmented line`);
+    }
+    if (sample.scanned_bytes > inputBytes * 1.01 || sample.byte_length_calls > sample.chunks + 1) {
+      failures.push(`SSE parser scan complexity is not linear at ${sample.input_mib}MiB`);
+    }
+  }
   for (const payload of report.large_payload_peak) {
     if (payload.admission_max_active_mib > payload.admission_budget_mib) {
       failures.push(`request admission exceeded its budget at ${payload.target_request_mib}MiB x${payload.concurrency}`);

package/src/anthropic.mjs

@@ -130,6 +130,14 @@ export function anthropicToChat(body, options = {}) {
 
 function uid() { return randomUUID().replace(/-/g, ""); }
 
+function invalidToolArguments(toolName) {
+  const name = String(toolName || "unknown").slice(0, 100);
+  return invalidUpstreamStream(
+    `Upstream Chat Completions tool "${name}" did not return valid JSON object arguments`,
+    "upstream_tool_arguments_json_invalid",
+  );
+}
+
 export function chatToAnthropic(openaiResp, model, options = {}) {
   const choice = openaiResp.choices?.[0];
   const msg = choice?.message || {};
@@ -138,8 +146,20 @@ export function chatToAnthropic(openaiResp, model, options = {}) {
   if (msg.content) content.push({ type: "text", text: msg.content });
   if (Array.isArray(msg.tool_calls)) {
     for (const tc of msg.tool_calls) {
-      let input = {};
-      try { input = JSON.parse(tc.function.arguments || "{}"); } catch { input = {}; }
+      const rawArguments = tc.function?.arguments;
+      let input;
+      if (rawArguments === undefined || rawArguments === null || rawArguments === "") {
+        input = {};
+      } else {
+        try {
+          input = JSON.parse(rawArguments);
+        } catch {
+          throw invalidToolArguments(tc.function?.name);
+        }
+        if (!input || typeof input !== "object" || Array.isArray(input)) {
+          throw invalidToolArguments(tc.function?.name);
+        }
+      }
       content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
     }
   }

package/src/config.mjs

@@ -9,8 +9,39 @@ const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 const MODEL_CONTEXT_WINDOW = 1_000_000;
 const MODEL_AUTO_COMPACT_TOKEN_LIMIT = 900_000;
 
+function isTomlTableHeader(line) {
+  const source = line.trimStart();
+  const openingBrackets = source.startsWith("[[") ? 2 : source.startsWith("[") ? 1 : 0;
+  if (!openingBrackets) return false;
+
+  let quote = "";
+  let escaped = false;
+  for (let index = openingBrackets; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = "";
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char !== "]" || (openingBrackets === 2 && source[index + 1] !== "]")) continue;
+
+    if (!source.slice(openingBrackets, index).trim()) return false;
+    const tail = source.slice(index + openingBrackets).trim();
+    return tail === "" || tail.startsWith("#");
+  }
+  return false;
+}
+
 function setTopLevelTomlDefault(lines, key, value) {
-  let end = lines.findIndex((line) => /^\s*\[[^\]]+\]\s*$/.test(line));
+  let end = lines.findIndex(isTomlTableHeader);
   if (end === -1) end = lines.length;
 
   const keyRe = new RegExp(`^\\s*${key}\\s*=`);
@@ -28,7 +59,7 @@ function setTomlKey(lines, sectionName, key, value) {
 
   let end = lines.length;
   for (let i = start + 1; i < lines.length; i++) {
-    if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
+    if (isTomlTableHeader(lines[i])) {
       end = i;
       break;
     }
@@ -57,7 +88,11 @@ export function computeUpdatedCodexConfig(content, adapterPort = 2026, adapterHo
 
   let changed = false;
   const openaiLine = `openai_base_url = "${baseUrl}"`;
-  const openaiIndex = lines.findIndex((line) => /^openai_base_url\s*=/.test(line));
+  const firstSection = lines.findIndex(isTomlTableHeader);
+  const topLevelEnd = firstSection === -1 ? lines.length : firstSection;
+  const openaiIndex = lines.findIndex((line, index) => (
+    index < topLevelEnd && /^\s*openai_base_url\s*=/.test(line)
+  ));
   if (openaiIndex === -1) {
     lines.unshift(openaiLine);
     changed = true;

package/src/doctor.mjs

@@ -181,13 +181,12 @@ export async function inspectAdapterCompatibility({
   });
 
   if (firstResponse) {
-    await runCompatibilityCheck(checks, "Responses stream, history, and image tool compatibility", async () => {
+    await runCompatibilityCheck(checks, "Responses stream and history compatibility", async () => {
       const text = await compatibilityRequest(fetchImpl, `${baseUrl}/v1/responses`, {
         model: responsesModel,
         stream: true,
         previous_response_id: firstResponse.id,
         input: "Reply with OK again.",
-        tools: [{ type: "image_generation" }],
       }, timeoutMs);
       if (!/^event:\s*response\.completed\s*$/m.test(text)) throw new Error("stream did not contain response.completed");
     });
@@ -599,11 +598,11 @@ export async function collectDoctorChecks({
     } else if (pm.app.state === "clean") {
       checks.push({
         kind: "warn",
-        message: `PM Studio ${version} is supported but not patched`,
+        message: `PM Studio ${version} has a compatible local patch structure but is not patched`,
         fix: "ccdx pms setup",
       });
     } else if (pm.app.state === "unsupported") {
-      checks.push({ kind: "warn", message: `PM Studio ${version} compatibility cannot be safely verified; no files will be changed` });
+      checks.push({ kind: "warn", message: `PM Studio ${version} does not expose one uniquely compatible patch structure; no files will be changed` });
     } else if (pm.app.state === "drift" || pm.app.state === "error") {
       checks.push({ kind: "err", message: `PM Studio integrity check failed: ${pm.app.issues.join("; ")}` });
     }

package/src/pm-studio-asar.mjs

@@ -8,17 +8,42 @@ export const ELECTRON_ASAR_INTEGRITY_SENTINEL = "AGbevlPCksUGKNL8TSn7wGmJEuJsXb2
 const PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH = 2_121;
 const PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256 = "3da6245d676015ab6cd26e4d6a0d2f54894a687c370aa419c5ad170533d086aa";
 const PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR = "47024(I,e,t){";
+const PM_STUDIO_COPILOT_CONFIG_MODULE_SENTINEL = `API_ENDPOINT:"${PM_STUDIO_ORIGIN}"`;
 const PM_STUDIO_COPILOT_CONFIG_MODULE_PATH = "dist/main/main.js";
 const PM_STUDIO_COMPATIBILITY_ID = "exact-copilot-config-module-v1";
 const PM_STUDIO_COMPATIBLE_TARGET_MAX_BYTES = 128 * 1024 * 1024;
 const PM_STUDIO_COMPATIBLE_BLOCK_MAX_COUNT = 16_384;
+const PM_STUDIO_COMPATIBLE_MODULE_PREFIX_MAX_BYTES = 512;
+const PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE = '47024(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"https://api.githubcopilot.com",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>`req_${Date.now()}_${Math.random().toString(36).substr(2,9)}`}};class c{constructor(){this.config={...l}}static getInstance(){return c.instance||(c.instance=new c),c.instance}getConfig(){return{...this.config}}updateConfig(I){this.config={...this.config,...I}}resetConfig(){this.config={...l}}validateConfig(){return function(){const I=[];return l.CLIENT_ID||I.push("GitHub Copilot Client ID is required"),l.API_ENDPOINT||I.push("GitHub Copilot API endpoint is required"),{valid:0===I.length,errors:I}}()}getStandardHeaders(I){return function(I){const e={Accept:l.STANDARD_HEADERS.Accept,"Content-Type":l.STANDARD_HEADERS["Content-Type"],"User-Agent":l.STANDARD_HEADERS["User-Agent"],"Editor-Version":l.STANDARD_HEADERS["Editor-Version"],"Editor-Plugin-Version":l.STANDARD_HEADERS["Editor-Plugin-Version"],"Copilot-Integration-Id":l.STANDARD_HEADERS["Copilot-Integration-Id"],"X-Request-Id":"function"==typeof l.STANDARD_HEADERS["X-Request-Id"]?l.STANDARD_HEADERS["X-Request-Id"]():l.STANDARD_HEADERS["X-Request-Id"]};return I&&(e.Authorization=`Bearer ${I}`),e}(I)}getCopilotTokenHeaders(I){return function(I){return{Authorization:`Bearer ${I}`,Accept:"application/json","User-Agent":l.USER_AGENT,"Editor-Version":l.EDITOR_VERSION,"Editor-Plugin-Version":l.EDITOR_PLUGIN_VERSION}}(I)}getDeviceCodeHeaders(){return{Accept:"application/json","User-Agent":l.USER_AGENT}}}c.getInstance()}';
+
+function copilotConfigAlphaTemplate() {
+  // This is a reviewed byte template, not a generic JavaScript normalizer:
+  // only the five minifier bindings vary; every other byte remains exact.
+  const parts = [];
+  const moduleIdEnd = PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE.indexOf("(");
+  const pattern = /(?<![$\w])(?:I|e|t|l|c)(?![$\w])/g;
+  pattern.lastIndex = moduleIdEnd;
+  let offset = moduleIdEnd;
+  for (let match = pattern.exec(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE); match; match = pattern.exec(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE)) {
+    parts.push(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE.slice(offset, match.index));
+    parts.push(Object.freeze({ identifier: match[0] }));
+    offset = match.index + match[0].length;
+  }
+  parts.push(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE.slice(offset));
+  return Object.freeze(parts);
+}
+
+const PM_STUDIO_COPILOT_CONFIG_ALPHA_TEMPLATE = copilotConfigAlphaTemplate();
 
-function splitOriginConfigModule() {
-  const source = `47024(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"${PM_STUDIO_ORIGIN}",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>\`req_\${Date.now()}_\${Math.random().toString(36).substr(2,9)}\`}};const c=fetch.bind(globalThis),n="${CCDX_PM_STUDIO_ORIGIN}",a="${PM_STUDIO_SPLIT_ORIGIN_MARKER}",h="X-CCDX-PM-Relay",d=new Set,m=I=>I.headers.get(h)===a,q=I=>AbortSignal.any([I,AbortSignal.timeout(750)].filter(Boolean)),f=(I,e=400)=>Response.json({error:{code:I}},{status:e,headers:{[h]:a}});globalThis.fetch=async(I,e)=>{const t=I.url||I+"";if(t===\`\${l.API_ENDPOINT}/models\`){try{const t=await c(\`\${n}/models\`,e);if(t.ok&&m(t))try{let I=await t.clone().json(),e=I.data||I;if(Array.isArray(e)){d.clear();for(const I of e)/anthropic/i.test(I.vendor||I.owned_by)&&d.add(I.id);return t}}catch{}t.body?.cancel?.()?.catch?.(()=>{})}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I}return c(I,e)}const s=t.startsWith(l.API_ENDPOINT)?t.slice(l.API_ENDPOINT.length):"";if("POST"===e?.method&&["/chat/completions","/responses","/embeddings"].includes(s)){let t="";try{t=(JSON.parse(e.body).model||"").trim()}catch{}if(d.has(t)||/^claude-/i.test(t)){if("/chat/completions"!==s)return f("model_not_supported");try{const I=await c(\`\${n}/models\`,{signal:q(e?.signal)}),t=401===I.status&&m(I);await I.text();if(!t)throw 0;const l=await c(\`\${n}\${s}\`,e);if(!m(l)){await l.body?.cancel?.();throw 0}return l}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I;return f("relay_incompatible",503)}}}return c(I,e)}}`;
-  if (source.length > PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH) {
+function splitOriginConfigModule(
+  moduleId = "47024",
+  windowLength = PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH,
+) {
+  const source = `${moduleId}(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"${PM_STUDIO_ORIGIN}",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>\`req_\${Date.now()}_\${Math.random().toString(36).substr(2,9)}\`}};const c=fetch.bind(globalThis),n="${CCDX_PM_STUDIO_ORIGIN}",a="${PM_STUDIO_SPLIT_ORIGIN_MARKER}",h="X-CCDX-PM-Relay",d=new Set,m=I=>I.headers.get(h)===a,q=I=>AbortSignal.any([I,AbortSignal.timeout(750)].filter(Boolean)),f=(I,e=400)=>Response.json({error:{code:I}},{status:e,headers:{[h]:a}});globalThis.fetch=async(I,e)=>{const t=I.url||I+"";if(t===\`\${l.API_ENDPOINT}/models\`){try{const t=await c(\`\${n}/models\`,e);if(t.ok&&m(t))try{let I=await t.clone().json(),e=I.data||I;if(Array.isArray(e)){d.clear();for(const I of e)/anthropic/i.test(I.vendor||I.owned_by)&&d.add(I.id);return t}}catch{}t.body?.cancel?.()?.catch?.(()=>{})}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I}return c(I,e)}const s=t.startsWith(l.API_ENDPOINT)?t.slice(l.API_ENDPOINT.length):"";if("POST"===e?.method&&["/chat/completions","/responses","/embeddings"].includes(s)){let t="";try{t=(JSON.parse(e.body).model||"").trim()}catch{}if(d.has(t)||/^claude-/i.test(t)){if("/chat/completions"!==s)return f("model_not_supported");try{const I=await c(\`\${n}/models\`,{signal:q(e?.signal)}),t=401===I.status&&m(I);await I.text();if(!t)throw 0;const l=await c(\`\${n}\${s}\`,e);if(!m(l)){await l.body?.cancel?.();throw 0}return l}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I;return f("relay_incompatible",503)}}}return c(I,e)}}`;
+  if (source.length > windowLength) {
     throw new Error("PM Studio split-origin module exceeds its exact source window");
   }
-  return `${source.slice(0, -1)}${" ".repeat(PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH - source.length)}}`;
+  return `${source.slice(0, -1)}${" ".repeat(windowLength - source.length)}}`;
 }
 
 export const PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE = splitOriginConfigModule();
@@ -320,6 +345,93 @@ function occurrencePositions(haystack, needle) {
   return positions;
 }
 
+function asciiDigit(byte) {
+  return byte >= 48 && byte <= 57;
+}
+
+function asciiIdentifierStart(byte) {
+  return byte === 36
+    || byte === 95
+    || (byte >= 65 && byte <= 90)
+    || (byte >= 97 && byte <= 122);
+}
+
+function matchCopilotConfigAlphaTemplate(source, offset) {
+  let moduleIdEnd = offset;
+  while (moduleIdEnd < source.length && asciiDigit(source[moduleIdEnd])) moduleIdEnd += 1;
+  const moduleIdLength = moduleIdEnd - offset;
+  if (moduleIdLength === 0
+    || moduleIdLength > 10
+    || (moduleIdLength > 1 && source[offset] === 48)) return null;
+  const moduleId = source.subarray(offset, moduleIdEnd).toString("ascii");
+  if (!Number.isSafeInteger(Number(moduleId))) return null;
+
+  let cursor = moduleIdEnd;
+  const identifiers = new Map();
+  const reverseIdentifiers = new Map();
+  for (const part of PM_STUDIO_COPILOT_CONFIG_ALPHA_TEMPLATE) {
+    if (typeof part === "string") {
+      const literal = Buffer.from(part);
+      if (cursor + literal.length > source.length
+        || !source.subarray(cursor, cursor + literal.length).equals(literal)) return null;
+      cursor += literal.length;
+      continue;
+    }
+
+    if (!asciiIdentifierStart(source[cursor])
+      || asciiIdentifierStart(source[cursor + 1])
+      || asciiDigit(source[cursor + 1])) return null;
+    const candidate = String.fromCharCode(source[cursor]);
+    // The audited module uses single-byte minifier names. Keeping that bound
+    // rejects capture-prone "semantic" guesses while allowing permutations.
+    const mapped = identifiers.get(part.identifier);
+    const reverse = reverseIdentifiers.get(candidate);
+    if ((mapped && mapped !== candidate) || (reverse && reverse !== part.identifier)) return null;
+    identifiers.set(part.identifier, candidate);
+    reverseIdentifiers.set(candidate, part.identifier);
+    cursor += 1;
+  }
+
+  if (cursor < source.length && source[cursor] !== 44 && source[cursor] !== 125) return null;
+  return {
+    offset,
+    end: cursor,
+    length: cursor - offset,
+    moduleId,
+    anchor: `${moduleId}(`,
+  };
+}
+
+function locateCompatibleCopilotConfigModule(source) {
+  const sentinel = Buffer.from(PM_STUDIO_COPILOT_CONFIG_MODULE_SENTINEL);
+  const matches = new Map();
+  let sentinelCount = 0;
+  let searchOffset = 0;
+  while (searchOffset <= source.length - sentinel.length) {
+    const sentinelOffset = source.indexOf(sentinel, searchOffset);
+    if (sentinelOffset < 0) break;
+    sentinelCount += 1;
+    searchOffset = sentinelOffset + sentinel.length;
+
+    const lowerBound = Math.max(0, sentinelOffset - PM_STUDIO_COMPATIBLE_MODULE_PREFIX_MAX_BYTES);
+    for (let offset = lowerBound; offset <= sentinelOffset; offset += 1) {
+      if (!asciiDigit(source[offset]) || (offset > 0 && asciiDigit(source[offset - 1]))) continue;
+      if (offset > 0 && source[offset - 1] !== 44 && source[offset - 1] !== 123) continue;
+      const match = matchCopilotConfigAlphaTemplate(source, offset);
+      if (match && sentinelOffset >= match.offset && sentinelOffset < match.end) {
+        matches.set(match.offset, match);
+      }
+    }
+  }
+  if (sentinelCount === 0) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has no compatible Copilot configuration sentinel`);
+  }
+  if (matches.size !== 1) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has ${matches.size} alpha-compatible Copilot configuration modules, expected exactly one`);
+  }
+  return matches.values().next().value;
+}
+
 export function blockSha256(buffer, blockSize) {
   const size = integer(blockSize, "block size");
   if (size === 0) throw new Error("Invalid ASAR block size: 0");
@@ -385,22 +497,24 @@ export function createCompatiblePmStudioRecipe(value, options = {}) {
     throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} integrity metadata does not match its bytes`);
   }
 
-  const anchorPositions = occurrencePositions(
-    sourceTarget,
-    Buffer.from(PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR),
-  );
-  if (anchorPositions.length !== 1) {
-    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has ${anchorPositions.length} compatible module anchors, expected exactly one`);
+  const compatibleModule = locateCompatibleCopilotConfigModule(sourceTarget);
+  const editOffset = compatibleModule.offset;
+  const editEnd = compatibleModule.end;
+  const sourceEdit = sourceTarget.subarray(editOffset, editEnd);
+  const anchorPositions = occurrencePositions(sourceTarget, Buffer.from(compatibleModule.anchor));
+  if (anchorPositions.length !== 1 || anchorPositions[0] !== editOffset) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} compatible module header is not unique`);
+  }
+  let replacementSource;
+  try {
+    replacementSource = splitOriginConfigModule(compatibleModule.moduleId, compatibleModule.length);
+  } catch (error) {
+    throw incompatibleAsar(error.message);
   }
-  const editOffset = anchorPositions[0];
-  const editEnd = editOffset + PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH;
-  if (editEnd > sourceTarget.length
-    || sha256Hex(sourceTarget.subarray(editOffset, editEnd))
-      !== PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256) {
-    throw incompatibleAsar("PM Studio Copilot configuration module is not the exact compatible source window");
+  const replacement = Buffer.from(replacementSource);
+  if (replacement.length !== compatibleModule.length) {
+    throw incompatibleAsar("PM Studio split-origin replacement does not preserve the compatible module size");
   }
-
-  const replacement = Buffer.from(PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE);
   const patchedTarget = Buffer.from(sourceTarget);
   replacement.copy(patchedTarget, editOffset);
   const patchedTargetSha256 = sha256Hex(patchedTarget);
@@ -436,12 +550,12 @@ export function createCompatiblePmStudioRecipe(value, options = {}) {
   const edit = Object.freeze({
     offset: editOffset,
     absoluteOffset: absoluteOffset + editOffset,
-    length: PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH,
-    anchor: PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR,
+    length: compatibleModule.length,
+    anchor: compatibleModule.anchor,
     anchorCount: 1,
-    sourceSha256: PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256,
+    sourceSha256: sha256Hex(sourceEdit),
     patchedSha256: sha256Hex(replacement),
-    replacement: PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE,
+    replacement: replacementSource,
   });
   const target = Object.freeze({
     path: PM_STUDIO_COPILOT_CONFIG_MODULE_PATH,