From 857d280b6f333fd9b8c81d632c0ed2e3512273d7 Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Fri, 7 Aug 2026 18:59:25 +0900
Subject: [PATCH 1/9] feat(v2): add Ultra mode toggle for proactive delegation
 on every model/effort

Expose codex-rs features.multi_agent_v2.multi_agent_mode_hint_text through
the OCX config editor, /api/v2, the ocx v2 CLI, and the Subagents GUI.

The upstream field overrides the effort-derived multi-agent policy (ultra ->
Proactive, else ExplicitRequestOnly) with custom <multi_agent_mode> text, so
any model and any reasoning effort can run the Proactive delegation prompt.

- features.ts: generalize the v2 string-field reader/writer and add
  get/setMultiAgentModeHintText (dedicated table, inline table, bare-boolean
  upgrade, CRLF/EOL preservation).
- agent-settings-routes.ts: GET /api/v2 reports multiAgentModeHintText; PUT
  accepts string|null and rejects empty/whitespace strings (a present empty
  override would suppress even the ultra-derived Proactive message).
- cli/v2.ts: ocx v2 mode-hint <text|--clear> and status line.
- GUI: Ultra mode switch + editable text + preset restore on the Subagents
  page, disabled until multi_agent_v2 is enabled.
- tests: reader/writer encodings, clear semantics, inline-table tricky values,
  API GET/PUT/400 validation, CLI mode-hint round-trip.
---
 .../SubagentDelegationSection.tsx             |  48 +++++++
 .../SubagentsWorkspace.tsx                    |   6 +-
 gui/src/i18n/de.ts                            |   7 +
 gui/src/i18n/en.ts                            |   7 +
 gui/src/i18n/ja.ts                            |   7 +
 gui/src/i18n/ko.ts                            |   7 +
 gui/src/i18n/ru.ts                            |   7 +
 gui/src/i18n/zh.ts                            |   7 +
 gui/src/pages/Subagents.tsx                   |  57 ++++++++-
 gui/src/pages/use-subagent-delegation.ts      |  11 ++
 src/cli/v2.ts                                 |  33 ++++-
 src/codex/features.ts                         |  54 ++++++--
 .../management/agent-settings-routes.ts       |  21 ++-
 tests/codex-v2-gate.test.ts                   | 120 ++++++++++++++++++
 14 files changed, 374 insertions(+), 18 deletions(-)

diff --git a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
index 2cf672b93..f19a7091f 100644
--- a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
+++ b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
@@ -10,6 +10,7 @@ import { Select } from "../../ui";
 import { useT } from "../../i18n/shared";
 import { formatNamespacedModelId } from "../../provider-icons";
 import type { DelegationPatch, DelegationModelOption } from "../../pages/use-subagent-delegation";
+import type { UltraModePatch, UltraModeState } from "../../pages/use-subagent-delegation";
 
 export interface SubagentDelegationSectionProps {
   model: string;
@@ -20,6 +21,8 @@ export interface SubagentDelegationSectionProps {
   syncCodexDefaults: boolean;
   saving: boolean;
   onSave: (patch: DelegationPatch) => void;
+  ultraMode: UltraModeState;
+  onUltraModeSave: (patch: UltraModePatch) => void;
 }
 
 export default function SubagentDelegationSection({
@@ -31,8 +34,11 @@ export default function SubagentDelegationSection({
   syncCodexDefaults,
   saving,
   onSave,
+  ultraMode,
+  onUltraModeSave,
 }: SubagentDelegationSectionProps) {
   const t = useT();
+  const ultraOn = ultraMode.hintText !== null;
 
   return (
     <div className="swi-delegation">
@@ -100,6 +106,48 @@ export default function SubagentDelegationSection({
           <span className="knob" />
         </button>
       </div>
+
+      <div className="swi-delegation-row">
+        <div className="setting-copy">
+          <div className="font-semibold">{t("sub.ultraMode")}</div>
+          <div className="muted setting-hint">{t("sub.ultraModeHint")}</div>
+        </div>
+        <button
+          type="button"
+          className={`switch ${ultraOn ? "on" : ""}`}
+          onClick={() => onUltraModeSave({ multiAgentModeHintText: ultraOn ? null : ULTRA_MODE_PRESET })}
+          disabled={saving || !ultraMode.multiAgentV2Enabled}
+          aria-label={t("sub.ultraMode")}
+          aria-pressed={ultraOn}
+          title={ultraMode.multiAgentV2Enabled ? undefined : t("sub.ultraModeV2Required")}
+        >
+          <span className="knob" />
+        </button>
+      </div>
+      {ultraOn && (
+        <div className="swi-delegation-row swi-ultra-mode-editor">
+          <textarea
+            className="input swi-ultra-mode-textarea"
+            value={ultraMode.hintText ?? ""}
+            onChange={e => onUltraModeSave({ multiAgentModeHintText: e.target.value || null })}
+            disabled={saving}
+            rows={4}
+            aria-label={t("sub.ultraModeText")}
+          />
+          <button
+            type="button"
+            className="btn btn-ghost btn-sm"
+            onClick={() => onUltraModeSave({ multiAgentModeHintText: ULTRA_MODE_PRESET })}
+            disabled={saving}
+          >
+            {t("sub.ultraModePreset")}
+          </button>
+        </div>
+      )}
     </div>
   );
 }
+
+/** Canonical Proactive delegation text mirrored from codex-rs (multi_agent_mode_instructions.rs). */
+export const ULTRA_MODE_PRESET =
+  "Proactive multi-agent delegation is active. Any earlier instruction requiring an explicit user request before spawning sub-agents no longer applies. Use sub-agents when parallel work would materially improve speed or quality. This mode remains active until a later multi-agent mode developer message changes it.";
diff --git a/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx b/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
index a2ec5cb57..bdddcb0ca 100644
--- a/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
+++ b/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
@@ -27,7 +27,7 @@ import { modelLabel } from "../../model-display";
 import { SectionTabs } from "../section-tabs";
 import { sectionAnchorId } from "../../section-anchors";
 import SubagentDelegationSection from "./SubagentDelegationSection";
-import type { DelegationPatch, DelegationModelOption } from "../../pages/use-subagent-delegation";
+import type { DelegationPatch, DelegationModelOption, UltraModePatch, UltraModeState } from "../../pages/use-subagent-delegation";
 
 export interface SubagentsWorkspaceProps {
   available: string[];
@@ -45,6 +45,8 @@ export interface SubagentsWorkspaceProps {
     syncCodexDefaults: boolean;
     saving: boolean;
     onSave: (patch: DelegationPatch) => void;
+    ultraMode: UltraModeState;
+    onUltraModeSave: (patch: UltraModePatch) => void;
   };
 }
 
@@ -224,6 +226,8 @@ export default function SubagentsWorkspace({
             syncCodexDefaults={delegation.syncCodexDefaults}
             saving={delegation.saving}
             onSave={delegation.onSave}
+            ultraMode={delegation.ultraMode}
+            onUltraModeSave={delegation.onUltraModeSave}
           />
         </section>
       </div>
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 917a92f56..a3648a388 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -567,6 +567,13 @@ export const de: Record<TKey, string> = {
   "sub.workspace.selectModel": "Modell auswählen",
   "sub.workspace.selectModelDesc": "Wählen Sie ein Modell aus der Liste, um Details anzuzeigen und es für spawn_agent hervorzuheben.",
   "sub.workspace.selector": "Öffentlicher Selektor",
+  "sub.ultraMode": "Ultra-Modus",
+  "sub.ultraModeHint": "Aktiviert die proaktive Multi-Agent-Delegierungsrichtlinie für alle Modelle und Reasoning-Efforts (ändert den Reasoning-Effort selbst nicht). Schreibt multi_agent_mode_hint_text in config.toml.",
+  "sub.ultraModeV2Required": "Benötigt das multi_agent_v2-Feature — aktivieren Sie es zuerst mit ocx v2 on.",
+  "sub.ultraModeText": "Delegierungstext des Ultra-Modus",
+  "sub.ultraModePreset": "Voreinstellung wiederherstellen",
+  "sub.ultraModeLoadFail": "Ultra-Modus-Einstellungen konnten nicht geladen werden — läuft der Proxy?",
+  "sub.ultraModeSaveFail": "Ultra-Modus-Einstellungen konnten nicht gespeichert werden",
   "logs.title": "Anfrage-Protokolle",
   "logs.tabLogs": "Protokolle",
   "logs.tabDebug": "Diagnose",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index 7bdebfeb0..c8fa0358f 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -588,6 +588,13 @@ export const en = {
   "sub.workspace.mainAria": "Subagent model details",
   "sub.workspace.notFeatured": "Not featured",
   "sub.workspace.priority": "Priority",
+  "sub.ultraMode": "Ultra mode",
+  "sub.ultraModeHint": "Enable the Proactive multi-agent delegation policy for every model and reasoning effort (does not change reasoning effort itself). Writes multi_agent_mode_hint_text in config.toml.",
+  "sub.ultraModeV2Required": "Requires the multi_agent_v2 feature — enable it with ocx v2 on first.",
+  "sub.ultraModeText": "Ultra mode delegation text",
+  "sub.ultraModePreset": "Restore preset",
+  "sub.ultraModeLoadFail": "Failed to load Ultra mode settings — is the proxy running?",
+  "sub.ultraModeSaveFail": "Failed to save Ultra mode settings",
   "sub.workspace.removeFromFeatured": "Remove {m} from featured",
   "sub.workspace.selectModel": "Select a model",
   "sub.workspace.selectModelDesc": "Pick a model from the list to see details and feature it for spawn_agent.",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 4d57ca670..274a41d1c 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -550,6 +550,13 @@ export const ja: Record<TKey, string> = {
   "sub.workspace.selectModel": "モデルを選択",
   "sub.workspace.selectModelDesc": "一覧からモデルを選んで詳細を確認し、spawn_agent のおすすめに設定します。",
   "sub.workspace.selector": "公開セレクター",
+  "sub.ultraMode": "ウルトラモード",
+  "sub.ultraModeHint": "すべてのモデルと reasoning effort で Proactive マルチエージェント委任ポリシーを有効にします（reasoning effort 自体は変更しません）。config.toml に multi_agent_mode_hint_text を書き込みます。",
+  "sub.ultraModeV2Required": "multi_agent_v2 機能が必要です — 先に ocx v2 on で有効にしてください。",
+  "sub.ultraModeText": "ウルトラモード委任テキスト",
+  "sub.ultraModePreset": "プリセットを復元",
+  "sub.ultraModeLoadFail": "ウルトラモード設定を読み込めませんでした — プロキシは実行中ですか？",
+  "sub.ultraModeSaveFail": "ウルトラモード設定の保存に失敗しました",
 
   // logs
   "logs.title": "リクエストログ",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index bf842b922..ff3734efa 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -584,6 +584,13 @@ export const ko: Record<TKey, string> = {
   "sub.workspace.selectModel": "모델 선택",
   "sub.workspace.selectModelDesc": "목록에서 모델을 선택하여 세부 정보를 확인하고 spawn_agent에 추천하세요.",
   "sub.workspace.selector": "공개 셀렉터",
+  "sub.ultraMode": "울트라 모드",
+  "sub.ultraModeHint": "모든 모델과 reasoning effort에서 Proactive 멀티에이전트 위임 정책을 켭니다 (reasoning effort 자체는 변경하지 않음). config.toml에 multi_agent_mode_hint_text를 기록합니다.",
+  "sub.ultraModeV2Required": "multi_agent_v2 기능이 필요합니다 — 먼저 ocx v2 on으로 켜세요.",
+  "sub.ultraModeText": "울트라 모드 위임 텍스트",
+  "sub.ultraModePreset": "프리셋 복원",
+  "sub.ultraModeLoadFail": "울트라 모드 설정을 불러오지 못했습니다 — 프록시가 실행 중인가요?",
+  "sub.ultraModeSaveFail": "울트라 모드 설정 저장에 실패했습니다",
 
   // logs
   "logs.title": "요청 로그",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 48a584e5e..b95c32895 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -582,6 +582,13 @@ export const ru: Record<TKey, string> = {
   "sub.workspace.selectModel": "Выберите модель",
   "sub.workspace.selectModelDesc": "Выберите модель из списка, чтобы увидеть детали и добавить её в избранные для spawn_agent.",
   "sub.workspace.selector": "Публичный селектор",
+  "sub.ultraMode": "Ультра-режим",
+  "sub.ultraModeHint": "Включает политику упреждающего делегирования мультиагентов для всех моделей и уровней reasoning effort (сам reasoning effort не меняется). Записывает multi_agent_mode_hint_text в config.toml.",
+  "sub.ultraModeV2Required": "Требуется функция multi_agent_v2 — сначала включите её через ocx v2 on.",
+  "sub.ultraModeText": "Текст делегирования ультра-режима",
+  "sub.ultraModePreset": "Восстановить пресет",
+  "sub.ultraModeLoadFail": "Не удалось загрузить настройки ультра-режима — работает ли прокси?",
+  "sub.ultraModeSaveFail": "Не удалось сохранить настройки ультра-режима",
 
   // logs
   "logs.title": "Журнал запросов",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index f1f0eb62b..354807a1c 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -577,6 +577,13 @@ export const zh: Record<TKey, string> = {
   "sub.workspace.selectModel": "选择模型",
   "sub.workspace.selectModelDesc": "从列表中选择一个模型以查看详情，并将其设为 spawn_agent 的精选模型。",
   "sub.workspace.selector": "公开选择器",
+  "sub.ultraMode": "超级模式",
+  "sub.ultraModeHint": "为所有模型和推理力度启用主动多代理委派策略（不改变推理力度本身）。将 multi_agent_mode_hint_text 写入 config.toml。",
+  "sub.ultraModeV2Required": "需要 multi_agent_v2 功能 — 请先通过 ocx v2 on 启用。",
+  "sub.ultraModeText": "超级模式委派文本",
+  "sub.ultraModePreset": "恢复预设",
+  "sub.ultraModeLoadFail": "无法加载超级模式设置 — 代理是否在运行？",
+  "sub.ultraModeSaveFail": "保存超级模式设置失败",
 
   // logs
   "logs.title": "请求日志",
diff --git a/gui/src/pages/Subagents.tsx b/gui/src/pages/Subagents.tsx
index ee19679b9..7698d10f4 100644
--- a/gui/src/pages/Subagents.tsx
+++ b/gui/src/pages/Subagents.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { readJsonOrThrow } from "../fetch-json";
 import { Notice } from "../ui";
 import { useT } from "../i18n/shared";
@@ -6,7 +6,7 @@ import SubagentsWorkspace, { FEATURED_MAX } from "../components/subagents-worksp
 import { readSessionListCache, writeSessionListCache } from "../session-list-cache";
 import { useDataSurface } from "../data-surface";
 import { DataSurfaceSkeleton } from "../components/data-surface";
-import { useSubagentDelegation } from "./use-subagent-delegation";
+import { useSubagentDelegation, type UltraModePatch, type UltraModeState } from "./use-subagent-delegation";
 
 type CachedSubagents = { available: string[]; chosen: string[] };
 
@@ -25,6 +25,57 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   /** Sync guard: state-only `busy` can miss clicks before the disabled re-render commits. */
   const saveInFlight = useRef(false);
   const delegation = useSubagentDelegation(apiBase);
+  const [ultraMode, setUltraMode] = useState<UltraModeState>({ enabled: false, hintText: null, multiAgentV2Enabled: false });
+  const [ultraSaving, setUltraSaving] = useState(false);
+
+  // Load /api/v2 state (multi-agent v2 flag + mode hint) once on mount.
+  const loadUltraMode = useCallback(async () => {
+    try {
+      const res = await fetch(`${apiBase}/api/v2`);
+      const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
+      if (!data) return;
+      setUltraMode({
+        enabled: data.enabled ?? false,
+        hintText: data.multiAgentModeHintText ?? null,
+        multiAgentV2Enabled: data.enabled ?? false,
+      });
+    } catch { /* keep defaults; panel still renders */ }
+  }, [apiBase, t]);
+
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      const res = await fetch(`${apiBase}/api/v2`);
+      const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
+      if (cancelled) return;
+      if (!data) return;
+      setUltraMode({
+        enabled: data.enabled ?? false,
+        hintText: data.multiAgentModeHintText ?? null,
+        multiAgentV2Enabled: data.enabled ?? false,
+      });
+    })().catch(() => { /* keep defaults; panel still renders */ });
+    return () => { cancelled = true; };
+  }, [apiBase, t]);
+
+  const saveUltraMode = async (patch: UltraModePatch) => {
+    if (ultraSaving) return;
+    setUltraSaving(true);
+    try {
+      const res = await fetch(`${apiBase}/api/v2`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(patch),
+      });
+      await readJsonOrThrow(res, t("sub.ultraModeSaveFail"));
+      await loadUltraMode();
+    } catch (error) {
+      setOk(false);
+      setStatus(error instanceof Error && error.message ? error.message : t("sub.networkError"));
+    } finally {
+      setUltraSaving(false);
+    }
+  };
 
   const loadSubagents = useCallback(async (): Promise<CachedSubagents> => {
     const res = await fetch(`${apiBase}/api/subagent-models`);
@@ -134,6 +185,8 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
           syncCodexDefaults: delegation.syncCodexDefaults,
           saving: delegation.saving,
           onSave: patch => { void delegation.save(patch); },
+          ultraMode,
+          onUltraModeSave: patch => { void saveUltraMode(patch); },
         }}
       />
     </>
diff --git a/gui/src/pages/use-subagent-delegation.ts b/gui/src/pages/use-subagent-delegation.ts
index 3d8b2195c..d2c5342bf 100644
--- a/gui/src/pages/use-subagent-delegation.ts
+++ b/gui/src/pages/use-subagent-delegation.ts
@@ -19,6 +19,17 @@ export type DelegationPatch = {
   effort?: string | null;
 };
 
+/** Ultra mode (Proactive delegation for every model/effort) via /api/v2. */
+export type UltraModeState = {
+  enabled: boolean;
+  hintText: string | null;
+  multiAgentV2Enabled: boolean;
+};
+
+export type UltraModePatch = {
+  multiAgentModeHintText: string | null;
+};
+
 type DelegationResponse = {
   multiAgentGuidanceEnabled?: boolean;
   syncCodexSubagentDefaults?: boolean;
diff --git a/src/cli/v2.ts b/src/cli/v2.ts
index 952d5741d..67b6c0ec6 100644
--- a/src/cli/v2.ts
+++ b/src/cli/v2.ts
@@ -12,7 +12,7 @@
  */
 import { execFileSync } from "node:child_process";
 import { dirname } from "node:path";
-import { activeCodexConfigPath, getAgentsEnabled, getAgentsMaxDepth, getLogicalMaxThreads, getSubagentDeveloperInstructions, hasAgentsMaxThreads, isMultiAgentV2Enabled, transitionMultiAgentV2 } from "../codex/features";
+import { activeCodexConfigPath, getAgentsEnabled, getAgentsMaxDepth, getLogicalMaxThreads, getMultiAgentModeHintText, getSubagentDeveloperInstructions, hasAgentsMaxThreads, isMultiAgentV2Enabled, setMultiAgentModeHintText, transitionMultiAgentV2 } from "../codex/features";
 
 import { commandInvocation, type SpawnInvocation } from "../lib/win-exec";
 import { loadConfig, saveConfig } from "../config";
@@ -121,11 +121,40 @@ export async function cmdV2(args: string[], deps: V2CliDeps = {}, findPort?: ()
     log.log(`agents.max_depth: ${maxDepth ?? "(unset — upstream default 1)"}${v2Active ? " (V1-only — ignored while multi_agent_v2 is enabled)" : ""}`);
     const instructions = getSubagentDeveloperInstructions();
     log.log(`subagent_developer_instructions: ${instructions === null ? "(unset — children inherit)" : instructions === "" ? '"" (clears inherited instructions)' : JSON.stringify(instructions)}`);
+    const modeHint = getMultiAgentModeHintText();
+    log.log(`multi_agent_mode_hint_text: ${modeHint === null ? "(unset — effort-derived policy: ultra=proactive, else explicit)" : JSON.stringify(modeHint)}`);
     if (isEnabled() && hasMaxThreads()) {
       log.log("WARNING: [agents] max_threads is set — codex refuses to start while multi_agent_v2 is enabled. Remove it from config.toml (concurrency lives in features.multi_agent_v2.max_concurrent_threads_per_session).");
     }
     return 0;
   }
+  if (verb === "mode-hint") {
+    const flag = (args[1] ?? "").trim();
+    if (flag === "--clear" || flag === "") {
+      const result = setMultiAgentModeHintText(null);
+      if (!result.ok) {
+        log.error(`v2 mode-hint: ${result.error}`);
+        return 1;
+      }
+      log.log(result.changed
+        ? "multi_agent_mode_hint_text cleared — effort-derived policy resumes (new sessions)."
+        : "multi_agent_mode_hint_text already unset — nothing to do.");
+      return 0;
+    }
+    if (flag.startsWith("-")) {
+      log.error("v2 mode-hint: pass the hint text, or --clear to unset it.");
+      return 1;
+    }
+    const result = setMultiAgentModeHintText(flag);
+    if (!result.ok) {
+      log.error(`v2 mode-hint: ${result.error}`);
+      return 1;
+    }
+    log.log(result.changed
+      ? `multi_agent_mode_hint_text set (new sessions).`
+      : "multi_agent_mode_hint_text already set — nothing to do.");
+    return 0;
+  }
   if (verb === "threads") {
     const value = Number((args[1] ?? "").trim());
     if (!Number.isInteger(value) || value < 1) {
@@ -170,7 +199,7 @@ export async function cmdV2(args: string[], deps: V2CliDeps = {}, findPort?: ()
     return 0;
   }
   if (verb !== "on" && verb !== "off") {
-    log.error(`v2: unknown verb '${verb}' (expected status|on|off|mode <v1|default|v2>|threads <n>)`);
+    log.error(`v2: unknown verb '${verb}' (expected status|on|off|mode <v1|default|v2>|threads <n>|mode-hint <text|--clear>)`);
     return 1;
   }
 
diff --git a/src/codex/features.ts b/src/codex/features.ts
index 9a588a8c2..29c8bb31b 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -669,12 +669,19 @@ export function setAgentsMaxDepth(value: number | null, configPath?: string): Co
  * Reads both the dedicated-table and inline forms; dedicated wins, mirroring
  * `getMaxConcurrentThreads` precedence.
  */
-export function getSubagentDeveloperInstructions(configPath?: string): string | null {
+/**
+ * Read a string-valued `features.multi_agent_v2` scalar (dedicated table or inline
+ * form; dedicated wins, mirroring `getMaxConcurrentThreads` precedence). Returns
+ * `null` when the key is absent or the config is unreadable. A present empty string
+ * round-trips faithfully — some upstream keys treat `""` and `null` differently.
+ */
+function getV2StringField(key: string, configPath?: string): string | null {
   const content = readConfigText(configPath);
   if (content === null) return null;
   const table = tomlTableBody(content, "features.multi_agent_v2");
   if (table !== null) {
-    const m = table.match(/^\s*subagent_developer_instructions\s*=\s*/m);
+    const keyRe = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*`, "m");
+    const m = table.match(keyRe);
     if (m) {
       const valueStart = m.index! + m[0].length;
       const token = table.slice(valueStart, scanTomlValueEnd(table, valueStart)).trim();
@@ -689,11 +696,24 @@ export function getSubagentDeveloperInstructions(configPath?: string): string |
   const openIdx = m.index! + m[0].length - 1;
   const closeIdx = findInlineTableEnd(features, openIdx);
   if (closeIdx === -1) return null;
-  const entry = findInlineEntry(features, openIdx + 1, closeIdx, "subagent_developer_instructions");
+  const entry = findInlineEntry(features, openIdx + 1, closeIdx, key);
   if (!entry) return null;
   return decodeTomlStringToken(features.slice(entry.valueStart, entry.valueEnd).trim());
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function getSubagentDeveloperInstructions(configPath?: string): string | null {
+  return getV2StringField("subagent_developer_instructions", configPath);
+}
+
+/** Current `features.multi_agent_v2.multi_agent_mode_hint_text`, or null when unset. */
+export function getMultiAgentModeHintText(configPath?: string): string | null {
+  return getV2StringField("multi_agent_mode_hint_text", configPath);
+}
+
 /**
  * Persist `features.multi_agent_v2.subagent_developer_instructions`, or remove the
  * key when `value` is null. Handles all three existing encodings: the dedicated
@@ -705,14 +725,14 @@ export function getSubagentDeveloperInstructions(configPath?: string): string |
  * carries `#[serde(deny_unknown_fields)]`, so a misspelling is not ignored — it is
  * a hard config-parse failure for the user's Codex.
  */
-export function setSubagentDeveloperInstructions(value: string | null, configPath?: string): ConfigEditResult {
+function setV2StringField(key: string, value: string | null, configPath?: string): ConfigEditResult {
   const path = configPath ?? activeCodexConfigPath();
   const content = readConfigText(path);
   if (content === null) return { ok: false, error: `config.toml not readable at ${path}` };
   const encoded = value === null ? null : encodeTomlBasicString(value);
 
   if (tomlTableBody(content, "features.multi_agent_v2") !== null) {
-    const next = editScalarInTable(content, "features.multi_agent_v2", "subagent_developer_instructions", encoded);
+    const next = editScalarInTable(content, "features.multi_agent_v2", key, encoded);
     if (next === content) return { ok: true, changed: false };
     atomicWriteFile(path, next);
     return { ok: true, changed: true };
@@ -733,7 +753,7 @@ export function setSubagentDeveloperInstructions(value: string | null, configPat
         const openIdx = inlineMatch[0].length - 1;
         const closeIdx = findInlineTableEnd(line, openIdx);
         if (closeIdx === -1) return { ok: false, error: "malformed multi_agent_v2 inline table" };
-        const entry = findInlineEntry(line, openIdx + 1, closeIdx, "subagent_developer_instructions");
+        const entry = findInlineEntry(line, openIdx + 1, closeIdx, key);
         if (encoded === null) {
           if (!entry) return { ok: true, changed: false };
           let start = entry.keyStart;
@@ -760,8 +780,8 @@ export function setSubagentDeveloperInstructions(value: string | null, configPat
           while (insertPos > openIdx + 1 && line[insertPos - 1] === " ") insertPos--;
           const hasEntries = line.slice(openIdx + 1, insertPos).trim().length > 0;
           const insertion = hasEntries
-            ? `, subagent_developer_instructions = ${encoded} `
-            : ` subagent_developer_instructions = ${encoded} `;
+            ? `, ${key} = ${encoded} `
+            : ` ${key} = ${encoded} `;
           lines[i] = line.slice(0, insertPos) + insertion + line.slice(closeIdx);
         }
         atomicWriteFile(path, applyEol(lines.join("\n"), eol));
@@ -770,7 +790,7 @@ export function setSubagentDeveloperInstructions(value: string | null, configPat
       const boolMatch = line.match(/^(\s*)multi_agent_v2\s*=\s*(true|false)(\s*(?:#.*)?)$/);
       if (boolMatch) {
         if (encoded === null) return { ok: true, changed: false };
-        lines[i] = `${boolMatch[1]}multi_agent_v2 = { enabled = ${boolMatch[2]}, subagent_developer_instructions = ${encoded} }${boolMatch[3]}`;
+        lines[i] = `${boolMatch[1]}multi_agent_v2 = { enabled = ${boolMatch[2]}, ${key} = ${encoded} }${boolMatch[3]}`;
         atomicWriteFile(path, applyEol(lines.join("\n"), eol));
         return { ok: true, changed: true };
       }
@@ -780,11 +800,25 @@ export function setSubagentDeveloperInstructions(value: string | null, configPat
   if (encoded === null) return { ok: true, changed: false };
   const suffix = content.endsWith("\n") || content.length === 0 ? "" : eol;
   const separator = content.length > 0 && !content.endsWith(`${eol}${eol}`) ? eol : "";
-  const tableText = `[features.multi_agent_v2]${eol}subagent_developer_instructions = ${encoded}${eol}`;
+  const tableText = `[features.multi_agent_v2]${eol}${key} = ${encoded}${eol}`;
   atomicWriteFile(path, `${content}${suffix}${separator}${tableText}`);
   return { ok: true, changed: true };
 }
 
+export function setSubagentDeveloperInstructions(value: string | null, configPath?: string): ConfigEditResult {
+  return setV2StringField("subagent_developer_instructions", value, configPath);
+}
+
+/**
+ * Persist `features.multi_agent_v2.multi_agent_mode_hint_text`, or remove the key
+ * when `value` is null. Same encoding coverage and upstream-name discipline as
+ * `setSubagentDeveloperInstructions`; the upstream struct rejects unknown fields,
+ * so the key spelling must match codex-rs exactly.
+ */
+export function setMultiAgentModeHintText(value: string | null, configPath?: string): ConfigEditResult {
+  return setV2StringField("multi_agent_mode_hint_text", value, configPath);
+}
+
 function editAgentsMaxThreads(value: number | null, configPath?: string, migratedComment?: string): ConfigEditResult {
   const path = configPath ?? activeCodexConfigPath();
   const content = readConfigText(path);
diff --git a/src/server/management/agent-settings-routes.ts b/src/server/management/agent-settings-routes.ts
index b407f4608..d332166e6 100644
--- a/src/server/management/agent-settings-routes.ts
+++ b/src/server/management/agent-settings-routes.ts
@@ -224,6 +224,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     const {
       isMultiAgentV2Enabled, hasAgentsMaxThreads, getLogicalMaxThreads,
       getAgentsEnabled, getAgentsMaxDepth, getSubagentDeveloperInstructions,
+      getMultiAgentModeHintText,
     } = await import("../../codex/features");
     const enabled = isMultiAgentV2Enabled();
     return jsonResponse({
@@ -234,6 +235,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       agentsEnabled: getAgentsEnabled(),
       agentsMaxDepth: getAgentsMaxDepth(),
       subagentDeveloperInstructions: getSubagentDeveloperInstructions(),
+      multiAgentModeHintText: getMultiAgentModeHintText(),
       // max_depth is V1-only upstream; this is the global-flag statement, derived
       // server-side so no client can present it as an effective V2 limit.
       agentsMaxDepthAppliesWhenV2Disabled: !enabled,
@@ -247,6 +249,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       agentsEnabled?: unknown;
       agentsMaxDepth?: unknown;
       subagentDeveloperInstructions?: unknown;
+      multiAgentModeHintText?: unknown;
     };
     try { body = await readManagementJsonBody(req); } catch (error) { rethrowManagementBodyTooLarge(error); return jsonResponse({ error: "invalid JSON body" }, 400); }
     const wantsFlag = body.enabled !== undefined;
@@ -255,8 +258,9 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     const wantsAgentsEnabled = body.agentsEnabled !== undefined;
     const wantsMaxDepth = body.agentsMaxDepth !== undefined;
     const wantsSubagentInstructions = body.subagentDeveloperInstructions !== undefined;
-    if (!wantsFlag && !wantsThreads && !wantsMode && !wantsAgentsEnabled && !wantsMaxDepth && !wantsSubagentInstructions) {
-      return jsonResponse({ error: "body must set enabled, multiAgentMode, maxConcurrentThreadsPerSession, agentsEnabled, agentsMaxDepth, and/or subagentDeveloperInstructions" }, 400);
+    const wantsModeHintText = body.multiAgentModeHintText !== undefined;
+    if (!wantsFlag && !wantsThreads && !wantsMode && !wantsAgentsEnabled && !wantsMaxDepth && !wantsSubagentInstructions && !wantsModeHintText) {
+      return jsonResponse({ error: "body must set enabled, multiAgentMode, maxConcurrentThreadsPerSession, agentsEnabled, agentsMaxDepth, subagentDeveloperInstructions, and/or multiAgentModeHintText" }, 400);
     }
     if (wantsFlag && typeof body.enabled !== "boolean") return jsonResponse({ error: "body.enabled must be a boolean" }, 400);
     if (wantsMode && body.multiAgentMode !== "v1" && body.multiAgentMode !== "default" && body.multiAgentMode !== "v2") {
@@ -280,6 +284,14 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     if (wantsSubagentInstructions && body.subagentDeveloperInstructions !== null && typeof body.subagentDeveloperInstructions !== "string") {
       return jsonResponse({ error: "body.subagentDeveloperInstructions must be a string or null" }, 400);
     }
+    // null unsets the upstream key (effort-derived policy resumes); an empty/whitespace
+    // string is rejected because codex-rs treats any present hint as an override that
+    // suppresses even the Ultra-derived Proactive message (Option<String>, no blank
+    // special-case in effective_multi_agent_mode).
+    if (wantsModeHintText && body.multiAgentModeHintText !== null
+        && (typeof body.multiAgentModeHintText !== "string" || body.multiAgentModeHintText.trim().length === 0)) {
+      return jsonResponse({ error: "body.multiAgentModeHintText must be a non-empty string or null" }, 400);
+    }
     const mode = wantsMode ? body.multiAgentMode as "v1" | "default" | "v2" : undefined;
     const modeFlag = mode === "v2" ? true : mode === "v1" ? false : undefined;
     if (wantsFlag && modeFlag !== undefined && body.enabled !== modeFlag) {
@@ -288,7 +300,8 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     const {
       isMultiAgentV2Enabled, hasAgentsMaxThreads, getLogicalMaxThreads, transitionMultiAgentV2,
       getAgentsEnabled, getAgentsMaxDepth, getSubagentDeveloperInstructions,
-      setAgentsEnabled, setAgentsMaxDepth, setSubagentDeveloperInstructions,
+      getMultiAgentModeHintText, setAgentsEnabled, setAgentsMaxDepth,
+      setSubagentDeveloperInstructions, setMultiAgentModeHintText,
     } = await import("../../codex/features");
     const warnings: string[] = [];
     const requestedFlag = wantsFlag ? body.enabled as boolean : modeFlag;
@@ -322,6 +335,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     if (wantsAgentsEnabled) scalarWrites.push({ field: "agentsEnabled", run: () => setAgentsEnabled(body.agentsEnabled as boolean | null) });
     if (wantsMaxDepth) scalarWrites.push({ field: "agentsMaxDepth", run: () => setAgentsMaxDepth(body.agentsMaxDepth as number | null) });
     if (wantsSubagentInstructions) scalarWrites.push({ field: "subagentDeveloperInstructions", run: () => setSubagentDeveloperInstructions(body.subagentDeveloperInstructions as string | null) });
+    if (wantsModeHintText) scalarWrites.push({ field: "multiAgentModeHintText", run: () => setMultiAgentModeHintText(body.multiAgentModeHintText as string | null) });
     const landed: string[] = [];
     for (const write of scalarWrites) {
       try {
@@ -353,6 +367,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       agentsEnabled: getAgentsEnabled(),
       agentsMaxDepth: getAgentsMaxDepth(),
       subagentDeveloperInstructions: getSubagentDeveloperInstructions(),
+      multiAgentModeHintText: getMultiAgentModeHintText(),
       agentsMaxDepthAppliesWhenV2Disabled: !enabled,
       warnings,
       catalogRefresh,
diff --git a/tests/codex-v2-gate.test.ts b/tests/codex-v2-gate.test.ts
index 82e50c8fa..37678ae65 100644
--- a/tests/codex-v2-gate.test.ts
+++ b/tests/codex-v2-gate.test.ts
@@ -26,6 +26,7 @@ import {
   getAgentsMaxThreads,
   getLogicalMaxThreads,
   getMaxConcurrentThreads,
+  getMultiAgentModeHintText,
   getSubagentDeveloperInstructions,
   hasAgentsMaxThreads,
   isDefaultModeRequestUserInputEnabled,
@@ -35,6 +36,7 @@ import {
   setAgentsEnabled,
   setAgentsMaxDepth,
   setMaxConcurrentThreads,
+  setMultiAgentModeHintText,
   setSubagentDeveloperInstructions,
   transitionMultiAgentV2,
   v1ChildLimitToV2TotalLimit,
@@ -361,6 +363,87 @@ describe("max_concurrent_threads_per_session reader/writer", () => {
   }, { timeout: 20_000 });
 });
 
+describe("multi_agent_mode_hint_text reader/writer", () => {
+  const PRESET = "Proactive multi-agent delegation is active.";
+  const TABLE = "# keep me\n[features.multi_agent_v2]\nenabled = true\nmax_concurrent_threads_per_session = 17 # tuned\n\n[notice]\nhide = true\n";
+
+  test("reader: present, absent key, absent table, empty string", () => {
+    const present = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"Proactive delegation\"\n");
+    expect(getMultiAgentModeHintText(present)).toBe("Proactive delegation");
+    expect(getMultiAgentModeHintText(fixtureConfig(TABLE))).toBe(null);
+    expect(getMultiAgentModeHintText(fixtureConfig("[features]\nmulti_agent_v2 = true\n"))).toBe(null);
+    // A present empty string round-trips (upstream treats "" as a present override).
+    const empty = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"\"\n");
+    expect(getMultiAgentModeHintText(empty)).toBe("");
+  });
+
+  test("writer sets in a dedicated table, preserving comments and neighbors", () => {
+    const path = fixtureConfig(TABLE);
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    const out = readFileSync(path, "utf8");
+    expect(out).toContain(`multi_agent_mode_hint_text = "${PRESET}"`);
+    expect(out).toContain("# keep me");
+    expect(out).toContain("max_concurrent_threads_per_session = 17 # tuned");
+    expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+  });
+
+  test("writer is idempotent: equal value -> no write, changed:false", () => {
+    const path = fixtureConfig(`[features.multi_agent_v2]\nmulti_agent_mode_hint_text = "${PRESET}"\n`);
+    const before = readFileSync(path, "utf8");
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: false });
+    expect(readFileSync(path, "utf8")).toBe(before);
+  });
+
+  test("writer clears with null: removes the key, keeps siblings", () => {
+    const path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\nmulti_agent_mode_hint_text = \"Proactive delegation\"\nmax_concurrent_threads_per_session = 17\n");
+    expect(setMultiAgentModeHintText(null, path)).toEqual({ ok: true, changed: true });
+    const out = readFileSync(path, "utf8");
+    expect(out).not.toContain("multi_agent_mode_hint_text");
+    expect(out).toContain("enabled = true");
+    expect(out).toContain("max_concurrent_threads_per_session = 17");
+    expect(getMultiAgentModeHintText(path)).toBe(null);
+    // Clearing when already absent is a no-op.
+    expect(setMultiAgentModeHintText(null, fixtureConfig(TABLE))).toEqual({ ok: true, changed: false });
+  });
+
+  test("writer upgrades the bare boolean form and preserves enabled", () => {
+    const path = fixtureConfig("[features]\nmulti_agent_v2 = true\n");
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    const out = readFileSync(path, "utf8");
+    expect(out).toContain("multi_agent_v2 = { enabled = true,");
+    expect(out).toContain(`multi_agent_mode_hint_text = "${PRESET}"`);
+    expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+    expect(isMultiAgentV2Enabled(path)).toBe(true);
+  });
+
+  test("writer supports inline-table form and values containing braces/commas/quotes", () => {
+    const tricky = "Use sub-agents {parallel}, \"quoted\", when needed.";
+    const path = fixtureConfig("[features]\nmulti_agent_v2 = { enabled = true, max_concurrent_threads_per_session = 8 } # keep\n");
+    expect(setMultiAgentModeHintText(tricky, path)).toEqual({ ok: true, changed: true });
+    const out = readFileSync(path, "utf8");
+    expect(out).toContain("# keep");
+    expect(out).toContain("max_concurrent_threads_per_session = 8");
+    expect(getMultiAgentModeHintText(path)).toBe(tricky);
+  });
+
+  test("writer creates the dedicated table when no v2 config exists", () => {
+    const path = fixtureConfig("[notice]\nhide = true\n");
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    const out = readFileSync(path, "utf8");
+    expect(out).toContain("[features.multi_agent_v2]");
+    expect(out).toContain(`multi_agent_mode_hint_text = "${PRESET}"`);
+    expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+  });
+
+  test("writer preserves CRLF files", () => {
+    const path = fixtureConfig("[features.multi_agent_v2]\r\nenabled = true\r\n");
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    const out = readFileSync(path, "utf8");
+    expect(out).toContain(`multi_agent_mode_hint_text = "${PRESET}"\r\n`);
+    expect(out).not.toMatch(/[^\r]\n/);
+  });
+});
+
 describe("thread-limit-preserving v1/v2 transition", () => {
   const flipTableFlag = (path: string) => (enabled: boolean) => {
     const content = readFileSync(path, "utf8");
@@ -897,6 +980,7 @@ describe("management API parity surface for the WP2 keys", () => {
         agentsEnabled: null,
         agentsMaxDepth: 2,
         subagentDeveloperInstructions: null,
+        multiAgentModeHintText: null,
         agentsMaxDepthAppliesWhenV2Disabled: true,
       });
       const v2Path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\n");
@@ -917,6 +1001,13 @@ describe("management API parity surface for the WP2 keys", () => {
       const instructions = await handleManagementAPI(put({ subagentDeveloperInstructions: "be thorough" }), new URL("http://localhost/api/v2"), config, deps);
       expect(instructions?.status).toBe(200);
       expect(getSubagentDeveloperInstructions(path)).toBe("be thorough");
+      const hint = await handleManagementAPI(put({ multiAgentModeHintText: "Proactive multi-agent delegation is active." }), new URL("http://localhost/api/v2"), config, deps);
+      expect(hint?.status).toBe(200);
+      expect(await hint?.json()).toMatchObject({ multiAgentModeHintText: "Proactive multi-agent delegation is active." });
+      expect(getMultiAgentModeHintText(path)).toBe("Proactive multi-agent delegation is active.");
+      const cleared = await handleManagementAPI(put({ multiAgentModeHintText: null }), new URL("http://localhost/api/v2"), config, deps);
+      expect(cleared?.status).toBe(200);
+      expect(getMultiAgentModeHintText(path)).toBe(null);
     });
   });
 
@@ -927,6 +1018,15 @@ describe("management API parity surface for the WP2 keys", () => {
       const cleared = await handleManagementAPI(put({ subagentDeveloperInstructions: null }), new URL("http://localhost/api/v2"), config, deps);
       expect(await cleared?.json()).toMatchObject({ subagentDeveloperInstructions: null });
       expect(getSubagentDeveloperInstructions(path)).toBe(null);
+      // multiAgentModeHintText rejects empty/whitespace strings (present empty string would
+      // suppress even the Ultra-derived Proactive message upstream).
+      const hintEmpty = await handleManagementAPI(put({ multiAgentModeHintText: "" }), new URL("http://localhost/api/v2"), config, deps);
+      expect(hintEmpty?.status).toBe(400);
+      const hintSpace = await handleManagementAPI(put({ multiAgentModeHintText: "   " }), new URL("http://localhost/api/v2"), config, deps);
+      expect(hintSpace?.status).toBe(400);
+      const hintSet = await handleManagementAPI(put({ multiAgentModeHintText: "custom" }), new URL("http://localhost/api/v2"), config, deps);
+      expect(hintSet?.status).toBe(200);
+      expect(getMultiAgentModeHintText(path)).toBe("custom");
     });
   });
 
@@ -938,6 +1038,7 @@ describe("management API parity surface for the WP2 keys", () => {
         { agentsMaxDepth: 1.5 },
         { agentsMaxDepth: 2_147_483_648 },
         { subagentDeveloperInstructions: 42 },
+        { multiAgentModeHintText: 42 },
       ]) {
         const res = await handleManagementAPI(put(payload), new URL("http://localhost/api/v2"), config, deps);
         expect(res?.status).toBe(400);
@@ -1129,6 +1230,25 @@ describe("cli surface", () => {
     expect(out).toContain("agents.enabled: false");
     expect(out).toContain("agents.max_depth: 2 (V1-only — ignored while multi_agent_v2 is enabled)");
     expect(out).toContain("subagent_developer_instructions: (unset — children inherit)");
+    expect(out).toContain("multi_agent_mode_hint_text: (unset — effort-derived policy: ultra=proactive, else explicit)");
+  });
+
+  test("mode-hint writes, echoes, and clears via --clear", async () => {
+    const path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\n");
+    const oldCodexHome = process.env.CODEX_HOME;
+    process.env.CODEX_HOME = dirname(path);
+    const logs: string[] = [];
+    const log = { log: (m?: unknown) => { logs.push(String(m)); }, error: (m?: unknown) => { logs.push(String(m)); } };
+    try {
+      expect(await cmdV2(["mode-hint", "Proactive multi-agent delegation is active."], { log })).toBe(0);
+      expect(getMultiAgentModeHintText(path)).toBe("Proactive multi-agent delegation is active.");
+      expect(await cmdV2(["status"], { log })).toBe(0);
+      expect(logs.join("\n")).toContain('multi_agent_mode_hint_text: "Proactive multi-agent delegation is active."');
+      expect(await cmdV2(["mode-hint", "--clear"], { log })).toBe(0);
+      expect(getMultiAgentModeHintText(path)).toBe(null);
+    } finally {
+      if (oldCodexHome === undefined) delete process.env.CODEX_HOME; else process.env.CODEX_HOME = oldCodexHome;
+    }
   });
 
   test("status renders empty-string instructions distinctly from unset", async () => {

From e9fe755f855231cbed12a4c163ac9be9a7317fcc Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Fri, 7 Aug 2026 19:16:52 +0900
Subject: [PATCH 2/9] =?UTF-8?q?fix(v2):=20address=20review=20=E2=80=94=20r?=
 =?UTF-8?q?aw=20CLI=20text,=20multi-line=20TOML=20guard,=20GUI=20draft=20e?=
 =?UTF-8?q?ditor,=20docs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CodeRabbit findings:

- CLI: preserve raw leading/trailing whitespace in mode-hint text; a missing
  argument is a usage error (never a destructive clear); only --clear unsets.
  Reject a present whitespace-only value, matching the API 400 contract.
- features.ts: refuse to edit an existing multi-line TOML string for the hint
  key. scanTomlValueEnd stops at the second quote, so rewriting/removing a
  """...""" value would corrupt the document; convert to single line first.
- GUI: the Ultra mode textarea now keeps a local draft and commits via an
  explicit Save button (remounted on server-value change), so keystrokes are
  never dropped while a PUT is in flight. /api/v2 fetch consolidated into one
  shared loader; initial-load failures surface sub.ultraModeLoadFail instead of
  masquerading as v2-off. V2 requirement is visible text, not only a title attr.
- docs: document ocx v2 mode-hint and the multi_agent_mode_hint_text config key
  (override semantics, --clear, whitespace rejection, v2 requirement).
---
 .../src/content/docs/reference/cli/agents.md  | 14 ++-
 .../docs/reference/configuration/agents.md    | 13 ++-
 .../SubagentDelegationSection.tsx             | 88 +++++++++++++++----
 .../SubagentsWorkspace.tsx                    |  2 +
 gui/src/pages/Subagents.tsx                   | 42 +++++----
 src/cli/v2.ts                                 | 12 ++-
 src/codex/features.ts                         | 10 +++
 tests/codex-v2-gate.test.ts                   | 32 +++++++
 8 files changed, 168 insertions(+), 45 deletions(-)

diff --git a/docs-site/src/content/docs/reference/cli/agents.md b/docs-site/src/content/docs/reference/cli/agents.md
index b98c036aa..6ed6cf9c2 100644
--- a/docs-site/src/content/docs/reference/cli/agents.md
+++ b/docs-site/src/content/docs/reference/cli/agents.md
@@ -17,7 +17,7 @@ surface modes, delegation, effort, and fallback behavior fit together.
 ocx agent subagents set ark/model-a,openai/gpt-5.5
 ```
 
-### `ocx v2 <status|on|off|mode <v1|default|v2>|threads <n>>`
+### `ocx v2 <status|on|off|mode <v1|default|v2>|threads <n>|mode-hint <text|--clear>>`
 
 Manage the Codex `multi_agent_v2` feature flag and the three-state multi-agent surface mode.
 
@@ -30,6 +30,8 @@ Manage the Codex `multi_agent_v2` feature flag and the three-state multi-agent s
 | `mode default` | Respect upstream model surface pins. |
 | `mode v2` | Force all models to v2, enable native v2, and preserve the active thread limit. |
 | `threads <n>` | Set the active v1/v2 thread limit to an integer of at least 1. |
+| `mode-hint <text>` | Set the Proactive delegation hint (Ultra mode) for every model and effort. |
+| `mode-hint --clear` | Remove the hint so the effort-derived policy (ultra = proactive) resumes. |
 
 ```bash
 ocx v2 status
@@ -37,6 +39,8 @@ ocx v2 mode v1
 ocx v2 mode default
 ocx v2 on
 ocx v2 threads 16
+ocx v2 mode-hint "Proactive multi-agent delegation is active."
+ocx v2 mode-hint --clear
 ```
 
 The `mode` subcommand writes `multiAgentMode` to the opencodex config and resyncs the Codex catalog.
@@ -44,6 +48,14 @@ Mode and flag transitions move the current numeric thread limit between the vali
 a failed transition restores the original `config.toml`. Changes apply to new Codex sessions, while
 running sessions keep their pinned surface.
 
+`mode-hint` writes `features.multi_agent_v2.multi_agent_mode_hint_text` in Codex's
+`$CODEX_HOME/config.toml`. The hint overrides codex-rs's effort-derived multi-agent
+policy, so any model and any reasoning effort receives the Proactive delegation
+prompt. It does **not** change reasoning effort itself. A missing argument or a
+whitespace-only value is rejected; only `--clear` removes the hint. This is the
+Ultra mode toggle exposed in the Subagents dashboard, which also requires the
+`multi_agent_v2` feature (see `ocx v2 on`).
+
 ## Combo routing
 
 ### `ocx combo <list|show|set|remove> ...` · `ocx route combo ...`
diff --git a/docs-site/src/content/docs/reference/configuration/agents.md b/docs-site/src/content/docs/reference/configuration/agents.md
index f490626d2..72c1f8945 100644
--- a/docs-site/src/content/docs/reference/configuration/agents.md
+++ b/docs-site/src/content/docs/reference/configuration/agents.md
@@ -23,11 +23,22 @@ routes, and limits delegated work.
 | `effortCap?` | `string` | — | Hard ceiling for qualifying v2 main turns and marked spawned-child turns. Accepts `low` through `ultra`. |
 | `subagentEffortCap?` | `string` | — | Additional ceiling for spawned-child turns only. When both caps apply, the lower wins. |
 
-Manage the surface with the dashboard or `ocx v2 status|on|off|mode <v1|default|v2>|threads <n>`.
+Manage the surface with the dashboard or
+`ocx v2 status|on|off|mode <v1|default|v2>|threads <n>|mode-hint <text|--clear>`.
 Mode changes apply to new sessions. `maxConcurrentThreadsPerSession` is a `PUT /api/v2` field, not a
 `config.json` key; `ocx v2 threads <n>` writes `max_concurrent_threads_per_session` under
 `[features.multi_agent_v2]` in Codex's `$CODEX_HOME/config.toml` after v2 is enabled.
 
+**Ultra mode** (the Subagents dashboard toggle, `PUT /api/v2` field
+`multiAgentModeHintText`, and `ocx v2 mode-hint`) writes
+`features.multi_agent_v2.multi_agent_mode_hint_text` in Codex's
+`$CODEX_HOME/config.toml`. The hint overrides codex-rs's effort-derived multi-agent
+policy, so any model and any reasoning effort receives the Proactive delegation
+prompt; it does **not** change reasoning effort. A `null` value removes the key so
+the effort-derived policy (ultra = proactive, otherwise explicit) resumes; empty or
+whitespace-only values are rejected because a present empty override would suppress
+even the ultra-derived Proactive message. Requires the `multi_agent_v2` feature.
+
 The management API exposes `GET`/`PUT /api/v2`, `/api/injection-model`, `/api/effort-caps`,
 `/api/subagent-models`, and `/api/subagent-model-fallback`. Injection-model updates are partial;
 the custom prompt is the `prompt` field on that API.
diff --git a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
index f19a7091f..341e7a24e 100644
--- a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
+++ b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
@@ -6,6 +6,7 @@
  * better next to the roster it affects: the roster picks who may be called, this picks who
  * gets called first.
  */
+import { useState } from "react";
 import { Select } from "../../ui";
 import { useT } from "../../i18n/shared";
 import { formatNamespacedModelId } from "../../provider-icons";
@@ -22,6 +23,7 @@ export interface SubagentDelegationSectionProps {
   saving: boolean;
   onSave: (patch: DelegationPatch) => void;
   ultraMode: UltraModeState;
+  ultraSaving: boolean;
   onUltraModeSave: (patch: UltraModePatch) => void;
 }
 
@@ -35,6 +37,7 @@ export default function SubagentDelegationSection({
   saving,
   onSave,
   ultraMode,
+  ultraSaving,
   onUltraModeSave,
 }: SubagentDelegationSectionProps) {
   const t = useT();
@@ -116,38 +119,89 @@ export default function SubagentDelegationSection({
           type="button"
           className={`switch ${ultraOn ? "on" : ""}`}
           onClick={() => onUltraModeSave({ multiAgentModeHintText: ultraOn ? null : ULTRA_MODE_PRESET })}
-          disabled={saving || !ultraMode.multiAgentV2Enabled}
+          disabled={saving || ultraSaving || !ultraMode.multiAgentV2Enabled}
           aria-label={t("sub.ultraMode")}
           aria-pressed={ultraOn}
-          title={ultraMode.multiAgentV2Enabled ? undefined : t("sub.ultraModeV2Required")}
         >
           <span className="knob" />
         </button>
+        {!ultraMode.multiAgentV2Enabled && (
+          <div className="muted setting-hint">{t("sub.ultraModeV2Required")}</div>
+        )}
       </div>
       {ultraOn && (
         <div className="swi-delegation-row swi-ultra-mode-editor">
-          <textarea
-            className="input swi-ultra-mode-textarea"
-            value={ultraMode.hintText ?? ""}
-            onChange={e => onUltraModeSave({ multiAgentModeHintText: e.target.value || null })}
-            disabled={saving}
-            rows={4}
-            aria-label={t("sub.ultraModeText")}
+          <UltraModeEditor
+            key={ultraMode.hintText}
+            initialHint={ultraMode.hintText ?? ""}
+            disabled={saving || ultraSaving}
+            onSave={onUltraModeSave}
+            preset={ULTRA_MODE_PRESET}
+            labels={{
+              text: t("sub.ultraModeText"),
+              preset: t("sub.ultraModePreset"),
+              save: t("common.save"),
+            }}
           />
-          <button
-            type="button"
-            className="btn btn-ghost btn-sm"
-            onClick={() => onUltraModeSave({ multiAgentModeHintText: ULTRA_MODE_PRESET })}
-            disabled={saving}
-          >
-            {t("sub.ultraModePreset")}
-          </button>
         </div>
       )}
     </div>
   );
 }
 
+/**
+ * Local-draft editor for the Ultra mode hint. Drafts are owned here and committed
+ * explicitly; the parent remounts this editor (via `key`) whenever the committed
+ * server value changes, so a stale draft never survives a reload or toggle flip.
+ */
+function UltraModeEditor({
+  initialHint,
+  disabled,
+  onSave,
+  preset,
+  labels,
+}: {
+  initialHint: string;
+  disabled: boolean;
+  onSave: (patch: UltraModePatch) => void;
+  preset: string;
+  labels: { text: string; preset: string; save: string };
+}) {
+  const [draft, setDraft] = useState(initialHint);
+  const commit = () => {
+    if (draft.trim().length === 0) return;
+    onSave({ multiAgentModeHintText: draft });
+  };
+  return (
+    <>
+      <textarea
+        className="input swi-ultra-mode-textarea"
+        value={draft}
+        onChange={e => setDraft(e.target.value)}
+        disabled={disabled}
+        rows={4}
+        aria-label={labels.text}
+      />
+      <button
+        type="button"
+        className="btn btn-ghost btn-sm"
+        onClick={() => setDraft(preset)}
+        disabled={disabled}
+      >
+        {labels.preset}
+      </button>
+      <button
+        type="button"
+        className="btn btn-primary btn-sm"
+        onClick={commit}
+        disabled={disabled || draft.trim().length === 0}
+      >
+        {labels.save}
+      </button>
+    </>
+  );
+}
+
 /** Canonical Proactive delegation text mirrored from codex-rs (multi_agent_mode_instructions.rs). */
 export const ULTRA_MODE_PRESET =
   "Proactive multi-agent delegation is active. Any earlier instruction requiring an explicit user request before spawning sub-agents no longer applies. Use sub-agents when parallel work would materially improve speed or quality. This mode remains active until a later multi-agent mode developer message changes it.";
diff --git a/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx b/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
index bdddcb0ca..266efcfe8 100644
--- a/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
+++ b/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
@@ -46,6 +46,7 @@ export interface SubagentsWorkspaceProps {
     saving: boolean;
     onSave: (patch: DelegationPatch) => void;
     ultraMode: UltraModeState;
+    ultraSaving: boolean;
     onUltraModeSave: (patch: UltraModePatch) => void;
   };
 }
@@ -227,6 +228,7 @@ export default function SubagentsWorkspace({
             saving={delegation.saving}
             onSave={delegation.onSave}
             ultraMode={delegation.ultraMode}
+            ultraSaving={delegation.ultraSaving}
             onUltraModeSave={delegation.onUltraModeSave}
           />
         </section>
diff --git a/gui/src/pages/Subagents.tsx b/gui/src/pages/Subagents.tsx
index 7698d10f4..686ada35b 100644
--- a/gui/src/pages/Subagents.tsx
+++ b/gui/src/pages/Subagents.tsx
@@ -28,35 +28,32 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   const [ultraMode, setUltraMode] = useState<UltraModeState>({ enabled: false, hintText: null, multiAgentV2Enabled: false });
   const [ultraSaving, setUltraSaving] = useState(false);
 
-  // Load /api/v2 state (multi-agent v2 flag + mode hint) once on mount.
+  // Shared loader for /api/v2 state (multi-agent v2 flag + mode hint). Initial-load
+  // failures surface sub.ultraModeLoadFail; refresh failures are rethrown so
+  // saveUltraMode can report them against the save action.
   const loadUltraMode = useCallback(async () => {
-    try {
-      const res = await fetch(`${apiBase}/api/v2`);
-      const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
-      if (!data) return;
-      setUltraMode({
-        enabled: data.enabled ?? false,
-        hintText: data.multiAgentModeHintText ?? null,
-        multiAgentV2Enabled: data.enabled ?? false,
-      });
-    } catch { /* keep defaults; panel still renders */ }
+    const res = await fetch(`${apiBase}/api/v2`);
+    const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
+    if (!data) return;
+    setUltraMode({
+      enabled: data.enabled ?? false,
+      hintText: data.multiAgentModeHintText ?? null,
+      multiAgentV2Enabled: data.enabled ?? false,
+    });
   }, [apiBase, t]);
 
   useEffect(() => {
     let cancelled = false;
     void (async () => {
-      const res = await fetch(`${apiBase}/api/v2`);
-      const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
-      if (cancelled) return;
-      if (!data) return;
-      setUltraMode({
-        enabled: data.enabled ?? false,
-        hintText: data.multiAgentModeHintText ?? null,
-        multiAgentV2Enabled: data.enabled ?? false,
-      });
-    })().catch(() => { /* keep defaults; panel still renders */ });
+      await loadUltraMode();
+    })().catch(() => {
+      if (!cancelled) {
+        setOk(false);
+        setStatus(t("sub.ultraModeLoadFail"));
+      }
+    });
     return () => { cancelled = true; };
-  }, [apiBase, t]);
+  }, [loadUltraMode, t]);
 
   const saveUltraMode = async (patch: UltraModePatch) => {
     if (ultraSaving) return;
@@ -186,6 +183,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
           saving: delegation.saving,
           onSave: patch => { void delegation.save(patch); },
           ultraMode,
+          ultraSaving,
           onUltraModeSave: patch => { void saveUltraMode(patch); },
         }}
       />
diff --git a/src/cli/v2.ts b/src/cli/v2.ts
index 67b6c0ec6..b65ddc54d 100644
--- a/src/cli/v2.ts
+++ b/src/cli/v2.ts
@@ -129,8 +129,12 @@ export async function cmdV2(args: string[], deps: V2CliDeps = {}, findPort?: ()
     return 0;
   }
   if (verb === "mode-hint") {
-    const flag = (args[1] ?? "").trim();
-    if (flag === "--clear" || flag === "") {
+    const value = args[1];
+    if (value === undefined) {
+      log.error("v2 mode-hint: pass the hint text, or --clear to unset it.");
+      return 1;
+    }
+    if (value === "--clear") {
       const result = setMultiAgentModeHintText(null);
       if (!result.ok) {
         log.error(`v2 mode-hint: ${result.error}`);
@@ -141,11 +145,11 @@ export async function cmdV2(args: string[], deps: V2CliDeps = {}, findPort?: ()
         : "multi_agent_mode_hint_text already unset — nothing to do.");
       return 0;
     }
-    if (flag.startsWith("-")) {
+    if (value.trim().length === 0 || value.startsWith("-")) {
       log.error("v2 mode-hint: pass the hint text, or --clear to unset it.");
       return 1;
     }
-    const result = setMultiAgentModeHintText(flag);
+    const result = setMultiAgentModeHintText(value);
     if (!result.ok) {
       log.error(`v2 mode-hint: ${result.error}`);
       return 1;
diff --git a/src/codex/features.ts b/src/codex/features.ts
index 29c8bb31b..d112621d2 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -731,6 +731,16 @@ function setV2StringField(key: string, value: string | null, configPath?: string
   if (content === null) return { ok: false, error: `config.toml not readable at ${path}` };
   const encoded = value === null ? null : encodeTomlBasicString(value);
 
+  // Multiline TOML strings ("""...""" / '''...''') span multiple lines and the
+  // single-line table editor cannot rewrite or remove them without corrupting
+  // the document (scanTomlValueEnd stops at the second quote). Refuse the edit
+  // rather than write invalid TOML; the user can convert the value to a single
+  // line first. Single-line literals and basic strings are unaffected.
+  const multilinePrefix = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*("""|''')`, "m");
+  if (multilinePrefix.test(content)) {
+    return { ok: false, error: `multi-line TOML string for ${key} is not editable; convert it to a single-line string first` };
+  }
+
   if (tomlTableBody(content, "features.multi_agent_v2") !== null) {
     const next = editScalarInTable(content, "features.multi_agent_v2", key, encoded);
     if (next === content) return { ok: true, changed: false };
diff --git a/tests/codex-v2-gate.test.ts b/tests/codex-v2-gate.test.ts
index 37678ae65..1698e01c1 100644
--- a/tests/codex-v2-gate.test.ts
+++ b/tests/codex-v2-gate.test.ts
@@ -442,6 +442,14 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
     expect(out).toContain(`multi_agent_mode_hint_text = "${PRESET}"\r\n`);
     expect(out).not.toMatch(/[^\r]\n/);
   });
+
+  test("writer refuses to edit an existing multi-line TOML string (would corrupt the doc)", () => {
+    const path = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"\"\"\nProactive\nmulti-line\n\"\"\"\n");
+    const before = readFileSync(path, "utf8");
+    expect(setMultiAgentModeHintText(PRESET, path)).toMatchObject({ ok: false });
+    expect(setMultiAgentModeHintText(null, path)).toMatchObject({ ok: false });
+    expect(readFileSync(path, "utf8")).toBe(before);
+  });
 });
 
 describe("thread-limit-preserving v1/v2 transition", () => {
@@ -1251,6 +1259,30 @@ describe("cli surface", () => {
     }
   });
 
+  test("mode-hint preserves raw whitespace in nonblank hints and rejects blank/missing args", async () => {
+    const path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\n");
+    const oldCodexHome = process.env.CODEX_HOME;
+    process.env.CODEX_HOME = dirname(path);
+    const logs: string[] = [];
+    const log = { log: (m?: unknown) => { logs.push(String(m)); }, error: (m?: unknown) => { logs.push(String(m)); } };
+    try {
+      // Raw leading/trailing whitespace is preserved, matching the API contract.
+      expect(await cmdV2(["mode-hint", "  spaced hint  "], { log })).toBe(0);
+      expect(getMultiAgentModeHintText(path)).toBe("  spaced hint  ");
+      // A present whitespace-only value is rejected (API rejects it with 400).
+      expect(await cmdV2(["mode-hint", "   "], { log })).toBe(1);
+      expect(getMultiAgentModeHintText(path)).toBe("  spaced hint  ");
+      // A missing argument is a usage error, never a destructive clear.
+      expect(await cmdV2(["mode-hint"], { log })).toBe(1);
+      expect(getMultiAgentModeHintText(path)).toBe("  spaced hint  ");
+      // Explicit --clear still removes the hint.
+      expect(await cmdV2(["mode-hint", "--clear"], { log })).toBe(0);
+      expect(getMultiAgentModeHintText(path)).toBe(null);
+    } finally {
+      if (oldCodexHome === undefined) delete process.env.CODEX_HOME; else process.env.CODEX_HOME = oldCodexHome;
+    }
+  });
+
   test("status renders empty-string instructions distinctly from unset", async () => {
     const path = fixtureConfig("[features.multi_agent_v2]\nenabled = false\nsubagent_developer_instructions = \"\"\n");
     const oldCodexHome = process.env.CODEX_HOME;

From 5a55b833b6d2b8464b5d5a52a145329fe2fab28a Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Fri, 7 Aug 2026 19:22:26 +0900
Subject: [PATCH 3/9] docs: add Ultra mode GUI screenshot for the Subagents
 page

---
 .../public/assets/ultra-mode-subagents.png      | Bin 0 -> 72831 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 docs-site/public/assets/ultra-mode-subagents.png

diff --git a/docs-site/public/assets/ultra-mode-subagents.png b/docs-site/public/assets/ultra-mode-subagents.png
new file mode 100644
index 0000000000000000000000000000000000000000..0a75c75b84b35802fc7844bf30f242f74b7f7485
GIT binary patch
literal 72831
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
CBXt=7

literal 0
HcmV?d00001


From a54eb5251eef7fca684361f42c80edeb1b614880 Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Fri, 7 Aug 2026 19:31:17 +0900
Subject: [PATCH 4/9] fix(gui): abort stale /api/v2 loads on unmount
 (CodeRabbit Major)

loadUltraMode now accepts an AbortSignal; the mount effect aborts it on
cleanup so a pending fetch cannot apply state after unmount or after a
refresh superseded it.
---
 gui/src/pages/Subagents.tsx | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/gui/src/pages/Subagents.tsx b/gui/src/pages/Subagents.tsx
index 686ada35b..660c42f93 100644
--- a/gui/src/pages/Subagents.tsx
+++ b/gui/src/pages/Subagents.tsx
@@ -31,10 +31,11 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   // Shared loader for /api/v2 state (multi-agent v2 flag + mode hint). Initial-load
   // failures surface sub.ultraModeLoadFail; refresh failures are rethrown so
   // saveUltraMode can report them against the save action.
-  const loadUltraMode = useCallback(async () => {
-    const res = await fetch(`${apiBase}/api/v2`);
+  const loadUltraMode = useCallback(async (signal?: AbortSignal) => {
+    const res = await fetch(`${apiBase}/api/v2`, { signal });
     const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
     if (!data) return;
+    if (signal?.aborted) return;
     setUltraMode({
       enabled: data.enabled ?? false,
       hintText: data.multiAgentModeHintText ?? null,
@@ -43,16 +44,16 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   }, [apiBase, t]);
 
   useEffect(() => {
-    let cancelled = false;
+    const controller = new AbortController();
     void (async () => {
-      await loadUltraMode();
+      await loadUltraMode(controller.signal);
     })().catch(() => {
-      if (!cancelled) {
+      if (!controller.signal.aborted) {
         setOk(false);
         setStatus(t("sub.ultraModeLoadFail"));
       }
     });
-    return () => { cancelled = true; };
+    return () => { controller.abort(); };
   }, [loadUltraMode, t]);
 
   const saveUltraMode = async (patch: UltraModePatch) => {

From bb2ef79c43da63e9097d1fa37a7322855eb42111 Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Fri, 7 Aug 2026 19:42:16 +0900
Subject: [PATCH 5/9] =?UTF-8?q?fix(v2):=20address=20second=20review=20roun?=
 =?UTF-8?q?d=20=E2=80=94=20multiline=20decode,=20runtime=20probe,=20GUI=20?=
 =?UTF-8?q?retry/clear?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Codex + CodeRabbit findings:

- features.ts: scanTomlValueEnd/decodeTomlStringToken now read complete
  multi-line TOML strings ("""...""" and '''...''') so the getter returns
  the real hint instead of an empty string. probeCodexSupportsModeHint checks
  the installed native codex binary for the multi_agent_mode_hint_text key
  (following shim -> npm wrapper -> vendor binary) and refuses writes on older
  builds that reject the unknown config member.
- cli/help.ts: advertise mode-hint in the v2 usage and global synopsis.
- GUI: empty/whitespace hint renders as OFF; clearing stays available when v2
  is disabled (stale hint would otherwise re-activate); load failures surface
  a retry; a successful save clears stale error status and confirms.
- tests: multi-line decode for basic and literal strings.
---
 .../SubagentDelegationSection.tsx             |  24 ++-
 .../SubagentsWorkspace.tsx                    |   4 +
 gui/src/i18n/de.ts                            |   1 +
 gui/src/i18n/en.ts                            |   1 +
 gui/src/i18n/ja.ts                            |   1 +
 gui/src/i18n/ko.ts                            |   1 +
 gui/src/i18n/ru.ts                            |   1 +
 gui/src/i18n/zh.ts                            |   1 +
 gui/src/pages/Subagents.tsx                   |   8 +
 src/cli/help.ts                               |   5 +-
 src/codex/features.ts                         | 143 +++++++++++++++++-
 tests/codex-v2-gate.test.ts                   |   7 +
 12 files changed, 191 insertions(+), 6 deletions(-)

diff --git a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
index 341e7a24e..035dbefb5 100644
--- a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
+++ b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
@@ -25,6 +25,8 @@ export interface SubagentDelegationSectionProps {
   ultraMode: UltraModeState;
   ultraSaving: boolean;
   onUltraModeSave: (patch: UltraModePatch) => void;
+  ultraLoadFailed: boolean;
+  onUltraModeRetry: () => void;
 }
 
 export default function SubagentDelegationSection({
@@ -39,12 +41,28 @@ export default function SubagentDelegationSection({
   ultraMode,
   ultraSaving,
   onUltraModeSave,
+  ultraLoadFailed,
+  onUltraModeRetry,
 }: SubagentDelegationSectionProps) {
   const t = useT();
-  const ultraOn = ultraMode.hintText !== null;
+  // A present empty/whitespace hint is an upstream override that suppresses the
+  // Proactive message, so it must render as OFF (and the toggle can install the
+  // preset). Only a nonblank hint is "on".
+  const ultraOn = (ultraMode.hintText ?? "").trim().length > 0;
 
   return (
     <div className="swi-delegation">
+      {ultraLoadFailed && (
+        <div className="swi-delegation-row">
+          <div className="setting-copy">
+            <div className="font-semibold">{t("sub.ultraMode")}</div>
+            <div className="muted setting-hint">{t("sub.ultraModeLoadFail")}</div>
+          </div>
+          <button type="button" className="btn btn-ghost btn-sm" onClick={onUltraModeRetry}>
+            {t("common.retry")}
+          </button>
+        </div>
+      )}
       <div className="swi-delegation-row">
         <div className="setting-copy">
           <div className="font-semibold">{t("sub.delegation.model")}</div>
@@ -119,7 +137,9 @@ export default function SubagentDelegationSection({
           type="button"
           className={`switch ${ultraOn ? "on" : ""}`}
           onClick={() => onUltraModeSave({ multiAgentModeHintText: ultraOn ? null : ULTRA_MODE_PRESET })}
-          disabled={saving || ultraSaving || !ultraMode.multiAgentV2Enabled}
+          // Turning OFF (clear) is always safe, even when v2 is disabled — a stale
+          // hint would otherwise silently re-activate on the next v2 enable.
+          disabled={saving || ultraSaving || (!ultraOn && !ultraMode.multiAgentV2Enabled)}
           aria-label={t("sub.ultraMode")}
           aria-pressed={ultraOn}
         >
diff --git a/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx b/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
index 266efcfe8..862467da0 100644
--- a/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
+++ b/gui/src/components/subagents-workspace/SubagentsWorkspace.tsx
@@ -48,6 +48,8 @@ export interface SubagentsWorkspaceProps {
     ultraMode: UltraModeState;
     ultraSaving: boolean;
     onUltraModeSave: (patch: UltraModePatch) => void;
+    ultraLoadFailed: boolean;
+    onUltraModeRetry: () => void;
   };
 }
 
@@ -230,6 +232,8 @@ export default function SubagentsWorkspace({
             ultraMode={delegation.ultraMode}
             ultraSaving={delegation.ultraSaving}
             onUltraModeSave={delegation.onUltraModeSave}
+            ultraLoadFailed={delegation.ultraLoadFailed}
+            onUltraModeRetry={delegation.onUltraModeRetry}
           />
         </section>
       </div>
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index a3648a388..bd2a4c174 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -574,6 +574,7 @@ export const de: Record<TKey, string> = {
   "sub.ultraModePreset": "Voreinstellung wiederherstellen",
   "sub.ultraModeLoadFail": "Ultra-Modus-Einstellungen konnten nicht geladen werden — läuft der Proxy?",
   "sub.ultraModeSaveFail": "Ultra-Modus-Einstellungen konnten nicht gespeichert werden",
+  "sub.ultraModeSaved": "Ultra-Modus gespeichert. Gilt für neue Codex-Sitzungen.",
   "logs.title": "Anfrage-Protokolle",
   "logs.tabLogs": "Protokolle",
   "logs.tabDebug": "Diagnose",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index c8fa0358f..159f0bf85 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -595,6 +595,7 @@ export const en = {
   "sub.ultraModePreset": "Restore preset",
   "sub.ultraModeLoadFail": "Failed to load Ultra mode settings — is the proxy running?",
   "sub.ultraModeSaveFail": "Failed to save Ultra mode settings",
+  "sub.ultraModeSaved": "Ultra mode saved. Applies to new Codex sessions.",
   "sub.workspace.removeFromFeatured": "Remove {m} from featured",
   "sub.workspace.selectModel": "Select a model",
   "sub.workspace.selectModelDesc": "Pick a model from the list to see details and feature it for spawn_agent.",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 274a41d1c..72b94da1f 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -557,6 +557,7 @@ export const ja: Record<TKey, string> = {
   "sub.ultraModePreset": "プリセットを復元",
   "sub.ultraModeLoadFail": "ウルトラモード設定を読み込めませんでした — プロキシは実行中ですか？",
   "sub.ultraModeSaveFail": "ウルトラモード設定の保存に失敗しました",
+  "sub.ultraModeSaved": "ウルトラモードを保存しました。新しい Codex セッションから適用されます。",
 
   // logs
   "logs.title": "リクエストログ",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index ff3734efa..a3e9051fd 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -591,6 +591,7 @@ export const ko: Record<TKey, string> = {
   "sub.ultraModePreset": "프리셋 복원",
   "sub.ultraModeLoadFail": "울트라 모드 설정을 불러오지 못했습니다 — 프록시가 실행 중인가요?",
   "sub.ultraModeSaveFail": "울트라 모드 설정 저장에 실패했습니다",
+  "sub.ultraModeSaved": "울트라 모드가 저장되었습니다. 새 Codex 세션부터 적용됩니다.",
 
   // logs
   "logs.title": "요청 로그",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index b95c32895..aa900c6fa 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -589,6 +589,7 @@ export const ru: Record<TKey, string> = {
   "sub.ultraModePreset": "Восстановить пресет",
   "sub.ultraModeLoadFail": "Не удалось загрузить настройки ультра-режима — работает ли прокси?",
   "sub.ultraModeSaveFail": "Не удалось сохранить настройки ультра-режима",
+  "sub.ultraModeSaved": "Ультра-режим сохранён. Применяется к новым сеансам Codex.",
 
   // logs
   "logs.title": "Журнал запросов",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 354807a1c..4ed90d31a 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -584,6 +584,7 @@ export const zh: Record<TKey, string> = {
   "sub.ultraModePreset": "恢复预设",
   "sub.ultraModeLoadFail": "无法加载超级模式设置 — 代理是否在运行？",
   "sub.ultraModeSaveFail": "保存超级模式设置失败",
+  "sub.ultraModeSaved": "超级模式已保存。适用于新的 Codex 会话。",
 
   // logs
   "logs.title": "请求日志",
diff --git a/gui/src/pages/Subagents.tsx b/gui/src/pages/Subagents.tsx
index 660c42f93..67f62d20c 100644
--- a/gui/src/pages/Subagents.tsx
+++ b/gui/src/pages/Subagents.tsx
@@ -27,6 +27,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   const delegation = useSubagentDelegation(apiBase);
   const [ultraMode, setUltraMode] = useState<UltraModeState>({ enabled: false, hintText: null, multiAgentV2Enabled: false });
   const [ultraSaving, setUltraSaving] = useState(false);
+  const [ultraLoadFailed, setUltraLoadFailed] = useState(false);
 
   // Shared loader for /api/v2 state (multi-agent v2 flag + mode hint). Initial-load
   // failures surface sub.ultraModeLoadFail; refresh failures are rethrown so
@@ -36,6 +37,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
     const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
     if (!data) return;
     if (signal?.aborted) return;
+    setUltraLoadFailed(false);
     setUltraMode({
       enabled: data.enabled ?? false,
       hintText: data.multiAgentModeHintText ?? null,
@@ -50,6 +52,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
     })().catch(() => {
       if (!controller.signal.aborted) {
         setOk(false);
+        setUltraLoadFailed(true);
         setStatus(t("sub.ultraModeLoadFail"));
       }
     });
@@ -59,6 +62,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   const saveUltraMode = async (patch: UltraModePatch) => {
     if (ultraSaving) return;
     setUltraSaving(true);
+    setStatus("");
     try {
       const res = await fetch(`${apiBase}/api/v2`, {
         method: "PUT",
@@ -67,6 +71,8 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
       });
       await readJsonOrThrow(res, t("sub.ultraModeSaveFail"));
       await loadUltraMode();
+      setOk(true);
+      setStatus(t("sub.ultraModeSaved"));
     } catch (error) {
       setOk(false);
       setStatus(error instanceof Error && error.message ? error.message : t("sub.networkError"));
@@ -186,6 +192,8 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
           ultraMode,
           ultraSaving,
           onUltraModeSave: patch => { void saveUltraMode(patch); },
+          ultraLoadFailed,
+          onUltraModeRetry: () => { void loadUltraMode().catch(() => { setOk(false); setUltraLoadFailed(true); setStatus(t("sub.ultraModeLoadFail")); }); },
         }}
       />
     </>
diff --git a/src/cli/help.ts b/src/cli/help.ts
index 2a8f919bb..49e384b35 100644
--- a/src/cli/help.ts
+++ b/src/cli/help.ts
@@ -236,13 +236,14 @@ const helpEntries: Record<string, HelpEntry> = {
     summary: "Stop the proxy and restart it (background). Equivalent to stop + ensure.",
   },
   v2: {
-    usage: "ocx v2 <status|on|off|mode <v1|default|v2>|threads <n>>",
+    usage: "ocx v2 <status|on|off|mode <v1|default|v2>|threads <n>|mode-hint <text|--clear>>",
     summary: "Toggle the Codex multi_agent_v2 feature (multi-agent surface).",
     details: [
       "status                Show flag, multi-agent mode, and thread limit.",
       "on | off              Enable/disable multi_agent_v2 (catalog resyncs).",
       "mode <v1|default|v2>  Force all models to one surface, or respect upstream pins.",
       "threads <n>           Set max_concurrent_threads_per_session (integer >= 1).",
+      "mode-hint <text|--clear>  Set/clear the Proactive delegation hint (Ultra mode).",
       "Flips preserve the active thread limit while moving between v1/v2 modes.",
     ],
   },
@@ -317,7 +318,7 @@ Usage:
   ocx gui                     Open the opencodex dashboard
   ocx update [--tag <tag>]    Update opencodex (keeps preview installs on @preview)
   ocx restart                  Stop and restart the proxy
-  ocx v2 <sub>                multi_agent_v2 surface (status|on|off|mode|threads)
+  ocx v2 <sub>                multi_agent_v2 surface (status|on|off|mode|threads|mode-hint)
   ocx health [--json]          Check proxy health (exit 0=healthy, 1=not)
   ocx ready [--json] [--wait [--timeout <s>]]  Check post-sync readiness (exit 0 only when ready)
   ocx provider <sub>          Providers, connectivity, quota, and selected models
diff --git a/src/codex/features.ts b/src/codex/features.ts
index d112621d2..2c0f88385 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -31,11 +31,12 @@
  * `configPath` parameter without fighting the module-load-time const in paths.ts.
  */
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { realpathSync } from "node:fs";
 import { AtomicWriteResidualTempError, AtomicWriteSecretResidualError, atomicWriteFile, expandUserPath } from "../config";
 import { forgetEphemeralSecretPath } from "../lib/windows-secret-acl";
 import { CODEX_CONFIG_PATH } from "./paths";
+import { resolveAndPersistCodexRuntime } from "./runtime";
 
 /** Upstream codex-rs feature key: allow `request_user_input` in Default mode. */
 export const DEFAULT_MODE_REQUEST_USER_INPUT_FEATURE_KEY = "default_mode_request_user_input";
@@ -451,11 +452,26 @@ function encodeTomlBasicString(value: string): string {
  */
 function decodeTomlStringToken(token: string): string | null {
   if (token.length < 2) return null;
+  // Multi-line literal string: `'''...'''` verbatim (backslashes not special).
+  if (token.startsWith("'''")) {
+    return token.endsWith("'''") && token.length >= 6
+      ? token.slice(3, -3)
+      : null;
+  }
+  // Multi-line basic string: `"""..."""` with escapes.
+  if (token.startsWith('"""')) {
+    if (!token.endsWith('"""') || token.length < 6) return null;
+    return decodeBasicStringBody(token.slice(3, -3));
+  }
   if (token.startsWith("'")) {
     return token.endsWith("'") ? token.slice(1, -1) : null;
   }
   if (!token.startsWith('"') || !token.endsWith('"')) return null;
-  const body = token.slice(1, -1);
+  return decodeBasicStringBody(token.slice(1, -1));
+}
+
+/** Unescape the body of a TOML basic string (single- or multi-line). */
+function decodeBasicStringBody(body: string): string | null {
   let out = "";
   for (let i = 0; i < body.length; i++) {
     const ch = body[i];
@@ -499,6 +515,19 @@ function scanTomlValueEnd(text: string, start: number): number {
   while (i < text.length && (text[i] === " " || text[i] === "\t")) i++;
   const first = text[i];
   if (first === '"') {
+    // Multi-line basic string: `"""..."""`. The closing delimiter is a triple
+    // quote; a single or double quote inside the body does not end the token.
+    if (text[i + 1] === '"' && text[i + 2] === '"') {
+      i += 3;
+      while (i < text.length) {
+        if (text[i] === "\\") { i += 2; continue; }
+        if (text[i] === '"' && text[i + 1] === '"' && text[i + 2] === '"') {
+          return i + 3;
+        }
+        i++;
+      }
+      return text.length;
+    }
     i++;
     while (i < text.length) {
       if (text[i] === "\\") { i += 2; continue; }
@@ -508,6 +537,12 @@ function scanTomlValueEnd(text: string, start: number): number {
     return text.length;
   }
   if (first === "'") {
+    // Multi-line literal string: `'''...'''`.
+    if (text[i + 1] === "'" && text[i + 2] === "'") {
+      i += 3;
+      const close = text.indexOf("'''", i);
+      return close === -1 ? text.length : close + 3;
+    }
     const close = text.indexOf("'", i + 1);
     return close === -1 ? text.length : close + 1;
   }
@@ -826,9 +861,113 @@ export function setSubagentDeveloperInstructions(value: string | null, configPat
  * so the key spelling must match codex-rs exactly.
  */
 export function setMultiAgentModeHintText(value: string | null, configPath?: string): ConfigEditResult {
+  // The upstream `multi_agent_mode_hint_text` key is newer than the v2 config
+  // surface opencodex already manages; an older Codex build rejects the unknown
+  // member (`#[serde(deny_unknown_fields)]`) and fails to start. Probe the
+  // installed runtime binary for the key string and refuse the write when the
+  // binary provably lacks it. A probe that cannot run (missing binary,
+  // unreadable file) does not block: that is the test/hermetic path and the
+  // headless runtime fallback.
+  const probe = probeCodexSupportsModeHint();
+  if (probe === false) {
+    return {
+      ok: false,
+      error: "installed Codex does not support multi_agent_mode_hint_text; update Codex first",
+    };
+  }
   return setV2StringField("multi_agent_mode_hint_text", value, configPath);
 }
 
+/**
+ * True when the installed Codex runtime binary contains the
+ * `multi_agent_mode_hint_text` config key, false when it provably does not, and
+ * null when the probe could not run (missing binary, unreadable file).
+ */
+export function probeCodexSupportsModeHint(): boolean | null {
+  try {
+    const runtime = resolveAndPersistCodexRuntime({ env: process.env }).runtime;
+    const candidates = codexNativeBinaryCandidates(runtime.command);
+    let sawBinary = false;
+    for (const candidate of candidates) {
+      try {
+        if (!existsSync(candidate)) continue;
+        const buf = readFileSync(candidate);
+        sawBinary = true;
+        if (buf.includes(Buffer.from("multi_agent_mode_hint_text", "utf8"))) {
+          return true;
+        }
+      } catch {
+        continue;
+      }
+    }
+    // At least one real binary was inspected and none contained the key.
+    return sawBinary ? false : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Candidate native codex binaries to probe. The resolved `command` may be the
+ * opencodex shim or the npm JS wrapper (`codex.opencodex-real`), neither of
+ * which embeds the Rust config schema. The real binary ships under the
+ * platform package's `vendor/<triple>/bin/codex`; also try adjacent wrappers.
+ */
+function codexNativeBinaryCandidates(command: string): string[] {
+  const out: string[] = [command];
+  // The opencodex autostart shim (`codex`) forwards to `codex.opencodex-real`
+  // (the npm JS wrapper). Add the real wrapper's resolved native binary when it
+  // is discoverable on PATH, so probing the shim still reaches the Rust binary.
+  const pathDirs = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+  for (const dir of pathDirs) {
+    const wrapper = join(dir, process.platform === "win32" ? "codex.opencodex-real.cmd" : "codex.opencodex-real");
+    if (existsSync(wrapper)) {
+      out.push(wrapper);
+      try {
+        const real = realpathSync(wrapper);
+        const pkgRoot = resolve(real, "..", "..");
+        out.push(join(pkgRoot, "node_modules", "@openai", "codex-darwin-arm64", "vendor", "aarch64-apple-darwin", "bin", "codex"));
+        out.push(join(pkgRoot, "node_modules", "@openai", "codex-darwin-x64", "vendor", "x86_64-apple-darwin", "bin", "codex"));
+        out.push(join(pkgRoot, "node_modules", "@openai", "codex-linux-x64", "vendor", "x86_64-unknown-linux-musl", "bin", "codex"));
+        out.push(join(pkgRoot, "node_modules", "@openai", "codex-linux-arm64", "vendor", "aarch64-unknown-linux-musl", "bin", "codex"));
+      } catch {
+        // keep the wrapper as a candidate
+      }
+    }
+  }
+  const managedRoot = process.env.CODEX_MANAGED_PACKAGE_ROOT;
+  if (managedRoot) {
+    out.push(
+      join(managedRoot, "node_modules", "@openai", "codex-darwin-arm64", "vendor", "aarch64-apple-darwin", "bin", "codex"),
+      join(managedRoot, "node_modules", "@openai", "codex-darwin-x64", "vendor", "x86_64-apple-darwin", "bin", "codex"),
+      join(managedRoot, "node_modules", "@openai", "codex-linux-x64", "vendor", "x86_64-unknown-linux-musl", "bin", "codex"),
+      join(managedRoot, "node_modules", "@openai", "codex-linux-arm64", "vendor", "aarch64-unknown-linux-musl", "bin", "codex"),
+      join(managedRoot, "node_modules", "@openai", "codex-win32-x64", "vendor", "x86_64-pc-windows-msvc", "bin", "codex.exe"),
+      join(managedRoot, "node_modules", "@openai", "codex-win32-arm64", "vendor", "aarch64-pc-windows-msvc", "bin", "codex.exe"),
+    );
+  }
+  // Follow the resolved command to its real location. The opencodex shim and
+  // the npm JS wrapper resolve to `@openai/codex/bin/codex.js`; the native
+  // binary lives in the sibling platform package's vendor directory.
+  try {
+    const real = realpathSync(command);
+    const pkgRoot = resolve(real, "..", "..");
+    for (const [pkg, triple, exe] of [
+      ["codex-darwin-arm64", "aarch64-apple-darwin", "codex"],
+      ["codex-darwin-x64", "x86_64-apple-darwin", "codex"],
+      ["codex-linux-x64", "x86_64-unknown-linux-musl", "codex"],
+      ["codex-linux-arm64", "aarch64-unknown-linux-musl", "codex"],
+      ["codex-win32-x64", "x86_64-pc-windows-msvc", "codex.exe"],
+      ["codex-win32-arm64", "aarch64-pc-windows-msvc", "codex.exe"],
+    ] as const) {
+      out.push(join(pkgRoot, "node_modules", "@openai", pkg, "vendor", triple, "bin", exe));
+    }
+  } catch {
+    // leave the raw command as the only candidate
+  }
+  return out;
+}
+
 function editAgentsMaxThreads(value: number | null, configPath?: string, migratedComment?: string): ConfigEditResult {
   const path = configPath ?? activeCodexConfigPath();
   const content = readConfigText(path);
diff --git a/tests/codex-v2-gate.test.ts b/tests/codex-v2-gate.test.ts
index 1698e01c1..d27e51305 100644
--- a/tests/codex-v2-gate.test.ts
+++ b/tests/codex-v2-gate.test.ts
@@ -450,6 +450,13 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
     expect(setMultiAgentModeHintText(null, path)).toMatchObject({ ok: false });
     expect(readFileSync(path, "utf8")).toBe(before);
   });
+
+  test("reader decodes multi-line basic and literal TOML strings", () => {
+    const basic = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"\"\"\nProactive\nmulti-line\n\"\"\"\n");
+    expect(getMultiAgentModeHintText(basic)).toBe("Proactive\nmulti-line\n");
+    const literal = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = '''\nLiteral\\path\n'''\n");
+    expect(getMultiAgentModeHintText(literal)).toBe("Literal\\path\n");
+  });
 });
 
 describe("thread-limit-preserving v1/v2 transition", () => {

From a8955cc35a8a297cca1d34fa40cef34173ad24c9 Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Sun, 9 Aug 2026 17:43:03 +0900
Subject: [PATCH 6/9] fix(v2): address integration review blockers

---
 .../SubagentDelegationSection.tsx             |   2 +-
 gui/src/i18n/de.ts                            |   2 +-
 gui/src/i18n/en.ts                            |   2 +-
 gui/src/i18n/ja.ts                            |   2 +-
 gui/src/i18n/ko.ts                            |   2 +-
 gui/src/i18n/ru.ts                            |   2 +-
 gui/src/i18n/zh.ts                            |   2 +-
 gui/src/pages/Subagents.tsx                   |  44 ++-
 gui/tests/multi-agent-guidance.test.tsx       |   5 +
 gui/tests/subagents-ultra-mode.test.tsx       | 175 ++++++++++
 src/cli/v2.ts                                 |   4 +-
 src/codex/features.ts                         | 303 ++++++++++++++----
 tests/codex-v2-gate.test.ts                   | 252 ++++++++++++++-
 13 files changed, 716 insertions(+), 81 deletions(-)
 create mode 100644 gui/tests/subagents-ultra-mode.test.tsx

diff --git a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
index 035dbefb5..d2e60c3cd 100644
--- a/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
+++ b/gui/src/components/subagents-workspace/SubagentDelegationSection.tsx
@@ -224,4 +224,4 @@ function UltraModeEditor({
 
 /** Canonical Proactive delegation text mirrored from codex-rs (multi_agent_mode_instructions.rs). */
 export const ULTRA_MODE_PRESET =
-  "Proactive multi-agent delegation is active. Any earlier instruction requiring an explicit user request before spawning sub-agents no longer applies. Use sub-agents when parallel work would materially improve speed or quality. This mode remains active until a later multi-agent mode developer message changes it.";
+  "Proactive multi-agent delegation is active. Any earlier instruction requiring an explicit user request before spawning sub-agents no longer applies. Delegate independent sub-tasks to sub-agents whenever parallel work would materially improve speed or quality — do not serialize work that can run concurrently. Each sub-agent runs in its own context and can use all available tools; prefer spawning specialists over doing everything yourself. This mode remains active until a later multi-agent mode developer message changes it.";
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index bd2a4c174..d4d287adb 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -569,7 +569,7 @@ export const de: Record<TKey, string> = {
   "sub.workspace.selector": "Öffentlicher Selektor",
   "sub.ultraMode": "Ultra-Modus",
   "sub.ultraModeHint": "Aktiviert die proaktive Multi-Agent-Delegierungsrichtlinie für alle Modelle und Reasoning-Efforts (ändert den Reasoning-Effort selbst nicht). Schreibt multi_agent_mode_hint_text in config.toml.",
-  "sub.ultraModeV2Required": "Benötigt das multi_agent_v2-Feature — aktivieren Sie es zuerst mit ocx v2 on.",
+  "sub.ultraModeV2Required": "Erfordert die v2-Multi-Agent-Oberfläche — aktivieren Sie zuerst multi_agent_v2 und wählen Sie v2 in der Subagentenmodus-Steuerung.",
   "sub.ultraModeText": "Delegierungstext des Ultra-Modus",
   "sub.ultraModePreset": "Voreinstellung wiederherstellen",
   "sub.ultraModeLoadFail": "Ultra-Modus-Einstellungen konnten nicht geladen werden — läuft der Proxy?",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index 159f0bf85..a65d488ea 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -590,7 +590,7 @@ export const en = {
   "sub.workspace.priority": "Priority",
   "sub.ultraMode": "Ultra mode",
   "sub.ultraModeHint": "Enable the Proactive multi-agent delegation policy for every model and reasoning effort (does not change reasoning effort itself). Writes multi_agent_mode_hint_text in config.toml.",
-  "sub.ultraModeV2Required": "Requires the multi_agent_v2 feature — enable it with ocx v2 on first.",
+  "sub.ultraModeV2Required": "Requires the v2 multi-agent surface — enable multi_agent_v2 and select v2 in the Sub-agent mode control first.",
   "sub.ultraModeText": "Ultra mode delegation text",
   "sub.ultraModePreset": "Restore preset",
   "sub.ultraModeLoadFail": "Failed to load Ultra mode settings — is the proxy running?",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 72b94da1f..d428dbd1f 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -552,7 +552,7 @@ export const ja: Record<TKey, string> = {
   "sub.workspace.selector": "公開セレクター",
   "sub.ultraMode": "ウルトラモード",
   "sub.ultraModeHint": "すべてのモデルと reasoning effort で Proactive マルチエージェント委任ポリシーを有効にします（reasoning effort 自体は変更しません）。config.toml に multi_agent_mode_hint_text を書き込みます。",
-  "sub.ultraModeV2Required": "multi_agent_v2 機能が必要です — 先に ocx v2 on で有効にしてください。",
+  "sub.ultraModeV2Required": "v2 マルチエージェントサーフェスが必要です — 先に multi_agent_v2 を有効にし、サブエージェントモードで v2 を選択してください。",
   "sub.ultraModeText": "ウルトラモード委任テキスト",
   "sub.ultraModePreset": "プリセットを復元",
   "sub.ultraModeLoadFail": "ウルトラモード設定を読み込めませんでした — プロキシは実行中ですか？",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index a3e9051fd..32e3b94f4 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -586,7 +586,7 @@ export const ko: Record<TKey, string> = {
   "sub.workspace.selector": "공개 셀렉터",
   "sub.ultraMode": "울트라 모드",
   "sub.ultraModeHint": "모든 모델과 reasoning effort에서 Proactive 멀티에이전트 위임 정책을 켭니다 (reasoning effort 자체는 변경하지 않음). config.toml에 multi_agent_mode_hint_text를 기록합니다.",
-  "sub.ultraModeV2Required": "multi_agent_v2 기능이 필요합니다 — 먼저 ocx v2 on으로 켜세요.",
+  "sub.ultraModeV2Required": "v2 멀티에이전트 서피스가 필요합니다 — 먼저 multi_agent_v2를 켜고 서브에이전트 모드에서 v2를 선택하세요.",
   "sub.ultraModeText": "울트라 모드 위임 텍스트",
   "sub.ultraModePreset": "프리셋 복원",
   "sub.ultraModeLoadFail": "울트라 모드 설정을 불러오지 못했습니다 — 프록시가 실행 중인가요?",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index aa900c6fa..d97cb4e09 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -584,7 +584,7 @@ export const ru: Record<TKey, string> = {
   "sub.workspace.selector": "Публичный селектор",
   "sub.ultraMode": "Ультра-режим",
   "sub.ultraModeHint": "Включает политику упреждающего делегирования мультиагентов для всех моделей и уровней reasoning effort (сам reasoning effort не меняется). Записывает multi_agent_mode_hint_text в config.toml.",
-  "sub.ultraModeV2Required": "Требуется функция multi_agent_v2 — сначала включите её через ocx v2 on.",
+  "sub.ultraModeV2Required": "Требуется мультиагентная поверхность v2 — сначала включите multi_agent_v2 и выберите v2 в переключателе режима субагентов.",
   "sub.ultraModeText": "Текст делегирования ультра-режима",
   "sub.ultraModePreset": "Восстановить пресет",
   "sub.ultraModeLoadFail": "Не удалось загрузить настройки ультра-режима — работает ли прокси?",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 4ed90d31a..8a3c82a96 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -579,7 +579,7 @@ export const zh: Record<TKey, string> = {
   "sub.workspace.selector": "公开选择器",
   "sub.ultraMode": "超级模式",
   "sub.ultraModeHint": "为所有模型和推理力度启用主动多代理委派策略（不改变推理力度本身）。将 multi_agent_mode_hint_text 写入 config.toml。",
-  "sub.ultraModeV2Required": "需要 multi_agent_v2 功能 — 请先通过 ocx v2 on 启用。",
+  "sub.ultraModeV2Required": "需要 v2 多代理表面 — 请先启用 multi_agent_v2，并在子代理模式控件中选择 v2。",
   "sub.ultraModeText": "超级模式委派文本",
   "sub.ultraModePreset": "恢复预设",
   "sub.ultraModeLoadFail": "无法加载超级模式设置 — 代理是否在运行？",
diff --git a/gui/src/pages/Subagents.tsx b/gui/src/pages/Subagents.tsx
index 67f62d20c..cc1028fc7 100644
--- a/gui/src/pages/Subagents.tsx
+++ b/gui/src/pages/Subagents.tsx
@@ -28,21 +28,37 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
   const [ultraMode, setUltraMode] = useState<UltraModeState>({ enabled: false, hintText: null, multiAgentV2Enabled: false });
   const [ultraSaving, setUltraSaving] = useState(false);
   const [ultraLoadFailed, setUltraLoadFailed] = useState(false);
+  const ultraLoadGeneration = useRef(0);
+  const currentUltraApiBase = useRef(apiBase);
+  useEffect(() => {
+    currentUltraApiBase.current = apiBase;
+    ultraLoadGeneration.current++;
+  }, [apiBase]);
 
   // Shared loader for /api/v2 state (multi-agent v2 flag + mode hint). Initial-load
   // failures surface sub.ultraModeLoadFail; refresh failures are rethrown so
   // saveUltraMode can report them against the save action.
   const loadUltraMode = useCallback(async (signal?: AbortSignal) => {
+    if (currentUltraApiBase.current !== apiBase) return false;
+    const generation = ++ultraLoadGeneration.current;
     const res = await fetch(`${apiBase}/api/v2`, { signal });
-    const data = await readJsonOrThrow<{ enabled?: boolean; multiAgentModeHintText?: string | null }>(res, t("sub.ultraModeLoadFail"));
-    if (!data) return;
-    if (signal?.aborted) return;
+    const data = await readJsonOrThrow<{
+      enabled?: boolean;
+      multiAgentMode?: "v1" | "default" | "v2";
+      multiAgentModeHintText?: string | null;
+    }>(res, t("sub.ultraModeLoadFail"));
+    if (!data) return false;
+    if (signal?.aborted || generation !== ultraLoadGeneration.current || currentUltraApiBase.current !== apiBase) return false;
     setUltraLoadFailed(false);
     setUltraMode({
       enabled: data.enabled ?? false,
       hintText: data.multiAgentModeHintText ?? null,
-      multiAgentV2Enabled: data.enabled ?? false,
+      // Ultra mode replaces Codex's effort-derived policy for every model. The
+      // `default` surface still preserves upstream V1 pins (for example luna),
+      // so only an explicitly forced V2 catalog is an effective surface here.
+      multiAgentV2Enabled: data.enabled === true && data.multiAgentMode === "v2",
     });
+    return true;
   }, [apiBase, t]);
 
   useEffect(() => {
@@ -61,6 +77,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
 
   const saveUltraMode = async (patch: UltraModePatch) => {
     if (ultraSaving) return;
+    const requestApiBase = apiBase;
     setUltraSaving(true);
     setStatus("");
     try {
@@ -70,10 +87,11 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
         body: JSON.stringify(patch),
       });
       await readJsonOrThrow(res, t("sub.ultraModeSaveFail"));
-      await loadUltraMode();
+      if (currentUltraApiBase.current !== requestApiBase || !await loadUltraMode()) return;
       setOk(true);
       setStatus(t("sub.ultraModeSaved"));
     } catch (error) {
+      if (currentUltraApiBase.current !== requestApiBase) return;
       setOk(false);
       setStatus(error instanceof Error && error.message ? error.message : t("sub.networkError"));
     } finally {
@@ -81,6 +99,20 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
     }
   };
 
+  const retryUltraMode = useCallback(async () => {
+    try {
+      if (!await loadUltraMode()) return;
+      // A successful retry replaces the failed initial load; do not leave the
+      // page-level load error visible after the controls have recovered.
+      setOk(false);
+      setStatus(current => current === t("sub.ultraModeLoadFail") ? "" : current);
+    } catch {
+      setOk(false);
+      setUltraLoadFailed(true);
+      setStatus(t("sub.ultraModeLoadFail"));
+    }
+  }, [loadUltraMode, t]);
+
   const loadSubagents = useCallback(async (): Promise<CachedSubagents> => {
     const res = await fetch(`${apiBase}/api/subagent-models`);
     const response = await readJsonOrThrow<{ available?: string[]; chosen?: string[] }>(res, t("sub.loadFail"));
@@ -193,7 +225,7 @@ export default function Subagents({ apiBase }: { apiBase: string }) {
           ultraSaving,
           onUltraModeSave: patch => { void saveUltraMode(patch); },
           ultraLoadFailed,
-          onUltraModeRetry: () => { void loadUltraMode().catch(() => { setOk(false); setUltraLoadFailed(true); setStatus(t("sub.ultraModeLoadFail")); }); },
+          onUltraModeRetry: () => { void retryUltraMode(); },
         }}
       />
     </>
diff --git a/gui/tests/multi-agent-guidance.test.tsx b/gui/tests/multi-agent-guidance.test.tsx
index e2a7366c1..16470385b 100644
--- a/gui/tests/multi-agent-guidance.test.tsx
+++ b/gui/tests/multi-agent-guidance.test.tsx
@@ -65,6 +65,11 @@ function props(overrides: Partial<Props> = {}): Props {
     guidanceEnabled: false,
     syncCodexDefaults: true,
     onSave: (patch) => { requests.push(patch); },
+    ultraMode: { enabled: false, hintText: null, multiAgentV2Enabled: false },
+    ultraSaving: false,
+    onUltraModeSave: () => {},
+    ultraLoadFailed: false,
+    onUltraModeRetry: () => {},
     ...overrides,
   };
 }
diff --git a/gui/tests/subagents-ultra-mode.test.tsx b/gui/tests/subagents-ultra-mode.test.tsx
new file mode 100644
index 000000000..73e34907c
--- /dev/null
+++ b/gui/tests/subagents-ultra-mode.test.tsx
@@ -0,0 +1,175 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import Subagents from "../src/pages/Subagents";
+import { ULTRA_MODE_PRESET } from "../src/components/subagents-workspace/SubagentDelegationSection";
+import { LanguageProvider } from "../src/i18n/provider";
+
+const globals = ["document", "window", "navigator", "localStorage", "fetch", "IS_REACT_ACT_ENVIRONMENT"] as const;
+let previousGlobals: Record<(typeof globals)[number], unknown>;
+let testWindow: Window;
+let container: HTMLElement;
+let root: Root | null = null;
+let v2Responses: Array<{ ok: boolean; body: unknown; status?: number }> = [];
+let v2Call = 0;
+let requests: Array<{ url: string; init?: RequestInit }> = [];
+
+function response(body: unknown, ok = true, status = 200): Response {
+  return {
+    ok,
+    status,
+    text: async () => JSON.stringify(body),
+    json: async () => body,
+  } as unknown as Response;
+}
+
+beforeEach(() => {
+  previousGlobals = Object.fromEntries(globals.map(k => [k, Reflect.get(globalThis, k)])) as typeof previousGlobals;
+  testWindow = new Window({ url: "http://localhost/" });
+  Object.defineProperty(testWindow.navigator, "language", { configurable: true, value: "en-US" });
+  Object.defineProperties(globalThis, {
+    document: { configurable: true, value: testWindow.document },
+    window: { configurable: true, value: testWindow },
+    navigator: { configurable: true, value: testWindow.navigator },
+    localStorage: { configurable: true, value: testWindow.localStorage },
+  });
+  (globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+  requests = [];
+  v2Responses = [];
+  v2Call = 0;
+  Object.defineProperty(globalThis, "fetch", {
+    configurable: true,
+    value: async (url: string, init?: RequestInit) => {
+      requests.push({ url: String(url), init });
+      const path = new URL(String(url), "http://localhost/").pathname;
+      if (path === "/api/v2") {
+        if (init?.method === "PUT") {
+          const latest = v2Responses.at(-1)?.body ?? { enabled: true, multiAgentMode: "v2", multiAgentModeHintText: null };
+          return response(latest);
+        }
+        const next = v2Responses[Math.min(v2Call++, Math.max(v2Responses.length - 1, 0))];
+        return next ? response(next.body, next.ok, next.status ?? (next.ok ? 200 : 500)) : response({ enabled: false });
+      }
+      if (path === "/api/subagent-models") return response({ available: [], chosen: [] });
+      if (path === "/api/injection-model") return response({ available: [], efforts: [] });
+      return response({});
+    },
+  });
+
+  container = testWindow.document.createElement("div") as unknown as HTMLElement;
+  testWindow.document.body.appendChild(container as never);
+});
+
+afterEach(async () => {
+  if (root) {
+    const current = root;
+    await act(async () => { current.unmount(); });
+    root = null;
+  }
+  for (const key of globals) {
+    Object.defineProperty(globalThis, key, { configurable: true, value: previousGlobals[key] });
+  }
+});
+
+async function mount(apiBase = "") {
+  await act(async () => {
+    root = createRoot(container);
+    root.render(
+      <LanguageProvider>
+        <Subagents apiBase={apiBase} />
+      </LanguageProvider>,
+    );
+  });
+  await act(async () => { await new Promise(resolve => setTimeout(resolve, 50)); });
+}
+
+function ultraSwitch(): HTMLButtonElement {
+  const button = Array.from(container.querySelectorAll("button"))
+    .find(candidate => candidate.getAttribute("aria-label") === "Ultra mode");
+  if (!button) throw new Error("Ultra mode switch not found");
+  return button as HTMLButtonElement;
+}
+
+test("does not enable Ultra mode for the default surface even when V2 is enabled", async () => {
+  v2Responses = [{ ok: true, body: { enabled: true, multiAgentMode: "default", multiAgentModeHintText: null } }];
+  await mount();
+
+  expect(ultraSwitch().disabled).toBe(true);
+  expect(ultraSwitch().getAttribute("aria-pressed")).toBe("false");
+});
+
+test("clears the page load error after a successful Ultra mode retry", async () => {
+  v2Responses = [
+    { ok: false, body: { error: "temporary failure" }, status: 503 },
+    { ok: true, body: { enabled: true, multiAgentMode: "v2", multiAgentModeHintText: null } },
+  ];
+  await mount();
+
+  expect(container.textContent).toContain("Failed to load Ultra mode settings");
+  const retry = Array.from(container.querySelectorAll("button"))
+    .find(button => button.textContent?.trim() === "Retry");
+  expect(retry).toBeTruthy();
+
+  await act(async () => { (retry as HTMLButtonElement).click(); });
+  await act(async () => { await new Promise(resolve => setTimeout(resolve, 20)); });
+
+  expect(container.textContent).not.toContain("Failed to load Ultra mode settings");
+  expect(ultraSwitch().disabled).toBe(false);
+});
+
+test("uses the complete canonical proactive delegation preset", () => {
+  expect(ULTRA_MODE_PRESET).toBe([
+    "Proactive multi-agent delegation is active.",
+    "Any earlier instruction requiring an explicit user request before spawning sub-agents no longer applies.",
+    "Delegate independent sub-tasks to sub-agents whenever parallel work would materially improve speed or quality — do not serialize work that can run concurrently.",
+    "Each sub-agent runs in its own context and can use all available tools; prefer spawning specialists over doing everything yourself.",
+    "This mode remains active until a later multi-agent mode developer message changes it.",
+  ].join(" "));
+});
+
+test("a save refresh from an old API server cannot overwrite a newer server", async () => {
+  let oldGets = 0;
+  let releaseOldRefresh!: (value: Response) => void;
+  const oldRefresh = new Promise<Response>(resolve => { releaseOldRefresh = resolve; });
+  Object.defineProperty(globalThis, "fetch", {
+    configurable: true,
+    value: async (url: string, init?: RequestInit) => {
+      const path = new URL(String(url), "http://localhost/").pathname;
+      if (path === "/old/api/v2") {
+        if (init?.method === "PUT") return response({ ok: true });
+        oldGets++;
+        if (oldGets === 1) return response({ enabled: true, multiAgentMode: "v2", multiAgentModeHintText: null });
+        return oldRefresh;
+      }
+      if (path === "/new/api/v2") return response({ enabled: false, multiAgentMode: "default", multiAgentModeHintText: null });
+      if (path.endsWith("/api/subagent-models")) return response({ available: [], chosen: [] });
+      if (path.endsWith("/api/injection-model")) return response({ available: [], efforts: [] });
+      return response({});
+    },
+  });
+
+  await mount("/old");
+  expect(ultraSwitch().disabled).toBe(false);
+  await act(async () => { ultraSwitch().click(); });
+  await act(async () => { await new Promise(resolve => setTimeout(resolve, 10)); });
+
+  await act(async () => {
+    root!.render(
+      <LanguageProvider>
+        <Subagents apiBase="/new" />
+      </LanguageProvider>,
+    );
+  });
+  await act(async () => { await new Promise(resolve => setTimeout(resolve, 20)); });
+  expect(ultraSwitch().disabled).toBe(true);
+
+  await act(async () => {
+    releaseOldRefresh(response({ enabled: true, multiAgentMode: "v2", multiAgentModeHintText: ULTRA_MODE_PRESET }));
+    await oldRefresh;
+    await new Promise(resolve => setTimeout(resolve, 10));
+  });
+  expect(ultraSwitch().disabled).toBe(true);
+  expect(ultraSwitch().getAttribute("aria-pressed")).toBe("false");
+});
diff --git a/src/cli/v2.ts b/src/cli/v2.ts
index b65ddc54d..9429eb204 100644
--- a/src/cli/v2.ts
+++ b/src/cli/v2.ts
@@ -145,7 +145,9 @@ export async function cmdV2(args: string[], deps: V2CliDeps = {}, findPort?: ()
         : "multi_agent_mode_hint_text already unset — nothing to do.");
       return 0;
     }
-    if (value.trim().length === 0 || value.startsWith("-")) {
+    // `--clear` is the only reserved token; hints are otherwise arbitrary
+    // nonblank text and may legitimately begin with a hyphen.
+    if (value.trim().length === 0) {
       log.error("v2 mode-hint: pass the hint text, or --clear to unset it.");
       return 1;
     }
diff --git a/src/codex/features.ts b/src/codex/features.ts
index 2c0f88385..d43b04607 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -31,9 +31,10 @@
  * `configPath` parameter without fighting the module-load-time const in paths.ts.
  */
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { createRequire } from "node:module";
 import { realpathSync } from "node:fs";
-import { AtomicWriteResidualTempError, AtomicWriteSecretResidualError, atomicWriteFile, expandUserPath } from "../config";
+import { AtomicWriteResidualTempError, AtomicWriteSecretResidualError, atomicWriteFile, expandUserPath, getConfigDir } from "../config";
 import { forgetEphemeralSecretPath } from "../lib/windows-secret-acl";
 import { CODEX_CONFIG_PATH } from "./paths";
 import { resolveAndPersistCodexRuntime } from "./runtime";
@@ -455,13 +456,13 @@ function decodeTomlStringToken(token: string): string | null {
   // Multi-line literal string: `'''...'''` verbatim (backslashes not special).
   if (token.startsWith("'''")) {
     return token.endsWith("'''") && token.length >= 6
-      ? token.slice(3, -3)
+      ? normalizeTomlMultilineBody(token.slice(3, -3))
       : null;
   }
   // Multi-line basic string: `"""..."""` with escapes.
   if (token.startsWith('"""')) {
     if (!token.endsWith('"""') || token.length < 6) return null;
-    return decodeBasicStringBody(token.slice(3, -3));
+    return decodeBasicStringBody(normalizeTomlMultilineBody(token.slice(3, -3)), true);
   }
   if (token.startsWith("'")) {
     return token.endsWith("'") ? token.slice(1, -1) : null;
@@ -470,13 +471,28 @@ function decodeTomlStringToken(token: string): string | null {
   return decodeBasicStringBody(token.slice(1, -1));
 }
 
+/** Apply TOML's multi-line newline rules before string-body decoding. */
+function normalizeTomlMultilineBody(body: string): string {
+  const normalized = body.replace(/\r\n/g, "\n");
+  return normalized.startsWith("\n") ? normalized.slice(1) : normalized;
+}
+
 /** Unescape the body of a TOML basic string (single- or multi-line). */
-function decodeBasicStringBody(body: string): string | null {
+function decodeBasicStringBody(body: string, multiline = false): string | null {
   let out = "";
   for (let i = 0; i < body.length; i++) {
     const ch = body[i];
     if (ch !== "\\") { out += ch; continue; }
     const esc = body[++i];
+    if (multiline) {
+      let newline = i;
+      while (body[newline] === " " || body[newline] === "\t") newline++;
+      if (body[newline] === "\n") {
+        i = newline;
+        while (body[i + 1] === " " || body[i + 1] === "\t" || body[i + 1] === "\n") i++;
+        continue;
+      }
+    }
     switch (esc) {
       case "\\": out += "\\"; break;
       case '"': out += '"'; break;
@@ -581,6 +597,40 @@ function findInlineTableEnd(text: string, openIdx: number): number {
 
 interface InlineEntry { keyStart: number; valueStart: number; valueEnd: number }
 
+/** Locate a top-level assignment while skipping complete (possibly multiline) values. */
+function findTomlAssignment(text: string, key: string): InlineEntry | null {
+  let lineStart = 0;
+  while (lineStart < text.length) {
+    let i = lineStart;
+    while (text[i] === " " || text[i] === "\t") i++;
+    const keyStart = i;
+    let keyText = "";
+    if (text[i] === '"' || text[i] === "'") {
+      const keyEnd = scanTomlValueEnd(text, i);
+      keyText = decodeTomlStringToken(text.slice(i, keyEnd)) ?? "";
+      i = keyEnd;
+    } else {
+      const match = /^[A-Za-z0-9_-]+/.exec(text.slice(i));
+      if (match) {
+        keyText = match[0];
+        i += match[0].length;
+      }
+    }
+    while (text[i] === " " || text[i] === "\t") i++;
+    if (keyText && text[i] === "=") {
+      const valueStart = i + 1;
+      const valueEnd = scanTomlValueEnd(text, valueStart);
+      if (keyText === key) return { keyStart, valueStart, valueEnd };
+      const nextLine = text.indexOf("\n", valueEnd);
+      lineStart = nextLine === -1 ? text.length : nextLine + 1;
+      continue;
+    }
+    const nextLine = text.indexOf("\n", lineStart);
+    lineStart = nextLine === -1 ? text.length : nextLine + 1;
+  }
+  return null;
+}
+
 /**
  * Locate `key = value` inside the inline-table body spanning [bodyStart, bodyEnd)
  * (exclusive of the braces), string-aware on both keys and values, or null.
@@ -637,7 +687,7 @@ function editScalarInTable(content: string, table: string, key: string, encoded:
   for (let i = headerIdx + 1; i < lines.length; i++) {
     if (/^\s*\[/.test(lines[i])) { end = i; break; }
   }
-  const keyRe = new RegExp(`^(\\s*)${key}\\s*=\\s*`);
+  const keyRe = new RegExp(`^(\\s*)${tomlKeyPattern(key)}\\s*=\\s*`);
   for (let i = headerIdx + 1; i < end; i++) {
     const m = lines[i].match(keyRe);
     if (!m) continue;
@@ -713,9 +763,9 @@ export function setAgentsMaxDepth(value: number | null, configPath?: string): Co
 function getV2StringField(key: string, configPath?: string): string | null {
   const content = readConfigText(configPath);
   if (content === null) return null;
-  const table = tomlTableBody(content, "features.multi_agent_v2");
+  const table = tomlTableBodyForStringFields(content, "features.multi_agent_v2");
   if (table !== null) {
-    const keyRe = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*`, "m");
+    const keyRe = new RegExp(`^\\s*${tomlKeyPattern(key)}\\s*=\\s*`, "m");
     const m = table.match(keyRe);
     if (m) {
       const valueStart = m.index! + m[0].length;
@@ -724,11 +774,13 @@ function getV2StringField(key: string, configPath?: string): string | null {
     }
     return null;
   }
-  const features = tomlTableBody(content, "features");
+  const features = tomlTableBodyForStringFields(content, "features");
   if (features === null) return null;
-  const m = features.match(/multi_agent_v2\s*=\s*\{/);
-  if (!m) return null;
-  const openIdx = m.index! + m[0].length - 1;
+  const v2Entry = findTomlAssignment(features, "multi_agent_v2");
+  if (!v2Entry) return null;
+  let openIdx = v2Entry.valueStart;
+  while (features[openIdx] === " " || features[openIdx] === "\t") openIdx++;
+  if (features[openIdx] !== "{") return null;
   const closeIdx = findInlineTableEnd(features, openIdx);
   if (closeIdx === -1) return null;
   const entry = findInlineEntry(features, openIdx + 1, closeIdx, key);
@@ -736,10 +788,54 @@ function getV2StringField(key: string, configPath?: string): string | null {
   return decodeTomlStringToken(features.slice(entry.valueStart, entry.valueEnd).trim());
 }
 
+/**
+ * A table body scanner that skips complete TOML values before recognizing the
+ * next header. Unlike the legacy line scanner, bracket-shaped prose inside a
+ * multi-line string cannot truncate the table.
+ */
+function tomlTableBodyForStringFields(content: string, header: string): string | null {
+  const escaped = escapeRegExp(header);
+  const match = new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`, "m").exec(content);
+  if (!match) return null;
+  const newline = content.indexOf("\n", match.index + match[0].length);
+  if (newline === -1) return "";
+  const bodyStart = newline + 1;
+  let lineStart = bodyStart;
+  while (lineStart < content.length) {
+    let cursor = lineStart;
+    while (content[cursor] === " " || content[cursor] === "\t") cursor++;
+    if (content[cursor] === "[") return content.slice(bodyStart, lineStart);
+    const lineEnd = content.indexOf("\n", cursor);
+    const boundedEnd = lineEnd === -1 ? content.length : lineEnd;
+    let keyEnd = cursor;
+    if (content[keyEnd] === '"' || content[keyEnd] === "'") {
+      keyEnd = scanTomlValueEnd(content, keyEnd);
+    } else {
+      const keyMatch = /^[A-Za-z0-9_.-]+/.exec(content.slice(keyEnd, boundedEnd));
+      if (keyMatch) keyEnd += keyMatch[0].length;
+    }
+    while (content[keyEnd] === " " || content[keyEnd] === "\t") keyEnd++;
+    if (content[keyEnd] === "=" && keyEnd < boundedEnd) {
+      const valueEnd = scanTomlValueEnd(content, keyEnd + 1);
+      const nextLine = content.indexOf("\n", valueEnd);
+      lineStart = nextLine === -1 ? content.length : nextLine + 1;
+    } else {
+      lineStart = lineEnd === -1 ? content.length : lineEnd + 1;
+    }
+  }
+  return content.slice(bodyStart);
+}
+
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+/** Bare and quoted TOML forms of one known-safe key. */
+function tomlKeyPattern(key: string): string {
+  const escaped = escapeRegExp(key);
+  return `(?:${escaped}|"${escaped}"|'${escaped}')`;
+}
+
 export function getSubagentDeveloperInstructions(configPath?: string): string | null {
   return getV2StringField("subagent_developer_instructions", configPath);
 }
@@ -771,12 +867,30 @@ function setV2StringField(key: string, value: string | null, configPath?: string
   // the document (scanTomlValueEnd stops at the second quote). Refuse the edit
   // rather than write invalid TOML; the user can convert the value to a single
   // line first. Single-line literals and basic strings are unaffected.
-  const multilinePrefix = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*("""|''')`, "m");
+  const multilinePrefix = new RegExp(`^\\s*${tomlKeyPattern(key)}\\s*=\\s*("""|''')`, "m");
   if (multilinePrefix.test(content)) {
     return { ok: false, error: `multi-line TOML string for ${key} is not editable; convert it to a single-line string first` };
   }
 
-  if (tomlTableBody(content, "features.multi_agent_v2") !== null) {
+  // A parsed V2 object without one of the supported source forms came from
+  // dotted/quoted path segments. Appending a dedicated table would redefine it
+  // and make Codex reject the file, so fail closed without changing any bytes.
+  const parsedFeatures = parsedTomlTable(content, "features");
+  const parsedV2 = parsedFeatures === null ? null : plainTomlRecord(parsedFeatures.multi_agent_v2);
+  const dedicatedV2 = tomlTableBodyForStringFields(content, "features.multi_agent_v2") !== null;
+  const featuresBody = tomlTableBodyForStringFields(content, "features");
+  const featuresV2Entry = featuresBody === null ? null : findTomlAssignment(featuresBody, "multi_agent_v2");
+  const supportedFeaturesEntry = featuresV2Entry !== null;
+  if (parsedV2 !== null && !dedicatedV2 && !supportedFeaturesEntry) {
+    return { ok: false, error: "dotted or quoted multi_agent_v2 config is not supported for managed string fields" };
+  }
+
+  const dedicatedStringBody = tomlTableBodyForStringFields(content, "features.multi_agent_v2");
+  if (dedicatedStringBody !== null) {
+    const legacyDedicatedBody = tomlTableBody(content, "features.multi_agent_v2") ?? "";
+    if (findTomlAssignment(dedicatedStringBody, key) !== null && findTomlAssignment(legacyDedicatedBody, key) === null) {
+      return { ok: false, error: `cannot edit ${key} after a header-shaped multiline value safely` };
+    }
     const next = editScalarInTable(content, "features.multi_agent_v2", key, encoded);
     if (next === content) return { ok: true, changed: false };
     atomicWriteFile(path, next);
@@ -840,6 +954,9 @@ function setV2StringField(key: string, value: string | null, configPath?: string
         return { ok: true, changed: true };
       }
     }
+    if (featuresV2Entry !== null) {
+      return { ok: false, error: "multi_agent_v2 inside a multiline [features] table is not editable safely" };
+    }
   }
 
   if (encoded === null) return { ok: true, changed: false };
@@ -868,16 +985,20 @@ export function setMultiAgentModeHintText(value: string | null, configPath?: str
   // binary provably lacks it. A probe that cannot run (missing binary,
   // unreadable file) does not block: that is the test/hermetic path and the
   // headless runtime fallback.
-  const probe = probeCodexSupportsModeHint();
-  if (probe === false) {
-    return {
-      ok: false,
-      error: "installed Codex does not support multi_agent_mode_hint_text; update Codex first",
-    };
+  if (value !== null) {
+    const probe = probeCodexSupportsModeHint();
+    if (probe === false) {
+      return {
+        ok: false,
+        error: "installed Codex does not support multi_agent_mode_hint_text; update Codex first",
+      };
+    }
   }
   return setV2StringField("multi_agent_mode_hint_text", value, configPath);
 }
 
+const modeHintCapabilityCache = new Map<string, boolean | null>();
+
 /**
  * True when the installed Codex runtime binary contains the
  * `multi_agent_mode_hint_text` config key, false when it provably does not, and
@@ -886,14 +1007,21 @@ export function setMultiAgentModeHintText(value: string | null, configPath?: str
 export function probeCodexSupportsModeHint(): boolean | null {
   try {
     const runtime = resolveAndPersistCodexRuntime({ env: process.env }).runtime;
+    const selectedPath = resolveSelectedCommandPath(runtime.command);
+    let selectedIdentity = selectedPath ?? "";
+    try { if (selectedPath) selectedIdentity = realpathSync(selectedPath); } catch { /* keep lexical path */ }
+    const cacheKey = `${runtime.command}\0${runtime.version ?? ""}\0${selectedIdentity}`;
+    if (modeHintCapabilityCache.has(cacheKey)) return modeHintCapabilityCache.get(cacheKey)!;
     const candidates = codexNativeBinaryCandidates(runtime.command);
     let sawBinary = false;
     for (const candidate of candidates) {
       try {
         if (!existsSync(candidate)) continue;
         const buf = readFileSync(candidate);
+        if (!isNativeExecutable(buf)) continue;
         sawBinary = true;
         if (buf.includes(Buffer.from("multi_agent_mode_hint_text", "utf8"))) {
+          modeHintCapabilityCache.set(cacheKey, true);
           return true;
         }
       } catch {
@@ -901,12 +1029,33 @@ export function probeCodexSupportsModeHint(): boolean | null {
       }
     }
     // At least one real binary was inspected and none contained the key.
-    return sawBinary ? false : null;
+    const result = sawBinary ? false : null;
+    modeHintCapabilityCache.set(cacheKey, result);
+    return result;
   } catch {
     return null;
   }
 }
 
+const CODEX_PLATFORM_PACKAGES = [
+  ["codex-darwin-arm64", "aarch64-apple-darwin", "codex"],
+  ["codex-darwin-x64", "x86_64-apple-darwin", "codex"],
+  ["codex-linux-x64", "x86_64-unknown-linux-musl", "codex"],
+  ["codex-linux-arm64", "aarch64-unknown-linux-musl", "codex"],
+  ["codex-win32-x64", "x86_64-pc-windows-msvc", "codex.exe"],
+  ["codex-win32-arm64", "aarch64-pc-windows-msvc", "codex.exe"],
+] as const;
+
+function isNativeExecutable(buf: Buffer): boolean {
+  if (buf.length < 4) return false;
+  if (buf[0] === 0x4d && buf[1] === 0x5a) return true; // PE/COFF
+  const magic = buf.readUInt32BE(0);
+  return magic === 0x7f454c46 // ELF
+    || magic === 0xfeedface || magic === 0xfeedfacf
+    || magic === 0xcefaedfe || magic === 0xcffaedfe
+    || magic === 0xcafebabe || magic === 0xbebafeca; // Mach-O/fat Mach-O
+}
+
 /**
  * Candidate native codex binaries to probe. The resolved `command` may be the
  * opencodex shim or the npm JS wrapper (`codex.opencodex-real`), neither of
@@ -914,58 +1063,84 @@ export function probeCodexSupportsModeHint(): boolean | null {
  * platform package's `vendor/<triple>/bin/codex`; also try adjacent wrappers.
  */
 function codexNativeBinaryCandidates(command: string): string[] {
-  const out: string[] = [command];
-  // The opencodex autostart shim (`codex`) forwards to `codex.opencodex-real`
-  // (the npm JS wrapper). Add the real wrapper's resolved native binary when it
-  // is discoverable on PATH, so probing the shim still reaches the Rust binary.
-  const pathDirs = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
-  for (const dir of pathDirs) {
-    const wrapper = join(dir, process.platform === "win32" ? "codex.opencodex-real.cmd" : "codex.opencodex-real");
-    if (existsSync(wrapper)) {
-      out.push(wrapper);
+  const out = new Set<string>();
+  const resolverBases = new Set<string>();
+  const selectedPath = resolveSelectedCommandPath(command);
+
+  const addSelectedTarget = (target: string) => {
+    try {
+      const real = realpathSync(target);
+      out.add(target);
+      out.add(real);
+      if (/[\\/]@openai[\\/]codex[\\/]bin[\\/]/.test(real)) resolverBases.add(real);
+    } catch {
+      // Missing backing paths cannot establish capability either way.
+    }
+  };
+
+  // Follow the resolved command to its real location. The opencodex shim and
+  // the npm JS wrapper resolve to `@openai/codex/bin/codex.js`; the native
+  // binary lives in the sibling platform package's vendor directory.
+  if (selectedPath) {
+    addSelectedTarget(selectedPath);
+    for (const target of selectedShimBackingPaths(selectedPath)) addSelectedTarget(target);
+  }
+
+  // npm's Windows wrappers are ordinary scripts. Resolve from both the global
+  // prefix layout and a project-local node_modules/.bin layout; createRequire
+  // then follows the selected installation's own dependency tree (including
+  // pnpm/nested optional dependencies) without consulting unrelated PATH bins.
+  const wrapperPath = selectedPath ?? command;
+  if (/\.(?:cmd|ps1)$/i.test(wrapperPath)) {
+    resolverBases.add(resolve(dirname(wrapperPath), "node_modules", "@openai", "codex", "bin", "codex.js"));
+    resolverBases.add(resolve(dirname(wrapperPath), "..", "@openai", "codex", "bin", "codex.js"));
+  }
+
+  for (const base of resolverBases) {
+    const requireFromSelected = createRequire(base);
+    for (const [pkg, triple, exe] of CODEX_PLATFORM_PACKAGES) {
       try {
-        const real = realpathSync(wrapper);
-        const pkgRoot = resolve(real, "..", "..");
-        out.push(join(pkgRoot, "node_modules", "@openai", "codex-darwin-arm64", "vendor", "aarch64-apple-darwin", "bin", "codex"));
-        out.push(join(pkgRoot, "node_modules", "@openai", "codex-darwin-x64", "vendor", "x86_64-apple-darwin", "bin", "codex"));
-        out.push(join(pkgRoot, "node_modules", "@openai", "codex-linux-x64", "vendor", "x86_64-unknown-linux-musl", "bin", "codex"));
-        out.push(join(pkgRoot, "node_modules", "@openai", "codex-linux-arm64", "vendor", "aarch64-unknown-linux-musl", "bin", "codex"));
+        const manifest = requireFromSelected.resolve(`@openai/${pkg}/package.json`);
+        out.add(join(dirname(manifest), "vendor", triple, "bin", exe));
       } catch {
-        // keep the wrapper as a candidate
+        // Optional platform packages for other targets are normally absent.
       }
     }
   }
-  const managedRoot = process.env.CODEX_MANAGED_PACKAGE_ROOT;
-  if (managedRoot) {
-    out.push(
-      join(managedRoot, "node_modules", "@openai", "codex-darwin-arm64", "vendor", "aarch64-apple-darwin", "bin", "codex"),
-      join(managedRoot, "node_modules", "@openai", "codex-darwin-x64", "vendor", "x86_64-apple-darwin", "bin", "codex"),
-      join(managedRoot, "node_modules", "@openai", "codex-linux-x64", "vendor", "x86_64-unknown-linux-musl", "bin", "codex"),
-      join(managedRoot, "node_modules", "@openai", "codex-linux-arm64", "vendor", "aarch64-unknown-linux-musl", "bin", "codex"),
-      join(managedRoot, "node_modules", "@openai", "codex-win32-x64", "vendor", "x86_64-pc-windows-msvc", "bin", "codex.exe"),
-      join(managedRoot, "node_modules", "@openai", "codex-win32-arm64", "vendor", "aarch64-pc-windows-msvc", "bin", "codex.exe"),
-    );
-  }
-  // Follow the resolved command to its real location. The opencodex shim and
-  // the npm JS wrapper resolve to `@openai/codex/bin/codex.js`; the native
-  // binary lives in the sibling platform package's vendor directory.
+  return [...out];
+}
+
+/** Backing paths tied to this exact OCX shim entry in codex-shim.json. */
+function selectedShimBackingPaths(commandPath: string): string[] {
   try {
-    const real = realpathSync(command);
-    const pkgRoot = resolve(real, "..", "..");
-    for (const [pkg, triple, exe] of [
-      ["codex-darwin-arm64", "aarch64-apple-darwin", "codex"],
-      ["codex-darwin-x64", "x86_64-apple-darwin", "codex"],
-      ["codex-linux-x64", "x86_64-unknown-linux-musl", "codex"],
-      ["codex-linux-arm64", "aarch64-unknown-linux-musl", "codex"],
-      ["codex-win32-x64", "x86_64-pc-windows-msvc", "codex.exe"],
-      ["codex-win32-arm64", "aarch64-pc-windows-msvc", "codex.exe"],
-    ] as const) {
-      out.push(join(pkgRoot, "node_modules", "@openai", pkg, "vendor", triple, "bin", exe));
+    const state = JSON.parse(readFileSync(join(getConfigDir(), "codex-shim.json"), "utf8")) as {
+      wrapperPath?: unknown;
+      originalPath?: unknown;
+      backupPath?: unknown;
+      realPath?: unknown;
+      wrappers?: Array<Record<string, unknown>>;
+    };
+    const entries = Array.isArray(state.wrappers) && state.wrappers.length > 0 ? state.wrappers : [state];
+    const selected = resolve(commandPath);
+    for (const entry of entries) {
+      if (typeof entry.wrapperPath !== "string" || resolve(entry.wrapperPath) !== selected) continue;
+      return [entry.backupPath, entry.realPath, entry.originalPath]
+        .filter((value): value is string => typeof value === "string" && value.length > 0 && resolve(value) !== selected);
     }
   } catch {
-    // leave the raw command as the only candidate
+    // Not an OCX-owned shim, or no readable state.
   }
-  return out;
+  return [];
+}
+
+/** Resolve only the selected bare command against PATH; never enumerate peers. */
+function resolveSelectedCommandPath(command: string): string | null {
+  if (command.includes("/") || command.includes("\\")) return existsSync(command) ? resolve(command) : null;
+  for (const dir of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
+    const candidate = join(dir, command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
 }
 
 function editAgentsMaxThreads(value: number | null, configPath?: string, migratedComment?: string): ConfigEditResult {
diff --git a/tests/codex-v2-gate.test.ts b/tests/codex-v2-gate.test.ts
index d27e51305..e0a29101d 100644
--- a/tests/codex-v2-gate.test.ts
+++ b/tests/codex-v2-gate.test.ts
@@ -4,7 +4,7 @@
  * config.toml reader + max_concurrent_threads_per_session writer fixtures.
  */
 import { describe, expect, test } from "bun:test";
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { readFileSync } from "node:fs";
@@ -33,6 +33,7 @@ import {
   isMultiAgentV2Enabled,
   isTranslatableV1ChildLimit,
   isTranslatableV2TotalLimit,
+  probeCodexSupportsModeHint,
   setAgentsEnabled,
   setAgentsMaxDepth,
   setMaxConcurrentThreads,
@@ -42,6 +43,7 @@ import {
   v1ChildLimitToV2TotalLimit,
   v2TotalLimitToV1ChildLimit,
 } from "../src/codex/features";
+import { resetCodexRuntimeResolveCacheForTests, setCodexRuntimeResolveCacheForTests } from "../src/codex/runtime";
 import { cmdV2, codexFeaturesInvocation, v2StatusLine, multiAgentModeLine } from "../src/cli/v2";
 import { handleManagementAPI } from "../src/server/management-api";
 import { catalogConvergenceFactory } from "./helpers/catalog-convergence";
@@ -457,6 +459,248 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
     const literal = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = '''\nLiteral\\path\n'''\n");
     expect(getMultiAgentModeHintText(literal)).toBe("Literal\\path\n");
   });
+
+  test("reader applies full multi-line newline and continuation semantics", () => {
+    const basic = fixtureConfig("[features.multi_agent_v2]\r\nmulti_agent_mode_hint_text = \"\"\"\r\nPro\\\r\n  active\r\n\"\"\"\r\n");
+    expect(getMultiAgentModeHintText(basic)).toBe("Proactive\n");
+    const literal = fixtureConfig("[features.multi_agent_v2]\r\nmulti_agent_mode_hint_text = '''\r\nLiteral\\\r\n  text\r\n'''\r\n");
+    expect(getMultiAgentModeHintText(literal)).toBe("Literal\\\n  text\n");
+    const slashParity = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"\"\"\na\\\\\nb\n\"\"\"\n");
+    expect(getMultiAgentModeHintText(slashParity)).toBe("a\\\nb\n");
+  });
+
+  test("reader keeps bracket-shaped prose inside a multi-line hint", () => {
+    const path = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"\"\"\nhello\n[bracketed]\nworld\n\"\"\"\nenabled = true\n");
+    expect(getMultiAgentModeHintText(path)).toBe("hello\n[bracketed]\nworld\n");
+  });
+
+  test("writer updates and clears quoted dedicated-table keys without duplicates", () => {
+    for (const quoted of ['"multi_agent_mode_hint_text"', "'multi_agent_mode_hint_text'"]) {
+      const path = fixtureConfig(`[features.multi_agent_v2]\n${quoted} = "old"\nenabled = true\n`);
+      expect(getMultiAgentModeHintText(path)).toBe("old");
+      expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+      expect((readFileSync(path, "utf8").match(/multi_agent_mode_hint_text/g) ?? [])).toHaveLength(1);
+      expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+      expect(setMultiAgentModeHintText(null, path)).toEqual({ ok: true, changed: true });
+      expect(readFileSync(path, "utf8")).not.toContain("multi_agent_mode_hint_text");
+    }
+  });
+
+  test("writer refuses dotted V2 definitions without changing config bytes", () => {
+    for (const original of [
+      "features.multi_agent_v2.enabled = true\n",
+      "[features]\nmulti_agent_v2.enabled = true\n",
+      '"features"."multi_agent_v2"."enabled" = true\n',
+    ]) {
+      const path = fixtureConfig(original);
+      expect(setMultiAgentModeHintText(PRESET, path)).toMatchObject({ ok: false });
+      expect(readFileSync(path, "utf8")).toBe(original);
+    }
+  });
+
+  test("dotted-looking prose inside a multi-line value does not block a supported table", () => {
+    const path = fixtureConfig('[features.multi_agent_v2]\nenabled = true\nother = """\nfeatures.multi_agent_v2.enabled = false\n"""\n');
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+  });
+
+  test("inline V2 after bracket-shaped multiline prose is read and fails closed on edit", () => {
+    const original = '[features]\nother = """\n[prose]\n"""\nmulti_agent_v2 = { enabled = true, multi_agent_mode_hint_text = "inline" }\n';
+    const path = fixtureConfig(original);
+    expect(getMultiAgentModeHintText(path)).toBe("inline");
+    expect(setMultiAgentModeHintText(PRESET, path)).toMatchObject({ ok: false });
+    expect(readFileSync(path, "utf8")).toBe(original);
+  });
+
+  test("dedicated key after bracket-shaped multiline prose fails closed without duplication", () => {
+    const original = '[features.multi_agent_v2]\nother = """\n[prose]\n"""\nmulti_agent_mode_hint_text = "old"\n';
+    const path = fixtureConfig(original);
+    expect(getMultiAgentModeHintText(path)).toBe("old");
+    expect(setMultiAgentModeHintText(PRESET, path)).toMatchObject({ ok: false });
+    expect(setMultiAgentModeHintText(null, path)).toMatchObject({ ok: false });
+    expect(readFileSync(path, "utf8")).toBe(original);
+  });
+});
+
+describe("multi_agent_mode_hint_text native capability probe", () => {
+  const native = (supported: boolean, windows = false) => Buffer.concat([
+    windows ? Buffer.from("MZ00") : Buffer.from([0x7f, 0x45, 0x4c, 0x46]),
+    Buffer.from(supported ? "multi_agent_mode_hint_text" : "older_codex_schema"),
+  ]);
+  const selectRuntime = (command: string, version = "test") => {
+    resetCodexRuntimeResolveCacheForTests();
+    setCodexRuntimeResolveCacheForTests({ runtime: { command, version, source: "fallback" }, failures: [] });
+  };
+
+  test("clear bypasses an unsupported runtime probe so invalid old config can recover", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ocx-mode-hint-clear-"));
+    const command = join(dir, "codex-old");
+    writeFileSync(command, native(false));
+    selectRuntime(command);
+    const path = fixtureConfig('[features.multi_agent_v2]\nmulti_agent_mode_hint_text = "new-only"\n');
+    try {
+      expect(setMultiAgentModeHintText(null, path)).toEqual({ ok: true, changed: true });
+      expect(getMultiAgentModeHintText(path)).toBe(null);
+    } finally {
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("probe caches by selected command/version and invalidates on selection change", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ocx-mode-hint-cache-"));
+    const supported = join(dir, "codex-supported");
+    const unsupported = join(dir, "codex-unsupported");
+    writeFileSync(supported, native(true));
+    writeFileSync(unsupported, native(false));
+    try {
+      selectRuntime(supported, "1");
+      expect(probeCodexSupportsModeHint()).toBe(true);
+      writeFileSync(supported, native(false));
+      expect(probeCodexSupportsModeHint()).toBe(true);
+      selectRuntime(unsupported, "1");
+      expect(probeCodexSupportsModeHint()).toBe(false);
+    } finally {
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("probe ignores unrelated PATH installations and script wrappers", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ocx-mode-hint-selected-"));
+    const selected = join(dir, "selected-old");
+    const unrelated = join(dir, "unrelated-bin");
+    mkdirSync(unrelated);
+    writeFileSync(selected, native(false));
+    writeFileSync(join(unrelated, "codex.opencodex-real"), native(true));
+    const oldPath = process.env.PATH;
+    process.env.PATH = `${unrelated}:${oldPath ?? ""}`;
+    try {
+      selectRuntime(selected);
+      expect(probeCodexSupportsModeHint()).toBe(false);
+      const wrapperOnly = join(dir, "wrapper-only.cmd");
+      writeFileSync(wrapperOnly, "@echo off\r\nnode codex.js %*\r\n");
+      selectRuntime(wrapperOnly);
+      expect(probeCodexSupportsModeHint()).toBe(null);
+    } finally {
+      if (oldPath === undefined) delete process.env.PATH; else process.env.PATH = oldPath;
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("probe resolves the selected Windows npm wrapper's platform package", () => {
+    const prefix = mkdtempSync(join(tmpdir(), "ocx-mode-hint-win-"));
+    const command = join(prefix, "codex.cmd");
+    const pkg = join(prefix, "node_modules", "@openai", "codex-win32-x64");
+    const binary = join(pkg, "vendor", "x86_64-pc-windows-msvc", "bin", "codex.exe");
+    mkdirSync(dirname(binary), { recursive: true });
+    writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@openai/codex", version: "test" }));
+    writeFileSync(binary, native(true, true));
+    writeFileSync(command, "@echo off\r\nnode node_modules\\@openai\\codex\\bin\\codex.js %*\r\n");
+    try {
+      selectRuntime(command);
+      expect(probeCodexSupportsModeHint()).toBe(true);
+    } finally {
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("probe resolves an exact bare PATH command without scanning peer installs", () => {
+    const prefix = mkdtempSync(join(tmpdir(), "ocx-mode-hint-bare-"));
+    const binDir = join(prefix, "bin");
+    const js = join(prefix, "node_modules", "@openai", "codex", "bin", "codex.js");
+    const pkg = join(prefix, "node_modules", "@openai", "codex-darwin-arm64");
+    const binary = join(pkg, "vendor", "aarch64-apple-darwin", "bin", "codex");
+    mkdirSync(dirname(js), { recursive: true });
+    mkdirSync(dirname(binary), { recursive: true });
+    mkdirSync(binDir, { recursive: true });
+    writeFileSync(js, "#!/usr/bin/env node\n");
+    writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@openai/codex", version: "test" }));
+    writeFileSync(binary, native(true));
+    symlinkSync(js, join(binDir, "codex.opencodex-real"));
+    const oldPath = process.env.PATH;
+    process.env.PATH = `${binDir}:${oldPath ?? ""}`;
+    try {
+      selectRuntime("codex.opencodex-real");
+      expect(probeCodexSupportsModeHint()).toBe(true);
+    } finally {
+      if (oldPath === undefined) delete process.env.PATH; else process.env.PATH = oldPath;
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("probe cache distinguishes different PATH targets for the same bare command", () => {
+    const root = mkdtempSync(join(tmpdir(), "ocx-mode-hint-path-swap-"));
+    const supportedDir = join(root, "supported");
+    const oldDir = join(root, "old");
+    const command = "codex.opencodex-real";
+    mkdirSync(supportedDir);
+    mkdirSync(oldDir);
+    writeFileSync(join(supportedDir, command), native(true));
+    writeFileSync(join(oldDir, command), native(false));
+    const oldPath = process.env.PATH;
+    try {
+      process.env.PATH = `${supportedDir}:${oldPath ?? ""}`;
+      selectRuntime(command, "same-version");
+      expect(probeCodexSupportsModeHint()).toBe(true);
+      process.env.PATH = `${oldDir}:${oldPath ?? ""}`;
+      selectRuntime(command, "same-version");
+      expect(probeCodexSupportsModeHint()).toBe(false);
+    } finally {
+      if (oldPath === undefined) delete process.env.PATH; else process.env.PATH = oldPath;
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("a bare selected command is resolved from PATH, never a same-named cwd file", () => {
+    const root = mkdtempSync(join(tmpdir(), "ocx-mode-hint-cwd-shadow-"));
+    const cwd = join(root, "cwd");
+    const bin = join(root, "bin");
+    const command = "codex-cwd-shadow";
+    mkdirSync(cwd);
+    mkdirSync(bin);
+    writeFileSync(join(cwd, command), native(true));
+    writeFileSync(join(bin, command), native(false));
+    const oldCwd = process.cwd();
+    const oldPath = process.env.PATH;
+    process.chdir(cwd);
+    process.env.PATH = `${bin}:${oldPath ?? ""}`;
+    try {
+      selectRuntime(command);
+      expect(probeCodexSupportsModeHint()).toBe(false);
+    } finally {
+      process.chdir(oldCwd);
+      if (oldPath === undefined) delete process.env.PATH; else process.env.PATH = oldPath;
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
+
+  test("probe follows only the selected OCX shim's recorded backing runtime", () => {
+    const prefix = mkdtempSync(join(tmpdir(), "ocx-mode-hint-shim-"));
+    const ocxHome = join(prefix, "ocx-home");
+    const shim = join(prefix, "bin", "codex");
+    const backing = join(prefix, "node_modules", "@openai", "codex", "bin", "codex.js");
+    const pkg = join(prefix, "node_modules", "@openai", "codex-darwin-arm64");
+    const binary = join(pkg, "vendor", "aarch64-apple-darwin", "bin", "codex");
+    mkdirSync(dirname(shim), { recursive: true });
+    mkdirSync(dirname(backing), { recursive: true });
+    mkdirSync(dirname(binary), { recursive: true });
+    mkdirSync(ocxHome, { recursive: true });
+    writeFileSync(shim, `#!/bin/sh\nexec '${backing}' "$@"\n`);
+    writeFileSync(backing, "#!/usr/bin/env node\n");
+    writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@openai/codex", version: "test" }));
+    writeFileSync(binary, native(true));
+    writeFileSync(join(ocxHome, "codex-shim.json"), JSON.stringify({
+      wrappers: [{ wrapperPath: shim, originalPath: shim, backupPath: backing }],
+    }));
+    const oldHome = process.env.OPENCODEX_HOME;
+    process.env.OPENCODEX_HOME = ocxHome;
+    try {
+      selectRuntime(shim);
+      expect(probeCodexSupportsModeHint()).toBe(true);
+    } finally {
+      if (oldHome === undefined) delete process.env.OPENCODEX_HOME; else process.env.OPENCODEX_HOME = oldHome;
+      resetCodexRuntimeResolveCacheForTests();
+    }
+  });
 });
 
 describe("thread-limit-preserving v1/v2 transition", () => {
@@ -1276,12 +1520,14 @@ describe("cli surface", () => {
       // Raw leading/trailing whitespace is preserved, matching the API contract.
       expect(await cmdV2(["mode-hint", "  spaced hint  "], { log })).toBe(0);
       expect(getMultiAgentModeHintText(path)).toBe("  spaced hint  ");
+      expect(await cmdV2(["mode-hint", "- Delegate independent work early"], { log })).toBe(0);
+      expect(getMultiAgentModeHintText(path)).toBe("- Delegate independent work early");
       // A present whitespace-only value is rejected (API rejects it with 400).
       expect(await cmdV2(["mode-hint", "   "], { log })).toBe(1);
-      expect(getMultiAgentModeHintText(path)).toBe("  spaced hint  ");
+      expect(getMultiAgentModeHintText(path)).toBe("- Delegate independent work early");
       // A missing argument is a usage error, never a destructive clear.
       expect(await cmdV2(["mode-hint"], { log })).toBe(1);
-      expect(getMultiAgentModeHintText(path)).toBe("  spaced hint  ");
+      expect(getMultiAgentModeHintText(path)).toBe("- Delegate independent work early");
       // Explicit --clear still removes the hint.
       expect(await cmdV2(["mode-hint", "--clear"], { log })).toBe(0);
       expect(getMultiAgentModeHintText(path)).toBe(null);

From 04d11a84195d20ebdfa98733456ebb2ce2b9c124 Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Mon, 10 Aug 2026 14:25:36 +0900
Subject: [PATCH 7/9] fix(v2): address latest review blockers

---
 .../src/content/docs/reference/cli/agents.md  | 15 +--
 .../docs/reference/configuration/agents.md    | 16 ++--
 gui/src/i18n/ja.ts                            |  2 +-
 gui/src/i18n/tr.ts                            |  8 ++
 src/codex/features.ts                         | 57 +++++++++---
 .../management/agent-settings-routes.ts       | 11 ++-
 tests/codex-v2-gate.test.ts                   | 91 +++++++++++++++----
 7 files changed, 155 insertions(+), 45 deletions(-)

diff --git a/docs-site/src/content/docs/reference/cli/agents.md b/docs-site/src/content/docs/reference/cli/agents.md
index 6ed6cf9c2..37508e129 100644
--- a/docs-site/src/content/docs/reference/cli/agents.md
+++ b/docs-site/src/content/docs/reference/cli/agents.md
@@ -49,12 +49,15 @@ a failed transition restores the original `config.toml`. Changes apply to new Co
 running sessions keep their pinned surface.
 
 `mode-hint` writes `features.multi_agent_v2.multi_agent_mode_hint_text` in Codex's
-`$CODEX_HOME/config.toml`. The hint overrides codex-rs's effort-derived multi-agent
-policy, so any model and any reasoning effort receives the Proactive delegation
-prompt. It does **not** change reasoning effort itself. A missing argument or a
-whitespace-only value is rejected; only `--clear` removes the hint. This is the
-Ultra mode toggle exposed in the Subagents dashboard, which also requires the
-`multi_agent_v2` feature (see `ocx v2 on`).
+`$CODEX_HOME/config.toml` even when `multi_agent_v2` is currently disabled. The
+command only persists the override; it does not enable or disable the feature, so
+the hint takes effect when a matching Codex surface is active. The hint overrides
+codex-rs's effort-derived multi-agent policy, so any model and any reasoning effort
+receives the Proactive delegation prompt. It does **not** change reasoning effort
+itself. A missing argument or a whitespace-only value is rejected; only `--clear`
+removes the hint. The Subagents dashboard's Ultra mode **on** toggle has a stricter
+gate: it requires the native feature to be enabled with an explicit v2 surface
+(`ocx v2 mode v2`); `ocx v2 on` alone does not satisfy that dashboard gate.
 
 ## Combo routing
 
diff --git a/docs-site/src/content/docs/reference/configuration/agents.md b/docs-site/src/content/docs/reference/configuration/agents.md
index 72c1f8945..dddf8d465 100644
--- a/docs-site/src/content/docs/reference/configuration/agents.md
+++ b/docs-site/src/content/docs/reference/configuration/agents.md
@@ -32,12 +32,16 @@ Mode changes apply to new sessions. `maxConcurrentThreadsPerSession` is a `PUT /
 **Ultra mode** (the Subagents dashboard toggle, `PUT /api/v2` field
 `multiAgentModeHintText`, and `ocx v2 mode-hint`) writes
 `features.multi_agent_v2.multi_agent_mode_hint_text` in Codex's
-`$CODEX_HOME/config.toml`. The hint overrides codex-rs's effort-derived multi-agent
-policy, so any model and any reasoning effort receives the Proactive delegation
-prompt; it does **not** change reasoning effort. A `null` value removes the key so
-the effort-derived policy (ultra = proactive, otherwise explicit) resumes; empty or
-whitespace-only values are rejected because a present empty override would suppress
-even the ultra-derived Proactive message. Requires the `multi_agent_v2` feature.
+`$CODEX_HOME/config.toml`. The CLI `ocx v2 mode-hint` command persists this key even
+when `multi_agent_v2` is disabled; it does not toggle the feature. The hint overrides
+codex-rs's effort-derived multi-agent policy, so any model and any reasoning effort
+receives the Proactive delegation prompt; it does **not** change reasoning effort.
+A `null` value removes the key so the effort-derived policy (ultra = proactive,
+otherwise explicit) resumes; empty or whitespace-only values are rejected because a
+present empty override would suppress even the ultra-derived Proactive message. The
+Subagents dashboard's Ultra mode **on** toggle requires both the native feature and
+an explicit v2 surface (`multiAgentMode: "v2"`, equivalent to `ocx v2 mode v2`);
+`ocx v2 on` alone does not satisfy that dashboard gate.
 
 The management API exposes `GET`/`PUT /api/v2`, `/api/injection-model`, `/api/effort-caps`,
 `/api/subagent-models`, and `/api/subagent-model-fallback`. Injection-model updates are partial;
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index d428dbd1f..6bee7f02c 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -551,7 +551,7 @@ export const ja: Record<TKey, string> = {
   "sub.workspace.selectModelDesc": "一覧からモデルを選んで詳細を確認し、spawn_agent のおすすめに設定します。",
   "sub.workspace.selector": "公開セレクター",
   "sub.ultraMode": "ウルトラモード",
-  "sub.ultraModeHint": "すべてのモデルと reasoning effort で Proactive マルチエージェント委任ポリシーを有効にします（reasoning effort 自体は変更しません）。config.toml に multi_agent_mode_hint_text を書き込みます。",
+  "sub.ultraModeHint": "すべてのモデルと reasoning effort で Proactive マルチエージェント委任ポリシーを有効にします（reasoning effort 自体は変更しません）。config.toml に features.multi_agent_v2.multi_agent_mode_hint_text を書き込みます。",
   "sub.ultraModeV2Required": "v2 マルチエージェントサーフェスが必要です — 先に multi_agent_v2 を有効にし、サブエージェントモードで v2 を選択してください。",
   "sub.ultraModeText": "ウルトラモード委任テキスト",
   "sub.ultraModePreset": "プリセットを復元",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index 494fa0721..ac1f70185 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -589,6 +589,14 @@ export const tr: Record<TKey, string> = {
   "sub.workspace.selectModel": "Bir model seçin",
   "sub.workspace.selectModelDesc": "Detayları görmek için listeden bir model seçin.",
   "sub.workspace.selector": "Genel seçici",
+  "sub.ultraMode": "Ultra modu",
+  "sub.ultraModeHint": "Tüm modeller ve reasoning effort için Proactive çoklu ajan delegasyon politikasını etkinleştirir (reasoning effort değerini değiştirmez). config.toml dosyasına multi_agent_mode_hint_text yazar.",
+  "sub.ultraModeV2Required": "v2 çoklu ajan yüzeyi gerekir — önce multi_agent_v2'yi etkinleştirin ve alt ajan modu denetiminde v2'yi seçin.",
+  "sub.ultraModeText": "Ultra modu delegasyon metni",
+  "sub.ultraModePreset": "Ön ayarı geri yükle",
+  "sub.ultraModeLoadFail": "Ultra modu ayarları yüklenemedi — proxy çalışıyor mu?",
+  "sub.ultraModeSaveFail": "Ultra modu ayarları kaydedilemedi",
+  "sub.ultraModeSaved": "Ultra modu kaydedildi. Yeni Codex oturumlarına uygulanır.",
 
   // logs
   "logs.title": "İstek Günlükleri",
diff --git a/src/codex/features.ts b/src/codex/features.ts
index d43b04607..025bc06e6 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -30,7 +30,7 @@
  * catalog.ts:40-54) so tests can point fixtures via env or the explicit
  * `configPath` parameter without fighting the module-load-time const in paths.ts.
  */
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { delimiter, dirname, join, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { realpathSync } from "node:fs";
@@ -664,6 +664,24 @@ function findInlineEntry(text: string, bodyStart: number, bodyEnd: number, key:
   return null;
 }
 
+/** Whether a TOML assignment's value starts with a triple-quoted string. */
+function isMultilineTomlString(text: string, valueStart: number): boolean {
+  let start = valueStart;
+  while (text[start] === " " || text[start] === "\t") start++;
+  return text.startsWith('"""', start) || text.startsWith("'''", start);
+}
+
+/** Whether one field in a supported inline `multi_agent_v2` table is triple-quoted. */
+function hasInlineMultilineTomlString(text: string, assignment: InlineEntry, key: string): boolean {
+  let openIdx = assignment.valueStart;
+  while (text[openIdx] === " " || text[openIdx] === "\t") openIdx++;
+  if (text[openIdx] !== "{") return false;
+  const closeIdx = findInlineTableEnd(text, openIdx);
+  if (closeIdx === -1) return false;
+  const entry = findInlineEntry(text, openIdx + 1, closeIdx, key);
+  return entry !== null && isMultilineTomlString(text, entry.valueStart);
+}
+
 /**
  * Set or remove one scalar key inside a top-level TOML table, preserving every
  * other line byte-for-byte — including the existing value's trailing comment,
@@ -862,16 +880,6 @@ function setV2StringField(key: string, value: string | null, configPath?: string
   if (content === null) return { ok: false, error: `config.toml not readable at ${path}` };
   const encoded = value === null ? null : encodeTomlBasicString(value);
 
-  // Multiline TOML strings ("""...""" / '''...''') span multiple lines and the
-  // single-line table editor cannot rewrite or remove them without corrupting
-  // the document (scanTomlValueEnd stops at the second quote). Refuse the edit
-  // rather than write invalid TOML; the user can convert the value to a single
-  // line first. Single-line literals and basic strings are unaffected.
-  const multilinePrefix = new RegExp(`^\\s*${tomlKeyPattern(key)}\\s*=\\s*("""|''')`, "m");
-  if (multilinePrefix.test(content)) {
-    return { ok: false, error: `multi-line TOML string for ${key} is not editable; convert it to a single-line string first` };
-  }
-
   // A parsed V2 object without one of the supported source forms came from
   // dotted/quoted path segments. Appending a dedicated table would redefine it
   // and make Codex reject the file, so fail closed without changing any bytes.
@@ -887,8 +895,16 @@ function setV2StringField(key: string, value: string | null, configPath?: string
 
   const dedicatedStringBody = tomlTableBodyForStringFields(content, "features.multi_agent_v2");
   if (dedicatedStringBody !== null) {
+    // Multiline TOML strings ("""...""" / '''...''') span multiple lines and the
+    // single-line table editor cannot rewrite or remove them without corrupting
+    // the document. Scope this guard to the target V2 table so an unrelated
+    // table carrying the same key does not block an otherwise safe edit.
+    const dedicatedEntry = findTomlAssignment(dedicatedStringBody, key);
+    if (dedicatedEntry !== null && isMultilineTomlString(dedicatedStringBody, dedicatedEntry.valueStart)) {
+      return { ok: false, error: `multi-line TOML string for ${key} is not editable; convert it to a single-line string first` };
+    }
     const legacyDedicatedBody = tomlTableBody(content, "features.multi_agent_v2") ?? "";
-    if (findTomlAssignment(dedicatedStringBody, key) !== null && findTomlAssignment(legacyDedicatedBody, key) === null) {
+    if (dedicatedEntry !== null && findTomlAssignment(legacyDedicatedBody, key) === null) {
       return { ok: false, error: `cannot edit ${key} after a header-shaped multiline value safely` };
     }
     const next = editScalarInTable(content, "features.multi_agent_v2", key, encoded);
@@ -897,6 +913,10 @@ function setV2StringField(key: string, value: string | null, configPath?: string
     return { ok: true, changed: true };
   }
 
+  if (featuresBody !== null && featuresV2Entry !== null && hasInlineMultilineTomlString(featuresBody, featuresV2Entry, key)) {
+    return { ok: false, error: `multi-line TOML string for ${key} is not editable; convert it to a single-line string first` };
+  }
+
   const eol = dominantEol(content);
   const lines = content.split(/\r?\n/);
   const featuresHeader = lines.findIndex(l => /^\s*\[features\]\s*(?:#.*)?$/.test(l));
@@ -1010,9 +1030,18 @@ export function probeCodexSupportsModeHint(): boolean | null {
     const selectedPath = resolveSelectedCommandPath(runtime.command);
     let selectedIdentity = selectedPath ?? "";
     try { if (selectedPath) selectedIdentity = realpathSync(selectedPath); } catch { /* keep lexical path */ }
-    const cacheKey = `${runtime.command}\0${runtime.version ?? ""}\0${selectedIdentity}`;
-    if (modeHintCapabilityCache.has(cacheKey)) return modeHintCapabilityCache.get(cacheKey)!;
     const candidates = codexNativeBinaryCandidates(runtime.command);
+    const binaryStatFingerprint = candidates.map(candidate => {
+      try {
+        const stat = statSync(candidate);
+        return `${candidate}\0${stat.dev}\0${stat.ino}\0${stat.size}\0${stat.mtimeMs}\0${stat.ctimeMs}`;
+      } catch {
+        return `${candidate}\0missing`;
+      }
+    }).join("\0");
+    const cacheKey = `${runtime.command}\0${runtime.version ?? ""}\0${selectedIdentity}\0${binaryStatFingerprint}`;
+    const cached = modeHintCapabilityCache.get(cacheKey);
+    if (cached !== undefined) return cached;
     let sawBinary = false;
     for (const candidate of candidates) {
       try {
diff --git a/src/server/management/agent-settings-routes.ts b/src/server/management/agent-settings-routes.ts
index d332166e6..331562378 100644
--- a/src/server/management/agent-settings-routes.ts
+++ b/src/server/management/agent-settings-routes.ts
@@ -300,9 +300,18 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     const {
       isMultiAgentV2Enabled, hasAgentsMaxThreads, getLogicalMaxThreads, transitionMultiAgentV2,
       getAgentsEnabled, getAgentsMaxDepth, getSubagentDeveloperInstructions,
-      getMultiAgentModeHintText, setAgentsEnabled, setAgentsMaxDepth,
+      getMultiAgentModeHintText, probeCodexSupportsModeHint, setAgentsEnabled, setAgentsMaxDepth,
       setSubagentDeveloperInstructions, setMultiAgentModeHintText,
     } = await import("../../codex/features");
+    // Probe the capability before any combined-request mutation. The scalar writer
+    // repeats this check, but doing it here prevents an earlier flag/mode/agents
+    // write from landing before an unsupported runtime returns 502.
+    if (wantsModeHintText && body.multiAgentModeHintText !== null
+        && probeCodexSupportsModeHint() === false) {
+      return jsonResponse({
+        error: "writing multiAgentModeHintText failed: installed Codex does not support multi_agent_mode_hint_text; update Codex first",
+      }, 502);
+    }
     const warnings: string[] = [];
     const requestedFlag = wantsFlag ? body.enabled as boolean : modeFlag;
     if (requestedFlag !== undefined || wantsThreads) {
diff --git a/tests/codex-v2-gate.test.ts b/tests/codex-v2-gate.test.ts
index e0a29101d..cf41d5726 100644
--- a/tests/codex-v2-gate.test.ts
+++ b/tests/codex-v2-gate.test.ts
@@ -3,10 +3,10 @@
  * The v2 toggle controls the multi-agent surface only, not ultra visibility.
  * config.toml reader + max_concurrent_threads_per_session writer fixtures.
  */
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { delimiter, dirname, join } from "node:path";
 import { readFileSync } from "node:fs";
 import {
   buildCatalogEntries,
@@ -77,6 +77,26 @@ function fixtureConfig(content: string): string {
   return path;
 }
 
+function native(supported: boolean, windows = false): Buffer {
+  return Buffer.concat([
+    windows ? Buffer.from("MZ00") : Buffer.from([0x7f, 0x45, 0x4c, 0x46]),
+    Buffer.from(supported ? "multi_agent_mode_hint_text" : "older_codex_schema"),
+  ]);
+}
+
+function selectRuntime(command: string, version = "test"): void {
+  resetCodexRuntimeResolveCacheForTests();
+  setCodexRuntimeResolveCacheForTests({ runtime: { command, version, source: "fallback" }, failures: [] });
+}
+
+function installModeHintRuntime(supported = true): string {
+  const dir = mkdtempSync(join(tmpdir(), "ocx-mode-hint-runtime-"));
+  const command = join(dir, "codex");
+  writeFileSync(command, native(supported));
+  selectRuntime(command);
+  return command;
+}
+
 describe("catalog ultra (always-on)", () => {
   const routed = [{ id: "glm-5.2", provider: "opencode-go", reasoningEfforts: ["low", "medium", "high", "xhigh"] }];
 
@@ -369,6 +389,14 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
   const PRESET = "Proactive multi-agent delegation is active.";
   const TABLE = "# keep me\n[features.multi_agent_v2]\nenabled = true\nmax_concurrent_threads_per_session = 17 # tuned\n\n[notice]\nhide = true\n";
 
+  beforeEach(() => {
+    installModeHintRuntime(true);
+  });
+
+  afterEach(() => {
+    resetCodexRuntimeResolveCacheForTests();
+  });
+
   test("reader: present, absent key, absent table, empty string", () => {
     const present = fixtureConfig("[features.multi_agent_v2]\nmulti_agent_mode_hint_text = \"Proactive delegation\"\n");
     expect(getMultiAgentModeHintText(present)).toBe("Proactive delegation");
@@ -504,6 +532,13 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
     expect(getMultiAgentModeHintText(path)).toBe(PRESET);
   });
 
+  test("same-named multi-line key in an unrelated table does not block the V2 writer", () => {
+    const path = fixtureConfig('[unrelated]\nmulti_agent_mode_hint_text = """\nleave me alone\n"""\n\n[features.multi_agent_v2]\nenabled = true\n');
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    expect(readFileSync(path, "utf8")).toContain('multi_agent_mode_hint_text = """\nleave me alone\n"""');
+    expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+  });
+
   test("inline V2 after bracket-shaped multiline prose is read and fails closed on edit", () => {
     const original = '[features]\nother = """\n[prose]\n"""\nmulti_agent_v2 = { enabled = true, multi_agent_mode_hint_text = "inline" }\n';
     const path = fixtureConfig(original);
@@ -523,15 +558,6 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
 });
 
 describe("multi_agent_mode_hint_text native capability probe", () => {
-  const native = (supported: boolean, windows = false) => Buffer.concat([
-    windows ? Buffer.from("MZ00") : Buffer.from([0x7f, 0x45, 0x4c, 0x46]),
-    Buffer.from(supported ? "multi_agent_mode_hint_text" : "older_codex_schema"),
-  ]);
-  const selectRuntime = (command: string, version = "test") => {
-    resetCodexRuntimeResolveCacheForTests();
-    setCodexRuntimeResolveCacheForTests({ runtime: { command, version, source: "fallback" }, failures: [] });
-  };
-
   test("clear bypasses an unsupported runtime probe so invalid old config can recover", () => {
     const dir = mkdtempSync(join(tmpdir(), "ocx-mode-hint-clear-"));
     const command = join(dir, "codex-old");
@@ -546,7 +572,7 @@ describe("multi_agent_mode_hint_text native capability probe", () => {
     }
   });
 
-  test("probe caches by selected command/version and invalidates on selection change", () => {
+  test("probe cache tracks in-place replacement and selected command changes", () => {
     const dir = mkdtempSync(join(tmpdir(), "ocx-mode-hint-cache-"));
     const supported = join(dir, "codex-supported");
     const unsupported = join(dir, "codex-unsupported");
@@ -556,6 +582,8 @@ describe("multi_agent_mode_hint_text native capability probe", () => {
       selectRuntime(supported, "1");
       expect(probeCodexSupportsModeHint()).toBe(true);
       writeFileSync(supported, native(false));
+      expect(probeCodexSupportsModeHint()).toBe(false);
+      writeFileSync(supported, native(true));
       expect(probeCodexSupportsModeHint()).toBe(true);
       selectRuntime(unsupported, "1");
       expect(probeCodexSupportsModeHint()).toBe(false);
@@ -572,7 +600,7 @@ describe("multi_agent_mode_hint_text native capability probe", () => {
     writeFileSync(selected, native(false));
     writeFileSync(join(unrelated, "codex.opencodex-real"), native(true));
     const oldPath = process.env.PATH;
-    process.env.PATH = `${unrelated}:${oldPath ?? ""}`;
+    process.env.PATH = `${unrelated}${delimiter}${oldPath ?? ""}`;
     try {
       selectRuntime(selected);
       expect(probeCodexSupportsModeHint()).toBe(false);
@@ -617,7 +645,7 @@ describe("multi_agent_mode_hint_text native capability probe", () => {
     writeFileSync(binary, native(true));
     symlinkSync(js, join(binDir, "codex.opencodex-real"));
     const oldPath = process.env.PATH;
-    process.env.PATH = `${binDir}:${oldPath ?? ""}`;
+    process.env.PATH = `${binDir}${delimiter}${oldPath ?? ""}`;
     try {
       selectRuntime("codex.opencodex-real");
       expect(probeCodexSupportsModeHint()).toBe(true);
@@ -638,10 +666,10 @@ describe("multi_agent_mode_hint_text native capability probe", () => {
     writeFileSync(join(oldDir, command), native(false));
     const oldPath = process.env.PATH;
     try {
-      process.env.PATH = `${supportedDir}:${oldPath ?? ""}`;
+      process.env.PATH = `${supportedDir}${delimiter}${oldPath ?? ""}`;
       selectRuntime(command, "same-version");
       expect(probeCodexSupportsModeHint()).toBe(true);
-      process.env.PATH = `${oldDir}:${oldPath ?? ""}`;
+      process.env.PATH = `${oldDir}${delimiter}${oldPath ?? ""}`;
       selectRuntime(command, "same-version");
       expect(probeCodexSupportsModeHint()).toBe(false);
     } finally {
@@ -662,7 +690,7 @@ describe("multi_agent_mode_hint_text native capability probe", () => {
     const oldCwd = process.cwd();
     const oldPath = process.env.PATH;
     process.chdir(cwd);
-    process.env.PATH = `${bin}:${oldPath ?? ""}`;
+    process.env.PATH = `${bin}${delimiter}${oldPath ?? ""}`;
     try {
       selectRuntime(command);
       expect(probeCodexSupportsModeHint()).toBe(false);
@@ -1216,12 +1244,14 @@ describe("management API parity surface for the WP2 keys", () => {
     const oldOcxHome = process.env.OPENCODEX_HOME;
     process.env.CODEX_HOME = dirname(path);
     process.env.OPENCODEX_HOME = mkdtempSync(join(tmpdir(), "ocx-api-parity-"));
+    installModeHintRuntime(true);
     const toggle = (enabled: boolean) => {
       const current = readFileSync(path, "utf8");
       writeFileSync(path, current.replace(/^enabled\s*=\s*(?:true|false)$/m, `enabled = ${enabled}`));
     };
     return run(path, { toggleCodexMultiAgentV2: toggle, createManagementConvergeCodex: catalogConvergenceFactory() })
       .finally(() => {
+        resetCodexRuntimeResolveCacheForTests();
         if (oldCodexHome === undefined) delete process.env.CODEX_HOME; else process.env.CODEX_HOME = oldCodexHome;
         if (oldOcxHome === undefined) delete process.env.OPENCODEX_HOME; else process.env.OPENCODEX_HOME = oldOcxHome;
       });
@@ -1270,6 +1300,29 @@ describe("management API parity surface for the WP2 keys", () => {
     });
   });
 
+  test("unsupported mode-hint preflight leaves a combined request entirely unchanged", async () => {
+    await withConfig("[features.multi_agent_v2]\nenabled = false\n", async (path, deps) => {
+      installModeHintRuntime(false);
+      const originalToml = readFileSync(path, "utf8");
+      const localConfig = { providers: [], multiAgentMode: "v1" as const };
+      let toggles = 0;
+      const response = await handleManagementAPI(
+        put({ enabled: true, multiAgentMode: "v2", multiAgentModeHintText: "custom" }),
+        new URL("http://localhost/api/v2"),
+        localConfig as never,
+        { ...deps, toggleCodexMultiAgentV2: () => { toggles++; } },
+      );
+      expect(response?.status).toBe(502);
+      expect(await response?.json()).toEqual({
+        error: "writing multiAgentModeHintText failed: installed Codex does not support multi_agent_mode_hint_text; update Codex first",
+      });
+      expect(toggles).toBe(0);
+      expect(readFileSync(path, "utf8")).toBe(originalToml);
+      expect(isMultiAgentV2Enabled(path)).toBe(false);
+      expect(localConfig.multiAgentMode).toBe("v1");
+    });
+  });
+
   test("empty string writes an empty value; null removes the key", async () => {
     await withConfig("[features.multi_agent_v2]\nenabled = false\n", async (path, deps) => {
       await handleManagementAPI(put({ subagentDeveloperInstructions: "" }), new URL("http://localhost/api/v2"), config, deps);
@@ -1496,6 +1549,7 @@ describe("cli surface", () => {
     const path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\n");
     const oldCodexHome = process.env.CODEX_HOME;
     process.env.CODEX_HOME = dirname(path);
+    installModeHintRuntime(true);
     const logs: string[] = [];
     const log = { log: (m?: unknown) => { logs.push(String(m)); }, error: (m?: unknown) => { logs.push(String(m)); } };
     try {
@@ -1506,6 +1560,7 @@ describe("cli surface", () => {
       expect(await cmdV2(["mode-hint", "--clear"], { log })).toBe(0);
       expect(getMultiAgentModeHintText(path)).toBe(null);
     } finally {
+      resetCodexRuntimeResolveCacheForTests();
       if (oldCodexHome === undefined) delete process.env.CODEX_HOME; else process.env.CODEX_HOME = oldCodexHome;
     }
   });
@@ -1514,6 +1569,7 @@ describe("cli surface", () => {
     const path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\n");
     const oldCodexHome = process.env.CODEX_HOME;
     process.env.CODEX_HOME = dirname(path);
+    installModeHintRuntime(true);
     const logs: string[] = [];
     const log = { log: (m?: unknown) => { logs.push(String(m)); }, error: (m?: unknown) => { logs.push(String(m)); } };
     try {
@@ -1532,6 +1588,7 @@ describe("cli surface", () => {
       expect(await cmdV2(["mode-hint", "--clear"], { log })).toBe(0);
       expect(getMultiAgentModeHintText(path)).toBe(null);
     } finally {
+      resetCodexRuntimeResolveCacheForTests();
       if (oldCodexHome === undefined) delete process.env.CODEX_HOME; else process.env.CODEX_HOME = oldCodexHome;
     }
   });

From 6649e5b6a1af420d582cf5064dbb1f6c04146d5e Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Mon, 10 Aug 2026 15:10:09 +0900
Subject: [PATCH 8/9] fix(v2): handle escaped quoted TOML keys

---
 src/codex/features.ts       | 21 ++++++++-------------
 tests/codex-v2-gate.test.ts | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 13 deletions(-)

diff --git a/src/codex/features.ts b/src/codex/features.ts
index 025bc06e6..338edee8e 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -705,22 +705,19 @@ function editScalarInTable(content: string, table: string, key: string, encoded:
   for (let i = headerIdx + 1; i < lines.length; i++) {
     if (/^\s*\[/.test(lines[i])) { end = i; break; }
   }
-  const keyRe = new RegExp(`^(\\s*)${tomlKeyPattern(key)}\\s*=\\s*`);
   for (let i = headerIdx + 1; i < end; i++) {
-    const m = lines[i].match(keyRe);
-    if (!m) continue;
+    const entry = findTomlAssignment(lines[i], key);
+    if (!entry) continue;
     // The existing value may itself contain '#', so scan the value token
     // string-aware instead of splitting on '#'.
     const line = lines[i];
-    const valueStart = m[0].length;
-    const valueEnd = scanTomlValueEnd(line, valueStart);
-    const trailing = line.slice(valueEnd);
+    const trailing = line.slice(entry.valueEnd);
     if (encoded === null) {
       lines.splice(i, 1);
       return applyEol(lines.join("\n"), eol);
     }
-    if (line.slice(valueStart, valueEnd).trim() === encoded) return content;
-    lines[i] = `${m[1]}${key} = ${encoded}${trailing}`;
+    if (line.slice(entry.valueStart, entry.valueEnd).trim() === encoded) return content;
+    lines[i] = `${line.slice(0, entry.keyStart)}${key} = ${encoded}${trailing}`;
     return applyEol(lines.join("\n"), eol);
   }
   if (encoded === null) return content;
@@ -783,11 +780,9 @@ function getV2StringField(key: string, configPath?: string): string | null {
   if (content === null) return null;
   const table = tomlTableBodyForStringFields(content, "features.multi_agent_v2");
   if (table !== null) {
-    const keyRe = new RegExp(`^\\s*${tomlKeyPattern(key)}\\s*=\\s*`, "m");
-    const m = table.match(keyRe);
-    if (m) {
-      const valueStart = m.index! + m[0].length;
-      const token = table.slice(valueStart, scanTomlValueEnd(table, valueStart)).trim();
+    const entry = findTomlAssignment(table, key);
+    if (entry) {
+      const token = table.slice(entry.valueStart, entry.valueEnd).trim();
       return decodeTomlStringToken(token);
     }
     return null;
diff --git a/tests/codex-v2-gate.test.ts b/tests/codex-v2-gate.test.ts
index cf41d5726..84b50d9b4 100644
--- a/tests/codex-v2-gate.test.ts
+++ b/tests/codex-v2-gate.test.ts
@@ -514,6 +514,24 @@ describe("multi_agent_mode_hint_text reader/writer", () => {
     }
   });
 
+  test("reader, update, and clear use semantic equality for escaped quoted hint keys", () => {
+    const path = fixtureConfig('[features.multi_agent_v2]\n"multi_agent_mode_hint_\\u0074ext" = "old"\nenabled = true\n');
+    expect(getMultiAgentModeHintText(path)).toBe("old");
+
+    expect(setMultiAgentModeHintText(PRESET, path)).toEqual({ ok: true, changed: true });
+    const updated = readFileSync(path, "utf8");
+    const parsedUpdated = Bun.TOML.parse(updated) as { features: { multi_agent_v2: Record<string, unknown> } };
+    expect(parsedUpdated.features.multi_agent_v2.multi_agent_mode_hint_text).toBe(PRESET);
+    expect(Object.keys(parsedUpdated.features.multi_agent_v2).filter(key => key === "multi_agent_mode_hint_text")).toHaveLength(1);
+    expect(getMultiAgentModeHintText(path)).toBe(PRESET);
+
+    expect(setMultiAgentModeHintText(null, path)).toEqual({ ok: true, changed: true });
+    const cleared = readFileSync(path, "utf8");
+    const parsedCleared = Bun.TOML.parse(cleared) as { features: { multi_agent_v2: Record<string, unknown> } };
+    expect(parsedCleared.features.multi_agent_v2.multi_agent_mode_hint_text).toBeUndefined();
+    expect(getMultiAgentModeHintText(path)).toBe(null);
+  });
+
   test("writer refuses dotted V2 definitions without changing config bytes", () => {
     for (const original of [
       "features.multi_agent_v2.enabled = true\n",
@@ -1045,6 +1063,22 @@ describe("config-surface parity: agents.enabled, max_depth, subagent_developer_i
     expect(readFileSync(path, "utf8")).toContain("enabled = true");
   });
 
+  test("subagent instructions support escaped quoted dedicated-table keys", () => {
+    const path = fixtureConfig('[features.multi_agent_v2]\n"subagent_developer_instruc\\u0074ions" = "old"\nenabled = true\n');
+    expect(getSubagentDeveloperInstructions(path)).toBe("old");
+
+    expect(setSubagentDeveloperInstructions("new", path)).toEqual({ ok: true, changed: true });
+    const updated = readFileSync(path, "utf8");
+    const parsedUpdated = Bun.TOML.parse(updated) as { features: { multi_agent_v2: Record<string, unknown> } };
+    expect(parsedUpdated.features.multi_agent_v2.subagent_developer_instructions).toBe("new");
+    expect(Object.keys(parsedUpdated.features.multi_agent_v2).filter(key => key === "subagent_developer_instructions")).toHaveLength(1);
+
+    expect(setSubagentDeveloperInstructions(null, path)).toEqual({ ok: true, changed: true });
+    const parsedCleared = Bun.TOML.parse(readFileSync(path, "utf8")) as { features: { multi_agent_v2: Record<string, unknown> } };
+    expect(parsedCleared.features.multi_agent_v2.subagent_developer_instructions).toBeUndefined();
+    expect(getSubagentDeveloperInstructions(path)).toBe(null);
+  });
+
   test("key name is emitted character-for-character (upstream deny_unknown_fields)", () => {
     const path = fixtureConfig("[features.multi_agent_v2]\nenabled = true\n");
     setSubagentDeveloperInstructions("x", path);

From 1fa84c5df37644a634c7eb2e5e0c6e358e5cc7ab Mon Sep 17 00:00:00 2001
From: Hanbin Noh <282618027+hanbinnoh@users.noreply.github.com>
Date: Mon, 10 Aug 2026 15:55:28 +0900
Subject: [PATCH 9/9] fix: address final ultra mode review notes

---
 gui/src/i18n/de.ts                             | 2 +-
 gui/src/i18n/en.ts                             | 2 +-
 gui/src/i18n/ko.ts                             | 2 +-
 gui/src/i18n/ru.ts                             | 2 +-
 gui/src/i18n/tr.ts                             | 2 +-
 gui/src/i18n/zh.ts                             | 2 +-
 src/codex/features.ts                          | 5 ++++-
 src/server/management/agent-settings-routes.ts | 4 ++--
 8 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index d4d287adb..a21f2bbc8 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -568,7 +568,7 @@ export const de: Record<TKey, string> = {
   "sub.workspace.selectModelDesc": "Wählen Sie ein Modell aus der Liste, um Details anzuzeigen und es für spawn_agent hervorzuheben.",
   "sub.workspace.selector": "Öffentlicher Selektor",
   "sub.ultraMode": "Ultra-Modus",
-  "sub.ultraModeHint": "Aktiviert die proaktive Multi-Agent-Delegierungsrichtlinie für alle Modelle und Reasoning-Efforts (ändert den Reasoning-Effort selbst nicht). Schreibt multi_agent_mode_hint_text in config.toml.",
+  "sub.ultraModeHint": "Aktiviert die proaktive Multi-Agent-Delegierungsrichtlinie für alle Modelle und Reasoning-Efforts (ändert den Reasoning-Effort selbst nicht). Schreibt features.multi_agent_v2.multi_agent_mode_hint_text in config.toml.",
   "sub.ultraModeV2Required": "Erfordert die v2-Multi-Agent-Oberfläche — aktivieren Sie zuerst multi_agent_v2 und wählen Sie v2 in der Subagentenmodus-Steuerung.",
   "sub.ultraModeText": "Delegierungstext des Ultra-Modus",
   "sub.ultraModePreset": "Voreinstellung wiederherstellen",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index a65d488ea..43cbc8cab 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -589,7 +589,7 @@ export const en = {
   "sub.workspace.notFeatured": "Not featured",
   "sub.workspace.priority": "Priority",
   "sub.ultraMode": "Ultra mode",
-  "sub.ultraModeHint": "Enable the Proactive multi-agent delegation policy for every model and reasoning effort (does not change reasoning effort itself). Writes multi_agent_mode_hint_text in config.toml.",
+  "sub.ultraModeHint": "Enable the Proactive multi-agent delegation policy for every model and reasoning effort (does not change reasoning effort itself). Writes features.multi_agent_v2.multi_agent_mode_hint_text in config.toml.",
   "sub.ultraModeV2Required": "Requires the v2 multi-agent surface — enable multi_agent_v2 and select v2 in the Sub-agent mode control first.",
   "sub.ultraModeText": "Ultra mode delegation text",
   "sub.ultraModePreset": "Restore preset",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 32e3b94f4..2e448f792 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -585,7 +585,7 @@ export const ko: Record<TKey, string> = {
   "sub.workspace.selectModelDesc": "목록에서 모델을 선택하여 세부 정보를 확인하고 spawn_agent에 추천하세요.",
   "sub.workspace.selector": "공개 셀렉터",
   "sub.ultraMode": "울트라 모드",
-  "sub.ultraModeHint": "모든 모델과 reasoning effort에서 Proactive 멀티에이전트 위임 정책을 켭니다 (reasoning effort 자체는 변경하지 않음). config.toml에 multi_agent_mode_hint_text를 기록합니다.",
+  "sub.ultraModeHint": "모든 모델과 reasoning effort에서 Proactive 멀티에이전트 위임 정책을 켭니다 (reasoning effort 자체는 변경하지 않음). config.toml에 features.multi_agent_v2.multi_agent_mode_hint_text를 기록합니다.",
   "sub.ultraModeV2Required": "v2 멀티에이전트 서피스가 필요합니다 — 먼저 multi_agent_v2를 켜고 서브에이전트 모드에서 v2를 선택하세요.",
   "sub.ultraModeText": "울트라 모드 위임 텍스트",
   "sub.ultraModePreset": "프리셋 복원",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index d97cb4e09..c18764dc9 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -583,7 +583,7 @@ export const ru: Record<TKey, string> = {
   "sub.workspace.selectModelDesc": "Выберите модель из списка, чтобы увидеть детали и добавить её в избранные для spawn_agent.",
   "sub.workspace.selector": "Публичный селектор",
   "sub.ultraMode": "Ультра-режим",
-  "sub.ultraModeHint": "Включает политику упреждающего делегирования мультиагентов для всех моделей и уровней reasoning effort (сам reasoning effort не меняется). Записывает multi_agent_mode_hint_text в config.toml.",
+  "sub.ultraModeHint": "Включает политику упреждающего делегирования мультиагентов для всех моделей и уровней reasoning effort (сам reasoning effort не меняется). Записывает features.multi_agent_v2.multi_agent_mode_hint_text в config.toml.",
   "sub.ultraModeV2Required": "Требуется мультиагентная поверхность v2 — сначала включите multi_agent_v2 и выберите v2 в переключателе режима субагентов.",
   "sub.ultraModeText": "Текст делегирования ультра-режима",
   "sub.ultraModePreset": "Восстановить пресет",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index ac1f70185..7d75b91a2 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -590,7 +590,7 @@ export const tr: Record<TKey, string> = {
   "sub.workspace.selectModelDesc": "Detayları görmek için listeden bir model seçin.",
   "sub.workspace.selector": "Genel seçici",
   "sub.ultraMode": "Ultra modu",
-  "sub.ultraModeHint": "Tüm modeller ve reasoning effort için Proactive çoklu ajan delegasyon politikasını etkinleştirir (reasoning effort değerini değiştirmez). config.toml dosyasına multi_agent_mode_hint_text yazar.",
+  "sub.ultraModeHint": "Tüm modeller ve reasoning effort için Proactive çoklu ajan delegasyon politikasını etkinleştirir (reasoning effort değerini değiştirmez). config.toml dosyasına features.multi_agent_v2.multi_agent_mode_hint_text yazar.",
   "sub.ultraModeV2Required": "v2 çoklu ajan yüzeyi gerekir — önce multi_agent_v2'yi etkinleştirin ve alt ajan modu denetiminde v2'yi seçin.",
   "sub.ultraModeText": "Ultra modu delegasyon metni",
   "sub.ultraModePreset": "Ön ayarı geri yükle",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 8a3c82a96..0cb8234a4 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -578,7 +578,7 @@ export const zh: Record<TKey, string> = {
   "sub.workspace.selectModelDesc": "从列表中选择一个模型以查看详情，并将其设为 spawn_agent 的精选模型。",
   "sub.workspace.selector": "公开选择器",
   "sub.ultraMode": "超级模式",
-  "sub.ultraModeHint": "为所有模型和推理力度启用主动多代理委派策略（不改变推理力度本身）。将 multi_agent_mode_hint_text 写入 config.toml。",
+  "sub.ultraModeHint": "为所有模型和推理力度启用主动多代理委派策略（不改变推理力度本身）。将 features.multi_agent_v2.multi_agent_mode_hint_text 写入 config.toml。",
   "sub.ultraModeV2Required": "需要 v2 多代理表面 — 请先启用 multi_agent_v2，并在子代理模式控件中选择 v2。",
   "sub.ultraModeText": "超级模式委派文本",
   "sub.ultraModePreset": "恢复预设",
diff --git a/src/codex/features.ts b/src/codex/features.ts
index 338edee8e..8308e4581 100644
--- a/src/codex/features.ts
+++ b/src/codex/features.ts
@@ -986,6 +986,9 @@ export function setSubagentDeveloperInstructions(value: string | null, configPat
   return setV2StringField("subagent_developer_instructions", value, configPath);
 }
 
+export const MODE_HINT_UNSUPPORTED_ERROR =
+  "installed Codex does not support multi_agent_mode_hint_text; update Codex first";
+
 /**
  * Persist `features.multi_agent_v2.multi_agent_mode_hint_text`, or remove the key
  * when `value` is null. Same encoding coverage and upstream-name discipline as
@@ -1005,7 +1008,7 @@ export function setMultiAgentModeHintText(value: string | null, configPath?: str
     if (probe === false) {
       return {
         ok: false,
-        error: "installed Codex does not support multi_agent_mode_hint_text; update Codex first",
+        error: MODE_HINT_UNSUPPORTED_ERROR,
       };
     }
   }
diff --git a/src/server/management/agent-settings-routes.ts b/src/server/management/agent-settings-routes.ts
index 331562378..ca8c6568c 100644
--- a/src/server/management/agent-settings-routes.ts
+++ b/src/server/management/agent-settings-routes.ts
@@ -301,7 +301,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       isMultiAgentV2Enabled, hasAgentsMaxThreads, getLogicalMaxThreads, transitionMultiAgentV2,
       getAgentsEnabled, getAgentsMaxDepth, getSubagentDeveloperInstructions,
       getMultiAgentModeHintText, probeCodexSupportsModeHint, setAgentsEnabled, setAgentsMaxDepth,
-      setSubagentDeveloperInstructions, setMultiAgentModeHintText,
+      setSubagentDeveloperInstructions, setMultiAgentModeHintText, MODE_HINT_UNSUPPORTED_ERROR,
     } = await import("../../codex/features");
     // Probe the capability before any combined-request mutation. The scalar writer
     // repeats this check, but doing it here prevents an earlier flag/mode/agents
@@ -309,7 +309,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     if (wantsModeHintText && body.multiAgentModeHintText !== null
         && probeCodexSupportsModeHint() === false) {
       return jsonResponse({
-        error: "writing multiAgentModeHintText failed: installed Codex does not support multi_agent_mode_hint_text; update Codex first",
+        error: `writing multiAgentModeHintText failed: ${MODE_HINT_UNSUPPORTED_ERROR}`,
       }, 502);
     }
     const warnings: string[] = [];