codex-copilot-dx 0.6.7 → 0.6.8

package/README.md

@@ -116,9 +116,11 @@ 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.
 
-The current patch recipe supports only an exact, unmodified PM Studio 2.9.7 bundle on
-macOS. Authorize the isolated Claude profile first, quit PM Studio and its
-updater, then run the one-time setup command:
+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:
+2.9.11 and other unknown builds remain unsupported until they receive their own
+verified recipe. 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>
@@ -145,22 +147,31 @@ does not attempt a second automatic write: it preserves the verified backup,
 retains any diagnostic stage still present, and prints recovery paths. Repeating
 setup for the exact installed recipe is idempotent.
 
+The official 2.9.10 artifact can fail macOS's vendor-signature verifier even
+though its signing metadata remains readable. CCDX does not generally ignore
+that failure: the 2.9.10 exception is accepted only when the complete App tree,
+including every file, mode, symlink, and non-volatile extended attribute,
+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 PM 2.9.7 Copilot paths discovered in the
-validated bundle (`GET /models` and `POST /chat/completions`, `/responses`, and
+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.
 
 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
 require reinstalling the official App. Setup prints the verified backup and
 manifest paths plus the version-matched restore procedure. Never restore a
-2.9.7 backup over a newer PM Studio installation.
+backup over a different PM Studio version or build.
 
 To restore, first quit PM Studio and its updater. Use the exact verified backup
 path printed by setup as `BACKUP_APP`, then confirm that both the installed App
-and backup still report version/build `2.9.7/2.9.7`:
+and backup still report the same version/build printed by setup (`2.9.7/2.9.7`
+or `2.9.10/2.9.10`):
 
 ```bash
 BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
@@ -170,8 +181,8 @@ BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
 /usr/bin/plutil -extract CFBundleVersion raw -o - "$BACKUP_APP/Contents/Info.plist"
 ```
 
-Only when all four values match `2.9.7`, move the patched App aside, restore the
-complete vendor-signed backup, and verify it before launch:
+Only when all four values match the one exact recipe, move the patched App
+aside, restore the complete vendor bundle, and verify it before launch:
 
 ```bash
 RECOVERY_DIR="$(/usr/bin/mktemp -d '/Applications/CCDX-PM-Studio-recovery.XXXXXX')"
@@ -179,12 +190,16 @@ PATCHED_APP="$RECOVERY_DIR/PM Studio.app"
 mv "/Applications/PM Studio.app" "$PATCHED_APP"
 /usr/bin/ditto --rsrc --extattr --acl "$BACKUP_APP" "/Applications/PM Studio.app"
 /usr/bin/codesign --verify --deep --strict --verbose=2 "/Applications/PM Studio.app"
+ccdx pms status
 ```
 
-If the version check, copy, or signature verification 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 2.9.7 backup to unknown content. CCDX never runs these
-restore commands or `sudo` automatically.
+For 2.9.10, the vendor `codesign` command may report the documented upstream
+signature failure; in that case the App-patch row from `ccdx pms status` must
+still classify the restored bundle as exact supported clean content rather than
+integrity drift. If the version check, copy, or both verification paths fail,
+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
+backup. CCDX never runs these restore commands or `sudo` automatically.
 
 To change the model used by Codex Auto-review, run:
 

package/package.json

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

package/src/config.mjs

@@ -6,6 +6,20 @@ import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
 import { adapterBaseUrl } from "./running-adapter.mjs";
 
 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 setTopLevelTomlDefault(lines, key, value) {
+  let end = lines.findIndex((line) => /^\s*\[[^\]]+\]\s*$/.test(line));
+  if (end === -1) end = lines.length;
+
+  const keyRe = new RegExp(`^\\s*${key}\\s*=`);
+  if (lines.slice(0, end).some((line) => keyRe.test(line))) return false;
+
+  while (end > 0 && lines[end - 1].trim() === "") end--;
+  lines.splice(end, 0, `${key} = ${value}`);
+  return true;
+}
 
 function setTomlKey(lines, sectionName, key, value) {
   const sectionLine = `[${sectionName}]`;
@@ -52,6 +66,8 @@ export function computeUpdatedCodexConfig(content, adapterPort = 2026, adapterHo
     changed = true;
   }
 
+  changed = setTopLevelTomlDefault(lines, "model_context_window", MODEL_CONTEXT_WINDOW) || changed;
+  changed = setTopLevelTomlDefault(lines, "model_auto_compact_token_limit", MODEL_AUTO_COMPACT_TOKEN_LIMIT) || changed;
   changed = setTomlKey(lines, "shell_environment_policy.set", "ANTHROPIC_AUTH_TOKEN", "dummy") || changed;
   changed = setTomlKey(lines, "shell_environment_policy.set", "ANTHROPIC_BASE_URL", anthropicBaseUrl) || changed;
   changed = setTomlKey(lines, "shell_environment_policy.set", "OPENAI_BASE_URL", baseUrl) || changed;
@@ -64,6 +80,8 @@ function initialCodexConfig(adapterPort, adapterHost) {
   const anthropicBaseUrl = adapterBaseUrl(adapterHost, adapterPort);
   const baseUrl = `${anthropicBaseUrl}/v1`;
   return `openai_base_url = "${baseUrl}"
+model_context_window = ${MODEL_CONTEXT_WINDOW}
+model_auto_compact_token_limit = ${MODEL_AUTO_COMPACT_TOKEN_LIMIT}
 
 [shell_environment_policy]
 inherit = "core"

package/src/pm-studio-asar.mjs

@@ -67,7 +67,106 @@ export const PM_STUDIO_2_9_7_RECIPE = Object.freeze({
   ]),
 });
 
-export const PM_STUDIO_RECIPES = Object.freeze([PM_STUDIO_2_9_7_RECIPE]);
+export const PM_STUDIO_2_9_10_RECIPE = Object.freeze({
+  id: "pm-studio-2.9.10-build-2.9.10",
+  version: "2.9.10",
+  build: "2.9.10",
+  bundleIdentifier: "com.pm-studio.app",
+  sourceTeamIdentifier: "HL75GKK4W4",
+  sourceArtifact: Object.freeze({
+    releaseUrl: "https://github.com/gim-home/max-studio/releases/tag/v2.9.10",
+    asset: "PM-Studio-2.9.10-mac-arm64.zip",
+    sha256: "85654e6ed173ce2565b5ef3694137de2c5f92eba1b749316c9e5b63181ccc3b0",
+  }),
+  sourceBundleContent: Object.freeze({
+    scheme: "ccdx-bundle-content-v2",
+    sha256: "478ca7f1f0826b07b7706fd1f410dee01b6dbaae21c40c63ecbdc0942eab63d9",
+    entryCount: 1_521,
+    regularFileCount: 1_013,
+    regularBytes: 494_995_602,
+    symlinkCount: 14,
+    xattrCount: 735,
+    ignoredXattrs: Object.freeze([
+      "com.apple.macl",
+      "com.apple.provenance",
+      "com.apple.quarantine",
+    ]),
+  }),
+  sourceCodeSignature: Object.freeze({
+    identifier: "com.pm-studio.app",
+    teamIdentifier: "HL75GKK4W4",
+    flags: "0x10000(runtime)",
+    runtimeVersion: "26.0.0",
+    cdHashFull: "86a4d64946123d21d20918041e88f58e8c497ce1a1f75a9f9d8cd592ce86e158",
+    notarizationTicket: "stapled",
+  }),
+  patchedSigningMetadata: Object.freeze({
+    identifier: "com.pm-studio.app",
+    flags: "0x10002(adhoc,runtime)",
+    runtime_version: "26.0.0",
+    entitlements_sha256: "9d4ccbda4fe0c81a70df3db93b3e61fe0500f67f14cdcbee4dea230e6512d05c",
+  }),
+  executable: "PM Studio",
+  sourceExecutableSha256: "a38f2054abb9770ba35d054d447be0de8e7c9d4fed6b37486bf15cf28de1e122",
+  electronFrameworkPath: "Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework",
+  sourceElectronFrameworkSha256: "a562a31f8f8d14440974466e5e611b19d93705dcf3ca2f57647578ffc002f5b4",
+  embeddedAsarIntegrity: "absent",
+  asarPath: "Contents/Resources/app.asar",
+  infoPlistPath: "Contents/Info.plist",
+  integrityKey: "ElectronAsarIntegrity.Resources/app.asar",
+  dataOffset: 3_833_292,
+  sourceAsarSha256: "d243860770e8b1d8044213924f9704d1fc52f900d6c33461eff6358962330b78",
+  sourceHeaderSha256: "5fc77d5b61e9647fba10fd2bd5752d0889c14da5a00b21d31bc48fdcccf74a69",
+  patchedAsarSha256: "49f72d999a6085102341c2d551577e164db6f22e4707d2112efa3fd280e7315e",
+  patchedHeaderSha256: "b264ece5b8e469cd3885a7a91f904f1902e1991f214ecbf228dfe91059ac7008",
+  sourceSentinel: PM_STUDIO_ORIGIN,
+  patchedSentinel: CCDX_PM_STUDIO_ORIGIN,
+  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",
+      sourceBlocks: Object.freeze([
+        "3910a9bc5459f493956aafee7b3644e8d242027758f0dcdea97d7c10a324c6bf",
+        "49fa64c68425d35b1baff0d5745d856d377e014a7a7829322cd1b39aade9532e",
+        "bd7cc14a1d2e02abe66c0ec6fc4e97b263cfc1f67c4ae39e956c06d3bcc2fe67",
+      ]),
+      patchedBlocks: Object.freeze([
+        "74022f5ad06c7879b37875efe0a090b23ccfbcf269afd26b10b77690413dca63",
+        "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",
+      ]),
+    }),
+  ]),
+});
+
+export const PM_STUDIO_RECIPES = Object.freeze([
+  PM_STUDIO_2_9_7_RECIPE,
+  PM_STUDIO_2_9_10_RECIPE,
+]);
 
 export function sha256Hex(value) {
   return createHash("sha256").update(value).digest("hex");

package/src/pm-studio-setup.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
   AUTH_PROFILE_CLAUDE,
@@ -19,6 +19,7 @@ import {
 export const DEFAULT_PM_STUDIO_APP_PATH = "/Applications/PM Studio.app";
 export const PM_STUDIO_CLAUDE_AUTH_COMMAND = "ccdx auth login claude --reauth --github-login <personal-login>";
 const MIN_FREE_MARGIN_BYTES = 16 * 1024 * 1024;
+const BUNDLE_CONTENT_SCHEME = "ccdx-bundle-content-v2";
 
 function setupError(code, message, details) {
   const error = new Error(message);
@@ -31,7 +32,7 @@ function defaultProcessRunner(command, args) {
   return spawnSync(command, args, {
     encoding: "utf8",
     windowsHide: true,
-    maxBuffer: 8 * 1024 * 1024,
+    maxBuffer: 32 * 1024 * 1024,
   });
 }
 
@@ -53,6 +54,166 @@ function runChecked(processRunner, command, args, label) {
   return result;
 }
 
+function hashRegularFile(filePath, expected) {
+  const hash = createHash("sha256");
+  const file = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  try {
+    const before = fs.fstatSync(file, { bigint: true });
+    if (before.dev !== BigInt(expected.dev)
+      || before.ino !== BigInt(expected.ino)
+      || before.size !== BigInt(expected.size)) {
+      throw setupError("PM_STUDIO_BUNDLE_CHANGED", `PM Studio bundle changed while reading ${filePath}`);
+    }
+    for (;;) {
+      const length = fs.readSync(file, buffer, 0, buffer.length, null);
+      if (length === 0) break;
+      hash.update(buffer.subarray(0, length));
+    }
+    const after = fs.fstatSync(file, { bigint: true });
+    if (before.dev !== after.dev
+      || before.ino !== after.ino
+      || before.size !== after.size
+      || before.mtimeNs !== after.mtimeNs
+      || before.ctimeNs !== after.ctimeNs) {
+      throw setupError("PM_STUDIO_BUNDLE_CHANGED", `PM Studio bundle changed while hashing ${filePath}`);
+    }
+  } finally {
+    fs.closeSync(file);
+  }
+  return hash.digest("hex");
+}
+
+function parseXattrHex(output, root, ignoredXattrs) {
+  const records = [];
+  const ignored = new Set(ignoredXattrs);
+  const seen = new Set();
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    if (!ignored.has(current.name)) {
+      const key = `${current.path}\0${current.name}`;
+      if (seen.has(key)) throw setupError("PM_STUDIO_XATTR_INVALID", `Duplicate extended attribute ${current.name}`);
+      seen.add(key);
+      const value = Buffer.from(current.hex.join(""), "hex");
+      records.push(["xattr", current.path, current.name, value.length, sha256Hex(value)]);
+    }
+    current = null;
+  };
+
+  for (const line of String(output || "").split(/\r?\n/)) {
+    if (!line) continue;
+    const separator = line.lastIndexOf(": ");
+    if ((line === `${root}:` || line.startsWith(`${root}: `) || line.startsWith(`${root}${path.sep}`))
+      && separator >= root.length && line.endsWith(":")) {
+      flush();
+      const target = line.slice(0, separator);
+      const relative = target === root ? "." : path.relative(root, target).split(path.sep).join("/");
+      if (!relative || relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) {
+        throw setupError("PM_STUDIO_XATTR_INVALID", `Extended attribute path escapes PM Studio: ${target}`);
+      }
+      current = { path: relative, name: line.slice(separator + 2, -1), hex: [] };
+      continue;
+    }
+    if (!current) throw setupError("PM_STUDIO_XATTR_INVALID", "Could not parse PM Studio extended attributes");
+    const data = line.includes("  |") ? line.slice(0, line.indexOf("  |")) : line;
+    const tokens = data.trim().split(/\s+/);
+    if (!/^[0-9a-f]{8}$/i.test(tokens[0]) || tokens.slice(1).some((token) => !/^[0-9a-f]{2}$/i.test(token))) {
+      throw setupError("PM_STUDIO_XATTR_INVALID", "Could not parse PM Studio extended attribute bytes");
+    }
+    current.hex.push(...tokens.slice(1));
+  }
+  flush();
+  return records.sort((left, right) => Buffer.compare(
+    Buffer.from(`${left[1]}\0${left[2]}`),
+    Buffer.from(`${right[1]}\0${right[2]}`),
+  ));
+}
+
+export function inspectBundleContent(appPath, {
+  xattrOutput = "",
+  ignoredXattrs = [],
+} = {}) {
+  const root = path.resolve(appPath);
+  const rootStat = fs.lstatSync(root);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+    throw setupError("PM_STUDIO_APP_INVALID", `PM Studio path is not a regular app bundle: ${appPath}`);
+  }
+  const records = [];
+  const normalizedPaths = new Map();
+  let regularFileCount = 0;
+  let regularBytes = 0;
+  let symlinkCount = 0;
+
+  const rememberPath = (relative) => {
+    const normalized = relative.normalize("NFC");
+    const existing = normalizedPaths.get(normalized);
+    if (existing && existing !== relative) {
+      throw setupError("PM_STUDIO_BUNDLE_PATH_COLLISION", `PM Studio contains colliding paths: ${existing} and ${relative}`);
+    }
+    normalizedPaths.set(normalized, relative);
+  };
+  rememberPath(".");
+  records.push(["directory", ".", rootStat.mode & 0o7777]);
+  const visit = (directory) => {
+    const names = fs.readdirSync(directory).sort((left, right) =>
+      Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    for (const name of names) {
+      const fullPath = path.join(directory, name);
+      const stat = fs.lstatSync(fullPath);
+      const relative = path.relative(root, fullPath).split(path.sep).join("/");
+      const mode = stat.mode & 0o7777;
+      rememberPath(relative);
+      if (stat.isDirectory() && !stat.isSymbolicLink()) {
+        records.push(["directory", relative, mode]);
+        visit(fullPath);
+      } else if (stat.isSymbolicLink()) {
+        const target = fs.readlinkSync(fullPath);
+        const resolved = path.resolve(path.dirname(fullPath), target);
+        if (path.isAbsolute(target)
+          || (resolved !== root && !resolved.startsWith(`${root}${path.sep}`))
+          || !fs.existsSync(resolved)) {
+          throw setupError("PM_STUDIO_BUNDLE_SYMLINK_INVALID", `PM Studio contains an unsafe symlink: ${relative}`);
+        }
+        symlinkCount += 1;
+        records.push(["symlink", relative, mode, target]);
+      } else if (stat.isFile()) {
+        if (stat.nlink !== 1) {
+          throw setupError("PM_STUDIO_BUNDLE_HARDLINK_INVALID", `PM Studio contains a hard-linked file: ${relative}`);
+        }
+        regularFileCount += 1;
+        regularBytes += stat.size;
+        records.push(["file", relative, mode, stat.size, hashRegularFile(fullPath, stat)]);
+      } else {
+        throw setupError("PM_STUDIO_BUNDLE_ENTRY_INVALID", `PM Studio contains an unsupported entry: ${relative}`);
+      }
+    }
+  };
+  visit(root);
+
+  const xattrRecords = parseXattrHex(xattrOutput, root, ignoredXattrs);
+  const hash = createHash("sha256");
+  for (const record of [...records, ...xattrRecords]) hash.update(`${JSON.stringify(record)}\n`);
+  return {
+    scheme: BUNDLE_CONTENT_SCHEME,
+    sha256: hash.digest("hex"),
+    entryCount: records.length,
+    regularFileCount,
+    regularBytes,
+    symlinkCount,
+    xattrCount: xattrRecords.length,
+  };
+}
+
+function defaultInspectBundleContent({ appPath, recipe, processRunner }) {
+  const xattrs = runChecked(processRunner, "/usr/bin/xattr", ["-r", "-s", "-x", "-l", appPath],
+    "Reading PM Studio extended attributes");
+  return inspectBundleContent(appPath, {
+    xattrOutput: xattrs.stdout,
+    ignoredXattrs: recipe.sourceBundleContent?.ignoredXattrs || [],
+  });
+}
+
 function plistRead(processRunner, plistPath, key) {
   return runChecked(processRunner, "/usr/bin/plutil", ["-extract", key, "raw", "-o", "-", plistPath],
     `Reading ${path.basename(plistPath)}`).stdout.trim();
@@ -91,30 +252,39 @@ function defaultInspectCodeSign({ appPath, processRunner }) {
   const verify = normalizedProcessResult(processRunner("/usr/bin/codesign", [
     "--verify", "--deep", "--strict", "--verbose=2", appPath,
   ]));
-  if (verify.error || verify.status !== 0) return { valid: false, adHoc: false };
   const display = normalizedProcessResult(processRunner("/usr/bin/codesign", [
     "--display", "--verbose=4", appPath,
   ]));
-  if (display.error || display.status !== 0) return { valid: false, adHoc: false };
   const details = `${display.stdout}\n${display.stderr}`;
   const entitlementsResult = normalizedProcessResult(processRunner("/usr/bin/codesign", [
     "--display", "--entitlements", "-", "--xml", appPath,
   ]));
-  if (entitlementsResult.error || entitlementsResult.status !== 0) return { valid: false, adHoc: false };
   const entitlementOutput = `${entitlementsResult.stdout}\n${entitlementsResult.stderr}`;
   const plistStart = entitlementOutput.indexOf("<?xml");
   const plistEnd = entitlementOutput.lastIndexOf("</plist>");
-  if (plistStart < 0 || plistEnd < plistStart) return { valid: false, adHoc: false };
-  const entitlements = entitlementOutput.slice(plistStart, plistEnd + "</plist>".length);
+  const hasEntitlements = plistStart >= 0 && plistEnd >= plistStart;
+  const entitlements = hasEntitlements
+    ? entitlementOutput.slice(plistStart, plistEnd + "</plist>".length)
+    : "";
   return {
-    valid: true,
+    valid: !verify.error && verify.status === 0
+      && !display.error && display.status === 0
+      && !entitlementsResult.error && entitlementsResult.status === 0
+      && hasEntitlements,
+    verifyValid: !verify.error && verify.status === 0,
+    displayValid: !display.error && display.status === 0,
+    entitlementsState: hasEntitlements
+      ? "xml"
+      : /invalid entitlements blob/i.test(entitlementOutput) ? "invalid" : "unavailable",
     adHoc: /(?:^|\n)Signature=adhoc(?:\n|$)/i.test(details)
       || /(?:^|\n)TeamIdentifier=not set(?:\n|$)/i.test(details),
     identifier: details.match(/(?:^|\n)Identifier=([^\n]+)/)?.[1]?.trim() || "",
     teamIdentifier: details.match(/(?:^|\n)TeamIdentifier=([^\n]+)/)?.[1]?.trim() || "",
     flags: details.match(/\bflags=([^\s]+)/)?.[1] || "",
     runtimeVersion: details.match(/(?:^|\n)Runtime Version=([^\n]+)/)?.[1]?.trim() || "",
-    entitlementsSha256: sha256Hex(entitlements),
+    cdHashFull: details.match(/(?:^|\n)CandidateCDHashFull sha256=([0-9a-f]+)/i)?.[1]?.toLowerCase() || "",
+    notarizationTicket: details.match(/(?:^|\n)Notarization Ticket=([^\n]+)/)?.[1]?.trim() || "",
+    entitlementsSha256: hasEntitlements ? sha256Hex(entitlements) : "",
   };
 }
 
@@ -240,6 +410,7 @@ export function createPmStudioSetupOperations(overrides = {}) {
     readAsarIntegrity: defaultReadAsarIntegrity,
     writeAsarIntegrity: defaultWriteAsarIntegrity,
     inspectCodeSign: defaultInspectCodeSign,
+    inspectBundleContent: defaultInspectBundleContent,
     inspectExecutableIntegrity: defaultInspectExecutableIntegrity,
     signApp: defaultSignApp,
     listBlockingProcesses: defaultListBlockingProcesses,
@@ -271,12 +442,34 @@ function integrityMatches(actual, algorithm, hash) {
   return actual?.algorithm === algorithm && actual?.hash === hash;
 }
 
+function bundleContentMatches(actual, expected) {
+  return actual?.scheme === expected?.scheme
+    && actual?.sha256 === expected?.sha256
+    && actual?.entryCount === expected?.entryCount
+    && actual?.regularFileCount === expected?.regularFileCount
+    && actual?.regularBytes === expected?.regularBytes
+    && actual?.symlinkCount === expected?.symlinkCount
+    && actual?.xattrCount === expected?.xattrCount;
+}
+
+function sourceCodeSignatureMatches(actual, expected) {
+  return actual?.adHoc === false
+    && actual?.displayValid === true
+    && actual?.identifier === expected?.identifier
+    && actual?.teamIdentifier === expected?.teamIdentifier
+    && actual?.flags === expected?.flags
+    && actual?.runtimeVersion === expected?.runtimeVersion
+    && actual?.cdHashFull === expected?.cdHashFull
+    && actual?.notarizationTicket === expected?.notarizationTicket;
+}
+
 export function inspectPmStudioApp({
   appPath,
   recipe = PM_STUDIO_2_9_7_RECIPE,
   operations = createPmStudioSetupOperations(),
 } = {}) {
   const paths = appPaths(appPath, recipe);
+  const issues = [];
   const metadata = operations.readBundleMetadata({ ...paths, recipe, processRunner: operations.processRunner });
   const asar = inspectAsarBuffer(fs.readFileSync(paths.asarPath), recipe);
   const plistIntegrity = operations.readAsarIntegrity({ ...paths, recipe, processRunner: operations.processRunner });
@@ -284,7 +477,16 @@ export function inspectPmStudioApp({
     ...paths, recipe, processRunner: operations.processRunner,
   });
   const codeSign = operations.inspectCodeSign({ ...paths, recipe, processRunner: operations.processRunner });
-  const issues = [];
+  let bundleContent = null;
+  if (recipe.sourceBundleContent) {
+    try {
+      bundleContent = operations.inspectBundleContent({
+        ...paths, recipe, processRunner: operations.processRunner,
+      });
+    } catch (error) {
+      issues.push(`bundle content inspection failed: ${error.message}`);
+    }
+  }
 
   if (String(metadata.version) !== recipe.version) {
     issues.push(`version is ${metadata.version}, expected ${recipe.version}`);
@@ -301,19 +503,33 @@ export function inspectPmStudioApp({
     issues.push("Electron Framework has an unsupported embedded ASAR integrity slot");
   }
 
+  const exactSourceBundle = !recipe.sourceBundleContent
+    || bundleContentMatches(bundleContent, recipe.sourceBundleContent);
+  const strictVendorSignature = codeSign?.valid === true
+    && codeSign?.adHoc === false
+    && codeSign?.teamIdentifier === recipe.sourceTeamIdentifier;
+  const exactInvalidVendorSignature = recipe.sourceBundleContent
+    && exactSourceBundle
+    && codeSign?.valid === false
+    && codeSign?.verifyValid === false
+    && codeSign?.entitlementsState === "invalid"
+    && sourceCodeSignatureMatches(codeSign, recipe.sourceCodeSignature);
+  const sourceSignatureAccepted = strictVendorSignature || exactInvalidVendorSignature;
+  const patchedSignatureAccepted = codeSign?.valid === true
+    && codeSign?.adHoc === true
+    && (!recipe.patchedSigningMetadata
+      || JSON.stringify(signingMetadata(codeSign)) === JSON.stringify(recipe.patchedSigningMetadata));
   const clean = issues.length === 0
     && asar.state === "clean"
     && integrityMatches(plistIntegrity, "SHA256", recipe.sourceHeaderSha256)
     && executableIntegrity.executableSha256 === recipe.sourceExecutableSha256
     && executableIntegrity.frameworkSha256 === recipe.sourceElectronFrameworkSha256
-    && codeSign?.valid === true
-    && codeSign?.adHoc === false
-    && codeSign?.teamIdentifier === recipe.sourceTeamIdentifier;
+    && exactSourceBundle
+    && sourceSignatureAccepted;
   const patched = issues.length === 0
     && asar.state === "patched"
     && integrityMatches(plistIntegrity, "SHA256", recipe.patchedHeaderSha256)
-    && codeSign?.valid === true
-    && codeSign?.adHoc === true;
+    && patchedSignatureAccepted;
 
   if (!clean && !patched) {
     if (asar.state === "drift") issues.push("app.asar is unknown drift");
@@ -324,7 +540,12 @@ export function inspectPmStudioApp({
       && !integrityMatches(plistIntegrity, "SHA256", recipe.patchedHeaderSha256)) {
       issues.push("patched ASAR does not match ElectronAsarIntegrity");
     }
-    if (!codeSign?.valid) issues.push("codesign verification failed");
+    if (asar.state === "clean" && recipe.sourceBundleContent && !exactSourceBundle) {
+      issues.push("bundle content does not match the exact clean recipe");
+    }
+    if (!codeSign?.valid && !(asar.state === "clean" && exactInvalidVendorSignature)) {
+      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 (asar.state === "clean" && codeSign.teamIdentifier !== recipe.sourceTeamIdentifier) {
@@ -338,6 +559,11 @@ 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
+      && recipe.patchedSigningMetadata
+      && !patchedSignatureAccepted) {
+      issues.push("patched bundle signing metadata does not match the recipe");
+    }
   }
 
   return {
@@ -351,6 +577,10 @@ export function inspectPmStudioApp({
     plistIntegrity,
     executableIntegrity,
     codeSign,
+    bundleContent,
+    sourceVerification: clean
+      ? exactInvalidVendorSignature ? "exact-bundle-content" : "codesign"
+      : "",
     paths,
     issues,
   };
@@ -393,7 +623,8 @@ function selectRecipe(metadata, recipes) {
 }
 
 function backupName(recipe) {
-  return `${recipe.id}-${recipe.sourceAsarSha256.slice(0, 12)}`;
+  const sourceHash = recipe.sourceBundleContent?.sha256 || recipe.sourceAsarSha256;
+  return `${recipe.id}-${sourceHash.slice(0, 12)}`;
 }
 
 export function pmStudioBackupRoot(home = os.homedir()) {
@@ -411,7 +642,7 @@ export function pmStudioPatchManifestPath({
 
 function backupManifest(recipe, createdAt) {
   return {
-    schema_version: 1,
+    schema_version: recipe.sourceBundleContent ? 2 : 1,
     kind: "ccdx-pm-studio-backup",
     recipe_id: recipe.id,
     created_at: createdAt.toISOString(),
@@ -430,12 +661,15 @@ function backupManifest(recipe, createdAt) {
         electron_framework_sha256: recipe.sourceElectronFrameworkSha256,
         embedded_asar_integrity: recipe.embeddedAsarIntegrity,
       },
+      ...(recipe.sourceBundleContent ? { bundle_content: recipe.sourceBundleContent } : {}),
+      ...(recipe.sourceArtifact ? { artifact: recipe.sourceArtifact } : {}),
     },
     patched: {
       asar_sha256: recipe.patchedAsarSha256,
       asar_header_sha256: recipe.patchedHeaderSha256,
       electron_asar_integrity: { algorithm: "SHA256", hash: recipe.patchedHeaderSha256 },
       binaries: null,
+      ...(recipe.sourceBundleContent ? { bundle_content: null } : {}),
     },
     backup_bundle: "PM Studio.app",
     restore_rule: `Restore only while the installed app is PM Studio ${recipe.version} build ${recipe.build}.`,
@@ -451,7 +685,9 @@ function validateBackup({ backupDir, recipe, operations }) {
   } catch {
     throw setupError("PM_STUDIO_BACKUP_INVALID", `Existing PM Studio backup manifest is invalid: ${manifestPath}`);
   }
-  if (manifest?.kind !== "ccdx-pm-studio-backup"
+  const expectedSchema = recipe.sourceBundleContent ? 2 : 1;
+  if (manifest?.schema_version !== expectedSchema
+    || manifest?.kind !== "ccdx-pm-studio-backup"
     || manifest?.recipe_id !== recipe.id
     || manifest?.app?.bundle_identifier !== recipe.bundleIdentifier
     || manifest?.app?.version !== recipe.version
@@ -462,6 +698,10 @@ function validateBackup({ backupDir, recipe, operations }) {
     || manifest?.source?.binaries?.main_executable_sha256 !== recipe.sourceExecutableSha256
     || manifest?.source?.binaries?.electron_framework_sha256 !== recipe.sourceElectronFrameworkSha256
     || manifest?.source?.binaries?.embedded_asar_integrity !== recipe.embeddedAsarIntegrity
+    || (recipe.sourceBundleContent
+      && 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)) {
@@ -508,13 +748,14 @@ function ensureBackup({ appPath, backupRoot, recipe, operations }) {
   }
 }
 
-function writePatchedBinaryRecord({ backup, inspection, 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,
   };
   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 });
@@ -532,12 +773,24 @@ export function assertPatchedBinaryRecord({ inspection, manifestPath, recipe })
   } catch {
     throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", "PM Studio patched-binary record is missing or invalid");
   }
-  if (recipe && (manifest?.schema_version !== 1
+  const expectedSchema = recipe?.sourceBundleContent ? 2 : 1;
+  if (recipe && (manifest?.schema_version !== expectedSchema
     || manifest?.kind !== "ccdx-pm-studio-backup"
     || manifest?.recipe_id !== recipe.id
     || manifest?.app?.bundle_identifier !== recipe.bundleIdentifier
     || manifest?.app?.version !== recipe.version
     || manifest?.app?.build !== recipe.build
+    || (recipe.sourceBundleContent && (
+      manifest?.source?.asar_sha256 !== recipe.sourceAsarSha256
+      || manifest?.source?.asar_header_sha256 !== recipe.sourceHeaderSha256
+      || !integrityMatches(manifest?.source?.electron_asar_integrity, "SHA256", recipe.sourceHeaderSha256)
+      || manifest?.source?.binaries?.main_executable_sha256 !== recipe.sourceExecutableSha256
+      || manifest?.source?.binaries?.electron_framework_sha256 !== recipe.sourceElectronFrameworkSha256
+      || manifest?.source?.binaries?.embedded_asar_integrity !== recipe.embeddedAsarIntegrity
+      || 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))) {
@@ -552,6 +805,10 @@ export function assertPatchedBinaryRecord({ inspection, manifestPath, recipe })
   if (JSON.stringify(manifest?.patched?.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)) {
+    throw setupError("PM_STUDIO_BUNDLE_DRIFT", "PM Studio bundle content differs from the installed patch record");
+  }
 }
 
 function signingMetadata(codeSign) {
@@ -570,7 +827,15 @@ function flagsWithoutAdHoc(value) {
   return `0x${(BigInt(`0x${match[1]}`) & ~2n).toString(16)}`;
 }
 
-function assertSigningMetadataPreserved(source, staged) {
+function assertSigningMetadataPreserved(source, staged, recipe) {
+  if (recipe.patchedSigningMetadata) {
+    if (JSON.stringify(signingMetadata(staged.codeSign))
+      !== JSON.stringify(recipe.patchedSigningMetadata)) {
+      throw setupError("PM_STUDIO_SIGNING_METADATA_CHANGED",
+        "Ad-hoc signing did not produce the exact PM Studio signing metadata required by the recipe");
+    }
+    return;
+  }
   const before = signingMetadata(source.codeSign);
   const after = signingMetadata(staged.codeSign);
   before.flags = flagsWithoutAdHoc(before.flags);
@@ -665,6 +930,10 @@ export async function runPmStudioSetup({
       `PM Studio ${recipe.version} build ${recipe.build} does not match the clean or patched recipe; no files were changed`, source.issues);
   }
 
+  if (source.sourceVerification === "exact-bundle-content") {
+    emit(`[WARN] macOS rejected the vendor signature; setup accepted only the exact PM Studio ${recipe.version} official bundle content fingerprint.`);
+  }
+
   const backupExists = fs.existsSync(finalBackupDir);
   assertSpace({ appPath, backupRoot, backupExists, operations });
 
@@ -674,6 +943,12 @@ export async function runPmStudioSetup({
   let preserveStage = false;
   try {
     operations.copyBundle({ source: appPath, destination: stagePath, processRunner: operations.processRunner });
+    const stagedSource = inspectPmStudioApp({ appPath: stagePath, recipe, operations });
+    if (stagedSource.state !== "clean"
+      || (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);
+    }
     const stageAsarPath = path.join(stagePath, recipe.asarPath);
     const patched = patchAsarBuffer(fs.readFileSync(stageAsarPath), recipe);
     if (!patched.changed) throw setupError("PM_STUDIO_STAGE_INVALID", "Staging copy was unexpectedly already patched");
@@ -691,14 +966,16 @@ 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);
-    writePatchedBinaryRecord({ backup, inspection: staged, operations });
+    assertSigningMetadataPreserved(source, staged, recipe);
+    writePatchedBinaryRecord({ backup, inspection: staged, operations, recipe });
 
     assertNoBlockingProcesses(operations, appPath);
     const unchangedSource = inspectPmStudioApp({ appPath, recipe, operations });
     if (unchangedSource.state !== "clean"
       || unchangedSource.asar.asarSha256 !== source.asar.asarSha256
-      || unchangedSource.asar.headerSha256 !== source.asar.headerSha256) {
+      || unchangedSource.asar.headerSha256 !== source.asar.headerSha256
+      || (recipe.sourceBundleContent
+        && unchangedSource.bundleContent?.sha256 !== source.bundleContent?.sha256)) {
       throw setupError("PM_STUDIO_SOURCE_CHANGED", "PM Studio changed during setup; the verified staging bundle was not installed");
     }