@baize-ai/core 0.3.15 → 0.3.17

package/.dockerignore

@@ -6,3 +6,4 @@
 !templates/pm2/ecosystem.config.cjs
 !.claude-local/claude
 !.claude-local/claude.version
+!core.tgz

package/CHANGELOG.md

@@ -5,6 +5,35 @@ 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.17] - 2026-09-14
+
+### Added
+- 启动链路 PATH 完整性加固（D54）：共享 `cli/lib/path-bins.js`（`completeBinPath`/`knownBinDirs`——静态 `~/.npm-global/bin` + 动态 npm prefix）；所有 runtime 二进制 spawn（codex/claude/baize）子进程 env 补完整 PATH——登录 shell PATH 污染（09-13 事故根因：缺 `~/.npm-global/bin`）不再导致 ENOENT
+- `init.js ensureCompletePathProfile`：每次 init 修复 shell profile 完整 bin PATH（npm-global/.local/claude/baize/node），幂等 + 存量缺失自动补；`saveSystemPath` 写显式完整集
+- `ecosystem.config.cjs` `ENHANCED_PATH` 显式含 `~/.npm-global/bin`（PM2 服务不依赖 SYSTEM_PATH/进程 PATH）
+- Guardian 连续失败告警（`ALERT_AFTER_RESTARTS=3` → `~/baize/activity-monitor/guardian-alert.json` + 日志，恢复自动清除）；ENOENT 启动失败打修复提示
+- `baize doctor` 新增 PATH 完整性检查（`path_incomplete` issue + path 组）
+- Dockerfile 本地源码构建层序修复：`COPY core.tgz` 移到 npm install RUN 前（tarball 变更正确失效 npm 层缓存）
+- 运维手册 `docs/ops-runbook.md`：PATH 事故排查 + D54 加固说明 + 巡检命令
+
+### Changed
+- `docker/entrypoint.sh` 不再写 `SYSTEM_PATH`（init.js `saveSystemPath` 唯一写者，写完整集）
+- `templates/pm2/ecosystem.config.cjs` 与 `docker-publish.sh`：发布构建临时 context + 空 `core.tgz` 占位（可选 COPY 不破坏 registry 构建）
+
+## [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,17 @@ 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=
+# Local-source build tarball — COPY'd BEFORE the install RUN so the file is
+# present in that layer AND a tarball change invalidates the install layer.
+# Registry builds provide an empty placeholder via docker-publish.sh's temp
+# context (or omit BAZE_CORE_TARBALL → the COPY still needs a file present).
+COPY core.tgz /tmp/core.tgz
 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

package/cli/commands/doctor.js

@@ -20,6 +20,7 @@ import { loadComponents } from '../lib/components.js';
 import { fetchLatestTagAsync, compareSemverDesc } from '../lib/github.js';
 import { getCurrentVersion } from '../lib/self-upgrade.js';
 import { commandExists } from '../lib/shell-utils.js';
+import { completeBinPath } from '../lib/path-bins.js';
 import { parseSkillMd } from '../lib/skill.js';
 import { bold, dim, green, red, yellow, heading } from '../lib/colors.js';
 import { getActiveAdapter } from '../lib/runtime/index.js';
@@ -280,6 +281,30 @@ function checkTmuxSession() {
   }
 }
 
+/**
+ * D54: verify the runtime binaries are resolvable from the CURRENT process
+ * PATH (i.e. PM2 services spawned from here can find codex/claude). A
+ * login-shell-polluted PATH (missing ~/.npm-global/bin) shows up here as
+ * missing binaries even though the files exist.
+ */
+function checkBinResolvable(bin) {
+  try {
+    execFileSync(bin, ['--version'], {
+      stdio: 'pipe', encoding: 'utf8', timeout: 10000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPathComplete() {
+  const bins = ['baize'];
+  if (ACTIVE_RUNTIME === 'codex') bins.push('codex');
+  else bins.push('claude');
+  const missing = bins.filter((b) => !checkBinResolvable(b));
+  return { complete: missing.length === 0, missing };
+}
+
 // ── Diagnostics collection ───────────────────────────────────────
 
 async function collectDiagnostics(env) {
@@ -308,11 +333,13 @@ async function collectDiagnostics(env) {
     ? checkPm2Services()
     : { running: false, total: 0, online: 0, activityMonitor: false, procs: [] };
   const session = tmux.installed ? checkTmuxSession() : false;
+  const pathCheck = checkPathComplete();
 
   return {
     system: { tmux, pm2, network: net },
     ai: { cli, auth, authStatus, autonomous, networkSkipped: !net.reachable },
     services: { ...services, session },
+    path: pathCheck,
   };
 }
 
@@ -366,6 +393,19 @@ function buildDiagnosticJson(diag, coreVersion) {
       }
     }
   }
+  // D54: PATH completeness — runtime binaries must resolve from the current
+  // process PATH (services spawned from here inherit it). A polluted login
+  // shell PATH missing ~/.npm-global/bin surfaces here as ENOENT risk.
+  // Only relevant when the CLI is actually installed (else cli_missing covers
+  // it and a PATH repair hint would be misleading).
+  const pathSkipped = !diag.ai.cli.installed;
+  if (!pathSkipped && !diag.path.complete) {
+    issues.push({
+      id: 'path_incomplete',
+      label: `PATH 缺失运行时二进制: ${diag.path.missing.join(', ')}`,
+      hint: 'Run: baize init（修复 ~/.npm-global/bin 等完整 PATH）',
+    });
+  }
 
   return {
     version: coreVersion.success ? coreVersion.version : null,
@@ -395,6 +435,10 @@ function buildDiagnosticJson(diag, coreVersion) {
         procs: diag.services.procs.map(p => ({ name: p.name, status: p.pm2_env?.status || 'unknown' })),
         session: { active: diag.services.session },
       },
+      path: {
+        passed: !diag.ai.cli.installed ? null : diag.path.complete,
+        checks: { missing: diag.path.missing },
+      },
     },
     issues,
   };
@@ -512,6 +556,18 @@ function displayServiceGroup(diag, jsonGroup) {
   logToFile(`check: services — ${jsonGroup.passed ? 'passed' : 'failed'}`);
 }
 
+// D54: PATH completeness group — runtime binaries must resolve from the
+// current process PATH (services spawned from here inherit it).
+function displayPathGroup(diag, jsonGroup) {
+  if (!diag.path.complete) {
+    const checks = diag.path.missing.map((b) => red(`${b} 不可解析（ENOENT 风险）`));
+    displayCheckGroup('PATH', 'fail', checks);
+  } else {
+    displayCheckGroup('PATH', 'pass', [green('运行时二进制可解析（npm-global/.local/claude/baize）')]);
+  }
+  logToFile(`check: path — ${jsonGroup.passed ? 'passed' : 'failed'}`);
+}
+
 // ── Channel discovery ────────────────────────────────────────────
 
 function getNetworkIP() {
@@ -651,6 +707,7 @@ function runClaudeFix(diagnosticJson) {
     const proc = spawn('claude', ['-p', prompt, ...permArgs], {
       cwd: BAIZE_DIR,
       stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, PATH: completeBinPath() },
     });
 
     let stdout = '';
@@ -772,6 +829,9 @@ export async function doctorCommand(args) {
   displaySystemGroup(diag, diagnostic.groups.system);
   displayAiGroup(diag, diagnostic.groups.ai_service);
   displayServiceGroup(diag, diagnostic.groups.services);
+  if (diagnostic.groups.path.passed !== null) {
+    displayPathGroup(diag, diagnostic.groups.path);
+  }
 
   // ── Phase 4: Channels ─────────────────────────────────────────
 

package/cli/commands/init.js

@@ -17,6 +17,7 @@ import { generateManifest, saveMergeBaseline } from '../lib/manifest.js';
 import { prompt, promptYesNo, promptChoice, promptSecret } from '../lib/prompts.js';
 import { bold, dim, green, red, yellow, cyan, bgGreen, success, error, warn, heading } from '../lib/colors.js';
 import { commandExists } from '../lib/shell-utils.js';
+import { knownBinDirs, completeBinPath } from '../lib/path-bins.js';
 import { getActiveAdapter } from '../lib/runtime/index.js';
 import {
   activateFreshSplitInstructions,
@@ -41,6 +42,7 @@ import {
   saveCodexApiKeyToEnv,
   saveCodexBaseUrlToEnv,
   writeCodexConfig,
+  applyCodexProviderBlock,
 } from '../lib/runtime-setup.js';
 
 // Source directories (shipped with baize package)
@@ -113,54 +115,68 @@ function installSystemPackage(pkg) {
 }
 
 /**
- * Ensure ~/.local/bin is in the user's shell profile.
- * Detects shell from $SHELL and writes to the appropriate rc file.
+ * D54: ensure the user's shell profile carries the COMPLETE bin PATH —
+ * every directory where baize/claude/codex binaries actually live:
+ *   ~/.npm-global/bin (static — codex/baize default install),
+ *   npm global prefix bin (dynamic), ~/.local/bin (claude default),
+ *   ~/.claude/bin, ~/baize/bin (components), ~/.local/node/bin.
+ * Idempotent (marker-based) and repairs existing profiles that miss any bin
+ * (the 09-13 incident root: ~/.npm-global/bin was never added, so login-shell
+ * PATH was always incomplete).
+ * NOTE: rc files are NOT chattr/chflags-locked — content-marker idempotency
+ * already prevents duplicate writes, and a lock would make `baize
+ * self-uninstall` / install.sh re-runs abort with EPERM (D54 review P1-3).
  * Returns the profile path if modified, null otherwise.
  */
-function ensureLocalBinInProfile() {
+function ensureCompletePathProfile() {
   const homedir = os.homedir();
   const shell = (process.env.SHELL || '').split('/').pop();
-  const pathLine = 'export PATH="$HOME/.local/bin:$PATH"';
-
-  // Map shell to profile file
   const profileMap = {
     zsh: '.zshrc',
     bash: '.bashrc',
-    fish: null, // fish uses different syntax
+    fish: null, // fish uses a different config mechanism (handled elsewhere)
     sh: '.profile',
   };
-
   const profileName = profileMap[shell] || '.profile';
   if (!profileName) return null; // unsupported shell (fish)
-
   const profilePath = path.join(homedir, profileName);
 
-  // Check if already present
-  try {
-    const content = fs.readFileSync(profilePath, 'utf8');
-    if (content.includes('.local/bin')) return null; // already there
-  } catch {
-    // File doesn't exist — we'll create it
-  }
+  // ── Complete bin set (single source of truth: cli/lib/path-bins.js) ──────
+  const bins = new Set(knownBinDirs());
 
-  try {
-    fs.appendFileSync(profilePath, `\n# Added by baize init\n${pathLine}\n`);
-    return `~/${profileName}`;
-  } catch {
-    return null;
+  // Read existing profile content (missing file → create)
+  let content = '';
+  try { content = fs.readFileSync(profilePath, 'utf8'); } catch { /* absent */ }
+
+  // ── Idempotent + repair: add any bin not already present ─────────────────
+  const toAdd = [];
+  for (const bin of bins) {
+    // match both absolute (~/...) and $HOME-relative forms already in profile
+    const rel = bin.startsWith(homedir) ? bin.slice(homedir.length) : bin;
+    if (content.includes(bin) || content.includes(`$HOME${rel}`)) continue;
+    const portable = bin.startsWith(homedir) ? `$HOME${rel}` : bin;
+    toAdd.push(`export PATH="${portable}:$PATH"`);
   }
+  if (toAdd.length === 0) return null; // already complete
+
+  fs.appendFileSync(profilePath, `\n# Added by baize init (D54 complete PATH)\n${toAdd.join('\n')}\n`);
+  return `~/${profileName}`;
 }
 
 /**
- * Save the current shell PATH to .env so PM2 services can use it.
- * Updates SYSTEM_PATH= line if exists, appends if not.
+ * Save the COMPLETE bin PATH to .env so PM2 services can use it.
+ * D54: no longer captures process.env.PATH (which may be polluted by a login
+ * shell) — builds the full known-good set explicitly: npm global prefix bin,
+ * ~/.local/bin, ~/.claude/bin, ~/baize/bin, ~/.local/node/bin.
  */
 function saveSystemPath(envPath) {
-  const currentPath = process.env.PATH || '';
-  // Deduplicate PATH entries before saving — prevents bloat when baize init
-  // runs while PM2 is already live (process.env.PATH may already contain
-  // the previous ENHANCED_PATH from ecosystem.config.cjs).
-  const dedupedPath = [...new Set(currentPath.split(':').filter(Boolean))].join(':');
+  const homedir = os.homedir();
+  // D54: build the full known-good set via path-bins (single source of truth)
+  const bins = new Set(knownBinDirs());
+  // keep the current PATH too (it may carry user-added entries worth keeping)
+  for (const entry of (process.env.PATH || '').split(':').filter(Boolean)) bins.add(entry);
+  const fullPath = [...bins].join(':');
+
   let content = '';
   try {
     content = fs.readFileSync(envPath, 'utf8');
@@ -168,7 +184,7 @@ function saveSystemPath(envPath) {
     return; // .env doesn't exist yet
   }
 
-  const line = `SYSTEM_PATH=${dedupedPath}`;
+  const line = `SYSTEM_PATH=${fullPath}`;
   if (content.includes('SYSTEM_PATH=')) {
     content = content.replace(/^SYSTEM_PATH=.*$/m, line);
   } else {
@@ -476,7 +492,7 @@ function verifySetupToken() {
   try {
     const result = spawnSync('claude', ['-p', 'hi', '--max-turns', '1'], {
       timeout: 30000,
-      env: { ...process.env },
+      env: { ...process.env, PATH: completeBinPath() },
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 
@@ -839,6 +855,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;
@@ -2153,7 +2193,7 @@ export async function initCommand(args) {
               console.log(`\n  ${cyan('Starting Codex device auth...')}`);
               console.log(`  ${dim('Follow the instructions to authenticate. Press Ctrl+C when done.')}\n`);
               try {
-                spawnSync('codex', ['login', '--device-auth'], { stdio: 'inherit' });
+                spawnSync('codex', ['login', '--device-auth'], { stdio: 'inherit', env: { ...process.env, PATH: completeBinPath() } });
               } catch { /* user may Ctrl+C */ }
               codexAuthenticated = isCodexAuthenticated();
               if (codexAuthenticated) {
@@ -2167,7 +2207,7 @@ export async function initCommand(args) {
               console.log(`\n  ${cyan('Starting Codex browser login...')}`);
               console.log(`  ${dim('After login completes, press Ctrl+C to return.')}\n`);
               try {
-                spawnSync('codex', ['login'], { stdio: 'inherit' });
+                spawnSync('codex', ['login'], { stdio: 'inherit', env: { ...process.env, PATH: completeBinPath() } });
               } catch { /* user may Ctrl+C */ }
               codexAuthenticated = isCodexAuthenticated();
               if (codexAuthenticated) {
@@ -2182,9 +2222,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')}`);
       }
     }
@@ -2276,9 +2324,9 @@ export async function initCommand(args) {
             // /dev/tty redirects. Use `script` to allocate a fresh pseudo-terminal
             // that gives Claude full terminal control.
             if (process.platform === 'darwin') {
-              spawnSync('script', ['-q', '/dev/null', 'claude'], { stdio: 'inherit' });
+              spawnSync('script', ['-q', '/dev/null', 'claude'], { stdio: 'inherit', env: { ...process.env, PATH: completeBinPath() } });
             } else {
-              spawnSync('claude', [], { stdio: 'inherit' });
+              spawnSync('claude', [], { stdio: 'inherit', env: { ...process.env, PATH: completeBinPath() } });
             }
           } catch { /* user may Ctrl+C */ }
           process.removeAllListeners('SIGINT');
@@ -2409,7 +2457,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 +2571,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...')}`);
@@ -2580,9 +2638,13 @@ export async function initCommand(args) {
 
   printWebConsoleInfo();
 
-  if (claudeJustInstalled) {
-    // Auto-add ~/.local/bin to shell profile so future shell sessions find claude
-    ensureLocalBinInProfile();
+  // D54: EVERY init run repairs the complete bin PATH in the shell profile
+  // (npm-global/.local/claude/baize/node bins) — idempotent, no-op when
+  // complete. Runs unconditionally: a claude-runtime deployment re-running
+  // init with --yes/--quiet must also get the missing bins repaired.
+  const profile = ensureCompletePathProfile();
+  if (profile && !quiet) {
+    console.log(`${green(`  ✔ PATH 已写入 ${profile}（含 npm-global/.local/claude/baize/node bin）`)}`);
   }
 
   if (!quiet) {

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-launch.test.js

@@ -278,12 +278,14 @@ describe('Claude launch — compat mode PATH dedupe', () => {
       await makeAdapter(ClaudeAdapter).launch({ bypassPermissions: false });
       const env = readSpecEnv();
       assert.ok(env, 'spec should be written');
-      assert.equal(env.PATH, '/a:/b:/c', 'PATH must be deduplicated in compat mode');
+      // D54: known bin dirs first + deduplicated (npm-global static first)
+      const expected = `${fakeHome}/.npm-global/bin:${fakeHome}/.local/bin:${fakeHome}/.claude/bin:${fakeHome}/baize/bin:${fakeHome}/.local/node/bin:/a:/b:/c`;
+      assert.equal(env.PATH, expected, 'PATH must carry known bins first and be deduplicated in compat mode');
 
       const tmux = findTmuxNewSession();
       const pathArg = tmux.args.find(a => a.startsWith('PATH='));
       assert.ok(pathArg, 'tmux args should contain PATH= env');
-      assert.equal(pathArg, 'PATH=/a:/b:/c', 'tmux -e PATH must also be deduplicated');
+      assert.equal(pathArg, `PATH=${expected}`, 'tmux -e PATH must also carry known bins + dedupe');
     } finally {
       process.env.PATH = origPath;
       // Restore default (clean env is now the default)