codex-copilot-dx 0.6.8 → 0.6.10

package/README.md

@@ -112,9 +112,11 @@ ccdx doctor --online --profile all
 ### PM Studio opt-in patch
 
 CCDX can add the isolated Claude catalog to PM Studio without switching its
-active account or profile. GPT requests continue to use the bearer supplied by
-the current PM profile; exact enabled Anthropic model IDs use the isolated
-CCDX Claude profile. Neither credential is copied into the other application.
+active account or profile. GPT requests keep PM Studio's native official GitHub
+Copilot transport and the bearer supplied by the current PM profile. Model
+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.
 
 The current patch recipes support only the exact, unmodified PM Studio 2.9.7
 and 2.9.10 bundles on macOS. This is exact-version support, not a version range:
@@ -155,12 +157,21 @@ matches the frozen official fingerprint. The staged and installed CCDX patch
 must still pass strict ad-hoc signature verification and match the complete
 patched-tree record in the backup manifest.
 
-The patch is App-wide: every PM profile sends its Copilot API traffic through
-the loopback-only `/pm-ccdx/*` relay. Run ordinary `ccdx` before opening PM
-Studio; if port 2026 is unavailable, PM Copilot requests cannot connect. The
-relay explicitly supports only the Copilot paths discovered in the validated
-2.9.7 and 2.9.10 bundles (`GET /models` and `POST /chat/completions`, `/responses`, and
-`/embeddings`) and is not a general-purpose proxy.
+The patch uses split origins, not an App-wide proxy. GPT and other non-Claude
+inference requests remain on PM Studio's native official GitHub Copilot origin;
+they do not enter CCDX or depend on port 2026. Model discovery first tries the
+loopback-only `GET /pm-ccdx/models` merge and accepts it only when the relay
+returns the `X-CCDX-PM-Relay: split-origin-v1` compatibility marker. If the
+relay is unavailable or incompatible, model discovery safely falls back to the
+official directory and GPT remains available. Exact enabled Claude chat uses
+`POST /pm-ccdx/chat/completions` and fails closed if CCDX is unavailable; it
+never falls back to the PM enterprise account. The relay does not expose
+`/responses` or `/embeddings` and is not a general-purpose proxy.
+
+The loopback relay trusts local callers that present a valid Copilot bearer.
+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
 updater is not disabled; an official update may overwrite the patch or may

package/package.json

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

package/src/cli-status.mjs

@@ -73,7 +73,7 @@ function routingTarget(value) {
 function pmRouteSummary(requests = {}) {
   const routes = requests.by_route;
   if (!routes || typeof routes !== "object") return null;
-  const names = ["pm_models", "pm_chat_completions", "pm_responses", "pm_embeddings"];
+  const names = ["pm_models", "pm_chat_completions"];
   const totals = names.reduce((summary, name) => {
     const route = routes[name] || {};
     summary.total += finiteNumber(route.total) || 0;
@@ -81,7 +81,7 @@ function pmRouteSummary(requests = {}) {
     summary.errors += finiteNumber(route.errors) || 0;
     return summary;
   }, { total: 0, active: 0, errors: 0 });
-  return `PM relay: ${count(totals.total)} requests, ${count(totals.active)} active, ${count(totals.errors)} errors; models ${count(routes.pm_models?.total)}, chat ${count(routes.pm_chat_completions?.total)}, responses ${count(routes.pm_responses?.total)}, embeddings ${count(routes.pm_embeddings?.total)}`;
+  return `PM relay: ${count(totals.total)} requests, ${count(totals.active)} active, ${count(totals.errors)} errors; models ${count(routes.pm_models?.total)}, chat ${count(routes.pm_chat_completions?.total)}`;
 }
 
 function errorCode(error) {

package/src/doctor.mjs

@@ -590,6 +590,12 @@ export async function collectDoctorChecks({
           fix: "stop the running adapter, then run ccdx start",
         });
       }
+    } else if (pm.app.state === "predecessor") {
+      checks.push({
+        kind: "warn",
+        message: `PM Studio ${version} has a verified predecessor split patch`,
+        fix: "ccdx pms setup",
+      });
     } else if (pm.app.state === "clean") {
       checks.push({
         kind: "warn",

package/src/observability.mjs

@@ -17,8 +17,6 @@ const ROUTE_NAMES = Object.freeze([
   "messages_count_tokens",
   "pm_models",
   "pm_chat_completions",
-  "pm_responses",
-  "pm_embeddings",
   "not_found",
 ]);
 
@@ -104,8 +102,6 @@ export function classifyAdapterRoute(method, pathname) {
   if (method === "POST" && pathname === "/v1/messages/count_tokens") return "messages_count_tokens";
   if (method === "GET" && pathname === "/pm-ccdx/models") return "pm_models";
   if (method === "POST" && pathname === "/pm-ccdx/chat/completions") return "pm_chat_completions";
-  if (method === "POST" && pathname === "/pm-ccdx/responses") return "pm_responses";
-  if (method === "POST" && pathname === "/pm-ccdx/embeddings") return "pm_embeddings";
   return "not_found";
 }
 

package/src/pm-studio-asar.mjs

@@ -2,8 +2,22 @@ import { createHash } from "node:crypto";
 
 export const PM_STUDIO_ORIGIN = "https://api.githubcopilot.com";
 export const CCDX_PM_STUDIO_ORIGIN = "http://127.0.0.1:2026/pm-ccdx";
+export const PM_STUDIO_SPLIT_ORIGIN_MARKER = "split-origin-v1";
 export const ELECTRON_ASAR_INTEGRITY_SENTINEL = "AGbevlPCksUGKNL8TSn7wGmJEuJsXb2A";
 
+const PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH = 2_121;
+const PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256 = "3da6245d676015ab6cd26e4d6a0d2f54894a687c370aa419c5ad170533d086aa";
+
+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) {
+    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)}}`;
+}
+
+export const PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE = splitOriginConfigModule();
+
 export const PM_STUDIO_2_9_7_RECIPE = Object.freeze({
   id: "pm-studio-2.9.7-build-2.9.7",
   version: "2.9.7",
@@ -21,50 +35,62 @@ export const PM_STUDIO_2_9_7_RECIPE = Object.freeze({
   dataOffset: 3_832_764,
   sourceAsarSha256: "36fb8bf2fc9326ddf49baab5cc0b54b38751a7db041bda3c42a3b01107b54118",
   sourceHeaderSha256: "87746d92e00db2d40c03830ea06de22ec7cba112d07729801ccd02e226ffd961",
-  patchedAsarSha256: "3dd0f53cdaa35a644d2cf56e4fc2dd20f5c90dc2989b6d81a467ef00ebb620a7",
-  patchedHeaderSha256: "86ed1113a563b82ecec05de89aab87a5fd1666f35bee76e2d76e2ed5f6dcb3fa",
-  sourceSentinel: PM_STUDIO_ORIGIN,
-  patchedSentinel: CCDX_PM_STUDIO_ORIGIN,
+  patchedAsarSha256: "799dc18103a4553daefcaaddbe3410a1bfaf68d84407f4c10ef3d996afd71ad0",
+  patchedHeaderSha256: "08253795176d5471c6f406a29ccb134875d503bb55bca909b2cd131cd7708510",
+  predecessor: Object.freeze({
+    id: "split-origin-v1-model-discovery-750ms",
+    kind: "split-origin-predecessor",
+    asarSha256: "d520d115604225c1a3feb749dbe29ad0d2cd175c5233c010de0e1fade527fa0b",
+    headerSha256: "83e5fba3b6751b3098d8f6901db361a9b620ab3b924e0e551d3df612ff412642",
+    signingMetadata: Object.freeze({
+      identifier: "com.pm-studio.app",
+      flags: "0x10002(adhoc,runtime)",
+      runtime_version: "26.0.0",
+      entitlements_sha256: "9d4ccbda4fe0c81a70df3db93b3e61fe0500f67f14cdcbee4dea230e6512d05c",
+    }),
+  }),
   targets: Object.freeze([
     Object.freeze({
       path: "dist/main/main.js",
       offset: 101_621_627,
       size: 9_909_974,
-      sentinelOffset: 1_120_480,
-      absoluteSentinelOffset: 106_574_871,
-      sentinelCount: 1,
       blockSize: 4_194_304,
       sourceSha256: "58383be112886becdb8d8e7cce1b3efce07be6716190aa4940627f456eb8edb2",
-      patchedSha256: "24f1c47831c30f59e8464a66237c6bc9ed771d79f3a6889019dfdf53bc20fe42",
+      patchedSha256: "b219d08290b208fe41fa29b1e8ac4a1dee789e15f68fd4ff01eb5cd21249099b",
+      predecessorSha256: "69156040fb233a835b7be2f86fbe2f653380f03379adfedf46c63ab45de9d39d",
       sourceBlocks: Object.freeze([
         "3ce05a21e8992ccf12966cf9b78fcd28b2f66e6786489b5bb0a06f1d4b2a0c1e",
         "0a4832413d8d8cdda67c8bb318c0e5c25df20c75802d637097ffd045a31cd443",
         "bcc10582d8a74717f8f81b98182d3551f1eaf23eb9cadd908d160ce5e4ef8cba",
       ]),
       patchedBlocks: Object.freeze([
-        "afc18cc7d56cce6dd6f3bade8661268a534f2de93de5ba638f6609d2638c7436",
+        "dcbffb0f3aaa79a5ca8f1ee9170826b874d9db237c230abcdc0490335b2dc6a8",
         "0a4832413d8d8cdda67c8bb318c0e5c25df20c75802d637097ffd045a31cd443",
         "bcc10582d8a74717f8f81b98182d3551f1eaf23eb9cadd908d160ce5e4ef8cba",
       ]),
-    }),
-    Object.freeze({
-      path: "dist/renderer/js/main.09f18d95.js",
-      offset: 137_002_230,
-      size: 2_469_533,
-      sentinelOffset: 489_935,
-      absoluteSentinelOffset: 141_324_929,
-      sentinelCount: 1,
-      blockSize: 4_194_304,
-      sourceSha256: "eb63abf35be3db101da179789e8ffdcc5b67131258ac8d7976109713ff0cc994",
-      patchedSha256: "89bbea9516a914da3fa4f32befd33d0dbb0e63b09545e4d85392bccb52adc145",
-      sourceBlocks: Object.freeze([
-        "eb63abf35be3db101da179789e8ffdcc5b67131258ac8d7976109713ff0cc994",
-      ]),
-      patchedBlocks: Object.freeze([
-        "89bbea9516a914da3fa4f32befd33d0dbb0e63b09545e4d85392bccb52adc145",
+      predecessorBlocks: Object.freeze([
+        "f0b5585d2ff0d403e5c4d35e9bd0b8cbfec5c41a9b9057b8cc808107e889cf46",
+        "0a4832413d8d8cdda67c8bb318c0e5c25df20c75802d637097ffd045a31cd443",
+        "bcc10582d8a74717f8f81b98182d3551f1eaf23eb9cadd908d160ce5e4ef8cba",
       ]),
+      edit: Object.freeze({
+        offset: 1_120_359,
+        absoluteOffset: 106_574_750,
+        length: PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH,
+        anchor: "47024(I,e,t){",
+        anchorCount: 1,
+        sourceSha256: PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256,
+        patchedSha256: "873d2dd276bd12a7dc2876f5eaf8c67d4ae34749ead8911d0588badf4e9fc0cf",
+        predecessorSha256: "a5b9312ed78e8a7fc3bd38f7ea5d4ab008f21bae18ba3dd6aa2d4be6b69191db",
+        replacement: PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE,
+      }),
     }),
   ]),
+  legacy: Object.freeze({
+    kind: "global-origin-replacement",
+    asarSha256: "3dd0f53cdaa35a644d2cf56e4fc2dd20f5c90dc2989b6d81a467ef00ebb620a7",
+    headerSha256: "86ed1113a563b82ecec05de89aab87a5fd1666f35bee76e2d76e2ed5f6dcb3fa",
+  }),
 });
 
 export const PM_STUDIO_2_9_10_RECIPE = Object.freeze({
@@ -117,50 +143,62 @@ export const PM_STUDIO_2_9_10_RECIPE = Object.freeze({
   dataOffset: 3_833_292,
   sourceAsarSha256: "d243860770e8b1d8044213924f9704d1fc52f900d6c33461eff6358962330b78",
   sourceHeaderSha256: "5fc77d5b61e9647fba10fd2bd5752d0889c14da5a00b21d31bc48fdcccf74a69",
-  patchedAsarSha256: "49f72d999a6085102341c2d551577e164db6f22e4707d2112efa3fd280e7315e",
-  patchedHeaderSha256: "b264ece5b8e469cd3885a7a91f904f1902e1991f214ecbf228dfe91059ac7008",
-  sourceSentinel: PM_STUDIO_ORIGIN,
-  patchedSentinel: CCDX_PM_STUDIO_ORIGIN,
+  patchedAsarSha256: "f309fc7e86bb4edaf1fecd9061fb4ddc634357c0ba9299f1d13f8b2ff33efd90",
+  patchedHeaderSha256: "98c4af8656e61cc1a1a8b2188592a499a987136f8e6b763b0e83abda788e798d",
+  predecessor: Object.freeze({
+    id: "split-origin-v1-model-discovery-750ms",
+    kind: "split-origin-predecessor",
+    asarSha256: "ea28d998056b32ca4115d208a4d81ce629c83f3f5f89c6a66d50749849beb6fc",
+    headerSha256: "348d80f5f2d1ebb92e6089195b1703b87467678f80d8946b8ab83b3ead03e5be",
+    signingMetadata: Object.freeze({
+      identifier: "com.pm-studio.app",
+      flags: "0x10002(adhoc,runtime)",
+      runtime_version: "26.0.0",
+      entitlements_sha256: "9d4ccbda4fe0c81a70df3db93b3e61fe0500f67f14cdcbee4dea230e6512d05c",
+    }),
+  }),
   targets: Object.freeze([
     Object.freeze({
       path: "dist/main/main.js",
       offset: 101_622_115,
       size: 10_150_157,
-      sentinelOffset: 1_241_344,
-      absoluteSentinelOffset: 106_696_751,
-      sentinelCount: 1,
       blockSize: 4_194_304,
       sourceSha256: "03607bb1edc068396b99f02b9c9e0d8e10388fb658afc112e06e875c123dbc27",
-      patchedSha256: "e400300575e2d1c5ad089613f14e138612114547ff5060e94cb81e8de587a75a",
+      patchedSha256: "71e936c79c3560ab5bd9813479f8a66f4a7b06629edca74953feaaf7904a6564",
+      predecessorSha256: "b5b5e37af3d06ffc603bdef620fc1e0254580f0ee325f1a77096af6c78379b79",
       sourceBlocks: Object.freeze([
         "3910a9bc5459f493956aafee7b3644e8d242027758f0dcdea97d7c10a324c6bf",
         "49fa64c68425d35b1baff0d5745d856d377e014a7a7829322cd1b39aade9532e",
         "bd7cc14a1d2e02abe66c0ec6fc4e97b263cfc1f67c4ae39e956c06d3bcc2fe67",
       ]),
       patchedBlocks: Object.freeze([
-        "74022f5ad06c7879b37875efe0a090b23ccfbcf269afd26b10b77690413dca63",
+        "203ad1efbdcd869314510086632fdb0089196eb25179c46fb4108133cc65412f",
         "49fa64c68425d35b1baff0d5745d856d377e014a7a7829322cd1b39aade9532e",
         "bd7cc14a1d2e02abe66c0ec6fc4e97b263cfc1f67c4ae39e956c06d3bcc2fe67",
       ]),
-    }),
-    Object.freeze({
-      path: "dist/renderer/js/main.5ad30c24.js",
-      offset: 137_266_992,
-      size: 2_520_547,
-      sentinelOffset: 528_919,
-      absoluteSentinelOffset: 141_629_203,
-      sentinelCount: 1,
-      blockSize: 4_194_304,
-      sourceSha256: "3d123f7a3eb91777f723fe2c4d412677e6722b6348373e4b4bfda41dda8b60ad",
-      patchedSha256: "dc4a9d550f4beb3a2cd7ad0fa6fc82286106762bdf789189d8f88abd0a90f619",
-      sourceBlocks: Object.freeze([
-        "3d123f7a3eb91777f723fe2c4d412677e6722b6348373e4b4bfda41dda8b60ad",
-      ]),
-      patchedBlocks: Object.freeze([
-        "dc4a9d550f4beb3a2cd7ad0fa6fc82286106762bdf789189d8f88abd0a90f619",
+      predecessorBlocks: Object.freeze([
+        "63aa15d8c44614a7b2d9656ddba23109d40bab66b66b36339154953bd164da75",
+        "49fa64c68425d35b1baff0d5745d856d377e014a7a7829322cd1b39aade9532e",
+        "bd7cc14a1d2e02abe66c0ec6fc4e97b263cfc1f67c4ae39e956c06d3bcc2fe67",
       ]),
+      edit: Object.freeze({
+        offset: 1_241_223,
+        absoluteOffset: 106_696_630,
+        length: PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH,
+        anchor: "47024(I,e,t){",
+        anchorCount: 1,
+        sourceSha256: PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256,
+        patchedSha256: "873d2dd276bd12a7dc2876f5eaf8c67d4ae34749ead8911d0588badf4e9fc0cf",
+        predecessorSha256: "a5b9312ed78e8a7fc3bd38f7ea5d4ab008f21bae18ba3dd6aa2d4be6b69191db",
+        replacement: PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE,
+      }),
     }),
   ]),
+  legacy: Object.freeze({
+    kind: "global-origin-replacement",
+    asarSha256: "49f72d999a6085102341c2d551577e164db6f22e4707d2112efa3fd280e7315e",
+    headerSha256: "b264ece5b8e469cd3885a7a91f904f1902e1991f214ecbf228dfe91059ac7008",
+  }),
 });
 
 export const PM_STUDIO_RECIPES = Object.freeze([
@@ -334,7 +372,7 @@ function addMismatch(issues, label, actual, expected) {
   if (actual !== expected) issues.push(`${label}: expected ${expected}, got ${actual}`);
 }
 
-function inspectTarget(parsed, target, recipe) {
+function inspectTarget(parsed, target) {
   const entry = findAsarEntry(parsed.header, target.path);
   if (!entry) return { path: target.path, missing: true };
 
@@ -352,8 +390,28 @@ function inspectTarget(parsed, target, recipe) {
   }
 
   const bytes = parsed.buffer.subarray(absoluteOffset, absoluteOffset + size);
-  const sourceSentinel = Buffer.from(recipe.sourceSentinel);
-  const patchedSentinel = Buffer.from(recipe.patchedSentinel);
+  let edit = null;
+  if (target.edit) {
+    let editOffset;
+    let editLength;
+    try {
+      editOffset = integer(target.edit.offset, `${target.path} edit offset`);
+      editLength = integer(target.edit.length, `${target.path} edit length`);
+    } catch (error) {
+      return { path: target.path, offset, size, absoluteOffset, malformed: error.message };
+    }
+    if (editLength === 0 || editOffset + editLength > bytes.length) {
+      return { path: target.path, offset, size, absoluteOffset, malformed: "edit window is outside the target" };
+    }
+    const anchor = Buffer.from(target.edit.anchor || "");
+    edit = {
+      offset: editOffset,
+      absoluteOffset: absoluteOffset + editOffset,
+      length: editLength,
+      sha256: sha256Hex(bytes.subarray(editOffset, editOffset + editLength)),
+      anchorPositions: occurrencePositions(bytes, anchor),
+    };
+  }
   return {
     path: target.path,
     offset,
@@ -363,41 +421,48 @@ function inspectTarget(parsed, target, recipe) {
     blockSize: entry.integrity?.blockSize,
     blocks: blockSha256(bytes, target.blockSize),
     integrity: entry.integrity || null,
-    sourceSentinelPositions: occurrencePositions(bytes, sourceSentinel),
-    patchedSentinelPositions: occurrencePositions(bytes, patchedSentinel),
+    edit,
   };
 }
 
-function targetStateIssues(detail, target, recipe, state) {
+function targetStateIssues(detail, target, state) {
   const issues = [];
   if (detail.missing) return [`${target.path}: entry is missing`];
   if (detail.malformed) return [`${target.path}: ${detail.malformed}`];
 
   addMismatch(issues, `${target.path} offset`, detail.offset, target.offset);
   addMismatch(issues, `${target.path} size`, detail.size, target.size);
-  addMismatch(issues, `${target.path} absolute sentinel offset`,
-    detail.absoluteOffset + target.sentinelOffset, target.absoluteSentinelOffset);
   addMismatch(issues, `${target.path} integrity algorithm`,
     detail.integrity?.algorithm, "SHA256");
   addMismatch(issues, `${target.path} block size`, detail.integrity?.blockSize, target.blockSize);
 
   const patched = state === "patched";
-  const expectedHash = patched ? target.patchedSha256 : target.sourceSha256;
-  const expectedBlocks = patched ? target.patchedBlocks : target.sourceBlocks;
-  const expectedSentinelPositions = [target.sentinelOffset];
-  const presentPositions = patched ? detail.patchedSentinelPositions : detail.sourceSentinelPositions;
-  const absentPositions = patched ? detail.sourceSentinelPositions : detail.patchedSentinelPositions;
+  const predecessor = state === "predecessor";
+  const expectedHash = patched
+    ? target.patchedSha256
+    : predecessor ? target.predecessorSha256 : target.sourceSha256;
+  const expectedBlocks = patched
+    ? target.patchedBlocks
+    : predecessor ? target.predecessorBlocks : target.sourceBlocks;
 
   addMismatch(issues, `${target.path} SHA-256`, detail.sha256, expectedHash);
   addMismatch(issues, `${target.path} integrity hash`, detail.integrity?.hash, expectedHash);
   if (!sameArray(detail.blocks, expectedBlocks)) issues.push(`${target.path} computed block hashes do not match ${state} recipe`);
   if (!sameArray(detail.integrity?.blocks, expectedBlocks)) issues.push(`${target.path} header block hashes do not match ${state} recipe`);
-  if (!sameArray(presentPositions, expectedSentinelPositions)) {
-    issues.push(`${target.path} ${state} sentinel position/count does not match recipe`);
-  }
-  if (absentPositions.length !== 0) issues.push(`${target.path} contains the opposite-state sentinel`);
-  if (presentPositions.length !== target.sentinelCount) {
-    issues.push(`${target.path} ${state} sentinel count is ${presentPositions.length}, expected ${target.sentinelCount}`);
+  if (target.edit) {
+    addMismatch(issues, `${target.path} edit offset`, detail.edit?.offset, target.edit.offset);
+    addMismatch(issues, `${target.path} absolute edit offset`, detail.edit?.absoluteOffset, target.edit.absoluteOffset);
+    addMismatch(issues, `${target.path} edit length`, detail.edit?.length, target.edit.length);
+    addMismatch(issues, `${target.path} edit SHA-256`, detail.edit?.sha256,
+      patched
+        ? target.edit.patchedSha256
+        : predecessor ? target.edit.predecessorSha256 : target.edit.sourceSha256);
+    if (!sameArray(detail.edit?.anchorPositions, [target.edit.offset])) {
+      issues.push(`${target.path} module anchor position/count does not match recipe`);
+    }
+    if (detail.edit?.anchorPositions?.length !== target.edit.anchorCount) {
+      issues.push(`${target.path} module anchor count is ${detail.edit?.anchorPositions?.length || 0}, expected ${target.edit.anchorCount}`);
+    }
   }
   return issues;
 }
@@ -406,26 +471,44 @@ export function inspectAsarBuffer(value, recipe = PM_STUDIO_2_9_7_RECIPE) {
   const parsed = parseAsarBuffer(value);
   const asarSha256 = sha256Hex(parsed.buffer);
   const headerSha256 = sha256Hex(parsed.headerBytes);
-  const targets = recipe.targets.map((target) => inspectTarget(parsed, target, recipe));
+  const targets = recipe.targets.map((target) => inspectTarget(parsed, target));
   const commonIssues = [];
   addMismatch(commonIssues, "ASAR data offset", parsed.dataOffset, recipe.dataOffset);
 
   const issuesFor = (state) => {
     const patched = state === "patched";
+    const predecessor = state === "predecessor";
+    const expected = predecessor ? recipe.predecessor : null;
     const issues = [...commonIssues];
     addMismatch(issues, "ASAR SHA-256", asarSha256,
-      patched ? recipe.patchedAsarSha256 : recipe.sourceAsarSha256);
+      patched ? recipe.patchedAsarSha256 : predecessor ? expected?.asarSha256 : recipe.sourceAsarSha256);
     addMismatch(issues, "ASAR header SHA-256", headerSha256,
-      patched ? recipe.patchedHeaderSha256 : recipe.sourceHeaderSha256);
+      patched ? recipe.patchedHeaderSha256 : predecessor ? expected?.headerSha256 : recipe.sourceHeaderSha256);
     for (let index = 0; index < recipe.targets.length; index += 1) {
-      issues.push(...targetStateIssues(targets[index], recipe.targets[index], recipe, state));
+      issues.push(...targetStateIssues(targets[index], recipe.targets[index], state));
     }
     return issues;
   };
 
   const cleanIssues = issuesFor("clean");
   const patchedIssues = issuesFor("patched");
-  const state = cleanIssues.length === 0 ? "clean" : patchedIssues.length === 0 ? "patched" : "drift";
+  const predecessorIssues = recipe.predecessor
+    ? issuesFor("predecessor")
+    : ["recipe has no recognized predecessor patch"];
+  const legacyIssues = [...commonIssues];
+  if (!recipe.legacy) {
+    legacyIssues.push("recipe has no recognized legacy patch");
+  } else {
+    addMismatch(legacyIssues, "ASAR SHA-256", asarSha256, recipe.legacy.asarSha256);
+    addMismatch(legacyIssues, "ASAR header SHA-256", headerSha256, recipe.legacy.headerSha256);
+  }
+  const state = cleanIssues.length === 0
+    ? "clean"
+    : patchedIssues.length === 0
+      ? "patched"
+      : predecessorIssues.length === 0
+        ? "predecessor"
+        : legacyIssues.length === 0 ? "legacy" : "drift";
   return {
     recipeId: recipe.id,
     state,
@@ -435,19 +518,30 @@ export function inspectAsarBuffer(value, recipe = PM_STUDIO_2_9_7_RECIPE) {
     targets,
     cleanIssues,
     patchedIssues,
+    predecessorIssues,
+    legacyIssues,
   };
 }
 
 export function patchAsarBuffer(value, recipe = PM_STUDIO_2_9_7_RECIPE) {
-  if (Buffer.byteLength(recipe.sourceSentinel) !== Buffer.byteLength(recipe.patchedSentinel)) {
-    throw new Error("PM Studio patch requires equal-length origin sentinels");
-  }
   const before = inspectAsarBuffer(value, recipe);
   if (before.state === "patched") {
     return { changed: false, buffer: Buffer.from(value), before, after: before };
   }
+  if (before.state === "predecessor") {
+    const error = new Error("Predecessor PM Studio split-origin patch must be migrated from a verified clean backup");
+    error.code = "PM_STUDIO_ASAR_PREDECESSOR";
+    error.inspection = before;
+    throw error;
+  }
+  if (before.state === "legacy") {
+    const error = new Error("Legacy PM Studio global-origin patch must be migrated from a verified clean backup");
+    error.code = "PM_STUDIO_ASAR_LEGACY";
+    error.inspection = before;
+    throw error;
+  }
   if (before.state !== "clean") {
-    const error = new Error("PM Studio ASAR does not match the clean or patched recipe");
+    const error = new Error("PM Studio ASAR does not match the clean, current split-origin, predecessor, or legacy recipe");
     error.code = "PM_STUDIO_ASAR_DRIFT";
     error.inspection = before;
     throw error;
@@ -455,16 +549,25 @@ export function patchAsarBuffer(value, recipe = PM_STUDIO_2_9_7_RECIPE) {
 
   const output = Buffer.from(value);
   const parsed = parseAsarBuffer(output);
-  const sourceSentinel = Buffer.from(recipe.sourceSentinel);
-  const patchedSentinel = Buffer.from(recipe.patchedSentinel);
 
   for (const target of recipe.targets) {
     const entry = findAsarEntry(parsed.header, target.path);
     const offset = entryOffset(entry.offset, `${target.path} offset`);
-    const absoluteSentinelOffset = parsed.dataOffset + offset + target.sentinelOffset;
-    const existing = output.subarray(absoluteSentinelOffset, absoluteSentinelOffset + sourceSentinel.length);
-    if (!existing.equals(sourceSentinel)) throw new Error(`${target.path} source sentinel moved before patching`);
-    patchedSentinel.copy(output, absoluteSentinelOffset);
+    const edit = target.edit;
+    if (!edit) throw new Error(`${target.path} has no split-origin edit recipe`);
+    const replacement = Buffer.from(edit.replacement);
+    if (replacement.length !== edit.length || sha256Hex(replacement) !== edit.patchedSha256) {
+      throw new Error(`${target.path} split-origin replacement does not match its recipe`);
+    }
+    const absoluteEditOffset = parsed.dataOffset + offset + edit.offset;
+    if (absoluteEditOffset !== edit.absoluteOffset) {
+      throw new Error(`${target.path} split-origin edit moved before patching`);
+    }
+    const existing = output.subarray(absoluteEditOffset, absoluteEditOffset + edit.length);
+    if (sha256Hex(existing) !== edit.sourceSha256) {
+      throw new Error(`${target.path} source edit window does not match its recipe`);
+    }
+    replacement.copy(output, absoluteEditOffset);
     entry.integrity = {
       ...entry.integrity,
       algorithm: "SHA256",

package/src/pm-studio-relay.mjs

@@ -16,6 +16,8 @@ import { requireUpstreamEventStream } from "./stream-contract.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 
 export const PM_STUDIO_RELAY_PREFIX = "/pm-ccdx";
+export const PM_STUDIO_RELAY_MARKER_HEADER = "X-CCDX-PM-Relay";
+export const PM_STUDIO_RELAY_MARKER_VALUE = "split-origin-v1";
 const COPILOT_ORIGIN = "https://api.githubcopilot.com";
 const DEFAULT_VALIDATION_TTL_MS = 5 * 60 * 1000;
 const DEFAULT_VALIDATION_CACHE_SIZE = 128;
@@ -32,11 +34,7 @@ const HOP_BY_HOP_HEADERS = new Set([
   "transfer-encoding",
   "upgrade",
 ]);
-const POST_PATHS = new Set([
-  "/chat/completions",
-  "/responses",
-  "/embeddings",
-]);
+const CHAT_COMPLETIONS_PATH = "/chat/completions";
 
 function localError(statusCode, code, message) {
   const error = httpError(message, statusCode);
@@ -46,7 +44,11 @@ function localError(statusCode, code, message) {
 
 function sendLocalError(res, statusCode, code, message, headers = {}) {
   if (res.destroyed || res.writableEnded) return;
-  res.writeHead(statusCode, { "Content-Type": "application/json", ...headers });
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json",
+    [PM_STUDIO_RELAY_MARKER_HEADER]: PM_STUDIO_RELAY_MARKER_VALUE,
+    ...headers,
+  });
   res.end(JSON.stringify({ error: { message, type: "invalid_request_error", code } }));
 }
 
@@ -160,6 +162,7 @@ async function responseSnapshot(response) {
 function responseHeaders(headers, body, options) {
   return {
     ...safeUpstreamResponseHeaders(headers, options),
+    [PM_STUDIO_RELAY_MARKER_HEADER]: PM_STUDIO_RELAY_MARKER_VALUE,
     "Content-Length": String(body.length),
   };
 }
@@ -179,8 +182,6 @@ function rejectUpstreamRedirect(response) {
 
 function mergeModelCatalog(snapshot, modelRouter) {
   if (!snapshot.ok) return null;
-  const allowed = modelRouter.allowedModels();
-  if (!allowed.length) return null;
   let enterprise;
   try {
     enterprise = JSON.parse(snapshot.body.toString("utf8"));
@@ -189,6 +190,8 @@ function mergeModelCatalog(snapshot, modelRouter) {
   }
   const data = catalogData(enterprise);
   if (!data) return null;
+  const allowed = modelRouter.allowedModels();
+  if (!allowed.length) return snapshot.body;
   const seen = new Set(data.map((model) => String(model?.id || "").trim()).filter(Boolean));
   const additions = [];
   for (const model of allowed) {
@@ -197,7 +200,7 @@ function mergeModelCatalog(snapshot, modelRouter) {
     seen.add(id);
     additions.push(model);
   }
-  if (!additions.length) return null;
+  if (!additions.length) return snapshot.body;
   return Buffer.from(JSON.stringify(Array.isArray(enterprise)
     ? [...enterprise, ...additions]
     : { ...enterprise, data: [...data, ...additions] }));
@@ -215,6 +218,7 @@ async function relayUpstreamResponse(response, reqBody, res, abort, streamIdleTi
   abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
   res.writeHead(response.status, {
     ...safeUpstreamResponseHeaders(response.headers, { contentType: "text/event-stream" }),
+    [PM_STUDIO_RELAY_MARKER_HEADER]: PM_STUDIO_RELAY_MARKER_VALUE,
     "Cache-Control": "no-cache",
   });
   const reader = response.body.getReader();
@@ -424,6 +428,9 @@ export function createPmStudioRelayHandler(options = {}) {
     }
     const merged = mergeModelCatalog(snapshot, modelRouter);
     if (!merged) {
+      throw localError(502, "invalid_upstream", "PM Studio upstream model catalog has an invalid JSON shape");
+    }
+    if (merged === snapshot.body) {
       sendSnapshot(res, snapshot);
       return;
     }
@@ -431,15 +438,26 @@ export function createPmStudioRelayHandler(options = {}) {
     res.end(merged);
   }
 
-  async function handlePost(req, res, pathname, token, abort) {
+  async function handleChatCompletions(req, res, token, abort) {
     let releaseRequest = releaseOnce();
     try {
       const admission = await acquireRequest(req, { signal: abort.signal });
       releaseRequest = releaseOnce(admission);
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const body = await readJsonBody(req, { admission, signal: abort.signal });
-      const supportsStream = pathname === "/chat/completions" || pathname === "/responses";
-      const streaming = supportsStream && body?.stream === true;
+      const modelType = modelRouter.classify(body?.model);
+      if (modelType === "unsupported_claude") {
+        throw localError(400, "model_not_supported", "The requested Claude model is not enabled for PM Studio");
+      }
+      if (modelType !== "claude") {
+        throw localError(
+          400,
+          "native_route_required",
+          "Non-Claude PM Studio requests must use the native GitHub Copilot origin",
+        );
+      }
+
+      const streaming = body?.stream === true;
       const requestTimeoutMs = streaming ? streamHandshakeTimeoutMs : upstreamTimeoutMs;
       const timeoutReason = streaming ? "stream_handshake_timeout" : "upstream_timeout";
       abort.setTimeout(requestTimeoutMs, timeoutReason);
@@ -452,23 +470,12 @@ export function createPmStudioRelayHandler(options = {}) {
       }
       abort.setTimeout(requestTimeoutMs, timeoutReason);
 
-      const modelType = modelRouter.classify(body?.model);
-      if (modelType === "unsupported_claude" || (modelType === "claude" && pathname !== "/chat/completions")) {
-        throw localError(400, "model_not_supported", "The requested Claude model is not available for this endpoint");
-      }
-
-      let upstream;
-      if (modelType === "claude") {
-        upstream = await options.claudeClient.chatCompletions(body, {
-          signal: abort.signal,
-          fetchImpl: fetchClaudeUpstream,
-        });
-      } else {
-        const bodyText = JSON.stringify(body);
-        upstream = await fetchEnterprise(pathname, "POST", req.headers, token, bodyText, abort.signal);
-      }
+      const upstream = await options.claudeClient.chatCompletions(body, {
+        signal: abort.signal,
+        fetchImpl: fetchClaudeUpstream,
+      });
       releaseRequest();
-      await relayUpstreamResponse(upstream, supportsStream ? body : null, res, abort, streamIdleTimeoutMs);
+      await relayUpstreamResponse(upstream, body, res, abort, streamIdleTimeoutMs);
     } finally {
       releaseRequest();
     }
@@ -494,7 +501,9 @@ export function createPmStudioRelayHandler(options = {}) {
     }
 
     const upstreamPath = pathname.slice(PM_STUDIO_RELAY_PREFIX.length);
-    const allowedMethod = upstreamPath === "/models" ? "GET" : POST_PATHS.has(upstreamPath) ? "POST" : null;
+    const allowedMethod = upstreamPath === "/models"
+      ? "GET"
+      : upstreamPath === CHAT_COMPLETIONS_PATH ? "POST" : null;
     if (!allowedMethod) {
       sendLocalError(res, 404, "route_not_found", "PM Studio relay route not found");
       return true;
@@ -512,13 +521,14 @@ export function createPmStudioRelayHandler(options = {}) {
         abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
         await handleModels(req, res, token, abort);
       } else {
-        await handlePost(req, res, upstreamPath, token, abort);
+        await handleChatCompletions(req, res, token, abort);
       }
     } catch (error) {
       const safe = safeFailure(error, abort);
       if (res.headersSent) {
         if (!res.destroyed) res.destroy();
       } else {
+        res.setHeader(PM_STUDIO_RELAY_MARKER_HEADER, PM_STUDIO_RELAY_MARKER_VALUE);
         sendJsonError(res, safe, safe.statusCode || 502);
       }
     } finally {

package/src/pm-studio-setup.mjs

@@ -519,6 +519,10 @@ export function inspectPmStudioApp({
     && codeSign?.adHoc === true
     && (!recipe.patchedSigningMetadata
       || JSON.stringify(signingMetadata(codeSign)) === JSON.stringify(recipe.patchedSigningMetadata));
+  const predecessorSignatureAccepted = codeSign?.valid === true
+    && codeSign?.adHoc === true
+    && Boolean(recipe.predecessor?.signingMetadata)
+    && JSON.stringify(signingMetadata(codeSign)) === JSON.stringify(recipe.predecessor.signingMetadata);
   const clean = issues.length === 0
     && asar.state === "clean"
     && integrityMatches(plistIntegrity, "SHA256", recipe.sourceHeaderSha256)
@@ -530,8 +534,16 @@ export function inspectPmStudioApp({
     && asar.state === "patched"
     && integrityMatches(plistIntegrity, "SHA256", recipe.patchedHeaderSha256)
     && patchedSignatureAccepted;
+  const predecessor = issues.length === 0
+    && asar.state === "predecessor"
+    && integrityMatches(plistIntegrity, "SHA256", recipe.predecessor?.headerSha256)
+    && predecessorSignatureAccepted;
+  const legacy = issues.length === 0
+    && asar.state === "legacy"
+    && integrityMatches(plistIntegrity, "SHA256", recipe.legacy?.headerSha256)
+    && patchedSignatureAccepted;
 
-  if (!clean && !patched) {
+  if (!clean && !patched && !predecessor && !legacy) {
     if (asar.state === "drift") issues.push("app.asar is unknown drift");
     else if (asar.state === "clean"
       && !integrityMatches(plistIntegrity, "SHA256", recipe.sourceHeaderSha256)) {
@@ -539,6 +551,12 @@ export function inspectPmStudioApp({
     } else if (asar.state === "patched"
       && !integrityMatches(plistIntegrity, "SHA256", recipe.patchedHeaderSha256)) {
       issues.push("patched ASAR does not match ElectronAsarIntegrity");
+    } else if (asar.state === "predecessor"
+      && !integrityMatches(plistIntegrity, "SHA256", recipe.predecessor?.headerSha256)) {
+      issues.push("predecessor ASAR does not match ElectronAsarIntegrity");
+    } else if (asar.state === "legacy"
+      && !integrityMatches(plistIntegrity, "SHA256", recipe.legacy?.headerSha256)) {
+      issues.push("legacy ASAR does not match ElectronAsarIntegrity");
     }
     if (asar.state === "clean" && recipe.sourceBundleContent && !exactSourceBundle) {
       issues.push("bundle content does not match the exact clean recipe");
@@ -547,7 +565,9 @@ export function inspectPmStudioApp({
       issues.push("codesign verification failed");
     }
     else if (asar.state === "clean" && codeSign.adHoc) issues.push("clean bundle has an unexpected ad-hoc signature");
-    else if (asar.state === "patched" && !codeSign.adHoc) issues.push("patched bundle is not ad-hoc signed");
+    else if (["patched", "predecessor", "legacy"].includes(asar.state) && !codeSign.adHoc) {
+      issues.push(`${asar.state} bundle is not ad-hoc signed`);
+    }
     else if (asar.state === "clean" && codeSign.teamIdentifier !== recipe.sourceTeamIdentifier) {
       issues.push(`clean bundle TeamIdentifier is ${codeSign.teamIdentifier || "missing"}, expected ${recipe.sourceTeamIdentifier}`);
     }
@@ -559,15 +579,21 @@ export function inspectPmStudioApp({
       && executableIntegrity.frameworkSha256 !== recipe.sourceElectronFrameworkSha256) {
       issues.push("Electron Framework hash does not match the clean recipe");
     }
-    if (asar.state === "patched" && codeSign?.valid && codeSign?.adHoc
+    if (["patched", "legacy"].includes(asar.state) && codeSign?.valid && codeSign?.adHoc
       && recipe.patchedSigningMetadata
       && !patchedSignatureAccepted) {
-      issues.push("patched bundle signing metadata does not match the recipe");
+      issues.push(`${asar.state} bundle signing metadata does not match the recipe`);
+    }
+    if (asar.state === "predecessor" && codeSign?.valid && codeSign?.adHoc
+      && !predecessorSignatureAccepted) {
+      issues.push("predecessor bundle signing metadata does not match the recipe");
     }
   }
 
   return {
-    state: clean ? "clean" : patched ? "patched" : "drift",
+    state: clean
+      ? "clean"
+      : patched ? "patched" : predecessor ? "predecessor" : legacy ? "legacy" : "drift",
     metadata: {
       version: String(metadata.version),
       build: String(metadata.build),
@@ -676,6 +702,28 @@ function backupManifest(recipe, createdAt) {
   };
 }
 
+function patchRecordMatches(record, recipe, state) {
+  const expected = state === "legacy"
+    ? recipe.legacy
+    : state === "predecessor"
+      ? recipe.predecessor
+      : { asarSha256: recipe.patchedAsarSha256, headerSha256: recipe.patchedHeaderSha256 };
+  return Boolean(expected)
+    && record?.asar_sha256 === expected.asarSha256
+    && record?.asar_header_sha256 === expected.headerSha256
+    && integrityMatches(record?.electron_asar_integrity, "SHA256", expected.headerSha256);
+}
+
+function patchRecordForState(manifest, recipe, state) {
+  const historicalKey = state === "legacy"
+    ? "legacy_patched"
+    : state === "predecessor" ? "predecessor_patched" : "";
+  if (historicalKey && patchRecordMatches(manifest?.[historicalKey], recipe, state)) {
+    return manifest[historicalKey];
+  }
+  return patchRecordMatches(manifest?.patched, recipe, state) ? manifest.patched : null;
+}
+
 function validateBackup({ backupDir, recipe, operations }) {
   const manifestPath = path.join(backupDir, "manifest.json");
   const backupAppPath = path.join(backupDir, "PM Studio.app");
@@ -702,9 +750,11 @@ function validateBackup({ backupDir, recipe, operations }) {
       && JSON.stringify(manifest?.source?.bundle_content) !== JSON.stringify(recipe.sourceBundleContent))
     || (recipe.sourceArtifact
       && JSON.stringify(manifest?.source?.artifact) !== JSON.stringify(recipe.sourceArtifact))
-    || manifest?.patched?.asar_sha256 !== recipe.patchedAsarSha256
-    || manifest?.patched?.asar_header_sha256 !== recipe.patchedHeaderSha256
-    || !integrityMatches(manifest?.patched?.electron_asar_integrity, "SHA256", recipe.patchedHeaderSha256)) {
+    || (manifest?.predecessor_patched !== undefined
+      && !patchRecordMatches(manifest.predecessor_patched, recipe, "predecessor"))
+    || (!patchRecordForState(manifest, recipe, "patched")
+      && !patchRecordForState(manifest, recipe, "legacy")
+      && !patchRecordForState(manifest, recipe, "predecessor"))) {
     throw setupError("PM_STUDIO_BACKUP_INVALID", `Existing PM Studio backup does not match recipe ${recipe.id}`);
   }
   const inspection = inspectPmStudioApp({ appPath: backupAppPath, recipe, operations });
@@ -750,12 +800,29 @@ function ensureBackup({ appPath, backupRoot, recipe, operations }) {
 
 function writePatchedBinaryRecord({ backup, inspection, operations, recipe }) {
   const manifest = JSON.parse(fs.readFileSync(backup.manifestPath, "utf8"));
-  manifest.patched.binaries = {
-    main_executable_sha256: inspection.executableIntegrity.executableSha256,
-    electron_framework_sha256: inspection.executableIntegrity.frameworkSha256,
+  if (manifest.predecessor_patched !== undefined
+    && !patchRecordMatches(manifest.predecessor_patched, recipe, "predecessor")) {
+    throw setupError("PM_STUDIO_BACKUP_INVALID", "Existing PM Studio predecessor record does not match the patch recipe");
+  }
+  if (manifest.predecessor_patched === undefined
+    && patchRecordMatches(manifest.patched, recipe, "predecessor")) {
+    manifest.predecessor_patched = manifest.patched;
+  }
+  if (!patchRecordMatches(manifest.legacy_patched, recipe, "legacy")
+    && patchRecordMatches(manifest.patched, recipe, "legacy")) {
+    manifest.legacy_patched = manifest.patched;
+  }
+  manifest.patched = {
+    asar_sha256: recipe.patchedAsarSha256,
+    asar_header_sha256: recipe.patchedHeaderSha256,
+    electron_asar_integrity: { algorithm: "SHA256", hash: recipe.patchedHeaderSha256 },
+    binaries: {
+      main_executable_sha256: inspection.executableIntegrity.executableSha256,
+      electron_framework_sha256: inspection.executableIntegrity.frameworkSha256,
+    },
+    signing_metadata: signingMetadata(inspection.codeSign),
+    ...(recipe.sourceBundleContent ? { bundle_content: inspection.bundleContent } : {}),
   };
-  manifest.patched.signing_metadata = signingMetadata(inspection.codeSign);
-  if (recipe.sourceBundleContent) manifest.patched.bundle_content = inspection.bundleContent;
   const temporaryPath = `${backup.manifestPath}.${operations.uuid()}.tmp`;
   try {
     fs.writeFileSync(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
@@ -766,7 +833,14 @@ function writePatchedBinaryRecord({ backup, inspection, operations, recipe }) {
   backup.manifest = manifest;
 }
 
-export function assertPatchedBinaryRecord({ inspection, manifestPath, recipe }) {
+export function assertPatchedBinaryRecord({
+  inspection,
+  manifestPath,
+  recipe,
+  recordState = ["legacy", "predecessor"].includes(inspection?.state)
+    ? inspection.state
+    : "patched",
+}) {
   let manifest;
   try {
     manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
@@ -790,23 +864,24 @@ export function assertPatchedBinaryRecord({ inspection, manifestPath, recipe })
       || JSON.stringify(manifest?.source?.bundle_content) !== JSON.stringify(recipe.sourceBundleContent)
     ))
     || (recipe.sourceArtifact
-      && JSON.stringify(manifest?.source?.artifact) !== JSON.stringify(recipe.sourceArtifact))
-    || manifest?.patched?.asar_sha256 !== recipe.patchedAsarSha256
-    || manifest?.patched?.asar_header_sha256 !== recipe.patchedHeaderSha256
-    || !integrityMatches(manifest?.patched?.electron_asar_integrity, "SHA256", recipe.patchedHeaderSha256))) {
+      && JSON.stringify(manifest?.source?.artifact) !== JSON.stringify(recipe.sourceArtifact)))) {
     throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", "PM Studio patched-binary record does not match the installed patch recipe");
   }
-  const binaries = manifest?.patched?.binaries;
+  const record = patchRecordForState(manifest, recipe, recordState);
+  if (!record) {
+    throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", `PM Studio ${recordState} record does not match the installed patch recipe`);
+  }
+  const binaries = record.binaries;
   if (!binaries
     || binaries.main_executable_sha256 !== inspection.executableIntegrity.executableSha256
     || binaries.electron_framework_sha256 !== inspection.executableIntegrity.frameworkSha256) {
     throw setupError("PM_STUDIO_BUNDLE_DRIFT", "PM Studio executable or Electron Framework differs from the installed patch record");
   }
-  if (JSON.stringify(manifest?.patched?.signing_metadata) !== JSON.stringify(signingMetadata(inspection.codeSign))) {
+  if (JSON.stringify(record.signing_metadata) !== JSON.stringify(signingMetadata(inspection.codeSign))) {
     throw setupError("PM_STUDIO_BUNDLE_DRIFT", "PM Studio signing metadata differs from the installed patch record");
   }
   if (recipe?.sourceBundleContent
-    && JSON.stringify(manifest?.patched?.bundle_content) !== JSON.stringify(inspection.bundleContent)) {
+    && JSON.stringify(record.bundle_content) !== JSON.stringify(inspection.bundleContent)) {
     throw setupError("PM_STUDIO_BUNDLE_DRIFT", "PM Studio bundle content differs from the installed patch record");
   }
 }
@@ -922,12 +997,15 @@ export async function runPmStudioSetup({
     emit(`[OK] PM Studio ${recipe.version} build ${recipe.build} is already patched; no backup or signing was repeated.`);
     emit(`[OK] Verified backup: ${backup.backupAppPath}`);
     emit(`[OK] Backup manifest: ${backup.manifestPath}`);
-    emit(`[INFO] Start ${commandName} before opening PM Studio.`);
+    emit(`[INFO] Start ${commandName} before using Claude in PM Studio; GPT remains on PM Studio's native GitHub Copilot path.`);
     return { status: "already_patched", changed: false, recipe: recipe.id, backup, inspection: source, messages };
   }
-  if (source.state !== "clean") {
+  const migratingLegacy = source.state === "legacy";
+  const migratingPredecessor = source.state === "predecessor";
+  const migratingExistingPatch = migratingLegacy || migratingPredecessor;
+  if (source.state !== "clean" && !migratingExistingPatch) {
     throw setupError("PM_STUDIO_BUNDLE_DRIFT",
-      `PM Studio ${recipe.version} build ${recipe.build} does not match the clean or patched recipe; no files were changed`, source.issues);
+      `PM Studio ${recipe.version} build ${recipe.build} does not match the clean, current split-origin, predecessor, or legacy recipe; no files were changed`, source.issues);
   }
 
   if (source.sourceVerification === "exact-bundle-content") {
@@ -935,17 +1013,38 @@ export async function runPmStudioSetup({
   }
 
   const backupExists = fs.existsSync(finalBackupDir);
+  let verifiedBackup = null;
+  if (migratingExistingPatch) {
+    if (!backupExists) {
+      throw setupError("PM_STUDIO_BACKUP_INVALID",
+        `${migratingLegacy ? "Legacy global-origin" : "Predecessor split-origin"} PM Studio patch has no matching verified clean backup; no files were changed`);
+    }
+    verifiedBackup = validateBackup({ backupDir: finalBackupDir, recipe, operations });
+    assertPatchedBinaryRecord({
+      inspection: source,
+      manifestPath: verifiedBackup.manifestPath,
+      recipe,
+      recordState: source.state,
+    });
+    emit(migratingLegacy
+      ? "[WARN] Legacy global-origin patch detected; setup will rebuild from the verified clean backup so GPT and enterprise authentication return to PM Studio's native origin."
+      : "[WARN] Predecessor split-origin patch detected; setup will rebuild from the verified clean backup so delayed Claude model discovery no longer falls back to the native catalog.");
+  }
   assertSpace({ appPath, backupRoot, backupExists, operations });
 
   emit("[WARN] PM Studio's vendor signature will be replaced with an ad-hoc signature; an official update or reinstall may overwrite this patch.");
-  const backup = ensureBackup({ appPath, backupRoot, recipe, operations });
+  const backup = verifiedBackup || ensureBackup({ appPath, backupRoot, recipe, operations });
   const stagePath = path.join(path.dirname(appPath), `.${path.basename(appPath)}.ccdx-stage-${operations.uuid()}`);
   let preserveStage = false;
   try {
-    operations.copyBundle({ source: appPath, destination: stagePath, processRunner: operations.processRunner });
+    operations.copyBundle({
+      source: migratingExistingPatch ? backup.backupAppPath : appPath,
+      destination: stagePath,
+      processRunner: operations.processRunner,
+    });
     const stagedSource = inspectPmStudioApp({ appPath: stagePath, recipe, operations });
     if (stagedSource.state !== "clean"
-      || (recipe.sourceBundleContent
+      || (!migratingExistingPatch && recipe.sourceBundleContent
         && stagedSource.bundleContent?.sha256 !== source.bundleContent?.sha256)) {
       throw setupError("PM_STUDIO_STAGE_INVALID", "PM Studio staging copy does not match the exact clean source bundle", stagedSource.issues);
     }
@@ -966,12 +1065,12 @@ export async function runPmStudioSetup({
     if (staged.state !== "patched") {
       throw setupError("PM_STUDIO_STAGE_VERIFY_FAILED", "Patched PM Studio staging bundle failed verification", staged.issues);
     }
-    assertSigningMetadataPreserved(source, staged, recipe);
+    assertSigningMetadataPreserved(stagedSource, staged, recipe);
     writePatchedBinaryRecord({ backup, inspection: staged, operations, recipe });
 
     assertNoBlockingProcesses(operations, appPath);
     const unchangedSource = inspectPmStudioApp({ appPath, recipe, operations });
-    if (unchangedSource.state !== "clean"
+    if (unchangedSource.state !== source.state
       || unchangedSource.asar.asarSha256 !== source.asar.asarSha256
       || unchangedSource.asar.headerSha256 !== source.asar.headerSha256
       || (recipe.sourceBundleContent
@@ -989,12 +1088,17 @@ export async function runPmStudioSetup({
         `PM Studio replacement final state could not be verified. Do not launch it. ${recoveryMessage(backup)}${preserveStage ? ` Verified staging retained: ${stagePath}.` : ""}`);
     }
     if (installed.state !== "patched") {
-      preserveStage = installed.state !== "clean" && fs.existsSync(stagePath);
-      const code = installed.state === "clean"
+      const originalRetained = installed.state === source.state
+        && installed.asar.asarSha256 === source.asar.asarSha256
+        && installed.asar.headerSha256 === source.asar.headerSha256
+        && (!recipe.sourceBundleContent
+          || installed.bundleContent?.sha256 === source.bundleContent?.sha256);
+      preserveStage = !originalRetained && fs.existsSync(stagePath);
+      const code = originalRetained
         ? "PM_STUDIO_REPLACE_FAILED"
         : "PM_STUDIO_INSTALL_VERIFY_FAILED";
-      const stateMessage = installed.state === "clean"
-        ? "The installed PM Studio remains the verified clean bundle"
+      const stateMessage = originalRetained
+        ? `The installed PM Studio remains the verified ${source.state} bundle`
         : "The installed PM Studio did not retain the verified patched state; do not launch it";
       throw setupError(code,
         `${stateMessage}. ${recoveryMessage(backup)}${preserveStage ? ` Verified staging retained: ${stagePath}.` : ""}`,
@@ -1011,7 +1115,11 @@ export async function runPmStudioSetup({
       emit("[WARN] Atomic replacement reported an error after the exact patched bundle became installed; the final bundle was independently verified.");
     }
 
-    emit(`[OK] Patched PM Studio ${recipe.version} build ${recipe.build}.`);
+    emit(migratingLegacy
+      ? `[OK] Migrated PM Studio ${recipe.version} build ${recipe.build} from the legacy global-origin patch to the split-origin patch.`
+      : migratingPredecessor
+        ? `[OK] Migrated PM Studio ${recipe.version} build ${recipe.build} from the predecessor split-origin patch to the current split-origin patch.`
+        : `[OK] Patched PM Studio ${recipe.version} build ${recipe.build}.`);
     emit(`[OK] app.asar SHA-256: ${installed.asar.asarSha256}`);
     emit(`[OK] Verified backup: ${backup.backupAppPath}${backup.reused ? " (reused)" : ""}`);
     emit(`[OK] Backup manifest: ${backup.manifestPath}`);
@@ -1019,9 +1127,9 @@ export async function runPmStudioSetup({
     emit(`[INFO] Restore step 1/3: quit PM Studio and its updater.`);
     emit(`[INFO] Restore step 2/3: confirm the installed Info.plist still reports version/build ${recipe.version}/${recipe.build}; never restore this backup over another version.`);
     emit(`[INFO] Restore step 3/3: move ${appPath} aside, copy ${backup.backupAppPath} to that exact path, and verify its signature before launch.`);
-    emit(`[INFO] Start ${commandName} before opening PM Studio.`);
+    emit(`[INFO] Start ${commandName} before using Claude in PM Studio; GPT remains on PM Studio's native GitHub Copilot path.`);
     return {
-      status: "patched",
+      status: migratingExistingPatch ? "migrated" : "patched",
       changed: true,
       recipe: recipe.id,
       backup,

package/src/pm-studio-status.mjs

@@ -16,6 +16,11 @@ import {
   pmStudioPatchManifestPath,
 } from "./pm-studio-setup.mjs";
 import { readAdapterStatus } from "./cli-status.mjs";
+import {
+  PM_STUDIO_RELAY_MARKER_HEADER,
+  PM_STUDIO_RELAY_MARKER_VALUE,
+  PM_STUDIO_RELAY_PREFIX,
+} from "./pm-studio-relay.mjs";
 import { checkRunningAdapter } from "./running-adapter.mjs";
 import { status } from "./status.mjs";
 import {
@@ -27,12 +32,11 @@ import {
 
 const PM_RELAY_HOST = "127.0.0.1";
 const PM_RELAY_PORT = 2026;
-const PM_RELAY_CAPABILITY = "pm_studio_relay_v1";
+const PM_RELAY_PROBE_TIMEOUT_MS = 500;
+const PM_RELAY_CAPABILITY = "pm_studio_split_origin_v1";
 const PM_RELAY_ROUTE_NAMES = Object.freeze([
   "pm_models",
   "pm_chat_completions",
-  "pm_responses",
-  "pm_embeddings",
 ]);
 
 function selectRecipe(metadata, recipes) {
@@ -45,6 +49,31 @@ function safeMessage(error) {
   return String(error?.message || "inspection failed").replace(/\s+/g, " ").trim();
 }
 
+export async function probePmStudioRelay({
+  baseUrl,
+  fetchImpl = fetch,
+  timeoutMs = PM_RELAY_PROBE_TIMEOUT_MS,
+} = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(new URL(`${PM_STUDIO_RELAY_PREFIX}/models`, baseUrl).href, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      redirect: "error",
+      signal: controller.signal,
+    });
+    const result = {
+      status: response.status,
+      marker: response.headers.get(PM_STUDIO_RELAY_MARKER_HEADER) || "",
+    };
+    await response.body?.cancel().catch(() => {});
+    return result;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 function inspectClaudeProfile(home, readCredentials) {
   try {
     const credentials = readCredentials(AUTH_PROFILE_CLAUDE, { home });
@@ -73,7 +102,7 @@ function inspectAdapterRuntime(adapter, runtimeStatus) {
     issues.push("health and runtime status do not describe the same adapter instance");
   }
   const capabilities = new Set(Array.isArray(data.capabilities) ? data.capabilities : []);
-  if (!capabilities.has(PM_RELAY_CAPABILITY)) issues.push("PM Studio relay capability is missing");
+  if (!capabilities.has(PM_RELAY_CAPABILITY)) issues.push("PM Studio split-origin relay capability is missing");
   if (data.profiles?.claude?.mode !== "isolated") issues.push("Claude profile mode is not isolated");
   if (data.profiles?.claude?.profile_current !== true) {
     issues.push("running Claude credentials do not match the current isolated profile");
@@ -93,6 +122,21 @@ function inspectAdapterRuntime(adapter, runtimeStatus) {
   };
 }
 
+function inspectRelayProbe(runtime, probe) {
+  const relayProbe = {
+    status: probe?.status,
+    marker: String(probe?.marker || ""),
+  };
+  const issues = [...runtime.issues];
+  if (relayProbe.status !== 401) {
+    issues.push(`PM Studio relay probe returned HTTP ${relayProbe.status ?? "unknown"}; expected 401`);
+  }
+  if (relayProbe.marker !== PM_STUDIO_RELAY_MARKER_VALUE) {
+    issues.push("PM Studio relay compatibility marker is missing or incompatible");
+  }
+  return { ...runtime, relayProbe, ok: issues.length === 0, issues };
+}
+
 export async function inspectPmStudioStatus({
   appPath = DEFAULT_PM_STUDIO_APP_PATH,
   home = os.homedir(),
@@ -105,6 +149,7 @@ export async function inspectPmStudioStatus({
   readClaudeCredentials = readAuthProfileCredentials,
   checkRunningAdapterFn = checkRunningAdapter,
   readAdapterStatusFn = readAdapterStatus,
+  probePmStudioRelayFn = probePmStudioRelay,
 } = {}) {
   const operations = createPmStudioSetupOperations(operationOverrides);
   let app;
@@ -125,10 +170,15 @@ export async function inspectPmStudioStatus({
       const recipe = selectRecipe(normalized, recipes);
       if (recipe) {
         app = { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id };
-        if (app.state === "patched") {
+        if (["patched", "predecessor"].includes(app.state)) {
           const manifestPath = pmStudioPatchManifestPath({ home, backupRoot, recipe });
           try {
-            verifyPatchRecord({ inspection: app, manifestPath, recipe });
+            verifyPatchRecord({
+              inspection: app,
+              manifestPath,
+              recipe,
+              recordState: app.state,
+            });
             app.patchRecord = { valid: true, manifestPath, reason: "" };
           } catch (error) {
             const reason = safeMessage(error);
@@ -163,6 +213,18 @@ export async function inspectPmStudioStatus({
     } catch (error) {
       runtime = { ok: false, baseUrl: adapter.baseUrl, data: null, issues: [safeMessage(error)] };
     }
+    if (runtime.data) {
+      try {
+        runtime = inspectRelayProbe(runtime, await probePmStudioRelayFn({ baseUrl: adapter.baseUrl }));
+      } catch (error) {
+        runtime = {
+          ...runtime,
+          ok: false,
+          relayProbe: null,
+          issues: [...runtime.issues, `PM Studio relay probe failed: ${safeMessage(error)}`],
+        };
+      }
+    }
   }
   const operational = app.state === "patched"
     && app.patchRecord?.valid === true
@@ -182,6 +244,12 @@ function appStatusItem(result, commandName) {
     const reason = app.patchRecord?.reason || "installed patch record is missing";
     return { kind: "err", component: "App patch", detail: `${version}; patch record not verified`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}` };
   }
+  if (app.state === "predecessor" && app.patchRecord?.valid === true) {
+    return { kind: "warn", component: "App patch", detail: `${version}; verified predecessor split patch`, message: `PM Studio ${version} has a verified predecessor split patch; run ${commandName} pms setup to migrate` };
+  }
+  if (app.state === "legacy") {
+    return { kind: "err", component: "App patch", detail: `${version}; legacy global-origin patch`, message: `PM Studio ${version} has a legacy global-origin patch; run ${commandName} pms setup to migrate` };
+  }
   if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; supported, not patched`, message: `PM Studio ${version} is supported but not patched; run ${commandName} pms setup` };
   if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; unsupported version`, message: `PM Studio ${version} has no exact patch recipe; no files will be changed` };
   if (app.state === "drift" && app.patchRecipeMatched) {
@@ -203,7 +271,7 @@ function pmStudioStatusItems(result, commandName) {
     items.push({ kind: "err", component: "Claude profile", detail: "not ready", message: `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}` });
   }
   if (result.adapter?.ok && result.runtime?.ok) {
-    items.push({ kind: "ok", component: "PM relay", detail: `verified at ${result.adapter.baseUrl}`, message: `PM relay and isolated Claude routing are verified at ${result.adapter.baseUrl}` });
+    items.push({ kind: "ok", component: "PM relay", detail: `verified at ${result.adapter.baseUrl}`, message: `PM model discovery and isolated Claude routing are verified at ${result.adapter.baseUrl}` });
   } else if (result.adapter?.ok) {
     const reason = result.runtime?.issues?.join("; ") || "runtime status is unavailable";
     items.push({ kind: "err", component: "PM relay", detail: "running but routing not ready", message: `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start` });
@@ -213,9 +281,9 @@ function pmStudioStatusItems(result, commandName) {
     items.push({ kind: "warn", component: "PM relay", detail: `not running at ${PM_RELAY_HOST}:${PM_RELAY_PORT}`, message: `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start` });
   }
   if (result.runtime?.ok) {
-    items.push({ kind: "info", component: "Routing", detail: "GPT -> PM bearer; Claude -> isolated profile", message: "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
+    items.push({ kind: "info", component: "Routing", detail: "GPT -> native official; models/Claude -> local", message: "Routing: PM GPT uses its native official GitHub Copilot path; model discovery and eligible Claude chat use the local CCDX relay" });
   } else {
-    items.push({ kind: "info", component: "Routing", detail: "expected: GPT -> PM bearer; Claude -> isolated profile", message: "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
+    items.push({ kind: "info", component: "Routing", detail: "expected: GPT -> native official; models/Claude -> local", message: "Expected routing: PM GPT uses its native official GitHub Copilot path; model discovery and eligible Claude chat use the local CCDX relay" });
   }
   return items;
 }

package/src/responses-request.mjs

@@ -65,9 +65,21 @@ function replayableResponsesOutputItems(output) {
   return output.filter((item) => item && typeof item === "object");
 }
 
+function isEncryptedContentPart(value) {
+  return value && typeof value === "object" && value.type === "encrypted_content";
+}
+
 function stripEncryptedReasoningValue(value, state) {
   if (Array.isArray(value)) {
-    return value.map((item) => stripEncryptedReasoningValue(item, state));
+    const out = [];
+    for (const item of value) {
+      if (isEncryptedContentPart(item)) {
+        state.changed = true;
+        continue;
+      }
+      out.push(stripEncryptedReasoningValue(item, state));
+    }
+    return out;
   }
 
   if (value && typeof value === "object") {
@@ -87,7 +99,9 @@ function stripEncryptedReasoningValue(value, state) {
 
 function isEncryptedReasoningInputItem(item) {
   return item && typeof item === "object"
-    && (item.type === "reasoning" || Object.prototype.hasOwnProperty.call(item, "encrypted_content"));
+    && (item.type === "reasoning"
+      || item.type === "encrypted_content"
+      || Object.prototype.hasOwnProperty.call(item, "encrypted_content"));
 }
 
 export function sanitizeEncryptedReasoningRequest(reqContext) {

package/src/running-adapter.mjs

@@ -5,7 +5,9 @@ export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
 export const ADAPTER_STATUS_PATH = "/_ccdx/status";
 export const ADAPTER_PROTOCOL_VERSION = 2;
 export const ADAPTER_VERSION = localPackageVersion();
-export const ADAPTER_CAPABILITIES = Object.freeze(["pm_studio_relay_v1"]);
+export const ADAPTER_CAPABILITIES = Object.freeze([
+  "pm_studio_split_origin_v1",
+]);
 const ADAPTER_INSTANCE_ID = randomUUID();
 
 export function adapterHealthPayload() {