diff --git a/MAINTAINER.md b/MAINTAINER.md
index 7f3cc986..8a4347e0 100644
--- a/MAINTAINER.md
+++ b/MAINTAINER.md
@@ -25,7 +25,7 @@ release this kit. User-facing docs live in [README.md](README.md); this file is
 ### CLI shape (`bin/agentic-kit.mjs`)
 
 - **Porcelain** (daily): `setup`, `status`, `sync`, `dashboard`, `admin`, `dual`, `uninstall`. Bare `ak` → `status --hint`. (`dashboard` and `admin` are also reachable as `ak x dashboard` / `ak x admin`.)
-- **Plumbing** (power users): `ak x daemon-gc | mcp | reference | verify | improvement-eval`.
+- **Plumbing** (power users): `ak x daemon-gc | mcp | reference | statusline | verify | improvement-eval`.
 - Each command module exports `options` (a `parseArgs` config) and `run({ flags, positionals, pkgRoot })`.
 - A best-effort drift nudge runs after non-`sync`, non-`--json` commands.
 
@@ -39,7 +39,7 @@ src/
   commands/              # porcelain verbs
     setup.mjs  status.mjs  sync.mjs  dual.mjs  uninstall.mjs
     x/                   # plumbing verbs
-      admin.mjs  daemon-gc.mjs  dashboard.mjs  harvest.mjs  mcp.mjs  provider.mjs  reference.mjs  verify.mjs
+      admin.mjs  daemon-gc.mjs  dashboard.mjs  harvest.mjs  mcp.mjs  provider.mjs  reference.mjs  statusline.mjs  verify.mjs
   lib/                   # the engine — each file is one concern
     heal.mjs             # the mutations sync/setup apply (idempotent, {ok,detail})
     natives.mjs          # better-sqlite3 / agentdb native detection
@@ -48,6 +48,7 @@ src/
     ruvnet-brain.mjs     # RuvNet Brain: on-disk detection + GitHub-release drift (NOT an npm pkg)
     blocks.mjs           # managed-block registry + syncBlocks + guidanceTargets (3 targets: ~/.claude/CLAUDE.md, project AGENTS.md, ~/.codex/AGENTS.md)
     hosts.mjs            # host-adapter core: drivingHost() + HOST_ADAPTERS (guidance file, auth, statusline)
+    codex-statusline.mjs # owned presets + narrow ~/.codex/config.toml projection
     providers.mjs        # frontier-host + LLM-provider detect/wire (hosts, auth, MCP bridges, aqe router)
     routing.mjs          # pure dual-host routing policy: defaults, projections, primary-host swap
     qeCourt.mjs          # qe-court vendor-diversity panel helpers
@@ -92,6 +93,17 @@ wiring, both MCP-bridge directions, aqe router file). Seeded/healed by `setup` +
 `sync` + `x provider pick`, surfaced by `status` + `dashboard`. Design records:
 ADRs [0001–0006](docs/adr/); user guide: `docs/PROVIDERS.md`.
 
+**Status-line capability is host-specific.** Claude owns a project-scoped,
+command-backed renderer; Codex offers a user-scoped, built-in field list.
+`ak x statusline codex native|extended` explicitly opts the user into management
+of only `tui.status_line` and `tui.status_line_use_colors`; `sync` must not touch
+those keys without that ownership record. The textual TOML merge is
+backup-first and must preserve unknown keys, comments, ordering, and newline
+style. `off` and uninstall remove each key only if its managed value is
+unchanged. See
+[the Codex status-line guide](docs/CODEX-STATUSLINE.md) and
+[ADR-0015](docs/adr/0015-managed-codex-native-statusline.md).
+
 > The consistency contract all managed tools share — install/update/version/display
 > invariants, the per-tool table, and the add-a-tool checklist — lives in
 > [docs/MANAGED-TOOLS.md](docs/MANAGED-TOOLS.md). The notes below are the
diff --git a/README.md b/README.md
index ed695659..1ead5496 100644
--- a/README.md
+++ b/README.md
@@ -52,6 +52,7 @@ ak sync         converge to good: upgrade + heal + verify          [--dry-run] [
 ak dashboard    open the local web dashboard (auto-opens your browser)
                 [--port N] [--no-open] [--live-source 'surface=path']
 ak dual         run a Claude+Codex collaboration swarm (dual-host)   run <template> "<task>"  [--dry-run] [--escalate] [--route ...]
+ak x statusline manage Codex's native user-wide status line          status | codex native|extended|off
 ak uninstall    leave cleanly                [--dry-run] [--this-project] [--remove-ruflo] [--remove-aqe] [--purge] [--yes]
 ```
 
@@ -77,6 +78,7 @@ What the verbs cover:
 
 Power-user mechanisms live under `ak x …` (`daemon-gc`, `harvest`,
 `mcp pick|off`, `provider status|pick|off`, `reference diff|sync`,
+`statusline status|codex native|extended|off`,
 `verify learning|security|aqe|providers|harvest`, `improvement-eval`) — see `ak --help --all`.
 
 One of those is worth calling out:
@@ -94,6 +96,14 @@ each segment shown **only when genuinely active**: 🧠 SONA patterns/trajectori
 live micro-LoRA Δ‖W‖), 📈 route-RL metrics, 🛡 aidefence, 🧿 RuvNet Brain KB,
 ⚙ machine-wide daemon count, and 🎓 Agentic-QE stats.
 
+That rich, command-backed footer is a Claude Code surface. Codex supports a
+single native line made from built-in fields instead. Opt into a compact
+machine-wide preset with `ak x statusline codex native` (or use `extended` on
+a wide terminal); `ak sync` then keeps the selected preset converged without
+rewriting unrelated `~/.codex/config.toml` settings. See
+[Managed Codex status line](docs/CODEX-STATUSLINE.md) for fields, ownership,
+rollback, and the current parity boundary.
+
 ## Requirements
 
 Node ≥ 22, npm, and the `claude` CLI (Claude Code). That's the whole list —
diff --git a/bin/agentic-kit.mjs b/bin/agentic-kit.mjs
index 15289d08..c7584931 100755
--- a/bin/agentic-kit.mjs
+++ b/bin/agentic-kit.mjs
@@ -33,6 +33,7 @@ const PLUMBING = Object.assign(Object.create(null), {
   'mcp': () => import('../src/commands/x/mcp.mjs'),
   'provider': () => import('../src/commands/x/provider.mjs'),
   'reference': () => import('../src/commands/x/reference.mjs'),
+  'statusline': () => import('../src/commands/x/statusline.mjs'),
   'verify': () => import('../src/commands/x/verify.mjs'),
 });
 
@@ -68,6 +69,7 @@ Plumbing (power users) — each takes --help:
   ak x mcp [status|pick|off]   MCP registration + tool-family deny rules
   ak x provider [status|pick|off]   detect claude/codex CLIs; wire ruflo + aqe hosts/providers
   ak x reference [diff|sync]   CLAUDE.md managed-block inspection/reconcile
+  ak x statusline [status|codex native|codex extended|codex off]   manage Codex's native user status line
   ak x verify [learning|security|aqe|providers|harvest|all]   deep proofs (slow, spawns real CLIs)
   ak x improvement-eval [...]  causal self-improvement eval (route Q-learner)`;
 
diff --git a/docs/CODEX-STATUSLINE.md b/docs/CODEX-STATUSLINE.md
new file mode 100644
index 00000000..8938f725
--- /dev/null
+++ b/docs/CODEX-STATUSLINE.md
@@ -0,0 +1,106 @@
+# Managed Codex status line
+
+Codex has a native, user-wide status line. Agentic-kit can manage a useful
+preset for every newly started Codex session while preserving the rest of
+`~/.codex/config.toml`.
+
+This is intentionally different from the rich Claude Code footer. Codex's
+native line is single-line and accepts only Codex's built-in fields. Ruflo,
+SONA, route-RL, daemon, RuvNet Brain, and Agentic QE segments cannot appear
+inside it until Codex provides a command or plugin-backed extension point.
+
+## Choose a preset
+
+```bash
+# Inspect agentic-kit's ownership and the current Codex configuration.
+ak x statusline status
+
+# Recommended: compact enough for an ordinary terminal.
+ak x statusline codex native
+
+# Add operational fields for a wide terminal.
+ak x statusline codex extended
+
+# Stop managing the Codex status line.
+ak x statusline codex off
+```
+
+`native` selects:
+
+```text
+model-with-reasoning, project-name, git-branch, run-state,
+context-remaining, five-hour-limit, weekly-limit, task-progress
+```
+
+`extended` adds:
+
+```text
+permissions, approval-mode, used-tokens, fast-mode, thread-id, codex-version
+```
+
+The setting is machine/user scoped rather than repository scoped. Start a new
+Codex session after changing it; an already-running TUI may not reload the
+configuration.
+
+## Ownership and sync
+
+Selecting `native` or `extended` records explicit ownership in agentic-kit's
+machine configuration. From then on, `ak status` reports drift and `ak sync`
+reconciles the selected preset.
+
+Agentic-kit narrowly updates only these keys under `[tui]`:
+
+```toml
+[tui]
+status_line_use_colors = true
+status_line = [
+  "model-with-reasoning",
+  "project-name",
+  "git-branch",
+  "run-state",
+  "context-remaining",
+  "five-hour-limit",
+  "weekly-limit",
+  "task-progress",
+]
+```
+
+Other tables, keys, comments, ordering, and newline style in
+`~/.codex/config.toml` are preserved. A backup is made before a managed write.
+If no preset is owned, `ak status` may describe a native configuration but
+`ak sync` leaves it alone.
+
+The narrow writer fails closed on TOML-equivalent quoted table/key syntax or
+dotted `tui.status_line` keys instead of risking a duplicate semantic key.
+Normalize those forms to the conventional `[tui]` table before opting in.
+
+`off` relinquishes ownership. Each managed key is removed only when its value
+still matches the last managed projection; an edited key is preserved as user
+state. Uninstall follows the same rule.
+
+## What each host can display
+
+| Capability | Claude Code | Codex |
+|---|---:|---:|
+| Configuration scope | Project | User/machine |
+| Native single-line fields | Host-dependent | Yes |
+| Command-backed renderer | Yes | No |
+| Multiple rich telemetry lines | Yes | No |
+| Managed by `ak sync` | Yes | After explicit preset selection |
+
+For Claude Code, agentic-kit continues to inject its rich renderer into the
+project's ruflo status-line helper. The Codex preset complements that renderer;
+it does not attempt to claim visual or telemetry parity.
+
+## Troubleshooting
+
+- **The line did not change:** exit and start a new Codex session.
+- **The right side is missing:** use `native`, or widen the terminal. Codex
+  renders one width-constrained line.
+- **`ak status` reports drift:** run `ak sync` to restore the owned preset, or
+  run `ak x statusline codex off` before maintaining the keys yourself.
+- **You need the rich subsystem display:** use Claude Code's project footer for
+  now. Hooks and notifications are event messages, not a persistent Codex UI.
+
+The design and safety constraints are recorded in
+[ADR-0015](adr/0015-managed-codex-native-statusline.md).
diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.md
index 64f71c82..c43de72f 100644
--- a/docs/TROUBLESHOOTING.md
+++ b/docs/TROUBLESHOOTING.md
@@ -22,6 +22,9 @@ ak sync             # apply it
 | `status` shows `aidefence missing` | ruflo ≥3.28 stopped shipping `@claude-flow/aidefence` but `ruflo security defend` still imports it — injection defense is silently non-functional ([ruvnet/ruflo#2670](https://github.com/ruvnet/ruflo/issues/2670)) | `ak sync` reinstalls it; `ak x verify security` proves defend works (exit 1=threat / 0=clean) |
 | `status` shows oversized RVF store(s) | A runaway append after a hard exit grew a `.rvf` past the 2 GB cap (seen at ~277 GB once) | `ak sync` quarantines the oversized store; agentic-qe rebuilds it |
 | Statusline footer (🧠/🛡/🎓 lines) disappeared | `@claude-flow/cli`'s version-stamped helper auto-refresh pristine-copies `statusline.cjs` on the **first ruflo command after an upgrade** — including the statusline render itself | `ak sync` — it now triggers that refresh *first*, then re-injects, so the footer survives; `ak status` flags an armed wipe before it fires |
+| Codex's native status line did not change | Codex reads the user-wide setting when a session starts; an existing TUI may not hot-reload it | Exit and start a new Codex session; inspect ownership with `ak x statusline status` and drift with `ak status` |
+| The right side of Codex's status line is missing | Codex has one width-constrained native line | Widen the terminal or choose the compact preset with `ak x statusline codex native` |
+| Want the rich Ruflo/SONA/AQE display inside Codex | Codex currently accepts built-in status-line fields only, not a command-backed renderer | Keep the rich footer in Claude Code; see [Managed Codex status line](CODEX-STATUSLINE.md) for the current boundary |
 | Too many `⚙` daemons / stale daemons | One daemon per active project is normal (local-only workers, $0). Stale = workspace deleted or past the 12h TTL | `ak x daemon-gc --kill`; `sync` also reaps (and verifies the pid really is a ruflo daemon before killing) |
 | Want to change which MCP tool families are callable | Exclusions are `permissions.deny` rules, persisted in kit.json | `ak x mcp pick` (re-runnable); `x mcp status` shows the inventory; `x mcp off` unregisters |
 | `ruflo memory store` says OK but reads return nothing | Absolute-DB-path pin missing, or WAL not checkpointed, or the WASM fallback above | `ak setup` in the project re-pins + verifies a real write lands on disk |
diff --git a/docs/UPGRADING.md b/docs/UPGRADING.md
index f981e43f..ddce915a 100644
--- a/docs/UPGRADING.md
+++ b/docs/UPGRADING.md
@@ -23,12 +23,19 @@ family on your behalf.
 | -------------------- | ----------------------------------------------- | -------------------------------- |
 | `ak sync`            | update the binary + heal to your recorded state | **no** — converges, never decides |
 | `ak x provider pick` | opt into / retune hosts & LLM providers         | **yes** — this is the switch     |
+| `ak x statusline codex native\|extended` | opt into a user-wide Codex status-line preset | **yes** — records the preset |
 | `ak setup`           | first-time bootstrap of absent tooling          | only via explicit flags (`--codex`, `--primary-host`) |
 
 If you already have `ak` working, you almost never need `ak setup` again — it's the
 installer. Enabling a shipped-but-opt-in feature is a `provider pick` (or an `x mcp pick`,
 etc.), not a re-`setup`.
 
+Codex status-line management is deliberately not enabled merely because an
+upgrade adds support for it. Run `ak x statusline codex native` once to opt in;
+later `ak sync` runs converge that recorded choice. Use
+`ak x statusline codex off` to relinquish ownership. See
+[Managed Codex status line](CODEX-STATUSLINE.md).
+
 ## Worked example: adopting ambidextrous dual-host
 
 You have an older `ak` and both the `claude` and `codex` CLIs installed, and you want the
diff --git a/docs/adr/0015-managed-codex-native-statusline.md b/docs/adr/0015-managed-codex-native-statusline.md
new file mode 100644
index 00000000..ec311ba2
--- /dev/null
+++ b/docs/adr/0015-managed-codex-native-statusline.md
@@ -0,0 +1,139 @@
+# ADR-0015 — Manage Codex's native user-wide status line without claiming rich-renderer parity
+
+- **Status:** Accepted
+- **Date:** 2026-07-28
+- **Deciders:** agentic-kit maintainers
+- **Related:** [ADR-0001](0001-one-routing-policy-many-projections.md),
+  [ADR-0006](0006-primary-host-and-ambidextrous-mirroring.md),
+  [ADR-0008](0008-guidance-target-scope-split.md),
+  [ADR-0010](0010-provider-mediated-quota-reads.md)
+
+## Context
+
+Agentic-kit gives Claude Code a rich, project-scoped status display by repairing ruflo's
+`.claude/helpers/statusline.cjs`, injecting `src/templates/statusline-footer.cjs`, and pointing
+Claude Code's command-backed `statusLine` setting at that renderer. The footer can read local
+ruflo, SONA, reinforcement-learning, daemon, RuvNet Brain, and agentic-qe state and render several
+ANSI-styled lines.
+
+Codex CLI has a different extension boundary. Codex 0.145.0 exposes `/statusline` and the
+user-scoped `tui.status_line` array in `~/.codex/config.toml`. The array selects from native item
+identifiers such as model, project, Git branch, run state, context remaining, five-hour and weekly
+limits, token totals, and task progress. It is a single native line. Codex does not accept a
+command-backed item, arbitrary text, custom ANSI output, or multiple renderer-owned lines.
+OpenAI tracks command/plugin-backed status-line support as an upstream feature request.
+
+The repository currently reduces this distinction to `statuslineSupported: false` for Codex and
+reports that the statusline is Claude-only. That is accurate for the rich command-backed renderer
+but no longer accurate for Codex's native declarative status line. It also leaves every Codex user
+to configure the same useful baseline by hand.
+
+`~/.codex/config.toml` is shared user state. It contains project trust, MCP registrations, user
+preferences, and possibly fields introduced by newer Codex releases. Agentic-kit must not parse and
+rewrite the whole document with an incomplete TOML model or silently seize a list the user already
+curated.
+
+## Decision
+
+### 1. Model status-line capability, not a boolean
+
+Host adapters distinguish three properties:
+
+- whether the host has a status line;
+- whether it accepts a command-backed custom renderer;
+- whether its configuration is project- or user-scoped.
+
+Claude remains `command` plus project scope. Codex becomes `builtin` plus user scope. User-facing
+status output says that Codex supports a managed native line while rich ruflo/SONA/AQE segments
+remain unavailable inside the Codex TUI.
+
+### 2. Add explicit managed Codex presets
+
+Agentic-kit provides an `ak x statusline` command with:
+
+```text
+ak x statusline status
+ak x statusline codex native
+ak x statusline codex extended
+ak x statusline codex off
+```
+
+`native` is the recommended compact preset:
+
+```text
+model-with-reasoning, project-name, git-branch, run-state,
+context-remaining, five-hour-limit, weekly-limit, task-progress
+```
+
+`extended` adds operational fields that are useful on wide terminals:
+
+```text
+permissions, approval-mode, used-tokens, fast-mode, thread-id, codex-version
+```
+
+The command is user/machine scoped because Codex reads `~/.codex/config.toml` for all sessions.
+Changes apply to newly started Codex sessions; a running TUI need not hot-reload them.
+
+### 3. Ownership is explicit and reversible
+
+Selecting `native` or `extended` records the chosen preset in `kit.json`. Only then may `ak sync`
+reconcile `tui.status_line` and `tui.status_line_use_colors`. `off` removes agentic-kit's ownership
+and removes only the two managed keys when their values still equal the last managed projection.
+It does not delete the `[tui]` table or unrelated user settings.
+
+If Codex or the user changes the managed values, `ak status` reports drift and `ak sync` restores the
+selected preset. If no preset is owned, status may describe the detected native configuration but
+must not propose a mutating fix.
+
+Uninstall follows the same ownership rule and never removes an unowned status line.
+
+### 4. Patch only the owned TOML keys
+
+The writer performs a narrow, backup-first, atomic textual merge of the two keys inside `[tui]`.
+It preserves comments, ordering, newline style, every other table, and every unknown key. It must
+recognize multiline arrays because `/statusline` may write one. It validates the resulting file
+before replacement using Codex's own configuration loader when a safe non-interactive validation
+path is available; otherwise structural tests and a rollback-on-write-failure boundary are
+mandatory.
+
+Agentic-kit remains zero-runtime-dependency. Adding a general TOML dependency solely for these two
+keys is rejected.
+
+### 5. Keep rich telemetry host-neutral, but outside this change
+
+The existing ruflo/SONA/RL/daemon/Brain/AQE footer remains Claude-backed. A later change may extract
+its filesystem probes into:
+
+```text
+ak statusline render --host codex --format ansi|json
+```
+
+for tmux, Zellij, shell prompts, an adjacent pane, or a future Codex command-backed item. This ADR
+does not add a terminal wrapper, patch the Codex binary, claim hooks are persistent UI, or maintain
+a private Codex fork.
+
+## Consequences
+
+- Codex users get a consistent, colored, machine-wide native status line through the same
+  status/sync drift model as the rest of agentic-kit.
+- The UI immediately exposes model, repository, execution state, context headroom, plan headroom,
+  and task progress without an external process.
+- Ruflo, SONA, RL, daemon, Brain, and agentic-qe telemetry cannot appear in Codex's native line until
+  Codex adds an extension point. Documentation states that boundary directly.
+- The implementation needs focused tests for absent `[tui]`, existing `[tui]`, multiline arrays,
+  CRLF, comments, duplicate/invalid structures, ownership, drift, sync, off, and uninstall.
+- Preset identifiers are version-sensitive. The compact preset uses fields verified in Codex
+  0.145.0; future incompatible Codex changes surface as drift/validation failures rather than
+  destructive fallback rewrites.
+
+## Rejected alternatives
+
+- **Reuse Claude's `statusline.cjs` directly.** Codex has no command-backed status-line item.
+- **Configure every available native item.** Codex renders one width-constrained line; later fields
+  become invisible on ordinary terminals.
+- **Always overwrite `~/.codex/config.toml` during setup or sync.** That would convert a convenience
+  into ownership of unrelated user state.
+- **Use hooks or `notify` as the renderer.** They produce event notifications, not a persistent
+  status surface.
+- **Rewrite the entire TOML document.** It risks losing comments and newer Codex fields and violates
+  the repository's merge-not-clobber rule.
diff --git a/docs/adr/README.md b/docs/adr/README.md
index eb64d230..6d870d6e 100644
--- a/docs/adr/README.md
+++ b/docs/adr/README.md
@@ -23,6 +23,7 @@ Consequences**, and cites the grounded source it rests on where relevant.
 | [0012](0012-live-sessions-observability.md) | Live sessions as local, evidence-graded observability | Accepted |
 | [0013](0013-admin-build-security-signals-and-honest-reach.md) | Admin: build/security signals, an honest Reach panel, and a pagination fix | Accepted |
 | [0014](0014-dashboard-auth-and-remediation.md) | Dashboard auth token, plus a security/quality remediation pass | Accepted |
+| [0015](0015-managed-codex-native-statusline.md) | Manage Codex's native user-wide status line without claiming rich-renderer parity | Accepted |
 
 Theme: ADRs **0001–0006** define **dual-host LLM routing and leadership** — how `ak` lets ruflo route
 each development activity (architecture, implementation, testing, review, …) to the right host (Claude
@@ -63,3 +64,8 @@ fixes from the same audit — an SSE client-cap race, `shell:true` on Windows, n
 writes, a build-gate that could pass having checked nothing, secret-masker gaps, an O(n) session
 lookup, a stale-cache bug, prototype-pollution-shaped CLI dispatch, enforced coverage floors, and
 new test coverage for the previously-untested machine-mutating commands.
+
+**0015** recognizes Codex's native status line without pretending it can host
+Claude's command-backed telemetry renderer. It adds opt-in, user-scoped presets,
+narrowly projects only the owned `[tui]` keys into `~/.codex/config.toml`, and
+keeps unowned or user-modified configuration outside `sync` and uninstall.
diff --git a/package.json b/package.json
index 50e5f6d6..bfd04a38 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,9 @@
     "bin/agentic-kit.mjs",
     "src/",
     "claude/",
-    "docs/TROUBLESHOOTING.md"
+    "docs/TROUBLESHOOTING.md",
+    "docs/CODEX-STATUSLINE.md",
+    "docs/adr/0015-managed-codex-native-statusline.md"
   ],
   "scripts": {
     "test": "node --test --experimental-test-coverage --test-coverage-lines=70 --test-coverage-branches=70 --test-coverage-functions=70 \"tests/kit/*.test.mjs\" && node tests/statusline-segments.test.cjs && node tests/statusline-brain.test.cjs && node tests/agentdb.test.cjs && node tests/health-history.test.cjs && node tests/harvest.test.cjs && node tests/dashboard.test.cjs && node tests/admin-model.test.cjs && node tests/admin.test.cjs",
diff --git a/src/commands/status.mjs b/src/commands/status.mjs
index 7abb17ab..3836134b 100644
--- a/src/commands/status.mjs
+++ b/src/commands/status.mjs
@@ -23,6 +23,7 @@ import { HOSTS, settingsTarget, isDefault, managedEnv, MANAGED_ENV_KEYS, hostIns
 import { policyToAgentOverrides, routingSummary, divergedRoutes } from '../lib/routing.mjs';
 import { qeCourtShipped, readQeCourtConfig, panelFromRouting, validatePanel, healJuryVendorCollision, UPSTREAM_JURY_VENDOR_ISSUE } from '../lib/qeCourt.mjs';
 import { drift as ruvectorDrift } from '../lib/ruvector.mjs';
+import { statuslineDrift } from '../lib/codex-statusline.mjs';
 
 export const options = {
   json: { type: 'boolean', default: false },
@@ -529,13 +530,20 @@ export async function collect({ pkgRoot, cwd = process.cwd() }) {
   } else {
     rows.push(row('statusline', 'info', 'no project statusline here (created by setup)'));
   }
-  // show + explain: the statusline is a Claude Code feature. Codex has no
-  // command-backed statusline (enum-only `tui.status_line`), so when codex is
-  // enabled we surface the asymmetry with its native compensating path rather
-  // than hiding it — the ambidextrous UX convention.
-  if (cfg.providers?.hosts?.codex) {
-    rows.push(row('statusline', 'info',
-      'statusline is claude-only — codex has no command-backed statusline; its guidance ships via AGENTS.md'));
+  // Codex has a native user-scoped line, but no command-backed rich renderer.
+  if (cfg.providers?.hosts?.codex || cfg.statusline?.codex) {
+    const codexLine = statuslineDrift(cfg);
+    if (!codexLine.owned) {
+      rows.push(row('codex-statusline', 'info',
+        'Codex native status line is unmanaged — opt in with `ak x statusline codex native`'));
+    } else if (codexLine.drifted) {
+      rows.push(row('codex-statusline', 'warn',
+        `managed Codex ${codexLine.preset} status line has drifted`,
+        'sync restores the selected native preset'));
+    } else {
+      rows.push(row('codex-statusline', 'ok',
+        `managed Codex ${codexLine.preset} native status line is current (rich ruflo/SONA/AQE segments remain Claude-only)`));
+    }
   }
 
   // qe-court (ADR-124): TEMPORARY, remove once fixed upstream. agentic-qe's own
diff --git a/src/commands/sync.mjs b/src/commands/sync.mjs
index ff9d82cc..80f3fc20 100644
--- a/src/commands/sync.mjs
+++ b/src/commands/sync.mjs
@@ -18,6 +18,7 @@ import { readJson } from '../lib/settings.mjs';
 import { appendToConfig } from '../lib/health-history.mjs';
 import * as paths from '../lib/paths.mjs';
 import { ok, warn, fail, info, bold, dim, withProgress } from '../lib/output.mjs';
+import { applyCodexStatusline, projectionFor } from '../lib/codex-statusline.mjs';
 
 export const options = {
   'dry-run': { type: 'boolean', default: false },
@@ -64,6 +65,14 @@ export async function run({ flags, pkgRoot }) {
   // visibly alive instead of freezing the prompt; fast/local steps clear in <1s.
   const step = async (name, thunk) => { const r = await withProgress(name, thunk); report(name, r); return r; };
 
+  if (subsystems.has('codex-statusline') && cfg.statusline?.codex?.preset) {
+    const preset = cfg.statusline.codex.preset;
+    const r = applyCodexStatusline(preset);
+    cfg.statusline.codex.lastProjection = projectionFor(preset);
+    saveKitConfig(cfg);
+    ok(`codex statusline: ${r.changed ? `restored ${preset} preset` : 'in sync'}`);
+  }
+
   if (subsystems.has('versions') && !flags['no-upgrade']) {
     report('daemons', await heal.stopAllDaemons());
     for (const d of await driftReport({ force: true })) {
diff --git a/src/commands/uninstall.mjs b/src/commands/uninstall.mjs
index 59d20ba6..2f757478 100644
--- a/src/commands/uninstall.mjs
+++ b/src/commands/uninstall.mjs
@@ -9,10 +9,11 @@ import readline from 'node:readline/promises';
 import { run as runCmd } from '../lib/exec.mjs';
 import { stripBlock, BEGIN, BUILTIN_BLOCKS } from '../lib/blocks.mjs';
 import { unregister } from '../lib/mcp.mjs';
-import { loadKitConfig } from '../lib/config.mjs';
+import { loadKitConfig, saveKitConfig } from '../lib/config.mjs';
 import { present as rbPresent } from '../lib/ruvnet-brain.mjs';
 import * as paths from '../lib/paths.mjs';
 import { ok, warn, info } from '../lib/output.mjs';
+import { removeCodexStatusline } from '../lib/codex-statusline.mjs';
 
 export const options = {
   'dry-run': { type: 'boolean', default: false },
@@ -58,6 +59,26 @@ export async function run({ flags }) {
   const dry = flags['dry-run'];
   const act = (msg, fn) => { if (dry) info(`[dry-run] ${msg}`); else { fn(); ok(msg); } };
 
+  const kitCfg = loadKitConfig();
+
+  // 0. User-scoped Codex line: only values recorded as ours are candidates.
+  if (kitCfg.statusline?.codex) {
+    if (dry) info('[dry-run] release managed Codex status line (preserving user-modified keys)');
+    else {
+      let r;
+      try { r = removeCodexStatusline(kitCfg.statusline.codex.lastProjection); }
+      catch (error) {
+        warn(`Codex config was not changed; status-line ownership retained: ${error.message}`);
+        r = null;
+      }
+      if (r) {
+        kitCfg.statusline.codex = null;
+        if (!flags.purge) saveKitConfig(kitCfg);
+        ok(`Codex status-line ownership released${r.changed ? ' (unchanged managed keys removed)' : ' (user-modified keys preserved)'}`);
+      }
+    }
+  }
+
   // 1. CLAUDE.md managed blocks: every built-in slug (registry-driven, so
   // non-ruflo blocks like ruvnet-brain-reference are covered), the legacy
   // ruflo-* pattern as a catch-all, plus any custom slugs from kit.json.
@@ -66,7 +87,7 @@ export async function run({ flags }) {
     let content = fs.readFileSync(md, 'utf8');
     const slugs = new Set([...content.matchAll(/<!-- BEGIN (ruflo-[\w-]+) -->/g)].map((m) => m[1]));
     for (const b of BUILTIN_BLOCKS) if (content.includes(BEGIN(b.slug))) slugs.add(b.slug);
-    for (const b of loadKitConfig().customBlocks) if (content.includes(BEGIN(b.slug))) slugs.add(b.slug);
+    for (const b of kitCfg.customBlocks) if (content.includes(BEGIN(b.slug))) slugs.add(b.slug);
     if (slugs.size) {
       act(`stripped ${slugs.size} managed block(s) from ~/.claude/CLAUDE.md (backup written)`, () => {
         fs.copyFileSync(md, `${md}.bak.${Date.now()}`);
diff --git a/src/commands/x/statusline.mjs b/src/commands/x/statusline.mjs
new file mode 100644
index 00000000..13465758
--- /dev/null
+++ b/src/commands/x/statusline.mjs
@@ -0,0 +1,81 @@
+import { loadKitConfig, saveKitConfig } from '../../lib/config.mjs';
+import {
+  PRESETS, applyCodexStatusline, inspectCodexStatusline, projectionFor, removeCodexStatusline,
+  statuslineDrift,
+} from '../../lib/codex-statusline.mjs';
+import { ok, info, warn } from '../../lib/output.mjs';
+
+export const options = {
+  'dry-run': { type: 'boolean', default: false },
+  json: { type: 'boolean', default: false },
+};
+
+export const help = `ak x statusline — manage native host status lines
+
+Codex's native status line is user-scoped and applies to newly started
+sessions. It cannot display command-backed ruflo/SONA/AQE segments.
+
+Usage:
+  ak x statusline status
+  ak x statusline codex native
+  ak x statusline codex extended
+  ak x statusline codex off
+
+Options:
+  --dry-run   describe the change without writing config.toml or kit.json
+  --json      emit status as JSON
+
+Examples:
+  ak x statusline codex native
+  ak x statusline status
+  ak x statusline codex off --dry-run`;
+
+export async function run({ flags, positionals }) {
+  const cfg = loadKitConfig();
+  const [target = 'status', choice] = positionals;
+  if (target === 'status') {
+    const current = inspectCodexStatusline();
+    const drift = statuslineDrift(cfg);
+    const result = { ownership: cfg.statusline?.codex ?? null, current, drifted: drift.drifted };
+    if (flags.json) console.log(JSON.stringify(result, null, 2));
+    else if (cfg.statusline?.codex) {
+      info(`codex: managed ${cfg.statusline.codex.preset} preset (${!current.valid ? current.error : drift.drifted ? 'drifted' : 'current'})`);
+    } else {
+      info(`codex: unmanaged${current.values?.status_line ? ' native status line detected' : ''}`);
+    }
+    return 0;
+  }
+  if (target !== 'codex' || !choice) {
+    warn('usage: ak x statusline status | codex native | codex extended | codex off');
+    return 2;
+  }
+  if (choice === 'off') {
+    if (!cfg.statusline?.codex) { info('codex status line is not managed by agentic-kit'); return 0; }
+    if (flags['dry-run']) { info('[dry-run] release Codex status-line ownership and remove unchanged managed keys'); return 0; }
+    let result;
+    try { result = removeCodexStatusline(cfg.statusline.codex.lastProjection); }
+    catch (error) {
+      warn(`Codex config was not changed; ownership retained: ${error.message}`);
+      return 1;
+    }
+    cfg.statusline.codex = null;
+    saveKitConfig(cfg);
+    ok(`codex status-line management disabled${result.changed ? '; unchanged managed keys removed' : '; user-modified keys preserved'}`);
+    return 0;
+  }
+  if (!PRESETS[choice]) { warn(`unknown preset '${choice}' (expected native, extended, or off)`); return 2; }
+  if (flags['dry-run']) { info(`[dry-run] apply Codex ${choice} preset at user scope`); return 0; }
+  // Persist ownership first. If the TOML merge then fails, sync retains enough
+  // intent to report/retry it; the inverse ordering could mutate config.toml
+  // and then lose ownership when saving kit.json fails.
+  cfg.statusline.codex = { preset: choice, lastProjection: projectionFor(choice) };
+  saveKitConfig(cfg);
+  let result;
+  try { result = applyCodexStatusline(choice); }
+  catch (error) {
+    warn(`Codex status-line ownership recorded, but config was not changed: ${error.message}`);
+    return 1;
+  }
+  ok(`codex ${choice} status line ${result.changed ? 'applied' : 'already current'} — restart Codex sessions to see it`);
+  return 0;
+}
diff --git a/src/lib/codex-statusline.mjs b/src/lib/codex-statusline.mjs
new file mode 100644
index 00000000..833ce8b3
--- /dev/null
+++ b/src/lib/codex-statusline.mjs
@@ -0,0 +1,222 @@
+// Managed projection of Codex's built-in, user-scoped status line (ADR-0015).
+// This deliberately is not a TOML serializer: only the two owned [tui] keys
+// are patched, preserving comments, ordering, unknown fields, and newlines.
+import fs from 'node:fs';
+import path from 'node:path';
+import * as paths from './paths.mjs';
+
+export const PRESETS = Object.freeze({
+  native: Object.freeze([
+    'model-with-reasoning', 'project-name', 'git-branch', 'run-state',
+    'context-remaining', 'five-hour-limit', 'weekly-limit', 'task-progress',
+  ]),
+  extended: Object.freeze([
+    'model-with-reasoning', 'project-name', 'git-branch', 'run-state',
+    'context-remaining', 'five-hour-limit', 'weekly-limit', 'task-progress',
+    'permissions', 'approval-mode', 'used-tokens', 'fast-mode', 'thread-id', 'codex-version',
+  ]),
+});
+
+export const projectionFor = (preset) => ({
+  status_line_use_colors: true,
+  status_line: [...(PRESETS[preset] ?? [])],
+});
+
+const arrayText = (items, nl) =>
+  `[${nl}${items.map((v) => `  ${JSON.stringify(v)},`).join(nl)}${nl}]`;
+
+function findTable(src) {
+  const headers = [...src.matchAll(/^[ \t]*\[([^\]\r\n]+)\][ \t]*(?:#.*)?(?=\r?$)/gm)];
+  // TOML quoted table names are semantically equivalent to [tui], but this
+  // narrow patcher intentionally does not normalize TOML. Fail closed rather
+  // than append a second, equivalent table.
+  if (headers.some((m) => /^["']tui["']$/.test(m[1].trim()))) {
+    throw new Error('quoted [tui] table is not safely patchable');
+  }
+  const tui = headers.filter((m) => m[1].trim() === 'tui');
+  if (tui.length > 1) throw new Error('duplicate [tui] tables');
+  if (!tui.length) return null;
+  const start = tui[0].index;
+  const bodyStart = start + tui[0][0].length;
+  const next = headers.find((m) => m.index > start);
+  return { start, bodyStart, end: next?.index ?? src.length };
+}
+
+function valueEnd(src, start, limit) {
+  let square = 0;
+  let quote = null;
+  let escape = false;
+  for (let i = start; i < limit; i++) {
+    const c = src[i];
+    if (quote) {
+      if (escape) escape = false;
+      else if (c === '\\' && quote === '"') escape = true;
+      else if (c === quote) quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'") { quote = c; continue; }
+    if (c === '#') {
+      while (i < limit && src[i] !== '\n') i++;
+      if (square === 0) return i;
+      continue;
+    }
+    if (c === '[') square++;
+    else if (c === ']') square--;
+    if (square < 0) throw new Error('invalid status_line array');
+    if ((c === '\n' || c === '\r') && square === 0) return i;
+  }
+  if (square !== 0 || quote) throw new Error('unterminated value in [tui]');
+  return limit;
+}
+
+function keySpans(src, table) {
+  if (!table) return new Map();
+  const body = src.slice(table.bodyStart, table.end);
+  if (/^[ \t]*["'](?:status_line_use_colors|status_line)["'][ \t]*=/m.test(body)) {
+    throw new Error('quoted managed keys in [tui] are not safely patchable');
+  }
+  const found = new Map();
+  const re = /^[ \t]*(status_line_use_colors|status_line)[ \t]*=/gm;
+  for (const m of body.matchAll(re)) {
+    const key = m[1];
+    if (found.has(key)) throw new Error(`duplicate ${key} in [tui]`);
+    const start = table.bodyStart + m.index;
+    const eq = start + m[0].lastIndexOf('=');
+    let end = valueEnd(src, eq + 1, table.end);
+    if (src[end] === '\r' && src[end + 1] === '\n') end += 2;
+    else if (src[end] === '\r' || src[end] === '\n') end++;
+    found.set(key, { start, end, raw: src.slice(eq + 1, end).trim() });
+  }
+  return found;
+}
+
+function parseValues(spans) {
+  const colorsRaw = spans.get('status_line_use_colors')?.raw?.replace(/#.*$/s, '').trim();
+  let colors = null;
+  if (colorsRaw != null) {
+    if (!/^(true|false)$/.test(colorsRaw)) throw new Error('status_line_use_colors must be boolean');
+    colors = colorsRaw === 'true';
+  }
+  let items = null;
+  const raw = spans.get('status_line')?.raw;
+  if (raw != null) {
+    let withoutComments = '';
+    let quote = null;
+    let escape = false;
+    for (let i = 0; i < raw.length; i++) {
+      const c = raw[i];
+      if (quote) {
+        withoutComments += c;
+        if (escape) escape = false;
+        else if (c === '\\' && quote === '"') escape = true;
+        else if (c === quote) quote = null;
+      } else if (c === '"' || c === "'") {
+        quote = c;
+        withoutComments += c;
+      } else if (c === '#') {
+        while (i + 1 < raw.length && raw[i + 1] !== '\n' && raw[i + 1] !== '\r') i++;
+      } else {
+        withoutComments += c;
+      }
+    }
+    try { items = JSON.parse(withoutComments.replace(/,\s*\]$/, ']')); }
+    catch { throw new Error('status_line must be an array of strings'); }
+    if (!Array.isArray(items) || items.some((v) => typeof v !== 'string')) {
+      throw new Error('status_line must be an array of strings');
+    }
+  }
+  return { status_line_use_colors: colors, status_line: items };
+}
+
+export function inspectCodexStatusline(file = paths.codexConfigPath()) {
+  if (!fs.existsSync(file)) return { file, exists: false, valid: true, values: { status_line_use_colors: null, status_line: null } };
+  try {
+    const source = fs.readFileSync(file, 'utf8');
+    if (/^[ \t]*tui[ \t]*\.[ \t]*(?:status_line_use_colors|status_line)[ \t]*=/m.test(source)) {
+      throw new Error('dotted tui status-line keys are not safely patchable');
+    }
+    const table = findTable(source);
+    const spans = keySpans(source, table);
+    return { file, exists: true, valid: true, values: parseValues(spans) };
+  } catch (error) {
+    return { file, exists: true, valid: false, error: error.message };
+  }
+}
+
+export function statuslineDrift(cfg, file = paths.codexConfigPath()) {
+  const owned = cfg.statusline?.codex?.preset;
+  const current = inspectCodexStatusline(file);
+  if (!owned) return { owned: false, current, drifted: false };
+  const expected = projectionFor(owned);
+  const drifted = !current.valid
+    || current.values.status_line_use_colors !== expected.status_line_use_colors
+    || JSON.stringify(current.values.status_line) !== JSON.stringify(expected.status_line);
+  return { owned: true, preset: owned, expected, current, drifted };
+}
+
+function writeAtomic(file, source) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  if (fs.existsSync(file)) fs.copyFileSync(file, `${file}.bak.${Date.now()}`);
+  const tmp = `${file}.tmp.${process.pid}.${Date.now()}`;
+  try {
+    fs.writeFileSync(tmp, source);
+    fs.renameSync(tmp, file);
+  } catch (error) {
+    try { fs.rmSync(tmp); } catch {}
+    throw error;
+  }
+}
+
+export function applyCodexStatusline(preset, file = paths.codexConfigPath()) {
+  if (!PRESETS[preset]) throw new Error(`unknown Codex status-line preset: ${preset}`);
+  const source = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+  if (/^[ \t]*tui[ \t]*\.[ \t]*(?:status_line_use_colors|status_line)[ \t]*=/m.test(source)) {
+    throw new Error('dotted tui status-line keys are not safely patchable');
+  }
+  const nl = source.includes('\r\n') ? '\r\n' : '\n';
+  let table = findTable(source);
+  let next = source;
+  if (!table) {
+    const join = source && !source.endsWith('\n') && !source.endsWith('\r') ? nl : '';
+    next += `${join}${source ? nl : ''}[tui]${nl}`;
+    table = findTable(next);
+  }
+  const spans = keySpans(next, table);
+  const projection = projectionFor(preset);
+  const values = {
+    status_line_use_colors: 'true',
+    status_line: arrayText(projection.status_line, nl),
+  };
+  // Replace from bottom to top so offsets remain stable.
+  for (const key of ['status_line', 'status_line_use_colors']) {
+    const span = spans.get(key);
+    if (span) next = next.slice(0, span.start) + `${key} = ${values[key]}${nl}` + next.slice(span.end);
+  }
+  const missing = ['status_line_use_colors', 'status_line'].filter((key) => !spans.has(key));
+  if (missing.length) {
+    table = findTable(next);
+    const insertion = missing.map((key) => `${key} = ${values[key]}${nl}`).join('');
+    next = next.slice(0, table.bodyStart) + nl + insertion + next.slice(table.bodyStart).replace(/^\r?\n/, '');
+  }
+  if (next === source) return { changed: false, file, projection };
+  writeAtomic(file, next);
+  return { changed: true, file, projection };
+}
+
+export function removeCodexStatusline(lastProjection, file = paths.codexConfigPath()) {
+  if (!lastProjection || !fs.existsSync(file)) return { changed: false, file };
+  const source = fs.readFileSync(file, 'utf8');
+  const table = findTable(source);
+  const spans = keySpans(source, table);
+  const current = parseValues(spans);
+  const removable = [];
+  if (current.status_line_use_colors === lastProjection.status_line_use_colors) removable.push(spans.get('status_line_use_colors'));
+  if (JSON.stringify(current.status_line) === JSON.stringify(lastProjection.status_line)) removable.push(spans.get('status_line'));
+  let next = source;
+  for (const span of removable.filter(Boolean).sort((a, b) => b.start - a.start)) {
+    next = next.slice(0, span.start) + next.slice(span.end);
+  }
+  if (next === source) return { changed: false, file };
+  writeAtomic(file, next);
+  return { changed: true, file };
+}
diff --git a/src/lib/config.mjs b/src/lib/config.mjs
index 5334fa5f..342300e7 100644
--- a/src/lib/config.mjs
+++ b/src/lib/config.mjs
@@ -26,6 +26,7 @@ const DEFAULTS = {
     dualRouting: {},                        // activity → {host,model,escalate?,source} per-activity routing policy (ADR-0001; seeded on dual-host)
     codexMcp: null,                         // 'ak' when ak registered the codex MCP server (ownership guard for teardown)
   },
+  statusline: { codex: null }, // {preset,lastProjection}: explicit ownership of Codex [tui] keys
   customBlocks: [],     // [{slug, templatePath, detector:{type:'command'|'dir'|'file', target}}]
   versionCheck: { ttlHours: 24, last: null, seen: {} },
 };
@@ -46,6 +47,7 @@ export function loadKitConfig(file = kitConfigPath()) {
           ...parsed.providers,
           hosts: { ...DEFAULTS.providers.hosts, ...parsed.providers?.hosts },
         },
+        statusline: { ...DEFAULTS.statusline, ...parsed.statusline },
       };
     } catch { /* try next */ }
   }
diff --git a/src/lib/hosts.mjs b/src/lib/hosts.mjs
index 29151315..c70d55b6 100644
--- a/src/lib/hosts.mjs
+++ b/src/lib/hosts.mjs
@@ -18,7 +18,7 @@
 //     `claude mcp add`.
 //   - codex statusline is a fixed built-in enum (`tui.status_line`); a
 //     command-backed footer like Claude Code's is an unimplemented upstream
-//     request (openai/codex #16921/#17827/#20140/#20244) → statuslineSupported:false.
+//     request (openai/codex #16921/#17827/#20140/#20244).
 //   - codex auth: OPENAI_API_KEY set ⇒ codex ignores the ChatGPT login stored in
 //     ~/.codex/auth.json (key overrides login). claude auth on macOS lives in the
 //     Keychain (no readable file); ANTHROPIC_API_KEY, when used, is not a simple
@@ -32,7 +32,8 @@ export const HOST_ADAPTERS = {
     label: 'Claude Code',
     guidanceFile: 'claude', // logical → CLAUDE.md (machine-wide) / project CLAUDE.md
     configFormat: 'json', // settings.json
-    statuslineSupported: true, // command-backed statusLine hook
+    statusline: { mode: 'command', scope: 'project', customCommand: true, multiline: true },
+    statuslineSupported: true, // compatibility: command-backed renderer support
     aqeProvider: 'claude-code',
     // env vars Claude Code sets in a running session — used to detect the driver.
     envMarkers: ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT', 'CLAUDE_CODE_SESSION_ID'],
@@ -47,7 +48,8 @@ export const HOST_ADAPTERS = {
     label: 'OpenAI Codex',
     guidanceFile: 'agents', // logical → AGENTS.md (+ .codex/AGENTS.override.md)
     configFormat: 'toml', // ~/.codex/config.toml, [mcp_servers.*]
-    statuslineSupported: false, // enum-only; show+explain, delivered via AGENTS.md
+    statusline: { mode: 'builtin', scope: 'user', customCommand: false, multiline: false },
+    statuslineSupported: false, // compatibility: no command-backed renderer
     aqeProvider: 'codex',
     envMarkers: ['CODEX_SANDBOX', 'CODEX_HOME', 'CODEX_SESSION_ID'],
     auth: {
diff --git a/src/lib/paths.mjs b/src/lib/paths.mjs
index cb0e734e..8f487485 100644
--- a/src/lib/paths.mjs
+++ b/src/lib/paths.mjs
@@ -34,6 +34,7 @@ export const claudeSkillsDir = () => path.join(claudeDir(), 'skills');
  *  codex is installed on the machine (see blocks.guidanceTargets). */
 export const codexDir = () => path.join(home, '.codex');
 export const codexAgentsMdPath = () => path.join(codexDir(), 'AGENTS.md');
+export const codexConfigPath = () => path.join(codexDir(), 'config.toml');
 
 /** Per-project locations, relative to a project root. */
 export const projectSettings = (root) => path.join(root, '.claude', 'settings.json');
diff --git a/tests/kit/codex-statusline.test.mjs b/tests/kit/codex-statusline.test.mjs
new file mode 100644
index 00000000..3ff5783a
--- /dev/null
+++ b/tests/kit/codex-statusline.test.mjs
@@ -0,0 +1,103 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  PRESETS, applyCodexStatusline, inspectCodexStatusline, projectionFor,
+  removeCodexStatusline, statuslineDrift,
+} from '../../src/lib/codex-statusline.mjs';
+
+const roots = [];
+const fixture = (body = null) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ak-codex-statusline-'));
+  roots.push(root);
+  const file = path.join(root, 'config.toml');
+  if (body != null) fs.writeFileSync(file, body);
+  return file;
+};
+
+test('applies native preset when config and [tui] are absent', () => {
+  const file = fixture();
+  const r = applyCodexStatusline('native', file);
+  assert.equal(r.changed, true);
+  assert.deepEqual(inspectCodexStatusline(file).values, projectionFor('native'));
+});
+
+test('preserves unrelated tables, comments, and keys in existing [tui]', () => {
+  const file = fixture('# hello\nmodel = "gpt"\n\n[tui]\nnotifications = true # keep\n\n[mcp_servers.ruflo]\ncommand = "ruflo"\n');
+  applyCodexStatusline('extended', file);
+  const out = fs.readFileSync(file, 'utf8');
+  assert.match(out, /# hello/);
+  assert.match(out, /notifications = true # keep/);
+  assert.match(out, /\[mcp_servers\.ruflo\]\ncommand = "ruflo"/);
+  assert.deepEqual(inspectCodexStatusline(file).values.status_line, PRESETS.extended);
+});
+
+test('replaces a multiline /statusline-style array idempotently', () => {
+  const file = fixture('[tui]\nstatus_line_use_colors = false\nstatus_line = [\n  "model", # old\n  "git-branch",\n]\nother = 1\n');
+  applyCodexStatusline('native', file);
+  const once = fs.readFileSync(file, 'utf8');
+  assert.equal(applyCodexStatusline('native', file).changed, false);
+  assert.equal(fs.readFileSync(file, 'utf8'), once);
+  assert.match(once, /other = 1/);
+});
+
+test('preserves CRLF newline style', () => {
+  const file = fixture('[tui]\r\nother = true\r\n');
+  applyCodexStatusline('native', file);
+  const out = fs.readFileSync(file, 'utf8');
+  assert.ok(!/(?<!\r)\n/.test(out), 'must not introduce bare LF');
+  assert.equal((out.match(/\[tui\]/g) ?? []).length, 1, 'must recognize the existing CRLF table');
+});
+
+test('invalid duplicate managed keys are rejected without writing', () => {
+  const body = '[tui]\nstatus_line = []\nstatus_line = []\n';
+  const file = fixture(body);
+  assert.throws(() => applyCodexStatusline('native', file), /duplicate status_line/);
+  assert.equal(fs.readFileSync(file, 'utf8'), body);
+  assert.equal(inspectCodexStatusline(file).valid, false);
+});
+
+test('preserves a hash inside a quoted status-line item while stripping comments', () => {
+  const file = fixture('[tui]\nstatus_line = [\n  "custom#field", # comment\n]\n');
+  assert.deepEqual(inspectCodexStatusline(file).values.status_line, ['custom#field']);
+});
+
+for (const [label, body] of [
+  ['quoted table', '["tui"]\nstatus_line = []\n'],
+  ['single-quoted table', "['tui']\nstatus_line = []\n"],
+  ['dotted key', 'tui.status_line = []\n'],
+  ['quoted key', '[tui]\n"status_line" = []\n'],
+]) {
+  test(`fails closed on TOML-equivalent ${label} syntax`, () => {
+    const file = fixture(body);
+    assert.equal(inspectCodexStatusline(file).valid, false);
+    assert.throws(() => applyCodexStatusline('native', file), /not safely patchable/);
+    assert.equal(fs.readFileSync(file, 'utf8'), body);
+  });
+}
+
+test('off removes only values that still equal the last managed projection', () => {
+  const file = fixture('[tui]\nother = true\n');
+  applyCodexStatusline('native', file);
+  let out = fs.readFileSync(file, 'utf8').replace('status_line_use_colors = true', 'status_line_use_colors = false');
+  fs.writeFileSync(file, out);
+  const r = removeCodexStatusline(projectionFor('native'), file);
+  assert.equal(r.changed, true);
+  out = fs.readFileSync(file, 'utf8');
+  assert.match(out, /status_line_use_colors = false/, 'user-modified key survives');
+  assert.doesNotMatch(out, /^status_line =/m, 'unchanged managed key is removed');
+  assert.match(out, /other = true/);
+});
+
+test('ownership controls drift and unmanaged configurations are never actionable', () => {
+  const file = fixture('[tui]\nstatus_line = ["custom"]\n');
+  assert.equal(statuslineDrift({ statusline: { codex: null } }, file).drifted, false);
+  const cfg = { statusline: { codex: { preset: 'native', lastProjection: projectionFor('native') } } };
+  assert.equal(statuslineDrift(cfg, file).drifted, true);
+  applyCodexStatusline('native', file);
+  assert.equal(statuslineDrift(cfg, file).drifted, false);
+});
+
+test.after(() => roots.forEach((root) => fs.rmSync(root, { recursive: true, force: true })));
diff --git a/tests/kit/hosts.test.mjs b/tests/kit/hosts.test.mjs
index ba52d264..b00197b6 100644
--- a/tests/kit/hosts.test.mjs
+++ b/tests/kit/hosts.test.mjs
@@ -21,6 +21,7 @@ test('codex adapter targets AGENTS.md/toml and has NO command-backed statusline'
   assert.equal(a.guidanceFile, 'agents');
   assert.equal(a.configFormat, 'toml');
   assert.equal(a.statuslineSupported, false);
+  assert.deepEqual(a.statusline, { mode: 'builtin', scope: 'user', customCommand: false, multiline: false });
   assert.equal(a.aqeProvider, 'codex');
 });
 
diff --git a/tests/kit/status-command.test.mjs b/tests/kit/status-command.test.mjs
index 33554f5c..ce8d6129 100644
--- a/tests/kit/status-command.test.mjs
+++ b/tests/kit/status-command.test.mjs
@@ -146,6 +146,29 @@ test('project-scope rows degrade to info in a project that was never set up', as
   assert.equal(one(rows, 'statusline').level, 'info');
 });
 
+test('owned Codex statusline reports independently without enabling Codex MCP routing', async () => {
+  const preset = [
+    'model-with-reasoning', 'project-name', 'git-branch', 'run-state',
+    'context-remaining', 'five-hour-limit', 'weekly-limit', 'task-progress',
+  ];
+  seedHome(offlineKitConfig({
+    providers: { hosts: { claude: true, codex: false } },
+    statusline: {
+      codex: {
+        preset: 'native',
+        lastProjection: { status_line_use_colors: true, status_line: preset },
+      },
+    },
+  }));
+  fs.mkdirSync(paths.codexDir(), { recursive: true });
+  fs.writeFileSync(paths.codexConfigPath(),
+    `[tui]\nstatus_line_use_colors = true\nstatus_line = ${JSON.stringify(preset)}\n`);
+  const rows = await collect();
+  assert.equal(one(rows, 'codex-statusline').level, 'ok');
+  assert.equal(rowsFor(rows, 'codex-mcp').length, 0,
+    'statusline ownership must not imply Codex is enabled as a routed host');
+});
+
 test('an initialized project reports its learned-pattern count', async () => {
   seedHome();
   const neural = path.join(paths.projectClaudeFlowDir(PROJECT), 'neural');