codex-copilot-dx 0.6.4 → 0.6.6

package/src/image-optimization.mjs

@@ -273,9 +273,11 @@ export async function runWithConcurrency(taskFns, concurrency) {
   }));
 }
 
-function visitImageParts(parts, references, commit = null) {
+function visitImageParts(parts, references, commit = null, assertActive) {
   if (!Array.isArray(parts)) return;
-  for (const part of parts) {
+  for (let index = 0; index < parts.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const part = parts[index];
     const image = readResponsesImagePart(part);
     if (!image?.identity) continue;
     references.push({
@@ -286,22 +288,24 @@ function visitImageParts(parts, references, commit = null) {
   }
 }
 
-function collectImageReferences(reqBody) {
+function collectImageReferences(reqBody, assertActive) {
   const references = [];
   const dirtyCommits = new Set();
   if (!Array.isArray(reqBody?.input)) {
     return { references, markDirty() {}, commitDirty() {} };
   }
 
-  for (const item of reqBody.input) {
+  for (let index = 0; index < reqBody.input.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const item = reqBody.input[index];
     if (!item) continue;
-    visitImageParts([item], references);
+    visitImageParts([item], references, null, assertActive);
     if (item.type === "message" && Array.isArray(item.content)) {
-      visitImageParts(item.content, references);
+      visitImageParts(item.content, references, null, assertActive);
     }
     const toolOutput = readResponsesToolOutputParts(item);
     if (toolOutput) {
-      visitImageParts(toolOutput.parts, references, toolOutput.commit);
+      visitImageParts(toolOutput.parts, references, toolOutput.commit, assertActive);
     }
   }
 
@@ -320,6 +324,7 @@ function collectImageReferences(reqBody) {
 }
 
 async function optimizeImageReferences(collection, {
+  assertActive,
   concurrency,
   model,
   optimizeImage,
@@ -334,7 +339,9 @@ async function optimizeImageReferences(collection, {
     return optimizedByDataUrl.get(identity);
   };
   const tasks = collection.references.map((reference) => async () => {
+    assertActive?.();
     if (reference.set(await optimizeOnce(reference.get()))) collection.markDirty([reference]);
+    assertActive?.();
   });
   if (tasks.length) await runWithConcurrency(tasks, concurrency);
   collection.commitDirty();
@@ -346,9 +353,11 @@ function imageInputBytes(dataUrl) {
   return match ? Buffer.byteLength(match[1], "base64") : 0;
 }
 
-function uniqueOriginalImages(references) {
+function uniqueOriginalImages(references, assertActive) {
   const unique = new Map();
-  for (const reference of references) {
+  for (let index = 0; index < references.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const reference = references[index];
     const dataUrl = reference.get();
     const identity = canonicalInlineImageIdentity(dataUrl);
     if (!identity) continue;
@@ -422,6 +431,7 @@ export async function optimizeImagesInBody(reqBody, {
 }
 
 export async function prepareResponsesPayload(reqBody, {
+  assertActive,
   currentInputStart = 0,
   maxBytes = MAX_UPSTREAM_BODY_BYTES,
   optimizeImage = optimizeImageDataUrl,
@@ -429,18 +439,22 @@ export async function prepareResponsesPayload(reqBody, {
   skipInitialOptimization = false,
   signal,
 } = {}) {
+  assertActive?.();
   const shouldOptimizeImages = !IMG_OPT_DISABLED && !skipInitialOptimization;
-  const collection = shouldOptimizeImages ? collectImageReferences(reqBody) : null;
-  const originalImages = collection ? uniqueOriginalImages(collection.references) : [];
+  const collection = shouldOptimizeImages ? collectImageReferences(reqBody, assertActive) : null;
+  const originalImages = collection ? uniqueOriginalImages(collection.references, assertActive) : [];
   if (collection) {
     await optimizeImageReferences(collection, {
+      assertActive,
       concurrency: IMG_CONCURRENCY,
       model: reqBody.model,
       optimizeImage: (dataUrl, options) => optimizeImage(dataUrl, { ...options, quality: IMG_QUALITY }),
       signal,
     });
   }
+  assertActive?.();
   let bodyText = JSON.stringify(reqBody);
+  assertActive?.();
   let bodyBytes = Buffer.byteLength(bodyText);
   const summary = summarizeReqBody(reqBody);
   const targetBytes = positiveInt(maxBytes, MAX_UPSTREAM_BODY_BYTES);
@@ -450,11 +464,13 @@ export async function prepareResponsesPayload(reqBody, {
   if (collection && originalImages.length > 0 && bodyBytes > targetBytes) {
     const batchSize = Math.max(1, IMG_CONCURRENCY);
     for (const profile of Array.isArray(profiles) ? profiles : []) {
+      assertActive?.();
       const beforeBytes = bodyBytes;
       let processed = 0;
       stage = `q${positiveInt(profile.quality, IMG_QUALITY, 100)}`;
       const orderedImages = orderImagesByCurrentWireBytes(originalImages);
       for (let index = 0; index < orderedImages.length && bodyBytes > targetBytes; index += batchSize) {
+        assertActive?.();
         const batch = orderedImages.slice(index, index + batchSize);
         const candidates = await Promise.all(batch.map((image) => optimizeImage(image.dataUrl, {
           ...profile,
@@ -462,6 +478,7 @@ export async function prepareResponsesPayload(reqBody, {
           model: reqBody.model,
           signal,
         })));
+        assertActive?.();
         for (let offset = 0; offset < batch.length && bodyBytes > targetBytes; offset += 1) {
           processed += 1;
           const applied = applyImageCandidate(collection, batch[offset], candidates[offset], bodyBytes);
@@ -469,19 +486,24 @@ export async function prepareResponsesPayload(reqBody, {
           adapted ||= applied.changed;
           if (bodyBytes <= targetBytes) {
             collection.commitDirty();
+            assertActive?.();
             bodyText = JSON.stringify(reqBody);
+            assertActive?.();
             bodyBytes = Buffer.byteLength(bodyText);
           }
         }
       }
       collection.commitDirty();
+      assertActive?.();
       bodyText = JSON.stringify(reqBody);
+      assertActive?.();
       bodyBytes = Buffer.byteLength(bodyText);
       console.warn(status("warn", `responses payload ${beforeBytes}b exceeds ${targetBytes}b; image profile max_dim=${profile.maxDim} quality=${profile.quality} processed=${processed}/${orderedImages.length} -> ${bodyBytes}b`));
       if (bodyBytes <= targetBytes) break;
     }
   }
 
+  assertActive?.();
   return {
     bodyText,
     bodyBytes,

package/src/launcher.mjs

@@ -3,9 +3,8 @@ import { status } from "./status.mjs";
 
 export { ensureAuth } from "./auth.mjs";
 
-// The Codex desktop app was folded into the ChatGPT app, but it keeps the
-// original bundle identifier. Launching by bundle id works for both the old
-// Codex.app and the new ChatGPT.app regardless of where they are installed.
+// Prefer the Codex bundle identifier, then fall back to the known app paths.
+// This supports both Codex.app and ChatGPT.app regardless of installation path.
 const CODEX_BUNDLE_ID = "com.openai.codex";
 const APP_PATH_CANDIDATES = [
   "/Applications/Codex.app",

package/src/legacy-command-warning.mjs

@@ -30,8 +30,9 @@ export function shouldShowLegacyCommandWarning({
   }
   try {
     atomicWriteFileSync(filePath, `${now}\n`, { mode: 0o600 });
+    return true;
   } catch {
-    // The warning remains best effort when the cache directory is read-only.
+    // Stay silent when the throttle cannot persist, otherwise every invocation would warn.
+    return false;
   }
-  return true;
 }

package/src/models.mjs

@@ -95,11 +95,6 @@ function numericLimit(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 
-function hasMessagesEndpoint(model) {
-  const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
-  return endpoints.includes("/v1/messages") || endpoints.includes("/chat/completions");
-}
-
 function hasOpenAIEndpoint(model) {
   const endpoints = Array.isArray(model?.supported_endpoints) ? model.supported_endpoints : [];
   return endpoints.includes("/responses") || endpoints.includes("/v1/responses") || endpoints.includes("/chat/completions");
@@ -140,13 +135,22 @@ function uniqueIds(models, predicate) {
   return ids;
 }
 
-function isClaudeCopilotModel(model) {
+export function isClaudeCopilotCatalogEntry(model) {
   const id = String(model?.id || "").trim();
-  const vendor = String(model?.vendor || "").toLowerCase();
-  return id
-    && (id.startsWith("claude-") || vendor === "anthropic")
+  const vendor = String(model?.vendor || model?.owned_by || "").trim().toLowerCase();
+  return Boolean(id) && (id.toLowerCase().startsWith("claude-") || vendor === "anthropic");
+}
+
+export function isClaudeCopilotModel(model) {
+  const policy = String(model?.policy?.state || "").trim().toLowerCase();
+  const declaredOwners = [model?.vendor, model?.owned_by]
+    .map((value) => String(value || "").trim().toLowerCase())
+    .filter(Boolean);
+  return isClaudeCopilotCatalogEntry(model)
+    && declaredOwners.every((owner) => owner === "anthropic")
     && model?.model_picker_enabled !== false
-    && hasMessagesEndpoint(model);
+    && (!policy || policy === "enabled")
+    && modelSupportsChatCompletions(model);
 }
 
 export function gptModelIdsFromCopilotModels(models) {

package/src/observability.mjs

@@ -150,6 +150,15 @@ function safeClientRuntimeStatus(client) {
   };
 }
 
+function safeProfileCurrent(checkProfileCurrent) {
+  if (typeof checkProfileCurrent !== "function") return false;
+  try {
+    return checkProfileCurrent() === true;
+  } catch {
+    return false;
+  }
+}
+
 export function runtimeStatusPayload({
   metrics,
   streamPerformance,
@@ -161,6 +170,7 @@ export function runtimeStatusPayload({
   codexModelRegistry,
   claudeModelRegistry,
   claudeMode = "inherited",
+  isClaudeProfileCurrent,
 } = {}) {
   const memory = process.memoryUsage();
   const resolvedClaudeMode = claudeMode === "isolated" ? "isolated" : "inherited";
@@ -172,6 +182,8 @@ export function runtimeStatusPayload({
   const claudeModels = resolvedClaudeMode === "isolated"
     ? modelRegistryStatus(claudeModelRegistry)
     : codexModels;
+  const claudeProfileCurrent = resolvedClaudeMode === "isolated"
+    && safeProfileCurrent(isClaudeProfileCurrent);
   return {
     ...adapterHealthPayload(),
     uptime_ms: Math.round(process.uptime() * 1000),
@@ -192,7 +204,12 @@ export function runtimeStatusPayload({
     models: codexModels,
     profiles: {
       codex: { mode: "legacy", client: codexRuntime, models: codexModels },
-      claude: { mode: resolvedClaudeMode, client: claudeRuntime, models: claudeModels },
+      claude: {
+        mode: resolvedClaudeMode,
+        profile_current: claudeProfileCurrent,
+        client: claudeRuntime,
+        models: claudeModels,
+      },
     },
     routing: profileRouting({ claudeMode: resolvedClaudeMode }),
     limits: {

package/src/pm-studio-setup.mjs

@@ -396,6 +396,19 @@ function backupName(recipe) {
   return `${recipe.id}-${recipe.sourceAsarSha256.slice(0, 12)}`;
 }
 
+export function pmStudioBackupRoot(home = os.homedir()) {
+  return path.join(home, ".local", "share", "codex-copilot-dx", "pm-studio-backups");
+}
+
+export function pmStudioPatchManifestPath({
+  home = os.homedir(),
+  backupRoot = pmStudioBackupRoot(home),
+  recipe,
+} = {}) {
+  if (!recipe) throw new TypeError("PM Studio patch recipe is required");
+  return path.join(backupRoot, backupName(recipe), "manifest.json");
+}
+
 function backupManifest(recipe, createdAt) {
   return {
     schema_version: 1,
@@ -512,13 +525,24 @@ function writePatchedBinaryRecord({ backup, inspection, operations }) {
   backup.manifest = manifest;
 }
 
-function assertPatchedBinaryRecord({ inspection, manifestPath }) {
+export function assertPatchedBinaryRecord({ inspection, manifestPath, recipe }) {
   let manifest;
   try {
     manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
   } catch {
     throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", "PM Studio patched-binary record is missing or invalid");
   }
+  if (recipe && (manifest?.schema_version !== 1
+    || 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
+    || manifest?.patched?.asar_sha256 !== recipe.patchedAsarSha256
+    || manifest?.patched?.asar_header_sha256 !== recipe.patchedHeaderSha256
+    || !integrityMatches(manifest?.patched?.electron_asar_integrity, "SHA256", recipe.patchedHeaderSha256))) {
+    throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", "PM Studio patched-binary record does not match the installed patch recipe");
+  }
   const binaries = manifest?.patched?.binaries;
   if (!binaries
     || binaries.main_executable_sha256 !== inspection.executableIntegrity.executableSha256
@@ -593,7 +617,7 @@ export async function runPmStudioSetup({
   commandName = "ccdx",
   appPath = DEFAULT_PM_STUDIO_APP_PATH,
   home = os.homedir(),
-  backupRoot = path.join(home, ".local", "share", "codex-copilot-dx", "pm-studio-backups"),
+  backupRoot = pmStudioBackupRoot(home),
   recipes = PM_STUDIO_RECIPES,
   operations: operationOverrides = {},
   logger = (line) => console.log(line),
@@ -629,7 +653,7 @@ export async function runPmStudioSetup({
       throw setupError("PM_STUDIO_BACKUP_INVALID", "Patched PM Studio has no matching verified backup; no files were changed");
     }
     const backup = validateBackup({ backupDir: finalBackupDir, recipe, operations });
-    assertPatchedBinaryRecord({ inspection: source, manifestPath: backup.manifestPath });
+    assertPatchedBinaryRecord({ inspection: source, manifestPath: backup.manifestPath, recipe });
     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}`);
@@ -700,7 +724,7 @@ export async function runPmStudioSetup({
         installed.issues);
     }
     try {
-      assertPatchedBinaryRecord({ inspection: installed, manifestPath: backup.manifestPath });
+      assertPatchedBinaryRecord({ inspection: installed, manifestPath: backup.manifestPath, recipe });
     } catch (error) {
       throw setupError("PM_STUDIO_INSTALL_VERIFY_FAILED",
         `Installed PM Studio differs from the verified staging record; do not launch it. ${recoveryMessage(backup)}`,

package/src/pm-studio-status.mjs

@@ -7,16 +7,27 @@ import {
 } from "./auth-profile.mjs";
 import { PM_STUDIO_RECIPES } from "./pm-studio-asar.mjs";
 import {
+  assertPatchedBinaryRecord,
   createPmStudioSetupOperations,
   DEFAULT_PM_STUDIO_APP_PATH,
   inspectPmStudioApp,
   PM_STUDIO_CLAUDE_AUTH_COMMAND,
+  pmStudioBackupRoot,
+  pmStudioPatchManifestPath,
 } from "./pm-studio-setup.mjs";
+import { readAdapterStatus } from "./cli-status.mjs";
 import { checkRunningAdapter } from "./running-adapter.mjs";
 import { status } from "./status.mjs";
 
 const PM_RELAY_HOST = "127.0.0.1";
 const PM_RELAY_PORT = 2026;
+const PM_RELAY_CAPABILITY = "pm_studio_relay_v1";
+const PM_RELAY_ROUTE_NAMES = Object.freeze([
+  "pm_models",
+  "pm_chat_completions",
+  "pm_responses",
+  "pm_embeddings",
+]);
 
 function selectRecipe(metadata, recipes) {
   return recipes.find((recipe) => recipe.version === String(metadata.version)
@@ -42,15 +53,52 @@ function inspectClaudeProfile(home, readCredentials) {
   }
 }
 
+function inspectAdapterRuntime(adapter, runtimeStatus) {
+  const data = runtimeStatus?.data;
+  const health = adapter?.data;
+  const issues = [];
+  if (!data || typeof data !== "object") {
+    return { ok: false, baseUrl: runtimeStatus?.baseUrl || adapter?.baseUrl, data: null, issues: ["runtime status payload is missing"] };
+  }
+  if (data.version !== health?.version
+    || data.protocol_version !== health?.protocol_version
+    || data.instance_id !== health?.instance_id
+    || data.pid !== health?.pid) {
+    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 (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");
+  }
+  if (data.routing?.responses !== "codex") issues.push("/v1/responses is not routed to Codex");
+  if (data.routing?.messages !== "claude") issues.push("/v1/messages is not routed to Claude");
+  const routes = data.requests?.by_route;
+  for (const routeName of PM_RELAY_ROUTE_NAMES) {
+    if (!routes || typeof routes !== "object" || !Object.hasOwn(routes, routeName)) {
+      issues.push(`runtime status does not expose ${routeName}`);
+    }
+  }
+  return {
+    ...runtimeStatus,
+    ok: issues.length === 0,
+    issues,
+  };
+}
+
 export async function inspectPmStudioStatus({
   appPath = DEFAULT_PM_STUDIO_APP_PATH,
   home = os.homedir(),
+  backupRoot = pmStudioBackupRoot(home),
   recipes = PM_STUDIO_RECIPES,
   operationOverrides = {},
   existsSync = fs.existsSync,
   inspectApp = inspectPmStudioApp,
+  verifyPatchRecord = assertPatchedBinaryRecord,
   readClaudeCredentials = readAuthProfileCredentials,
   checkRunningAdapterFn = checkRunningAdapter,
+  readAdapterStatusFn = readAdapterStatus,
 } = {}) {
   const operations = createPmStudioSetupOperations(operationOverrides);
   let app;
@@ -69,9 +117,24 @@ export async function inspectPmStudioStatus({
         bundleIdentifier: String(metadata.bundleIdentifier),
       };
       const recipe = selectRecipe(normalized, recipes);
-      app = recipe
-        ? { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id }
-        : { state: "unsupported", metadata: normalized, issues: [], recipe: "" };
+      if (recipe) {
+        app = { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id };
+        if (app.state === "patched") {
+          const manifestPath = pmStudioPatchManifestPath({ home, backupRoot, recipe });
+          try {
+            verifyPatchRecord({ inspection: app, manifestPath, recipe });
+            app.patchRecord = { valid: true, manifestPath, reason: "" };
+          } catch (error) {
+            const reason = safeMessage(error);
+            app.patchRecipeMatched = true;
+            app.patchRecord = { valid: false, manifestPath, reason };
+            app.state = "drift";
+            app.issues = [...(Array.isArray(app.issues) ? app.issues : []), reason];
+          }
+        }
+      } else {
+        app = { state: "unsupported", metadata: normalized, issues: [], recipe: "" };
+      }
     } catch (error) {
       app = { state: "error", metadata: null, issues: [safeMessage(error)], recipe: "" };
     }
@@ -84,16 +147,40 @@ export async function inspectPmStudioStatus({
   } catch (error) {
     adapter = { ok: false, error };
   }
-  const operational = app.state === "patched" && claude.valid && adapter?.ok === true;
-  return { ok: operational, appPath, app, claude, adapter };
+  let runtime = { ok: false, baseUrl: adapter?.baseUrl, data: null, issues: ["adapter health check failed"] };
+  if (adapter?.ok === true) {
+    try {
+      runtime = inspectAdapterRuntime(adapter, await readAdapterStatusFn({
+        host: PM_RELAY_HOST,
+        port: PM_RELAY_PORT,
+      }));
+    } catch (error) {
+      runtime = { ok: false, baseUrl: adapter.baseUrl, data: null, issues: [safeMessage(error)] };
+    }
+  }
+  const operational = app.state === "patched"
+    && app.patchRecord?.valid === true
+    && claude.valid
+    && adapter?.ok === true
+    && runtime.ok === true;
+  return { ok: operational, appPath, app, claude, adapter, runtime };
 }
 
 function appStatusLine(result, commandName) {
   const { app } = result;
   const version = app.metadata ? `${app.metadata.version} build ${app.metadata.build}` : "";
-  if (app.state === "patched") return status("ok", `PM Studio ${version} is patched and verified`);
+  if (app.state === "patched" && app.patchRecord?.valid === true) {
+    return status("ok", `PM Studio ${version} is patched and verified against its installed patch record`);
+  }
+  if (app.state === "patched") {
+    const reason = app.patchRecord?.reason || "installed patch record is missing";
+    return status("err", `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}`);
+  }
   if (app.state === "clean") return status("warn", `PM Studio ${version} is supported but not patched; run ${commandName} pms setup`);
   if (app.state === "unsupported") return status("err", `PM Studio ${version} has no exact patch recipe; no files will be changed`);
+  if (app.state === "drift" && app.patchRecipeMatched) {
+    return status("err", `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}`);
+  }
   if (app.state === "drift") return status("err", `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}`);
   if (app.state === "not_installed") return status("warn", `PM Studio is not installed at ${result.appPath}`);
   return status("err", `PM Studio could not be inspected: ${app.issues.join("; ")}`);
@@ -111,14 +198,21 @@ export function formatPmStudioStatus(result, { commandName = "ccdx" } = {}) {
     const reason = result.claude.configured && result.claude.reason ? ` (${result.claude.reason})` : "";
     lines.push(status("err", `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}`));
   }
-  if (result.adapter?.ok) {
-    lines.push(status("ok", `PM relay is available at ${result.adapter.baseUrl}`));
+  if (result.adapter?.ok && result.runtime?.ok) {
+    lines.push(status("ok", `PM relay 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";
+    lines.push(status("err", `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start`));
   } else if (result.adapter?.incompatible) {
     lines.push(status("err", `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start`));
   } else {
     lines.push(status("warn", `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start`));
   }
-  lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+  if (result.runtime?.ok) {
+    lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+  } else {
+    lines.push(status("info", "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+  }
   return lines.join("\n");
 }
 

package/src/profile-routing.mjs

@@ -1,22 +1,13 @@
+import {
+  isClaudeCopilotCatalogEntry,
+  isClaudeCopilotModel,
+} from "./models.mjs";
+
 function catalogData(catalog) {
   if (Array.isArray(catalog)) return catalog;
   return Array.isArray(catalog?.data) ? catalog.data : [];
 }
 
-function isClaudeCatalogEntry(model) {
-  const id = String(model?.id || "").trim();
-  const vendor = String(model?.vendor || "").trim().toLowerCase();
-  return Boolean(id) && (vendor === "anthropic" || id.toLowerCase().startsWith("claude-"));
-}
-
-function isAllowedClaudeModel(model) {
-  return isClaudeCatalogEntry(model)
-    && String(model?.vendor || "").trim().toLowerCase() === "anthropic"
-    && model?.model_picker_enabled !== false
-    && Array.isArray(model?.supported_endpoints)
-    && model.supported_endpoints.includes("/chat/completions");
-}
-
 export function profileRouting({ claudeMode = "inherited", claudeConfigured = false } = {}) {
   const isolated = claudeMode === "isolated" || claudeConfigured === true;
   return Object.freeze({ responses: "codex", messages: isolated ? "claude" : "codex" });
@@ -44,9 +35,9 @@ export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {})
     const known = new Set();
     for (const model of catalogData(catalog)) {
       const id = String(model?.id || "").trim();
-      if (!id || !isClaudeCatalogEntry(model)) continue;
+      if (!id || !isClaudeCopilotCatalogEntry(model)) continue;
       known.add(id);
-      if (enabled && isAllowedClaudeModel(model) && !allowed.has(id)) allowed.set(id, model);
+      if (enabled && isClaudeCopilotModel(model) && !allowed.has(id)) allowed.set(id, model);
     }
     cachedCatalog = catalog;
     cachedEnabled = enabled;

package/src/profile-runtime.mjs

@@ -46,6 +46,15 @@ export function createProfileRuntime({
   };
   const credentials = readCredentials();
   const claudeProfile = safeProfileStatus(credentials);
+  const claudeCredentialFingerprint = credentials.valid
+    ? githubTokenFingerprint(credentials.token)
+    : "";
+  const isClaudeProfileCurrent = () => {
+    if (!claudeCredentialFingerprint) return false;
+    const current = readCredentials();
+    return current.valid === true
+      && githubTokenFingerprint(current.token) === claudeCredentialFingerprint;
+  };
   let codexCredentialFingerprint = "";
   try {
     const codexCredentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
@@ -65,6 +74,7 @@ export function createProfileRuntime({
       claudeProfile,
       codexCredentialFingerprint,
       claudeCredentialFingerprint: "",
+      isClaudeProfileCurrent,
     });
   }
 
@@ -86,8 +96,7 @@ export function createProfileRuntime({
     claudeMode: "isolated",
     claudeProfile,
     codexCredentialFingerprint,
-    claudeCredentialFingerprint: credentials.valid
-      ? githubTokenFingerprint(credentials.token)
-      : "",
+    claudeCredentialFingerprint,
+    isClaudeProfileCurrent,
   });
 }

package/src/response-history.mjs

@@ -1,4 +1,5 @@
 import { httpError } from "./http-transport.mjs";
+import { clearResponsesToolOutputPartsCache } from "./responses-content.mjs";
 import { loadRuntimeConfig, parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 
 const DEFAULT_MAX_BYTES = RUNTIME_DEFAULTS.responseHistoryMaxBytes;
@@ -201,17 +202,26 @@ export function responseHistoryMaterializedBytes(responseId) {
   return chain.reduce((bytes, entry) => bytes + entry.bytes, 0);
 }
 
-export function materializeResponseHistory(responseId) {
+export function materializeResponseHistory(responseId, { assertActive } = {}) {
+  assertActive?.();
   const { chain, rootId } = responseHistoryChain(responseId);
   const items = [];
-  for (const entry of chain.reverse()) items.push(...entry.inputItems, ...entry.outputItems);
+  for (let index = 0; index < chain.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const entry = chain[chain.length - index - 1];
+    items.push(...entry.inputItems, ...entry.outputItems);
+  }
+  assertActive?.();
   const materialized = cloneJson(items);
+  assertActive?.();
   touchTree(rootId);
   return materialized;
 }
 
 export function rememberResponseHistoryNode({ id, parentId, inputItems, outputItems, takeOwnership = false }) {
   if (!id || !Array.isArray(inputItems)) return;
+  clearResponsesToolOutputPartsCache(inputItems);
+  clearResponsesToolOutputPartsCache(outputItems);
   const bytes = jsonByteLength([inputItems, outputItems]);
   if (bytes > maxBytes) {
     if (histories.has(id)) removeSubtree(id);