npm - @yansigit/opencodex - Versions diffs - 2.36.1-dev.20260829.35 → 2.36.1-dev.20260829.39 - Mend

@yansigit/opencodex 2.36.1-dev.20260829.35 → 2.36.1-dev.20260829.39

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

package/gui/dist/index.html CHANGED Viewed

@@ -16,8 +16,8 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-WNYAjf83.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/shared-p0R307IX.js">
+    <script type="module" crossorigin src="/assets/index-Bs27ITj_.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/shared-BdYGV-yJ.js">
     <link rel="stylesheet" crossorigin href="/assets/index-pLho_LBF.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yansigit/opencodex",
-  "version": "2.36.1-dev.20260829.35",
+  "version": "2.36.1-dev.20260829.39",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",

package/src/codex/app-server-processes.ts CHANGED Viewed

@@ -15,6 +15,7 @@ import {
   resolveTrustedWindowsTaskkillExe,
 } from "../lib/windows-elevation";
 import { readCodexCatalogPath } from "./catalog/parsing";
+import { CODEX_CONFIG_PATH } from "./paths";
 export const STALE_CODEX_APP_SERVER_HINT =
   "If Codex still shows an older model list, restart its long-lived app-server process after sync (ocx sync --restart-codex). "
@@ -104,6 +105,10 @@ export interface CodexAppServerProcessIo {
   /** Async batch start-time seam used by the request-path Windows collector. */
   readStartMsBatchAsync?: (pids: readonly number[]) => Promise<Map<number, number | null>>;
   catalogMtimeMs?: () => number | null;
+  /** Which on-disk write should be compared with app-server start times. */
+  freshnessTarget?: "catalog" | "config";
+  /** Custom path for the default freshness stat; process-observation identity excludes it. */
+  freshnessPath?: string;
 }
 function execFileTextAsync(
@@ -680,9 +685,12 @@ export interface CodexAppServerCatalogStatus {
 }
 /** Resolve the catalog file Codex app-servers loaded at startup, for staleness checks. */
-function defaultCatalogMtimeMs(): number | null {
+function defaultCatalogMtimeMs(
+  target: "catalog" | "config" = "catalog",
+  freshnessPath?: string,
+): number | null {
   try {
-    return statSync(readCodexCatalogPath()).mtimeMs;
+    return statSync(freshnessPath ?? (target === "config" ? CODEX_CONFIG_PATH : readCodexCatalogPath())).mtimeMs;
   } catch {
     return null;
   }
@@ -720,23 +728,58 @@ function catalogStatusFromProcesses(
   return { state: stale ? "stale" : "fresh", processes: withStarts, catalogMtimeMs };
 }
+function startsHasUnreadable(starts: ReadonlyMap<number, number | null>): boolean {
+  for (const startedAtMs of starts.values()) {
+    if (startedAtMs === null) return true;
+  }
+  return false;
+}
 // Short TTL: process listing + stat run once per window even under per-turn
-// guidance calls (#857).
-let catalogStateCache: { atMs: number; status: CodexAppServerCatalogStatus } | null = null;
+// guidance calls (#857). The process evidence is independent of which on-disk
+// write callers compare it with; only the mtime lookup and final status are
+// target-specific.
+interface ProcessEvidence {
+  processes: CodexAppServerProcess[];
+  starts: Map<number, number | null>;
+  enumerationFailed: boolean;
+}
+interface ProcessEvidenceIdentity {
+  platform: NodeJS.Platform;
+  getuid?: CodexAppServerProcessIo["getuid"];
+  listSnapshots?: CodexAppServerProcessIo["listSnapshots"];
+  readStartMs?: CodexAppServerProcessIo["readStartMs"];
+}
+let processEvidenceCache: {
+  atMs: number;
+  identity: ProcessEvidenceIdentity;
+  evidence: ProcessEvidence;
+  ttlState: CodexAppServerCatalogState;
+} | null = null;
+const catalogStatusCache = new Map<"catalog" | "config", {
+  evidence: ProcessEvidence;
+  status: CodexAppServerCatalogStatus;
+}>();
 interface RequestCatalogStateIdentity {
   platform: NodeJS.Platform;
   listSnapshots?: CodexAppServerProcessIo["listSnapshots"];
   listSnapshotsAsync?: CodexAppServerProcessIo["listSnapshotsAsync"];
   readStartMs?: CodexAppServerProcessIo["readStartMs"];
   readStartMsBatchAsync?: CodexAppServerProcessIo["readStartMsBatchAsync"];
-  catalogMtimeMs?: CodexAppServerProcessIo["catalogMtimeMs"];
   now?: CodexAppServerProcessIo["now"];
 }
 interface RequestCatalogStateFlight {
   generation: number;
   identity: RequestCatalogStateIdentity;
-  promise: Promise<CodexAppServerCatalogStatus>;
+  promise: Promise<RequestCatalogStateReading>;
+}
+interface RequestCatalogStateReading {
+  status: CodexAppServerCatalogStatus;
+  observationState: CodexAppServerCatalogState;
 }
 let requestCatalogStateGeneration = 0;
@@ -745,6 +788,7 @@ let requestCatalogStateCache: {
   identity: RequestCatalogStateIdentity;
   atMs: number;
   status: CodexAppServerCatalogStatus;
+  observationState: CodexAppServerCatalogState;
 } | null = null;
 let requestCatalogStateFlight: RequestCatalogStateFlight | null = null;
 const CATALOG_STATE_TTL_MS = 5_000;
@@ -792,10 +836,34 @@ function sameRequestCatalogStateIdentity(
     && left.listSnapshotsAsync === right.listSnapshotsAsync
     && left.readStartMs === right.readStartMs
     && left.readStartMsBatchAsync === right.readStartMsBatchAsync
-    && left.catalogMtimeMs === right.catalogMtimeMs
     && left.now === right.now;
 }
+function statusForFreshnessTarget(
+  status: CodexAppServerCatalogStatus,
+  io: CodexAppServerProcessIo,
+): CodexAppServerCatalogStatus {
+  if (status.processes.length === 0) return status;
+  let catalogMtimeMs: number | null;
+  try {
+    const target = io.freshnessTarget ?? "catalog";
+    catalogMtimeMs = (io.catalogMtimeMs ?? (() => defaultCatalogMtimeMs(target, io.freshnessPath)))();
+  } catch {
+    catalogMtimeMs = null;
+  }
+  if (status.catalogMtimeMs === catalogMtimeMs) return status;
+  return catalogStatusFromProcesses(
+    status.processes.map(proc => ({ pid: proc.pid, commandLine: "" })),
+    catalogMtimeMs,
+    new Map(status.processes.map(proc => [proc.pid, proc.startedAtMs] as const)),
+  );
+}
+function processObservationState(status: CodexAppServerCatalogStatus): CodexAppServerCatalogState {
+  if (status.processes.length === 0) return status.state === "unknown" ? "unknown" : "not_running";
+  return status.processes.some(process => process.startedAtMs === null) ? "unknown" : "fresh";
+}
 /**
  * Compare the on-disk catalog mtime against the start time of running Codex
  * app-servers (#857): a server that started before the catalog changed keeps
@@ -816,15 +884,26 @@ export function collectCodexAppServerCatalogState(
   io: CodexAppServerProcessIo = {},
 ): CodexAppServerCatalogStatus {
   const now = (io.now ?? Date.now)();
-  const fullyDefault = !io.listSnapshots && !io.readStartMs && !io.catalogMtimeMs
-    && !io.platform && !io.getuid && !io.now;
-  if (fullyDefault
-    && catalogStateCache
-    && now - catalogStateCache.atMs < catalogStateTtlMs(catalogStateCache.status.state)) {
-    return catalogStateCache.status;
-  }
-  const compute = (): CodexAppServerCatalogStatus => {
-    const platform = io.platform ?? process.platform;
+  const target = io.freshnessTarget ?? "catalog";
+  const platform = io.platform ?? process.platform;
+  const identity: ProcessEvidenceIdentity = {
+    platform,
+    getuid: io.getuid,
+    listSnapshots: io.listSnapshots,
+    readStartMs: io.readStartMs,
+  };
+  const cachedEvidence = processEvidenceCache
+    && processEvidenceCache.identity.platform === identity.platform
+    && processEvidenceCache.identity.getuid === identity.getuid
+    && processEvidenceCache.identity.listSnapshots === identity.listSnapshots
+    && processEvidenceCache.identity.readStartMs === identity.readStartMs
+    && now - processEvidenceCache.atMs < catalogStateTtlMs(processEvidenceCache.ttlState)
+    ? processEvidenceCache.evidence
+    : null;
+  let evidence: ProcessEvidence;
+  if (cachedEvidence) {
+    evidence = cachedEvidence;
+  } else {
     const getuid = io.getuid ?? (() => {
       try {
         return typeof process.getuid === "function" ? process.getuid() : undefined;
@@ -841,26 +920,38 @@ export function collectCodexAppServerCatalogState(
       // Enumeration failure must never read as "nothing running" — that would let
       // positive model guidance through on guesswork (#857). The injected seam gets
       // the same contract as the default path: whoever enumerates, a failure to read
-      // the process list is unknown, not an empty machine.
+      // the process list, unknown, not an empty machine.
       snapshots = [];
       enumerationFailed = true;
     }
     const processes = codexAppServerProcessesFromSnapshots(snapshots);
-    if (processes.length === 0) {
-      return enumerationFailed
-        ? { state: "unknown", processes: [], catalogMtimeMs: null }
-        : { state: "not_running", processes: [], catalogMtimeMs: null };
-    }
-    const catalogMtimeMs = (io.catalogMtimeMs ?? defaultCatalogMtimeMs)();
-    const starts = io.readStartMs
-      ? new Map(processes.map(proc => [proc.pid, io.readStartMs!(proc.pid)] as const))
-      : readProcessStartMsBatch(processes.map(proc => proc.pid), platform);
-    return catalogStatusFromProcesses(processes, catalogMtimeMs, starts);
-  };
-  const status = compute();
-  if (fullyDefault) {
-    catalogStateCache = { atMs: now, status };
+    const starts = processes.length === 0
+      ? new Map<number, number | null>()
+      : io.readStartMs
+        ? new Map(processes.map(proc => [proc.pid, io.readStartMs!(proc.pid)] as const))
+        : readProcessStartMsBatch(processes.map(proc => proc.pid), platform);
+    const ttlState: CodexAppServerCatalogState = enumerationFailed || startsHasUnreadable(starts)
+      ? "unknown"
+      : processes.length === 0 ? "not_running" : "fresh";
+    evidence = { processes, starts, enumerationFailed };
+    processEvidenceCache = { atMs: now, identity, evidence, ttlState };
+  }
+  if (evidence.processes.length === 0) {
+    const status: CodexAppServerCatalogStatus = evidence.enumerationFailed
+      ? { state: "unknown", processes: [], catalogMtimeMs: null }
+      : { state: "not_running", processes: [], catalogMtimeMs: null };
+    const prior = catalogStatusCache.get(target);
+    if (prior?.evidence === evidence) return prior.status;
+    catalogStatusCache.set(target, { evidence, status });
+    return status;
   }
+  const catalogMtimeMs = (io.catalogMtimeMs ?? (() => defaultCatalogMtimeMs(target, io.freshnessPath)))();
+  const status = catalogStatusFromProcesses(evidence.processes, catalogMtimeMs, evidence.starts);
+  const prior = catalogStatusCache.get(target);
+  if (prior?.evidence === evidence && prior.status.catalogMtimeMs === status.catalogMtimeMs) {
+    return prior.status;
+  }
+  catalogStatusCache.set(target, { evidence, status });
   return status;
 }
@@ -897,7 +988,6 @@ export async function collectCodexAppServerCatalogStateForRequest(
     listSnapshotsAsync: io.listSnapshotsAsync,
     readStartMs: io.readStartMs,
     readStartMsBatchAsync: io.readStartMsBatchAsync,
-    catalogMtimeMs: io.catalogMtimeMs,
     now: io.now,
   };
   const cached = requestCatalogStateCache
@@ -905,8 +995,8 @@ export async function collectCodexAppServerCatalogStateForRequest(
     && sameRequestCatalogStateIdentity(requestCatalogStateCache.identity, identity)
     ? requestCatalogStateCache
     : null;
-  if (cached && now - cached.atMs < catalogStateTtlMs(cached.status.state)) {
-    return cached.status;
+  if (cached && now - cached.atMs < catalogStateTtlMs(cached.observationState)) {
+    return statusForFreshnessTarget(cached.status, io);
   }
   // An expired real reading is still worth handing back while the refresh runs. It
   // cannot have been invalidated by an ocx catalog write: every such write calls
@@ -915,18 +1005,20 @@ export async function collectCodexAppServerCatalogStateForRequest(
   // What it can miss is an app-server that started or stopped meanwhile -- and a
   // server started after the reading is newer than the catalog, which is the `fresh`
   // this entry already says.
+  const targetStatus = cached ? statusForFreshnessTarget(cached.status, io) : null;
   const servableStale = cached
-    && cached.status.state !== "unknown"
-    && now - cached.atMs < catalogStateTtlMs(cached.status.state) + CATALOG_STATE_MAX_STALE_MS
-    ? cached.status
+    && cached.observationState !== "unknown"
+    && targetStatus?.state !== "unknown"
+    && now - cached.atMs < catalogStateTtlMs(cached.observationState) + CATALOG_STATE_MAX_STALE_MS
+    ? targetStatus
     : null;
   if (requestCatalogStateFlight
     && requestCatalogStateFlight.generation === generation
     && sameRequestCatalogStateIdentity(requestCatalogStateFlight.identity, identity)) {
-    return servableStale ?? requestCatalogStateFlight.promise;
+    return servableStale ?? requestCatalogStateFlight.promise.then(reading => statusForFreshnessTarget(reading.status, io));
   }
-  const refresh = async (): Promise<CodexAppServerCatalogStatus> => {
+  const refresh = async (): Promise<RequestCatalogStateReading> => {
     let snapshots: ProcessSnapshot[];
     try {
       snapshots = io.listSnapshotsAsync
@@ -935,15 +1027,21 @@ export async function collectCodexAppServerCatalogStateForRequest(
           ? io.listSnapshots()
           : await listWindowsSnapshotsAsync();
     } catch {
-      return { state: "unknown", processes: [], catalogMtimeMs: null };
+      return {
+        status: { state: "unknown", processes: [], catalogMtimeMs: null },
+        observationState: "unknown",
+      };
     }
     const processes = codexAppServerProcessesFromSnapshots(snapshots);
     if (processes.length === 0) {
-      return { state: "not_running", processes: [], catalogMtimeMs: null };
+      return {
+        status: { state: "not_running", processes: [], catalogMtimeMs: null },
+        observationState: "not_running",
+      };
     }
     let catalogMtimeMs: number | null;
     try {
-      catalogMtimeMs = (io.catalogMtimeMs ?? defaultCatalogMtimeMs)();
+      catalogMtimeMs = (io.catalogMtimeMs ?? (() => defaultCatalogMtimeMs(io.freshnessTarget, io.freshnessPath)))();
     } catch {
       catalogMtimeMs = null;
     }
@@ -953,16 +1051,19 @@ export async function collectCodexAppServerCatalogStateForRequest(
       : io.readStartMs
         ? new Map(pids.map(pid => [pid, io.readStartMs!(pid)] as const))
         : await readWindowsProcessStartMsBatchAsync(pids);
-    return catalogStatusFromProcesses(processes, catalogMtimeMs, starts);
+    const status = catalogStatusFromProcesses(processes, catalogMtimeMs, starts);
+    return {
+      status,
+      observationState: processObservationState(status),
+    };
   };
   const pending = refresh().catch(() => ({
-    state: "unknown" as const,
-    processes: [],
-    catalogMtimeMs: null,
+    status: { state: "unknown" as const, processes: [], catalogMtimeMs: null },
+    observationState: "unknown" as const,
   }));
   let flight: RequestCatalogStateFlight;
-  const promise = pending.then(status => {
+  const promise = pending.then(reading => {
     // A catalog write can invalidate while slow CIM is still running. The result
     // describes the PRE-write world, so it must neither repopulate the post-write
     // cache nor reach the caller.
@@ -979,7 +1080,10 @@ export async function collectCodexAppServerCatalogStateForRequest(
     // invalidated observation knows, and the guidance path already treats it as
     // "say nothing positive".
     if (requestCatalogStateGeneration !== generation) {
-      return { state: "unknown" as const, processes: [], catalogMtimeMs: null };
+      return {
+        status: { state: "unknown" as const, processes: [], catalogMtimeMs: null },
+        observationState: "unknown" as const,
+      };
     }
     // A refresh that failed must not evict a real reading. Before this function
     // served stale entries, caching `unknown` cost at most the 250ms that state
@@ -988,19 +1092,20 @@ export async function collectCodexAppServerCatalogStateForRequest(
     // them on a transient failure -- `unknown` is not servable, so the next
     // caller waits for a probe instead of getting the reading it would have had.
     // Keep the observation and let its own age retire it.
-    const wouldEvictAnObservation = status.state === "unknown"
+    const wouldEvictAnObservation = reading.observationState === "unknown"
       && requestCatalogStateCache?.generation === generation
-      && requestCatalogStateCache.status.state !== "unknown"
+      && requestCatalogStateCache.observationState !== "unknown"
       && sameRequestCatalogStateIdentity(requestCatalogStateCache.identity, identity);
     if (requestCatalogStateFlight === flight && !wouldEvictAnObservation) {
       requestCatalogStateCache = {
         generation,
         identity,
         atMs: (io.now ?? Date.now)(),
-        status,
+        status: reading.status,
+        observationState: reading.observationState,
       };
     }
-    return status;
+    return reading;
   }).finally(() => {
     if (requestCatalogStateFlight === flight) requestCatalogStateFlight = null;
   });
@@ -1008,7 +1113,7 @@ export async function collectCodexAppServerCatalogStateForRequest(
   requestCatalogStateFlight = flight;
   // `promise` already absorbs its own failures, so leaving it unawaited here cannot
   // surface as an unhandled rejection; the next caller picks up whatever it stored.
-  return servableStale ?? flight.promise;
+  return servableStale ?? flight.promise.then(reading => statusForFreshnessTarget(reading.status, io));
 }
 /**
@@ -1018,7 +1123,8 @@ export async function collectCodexAppServerCatalogStateForRequest(
  * write has completed.
  */
 export function resetCodexAppServerCatalogStateCache(): void {
-  catalogStateCache = null;
+  processEvidenceCache = null;
+  catalogStatusCache.clear();
   requestCatalogStateGeneration += 1;
   requestCatalogStateCache = null;
   requestCatalogStateFlight = null;

package/src/codex/internal/catalog-writer.ts CHANGED Viewed

@@ -16,6 +16,7 @@ import {
   forgetEphemeralSecretPath,
   hardenSecretPath,
 } from "../../lib/windows-secret-acl";
+import { resetCodexAppServerCatalogStateCache } from "../app-server-processes";
 export interface PreparedCatalogFileWrite {
   readonly path: string;
@@ -167,6 +168,7 @@ export function replaceActiveCodexCatalog(
 ): void {
   assertCatalogWritePermit(permit, owningCodexHome);
   atomicWriteFile(prepared.path, prepared.content, io);
+  resetCodexAppServerCatalogStateCache();
 }
 /** Atomically publish the catalog-path-keyed immutable backup without clobbering. */
@@ -200,4 +202,5 @@ export function replaceCodexModelsCache(
 ): void {
   assertCatalogWritePermit(permit, owningCodexHome);
   atomicWriteFile(prepared.path, prepared.content, io);
+  resetCodexAppServerCatalogStateCache();
 }

package/src/codex/subagent-defaults.ts CHANGED Viewed

@@ -1,3 +1,8 @@
+import { readFileSync } from "node:fs";
+import { CODEX_CONFIG_PATH } from "./paths";
+import { hasInjectedCodexRouting } from "./injected-marker";
+import { resolveEffectiveProjectModelProvider } from "./project-config-warnings";
 /**
  * Pure, ownership-aware edits for Codex's native `[agents]` defaults.
  *
@@ -19,6 +24,17 @@ export interface ManagedSubagentDefaults {
   reasoningEffort?: string;
 }
+export type NativeDefaultState = "active" | "disabled" | "pending" | "blocked";
+export interface NativeDefaultStateDeps {
+  configPath?: string;
+  readConfig?: () => string;
+  processIo?: import("./app-server-processes").CodexAppServerProcessIo;
+  collectCatalogState?: () => {
+    state: "fresh" | "stale" | "not_running" | "unknown";
+  } | Promise<{ state: "fresh" | "stale" | "not_running" | "unknown" }>;
+}
 export interface ManagedSubagentDefaultsConflict {
   key: ManagedSubagentDefaultKey;
   line: number;
@@ -365,6 +381,104 @@ function analyzeToml(lines: readonly SourceLine[]): { shape: TomlShape } | { err
   };
 }
+interface ManagedSubagentDefaultsInspection {
+  values: Partial<ManagedSubagentDefaults>;
+  owned: Record<ManagedSubagentDefaultKey, boolean>;
+}
+/** Read the effective native defaults without changing the TOML document. */
+function inspectManagedSubagentDefaults(content: string):
+  | { ok: true; inspection: ManagedSubagentDefaultsInspection }
+  | { ok: false; error: string } {
+  const analysis = analyzeToml(splitSourceLines(content));
+  if ("error" in analysis) return { ok: false, error: analysis.error };
+  let parsed: unknown;
+  try {
+    parsed = Bun.TOML.parse(content);
+  } catch {
+    return { ok: false, error: "Codex config is not valid TOML" };
+  }
+  const root = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    ? parsed as Record<string, unknown>
+    : null;
+  const agents = root?.agents && typeof root.agents === "object" && !Array.isArray(root.agents)
+    ? root.agents as Record<string, unknown>
+    : {};
+  const values: Partial<ManagedSubagentDefaults> = {};
+  const owned = {} as Record<ManagedSubagentDefaultKey, boolean>;
+  for (const key of TARGET_KEYS) {
+    const definition = analysis.shape.definitions.get(key);
+    owned[key] = definition?.owned === true;
+    if (!definition) continue;
+    const value = agents[key];
+    if (typeof value !== "string") return { ok: false, error: `agents.${key} is not a string` };
+    if (key === "default_subagent_model") values.model = value;
+    else values.reasoningEffort = value;
+  }
+  return { ok: true, inspection: { values, owned } };
+}
+/**
+ * Resolve whether the configured preference is actually authoritative for omitted-model Codex
+ * subagents. This is intentionally read-only; sync/start remains the writer of native defaults.
+ */
+export async function resolveNativeDefaultState(
+  config: { syncCodexSubagentDefaults?: boolean; injectionModel?: string; injectionEffort?: string },
+  deps: NativeDefaultStateDeps = {},
+): Promise<NativeDefaultState> {
+  const model = config.injectionModel?.trim();
+  const enabled = config.syncCodexSubagentDefaults === true && Boolean(model);
+  if (!enabled) return "disabled";
+  const configPath = deps.configPath ?? CODEX_CONFIG_PATH;
+  let content: string;
+  try {
+    content = (deps.readConfig ?? (() => readFileSync(configPath, "utf8")))();
+  } catch (error) {
+    // A config that has not been created yet is waiting for the next sync; other read failures
+    // cannot be safely diagnosed as a missing desired value.
+    return (error as NodeJS.ErrnoException | undefined)?.code === "ENOENT" ? "pending" : "blocked";
+  }
+  const inspected = inspectManagedSubagentDefaults(content);
+  if (!inspected.ok) return "blocked";
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = Bun.TOML.parse(content) as Record<string, unknown>;
+  } catch {
+    return "blocked";
+  }
+  const provider = resolveEffectiveProjectModelProvider(content).provider;
+  if (provider && provider !== "openai" && provider !== "opencodex") return "blocked";
+  const baseUrl = parsed.openai_base_url;
+  if (typeof baseUrl === "string" && baseUrl.trim() && !hasInjectedCodexRouting(content)) return "blocked";
+  const { values, owned } = inspected.inspection;
+  for (const key of TARGET_KEYS) {
+    if (owned[key] === false && Object.hasOwn(values, key === "default_subagent_model" ? "model" : "reasoningEffort")) {
+      return "blocked";
+    }
+  }
+  if (values.model !== model) return "pending";
+  const effort = config.injectionEffort?.trim() || undefined;
+  if (values.reasoningEffort !== effort) return "pending";
+  let catalogState: { state: "fresh" | "stale" | "not_running" | "unknown" };
+  try {
+    catalogState = await (deps.collectCatalogState ?? (async () => {
+      const { collectCodexAppServerCatalogStateForRequest } = await import("./app-server-processes");
+      return collectCodexAppServerCatalogStateForRequest({
+        ...deps.processIo,
+        freshnessPath: configPath,
+        freshnessTarget: "config",
+      });
+    }))();
+  } catch {
+    return "pending";
+  }
+  return catalogState.state === "fresh" || catalogState.state === "not_running" ? "active" : "pending";
+}
 function quotedTomlString(value: string): string {
   // JSON basic strings are valid TOML basic strings and cover quotes,
   // backslashes, control characters, and newlines. JSON leaves DEL literal,

package/src/codex/sync.ts CHANGED Viewed

@@ -8,6 +8,7 @@ import { summarizeComboCatalogOmissions, type ComboCatalogOmission } from "./cat
 import { shouldSyncCodexOnStart } from "./desired-state";
 import { admitCodexWrite, type CodexAdmission } from "./admission";
 import type { CodexCatalogSyncOptions } from "./catalog/sync";
+import { resetCodexAppServerCatalogStateCache } from "./app-server-processes";
 export interface CodexSyncResult {
   /**
@@ -116,6 +117,10 @@ export async function syncModelsToCodex(
       message: admission.message,
     };
   }
+  // Config injection is a relevant Codex write even when the catalog bytes are unchanged.
+  // Drop cached process evidence before async discovery so a process that appeared since the
+  // last read cannot make native-default guidance report active after this sync.
+  resetCodexAppServerCatalogStateCache();
   const p = port ?? config.port ?? 10100;
   const externalProvider = (deps.currentExternalCodexModelProvider ?? currentExternalCodexModelProvider)();