@bitkyc08/opencodex 2.6.32 → 2.7.0

package/src/codex/features.ts

@@ -0,0 +1,178 @@
+/**
+ * features.ts — codex feature-flag view for $CODEX_HOME/config.toml.
+ *
+ * Used by the catalog v2-gated-ultra policy (devlog/260709_v2_gated_ultra) and the
+ * `ocx v2` toggle surface. The FLAG itself is never written here — toggling goes
+ * through the official `codex features enable|disable` CLI (format-preserving).
+ * The one write this module owns is the numeric
+ * `features.multi_agent_v2.max_concurrent_threads_per_session` scalar
+ * (setMaxConcurrentThreads): the codex CLI has no persisted setter for nested
+ * feature config (`-c` is per-invocation only), so ocx does a scoped,
+ * EOL-preserving line edit — same practice as codex/inject.ts.
+ *
+ * CODEX_HOME is resolved at CALL time (activeCodexConfigPath pattern, mirrors
+ * catalog.ts:40-54) so tests can point fixtures via env or the explicit
+ * `configPath` parameter without fighting the module-load-time const in paths.ts.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { realpathSync } from "node:fs";
+import { atomicWriteFile, expandUserPath } from "../config";
+import { CODEX_CONFIG_PATH } from "./paths";
+
+// EOL preservation, local copies of inject.ts dominantEol/applyEol: importing
+// inject here would close a module cycle (features -> inject -> catalog -> features).
+function dominantEol(content: string): "\r\n" | "\n" {
+  const crlf = (content.match(/\r\n/g) ?? []).length;
+  if (crlf === 0) return "\n";
+  const bareLf = (content.match(/\n/g) ?? []).length - crlf;
+  return crlf >= bareLf ? "\r\n" : "\n";
+}
+
+function applyEol(content: string, eol: "\r\n" | "\n"): string {
+  const normalized = content.replace(/\r\n/g, "\n");
+  return eol === "\n" ? normalized : normalized.replace(/\n/g, "\r\n");
+}
+
+function activeCodexConfigPath(): string {
+  const raw = process.env.CODEX_HOME?.trim();
+  if (!raw) return CODEX_CONFIG_PATH;
+  const path = resolve(expandUserPath(raw));
+  try {
+    return join(realpathSync.native(path), "config.toml");
+  } catch {
+    return join(path, "config.toml");
+  }
+}
+
+function readConfigText(configPath?: string): string | null {
+  const path = configPath ?? activeCodexConfigPath();
+  try {
+    if (!existsSync(path)) return null;
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+/** Body lines of a TOML table `[header]` up to (not including) the next table header. */
+function tomlTableBody(content: string, header: string): string | null {
+  const lines = content.split("\n");
+  const escaped = header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const start = lines.findIndex(l => new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`).test(l));
+  if (start === -1) return null;
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex(l => /^\s*\[/.test(l));
+  return (end === -1 ? rest : rest.slice(0, end)).join("\n");
+}
+
+function tomlBoolInBody(body: string, key: string): boolean | null {
+  const m = body.match(new RegExp(`^\\s*${key}\\s*=\\s*(true|false)\\s*(?:#.*)?$`, "m"));
+  return m ? m[1] === "true" : null;
+}
+
+/**
+ * TRUE when the codex `multi_agent_v2` feature is enabled in config.toml.
+ * Recognizes both shipped forms (codex-rs features/src/tests.rs):
+ *   [features.multi_agent_v2]           [features]
+ *   enabled = true                      multi_agent_v2 = true
+ * plus the inline-table form `multi_agent_v2 = { enabled = true, ... }`.
+ * Missing file/key -> false (upstream default_enabled = false).
+ */
+export function isMultiAgentV2Enabled(configPath?: string): boolean {
+  const content = readConfigText(configPath);
+  if (content === null) return false;
+
+  const table = tomlTableBody(content, "features.multi_agent_v2");
+  if (table !== null) {
+    const enabled = tomlBoolInBody(table, "enabled");
+    if (enabled !== null) return enabled;
+    // A bare [features.multi_agent_v2] table without `enabled` counts as on
+    // (FeatureToml::Config with enabled: None materializes as enabled upstream
+    // only when set; be conservative and require the boolean).
+    return false;
+  }
+
+  const features = tomlTableBody(content, "features");
+  if (features !== null) {
+    const bool = tomlBoolInBody(features, "multi_agent_v2");
+    if (bool !== null) return bool;
+    const inline = features.match(/^\s*multi_agent_v2\s*=\s*\{([^}]*)\}/m);
+    if (inline) {
+      const enabled = inline[1].match(/enabled\s*=\s*(true|false)/);
+      if (enabled) return enabled[1] === "true";
+    }
+  }
+  return false;
+}
+
+/**
+ * TRUE when config.toml still carries `[agents] max_threads` — codex-rs REFUSES to
+ * boot with that key while multi_agent_v2 is enabled ("agents.max_threads cannot be
+ * set when features.multi_agent_v2 is enabled", core/src/config/mod.rs:1421). The
+ * `ocx v2 on` flow warns about it instead of editing config itself.
+ */
+export function hasAgentsMaxThreads(configPath?: string): boolean {
+  const content = readConfigText(configPath);
+  if (content === null) return false;
+  const agents = tomlTableBody(content, "agents");
+  if (agents === null) return false;
+  return /^\s*max_threads\s*=/m.test(agents);
+}
+
+/**
+ * Current `features.multi_agent_v2.max_concurrent_threads_per_session`, or null when
+ * the table/key is absent (codex-rs then applies its own default).
+ */
+export function getMaxConcurrentThreads(configPath?: string): number | null {
+  const content = readConfigText(configPath);
+  if (content === null) return null;
+  const table = tomlTableBody(content, "features.multi_agent_v2");
+  if (table === null) return null;
+  const m = table.match(/^\s*max_concurrent_threads_per_session\s*=\s*(\d+)\s*(?:#.*)?$/m);
+  if (!m) return null;
+  const value = Number(m[1]);
+  return Number.isFinite(value) && value >= 1 ? value : null;
+}
+
+/**
+ * Persist `features.multi_agent_v2.max_concurrent_threads_per_session = value`.
+ * Scoped line edit inside the existing `[features.multi_agent_v2]` table only:
+ * replaces the key line when present, else inserts it right under the header.
+ * Refuses (returns an error string) when the table is missing — creating it next
+ * to a boolean-form `multi_agent_v2 = true` would be a TOML key conflict, and the
+ * table is exactly what `codex features enable multi_agent_v2` materializes, so
+ * "enable first" is the honest remedy. Idempotent: equal value -> no write.
+ */
+export function setMaxConcurrentThreads(value: number, configPath?: string): { ok: true; changed: boolean } | { ok: false; error: string } {
+  if (!Number.isInteger(value) || value < 1) {
+    return { ok: false, error: "max_concurrent_threads_per_session must be an integer >= 1" };
+  }
+  const path = configPath ?? activeCodexConfigPath();
+  const content = readConfigText(path);
+  if (content === null) return { ok: false, error: `config.toml not readable at ${path}` };
+
+  const eol = dominantEol(content);
+  const lines = content.split(/\r?\n/);
+  const headerRe = /^\s*\[features\.multi_agent_v2\]\s*(?:#.*)?$/;
+  const headerIdx = lines.findIndex(l => headerRe.test(l));
+  if (headerIdx === -1) {
+    return { ok: false, error: "[features.multi_agent_v2] table not found — enable v2 first (ocx v2 on)" };
+  }
+  let end = lines.length;
+  for (let i = headerIdx + 1; i < lines.length; i++) {
+    if (/^\s*\[/.test(lines[i])) { end = i; break; }
+  }
+  const keyRe = /^(\s*)max_concurrent_threads_per_session\s*=\s*(\d+)(\s*#.*)?$/;
+  for (let i = headerIdx + 1; i < end; i++) {
+    const m = lines[i].match(keyRe);
+    if (!m) continue;
+    if (Number(m[2]) === value) return { ok: true, changed: false };
+    lines[i] = `${m[1]}max_concurrent_threads_per_session = ${value}${m[3] ?? ""}`;
+    atomicWriteFile(path, applyEol(lines.join("\n"), eol));
+    return { ok: true, changed: true };
+  }
+  lines.splice(headerIdx + 1, 0, `max_concurrent_threads_per_session = ${value}`);
+  atomicWriteFile(path, applyEol(lines.join("\n"), eol));
+  return { ok: true, changed: true };
+}

package/src/codex/project-config-warnings.ts

@@ -0,0 +1,388 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { expandUserPath } from "../config";
+import { defaultCodexHome } from "./home";
+import { readRootTomlString } from "./paths";
+
+const OCX_SECTION_MARKER = "# Auto-injected by opencodex";
+const DIAGNOSTICS_CACHE_TTL_MS = 30_000;
+
+function resolveCodexConfigPath(): string {
+  const raw = process.env.CODEX_HOME?.trim();
+  const home = raw ? resolve(expandUserPath(raw)) : defaultCodexHome();
+  return join(home, "config.toml");
+}
+
+export type ProjectCodexConfigIssueCode = "model_providers_table" | "profile_selector" | "model_provider_root";
+
+export interface ProjectCodexConfigWarning {
+  path: string;
+  code: ProjectCodexConfigIssueCode;
+  /** Effective provider id that bypasses OpenCodex. */
+  detail: string;
+  /** Profile name when the bypass is selected via profile = "…". */
+  profileName?: string;
+  message: string;
+}
+
+interface TomlDocument {
+  root: Record<string, string>;
+  sections: Map<string, Record<string, string>>;
+}
+
+let diagnosticsCache: { at: number; warnings: ProjectCodexConfigWarning[] } | null = null;
+
+function hasInjectedOpenaiBaseUrl(content: string): boolean {
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
+  const rootEnd = firstTable === -1 ? lines.length : firstTable;
+  for (let i = 1; i < rootEnd; i++) {
+    if (/^\s*openai_base_url\s*=/.test(lines[i]) && lines[i - 1].includes(OCX_SECTION_MARKER)) return true;
+  }
+  return false;
+}
+
+function parseTomlString(raw: string): string {
+  if (raw.startsWith("\"")) {
+    try {
+      return JSON.parse(raw) as string;
+    } catch {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw.slice(1, -1);
+}
+
+/** Lightweight TOML parse for root keys and [section] tables (Codex config shape). */
+export function parseTomlDocument(content: string): TomlDocument {
+  const root: Record<string, string> = {};
+  const sections = new Map<string, Record<string, string>>();
+  let current = root;
+
+  for (const line of content.split("\n")) {
+    const table = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (table) {
+      const name = table[1]!.trim();
+      const section = sections.get(name) ?? {};
+      sections.set(name, section);
+      current = section;
+      continue;
+    }
+    const kv = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=\s*("(?:\\.|[^"])*"|'[^']*'|[^\s#]+)\s*(?:#.*)?$/);
+    if (kv) current[kv[1]!] = parseTomlString(kv[2]!);
+  }
+
+  return { root, sections };
+}
+
+function profileSectionKeys(profileName: string): string[] {
+  return [
+    `profiles.${profileName}`,
+    `profiles."${profileName}"`,
+    `profiles.'${profileName}'`,
+  ];
+}
+
+function readProfileModelProvider(sections: Map<string, Record<string, string>>, profileName: string): string | null {
+  for (const key of profileSectionKeys(profileName)) {
+    const provider = sections.get(key)?.model_provider;
+    if (provider) return provider;
+  }
+  return null;
+}
+
+function hasModelProviderTable(sections: Map<string, Record<string, string>>, provider: string): boolean {
+  return sections.has(`model_providers.${provider}`);
+}
+
+/** Built-in openai provider still routes through the proxy under Design B (marker-owned openai_base_url). */
+function isProxyCompatibleProvider(provider: string): boolean {
+  return provider === "opencodex" || provider === "openai";
+}
+
+export interface EffectiveProjectModelRouting {
+  provider: string | null;
+  profileName: string | null;
+  via: "profile" | "root" | null;
+}
+
+/** Resolve the provider Codex would actually use from a project .codex/config.toml. */
+export function resolveEffectiveProjectModelProvider(content: string): EffectiveProjectModelRouting {
+  const { root, sections } = parseTomlDocument(content);
+  const rootProfile = root.profile ?? null;
+  const rootProvider = root.model_provider ?? null;
+
+  if (rootProfile) {
+    const fromProfile = readProfileModelProvider(sections, rootProfile);
+    if (fromProfile) {
+      return { provider: fromProfile, profileName: rootProfile, via: "profile" };
+    }
+    if (rootProvider) {
+      return { provider: rootProvider, profileName: rootProfile, via: "root" };
+    }
+    return { provider: null, profileName: rootProfile, via: null };
+  }
+
+  if (rootProvider) {
+    return { provider: rootProvider, profileName: null, via: "root" };
+  }
+
+  return { provider: null, profileName: null, via: null };
+}
+
+/** True when global Codex config routes through the opencodex proxy. */
+export function isGlobalOpencodexRoutingActive(
+  codexConfigPath: string = resolveCodexConfigPath(),
+  content?: string,
+): boolean {
+  let text = content;
+  if (text === undefined) {
+    if (!existsSync(codexConfigPath)) return false;
+    try {
+      text = readFileSync(codexConfigPath, "utf-8");
+    } catch {
+      return false;
+    }
+  }
+  if (hasInjectedOpenaiBaseUrl(text)) return true;
+  if (readRootTomlString(text, "model_provider") === "opencodex") return true;
+  return false;
+}
+
+export function parseTrustedProjectPathsFromCodexConfig(content: string): string[] {
+  const { sections } = parseTomlDocument(content);
+  const paths: string[] = [];
+
+  for (const [name, keys] of sections) {
+    const quoted = name.match(/^projects\.(?:'([^']*)'|"([^"]*)")$/);
+    if (!quoted) continue;
+    const raw = (quoted[1] ?? quoted[2] ?? "").trim();
+    if (!raw) continue;
+    if ((keys.trust_level ?? "").toLowerCase() !== "trusted") continue;
+    paths.push(raw);
+  }
+
+  return paths;
+}
+
+export function analyzeProjectCodexConfig(content: string, configPath: string): ProjectCodexConfigWarning[] {
+  const { sections } = parseTomlDocument(content);
+  const routing = resolveEffectiveProjectModelProvider(content);
+  const provider = routing.provider;
+
+  if (!provider || isProxyCompatibleProvider(provider)) return [];
+
+  const rel = relPath(configPath);
+  if (hasModelProviderTable(sections, provider)) {
+    return [{
+      path: configPath,
+      code: "model_providers_table",
+      detail: provider,
+      profileName: routing.profileName ?? undefined,
+      message:
+        `Project Codex config selects provider "${provider}" via `
+        + `${routing.via === "profile" ? `profile = "${routing.profileName}"` : "model_provider"} and defines `
+        + `[model_providers.${provider}] (${rel}). That routes this trusted project away from the OpenCodex proxy.`,
+    }];
+  }
+
+  if (routing.via === "profile" && routing.profileName) {
+    return [{
+      path: configPath,
+      code: "profile_selector",
+      detail: provider,
+      profileName: routing.profileName,
+      message:
+        `Project Codex config profile "${routing.profileName}" sets model_provider = "${provider}" (${rel}). `
+        + "That routes this trusted project away from the OpenCodex proxy.",
+    }];
+  }
+
+  return [{
+    path: configPath,
+    code: "model_provider_root",
+    detail: provider,
+    message:
+      `Project Codex config sets model_provider = "${provider}" (${rel}). `
+      + "Use global ~/.codex/config.toml for OpenCodex routing instead of a project-local provider override.",
+  }];
+}
+
+/** profile/model_provider that selects an already-flagged [model_providers.X] table is one bypass, not two. */
+export function dedupeRelatedProjectCodexWarnings(
+  warnings: ProjectCodexConfigWarning[],
+): ProjectCodexConfigWarning[] {
+  const providerTables = new Set(
+    warnings.filter(w => w.code === "model_providers_table").map(w => w.detail),
+  );
+  if (providerTables.size === 0) return warnings;
+  return warnings.filter(w => {
+    if (w.code === "profile_selector" && providerTables.has(w.detail)) return false;
+    if (w.code === "model_provider_root" && providerTables.has(w.detail)) return false;
+    return true;
+  });
+}
+
+function relPath(abs: string): string {
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? "";
+  if (home && abs.toLowerCase().startsWith(home.toLowerCase())) {
+    return `~${abs.slice(home.length).replace(/\\/g, "/")}`;
+  }
+  return abs;
+}
+
+export function discoverProjectCodexConfigPaths(options: {
+  cwd?: string;
+  codexConfigPath?: string;
+  maxWalkParents?: number;
+} = {}): string[] {
+  const found = new Set<string>();
+  const codexConfigPath = options.codexConfigPath ?? resolveCodexConfigPath();
+  const addIfExists = (projectRoot: string) => {
+    const path = join(resolve(projectRoot), ".codex", "config.toml");
+    if (existsSync(path)) found.add(path);
+  };
+
+  let cwd = resolve(options.cwd ?? process.cwd());
+  const maxWalk = options.maxWalkParents ?? 12;
+  for (let depth = 0; depth < maxWalk; depth++) {
+    addIfExists(cwd);
+    const parent = dirname(cwd);
+    if (parent === cwd) break;
+    cwd = parent;
+  }
+
+  if (existsSync(codexConfigPath)) {
+    try {
+      const global = readFileSync(codexConfigPath, "utf-8");
+      for (const projectPath of parseTrustedProjectPathsFromCodexConfig(global)) {
+        addIfExists(projectPath);
+      }
+    } catch {
+      /* ignore unreadable global config */
+    }
+  }
+
+  return [...found];
+}
+
+export function collectProjectCodexConfigWarnings(options: {
+  cwd?: string;
+  codexConfigPath?: string;
+  requireOpencodexRouting?: boolean;
+} = {}): ProjectCodexConfigWarning[] {
+  const codexConfigPath = options.codexConfigPath ?? resolveCodexConfigPath();
+  const requireRouting = options.requireOpencodexRouting ?? true;
+  if (requireRouting && !isGlobalOpencodexRoutingActive(codexConfigPath)) return [];
+
+  const warnings: ProjectCodexConfigWarning[] = [];
+  for (const path of discoverProjectCodexConfigPaths({ cwd: options.cwd, codexConfigPath })) {
+    try {
+      const content = readFileSync(path, "utf-8");
+      warnings.push(...analyzeProjectCodexConfig(content, path));
+    } catch {
+      /* skip unreadable project config */
+    }
+  }
+  return warnings;
+}
+
+export function invalidateProjectConfigDiagnosticsCache(): void {
+  diagnosticsCache = null;
+}
+
+export function getCachedProjectConfigDiagnostics(): {
+  warnings: ProjectCodexConfigWarning[];
+  grouped: ProjectCodexConfigWarningGroup[];
+} {
+  const now = Date.now();
+  if (!diagnosticsCache || now - diagnosticsCache.at > DIAGNOSTICS_CACHE_TTL_MS) {
+    diagnosticsCache = { at: now, warnings: collectProjectCodexConfigWarnings() };
+  }
+  const warnings = diagnosticsCache.warnings;
+  return { warnings, grouped: groupProjectCodexConfigWarningsByPath(warnings) };
+}
+
+export function summarizeProjectCodexIssue(warning: ProjectCodexConfigWarning): string {
+  switch (warning.code) {
+    case "model_providers_table":
+      return `[model_providers.${warning.detail}]`;
+    case "profile_selector":
+      return warning.profileName ? `profile="${warning.profileName}"` : `model_provider="${warning.detail}"`;
+    case "model_provider_root":
+      return `model_provider="${warning.detail}"`;
+  }
+}
+
+function humanizeProviderDetail(detail: string): string {
+  if (detail === "opencode_go") return "OpenCode Go";
+  if (detail.startsWith("opencode")) return "OpenCode";
+  if (detail === "opencodex") return "OpenCodex";
+  return detail;
+}
+
+/** Short "why" line: what this project config overrides and where traffic goes instead. */
+export function explainProjectConfigBypass(warnings: ProjectCodexConfigWarning[]): string {
+  const targets = [...new Set(warnings.map(w => humanizeProviderDetail(w.detail)))];
+  const via = targets.length === 1 ? targets[0]! : targets.join(" / ");
+  return `Overrides OpenCodex — Codex uses ${via} for this repo instead of the proxy (~/.codex/config.toml).`;
+}
+
+export interface ProjectCodexConfigWarningGroup {
+  path: string;
+  issues: string[];
+  bypass: string;
+}
+
+export function groupProjectCodexConfigWarningsByPath(
+  warnings: ProjectCodexConfigWarning[],
+): ProjectCodexConfigWarningGroup[] {
+  const grouped = new Map<string, ProjectCodexConfigWarning[]>();
+  for (const warning of warnings) {
+    const list = grouped.get(warning.path) ?? [];
+    list.push(warning);
+    grouped.set(warning.path, list);
+  }
+  return [...grouped.entries()].map(([path, pathWarnings]) => ({
+    path,
+    issues: pathWarnings.map(summarizeProjectCodexIssue),
+    bypass: explainProjectConfigBypass(pathWarnings),
+  }));
+}
+
+export function formatProjectCodexConfigWarningsForDoctor(warnings: ProjectCodexConfigWarning[]): string[] {
+  const grouped = groupProjectCodexConfigWarningsByPath(warnings);
+  if (grouped.length === 0) return [];
+  const lines: string[] = [];
+  for (const { path, issues, bypass } of grouped) {
+    lines.push(`  --     ${relPath(path)} — ${issues.join(", ")}`);
+    lines.push(`         ${bypass}`);
+  }
+  lines.push("       fix: remove those entries so OpenCodex proxy routing applies in this project");
+  return lines;
+}
+
+export function formatProjectCodexConfigWarningsForConsole(warnings: ProjectCodexConfigWarning[]): string[] {
+  const grouped = groupProjectCodexConfigWarningsByPath(warnings);
+  if (grouped.length === 0) return [];
+  const lines = ["⚠️  Project Codex config bypasses OpenCodex:"];
+  for (const { path, issues, bypass } of grouped) {
+    lines.push(`    ${relPath(path)} — ${issues.join(", ")}`);
+    lines.push(`    ${bypass}`);
+  }
+  lines.push("    fix: remove those entries so OpenCodex proxy routing applies in this project");
+  return lines;
+}
+
+export function printProjectCodexConfigWarnings(
+  log?: Pick<Console, "log"> | null,
+  options?: Parameters<typeof collectProjectCodexConfigWarnings>[0],
+): ProjectCodexConfigWarning[] {
+  const warnings = collectProjectCodexConfigWarnings(options);
+  if (log) {
+    for (const line of formatProjectCodexConfigWarningsForConsole(warnings)) {
+      log.log(line);
+    }
+  }
+  return warnings;
+}

package/src/codex/sync.ts

@@ -1,4 +1,5 @@
 import { injectCodexConfig } from "./inject";
+import { printProjectCodexConfigWarnings, groupProjectCodexConfigWarningsByPath, type ProjectCodexConfigWarning } from "./project-config-warnings";
 import { refreshCodexModelCatalog } from "./refresh";
 import { applyProxyEnv, loadConfig } from "../config";
 import type { OcxConfig } from "../types";
@@ -11,6 +12,8 @@ export interface CodexSyncResult {
   cacheSynced: boolean;
   message: string;
   warning?: string;
+  projectConfigWarnings?: ProjectCodexConfigWarning[];
+  projectConfigGrouped?: { path: string; issues: string[]; bypass: string }[];
 }
 
 interface CodexSyncDeps {
@@ -58,6 +61,7 @@ export async function syncModelsToCodex(
 
   const result = await deps.injectCodexConfig(p, config, { catalogPath: catalogPathForInjection });
   log?.log(result.message);
+  const projectConfigWarnings = printProjectCodexConfigWarnings(log, { cwd: process.cwd() });
   return {
     ok: result.success,
     added,
@@ -66,5 +70,9 @@ export async function syncModelsToCodex(
     cacheSynced,
     message: result.message,
     ...(warning ? { warning } : {}),
+    ...(projectConfigWarnings.length > 0 ? {
+      projectConfigWarnings,
+      projectConfigGrouped: groupProjectCodexConfigWarningsByPath(projectConfigWarnings),
+    } : {}),
   };
 }