@baize-ai/core 0.3.15 → 0.3.16

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to baize-core will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.16] - 2026-09-13
+
+### Added
+- Codex 供应商配置改造（D51）：独立 provider 块写入器 + kind/slug store + init/runtime 遗留路径转换 + web-console 只读激活卡；`/models` 探测读取 provider 块 base_url
+- Dockerfile 本地源码构建支持（D51）：`BAZE_CORE_TARBALL=/core.tgz` 安装工作区包而非 registry 版本——验证未发布修复（如 D51）进镜像
+
+### Fixed
+- D51 部署缺陷（init）：web-console `import ../../../cli/lib/runtime-setup.js` 运行时 `~/.claude/cli/lib/` 不存在 → ERR_MODULE_NOT_FOUND 崩溃——`syncCoreSkills` 补拷 `package/cli` 至 `SKILLS_DIR 上级/cli`，并从包根复制零依赖 `node_modules/smol-toml`
+- D51 配置污染事故根因（4a37368）：`globalCodexConfigPath` 优先读 `HOME` env 而非 `os.homedir()`——jest ESM sandbox 曾写穿真实 `~/.codex/config.toml`
+- D51 review 修复：restore 只删 baize-written 块（`name=key && wire_api=responses`）；写盘直设 `0600` + 去重用例；激活卡展示 kind
+
+### Changed
+- A2A 授权治理收敛（D52 2b11171）：agent 本地 authz 仅保留 mode 切换（open/allowlist）——allow/block 名单由 admin 控制台统一管控（PUT 忽略名单强制清空 + UI 隐藏名单编辑并提示管控来源；移除死代码 `validateAuthzList`/peerIds 请求）
+
 ## [0.3.15] - 2026-08-31
 
 ### Fixed

package/Dockerfile

@@ -82,8 +82,12 @@ ENV WEB_CONSOLE_BIND=0.0.0.0
 # build context) — source stays private, the image matches the npm version
 # exactly. Build with: docker build --build-arg BAZE_CORE_VERSION=0.2.0 .
 ARG BAZE_CORE_VERSION=latest
+# Local-source build: pass BAZE_CORE_TARBALL=/core.tgz (COPY'd into the
+# build context) to install the workspace package instead of the registry
+# version — lets us verify un-released fixes (e.g. D51) in the image.
+ARG BAZE_CORE_TARBALL=
 WORKDIR /home/baize
-RUN npm install -g @baize-ai/core@${BAZE_CORE_VERSION} \
+RUN if [ -n "${BAZE_CORE_TARBALL}" ]; then npm install -g /tmp/${BAZE_CORE_TARBALL}; else npm install -g @baize-ai/core@${BAZE_CORE_VERSION}; fi \
     && baize --version \
     # ── Build-time skill dependency preinstall (reproducibility) ─────────
     # `baize init` reinstalls skill deps at runtime; doing it here bakes the
@@ -134,6 +138,11 @@ RUN mkdir -p \
 # ── Copy PM2 ecosystem config ─────────────────────────────────────────────────
 COPY --chown=baize:baize templates/pm2/ecosystem.config.cjs /home/baize/baize/pm2/ecosystem.config.cjs
 
+# ── Local-source build context (optional) ────────────────────────────────────
+# When BAZE_CORE_TARBALL is set, the tarball must live at ./core.tgz in the
+# build context; it is staged at /tmp so the install RUN above can consume it.
+COPY core.tgz /tmp/core.tgz
+
 # ── Copy entrypoint ───────────────────────────────────────────────────────────
 COPY --chown=baize:baize docker/entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh

package/cli/commands/init.js

@@ -41,6 +41,7 @@ import {
   saveCodexApiKeyToEnv,
   saveCodexBaseUrlToEnv,
   writeCodexConfig,
+  applyCodexProviderBlock,
 } from '../lib/runtime-setup.js';
 
 // Source directories (shipped with baize package)
@@ -839,6 +840,30 @@ function syncCoreSkills() {
   const installed = [];
   const updated = [];
 
+  // D51: web-console imports `../../../cli/lib/runtime-setup.js`, which from
+  // `~/.claude/skills/web-console/scripts/` resolves to `~/.claude/cli/lib/`.
+  // The npm package ships `package/cli`, but init never deployed it to the
+  // runtime tree — web-console crashed with ERR_MODULE_NOT_FOUND in the image.
+  // Deploy the shared CLI lib beside SKILLS_DIR so the import path mirrors the
+  // package layout (package/cli ↔ <SKILLS_DIR>/../cli).
+  const cliSrc = path.join(PACKAGE_ROOT, 'cli');
+  const cliDest = path.join(path.dirname(SKILLS_DIR), 'cli');
+  if (fs.existsSync(cliSrc)) {
+    try {
+      copyTree(cliSrc, cliDest);
+      // runtime-setup.js imports smol-toml (D51). The cli/ tree is deployed
+      // outside any skill's node_modules, so the dependency must ride along —
+      // mirror the package layout by copying the package's smol-toml into
+      // <cliDest>/node_modules/.
+      const tomlSrc = path.join(PACKAGE_ROOT, 'node_modules', 'smol-toml');
+      if (fs.existsSync(tomlSrc)) {
+        copyTree(tomlSrc, path.join(cliDest, 'node_modules', 'smol-toml'));
+      }
+    } catch {
+      console.log(`  ${warn(`Failed to sync cli/ to ${cliDest}`)}`);
+    }
+  }
+
   const entries = fs.readdirSync(CORE_SKILLS_SRC, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -2182,9 +2207,17 @@ export async function initCommand(args) {
           }
         }
       }
-
-      // Write ~/.codex/config.toml to suppress interactive prompts on first launch
-      if (writeCodexConfig(BAIZE_DIR, { openaiBaseUrl: pendingCodexBaseUrl || undefined })) {
+      // Write ~/.codex/config.toml to suppress interactive prompts on first
+      // launch. A custom --codex-base-url becomes a dedicated provider block
+      // (D51) — never the built-in-OpenAI openai_base_url override.
+      if (pendingCodexBaseUrl) {
+        applyCodexProviderBlock({
+          providerKey: 'baize-init',
+          baseUrl: pendingCodexBaseUrl,
+          token: opts.codexApiKey || undefined,
+        });
+        if (!quiet) console.log(`  ${success('Codex startup config written (provider block)')}`);
+      } else if (writeCodexConfig(BAIZE_DIR)) {
         if (!quiet) console.log(`  ${success('Codex startup config written')}`);
       }
     }
@@ -2409,7 +2442,12 @@ export async function initCommand(args) {
     }
     if (pendingCodexBaseUrl) {
       saveCodexBaseUrlToEnv(pendingCodexBaseUrl);
-      writeCodexConfig(BAIZE_DIR, { openaiBaseUrl: pendingCodexBaseUrl });
+      // D51: custom endpoint → dedicated provider block, not the built-in-OpenAI override.
+      applyCodexProviderBlock({
+        providerKey: 'baize-init',
+        baseUrl: pendingCodexBaseUrl,
+        token: opts.codexApiKey || undefined,
+      });
     }
 
     // Timezone: use resolved value or show current
@@ -2518,7 +2556,12 @@ export async function initCommand(args) {
   }
   if (pendingCodexBaseUrl) {
     saveCodexBaseUrlToEnv(pendingCodexBaseUrl);
-    writeCodexConfig(BAIZE_DIR, { openaiBaseUrl: pendingCodexBaseUrl });
+    // D51: custom endpoint → dedicated provider block, not the built-in-OpenAI override.
+    applyCodexProviderBlock({
+      providerKey: 'baize-init',
+      baseUrl: pendingCodexBaseUrl,
+      token: opts.codexApiKey || undefined,
+    });
   }
   // Step 8: Configure timezone
   if (!quiet) console.log(`\n${heading('Timezone configuration...')}`);

package/cli/commands/runtime.js

@@ -29,6 +29,7 @@ import {
   saveSetupTokenToEnv,
   saveCodexApiKey,
   saveCodexBaseUrlToEnv,
+  applyCodexProviderBlock,
   saveCodexApiKeyToEnv,
   writeCodexConfig,
 } from '../lib/runtime-setup.js';
@@ -123,7 +124,14 @@ export function applyBaseUrl(target, baseUrl) {
   }
   if (target === 'codex') {
     if (!saveCodexBaseUrlToEnv(baseUrl)) return false;
-    return writeCodexConfig(BAIZE_DIR, { openaiBaseUrl: baseUrl });
+    // D51: external endpoints get a dedicated provider block (DeepSeek-safe,
+    // local compaction) — never the built-in-openai openai_base_url override.
+    try {
+      applyCodexProviderBlock({ providerKey: 'baize-runtime', baseUrl, projectDir: BAIZE_DIR });
+      return true;
+    } catch {
+      return false;
+    }
   }
   return false;
 }

package/cli/lib/__tests__/init-base-url.test.js

@@ -72,7 +72,7 @@ describe('base URL support', () => {
     }
   });
 
-  test('writeCodexConfig writes openai_base_url when OPENAI_BASE_URL is set', async () => {
+  test('writeCodexConfig never writes openai_base_url — env override is dropped (D51)', async () => {
     const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'baize-base-url-'));
     const originalHome = process.env.HOME;
     const originalOpenAiBaseUrl = process.env.OPENAI_BASE_URL;
@@ -87,7 +87,7 @@ describe('base URL support', () => {
 
       const configPath = path.join(tmpRoot, '.codex', 'config.toml');
       const config = fs.readFileSync(configPath, 'utf8');
-      assert.match(config, /openai_base_url = "https:\/\/openai-proxy\.example\.com\/v1"/);
+      assert.doesNotMatch(config, /openai_base_url/);
     } finally {
       if (originalHome === undefined) delete process.env.HOME;
       else process.env.HOME = originalHome;
@@ -99,31 +99,73 @@ describe('base URL support', () => {
     }
   });
 
-  test('writeCodexConfig writes openai_base_url when explicit opts.openaiBaseUrl is provided', async () => {
+  test('writeCodexConfig strips a stale legacy openai_base_url from existing config (D51)', async () => {
     const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'baize-base-url-opt-'));
     const originalHome = process.env.HOME;
-    const originalOpenAiBaseUrl = process.env.OPENAI_BASE_URL;
 
     process.env.HOME = tmpRoot;
-    delete process.env.OPENAI_BASE_URL;
 
     try {
       const { writeCodexConfig } = await import('../runtime-setup.js');
 
-      assert.equal(
-        writeCodexConfig(path.join(tmpRoot, 'baize-project'), { openaiBaseUrl: 'https://explicit-proxy.example.com/v1' }),
-        true
-      );
-
       const configPath = path.join(tmpRoot, '.codex', 'config.toml');
+      fs.mkdirSync(path.dirname(configPath), { recursive: true });
+      fs.writeFileSync(configPath, 'openai_base_url = "https://explicit-proxy.example.com/v1"\nmodel = "old"\n');
+
+      assert.equal(writeCodexConfig(path.join(tmpRoot, 'baize-project'), { openaiBaseUrl: 'https://explicit-proxy.example.com/v1' }), true);
+
       const config = fs.readFileSync(configPath, 'utf8');
-      assert.match(config, /openai_base_url = "https:\/\/explicit-proxy\.example\.com\/v1"/);
+      assert.doesNotMatch(config, /openai_base_url/);
+      assert.match(config, /^model = "old"$/m, 'unrelated keys preserved');
     } finally {
       if (originalHome === undefined) delete process.env.HOME;
       else process.env.HOME = originalHome;
 
-      if (originalOpenAiBaseUrl === undefined) delete process.env.OPENAI_BASE_URL;
-      else process.env.OPENAI_BASE_URL = originalOpenAiBaseUrl;
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  test('--codex-base-url path writes a baize-init provider block (D51)', async () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'baize-init-provider-'));
+    const originalHome = process.env.HOME;
+    const originalBaizeDir = process.env.BAIZE_DIR;
+
+    process.env.HOME = tmpRoot;
+    process.env.BAIZE_DIR = path.join(tmpRoot, 'baize');
+
+    try {
+      const { applyCodexProviderBlock } = await import('../runtime-setup.js');
+
+      // This mirrors exactly what init.js does when --codex-base-url is given:
+      // pendingCodexBaseUrl → applyCodexProviderBlock (providerKey 'baize-init').
+      // projectDir passed explicitly: the module-level BAIZE_DIR fallback is
+      // captured at first import and may not match this test's env override.
+      applyCodexProviderBlock({
+        providerKey: 'baize-init',
+        baseUrl: 'https://proxy.example.com/v1',
+        token: 'sk-init-key',
+        projectDir: process.env.BAIZE_DIR,
+      });
+
+      const config = fs.readFileSync(path.join(tmpRoot, '.codex', 'config.toml'), 'utf8');
+      assert.match(config, /\[model_providers\.baize-init\]/);
+      assert.match(config, /^model_provider = "baize-init"$/m);
+      assert.match(config, /^name = "baize-init"$/m);
+      assert.match(config, /^base_url = "https:\/\/proxy\.example\.com\/v1"$/m);
+      assert.match(config, /^wire_api = "responses"$/m);
+      assert.match(config, /^experimental_bearer_token = "sk-init-key"$/m);
+      assert.doesNotMatch(config, /openai_base_url/);
+
+      // Project-level: no provider block, no override.
+      const projectConfig = fs.readFileSync(path.join(tmpRoot, 'baize', '.codex', 'config.toml'), 'utf8');
+      assert.doesNotMatch(projectConfig, /model_provider/);
+      assert.doesNotMatch(projectConfig, /\[model_providers\./);
+      assert.doesNotMatch(projectConfig, /openai_base_url/);
+    } finally {
+      if (originalHome === undefined) delete process.env.HOME;
+      else process.env.HOME = originalHome;
+      if (originalBaizeDir === undefined) delete process.env.BAIZE_DIR;
+      else process.env.BAIZE_DIR = originalBaizeDir;
 
       fs.rmSync(tmpRoot, { recursive: true, force: true });
     }

package/cli/lib/__tests__/runtime-base-url.test.js

@@ -126,6 +126,8 @@ describe('runtime base URL support', () => {
     assert.equal(claudeSettings.env.ANTHROPIC_BASE_URL, 'https://claude-proxy.example.com');
 
     const codexConfig = fs.readFileSync(path.join(tmpRoot, '.codex', 'config.toml'), 'utf8');
-    assert.match(codexConfig, /openai_base_url = "https:\/\/codex-proxy\.example\.com\/v1"/);
+    assert.match(codexConfig, /model_provider = "baize-runtime"/);
+    assert.match(codexConfig, /\[model_providers\.baize-runtime\][\s\S]*?base_url = "https:\/\/codex-proxy\.example\.com\/v1"/);
+    assert.doesNotMatch(codexConfig, /openai_base_url/);
   });
 });

package/cli/lib/__tests__/runtime-setup.test.js

@@ -162,9 +162,55 @@ describe('renderCodexGlobalConfig', () => {
     assert.doesNotMatch(content, /check_for_update_on_startup/);
   });
 
-  it('includes openai_base_url when provided', () => {
+  it('never writes openai_base_url — legacy opt only cleans the override (D51)', () => {
     const content = renderCodexGlobalConfig('/home/user/baize', '', { openaiBaseUrl: 'https://proxy.example.com/v1' });
-    assert.match(content, /openai_base_url = "https:\/\/proxy\.example\.com\/v1"/);
+    assert.doesNotMatch(content, /openai_base_url/);
+  });
+
+  it('renders a dedicated provider block from opts.codex (D51)', () => {
+    const content = renderCodexGlobalConfig('/home/user/baize', '', {
+      codex: {
+        providerKey: 'deepseek',
+        baseUrl: 'https://api.deepseek.com/',
+        token: 'sk-test',
+        model: 'deepseek-v4-flash',
+      },
+    });
+    assert.match(content, /^model = "deepseek-v4-flash"$/m);
+    assert.match(content, /^model_provider = "deepseek"$/m);
+    assert.match(content, /\[model_providers\.deepseek\]/);
+    assert.match(content, /name = "deepseek"/);
+    assert.match(content, /base_url = "https:\/\/api\.deepseek\.com\/"/);
+    assert.match(content, /wire_api = "responses"/);
+    assert.match(content, /experimental_bearer_token = "sk-test"/);
+    assert.doesNotMatch(content, /openai_base_url/);
+  });
+
+  it('provider block omits the token key when no token is given (D51)', () => {
+    const content = renderCodexGlobalConfig('/home/user/baize', '', {
+      codex: { providerKey: 'deepseek', baseUrl: 'https://api.deepseek.com/', model: 'deepseek-v4-flash' },
+    });
+    assert.match(content, /\[model_providers\.deepseek\]/);
+    assert.doesNotMatch(content, /experimental_bearer_token/);
+  });
+
+  it('provider block replaces the legacy override and keeps other provider tables (D51)', () => {
+    const existing = [
+      'openai_base_url = "https://old.example.com/v1"',
+      'model = "old"',
+      '',
+      '[model_providers.userown]',
+      'name = "userown"',
+      'base_url = "https://u.example"',
+      '',
+    ].join('\n');
+    const content = renderCodexGlobalConfig('/home/user/baize', existing, {
+      codex: { providerKey: 'deepseek', baseUrl: 'https://api.deepseek.com/' },
+    });
+    assert.doesNotMatch(content, /openai_base_url/);
+    assert.match(content, /^model = "old"$/m, 'model kept when opts.codex.model absent');
+    assert.match(content, /\[model_providers\.userown\]/, 'user tables survive');
+    assert.match(content, /\[model_providers\.deepseek\]/);
   });
 
   it('preserves unknown global top-level keys, sections, and unrelated projects', () => {
@@ -189,22 +235,23 @@ describe('renderCodexGlobalConfig', () => {
     assert.match(content, /\[projects\."\/home\/user\/baize"\]\ntrust_level = "trusted"/);
   });
 
-  it('preserves existing openai_base_url when baize has no value', () => {
+  it('strips a stale legacy openai_base_url even without opts (D51 migration)', () => {
     const existing = 'openai_base_url = "https://user-proxy.example.com/v1"\n';
     const content = renderCodexGlobalConfig('/home/user/baize', existing);
-    assert.match(content, /openai_base_url = "https:\/\/user-proxy\.example\.com\/v1"/);
+    assert.doesNotMatch(content, /openai_base_url/);
   });
 
-  it('overwrites existing openai_base_url when baize has a value', () => {
+  it('cleans the legacy openai_base_url when the legacy opt is passed (D51)', () => {
     const existing = 'openai_base_url = "https://old-proxy.example.com/v1"\n';
     const content = renderCodexGlobalConfig('/home/user/baize', existing, {
       openaiBaseUrl: 'https://new-proxy.example.com/v1',
     });
-    assert.match(content, /openai_base_url = "https:\/\/new-proxy\.example\.com\/v1"/);
+    assert.doesNotMatch(content, /openai_base_url/);
     assert.doesNotMatch(content, /old-proxy/);
   });
 });
 
+
 describe('writeCodexConfig', () => {
   it('writes project-level config and global config to separate locations', () => {
     const globalConfigPath = path.join(fakeHome, '.codex', 'config.toml');

package/cli/lib/runtime/codex.js

@@ -55,10 +55,27 @@ function getCodexApiBaseUrl() {
   try {
     const configPath = path.join(os.homedir(), '.codex', 'config.toml');
     const config = fs.readFileSync(configPath, 'utf8');
+    // legacy override first (pre-D51 configs)
     const match = config.match(/^\s*openai_base_url\s*=\s*"([^"]+)"\s*$/m);
     if (match?.[1]) {
       return match[1].replace(/\/+$/, '');
     }
+    // D51: the active provider block carries the endpoint — resolve the
+    // top-level model_provider slug and read its base_url, so the /models
+    // probe stays in sync with what codex actually calls (otherwise an
+    // external endpoint activation reports 401 against api.openai.com).
+    const providerKey = config.match(/^\s*model_provider\s*=\s*"([^"]+)"\s*$/m)?.[1];
+    if (providerKey) {
+      const escaped = providerKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const blockRe = new RegExp(
+        `\\[model_providers\\.${escaped}\\][^[]*?\\bbase_url\\s*=\\s*"([^"]+)"`,
+        'm'
+      );
+      const blockMatch = config.match(blockRe);
+      if (blockMatch?.[1]) {
+        return blockMatch[1].replace(/\/+$/, '');
+      }
+    }
   } catch { /* ignore missing config */ }
 
   if (process.env.OPENAI_BASE_URL) {

package/cli/lib/runtime-setup.js

@@ -11,6 +11,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { execSync, execFileSync, spawnSync } from 'node:child_process';
 import { parse, stringify } from 'smol-toml';
+import crypto from 'node:crypto';
 import { BAIZE_DIR } from './config.js';
 import { commandExists } from './shell-utils.js';
 import { parseClaudeAuthStatus, parseCodexLoginStatus } from './auth-parsers.js';
@@ -410,21 +411,30 @@ export function renderCodexProjectConfig(existingContent = '', opts = {}) {
 /**
  * Render global ~/.codex/config.toml with user/environment-level settings.
  *
- * Contains only trust declarations and optional base URL override.
- * Existing [projects.*] trust entries are preserved; the baize project trust
- * entry is always regenerated.
- *
- * @param {string} projectDir - The baize working directory to pre-trust
- * @param {string} existingContent - Existing global config.toml contents (optional)
- * @param {{ openaiBaseUrl?: string }} opts - Optional Codex config overrides
+ * Contains only trust declarations and the optional D51 provider block.
  * @returns {string}
  */
 export function renderCodexGlobalConfig(projectDir, existingContent = '', opts = {}) {
   const absProject = path.resolve(projectDir);
-  const openaiBaseUrl = opts.openaiBaseUrl || process.env.OPENAI_BASE_URL || '';
   const obj = parseCodexToml(existingContent);
-  if (openaiBaseUrl) {
-    obj.openai_base_url = openaiBaseUrl;
+  // D51: external Codex endpoints are configured as a dedicated provider
+  // block (model_providers.<key> + top-level model_provider) instead of
+  // overriding the built-in OpenAI provider via openai_base_url — the override
+  // keeps provider.name === "OpenAI", which makes Codex enable remote
+  // compaction v2 against endpoints that cannot answer it (DeepSeek → fatal
+  // "expected exactly one compaction output item").
+  const codex = opts.codex || null;
+  if (codex && codex.providerKey && codex.baseUrl) {
+    obj.model = codex.model || obj.model;
+    obj.model_provider = codex.providerKey;
+    obj.model_providers = isTomlSectionValue(obj.model_providers) ? obj.model_providers : {};
+    const block = { name: codex.providerKey, base_url: codex.baseUrl, wire_api: 'responses' };
+    if (codex.token) block.experimental_bearer_token = codex.token;
+    obj.model_providers[codex.providerKey] = block;
+    delete obj.openai_base_url; // migration cleanup — never mix the two mechanisms
+  } else {
+    // D51: no provider block requested → never leave a stale override behind
+    delete obj.openai_base_url;
   }
   obj.features = isTomlSectionValue(obj.features) ? obj.features : {};
   obj.features.hooks = true;
@@ -438,8 +448,9 @@ export function renderCodexGlobalConfig(projectDir, existingContent = '', opts =
  *
  * - Project config (<projectDir>/.codex/config.toml): headless settings,
  *   features, notice suppression — required for baize unattended operation.
- * - Global config (~/.codex/config.toml): trust declarations, optional
- *   base URL override.
+ * - Global config (~/.codex/config.toml): trust declarations + optional D51
+ *   provider block (opts.codex). Legacy opts.openaiBaseUrl is still accepted
+ *   for compatibility but only cleans the override key (D51 migration).
  *
  * Called by both `baize init` (Codex runtime) and `baize runtime codex` so the
  * config is always present when switching to Codex.
@@ -485,6 +496,136 @@ export function writeCodexConfig(projectDir, opts = {}) {
   }
 }
 
+// ── D51: dedicated provider block writers (DeepSeek remote-compaction fix) ──
+
+// Keys Codex treats as built-in model_providers entries — a custom provider
+// must never shadow these (merge_configured_model_providers silently drops
+// colliding keys). Also covers the web-console restore targets.
+export const CODEX_RESERVED_PROVIDER_KEYS = new Set([
+  'openai', 'azure', 'amazon-bedrock', 'amazon-bedrock-runtime',
+  'ollama', 'lmstudio', 'gpt-oss', 'official', 'official-openai',
+]);
+
+/**
+ * Deterministic provider slug for a provider id: ASCII slug, or
+ * `codex-<id-hash8>` when empty or reserved. Pure — no store access.
+ */
+export function codexProviderKeyForId(id) {
+  const base = String(id || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  if (base && !CODEX_RESERVED_PROVIDER_KEYS.has(base)) return base;
+  const hash = crypto.createHash('sha256').update(String(id || '')).digest('hex').slice(0, 8);
+  return `codex-${hash}`;
+}
+
+function globalCodexConfigPath(homeDir) {
+  // D51 incident hardening: jest's ESM sandbox resolves os.homedir() to the
+  // REAL home regardless of process.env.HOME — relying on the default once
+  // wrote test fixtures into the user's live ~/.codex. Callers must pass
+  // homeDir explicitly; when they don't, honor HOME env first and only then
+  // fall back to os.homedir().
+  const base = homeDir || process.env.HOME || os.homedir();
+  return path.join(base, '.codex', 'config.toml');
+}
+
+function projectCodexConfigPathFor(projectDir) {
+  // D51: resolve the fallback lazily — BAIZE_DIR is a module-load constant in
+  // config.js, so under test runners that mutate HOME/BAIZE_DIR per case the
+  // cached value would point at the first case's temp dir. env wins here.
+  const base = projectDir
+    ? path.resolve(projectDir)
+    : (process.env.BAIZE_DIR || BAIZE_DIR);
+  return path.join(base, '.codex', 'config.toml');
+}
+
+/** Parse + stringify round-trip preserving everything smol-toml supports. */
+function rewriteCodexToml(targetPath, mutate, { mode } = {}) {
+  const dir = path.dirname(targetPath);
+  fs.mkdirSync(dir, { recursive: true });
+  let content = '';
+  try { content = fs.readFileSync(targetPath, 'utf8'); } catch { /* new file */ }
+  const obj = parseCodexToml(content);
+  mutate(obj);
+  const out = stringify(obj);
+  fs.writeFileSync(targetPath, out.endsWith('\n') ? out : `${out}\n`, mode ? { mode } : 'utf8');
+  return targetPath;
+}
+
+/**
+ * D51: activate an external Codex provider as a dedicated [model_providers.<key>]
+ * block in the GLOBAL config + top-level model_provider, and ensure both files
+ * are free of the legacy openai_base_url override. The block's `name` always
+ * equals the slug (never "OpenAI") so Codex treats the endpoint as a generic
+ * responses-compatible provider → local compaction (DeepSeek-safe).
+ *
+ * @param {{ providerKey: string, baseUrl: string, token?: string, model?: string,
+ *           homeDir?: string, projectDir?: string }} opts
+ * @returns {{ globalPath: string, projectPath: string }} written file paths
+ */
+export function applyCodexProviderBlock(opts) {
+  const { providerKey, baseUrl, token, model } = opts || {};
+  if (!providerKey || !baseUrl) {
+    throw new Error('applyCodexProviderBlock requires providerKey and baseUrl');
+  }
+  const key = CODEX_RESERVED_PROVIDER_KEYS.has(providerKey)
+    ? codexProviderKeyForId(providerKey)
+    : providerKey;
+  const globalPath = rewriteCodexToml(globalCodexConfigPath(opts.homeDir), (obj) => {
+    if (model) obj.model = model;
+    obj.model_provider = key;
+    obj.model_providers = isTomlSectionValue(obj.model_providers) ? obj.model_providers : {};
+    const block = { name: key, base_url: baseUrl, wire_api: 'responses' };
+    if (token) block.experimental_bearer_token = token;
+    obj.model_providers[key] = block;
+    delete obj.openai_base_url;
+  }, { mode: 0o600 }); // token may ride the global file — write user-only from the start
+
+
+  // D31 semantics: codex prefers project-level values, so the provider model
+  // must be mirrored here — otherwise a stale project model (e.g. gpt-5.5
+  // backfilled by init) would shadow the just-activated provider model.
+  const projectPath = rewriteCodexToml(projectCodexConfigPathFor(opts.projectDir), (obj) => {
+    if (model) obj.model = model;
+    delete obj.openai_base_url; // project-level never carries endpoint/auth
+  });
+  return { globalPath, projectPath };
+}
+
+/**
+ * D51: restore the official OpenAI configuration — remove the top-level
+ * model_provider and every baize-written custom provider block, drop the
+ * legacy openai_base_url override, reset model to gpt-5.5. Project-level
+ * model resets too (mirrors the pre-D51 applyCodexOfficial behavior).
+ *
+ * @param {{ homeDir?: string, projectDir?: string }} [opts]
+ * @returns {{ globalPath: string, projectPath: string }}
+ */
+export function restoreCodexOfficialBlock(opts = {}) {
+  const globalPath = rewriteCodexToml(globalCodexConfigPath(opts.homeDir), (obj) => {
+    delete obj.model_provider;
+    if (isTomlSectionValue(obj.model_providers)) {
+      for (const key of Object.keys(obj.model_providers)) {
+        const block = obj.model_providers[key];
+        // D51 review P2: only remove blocks baize itself wrote — the writer
+        // always stamps name === key && wire_api === 'responses'. Hand-edited
+        // user providers (any other shape) must survive an official restore.
+        const isBaizeWritten = isTomlSectionValue(block)
+          && block.name === key
+          && block.wire_api === 'responses';
+        if (isBaizeWritten) delete obj.model_providers[key];
+      }
+      if (Object.keys(obj.model_providers).length === 0) delete obj.model_providers;
+    }
+    delete obj.openai_base_url;
+    obj.model = 'gpt-5.5';
+  });
+  const projectPath = rewriteCodexToml(projectCodexConfigPathFor(opts.projectDir), (obj) => {
+    delete obj.openai_base_url;
+    obj.model = 'gpt-5.5';
+  });
+  return { globalPath, projectPath };
+}
+
+
 /**
  * Persist an OpenAI API key to ~/.codex/auth.json (Codex's native credential store).
  * Also sets OPENAI_API_KEY in process.env for the current init process so that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baize-ai/core",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "type": "module",
   "description": "Baize (白泽) — autonomous AI agent infrastructure",
   "main": "cli/baize.js",
@@ -46,4 +46,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/scripts/docker-publish.sh

@@ -35,10 +35,6 @@ docker build \
   -t "${GHCR_IMAGE}:${VERSION}" \
   -t "${GHCR_IMAGE}:latest" \
   .
-  "${BUILD_ARGS[@]}" \
-  -t "${GHCR_IMAGE}:${VERSION}" \
-  -t "${GHCR_IMAGE}:latest" \
-  .
 
 if [ -n "${ACR_REGISTRY}" ] && [ -n "${ACR_NAMESPACE}" ]; then
   ACR_IMAGE="${ACR_REGISTRY}/${ACR_NAMESPACE}/baize-core"