codex-copilot-dx 0.9.23 → 0.9.25

package/src/cli-image.mjs

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
-import path from "node:path";
 import readline from "node:readline";
 import { createInterface } from "node:readline/promises";
+import { codexPaths } from "./codex-paths.mjs";
+import { withFileLockSync } from "./lock.mjs";
 import { atomicWriteFileIfChangedSync, atomicWriteFilePairSync } from "./atomic-file.mjs";
 import { terminalCell } from "./cli-table.mjs";
 import { computeImageMcpCodexConfig } from "./config.mjs";
@@ -15,11 +16,6 @@ import {
   readImageProviderConfig,
   validateImageProviderConfig,
 } from "./image-provider-config.mjs";
-
-function defaultCodexConfigPath(home) {
-  return path.join(home, ".codex", "config.toml");
-}
-
 async function visibleQuestion(input, output, question) {
   const prompt = createInterface({ input, output });
   try { return await prompt.question(question); }
@@ -102,7 +98,10 @@ function configSummary(config) {
   };
 }
 
-function enableImageProvider({ providerConfig, providerPath, codexPath, codexContent, adapterPort, adapterHost }) {
+function enableImageProvider(options) {
+  return withFileLockSync(`${options.codexPath}.ccdx.lock`, () => enableImageProviderUnlocked(options));
+}
+function enableImageProviderUnlocked({ providerConfig, providerPath, codexPath, codexContent, adapterPort, adapterHost }) {
   const codex = computeImageMcpCodexConfig(codexContent, {
     enabled: true,
     adapterPort,
@@ -128,7 +127,11 @@ function enableImageProvider({ providerConfig, providerPath, codexPath, codexCon
   return { codexChanged: codex.changed, config: normalized };
 }
 
-function disableImageProvider({ providerPath, codexPath, codexContent, adapterPort, adapterHost }) {
+function disableImageProvider(options) {
+  if (!fs.existsSync(options.codexPath)) return disableImageProviderUnlocked(options);
+  return withFileLockSync(`${options.codexPath}.ccdx.lock`, () => disableImageProviderUnlocked(options));
+}
+function disableImageProviderUnlocked({ providerPath, codexPath, codexContent, adapterPort, adapterHost }) {
   const codex = computeImageMcpCodexConfig(codexContent, {
     enabled: false,
     adapterPort,
@@ -154,7 +157,7 @@ function disableImageProvider({ providerPath, codexPath, codexContent, adapterPo
   return { changed: providerExists || codex.changed || skill.changed, preservedGuidance: Boolean(skill.preserved) };
 }
 
-export function syncEnabledImageSkill({ home = os.homedir(), codexPath = defaultCodexConfigPath(home), ...options } = {}) {
+export function syncEnabledImageSkill({ home = os.homedir(), env = process.env, codexPath = codexPaths({ env, home }).config, ...options } = {}) {
   return updateImageSkill({ ...options, enabled: true, codexPath });
 }
 
@@ -179,7 +182,7 @@ export async function runImageCommand({
   probeFetchImpl = fetch,
   adapterPort = 2026,
   adapterHost = "127.0.0.1",
-  codexPath = defaultCodexConfigPath(home),
+  codexPath = codexPaths({ env, home }).config,
 } = {}) {
   const providerPath = imageProviderConfigPath({ env, home });
   if (action === "status") {

package/src/cli-options.mjs

@@ -28,6 +28,7 @@ const HELP_TOPICS = new Set([
   "image-status",
   "auto-review-model",
   "suggestion",
+  "prediction",
   "update",
   "version",
 ]);
@@ -252,11 +253,18 @@ export function parseCliArgs(args = []) {
     if (rest.length) unexpectedArgs(rest);
     return baseCommand("animation");
   }
+  if (command === "prediction") {
+    const [action = "status", ...extra] = rest;
+    if (!["on", "off", "status"].includes(action)) throw new Error("Prediction action must be on, off, or status");
+    if (extra.length) unexpectedArgs(extra);
+    return baseCommand("prediction", { action });
+  }
   if (command === "suggestion") {
     const [action = "status", model, ...extra] = rest;
     if (!["on", "off", "model", "status"].includes(action)) throw new Error("Suggestion action must be on, off, model, or status");
     if (extra.length || (model !== undefined && action !== "model")) unexpectedArgs(rest.slice(1));
-    return baseCommand("suggestion", { action, ...(model !== undefined ? { model } : {}) });
+    if (["on", "model"].includes(action)) throw new Error("The CCDX prediction panel has been retired; use ccdx prediction for the separate optional native feature");
+    return baseCommand("suggestion", { action });
   }
   if (command === "enable-image" || command === "disable-image" || command === "image-status") {
     if (rest.length) unexpectedArgs(rest);
@@ -363,7 +371,8 @@ function topicHelp(name, topic) {
     "disable-image": `Usage:\n  ${name} disable-image\n\nDisables the local CCDX image tool and removes its stored API credential and unmodified CCDX image guidance.`,
     "image-status": `Usage:\n  ${name} image-status\n\nShows provider configuration and locally advertised generation/editing tools without generating an image or exposing its API key.`,
     "auto-review-model": `Usage:\n  ${name} auto-review-model\n\nSelect a Responses model, then an advertised reasoning effort. Enter keeps the default/current choice; q cancels both steps without saving. Effort 0 follows the client (low when omitted). Settings apply only to Auto-review on the next request; no client patch or restart is required for adapters running 0.9.13 or newer.`,
-    "suggestion": `Usage:\n  ${name} suggestion on\n  ${name} suggestion off\n  ${name} suggestion model [MODEL_ID]\n  ${name} suggestion status\n\nOptional next-message panel; disabled by default. Open it in a local Codex conversation to generate a suggestion, then choose Add to draft. Ordinary text only: no client patch, background prediction, automatic insertion or sending. Model selection alone does not enable the feature. Requires a running local adapter and recent Codex. Existing user-owned MCP configuration is preserved; native prediction settings are never modified. Future account/remote defaults cannot be universally detected.`,
+    "suggestion": `The CCDX prediction panel has been retired. Run ${name} suggestion off to safely remove unchanged CCDX registrations. This cleanup does not change native predictions; see ${name} prediction --help for that separate opt-in feature.`,
+    prediction: `Usage:\n  ${name} prediction [status|on|off]\n\nOptional native next-message predictions; off by default. macOS only. Quit Codex before on/off, then restart ccdx. On adds private App-profile certificate trust and an App-only route for chatgpt.com and ab.chatgpt.com. HTTPS on those hosts is decrypted locally; only prediction configuration is changed. No client program files, OS trust, account permissions, MCP or Hooks are changed. Static HTTP/HTTPS/SOCKS5 proxies and bypass rules are preserved; dynamic PAC/WPAD and CIDR bypass rules are reported as unsupported. Official prediction configuration is preserved; the conversation's model is used. App updates require another compatibility check. Status distinguishes saved preference and observed config traffic from unverified candidate visibility.`,
     update: `Usage:\n  ${name} update [npm|github]\n\nUpdates the global package from the configured npm registry or the latest stable GitHub release. With no source, an interactive terminal prompts for one.`,
     version: `Usage:\n  ${name} --version`,
   };
@@ -389,7 +398,7 @@ export function cliHelp(commandName = "ccdx", topic = "") {
   ${name} disable-image
   ${name} image-status
   ${name} auto-review-model
-  ${name} suggestion on|off|model|status
+  ${name} prediction [status|on|off]
   ${name} update [npm|github]
   ${name} --version
   ${name} --help
@@ -408,7 +417,7 @@ Commands:
   disable-image      Disable the image provider and remove its credential
   image-status       Show the optional image provider status
   auto-review-model  Select the Codex Auto-review model and reasoning effort
-  suggestion         Optional next-message suggestions (off by default)
+  prediction         Toggle optional native next-message predictions
   update             Update the global package from npm or GitHub
 
 Run ${name} <command> --help for command details.`;

package/src/cli-status.mjs

@@ -188,6 +188,11 @@ export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", c
     }
   }
   lines.push(status("info", `Models: ${count(models.models)} total; Copilot token ${copilot.token_cached ? `cached (${duration(copilot.token_expires_in_ms)} remaining)` : "not cached"}`));
+  const prediction = data.client_integrations?.prediction;
+  if (prediction) {
+    lines.push(status("info", `Native predictions: ${prediction.configured ? "on" : "off"}; bridge ${prediction.bridge}; client route ${prediction.client_route}; visible candidate unknown`));
+    if (prediction.reason) lines.push(status("warn", terminalCell(prediction.reason).slice(0, 400)));
+  }
   if (data.profiles?.codex) {
     lines.push(status("info", `Profile: ${profileSummary("Codex", data.profiles.codex)}`));
   }

package/src/client-integration.mjs

@@ -0,0 +1,41 @@
+import { ensureCodexConfig } from "./config.mjs";
+import { readImageProviderConfig } from "./image-provider-config.mjs";
+import { ensureCodexThreadCompression } from "./codex-thread-compression.mjs";
+import { runInBackground } from "./startup.mjs";
+import { createPredictionState } from "./native-prediction-state.mjs";
+
+// The CLI composes the services; this module owns optional client integration
+// lifecycle. It never forwards model requests or depends on dashboard rendering.
+export function createClientIntegration({ port, host, info = () => {}, warning = () => {} } = {}) {
+  const prediction = createPredictionState();
+  let native = null;
+  return {
+    async configure() {
+      try {
+        const { retirePredictionIntegration } = await import("./prediction-retirement.mjs");
+        const result = retirePredictionIntegration();
+        if (result.changed) info("Removed the retired CCDX prediction integration");
+        if (result.preserved) warning("Modified prediction settings were preserved");
+      } catch (error) { warning(`${error.message}. Core startup will continue.`); }
+      const enabled = Boolean(readImageProviderConfig());
+      const { imageMcpSkipped } = ensureCodexConfig(port, { host, imageProviderEnabled: enabled });
+      if (enabled && !imageMcpSkipped) {
+        try {
+          const { syncEnabledImageSkill } = await import("./cli-image.mjs");
+          syncEnabledImageSkill({ adapterPort: port, adapterHost: host });
+        } catch (error) { warning(`Image guidance could not be updated: ${error.message}`); }
+      }
+      return { compressionSetup: runInBackground(ensureCodexThreadCompression) };
+    },
+    async start() {
+      try {
+        const { startNativePrediction } = await import("./native-prediction.mjs");
+        native = await startNativePrediction({ state: prediction, warning: info });
+      } catch (error) { prediction.unavailable(error); warning(`${error.message}. Core startup will continue.`); }
+      return native;
+    },
+    pacUrl() { return native?.pacUrl || null; },
+    snapshot() { return { prediction: prediction.snapshot() }; },
+    async close() { await native?.close(); native = null; },
+  };
+}

package/src/codex-config-doctor.mjs

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import os from "node:os";
-import path from "node:path";
+import { codexPaths } from "./codex-paths.mjs";
 import { isDeepStrictEqual } from "node:util";
 import { parse } from "smol-toml";
 import { computeUpdatedCodexConfig, initialCodexConfig } from "./config.mjs";
@@ -87,8 +87,8 @@ function checkUrl(value, expected, label) {
     : { kind: "warn", message: `${label} differs from the CCDX address ${expected}` };
 }
 
-export function inspectCodexConfig({ home = os.homedir(), host = "127.0.0.1", port = 2026 } = {}) {
-  const filePath = path.join(home, ".codex", "config.toml");
+export function inspectCodexConfig({ home = os.homedir(), env: processEnv = process.env, host = "127.0.0.1", port = 2026 } = {}) {
+  const filePath = codexPaths({ env: processEnv, home }).config;
   let content;
   try {
     content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(fs.readFileSync(filePath));

package/src/codex-paths.mjs

@@ -0,0 +1,10 @@
+import os from "node:os";
+import path from "node:path";
+
+export function codexPaths({ env = process.env, home = os.homedir() } = {}) {
+  const directory = path.resolve(String(env.CODEX_HOME || "").trim() || path.join(home, ".codex"));
+  const profile = path.resolve(String(env.CODEX_ELECTRON_USER_DATA_PATH || "").trim()
+    || path.join(home, "Library", "Application Support", "Codex"));
+  return { directory, config: path.join(directory, "config.toml"), profile,
+    certificateStore: path.join(profile, "Default", "ServerCertificate") };
+}

package/src/codex-thread-compression.mjs

@@ -6,6 +6,8 @@ import { promisify } from "node:util";
 import { CODEX_APP_BINARY_PATHS } from "./codex-model-catalog.mjs";
 import { parseCodexToml, codexTomlStatements, validateManagedConfigEdit } from "./config-toml.mjs";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { codexPaths } from "./codex-paths.mjs";
+import { withFileLockSync } from "./lock.mjs";
 import { status } from "./status.mjs";
 
 const FEATURE = "local_thread_store_compression";
@@ -70,7 +72,8 @@ export async function codexNeedsThreadCompressionDefault({
 }
 
 export async function ensureCodexThreadCompression({
-  filePath = path.join(os.homedir(), ".codex", "config.toml"),
+  env = process.env, home = os.homedir(),
+  filePath = codexPaths({ env, home }).config,
   probe = codexNeedsThreadCompressionDefault,
 } = {}) {
   try {
@@ -79,11 +82,13 @@ export async function ensureCodexThreadCompression({
     if (!await probe()) return;
     // The client/user may edit the shared file while the asynchronous probe runs.
     // Recompute against its current bytes; explicit opt-outs always win.
-    const updated = computeThreadCompressionDefault(read());
-    if (updated.changed) {
-      atomicWriteFileIfChangedSync(filePath, updated.content);
-      console.log(status("ok", "Enabled Codex local history compression (experimental)"));
-    }
+    withFileLockSync(`${filePath}.ccdx.lock`, () => {
+      const updated = computeThreadCompressionDefault(read());
+      if (updated.changed) {
+        atomicWriteFileIfChangedSync(filePath, updated.content);
+        console.log(status("ok", "Enabled Codex local history compression (experimental)"));
+      }
+    });
   } catch {
     console.warn(status("warn", "Optional Codex history compression setup was skipped; core proxy remains available"));
   }

package/src/config.mjs

@@ -1,13 +1,12 @@
 import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
 import { status } from "./status.mjs";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
 import { adapterBaseUrl } from "./running-adapter.mjs";
 import { isLoopbackHost } from "./security.mjs";
 import { codexTomlStatements, configValue, parseCodexToml, validateManagedConfigEdit } from "./config-toml.mjs";
+import { codexPaths } from "./codex-paths.mjs";
+import { withFileLockSync } from "./lock.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;
 const IMAGE_MCP_START = "# ccdx:image-mcp:start";
@@ -278,8 +277,13 @@ export function computeImageMcpCodexConfig(content, options = {}) {
   return computeImageConfig(content, options);
 }
 
-export function ensureCodexConfig(adapterPort = 2026, {
-  filePath = CONFIG_PATH,
+export function ensureCodexConfig(adapterPort = 2026, options = {}) {
+  const filePath = options.filePath || codexPaths(options).config;
+  return withFileLockSync(`${filePath}.ccdx.lock`, () => ensureCodexConfigUnlocked(adapterPort, { ...options, filePath }));
+}
+
+function ensureCodexConfigUnlocked(adapterPort = 2026, {
+  filePath,
   host = "127.0.0.1",
   imageProviderEnabled = false,
 } = {}) {
@@ -303,7 +307,7 @@ export function ensureCodexConfig(adapterPort = 2026, {
     console.log(status("ok", `Codex already points to ${baseUrl}`));
   } else {
     atomicWriteFileIfChangedSync(filePath, core.content);
-    console.log(status("ok", content === undefined ? "Created ~/.codex/config.toml" : `Configured Codex base URL: ${baseUrl}`));
+    console.log(status("ok", content === undefined ? `Created Codex configuration: ${filePath}` : `Configured Codex base URL: ${baseUrl}`));
   }
   // Disabled means no image maintenance, including no implicit removal of old
   // or user-owned entries. Explicit disable-image owns the cleanup operation.

package/src/copilot-responses-policy.mjs

@@ -1,10 +1,12 @@
+import { errorEvidenceText } from "./operation-error.mjs";
+
 function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
 }
 
 export function isEncryptedContentVerificationError(statusCode, text) {
   if (statusCode < 400 || !text) return false;
-  const lower = String(text).toLowerCase();
+  const lower = errorEvidenceText(text).toLowerCase();
   const reasoningFailure = lower.includes("encrypted content")
     && lower.includes("could not be verified")
     && (lower.includes("could not be decrypted") || lower.includes("could not be parsed"));
@@ -17,7 +19,7 @@ export function isEncryptedContentVerificationError(statusCode, text) {
 
 export function isImageNamespaceCollisionError(statusCode, text) {
   if (statusCode < 400 || !text) return false;
-  const lower = String(text).toLowerCase();
+  const lower = errorEvidenceText(text).toLowerCase();
   return lower.includes("namespace")
     && lower.includes("image_gen")
     && lower.includes("collid");

package/src/dashboard/index.html

@@ -50,12 +50,6 @@
           </article>
         </section>
 
-        <section class="panel dashboard-section" id="suggestion-panel">
-          <div class="panel-heading"><h2 data-i18n>NEXT MESSAGE</h2><span data-i18n>OPTIONAL</span></div>
-          <dl class="stats"><div><dt data-i18n>Status</dt><dd id="suggestion-enabled">—</dd></div><div><dt data-i18n>Model</dt><dd id="suggestion-model">—</dd></div><div><dt data-i18n>Auto generation</dt><dd id="suggestion-auto">—</dd></div><div><dt data-i18n>Draft insertion</dt><dd data-i18n>Choose Add to draft</dd></div></dl>
-          <p id="suggestion-recent" class="hint" role="status">—</p><p id="suggestion-detail" class="hint">—</p><p class="hint"><span data-i18n>Commands</span>: <code>ccdx suggestion on|off|model|status</code></p>
-        </section>
-
         <details class="panel dashboard-section" id="request-context">
           <summary data-i18n>RECENT REQUEST CONTEXT</summary>
           <p id="context-note" class="table-note">—</p>
@@ -63,6 +57,13 @@
           <p class="hint" data-i18n>Recent upstream request metadata, not exact live session occupancy. Missing values are unknown. No prompt or image content is retained.</p>
         </details>
 
+        <section class="panel dashboard-section" aria-label="CLIENT FEATURES" data-i18n-label>
+          <div class="panel-heading"><h2 data-i18n>CLIENT FEATURES</h2><span data-i18n>OBSERVED STATE</span></div>
+          <dl class="stats"><div><dt data-i18n>Native predictions</dt><dd id="prediction-preference">—</dd></div><div><dt data-i18n>Local bridge</dt><dd id="prediction-bridge">—</dd></div><div><dt data-i18n>Client route</dt><dd id="prediction-route">—</dd></div><div><dt data-i18n>Visible candidate</dt><dd id="prediction-candidate">—</dd></div></dl>
+          <p id="prediction-note" class="hint">—</p>
+          <p class="hint" data-i18n>Configured does not mean displayed. Use ccdx prediction status for details.</p>
+        </section>
+
         <section class="panel dashboard-section" aria-label="Live upstream models" data-i18n-label>
           <div class="panel-heading"><h2 data-i18n>UPSTREAM GPT MODELS</h2><div class="heading-actions"><span id="models-state" data-i18n>CHECKING LIVE</span><button id="refresh-models" type="button" data-i18n>Refresh</button></div></div>
           <p id="models-note" class="table-note" data-i18n>Querying GitHub Copilot…</p>

package/src/dashboard/language.js

@@ -1,26 +1,18 @@
 (() => {
   const translations = {
-    "NEXT MESSAGE":["NEXT MESSAGE","下一句"],
-    "Status":["Status","状态"],
-    "Auto generation":["Auto generation","自动生成"],
-    "Configured; review hook":["Configured; review hook","已配置，需审核"],
-    "{time} / {reason}":["{time} / {reason}","{time} / {reason}"],
-    "Context unavailable":["Context unavailable","无法读取对话。"],
-    "Model request failed":["Model request failed","模型请求失败。"],
-    "Settings changed":["Settings changed","设置已变化。"],
-    "Conversation changed":["Conversation changed","对话已变化。"],
-    "Suggestion timed out":["Suggestion timed out","建议生成超时。"],
-    "No recorded error":["No recorded error","暂无错误记录。"],
-    "Draft insertion":["Draft insertion","加入草稿"],
-    "Choose Add to draft":["Click to add","点击加入"],
-    "Commands":["Commands","命令"],
-    "No automatic suggestion yet":["No automatic suggestion yet.","暂无自动建议。"],
-    "Generating suggestion":["Generating…","正在生成。"],
-    "Suggestion ready; open Next message":["Ready. Open Next message.","已生成，请打开下一句。"],
-    "No useful suggestion":["No useful suggestion.","暂无合适建议。"],
-    "Suggestion failed; retry manually":["Failed. Retry in Next message.","生成失败，请手动重试。"],
-    "Suggestion cancelled":["Cancelled.","已取消。"],
-    "Run ccdx suggestion status":["Run ccdx suggestion status.","请用命令检查设置。"],
+    "CLIENT FEATURES": ["CLIENT FEATURES", "接入能力"],
+    "OBSERVED STATE": ["OBSERVED STATE", "实际状态"],
+    "Native predictions": ["Native predictions", "输入建议"],
+    "Local bridge": ["Local bridge", "本地接入"],
+    "Client route": ["Client route", "配置请求"],
+    "Visible candidate": ["Visible candidate", "显示结果"],
+    "Configured does not mean displayed. Use ccdx prediction status for details.": ["Enabled is not proof of a visible suggestion. Check ccdx prediction status.", "开启不等于已显示。\n终端命令可查看详情。"],
+    "Enabled": ["Enabled", "已开启"],
+    "Disabled": ["Disabled", "已关闭"],
+    "Running": ["Running", "运行中"],
+    "Stopped": ["Stopped", "未运行"],
+    "Unavailable": ["Unavailable", "不可用"],
+    "Observed": ["Observed", "已收到配置请求"],
     "First output": ["First output", "首次输出"],
     "Token time": ["Token time", "输出耗时"],
     "Gateway timing. Token time is estimated.": ["Observed at the gateway. Token time is an estimate.", "网关观测时间。\n每Token耗时为估算值。"],

package/src/dashboard/ui.js

@@ -16,7 +16,6 @@ const finite = (value) => value !== null && value !== undefined && Number.isFini
 const number = (value) => finite(value) ? Math.max(0, Math.round(Number(value))).toLocaleString() : "—";
 const mib = (value) => finite(value) ? `${(Number(value) / 1048576).toFixed(1)} MiB` : "—";
 let authLoading = false;
-let suggestionLoading=false;
 let contextRequests = [];
 let contextCompactions = {};
 
@@ -41,23 +40,6 @@ async function loadAuth() {
   } finally { authLoading = false; }
 }
 
-async function loadSuggestion(){
-  if(suggestionLoading)return;
-  suggestionLoading=true;
-  try{
-    const response=await fetch("/_ccdx/ui/suggestion",{cache:"no-store",headers:{"X-CCDX-Dashboard":"1"},signal:AbortSignal.timeout(5000)});
-    const data=await response.json();
-    if(!response.ok||data.source!=="local_suggestion_settings")throw new Error();
-    text("suggestion-enabled",data.enabled?"ENABLED":"DISABLED");
-    element("suggestion-model").textContent=data.model;
-    text("suggestion-auto",data.automatic_generation_configured?"Configured; review hook":"DISABLED");
-    const state={idle:"No automatic suggestion yet",generating:"Generating suggestion",ready:"Suggestion ready; open Next message",empty:"No useful suggestion",failed:"Suggestion failed; retry manually",cancelled:"Suggestion cancelled",unknown:"Unknown"}[data.recent?.state]||"Unknown";
-    text("suggestion-recent",state);
-    text("suggestion-detail","{time} / {reason}",{time:data.recent?.at?new Date(data.recent.at).toLocaleTimeString():"—",reason:phrase({context_unavailable:"Context unavailable",model_failed:"Model request failed",settings_changed:"Settings changed",turn_changed:"Conversation changed",timeout:"Suggestion timed out"}[data.recent?.reason]||"No recorded error")});
-  }catch{text("suggestion-enabled","UNAVAILABLE");element("suggestion-model").textContent="—";text("suggestion-auto","UNAVAILABLE");text("suggestion-recent","Run ccdx suggestion status");element("suggestion-detail").textContent="—";}
-  finally{suggestionLoading=false;}
-}
-
 function duration(value) {
   if (!finite(value)) return "—";
   const seconds = Math.max(0, Math.round(Number(value) / 1000));
@@ -186,6 +168,15 @@ function render(data) {
 
   renderFailures(data.response_failures?.recent, data.stream_performance?.recent_requests);
   renderContext(data.stream_performance);
+  if (element("prediction-preference")) {
+    const prediction = data.client_integrations?.prediction;
+    text("prediction-preference", prediction ? prediction.configured ? "Enabled" : "Disabled" : "Unknown");
+    text("prediction-bridge", ({ running: "Running", stopped: "Stopped", unavailable: "Unavailable" })[prediction?.bridge] || "Unknown");
+    text("prediction-route", prediction?.client_route === "observed" ? "Observed" : "Unknown");
+    text("prediction-candidate", "Unknown");
+    const note = element("prediction-note");
+    if (note) note.textContent = prediction?.reason || "";
+  }
   text("updated", "Snapshot {time}", { time: new Date().toLocaleTimeString() });
 }
 
@@ -241,11 +232,10 @@ async function refresh() {
   }
 }
 
-element("refresh").addEventListener("click", () => { refresh(); loadAuth(); loadSuggestion(); });
+element("refresh").addEventListener("click", () => { refresh(); loadAuth(); });
 element("request-context").addEventListener("toggle", () => { if (element("request-context").open) renderContext(); });
 refresh();
 loadAuth();
-loadSuggestion();
 
 const animationRows = new Map();
 let animationTimelines = [];

package/src/dashboard-api.mjs

@@ -15,14 +15,11 @@ import { cacheReadTokens, summarizeUsageLogs, usageCacheHitRate } from "./usage-
 import { createUsageAnalytics } from "./usage-analytics.mjs";
 import { analyzeUsageLogs } from "./usage-analysis.mjs";
 import { readUserSettings, terminalAnimationPreference, writeTerminalAnimationTheme } from "./user-settings.mjs";
-import { readSuggestionConfig, suggestionConfigPath } from "./suggestion-config.mjs";
-import { automaticSuggestionStatus } from "./suggestion-auto.mjs";
 
 const ANIMATION_PATH = "/_ccdx/ui/animation";
 const MODELS_PATH = "/_ccdx/ui/models/live";
 const USAGE_PATH = "/_ccdx/ui/usage";
 const AUTH_PATH = "/_ccdx/ui/auth";
-const SUGGESTION_PATH = "/_ccdx/ui/suggestion";
 const DISABLED_ANIMATION = /^(0|false|no|off)$/i;
 
 function sendJson(res, statusCode, value) {
@@ -149,15 +146,6 @@ export async function handleDashboardApi(req, res, pathname, {
     }
     return;
   }
-  if(pathname===SUGGESTION_PATH && req.method==="GET"){
-    try{
-      const filePath=suggestionConfigPath({env,home}),config=readSuggestionConfig({filePath,strict:true});
-      sendJson(res,200,{source:"local_suggestion_settings",enabled:config.enabled,model:config.model,
-        automatic_generation_configured:config.enabled&&config.automatic===true,hook_trust:"unknown",automatic_insertion:false,
-        recent:config.enabled?automaticSuggestionStatus(filePath):{state:"idle",at:null,reason:null}});
-    }catch{sendJson(res,409,{error:"Suggestion settings are invalid; run ccdx suggestion status"})}
-    return;
-  }
 
   if (pathname === ANIMATION_PATH && req.method === "GET") {
     try {

package/src/launcher.mjs

@@ -36,7 +36,7 @@ export function launchAttempts() {
   return [["-b", CODEX_BUNDLE_ID], ...APP_PATH_CANDIDATES.map((path) => [path])];
 }
 
-export async function openCodex({ env = process.env, spawnImpl = spawn, platform = process.platform } = {}) {
+export async function openCodex({ env = process.env, spawnImpl = spawn, platform = process.platform, predictionPacUrl = null, predictionApp = null } = {}) {
   if (platform !== "darwin") {
     console.log(status("warn", "Auto-launch is only supported on macOS"));
     console.log(status("info", "Open Codex App manually; it will connect to the adapter."));
@@ -48,7 +48,12 @@ export async function openCodex({ env = process.env, spawnImpl = spawn, platform
     return false;
   }
 
-  for (const args of launchAttempts()) {
+  const extraArgs = typeof predictionPacUrl === "string" && /^http:\/\/127\.0\.0\.1:\d{1,5}\/proxy\.pac$/.test(predictionPacUrl)
+    && APP_PATH_CANDIDATES.includes(predictionApp)
+    ? ["--args", `--proxy-pac-url=${predictionPacUrl}`] : [];
+  const attempts = extraArgs.length ? [[predictionApp]] : launchAttempts();
+  for (const attempt of attempts) {
+    const args = [...attempt, ...extraArgs];
     if (await tryOpen(args, { spawnImpl })) {
       console.log(status("ok", "Codex app launched"));
       return true;

package/src/lock.mjs

@@ -6,6 +6,35 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// Synchronous configuration writers share the same cross-process lock format.
+// Readers never take the lock. A live lock is never stolen on timeout.
+export function withFileLockSync(lockPath, fn, { timeoutMs = 1000, staleMs = 60_000 } = {}) {
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true, mode: 0o700 });
+  const started = Date.now(), owner = randomUUID();
+  const sleeper = new Int32Array(new SharedArrayBuffer(4));
+  while (true) {
+    if (lockPathExists(reclaimGuardPath(lockPath), fs)) {
+      if (Date.now() - started >= timeoutMs) throw new Error("Configuration lock recovery is in progress; retry shortly");
+      Atomics.wait(sleeper, 0, 0, 10);
+      continue;
+    }
+    try {
+      const fd = writeLockRecord(lockPath, { pid: process.pid, owner, created_at: new Date().toISOString() }, fs);
+      fs.closeSync(fd);
+      if (lockPathExists(reclaimGuardPath(lockPath), fs)) { removeOwnedLock(lockPath, owner, fs); continue; }
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (maybeRemoveStaleLock(lockPath, staleMs, Date.now(), fs, processIsAlive)) continue;
+      let sameProcess = false;
+      try { sameProcess = readLockSnapshot(lockPath).pid === process.pid; } catch {}
+      if (sameProcess || Date.now() - started >= timeoutMs) throw new Error("Configuration is being updated by another operation; retry shortly");
+      Atomics.wait(sleeper, 0, 0, 10);
+    }
+  }
+  try { return fn(); } finally { removeOwnedLock(lockPath, owner, fs); }
+}
+
 function readLockSnapshot(lockPath) {
   const stat = fs.statSync(lockPath);
   let record = {};

package/src/native-prediction-overlay.mjs

@@ -0,0 +1,92 @@
+export const NATIVE_PREDICTION_GATE = "4290031608";
+
+const LOCAL_PREDICTION_CONFIG = Object.freeze({
+  is_enabled: true,
+  prompt: 'Predict one useful next message the user may send, based on the conversation. Write from the user\'s perspective and use the user\'s language. Do not answer the message, call tools, or invent new requests, consent, or permission. Prefer a short, natural follow-up. If no useful follow-up is apparent, use an empty string. Return only a JSON object with exactly one key: {"suggestion":"the predicted user message"}.',
+  prompt_version: "ccdx-native-prediction-v1",
+  prediction_reasoning_effort: "low",
+});
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function parseBody(body) {
+  if (typeof body !== "string" && !Buffer.isBuffer(body)) return null;
+  try { return JSON.parse(body.toString()); } catch { return null; }
+}
+
+function encodeBody(value, original) {
+  const text = JSON.stringify(value);
+  return Buffer.isBuffer(original) ? Buffer.from(text) : text;
+}
+
+export function classifyNativePredictionPath({ hostname, pathname } = {}) {
+  const host = typeof hostname === "string" ? hostname.toLowerCase() : "";
+  if (host === "chatgpt.com") {
+    if (pathname === "/backend-api/wham/statsig/bootstrap") return "bootstrap";
+    if (pathname === "/backend-api/wham/predictions/config") return "config";
+  }
+  if (host === "ab.chatgpt.com" && pathname === "/v1/initialize") return "refresh";
+  return null;
+}
+
+function enablePredictionGate(payload) {
+  if (!isObject(payload) || (payload.response_mode === "live_overlay" ? payload.has_updates === false : payload.has_updates !== true) ||
+      (payload.is_delta !== undefined && payload.is_delta !== false) ||
+      (payload.response_mode !== undefined && !["full", "live_overlay"].includes(payload.response_mode)) ||
+      !isObject(payload.feature_gates)) return false;
+  // Statsig V1 first resolves the literal name, then its djb2 lookup key.
+  let hash = 0;
+  for (const char of NATIVE_PREDICTION_GATE) hash = ((hash << 5) - hash + char.charCodeAt(0)) | 0;
+  const hashedKey = String(hash >>> 0);
+  const key = Object.hasOwn(payload.feature_gates, NATIVE_PREDICTION_GATE) ? NATIVE_PREDICTION_GATE
+    : Object.hasOwn(payload.feature_gates, hashedKey) ? hashedKey : NATIVE_PREDICTION_GATE;
+  const gate = payload.feature_gates[key];
+  if (gate !== undefined && (!isObject(gate) || typeof gate.value !== "boolean" || gate.value === true)) return false;
+  if (payload.response_mode === "live_overlay" && !Array.isArray(payload.live_entity_names?.feature_gates)) return false;
+  if (gate) gate.value = true;
+  else payload.feature_gates[key] = { name: key, value: true, rule_id: "ccdx-local-compatibility", secondary_exposures: [] };
+  if (payload.response_mode === "live_overlay" && !payload.live_entity_names.feature_gates.includes(key)) {
+    payload.live_entity_names.feature_gates.push(key);
+  }
+  return true;
+}
+
+// No-op results retain the original bytes; callers own HTTP headers and decoding.
+export function applyNativePredictionOverlay({ hostname, pathname, statusCode, body, enabled = false } = {}) {
+  const kind = classifyNativePredictionPath({ hostname, pathname });
+  const result = { body, statusCode, changed: false, official: false, kind };
+  if (!enabled || !kind) return result;
+  if (kind === "config" && statusCode === 404) {
+    return { ...result, statusCode: 200, body: encodeBody(LOCAL_PREDICTION_CONFIG, body), changed: true };
+  }
+  if (statusCode !== 200) return result;
+  const parsed = parseBody(body);
+  if (!isObject(parsed)) return result;
+  if (kind === "config") {
+    if (parsed.is_enabled === true) return { ...result, official: true };
+    if (parsed.is_enabled !== false || typeof parsed.prompt !== "string" || !parsed.prompt.trim()) return result;
+    parsed.is_enabled = true;
+  } else if (kind === "bootstrap") {
+    const stringPayload = typeof parsed.statsigPayload === "string";
+    const payload = stringPayload ? parseBody(parsed.statsigPayload) : parsed.statsigPayload;
+    if (!enablePredictionGate(payload)) return result;
+    if (stringPayload) parsed.statsigPayload = JSON.stringify(payload);
+  } else if (!enablePredictionGate(parsed)) return result;
+  return { ...result, body: encodeBody(parsed, body), changed: true };
+}
+
+// Overlaying a delta would invalidate its checksum. Ask for a full response instead.
+export function normalizeStatsigRequest({ hostname, pathname, body, enabled = false } = {}) {
+  const result = { body, changed: false };
+  if (!enabled || classifyNativePredictionPath({ hostname, pathname }) !== "refresh") return result;
+  const parsed = parseBody(body);
+  if (!isObject(parsed) || !isObject(parsed.user) ||
+      (parsed.responseMode !== undefined && !["full", "live_overlay"].includes(parsed.responseMode))) return result;
+  if (parsed.deltasResponseRequested === false && parsed.full_checksum === null && parsed.sinceTime === 0) return result;
+  parsed.deltasResponseRequested = false;
+  parsed.full_checksum = null;
+  parsed.sinceTime = 0;
+  return { body: encodeBody(parsed, body), changed: true };
+}