pi-cache-optimizer 2.6.4 → 2.6.5

package/README.md

@@ -8,7 +8,7 @@
 
 Pi extension for improving provider-side KV / prompt cache hit rates. It keeps stable prompt content near the front, adds a conservative OpenAI-compatible `prompt_cache_key` fallback, warns about common proxy cache-routing gaps, and shows read-only footer cache stats.
 
-> Renamed from `pi-deepseek-cache-optimizer`. Existing footer counters migrate automatically. This package never creates, edits, backs up, or deletes your `~/.pi/agent/models.json`.
+> Renamed from `pi-deepseek-cache-optimizer`. Existing footer counters migrate automatically. The extension does **not** touch `~/.pi/agent/models.json` during normal operation; only `/cache-optimizer fix` can edit it, and only after an explicit interactive preview + confirmation with an automatic timestamped backup.
 
 ## Contents
 
@@ -17,6 +17,8 @@ Pi extension for improving provider-side KV / prompt cache hit rates. It keeps s
 - [Commands](#commands)
 - [Persistent opt-out](#persistent-opt-out)
 - [OpenAI-compatible proxy setup](#openai-compatible-proxy-setup)
+- [Anthropic adaptive thinking models](#anthropic-adaptive-thinking-models)
+- [Auto-repair with `/cache-optimizer fix`](#auto-repair-with-cache-optimizer-fix)
 - [Footer stats](#footer-stats)
 - [Uninstall](#uninstall)
 - [Verify effect](#verify-effect)
@@ -161,7 +163,7 @@ Or use model-level override:
 
 1. Shows full preview of changes (file path, edit location, JSON to write, risks)
 2. Warns: ① changes affect all sessions using that channel, ② automatic backup created at `models.json.backup-cache-optimizer-<timestamp>`, ③ Pi reload required
-3. Uses comment-preserving surgical editor — existing comments, indentation, key order preserved
+3. Uses comment-preserving surgical editor — existing comments, indentation, and existing key order are preserved
 4. Requires explicit user confirmation (interactive prompt or `ui.select`)
 5. Writes atomically (temp + rename); self-validates after write
 6. Falls back to manual guidance if JSONC scanner cannot confidently locate the target

package/README.zh-CN.md

@@ -8,7 +8,7 @@
 
 用于提升 Pi 中 provider 侧 KV Cache / Prompt Cache 命中率的扩展：把稳定 prompt 内容前置，给 OpenAI-compatible 请求补保守的 `prompt_cache_key`，提示代理渠道常见缓存路由兼容问题，并在底部显示只读缓存统计。
 
-> 本包已从 `pi-deepseek-cache-optimizer` 改名。已有底部统计会自动迁移。本扩展绝不会创建、修改、备份或删除你的 `~/.pi/agent/models.json`。
+> 本包已从 `pi-deepseek-cache-optimizer` 改名。已有底部统计会自动迁移。正常运行时扩展不会触碰你的 `~/.pi/agent/models.json`；只有 `/cache-optimizer fix` 会在展示交互式预览、风险提示并得到明确确认后写入，且会先创建带时间戳的自动备份。
 
 ## 目录
 
@@ -17,6 +17,8 @@
 - [命令](#命令)
 - [持久 Opt-out](#持久-opt-out)
 - [OpenAI-compatible 代理配置](#openai-compatible-代理配置)
+- [Anthropic adaptive thinking 模型](#anthropic-adaptive-thinking-模型)
+- [使用 `/cache-optimizer fix` 自动修复](#使用-cache-optimizer-fix-自动修复)
 - [Footer 统计](#footer-统计)
 - [卸载](#卸载)
 - [验证效果](#验证效果)
@@ -161,7 +163,7 @@ Pi 内置 catalog 已为官方模型设置此 flag。`models.json` 中覆盖这
 
 1. 显示完整变更预览（文件路径、编辑位置、要写入的 JSON、风险说明）
 2. 警告：① 修改影响使用该渠道的所有 session，② 自动备份到 `models.json.backup-cache-optimizer-<timestamp>`，③ 需重启 Pi 或 reload
-3. 使用保留注释的精确编辑器 —— 现有注释、缩进、key 顺序全部保留
+3. 使用保留注释的精确编辑器 —— 现有注释、缩进和已有 key 顺序都会保留
 4. 需要用户明确确认（交互式提示或 `ui.select`）
 5. 原子写入（temp + rename）；写入后自我验证
 6. 如果 JSONC 扫描器无法置信定位目标，回退到手动修改指引

package/index.ts

@@ -1612,7 +1612,7 @@ function hasEffectivePromptCacheKey(record: UnknownRecord): boolean {
   return isNonEmptyString(record.prompt_cache_key) || isNonEmptyString(record.promptCacheKey);
 }
 
-function isNonEmptyString(value: unknown): boolean {
+function isNonEmptyString(value: unknown): value is string {
   return typeof value === "string" && value.trim().length > 0;
 }
 
@@ -1637,9 +1637,6 @@ function describeMissingOpenAIFamilyProxyCompat(model: PiModel): string[] {
   if (!isOpenAICompatibleProxyApi(model.api)) return missing;
   if (isOfficialOpenAIBaseUrl(model)) return missing;
 
-  if (compat.supportsLongCacheRetention !== true) {
-    missing.push("supportsLongCacheRetention");
-  }
   if (compat.sendSessionAffinityHeaders !== true) {
     missing.push("sendSessionAffinityHeaders");
   }
@@ -1660,9 +1657,6 @@ function describeMissingOpenAICompatibleProxyCompat(model: PiModel): string[] {
   if (!isOpenAICompatibleProxyApi(model.api)) return missing;
   if (isOfficialOpenAIBaseUrl(model)) return missing;
 
-  if (compat.supportsLongCacheRetention !== true) {
-    missing.push("supportsLongCacheRetention");
-  }
   if (compat.sendSessionAffinityHeaders !== true) {
     missing.push("sendSessionAffinityHeaders");
   }
@@ -1670,6 +1664,20 @@ function describeMissingOpenAICompatibleProxyCompat(model: PiModel): string[] {
   return missing;
 }
 
+function describeOptionalOpenAICompatibleProxyCompat(model: PiModel): string[] {
+  const compat = getCompat(model);
+  const optional: string[] = [];
+
+  if (!isOpenAICompatibleProxyApi(model.api)) return optional;
+  if (isOfficialOpenAIBaseUrl(model)) return optional;
+
+  if (compat.supportsLongCacheRetention !== true) {
+    optional.push("supportsLongCacheRetention");
+  }
+
+  return optional;
+}
+
 function buildSafeOpenAIProxyCompatSuggestion(missing: string[]): Record<string, boolean> {
   const suggestion: Record<string, boolean> = {};
   if (missing.includes("sendSessionAffinityHeaders")) {
@@ -1760,21 +1768,22 @@ function appendOpenAIProxyCompatAdviceLines(lines: string[], missing: string[],
       lines.push("Safe default suggestion:");
     }
     lines.push(JSON.stringify(suggestion, null, 2));
-  } else if (missing.includes("supportsLongCacheRetention")) {
-    lines.push("No safe automatic JSON change is recommended for `supportsLongCacheRetention`.");
   }
 
   if (missing.includes("sendSessionAffinityHeaders")) {
     lines.push("- sendSessionAffinityHeaders: recommended for third-party proxies when supported; it helps keep one Pi session on the same upstream/backend.");
   }
-  if (missing.includes("supportsLongCacheRetention")) {
-    lines.push("- supportsLongCacheRetention: optional. Enable only after your endpoint/proxy explicitly supports OpenAI long prompt cache retention.");
-    lines.push(`- ${getPromptCacheRetentionUnsupportedHint()}`);
-  }
-
   appendCredentialSafeProviderGuidance(lines, options, suggestion);
 }
 
+function appendOptionalOpenAIProxyCompatAdviceLines(lines: string[], optional: string[]): void {
+  if (!optional.includes("supportsLongCacheRetention")) return;
+  lines.push("");
+  lines.push("Optional (not required, not auto-fixed):");
+  lines.push("- supportsLongCacheRetention: enable only after your endpoint/proxy explicitly supports OpenAI long prompt cache retention.");
+  lines.push(`- ${getPromptCacheRetentionUnsupportedHint()}`);
+}
+
 /**
  * Build the warning text displayed to users when an OpenAI-family third-party
  * proxy is missing one or more cache/session-affinity compat flags.
@@ -3121,12 +3130,15 @@ function parseCacheStats(value: unknown): CacheStats | undefined {
 
 function parsePersistedRoutedModelRef(value: unknown): PersistedRoutedModelRef | undefined {
   const record = asRecord(value);
-  if (!record || !isNonEmptyString(record.provider) || !isNonEmptyString(record.id)) return undefined;
+  const provider = record?.provider;
+  const id = record?.id;
+  const name = record?.name;
+  if (!isNonEmptyString(provider) || !isNonEmptyString(id)) return undefined;
 
   return {
-    provider: record.provider.trim(),
-    id: record.id.trim(),
-    name: isNonEmptyString(record.name) ? record.name.trim() : record.id.trim(),
+    provider: provider.trim(),
+    id: id.trim(),
+    name: isNonEmptyString(name) ? name.trim() : id.trim(),
   };
 }
 
@@ -3530,8 +3542,9 @@ function describeRouterChannelDiagnostics(model: PiModel): string[] {
     provider.includes("openrouter")
   ) {
     const compat = getCompat(model);
-    const hasOnly = !!(compat as Record<string, unknown>)["openRouterRouting"]?.only;
-    const hasOrder = !!(compat as Record<string, unknown>)["openRouterRouting"]?.order;
+    const routing = asRecord((compat as Record<string, unknown>)["openRouterRouting"]);
+    const hasOnly = !!routing?.only;
+    const hasOrder = !!routing?.order;
 
     notes.push(
       "🔀 Router/channel: OpenRouter detected. OpenRouter is a multi-provider router; " +
@@ -3566,8 +3579,9 @@ function describeRouterChannelDiagnostics(model: PiModel): string[] {
     provider.includes("vercel-ai-gateway")
   ) {
     const compat = getCompat(model);
-    const hasOnly = !!(compat as Record<string, unknown>)["vercelGatewayRouting"]?.only;
-    const hasOrder = !!(compat as Record<string, unknown>)["vercelGatewayRouting"]?.order;
+    const routing = asRecord((compat as Record<string, unknown>)["vercelGatewayRouting"]);
+    const hasOnly = !!routing?.only;
+    const hasOrder = !!routing?.order;
 
     notes.push(
       "🔀 Router/channel: Vercel AI Gateway detected. The gateway may route to different " +
@@ -3694,8 +3708,21 @@ function buildDoctorDiagnosis(model: PiModel, options: { promptCacheRetention400
   const adaptiveThinkingApplicable = isAdaptiveThinkingCompatApplicable(model);
   const deepSeekCompatApplicable = isDeepSeekCompatCheckApplicable(model);
   const missing = describeMissingCacheCompatForModel(model);
+  const optionalOpenAIProxyCompat = (!adaptiveThinkingApplicable && !deepSeekCompatApplicable)
+    ? describeOptionalOpenAICompatibleProxyCompat(model)
+    : [];
+  const fixSug = buildFixSuggestion(model);
+  const safeFixableMissing = fixSug ? Object.keys(fixSug.compatKeys) : [];
+  const advisoryMissing = missing.filter(m => !safeFixableMissing.includes(m));
+
+  if (safeFixableMissing.length > 0) {
+    lines.push(`⚠️  Missing compat flags: ${safeFixableMissing.join(", ")}`);
+  }
+  if (advisoryMissing.length > 0) {
+    lines.push(`ℹ️  Optional: ${advisoryMissing.join(", ")} (enable only if needed)`);
+  }
+
   if (missing.length > 0) {
-    lines.push(`⚠️  Missing compat flags: ${missing.join(", ")}`);
     const key = modelKey(model);
     const slashIdx = key.indexOf("/");
     const providerLabel = slashIdx > 0 ? key.slice(0, slashIdx) : key;
@@ -3707,9 +3734,11 @@ function buildDoctorDiagnosis(model: PiModel, options: { promptCacheRetention400
       appendDeepSeekCompatAdviceLines(lines, missing, { providerLabel, modelId: model.id });
     } else {
       appendOpenAIProxyCompatAdviceLines(lines, missing, { providerLabel, modelId: model.id });
+      appendOptionalOpenAIProxyCompatAdviceLines(lines, optionalOpenAIProxyCompat);
     }
   } else if (adaptiveThinkingApplicable || deepSeekCompatApplicable || isCompatCheckApplicable(model)) {
     lines.push("✅ Compat fully configured.");
+    appendOptionalOpenAIProxyCompatAdviceLines(lines, optionalOpenAIProxyCompat);
   } else {
     lines.push(...getCompatCheckNotApplicableLines(model));
   }
@@ -3767,7 +3796,8 @@ function buildLowHitDiagnosis(
   const lines: string[] = [];
 
   // 1. Missing compat flags (adapter-aware: DeepSeek has extra reasoning compat)
-  const missingCompat = describeMissingCacheCompatForModel(model);
+  const fixSugLHD = buildFixSuggestion(model);
+  const safeFixableMissingLHD = fixSugLHD ? Object.keys(fixSugLHD.compatKeys) : [];
 
   // 2. Router/channel risk (reuse existing check)
   const routerNotes = describeRouterChannelDiagnostics(model);
@@ -3785,7 +3815,7 @@ function buildLowHitDiagnosis(
   // 5. Today's overall trend from persisted stats
   const todayStats = stats ?? emptyCacheStats();
 
-  const hasMissingCompat = missingCompat.length > 0;
+  const hasMissingCompat = safeFixableMissingLHD.length > 0;
   const hasRouterRisk = routerNotes.length > 0;
   const hasUsageMissing = missingUsageSamples > 0;
 
@@ -3814,7 +3844,7 @@ function buildLowHitDiagnosis(
 
   // Priority 1: missing compat flags
   if (hasMissingCompat) {
-    lines.push(`⚠️  Missing compat flags: ${missingCompat.join(", ")}`);
+    lines.push(`⚠️  Missing compat flags: ${safeFixableMissingLHD.join(", ")}`);
     lines.push("   These flags enable prompt caching and session-affinity routing.");
     lines.push("   Run /cache-optimizer compat for edit instructions.");
   }
@@ -3867,11 +3897,17 @@ function buildLowHitDiagnosis(
 
 function buildCompatDiagnosis(model: PiModel): string | undefined {
   const missing = describeMissingCacheCompatForModel(model);
+  const fixSugC = buildFixSuggestion(model);
+  const safeFixableMissingC = fixSugC ? Object.keys(fixSugC.compatKeys) : [];
+  const advisoryMissingC = missing.filter(m => !safeFixableMissingC.includes(m));
   const adaptiveThinkingApplicable = isAdaptiveThinkingCompatApplicable(model);
   const deepSeekCompatApplicable = isDeepSeekCompatCheckApplicable(model);
+  const optionalOpenAIProxyCompat = (!adaptiveThinkingApplicable && !deepSeekCompatApplicable)
+    ? describeOptionalOpenAICompatibleProxyCompat(model)
+    : [];
   const routerNotes = describeRouterChannelDiagnostics(model);
 
-  if (missing.length === 0 && routerNotes.length === 0) return undefined;
+  if (missing.length === 0 && routerNotes.length === 0 && optionalOpenAIProxyCompat.length === 0) return undefined;
 
   const key = modelKey(model);
   const lines: string[] = [];
@@ -3881,7 +3917,12 @@ function buildCompatDiagnosis(model: PiModel): string | undefined {
     const providerLabel = slashIdx > 0 ? key.slice(0, slashIdx) : key;
     const modelsJsonPath = getModelsJsonDisplayPath();
     lines.push(`Active model: ${key}`);
-    lines.push(`Missing: ${missing.join(", ")}`);
+    if (safeFixableMissingC.length > 0) {
+      lines.push(`Safe-fixable: ${safeFixableMissingC.join(", ")}`);
+    }
+    if (advisoryMissingC.length > 0) {
+      lines.push(`Optional: ${advisoryMissingC.join(", ")} (enable only if needed)`);
+    }
     lines.push("");
     lines.push(`Edit ${modelsJsonPath} -> providers["${providerLabel}"] -> compat`);
     lines.push(`(at the same level as baseUrl/api/apiKey/models).`);
@@ -3891,16 +3932,18 @@ function buildCompatDiagnosis(model: PiModel): string | undefined {
       appendDeepSeekCompatAdviceLines(lines, missing, { providerLabel, modelId: model.id });
     } else {
       appendOpenAIProxyCompatAdviceLines(lines, missing, { providerLabel, modelId: model.id });
+      appendOptionalOpenAIProxyCompatAdviceLines(lines, optionalOpenAIProxyCompat);
     }
   }
 
-  // When compat is fully configured but router notes exist, prefix the status.
-  if (routerNotes.length > 0 && missing.length === 0) {
+  // When compat is fully configured but router/optional notes exist, prefix the status.
+  if ((routerNotes.length > 0 || optionalOpenAIProxyCompat.length > 0) && missing.length === 0) {
     if (adaptiveThinkingApplicable || deepSeekCompatApplicable || isCompatCheckApplicable(model)) {
       lines.push("✅ Compat fully configured.");
       if (isPromptCacheRetention400Applicable(model)) {
         lines.push(getPromptCacheRetentionUnsupportedHint());
       }
+      appendOptionalOpenAIProxyCompatAdviceLines(lines, optionalOpenAIProxyCompat);
     } else {
       lines.push(...getCompatCheckNotApplicableLines(model));
     }
@@ -4131,8 +4174,10 @@ function stripJsoncComments(text: string): string {
   let i = 0;
   while (i < text.length) {
     const ch = text[i];
+
     if (ch === '"') {
-      // String literal — copy until closing quote (handle escapes)
+      // String literal — copy byte-for-byte until the closing quote.
+      // Escaped quotes/slashes must not be mistaken for comment delimiters.
       out.push(ch);
       i++;
       while (i < text.length) {
@@ -4146,39 +4191,74 @@ function stripJsoncComments(text: string): string {
           break;
         }
       }
-    } else if (ch === '/' && i + 1 < text.length && text[i + 1] === '/') {
-      // Line comment — replace with spaces until newline
-      out.push(' ');
-      i++;
+      continue;
+    }
+
+    if (ch === '/' && i + 1 < text.length && text[i + 1] === '/') {
+      // Line comment — replace BOTH slashes and every comment byte with
+      // spaces, but leave the newline to be copied by the normal path.
+      out.push(' ', ' ');
+      i += 2;
       while (i < text.length && text[i] !== '\n') {
         out.push(' ');
         i++;
       }
-    } else if (ch === '/' && i + 1 < text.length && text[i + 1] === '*') {
-      // Block comment — replace with spaces (preserve newlines)
-      out.push(' ');
-      i++;
-      while (i + 1 < text.length) {
-        if (text[i] === '*' && text[i + 1] === '/') {
-          out.push(' ');
+      continue;
+    }
+
+    if (ch === '/' && i + 1 < text.length && text[i + 1] === '*') {
+      // Block comment — replace every byte with a space except newlines.
+      // This deliberately preserves text.length and all structural offsets.
+      out.push(' ', ' ');
+      i += 2;
+      while (i < text.length) {
+        if (text[i] === '*' && i + 1 < text.length && text[i + 1] === '/') {
+          out.push(' ', ' ');
           i += 2;
           break;
         }
-        if (text[i] === '\n') {
-          out.push('\n');
-        } else {
-          out.push(' ');
-        }
+        out.push(text[i] === '\n' ? '\n' : ' ');
         i++;
       }
-    } else {
-      out.push(ch);
-      i++;
+      continue;
     }
+
+    out.push(ch);
+    i++;
   }
   return out.join('');
 }
 
+/**
+ * Remove JSONC trailing commas from already comment-stripped text.
+ * The returned text stays length-preserving (commas become spaces), which
+ * gives JSON.parse a tolerant JSONC surface without affecting diagnostics.
+ */
+function stripJsoncTrailingCommas(text: string): string {
+  const chars = text.split("");
+  let i = 0;
+  while (i < chars.length) {
+    if (chars[i] === '"') {
+      const str = readJsonStringLiteral(text, i);
+      if (!str) break;
+      i = str.end;
+      continue;
+    }
+
+    if (chars[i] === ',') {
+      let j = i + 1;
+      while (j < chars.length && isJsonWhitespace(chars[j])) j++;
+      if (chars[j] === '}' || chars[j] === ']') chars[i] = ' ';
+    }
+    i++;
+  }
+  return chars.join('');
+}
+
+function parseJsonc(text: string): unknown {
+  return JSON.parse(stripJsoncTrailingCommas(stripJsoncComments(text)));
+}
+
 /**
  * JSONC scanner: locate the provider block and model entry in models.json text.
  * Returns the byte offsets for surgical insertion, or undefined if ambiguous.
@@ -4222,153 +4302,51 @@ function locateModelInJsonc(
   // Clean text of comments first for reliable structural scanning
   const clean = stripJsoncComments(text);
 
-  // Strategy: find `"providers"` key in the root object, then find the
-  // provider key under it, then the `"models"` array, then the array
-  // element whose `"id"` matches. We map via the stripped text (comment
-  // removal replaces comment chars with spaces, preserving offsets).
-
-  const pos = clean.indexOf('"providers"');
-  if (pos < 0) return undefined;
-
-  // Scan from `"providers"` to find the `{` of the provider block
-  let cur = pos + '"providers"'.length;
-  // Skip `:`, whitespace, etc.
-  while (cur < clean.length && clean[cur] !== '{') cur++;
-  if (cur >= clean.length) return undefined;
-  cur++; // Skip `{`
-
-  // Now scan key-value pairs in the providers object to find the matching providerLabel
-  const providerLabelJson = JSON.stringify(providerLabel);
-  let providerBrace = -1;
-  let providerEndBrace = -1;
-
-  while (cur < clean.length) {
-    // Skip whitespace/comments
-    while (cur < clean.length && (clean[cur] === ' ' || clean[cur] === '\n' || clean[cur] === '\r' || clean[cur] === '\t')) cur++;
-    if (cur >= clean.length) break;
-    if (clean[cur] === '}') break; // End of providers
-
-    // Try to read a string key
-    if (clean[cur] !== '"') { cur++; continue; }
-    const keyEnd = clean.indexOf('"', cur + 1);
-    if (keyEnd < 0) return undefined;
-    const key = clean.slice(cur + 1, keyEnd);
-    cur = keyEnd + 1;
-
-    // Skip `:`
-    while (cur < clean.length && clean[cur] !== ':') cur++;
-    if (cur >= clean.length) return undefined;
-    cur++; // Skip `:`
-    while (cur < clean.length && (clean[cur] === ' ' || clean[cur] === '\n' || clean[cur] === '\r' || clean[cur] === '\t')) cur++;
-
-    if (key === providerLabel) {
-      // Found — expect `{` starting the provider object
-      if (clean[cur] !== '{') return undefined;
-      providerBrace = cur;
-      // Find matching closing `}` for the provider object (track depth)
-      let depth = 1;
-      let scan = cur + 1;
-      while (scan < clean.length && depth > 0) {
-        if (clean[scan] === '{') depth++;
-        else if (clean[scan] === '}') depth--;
-        if (depth > 0) scan++;
-      }
-      providerEndBrace = scan;
-      break;
-    }
-
-    // Skip the value
-    if (clean[cur] === '{') {
-      let depth = 1;
-      cur++;
-      while (cur < clean.length && depth > 0) {
-        if (clean[cur] === '{') depth++;
-        else if (clean[cur] === '}') depth--;
-        cur++;
-      }
-    } else if (clean[cur] === '[') {
-      let depth = 1;
-      cur++;
-      while (cur < clean.length && depth > 0) {
-        if (clean[cur] === '[') depth++;
-        else if (clean[cur] === ']') depth--;
-        cur++;
-      }
-    } else if (clean[cur] === '"') {
-      const strEnd = clean.indexOf('"', cur + 1);
-      if (strEnd < 0) return undefined;
-      cur = strEnd + 1;
-    } else {
-      // Number, boolean, etc.
-      while (cur < clean.length && clean[cur] !== ',' && clean[cur] !== '}' && clean[cur] !== '\n') cur++;
-    }
-    // Skip comma
-    if (cur < clean.length && clean[cur] === ',') cur++;
-  }
-
-  if (providerBrace < 0 || providerEndBrace < 0) return undefined;
-
-  // Scan provider object at depth 1 for a provider-level "compat" object.
-  // Depth-aware + string-aware so nested model compat objects are not confused
-  // with the provider-level one.
+  // Strategy: find `"providers"` as a direct root key, then find the
+  // provider key under it, then the provider's direct `"models"` key.
+  // All object/value traversal uses the string-aware primitives above so
+  // braces, brackets, comment markers, or escaped quotes inside strings do
+  // not corrupt offsets.
+  const rootBrace = skipJsonWhitespace(clean, 0);
+  if (clean[rootBrace] !== "{") return undefined;
+
+  const providersKey = findJsonObjectKey(clean, rootBrace, "providers");
+  if (!providersKey) return undefined;
+  const providersBrace = skipJsonWhitespace(clean, providersKey.valueStart);
+  if (clean[providersBrace] !== "{") return undefined;
+  const providersEnd = findMatchingBracket(clean, providersBrace);
+  if (providersEnd === undefined) return undefined;
+
+  const providerKey = findJsonObjectKey(clean, providersBrace, providerLabel);
+  if (!providerKey || providerKey.keyStart > providersEnd) return undefined;
+  const providerBrace = skipJsonWhitespace(clean, providerKey.valueStart);
+  if (clean[providerBrace] !== "{") return undefined;
+  const providerEndBrace = findMatchingBracket(clean, providerBrace);
+  if (providerEndBrace === undefined || providerEndBrace > providersEnd) return undefined;
+
+  // Provider-level compat is a direct provider child only. Nested model
+  // compat objects are intentionally skipped whole by findJsonObjectKey.
   let providerCompatBrace = -1;
   let providerCompatEnd = -1;
-  {
-    let pScan = providerBrace + 1;
-    let pDepth = 1;
-    while (pScan < providerEndBrace && pDepth > 0) {
-      const ch = clean[pScan];
-      if (ch === '"') {
-        // Read the string (key or value) fully
-        const strEnd = clean.indexOf('"', pScan + 1);
-        if (strEnd < 0) break;
-        const str = clean.slice(pScan + 1, strEnd);
-        if (pDepth === 1 && str === 'compat') {
-          // Confirm it's a key: next non-ws char must be ':'
-          let after = strEnd + 1;
-          while (after < providerEndBrace && (clean[after] === ' ' || clean[after] === '\n' || clean[after] === '\r' || clean[after] === '\t')) after++;
-          if (clean[after] === ':') {
-            after++;
-            while (after < providerEndBrace && (clean[after] === ' ' || clean[after] === '\n' || clean[after] === '\r' || clean[after] === '\t')) after++;
-            if (clean[after] === '{') {
-              providerCompatBrace = after;
-              let d = 1;
-              let s = after + 1;
-              while (s < clean.length && d > 0) {
-                if (clean[s] === '"') {
-                  const e = clean.indexOf('"', s + 1);
-                  if (e < 0) break;
-                  s = e + 1;
-                  continue;
-                }
-                if (clean[s] === '{') d++;
-                else if (clean[s] === '}') d--;
-                if (d > 0) s++;
-              }
-              providerCompatEnd = s;
-              pScan = s + 1;
-              continue;
-            }
-          }
-        }
-        pScan = strEnd + 1;
-        continue;
+  const providerCompatKey = findJsonObjectKey(clean, providerBrace, "compat");
+  if (providerCompatKey && providerCompatKey.keyStart < providerEndBrace) {
+    const brace = skipJsonWhitespace(clean, providerCompatKey.valueStart);
+    if (clean[brace] === "{") {
+      const end = findMatchingBracket(clean, brace);
+      if (end !== undefined && end <= providerEndBrace) {
+        providerCompatBrace = brace;
+        providerCompatEnd = end;
       }
-      if (ch === '{' || ch === '[') pDepth++;
-      else if (ch === '}' || ch === ']') pDepth--;
-      pScan++;
     }
   }
 
-  // Now find the `"models"` array within the provider
-  const providerContent = clean.slice(providerBrace + 1, providerEndBrace);
-  const modelsIdx = providerContent.indexOf('"models"');
-  if (modelsIdx < 0) return undefined;
+  const modelsKey = findJsonObjectKey(clean, providerBrace, "models");
+  if (!modelsKey || modelsKey.keyStart > providerEndBrace) return undefined;
 
-  // Find the `[` of the models array
-  let modelsScan = providerBrace + 1 + modelsIdx + '"models"'.length;
-  while (modelsScan < clean.length && clean[modelsScan] !== '[') modelsScan++;
-  if (modelsScan >= clean.length) return undefined;
+  let modelsScan = skipJsonWhitespace(clean, modelsKey.valueStart);
+  if (clean[modelsScan] !== "[") return undefined;
+  const modelsEnd = findMatchingBracket(clean, modelsScan);
+  if (modelsEnd === undefined || modelsEnd > providerEndBrace) return undefined;
   modelsScan++; // Skip `[`
 
   // Scan ALL array elements: collect every model id, and record the target's position
@@ -4379,83 +4357,52 @@ function locateModelInJsonc(
   let compatBrace = -1;
   let compatEndBrace = -1;
 
-  while (modelsScan < clean.length) {
-    // Skip whitespace/comma
-    while (modelsScan < clean.length && (clean[modelsScan] === ' ' || clean[modelsScan] === '\n' || clean[modelsScan] === '\r' || clean[modelsScan] === '\t' || clean[modelsScan] === ',')) modelsScan++;
-    if (modelsScan >= clean.length) break;
-    if (clean[modelsScan] === ']') break; // End of array
-
-    if (clean[modelsScan] !== '{') { modelsScan++; continue; }
+  while (modelsScan < modelsEnd) {
+    modelsScan = skipJsonWhitespace(clean, modelsScan);
+    if (clean[modelsScan] === ',') {
+      modelsScan++;
+      continue;
+    }
+    if (modelsScan >= modelsEnd || clean[modelsScan] === ']') break;
+    if (clean[modelsScan] !== '{') return undefined;
 
-    // Found a model object `{`
     const elementBrace = modelsScan;
+    const elementEnd = findMatchingBracket(clean, elementBrace);
+    if (elementEnd === undefined || elementEnd > modelsEnd) return undefined;
 
-    // Find the matching closing `}` and extract this element's `"id"` at depth 1
-    let depth = 1;
-    let scan = modelsScan + 1;
+    const idKey = findJsonObjectKey(clean, elementBrace, "id");
     let elementId: string | undefined;
-
-    while (scan < clean.length && depth > 0) {
-      if (clean[scan] === '"') {
-        const strEnd = clean.indexOf('"', scan + 1);
-        if (strEnd < 0) break;
-        if (depth === 1 && elementId === undefined && clean.slice(scan, scan + 4) === '"id"') {
-          // Found "id" key — find the colon and the value
-          let afterKey = scan + 4;
-          while (afterKey < clean.length && clean[afterKey] !== ':') afterKey++;
-          if (afterKey < clean.length) {
-            afterKey++; // skip ':'
-            while (afterKey < clean.length && (clean[afterKey] === ' ' || clean[afterKey] === '\n' || clean[afterKey] === '\r' || clean[afterKey] === '\t')) afterKey++;
-            if (afterKey < clean.length && clean[afterKey] === '"') {
-              const idStart = afterKey + 1;
-              const idEnd = clean.indexOf('"', idStart);
-              if (idEnd > idStart) {
-                elementId = clean.slice(idStart, idEnd);
-              }
-            }
-          }
-        }
-        scan = strEnd + 1;
-        continue;
+    if (idKey && idKey.keyStart < elementEnd) {
+      const idValueStart = skipJsonWhitespace(clean, idKey.valueStart);
+      const idLiteral = readJsonStringLiteral(clean, idValueStart);
+      if (idLiteral && idLiteral.end <= elementEnd) {
+        elementId = idLiteral.value;
       }
-      if (clean[scan] === '{') depth++;
-      else if (clean[scan] === '}') depth--;
-      scan++;
     }
 
-    const elementEnd = scan - 1; // The `}` that closed this element
-
     if (elementId !== undefined) {
       allModelIds.push(elementId);
     }
 
     if (elementId === modelId && modelBrace < 0) {
-      // This is the target model — record its position and find its compat
       modelBrace = elementBrace;
       modelEndBrace = elementEnd;
-      const modelContent = clean.slice(modelBrace + 1, modelEndBrace);
-      const compatIdx = modelContent.indexOf('"compat"');
-      if (compatIdx >= 0) {
-        compatKeyStartClean = modelBrace + 1 + compatIdx;
-        let compatScan = compatKeyStartClean + '"compat"'.length;
-        while (compatScan < clean.length && clean[compatScan] !== ':') compatScan++;
-        compatScan++;
-        while (compatScan < clean.length && (clean[compatScan] === ' ' || clean[compatScan] === '\n' || clean[compatScan] === '\r' || clean[compatScan] === '\t')) compatScan++;
-        if (compatScan < clean.length && clean[compatScan] === '{') {
-          compatBrace = compatScan;
-          let cdepth = 1;
-          let cscan = compatScan + 1;
-          while (cscan < clean.length && cdepth > 0) {
-            if (clean[cscan] === '{') cdepth++;
-            else if (clean[cscan] === '}') cdepth--;
-            if (cdepth > 0) cscan++;
+
+      const compatKey = findJsonObjectKey(clean, modelBrace, "compat");
+      if (compatKey && compatKey.keyStart < modelEndBrace) {
+        compatKeyStartClean = compatKey.keyStart;
+        const brace = skipJsonWhitespace(clean, compatKey.valueStart);
+        if (clean[brace] === "{") {
+          const end = findMatchingBracket(clean, brace);
+          if (end !== undefined && end <= modelEndBrace) {
+            compatBrace = brace;
+            compatEndBrace = end;
           }
-          compatEndBrace = cscan;
         }
       }
     }
 
-    modelsScan = scan;
+    modelsScan = elementEnd + 1;
   }
 
   if (modelBrace < 0 || modelEndBrace < 0) return undefined;
@@ -4596,6 +4543,48 @@ function decideFixPlacement(
   };
 }
 
+function findExistingCompatKeysInJsonc(
+  original: string,
+  compatBrace: number,
+  compatEnd: number,
+  keys: string[],
+): string[] {
+  if (compatBrace < 0 || compatEnd <= compatBrace) return [];
+  const clean = stripJsoncComments(original);
+  return keys.filter((key) => {
+    const found = findJsonObjectKey(clean, compatBrace, key);
+    return !!found && found.keyStart < compatEnd;
+  });
+}
+
+function chooseFixPlacement(
+  original: string,
+  location: ModelNodeLocation,
+  compatKeys: Record<string, unknown>,
+  providerLabel: string,
+): { placement: "provider" | "model"; reason: string } {
+  const decision = decideFixPlacement(compatKeys, providerLabel, location.allModelIds);
+  const existingModelKeys = findExistingCompatKeysInJsonc(
+    original,
+    location.compatObjectBrace,
+    location.compatObjectEnd,
+    Object.keys(compatKeys),
+  );
+
+  // Provider-level writes cannot override a model-level compat key because Pi's
+  // merge order is provider.compat then model.compat. If the active model already
+  // has one of the keys we need to repair (e.g. thinkingFormat: "legacy"), write
+  // at model level even when the key would otherwise be provider-safe.
+  if (decision.placement === "provider" && existingModelKeys.length > 0) {
+    return {
+      placement: "model",
+      reason: `model-level compat already contains ${existingModelKeys.join(", ")} — repairing the active model override directly`,
+    };
+  }
+
+  return decision;
+}
+
 function composeFixInsertion(
   original: string,
   location: ModelNodeLocation,
@@ -4607,14 +4596,12 @@ function composeFixInsertion(
   const targetCompatEnd = placement === "provider" ? location.providerCompatEnd : location.compatObjectEnd;
   const containerBrace = placement === "provider" ? location.providerObjectBrace : location.modelObjectBrace;
 
-  // Helper: format the new keys as lines with the given indent, alphabetically sorted.
-  const formatKeys = (indent: string): string =>
-    Object.entries(compatKeys)
-      .sort(([a], [b]) => a.localeCompare(b))
-      .map(([k, v]) => {
-        const val = typeof v === 'string' ? `"${v}"` : JSON.stringify(v);
-        return `${indent}${JSON.stringify(k)}: ${val}`;
-      })
+  // Helper: format key/value pairs as lines with the given indent,
+  // alphabetically sorted for stable previews and deterministic edits.
+  const sortedEntries = Object.entries(compatKeys).sort(([a], [b]) => a.localeCompare(b));
+  const formatEntries = (indent: string, entries: Array<[string, unknown]>): string =>
+    entries
+      .map(([k, v]) => `${indent}${JSON.stringify(k)}: ${JSON.stringify(v)}`)
       .join(',\n');
 
   // Helper: line-start indentation of the line containing `offset` in `original`.
@@ -4627,25 +4614,52 @@ function composeFixInsertion(
   };
 
   if (targetCompatBrace >= 0 && targetCompatEnd > targetCompatBrace) {
-    // ── Existing compat object: insert new key lines right after `{`. ──
-    // The existing interior is preserved BYTE-FOR-BYTE (no reflow, no re-indent).
+    // ── Existing compat object: insert absent keys and surgically replace
+    // direct existing keys whose value is wrong (e.g. thinkingFormat: "legacy").
+    // Unrelated interior bytes/comments/key order are preserved.
     const interiorStart = targetCompatBrace + 1;
     const interior = original.slice(interiorStart, targetCompatEnd);
     const hasContent = interior.trim().length > 0;
+    const clean = stripJsoncComments(original);
 
-    // Indent for the new key lines: copy the first existing key line's indent,
+    // Indent for inserted key lines: copy the first existing key line's indent,
     // else derive one level deeper than the compat brace's own line.
     const braceLineIndent = lineIndentAt(targetCompatBrace);
     const innerMatch = interior.match(/\r?\n([ \t]+)\S/);
     const innerIndent = innerMatch ? innerMatch[1] : braceLineIndent + '  ';
-    const keysFormatted = formatKeys(innerIndent);
 
-    if (hasContent) {
-      // `{` + "\n<new keys>," + <original interior untouched> + `}`
-      return original.slice(0, interiorStart) + `\n${keysFormatted},` + original.slice(interiorStart);
+    const edits: Array<{ start: number; end: number; text: string }> = [];
+    const missingEntries: Array<[string, unknown]> = [];
+
+    for (const [key, value] of sortedEntries) {
+      const existing = findJsonObjectKey(clean, targetCompatBrace, key);
+      if (existing && existing.keyStart < targetCompatEnd) {
+        const valueStart = skipJsonWhitespace(clean, existing.valueStart);
+        const valueEnd = skipJsonValue(clean, valueStart);
+        if (valueEnd !== undefined && valueEnd <= targetCompatEnd) {
+          const nextValue = JSON.stringify(value);
+          if (original.slice(valueStart, valueEnd) !== nextValue) {
+            edits.push({ start: valueStart, end: valueEnd, text: nextValue });
+          }
+          continue;
+        }
+      }
+      missingEntries.push([key, value]);
+    }
+
+    if (missingEntries.length > 0) {
+      const keysFormatted = formatEntries(innerIndent, missingEntries);
+      if (hasContent) {
+        edits.push({ start: interiorStart, end: interiorStart, text: `\n${keysFormatted},` });
+      } else {
+        edits.push({ start: interiorStart, end: targetCompatEnd, text: `\n${keysFormatted}\n${braceLineIndent}` });
+      }
     }
-    // Empty compat `{}` (or whitespace only): write keys + put `}` back on its own line.
-    return original.slice(0, interiorStart) + `\n${keysFormatted}\n${braceLineIndent}` + original.slice(targetCompatEnd);
+
+    // Apply later edits first so earlier offsets remain valid.
+    return edits
+      .sort((a, b) => b.start - a.start)
+      .reduce((text, edit) => text.slice(0, edit.start) + edit.text + text.slice(edit.end), original);
   }
 
   // ── No compat object yet: create one right after the container `{`. ──
@@ -4666,12 +4680,12 @@ function composeFixInsertion(
     : '  ';
   const innerIndent = keyIndent + unit;
 
-  const compatBlock = `\n${keyIndent}"compat": {\n${formatKeys(innerIndent)}\n${keyIndent}},`;
+  const compatBlock = `\n${keyIndent}"compat": {\n${formatEntries(innerIndent, sortedEntries)}\n${keyIndent}},`;
   return original.slice(0, afterBrace) + compatBlock + suffix;
 }
 
 /**
- * Self-check after compose: parse original and modified via stripJsoncComments,
+ * Self-check after compose: parse original and modified as JSONC,
  * assert target compat flags exist in the right path, and remaining structure
  * is deep-equal (ignoring the inserted keys).
  * Returns null on success, error message on failure.
@@ -4684,17 +4698,17 @@ function selfCheckFix(
   compatKeys: Record<string, unknown>,
 ): string | null {
   try {
-    // Step 1: Parse both versions (this validates JSON syntax)
-    const origParsed = JSON.parse(stripJsoncComments(original));
-    const modParsed = JSON.parse(stripJsoncComments(modified));
+    // Step 1: Parse both versions as JSONC (comments + trailing commas allowed).
+    const origParsed = parseJsonc(original);
+    const modParsed = parseJsonc(modified);
 
     // Step 2: Validate modified file has correct structure
-    const providers = modParsed?.providers;
-    if (!providers || typeof providers !== 'object') {
+    const providers = asRecord(asRecord(modParsed)?.providers);
+    if (!providers) {
       return "Modified file: providers object missing or invalid";
     }
-    const provider = providers[providerLabel];
-    if (!provider || typeof provider !== 'object') {
+    const provider = asRecord(providers[providerLabel]);
+    if (!provider) {
       return `Modified file: provider "${providerLabel}" not found`;
     }
 
@@ -4712,6 +4726,18 @@ function selfCheckFix(
     if (!targetModel || typeof targetModel !== 'object') {
       return `Modified file: model "${modelId}" not found in provider`;
     }
+
+    // Locate the corresponding original provider/model objects. The structure
+    // preservation check below may allow repaired compat values to differ, but
+    // only on these exact target/provider compat objects — never on siblings.
+    const origProviders = asRecord(asRecord(origParsed)?.providers);
+    const origProvider = asRecord(origProviders?.[providerLabel]);
+    const origModels = Array.isArray(origProvider?.models) ? origProvider.models : undefined;
+    const origTargetModel = origModels?.find((m: unknown) => asRecord(m)?.id === modelId);
+    const origTargetModelRecord = asRecord(origTargetModel);
+    if (!origProvider || !origTargetModelRecord) {
+      return `Original file: provider/model "${providerLabel}/${modelId}" not found`;
+    }
     
     // Step 5: Compute the EFFECTIVE merged compat (provider-level + model-level),
     // mirroring Pi's mergeCompat behavior (model wins on conflicts). The fix may
@@ -4754,15 +4780,23 @@ function selfCheckFix(
       for (const key of Object.keys(origObj)) {
         if (!(key in modObj)) return false;
         if (key === 'compat') {
-          // For compat, allow extra keys in modified (the inserted ones)
+          // For compat, allow extra keys in modified (the inserted ones).
+          // Use recursive isSubset so nested objects (e.g. { deep: true })
+          // are compared by content, not reference.
           if (typeof origObj[key] !== 'object' || typeof modObj[key] !== 'object') {
             if (origObj[key] !== modObj[key]) return false;
           } else {
-            // Check all original compat keys are present and equal
             const origCompat = origObj[key] as Record<string, unknown>;
             const modCompat = modObj[key] as Record<string, unknown>;
+            const mayRepairThisCompat = origObj === origProvider || origObj === origTargetModelRecord;
             for (const ck of Object.keys(origCompat)) {
-              if (origCompat[ck] !== modCompat[ck]) return false;
+              if (!(ck in modCompat)) return false;
+              // The fix may repair an existing wrong compat value (for example
+              // thinkingFormat: "legacy" -> "deepseek"), but only on the
+              // target provider/model compat objects. Sibling compat blocks must
+              // remain structure-equivalent.
+              if (mayRepairThisCompat && Object.prototype.hasOwnProperty.call(compatKeys, ck)) continue;
+              if (!isSubset(origCompat[ck], modCompat[ck], `${path}.${ck}`)) return false;
             }
           }
         } else if (!isSubset(origObj[key], modObj[key], `${path}.${key}`)) {
@@ -4781,11 +4815,17 @@ function selfCheckFix(
       return "Modified file: content is shorter than original (possible truncation)";
     }
     
-    // Step 9: Validate no syntax issues by checking brackets balance
-    const openBraces = (modified.match(/{/g) || []).length;
-    const closeBraces = (modified.match(/}/g) || []).length;
-    if (openBraces !== closeBraces) {
-      return `Modified file: bracket mismatch (${openBraces} open, ${closeBraces} close)`;
+    // Step 9: Validate root bracket integrity with the same string/comment-aware
+    // scanner used for edits. Do not count raw braces: comments or strings may
+    // legitimately contain unmatched `{` / `}` bytes.
+    const modifiedClean = stripJsoncComments(modified);
+    const rootStart = skipJsonWhitespace(modifiedClean, 0);
+    const rootEnd = findMatchingBracket(modifiedClean, rootStart);
+    if (rootEnd === undefined) {
+      return "Modified file: root bracket mismatch";
+    }
+    if (skipJsonWhitespace(modifiedClean, rootEnd + 1) !== modifiedClean.length) {
+      return "Modified file: trailing non-whitespace content after root object";
     }
 
     return null;
@@ -4801,8 +4841,7 @@ function selfCheckFix(
 function formatCompatKeysForInsertion(compatKeys: Record<string, unknown>): string {
   return Object.entries(compatKeys)
     .map(([k, v]) => {
-      const val = typeof v === 'string' ? `"${v}"` : String(v);
-      return `  ${JSON.stringify(k)}: ${val}`;
+      return `  ${JSON.stringify(k)}: ${JSON.stringify(v)}`;
     })
     .join(',\n');
 }
@@ -4852,6 +4891,7 @@ export const __internals_for_tests = {
   isOpenAIFamilyToken,
   describeMissingOpenAIFamilyProxyCompat,
   describeMissingOpenAICompatibleProxyCompat,
+  describeOptionalOpenAICompatibleProxyCompat,
   describeMissingDeepSeekCompat,
   isDeepSeekCompatCheckApplicable,
   describeMissingCacheCompatForModel,
@@ -5033,10 +5073,14 @@ export const __internals_for_tests = {
   // JSONC surgical edit helpers
   MODELS_JSON_PATH,
   stripJsoncComments,
+  stripJsoncTrailingCommas,
+  parseJsonc,
   locateModelInJsonc,
   composeFixInsertion,
   selfCheckFix,
   decideFixPlacement,
+  chooseFixPlacement,
+  findExistingCompatKeysInJsonc,
   deepEqualIgnoringKeys,
   formatCompatKeysForInsertion,
   backupTimestamp,
@@ -5400,8 +5444,11 @@ export default function (pi: ExtensionAPI) {
     // changes and day rollovers. Redundant setStatus calls are blocked by the
     // `lastStatusText` early return above.
     if (runtimeOptimizerEnabled && statusText !== undefined && model) {
-      const compatMissing = describeMissingCacheCompatForModel(model);
-      if (compatMissing.length > 0) {
+      // Only show ⚠️ compat when there are safe-fixable missing compat keys.
+      // Optional/advisory-only flags (e.g. supportsLongCacheRetention on generic
+      // OpenAI-compatible proxies) do NOT trigger the marker — the doctor/compat
+      // commands still mention them as optional guidance.
+      if (buildFixSuggestion(model) !== undefined) {
         statusText = statusText + " ⚠️ compat";
       }
     }
@@ -5755,7 +5802,7 @@ export default function (pi: ExtensionAPI) {
 
         // Compose the modified text — auto-detect the best placement level:
         // provider level (channel-wide) when safe for all sibling models, else model level.
-        const decision = decideFixPlacement(suggestion.compatKeys, suggestion.providerLabel, location.allModelIds);
+        const decision = chooseFixPlacement(originalText, location, suggestion.compatKeys, suggestion.providerLabel);
         const modifiedText = composeFixInsertion(originalText, location, suggestion.compatKeys, decision.placement);
 
         // Self-check
@@ -5769,10 +5816,9 @@ export default function (pi: ExtensionAPI) {
           return;
         }
 
-        // Build preview snippet
-        const keysPreview = Object.entries(suggestion.compatKeys)
-          .map(([k, v]) => `    ${k}: ${JSON.stringify(v)}`)
-          .join("\n");
+        // Build preview snippet as copyable JSON (the surgical editor will
+        // insert or repair these exact compat key/value pairs).
+        const keysPreview = JSON.stringify(suggestion.compatKeys, null, 2);
         const targetHasCompat = decision.placement === "provider" ? location.providerCompatBrace >= 0 : location.compatObjectBrace >= 0;
         const placementDesc = targetHasCompat ? `existing "compat" object` : `new "compat" object`;
         const locationDesc = decision.placement === "provider"
@@ -5791,7 +5837,7 @@ export default function (pi: ExtensionAPI) {
           ``,
           `Location: ${locationDesc}`,
           `Placement: ${decision.placement} level — ${decision.reason}`,
-          `Keys to insert:`, 
+          `Compat JSON to write:`,
           keysPreview,
           ``, 
           `⚠️  Risk notice:`,
@@ -5948,7 +5994,7 @@ export default function (pi: ExtensionAPI) {
               return;
             }
 
-            const menuDecision = decideFixPlacement(suggestion.compatKeys, suggestion.providerLabel, location.allModelIds);
+            const menuDecision = chooseFixPlacement(originalText, location, suggestion.compatKeys, suggestion.providerLabel);
             const modifiedText = composeFixInsertion(originalText, location, suggestion.compatKeys, menuDecision.placement);
             const checkError = selfCheckFix(originalText, modifiedText, suggestion.providerLabel, suggestion.modelId, suggestion.compatKeys);
             if (checkError !== null) {
@@ -5956,9 +6002,7 @@ export default function (pi: ExtensionAPI) {
               return;
             }
 
-            const keysPreview = Object.entries(suggestion.compatKeys)
-              .map(([k, v]) => `    ${k}: ${JSON.stringify(v)}`)
-              .join("\n");
+            const keysPreview = JSON.stringify(suggestion.compatKeys, null, 2);
             const ts = backupTimestamp();
             const backupPath = `${MODELS_JSON_PATH}.backup-cache-optimizer-${ts}`;
 
@@ -5973,7 +6017,7 @@ export default function (pi: ExtensionAPI) {
               `📝 Preview of changes to ${getModelsJsonDisplayPath()}:`,
               `Location: ${menuLocationDesc}`,
               `Placement: ${menuDecision.placement} level — ${menuDecision.reason}`,
-              `Keys to insert:`, 
+              `Compat JSON to write:`,
               keysPreview,
               ``, 
               `⚠️  Risk notice:`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cache-optimizer",
-  "version": "2.6.4",
+  "version": "2.6.5",
   "description": "Improve Pi prompt/KV cache hit rates with stable prompts, OpenAI-compatible cache keys, proxy compat warnings, and footer cache stats.",
   "keywords": [
     "pi-package",