@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.7.1
+
+Codex CLI joins Claude Code and Gemini CLI in the v0.7.0 MCP-server-mode infrastructure. Brought up as v0.7.1 because Codex's TOML config format required a small hand-rolled serializer; deferred from v0.7.0 to keep that release focused on the architectural foundation.
+
+A Windows / macOS / Linux operator with Codex CLI installed can now run:
+
+```bash
+npx @pythonluvr/openwar run examples/cli-bridge-mcp-memory-brief.md \
+  --adapter cli-bridge \
+  --cli-binary codex
+```
+
+The runner writes `~/.codex/config.toml` with the OpenWar MCP server config, Codex discovers and consumes it, the bridged Codex session can call OpenWar's eight native tools through MCP. Same operator experience as Claude Code and Gemini CLI in v0.7.0.
+
+### Added
+
+- **`src/mcp/toml-writer.ts`**: hand-rolled TOML serializer scoped to MCP config shape only. Supports dotted section headers, string values, string array values. Escape rules cover every TOML 1.0 basic-string escape (`\b`, `\t`, `\n`, `\f`, `\r`, `\"`, `\\`, `\uXXXX` for non-printable Unicode). Public API is `writeTomlConfig(config: TomlConfig): string` plus `TomlConfig` type plus `upsertTomlSection(existing, header, body): string` for the read-modify-write merge path. Deliberately not a general-purpose TOML library: no integers, floats, booleans, dates, inline tables, multi-line strings, parsing.
+- **Codex CLI registry entry**: `binary: "codex"` resolves to the Codex strategy. `configPath` returns `~/.codex/config.toml` via `os.homedir()`. Serializes the standard `McpConfigFileContent` to TOML via the new writer. No CLI flag injection (Codex auto-discovers `~/.codex/config.toml`). `cleanupConfigFile: false` consistent with Gemini (operators who wire Codex MCP typically want the wiring sticky). `mergeIntoExisting: true` so existing operator-edited sections survive.
+- **`BridgedCliStrategy` interface gains three optional fields** (back-compat additive): `serializeConfig?(content): string` (default `JSON.stringify(content, null, 2)`), `mergeIntoExisting?: boolean` (default `false`), `mergeSectionHeader?: string` (default `"mcp_servers.<serverName>"`). Claude Code and Gemini CLI entries unchanged; the JSON default + overwrite behavior matches v0.7.0 exactly.
+- **Runner-side read-modify-write** in `src/mcp/cli-bridge-wiring.ts`. When a strategy sets `mergeIntoExisting: true` and the config file exists, the runner reads the existing content, calls `upsertTomlSection` to replace or append just the OpenWar section, writes the merged result. When the file doesn't exist, behavior is unchanged (write the serialized output verbatim).
+- **Tests**: `tests/mcp/toml-writer.test.ts` (25 cases covering basic strings, every TOML 1.0 escape individually, Windows backslash paths, paths with spaces, dotted section headers, string arrays, empty arrays, the canonical MCP config shape, and 6 cases on `upsertTomlSection` for append / replace / final-section / prefix-collision / CRLF normalization). `tests/mcp/cli-bridge-wiring-codex.test.ts` (4 end-to-end cases against a tmp HOME: writes TOML to `~/.codex/config.toml`, merge preserves operator `[user]` + `[history]` sections, merge replaces stale `[mcp_servers.openwar]` block, `cli.mcp_forward: false` opt-out short-circuits the whole setup). `tests/mcp/bridged-cli-registry.test.ts` extended with 7 Codex resolution + behavior cases.
+- **`docs/adapters.md`**: cli-bridge section gains a "MCP-server-mode and the bridged-CLI registry" subsection with a table of all three registered CLIs (Claude Code, Gemini CLI, Codex CLI) and their config strategy.
+
+### Changed
+
+- The cli-bridge MCP forwarding now serializes the config file through the strategy's `serializeConfig` hook (default JSON, Codex TOML). Behavior for Claude Code and Gemini CLI is byte-identical to v0.7.0.
+
+### Phase 0 design pick
+
+**Append vs overwrite for `~/.codex/config.toml`: read-modify-write.** Builder picked option (a) from the v0.7.1 brief for safety. Operators with hand-edited Codex configs (model preferences, history settings) keep those sections intact across OpenWar runs. The merge is text-boundary based: find `[mcp_servers.openwar]` at column 0, replace its body up to the next column-0 section header or EOF, append if absent. No TOML parser required.
+
+### Known smoke-gap
+
+The brief allowed deferring the operator smoke test if Codex CLI isn't available locally. This release ships on the strength of 35 new unit tests (TOML writer + Codex registry + end-to-end wiring against a tmp HOME), validated cross-platform via the existing CI matrix. A real bridged-Codex session against an OpenWar brief is the v0.7.2 smoke-verification target once the operator has Codex installed.
+
+### Out of scope (deferred or skipped)
+
+- **aider registry entry.** Aider has no native MCP server support today. Defer to v0.7.2 or whenever aider ships first-class MCP support.
+- **TOML parsing.** OpenWar only writes TOML. No parser is added.
+- **General-purpose TOML support.** The serializer covers only what MCP config requires. Scope creep is the failure mode for v0.7.1; integers, floats, booleans, dates, inline tables, multi-line strings, tables of tables are all deliberately unsupported.
+
+### Notes for forkers and War Room integrators
+
+- Zero new runtime dependencies. The TOML writer is ~150 lines of hand-rolled Node stdlib.
+- No state schema bump. No brief format change. Drop-in compatible with v0.7.0.
+- The `BridgedCliStrategy` interface additions are optional fields; forker-defined custom registry entries that don't set them get the v0.7.0 JSON + overwrite behavior unchanged.
+
 ## 0.7.0
 
 MCP-server-mode for cli-bridge. v0.5.0's cli-bridge adapter let OpenWar coordinate a CLI agent (Claude Code, etc), but the bridged CLI could not call OpenWar's native tools because its tool registry was its own. v0.7 closes the gap: OpenWar exposes its native tools as an MCP server, the bridged CLI consumes them through standard MCP, and the runtime threads OpenWar's authorization gates across the bridge. Operators can now run a brief that asks the bridged Claude Code to call `write_project_memory` (or any of the eight native tools) and have it actually work.
 
@@ -144,7 +144,7 @@ System prompts cost nothing to install and work with any agent. The runtime is h
 
 ## Versioning
 
-Current: **v0.7.0**. See [CHANGELOG.md](./CHANGELOG.md) for full release notes.
+Current: **v0.7.1**. See [CHANGELOG.md](./CHANGELOG.md) for full release notes.
 
 - v0.1: framework doc only (single markdown file).
 - v0.2: runtime, CLI, BYOK adapters.
 
@@ -82,6 +82,22 @@ cli:
 
 Set `framework_prefix: false` (or pass `--cli-no-framework`) when the CLI already has OpenWar in its own system prompt. For Claude Code with `openwar.md` already in CLAUDE.md, the prepend is redundant and wasteful.
 
+### MCP-server-mode and the bridged-CLI registry (v0.7+)
+
+When a brief uses cli-bridge, OpenWar additionally exposes its eight native tools (`read_file`, `write_file`, `list_dir`, `shell_exec`, `http_fetch`, `apply_patch`, `read_project_memory`, `write_project_memory`) to the bridged CLI through standard MCP. The bridged agent can call any of them as `openwar:<tool_name>` and the runtime authorizes every call through the brief's `authorized_costs`.
+
+The runtime knows how to wire MCP forwarding for these bridged CLIs out of the box:
+
+| Binary basename | CLI | Config file | Wiring | Persists |
+|---|---|---|---|---|
+| `claude` | Claude Code | `<temp>/openwar-mcp-config-*.json` | `--mcp-config <path>` flag injection | cleaned up at session end |
+| `gemini` | Gemini CLI | `<workdir>/.gemini/settings.json` | auto-discovered | yes (no cleanup) |
+| `codex` | Codex CLI (v0.7.1+) | `~/.codex/config.toml` | auto-discovered, merged into existing TOML | yes (no cleanup) |
+
+Unknown binaries (aider, custom tools without native MCP support) hit a fallback: the OpenWar MCP config is still written to a temp JSON file, but no CLI args are injected. The runtime emits a startup warning so the operator can wire MCP manually for that CLI, or set `cli.mcp_forward: false` in the brief frontmatter to disable forwarding entirely and run the bridged CLI in its own tool sandbox.
+
+The Codex entry preserves operator hand-edits to other sections of `~/.codex/config.toml` (it reads the file, replaces or appends the `[mcp_servers.openwar]` block, leaves everything else untouched). Same model is expected to extend to other TOML-config CLIs in v0.7.2+.
+
 ### When to use cli-bridge vs an API adapter
 
 Use `cli-bridge` when:
 
@@ -1,6 +1,6 @@
 {
   "name": "@pythonluvr/openwar",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Runtime that enforces the OpenWar framework: phase-aware agent loop with confirmation, blocker, and destructive-action gates.",
   "license": "MIT",
   "type": "module",
 
@@ -24,6 +24,8 @@
 // --cli-binary claude, --cli-binary claude.cmd, and absolute paths.
 
 import { join } from "node:path";
+import { homedir } from "node:os";
+import { writeTomlConfig, type TomlConfig } from "./toml-writer.js";
 
 export interface ConfigPathContext {
   workdir: string;
@@ -57,6 +59,19 @@ export interface BridgedCliStrategy {
   // temp paths; false for known-location overrides where the operator may
   // want the config to persist for future runs.
   cleanupConfigFile?: boolean;
+  // v0.7.1: serialize the MCP config to the on-disk format the bridged CLI
+  // expects. Default (undefined) is JSON.stringify with two-space indent.
+  // Codex overrides to TOML because its config.toml is, well, TOML.
+  serializeConfig?(content: McpConfigFileContent): string;
+  // v0.7.1: when true, the runner reads the existing config file and merges
+  // the OpenWar MCP server section in (preserving other operator-authored
+  // sections) instead of overwriting. Used by Codex because operators may
+  // hand-edit other parts of ~/.codex/config.toml. Strategies that own a
+  // temp path or a dedicated subdir keep this false.
+  mergeIntoExisting?: boolean;
+  // v0.7.1: the merge step needs to know the section header to replace.
+  // Defaults to "mcp_servers.<serverName>" when omitted.
+  mergeSectionHeader?: string;
 }
 
 // Map of binary basename → strategy. Match is case-insensitive; .cmd / .bat /
@@ -81,8 +96,46 @@ const STRATEGIES = new Map<string, BridgedCliStrategy>([
     configPath: ({ workdir }) => join(workdir, ".gemini", "settings.json"),
     buildArgs: () => [],
   }],
+  // v0.7.1: Codex CLI. Reads MCP server config from ~/.codex/config.toml.
+  // TOML format requires the v0.7.1 hand-rolled serializer. The runner
+  // merges the [mcp_servers.openwar] section into any existing file rather
+  // than overwriting so operator hand-edits to other sections survive
+  // (Phase 0 pick (a) in the v0.7.1 brief). Codex auto-discovers; no CLI
+  // args needed. File persists across runs like Gemini.
+  ["codex", {
+    display_name: "Codex CLI",
+    mcp_supported: true,
+    writeConfigFile: true,
+    cleanupConfigFile: false,
+    configPath: () => join(homedir(), ".codex", "config.toml"),
+    buildArgs: () => [],
+    serializeConfig: (content) => writeTomlConfig(mcpConfigToToml(content)),
+    mergeIntoExisting: true,
+    mergeSectionHeader: "mcp_servers.openwar",
+  }],
 ]);
 
+// Convert the standard McpConfigFileContent (JSON-shaped, used by Claude
+// Code + Gemini) into the TomlConfig shape the writer accepts. v0.7.1 only
+// emits one section per call (the OpenWar entry under mcp_servers) because
+// that is the only section the strategy owns.
+function mcpConfigToToml(content: McpConfigFileContent): TomlConfig {
+  const sections: TomlConfig["sections"] = [];
+  for (const [serverName, server] of Object.entries(content.mcpServers)) {
+    const fields: TomlConfig["sections"][number]["fields"] = [
+      { key: "command", value: server.command },
+      { key: "args", value: server.args },
+    ];
+    if (server.env) {
+      for (const [k, v] of Object.entries(server.env)) {
+        fields.push({ key: `env.${k}`, value: v });
+      }
+    }
+    sections.push({ header: `mcp_servers.${serverName}`, fields });
+  }
+  return { sections };
+}
+
 // Fallback used when the binary is unknown. Writes the config file, does not
 // inject CLI args (we don't know how this CLI consumes config). Caller emits
 // a startup warning so the operator can wire the config manually.
 
@@ -19,6 +19,7 @@ import { fileURLToPath } from "node:url";
 import type { Brief, RunnerIO, ToolCallRecord } from "../types.js";
 import type { CliBridgeAdapter } from "../adapters/cli-bridge.js";
 import { resolveBridgedCliStrategy, buildMcpConfigFile } from "./bridged-cli-registry.js";
+import { upsertTomlSection } from "./toml-writer.js";
 
 export interface CliBridgeMcpSetup {
   enabled: boolean;
@@ -114,7 +115,27 @@ export async function setupCliBridgeMcpForwarding(
       serverArgs: [openwarBin, ...serverArgs],
     });
     await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, JSON.stringify(content, null, 2), "utf8");
+    // v0.7.1: per-strategy serializer (default JSON). Codex returns TOML.
+    const serialized = strategy.serializeConfig
+      ? strategy.serializeConfig(content)
+      : JSON.stringify(content, null, 2);
+    // v0.7.1: optional merge-into-existing. Codex sets this true so we
+    // don't clobber operator hand-edits to other sections of config.toml.
+    if (strategy.mergeIntoExisting && existsSync(configPath)) {
+      const existing = await readFile(configPath, "utf8");
+      const sectionHeader = strategy.mergeSectionHeader ?? "mcp_servers.openwar";
+      // The serialized output is one [section]\nkey=val\n... block. Strip
+      // the leading "[header]\n" so upsertTomlSection's body argument is
+      // just the field lines; the helper re-adds the header verbatim.
+      const headerLine = `[${sectionHeader}]\n`;
+      const body = serialized.startsWith(headerLine)
+        ? serialized.slice(headerLine.length).replace(/\n+$/, "")
+        : serialized.replace(/\n+$/, "");
+      const merged = upsertTomlSection(existing, sectionHeader, body);
+      await writeFile(configPath, merged, "utf8");
+    } else {
+      await writeFile(configPath, serialized, "utf8");
+    }
   }
 
   const cliArgs = strategy.buildArgs({
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@pythonluvr/openwar",`
`3`		`- "version": "0.7.0",`
	`3`	`+ "version": "0.7.1",`
`4`	`4`	`"description": "Runtime that enforces the OpenWar framework: phase-aware agent loop with confirmation, blocker, and destructive-action gates.",`
`5`	`5`	`"license": "MIT",`
`6`	`6`	`"type": "module",`