diff --git a/docs-site/src/content/docs/guides/integrations.md b/docs-site/src/content/docs/guides/integrations.md
index b4488b926d8..d2bd4e9e21e 100644
--- a/docs-site/src/content/docs/guides/integrations.md
+++ b/docs-site/src/content/docs/guides/integrations.md
@@ -623,6 +623,30 @@ Chat Completions endpoint. Choose a row from Droid's `/model` picker. Disable
 removes the managed rows; Undo restores the exact saved file. Other settings and
 custom models remain yours.
 
+Open **Integrations → Factory Droid** (`/#integrations/droid`) to set a reasoning
+default for each connected model. Choose from the model's supported efforts,
+review the changes, then confirm. **No default** clears that model's draft setting;
+use **Save / review changes** and confirm to apply the removal.
+Models without a declared effort list show that no default is available.
+
+The default applies only when Droid omits an effort from its request. An explicit
+request effort takes precedence over this default; existing OpenCodex pins and
+caps still apply. Droid may continue to display **Dynamic** even when OpenCodex
+applies the configured default. Requests without the Droid default header are
+unaffected; the header is a request preference, not proof of client identity.
+For combos and routing policies, each concrete target checks the preference
+against its own effort list, so an incompatible first target does not remove it
+from a compatible fallback.
+
+A saved default that the routed model no longer supports is ignored for requests.
+Clear it in the panel, then review and confirm the change to remove it from Droid.
+
+Refresh preserves defaults while the exact `provider/model` selector remains
+connected. Renaming a provider, model, or combo alias replaces that managed row
+and clears its default; choose a default for the renamed row again. Disable
+removes the defaults with the managed model rows, and Undo restores the saved
+rows and their defaults together.
+
 Models whose IDs or display names contain `,` or `]` are skipped because the
 managed selector cannot address them safely; export and managed settings show
 the same rows. A nonempty catalog with no addressable models is refused.
diff --git a/docs-site/src/content/docs/ko/guides/integrations.md b/docs-site/src/content/docs/ko/guides/integrations.md
index e39df9ea9da..f321c73ac5c 100644
--- a/docs-site/src/content/docs/ko/guides/integrations.md
+++ b/docs-site/src/content/docs/ko/guides/integrations.md
@@ -258,4 +258,27 @@ GitHub Copilot 데스크톱 앱에서 opencodex를 OpenAI 호환 모델 프로
 
 ## Factory Droid
 
+**연동 → Factory Droid** (`/#integrations/droid`)에서 연결된 모델별 추론 기본값을
+설정할 수 있습니다. 모델이 지원하는 effort를 선택하고 변경 내용을 검토한 뒤
+확인하세요. **기본값 없음**은 해당 모델의 편집 중인 값을 지웁니다. 실제로 적용하려면
+**변경 사항 저장 / 검토**에서 확인해야 합니다. 지원 effort
+목록이 없는 모델에는 사용 가능한 기본값이 없다고 표시됩니다.
+
+이 값은 Droid 요청에 effort가 없을 때만 적용됩니다. 요청이 effort를 명시하면
+그 값을 사용하며, 기존 OpenCodex pin과 cap 정책은 계속 적용됩니다. OpenCodex가
+기본값을 적용하더라도 Droid에는 **Dynamic**으로 표시될 수 있습니다. Droid 기본값
+헤더가 없는 요청에는 영향을 주지 않습니다. 이 헤더는 요청의 선호 값이며,
+클라이언트 신원을 증명하지 않습니다.
+콤보와 라우팅 정책에서는 각 실제 대상이 자체 effort 목록으로 이 선호 값을
+확인하므로, 첫 대상이 지원하지 않아도 지원하는 다음 대상으로 전달됩니다.
+
+저장된 기본값을 라우팅된 모델이 더 이상 지원하지 않으면 요청에는 적용하지
+않습니다. Droid 설정에서도 제거하려면 패널에서 지운 뒤 변경 내용을 검토하고
+확인하세요.
+
+새로고침은 정확히 같은 `provider/model` 선택자가 계속 연결된 동안 기본값을
+유지합니다. 프로바이더, 모델, 콤보 별칭의 이름을 바꾸면 관리 행이 교체되고
+기본값이 지워지므로 새 행에서 다시 선택하세요. 연동을 해제하면 관리되는 모델
+행과 기본값이 함께 제거되며, 되돌리기는 저장된 행과 기본값을 함께 복원합니다.
+
 Factory Droid는 `~/.factory/settings.json`(Windows에서는 `%USERPROFILE%\.factory\settings.json`)을 사용합니다. `ocx integration client enable --client droid`로 명시적으로 활성화한 다음 `/model`에서 사용자 지정 모델을 선택하세요. 관리되는 항목에는 키가 없으며 루프백에서만 동작합니다. 비활성화하면 관리되는 항목이 제거되고, Undo는 저장된 원본 바이트를 복원합니다. 기존 `config.json`에 OpenCodex 항목이 있거나 `settings.local.json`이 `customModels`를 덮어쓰면 활성화 전에 충돌을 해결하세요. [Factory BYOK 문서](https://docs.factory.ai/model-independence/byok)를 참고하세요.
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 0d41a71b036..0065b24a615 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -1483,6 +1483,16 @@ export const de: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "Standard für Reasoning-Aufwand",
+  "integrations.droidReasoning.description": "Der Standard gilt nur, wenn eine Anfrage keinen Reasoning-Aufwand angibt. Deaktiviere Factory Droid, um diese gespeicherten Standards zu entfernen.",
+  "integrations.droidReasoning.noDefault": "Kein Standard",
+  "integrations.droidReasoning.noEfforts": "Keine Optionen für die Reasoning-Stärke verfügbar",
+  "integrations.droidReasoning.noModels": "Keine exportierten Modelle verfügbar.",
+  "integrations.droidReasoning.modelDefault": "Standard-Reasoning-Aufwand für {model}",
+  "integrations.droidReasoning.unsupportedTitle": "Einige gespeicherte Standards werden nicht mehr unterstützt. Entferne sie; speichere und prüfe anschließend die Änderungen, um sie anzuwenden.",
+  "integrations.droidReasoning.unsupportedEffort": "Nicht unterstützter Aufwand: {effort}",
+  "integrations.droidReasoning.clear": "Standard entfernen",
+  "integrations.droidReasoning.saveReview": "Änderungen speichern / prüfen",
   "integrations.aside.profilesTitle": "Aside-Profile",
   "integrations.aside.profilesHint": "Wähle, welche Profile die ausgewählten Modelle erhalten. Das aktive Aside-Profil bleibt unverändert.",
   "integrations.aside.all": "Alle Profile synchronisieren",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index b71168448c5..4a626601016 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -2049,6 +2049,16 @@ export const en = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "Default reasoning effort",
+  "integrations.droidReasoning.description": "A default is used only when a request omits its reasoning effort. Disable Factory Droid to remove these saved defaults.",
+  "integrations.droidReasoning.noDefault": "No default",
+  "integrations.droidReasoning.noEfforts": "No reasoning-effort options available",
+  "integrations.droidReasoning.noModels": "No exported models are available.",
+  "integrations.droidReasoning.modelDefault": "Default reasoning effort for {model}",
+  "integrations.droidReasoning.unsupportedTitle": "Some saved defaults are no longer supported. Clear them, then save / review changes to apply.",
+  "integrations.droidReasoning.unsupportedEffort": "Unsupported effort: {effort}",
+  "integrations.droidReasoning.clear": "Clear default",
+  "integrations.droidReasoning.saveReview": "Save / review changes",
   "integrations.aside.profilesTitle": "Aside profiles",
   "integrations.aside.profilesHint": "Choose which profiles receive the selected models. Aside’s active profile stays unchanged.",
   "integrations.aside.all": "Sync all profiles",
diff --git a/gui/src/i18n/fr.ts b/gui/src/i18n/fr.ts
index 01b2f499219..4a07c3cb936 100644
--- a/gui/src/i18n/fr.ts
+++ b/gui/src/i18n/fr.ts
@@ -2021,6 +2021,16 @@ export const fr: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "Niveau de raisonnement par défaut",
+  "integrations.droidReasoning.description": "Le niveau par défaut s’applique uniquement si la requête ne précise aucun niveau de raisonnement. Désactivez Factory Droid pour supprimer ces valeurs enregistrées.",
+  "integrations.droidReasoning.noDefault": "Aucune valeur par défaut",
+  "integrations.droidReasoning.noEfforts": "Aucune option de niveau de raisonnement disponible",
+  "integrations.droidReasoning.noModels": "Aucun modèle exporté n’est disponible.",
+  "integrations.droidReasoning.modelDefault": "Niveau de raisonnement par défaut pour {model}",
+  "integrations.droidReasoning.unsupportedTitle": "Certaines valeurs enregistrées ne sont plus prises en charge. Supprimez-les, puis enregistrez / vérifiez les changements pour les appliquer.",
+  "integrations.droidReasoning.unsupportedEffort": "Niveau non pris en charge : {effort}",
+  "integrations.droidReasoning.clear": "Supprimer la valeur",
+  "integrations.droidReasoning.saveReview": "Enregistrer / vérifier les changements",
   "integrations.aside.profilesTitle": "Profils Aside",
   "integrations.aside.profilesHint": "Choisissez les profils qui recevront les modèles sélectionnés. Le profil actif dans Aside reste inchangé.",
   "integrations.aside.all": "Synchroniser tous les profils",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index e3f01974249..a0a636a0b2a 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -1916,6 +1916,16 @@ export const ja: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "推論レベルの既定値",
+  "integrations.droidReasoning.description": "リクエストに推論レベルが指定されていない場合にのみ既定値が使われます。Factory Droid を無効にすると、保存済みの既定値も削除されます。",
+  "integrations.droidReasoning.noDefault": "既定値なし",
+  "integrations.droidReasoning.noEfforts": "利用可能な推論強度の選択肢はありません",
+  "integrations.droidReasoning.noModels": "エクスポートされたモデルはありません。",
+  "integrations.droidReasoning.modelDefault": "{model} の推論レベルの既定値",
+  "integrations.droidReasoning.unsupportedTitle": "一部の保存済み既定値はサポートされなくなりました。削除した後、変更を保存 / 確認して適用してください。",
+  "integrations.droidReasoning.unsupportedEffort": "未サポートのレベル: {effort}",
+  "integrations.droidReasoning.clear": "既定値を削除",
+  "integrations.droidReasoning.saveReview": "変更を保存 / 確認",
   "integrations.aside.profilesTitle": "Asideのプロファイル",
   "integrations.aside.profilesHint": "選択したモデルを同期するプロファイルを選んでください。Asideで使用中のプロファイルは変わりません。",
   "integrations.aside.all": "すべてのプロファイルを同期",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 7c667aadc75..5e22d0f9a31 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -1527,6 +1527,16 @@ export const ko: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "기본 추론 강도",
+  "integrations.droidReasoning.description": "요청에 추론 강도가 지정되지 않은 경우에만 기본값을 사용합니다. Factory Droid를 비활성화하면 저장된 기본값도 제거됩니다.",
+  "integrations.droidReasoning.noDefault": "기본값 없음",
+  "integrations.droidReasoning.noEfforts": "사용 가능한 추론 강도 없음",
+  "integrations.droidReasoning.noModels": "내보낸 모델이 없습니다.",
+  "integrations.droidReasoning.modelDefault": "{model}의 기본 추론 강도",
+  "integrations.droidReasoning.unsupportedTitle": "저장된 기본값 중 일부가 더 이상 지원되지 않습니다. 지운 다음 변경 사항을 저장 / 검토해야 적용됩니다.",
+  "integrations.droidReasoning.unsupportedEffort": "지원하지 않는 강도: {effort}",
+  "integrations.droidReasoning.clear": "기본값 지우기",
+  "integrations.droidReasoning.saveReview": "변경 사항 저장 / 검토",
   "integrations.aside.profilesTitle": "Aside 프로필",
   "integrations.aside.profilesHint": "선택한 모델을 동기화할 프로필을 고르세요. Aside에서 사용 중인 프로필은 바뀌지 않습니다.",
   "integrations.aside.all": "모든 프로필 동기화",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 9f6b89fbf03..1945d41ed9f 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -2007,6 +2007,16 @@ export const ru: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "Уровень рассуждений по умолчанию",
+  "integrations.droidReasoning.description": "Значение по умолчанию применяется, только если запрос не задаёт уровень рассуждений. Отключите Factory Droid, чтобы удалить сохранённые значения.",
+  "integrations.droidReasoning.noDefault": "Без значения по умолчанию",
+  "integrations.droidReasoning.noEfforts": "Нет доступных вариантов уровня рассуждения",
+  "integrations.droidReasoning.noModels": "Нет доступных экспортированных моделей.",
+  "integrations.droidReasoning.modelDefault": "Уровень рассуждений по умолчанию для {model}",
+  "integrations.droidReasoning.unsupportedTitle": "Некоторые сохранённые значения больше не поддерживаются. Удалите их, затем сохраните / проверьте изменения, чтобы применить их.",
+  "integrations.droidReasoning.unsupportedEffort": "Неподдерживаемый уровень: {effort}",
+  "integrations.droidReasoning.clear": "Удалить значение",
+  "integrations.droidReasoning.saveReview": "Сохранить / проверить изменения",
   "integrations.aside.profilesTitle": "Профили Aside",
   "integrations.aside.profilesHint": "Выберите профили, в которые будут добавлены выбранные модели. Активный профиль Aside не изменится.",
   "integrations.aside.all": "Синхронизировать все профили",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index 596ddc56929..9081c67657e 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -2034,6 +2034,16 @@ export const tr: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "Varsayılan akıl yürütme düzeyi",
+  "integrations.droidReasoning.description": "Varsayılan yalnızca istek akıl yürütme düzeyi belirtmediğinde kullanılır. Kaydedilmiş varsayılanları kaldırmak için Factory Droid'u devre dışı bırakın.",
+  "integrations.droidReasoning.noDefault": "Varsayılan yok",
+  "integrations.droidReasoning.noEfforts": "Kullanılabilir akıl yürütme düzeyi seçeneği yok",
+  "integrations.droidReasoning.noModels": "Dışa aktarılmış model yok.",
+  "integrations.droidReasoning.modelDefault": "{model} için varsayılan akıl yürütme düzeyi",
+  "integrations.droidReasoning.unsupportedTitle": "Kaydedilmiş bazı varsayılanlar artık desteklenmiyor. Bunları temizleyin, ardından uygulamak için değişiklikleri kaydedip inceleyin.",
+  "integrations.droidReasoning.unsupportedEffort": "Desteklenmeyen düzey: {effort}",
+  "integrations.droidReasoning.clear": "Varsayılanı temizle",
+  "integrations.droidReasoning.saveReview": "Değişiklikleri kaydet / incele",
   "integrations.aside.profilesTitle": "Aside profilleri",
   "integrations.aside.profilesHint": "Seçili modellerin hangi profillere aktarılacağını seçin. Aside’ın etkin profili değişmez.",
   "integrations.aside.all": "Tüm profilleri eşitle",
diff --git a/gui/src/i18n/vi.ts b/gui/src/i18n/vi.ts
index fda93dd64fb..a07d696d913 100644
--- a/gui/src/i18n/vi.ts
+++ b/gui/src/i18n/vi.ts
@@ -2004,6 +2004,16 @@ export const vi: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "Mức suy luận mặc định",
+  "integrations.droidReasoning.description": "Chỉ dùng mức mặc định khi yêu cầu không chỉ định mức suy luận. Tắt Factory Droid để xóa các mức mặc định đã lưu.",
+  "integrations.droidReasoning.noDefault": "Không có mặc định",
+  "integrations.droidReasoning.noEfforts": "Không có tùy chọn mức độ suy luận khả dụng",
+  "integrations.droidReasoning.noModels": "Không có mô hình nào được xuất.",
+  "integrations.droidReasoning.modelDefault": "Mức suy luận mặc định cho {model}",
+  "integrations.droidReasoning.unsupportedTitle": "Một số mức mặc định đã lưu không còn được hỗ trợ. Hãy xóa chúng, sau đó lưu / xem lại thay đổi để áp dụng.",
+  "integrations.droidReasoning.unsupportedEffort": "Mức không được hỗ trợ: {effort}",
+  "integrations.droidReasoning.clear": "Xóa mặc định",
+  "integrations.droidReasoning.saveReview": "Lưu / xem lại thay đổi",
   "integrations.aside.profilesTitle": "Cấu hình Aside",
   "integrations.aside.profilesHint": "Chọn profile nào sẽ nhận các model được chọn. Profile đang hoạt động của Aside sẽ được giữ nguyên.",
   "integrations.aside.all": "Đồng bộ tất cả profile",
diff --git a/gui/src/i18n/zh-TW.ts b/gui/src/i18n/zh-TW.ts
index 46d84a91689..9e827acff60 100644
--- a/gui/src/i18n/zh-TW.ts
+++ b/gui/src/i18n/zh-TW.ts
@@ -2896,6 +2896,16 @@ export const zhTW: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "預設推理強度",
+  "integrations.droidReasoning.description": "只有在要求未指定推理強度時才會使用預設值。停用 Factory Droid 會移除這些已儲存的預設值。",
+  "integrations.droidReasoning.noDefault": "無預設值",
+  "integrations.droidReasoning.noEfforts": "沒有可用的推理強度選項",
+  "integrations.droidReasoning.noModels": "沒有可匯出的模型。",
+  "integrations.droidReasoning.modelDefault": "{model} 的預設推理強度",
+  "integrations.droidReasoning.unsupportedTitle": "部分已儲存的預設值已不再支援。清除後，請儲存 / 檢查變更以套用。",
+  "integrations.droidReasoning.unsupportedEffort": "不支援的強度：{effort}",
+  "integrations.droidReasoning.clear": "清除預設值",
+  "integrations.droidReasoning.saveReview": "儲存 / 檢查變更",
   "integrations.aside.profilesTitle": "Aside 設定檔",
   "integrations.aside.profilesHint": "選擇要接收所選模型的設定檔。Aside 目前使用的設定檔不會改變。",
   "integrations.aside.all": "同步所有設定檔",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 0ffc79db81f..902d4438e23 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -1500,6 +1500,16 @@ export const zh: Record<TKey, string> = {
   "integrations.tab.cline": "Cline CLI",
   "integrations.tab.kilo": "Kilo",
   "integrations.tab.droid": "Factory Droid",
+  "integrations.droidReasoning.title": "默认推理强度",
+  "integrations.droidReasoning.description": "仅当请求未指定推理强度时才使用默认值。停用 Factory Droid 会删除这些已保存的默认值。",
+  "integrations.droidReasoning.noDefault": "无默认值",
+  "integrations.droidReasoning.noEfforts": "没有可用的推理强度选项",
+  "integrations.droidReasoning.noModels": "没有可导出的模型。",
+  "integrations.droidReasoning.modelDefault": "{model} 的默认推理强度",
+  "integrations.droidReasoning.unsupportedTitle": "部分已保存的默认值已不再受支持。清除后，请保存 / 检查更改以应用。",
+  "integrations.droidReasoning.unsupportedEffort": "不支持的强度：{effort}",
+  "integrations.droidReasoning.clear": "清除默认值",
+  "integrations.droidReasoning.saveReview": "保存 / 检查更改",
   "integrations.aside.profilesTitle": "Aside 配置文件",
   "integrations.aside.profilesHint": "选择要接收所选模型的配置文件。Aside 当前使用的配置文件不会改变。",
   "integrations.aside.all": "同步所有配置文件",
diff --git a/gui/src/pages/integrations/DroidReasoningDefaultsPanel.tsx b/gui/src/pages/integrations/DroidReasoningDefaultsPanel.tsx
new file mode 100644
index 00000000000..3238ed2b1ef
--- /dev/null
+++ b/gui/src/pages/integrations/DroidReasoningDefaultsPanel.tsx
@@ -0,0 +1,99 @@
+import { useT } from "../../i18n/shared";
+import { Select } from "../../ui";
+import type { DroidReasoningStatus } from "./integration-api";
+
+export default function DroidReasoningDefaultsPanel({
+  reasoning,
+  defaults,
+  disabled,
+  onChange,
+  onReview,
+}: {
+  reasoning: DroidReasoningStatus;
+  defaults: Record<string, string>;
+  disabled: boolean;
+  onChange: (next: Record<string, string>) => void;
+  onReview: () => void;
+}) {
+  const t = useT();
+  const effortsByModel = new Map(reasoning.models.map(model => [model.model, new Set(model.efforts)]));
+  const unsupported = Object.entries(defaults).filter(([modelId, effort]) => {
+    return !effortsByModel.get(modelId)?.has(effort);
+  });
+
+  const setDefault = (model: string, effort: string) => {
+    const next = { ...defaults };
+    if (effort) next[model] = effort;
+    else delete next[model];
+    onChange(next);
+  };
+
+  return (
+    <section className="droid-reasoning-panel" aria-labelledby="droid-reasoning-title">
+      <div className="droid-reasoning-heading">
+        <div>
+          <h4 id="droid-reasoning-title">{t("integrations.droidReasoning.title")}</h4>
+          <p className="page-sub">{t("integrations.droidReasoning.description")}</p>
+        </div>
+        <button type="button" className="btn btn-primary" onClick={onReview} disabled={disabled}>
+          {t("integrations.droidReasoning.saveReview")}
+        </button>
+      </div>
+
+      {reasoning.models.length > 0 ? (
+        <ul className="droid-reasoning-list">
+          {reasoning.models.map(model => {
+            const selected = defaults[model.model] ?? "";
+            const declared = model.efforts.includes(selected);
+            const options = [
+              { value: "", label: t("integrations.droidReasoning.noDefault") },
+              ...(!declared && selected ? [{
+                value: selected,
+                label: t("integrations.droidReasoning.unsupportedEffort", { effort: selected }),
+              }] : []),
+              ...model.efforts.map(effort => ({ value: effort, label: effort })),
+            ];
+            return (
+              <li className="droid-reasoning-row" key={model.model}>
+                <div className="droid-reasoning-model">
+                  <span>{model.label}</span>
+                  <code>{model.model}</code>
+                </div>
+                {model.efforts.length > 0 ? (
+                  <Select
+                    value={selected}
+                    options={options}
+                    onChange={effort => setDefault(model.model, effort)}
+                    disabled={disabled}
+                    label={t("integrations.droidReasoning.modelDefault", { model: model.label })}
+                  />
+                ) : (
+                  <span className="muted text-caption">{t("integrations.droidReasoning.noEfforts")}</span>
+                )}
+              </li>
+            );
+          })}
+        </ul>
+      ) : (
+        <p className="page-sub">{t("integrations.droidReasoning.noModels")}</p>
+      )}
+
+      {unsupported.length > 0 && (
+        <div className="droid-reasoning-unsupported" role="status">
+          <p>{t("integrations.droidReasoning.unsupportedTitle")}</p>
+          <ul>
+            {unsupported.map(([model, effort]) => (
+              <li key={model}>
+                <code>{model}</code>
+                {" "}{t("integrations.droidReasoning.unsupportedEffort", { effort })}
+                <button type="button" className="btn btn-ghost btn-sm" disabled={disabled} onClick={() => setDefault(model, "")}>
+                  {t("integrations.droidReasoning.clear")}
+                </button>
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+    </section>
+  );
+}
diff --git a/gui/src/pages/integrations/FileIntegrationPage.tsx b/gui/src/pages/integrations/FileIntegrationPage.tsx
index bcfa783178e..69b5c40414b 100644
--- a/gui/src/pages/integrations/FileIntegrationPage.tsx
+++ b/gui/src/pages/integrations/FileIntegrationPage.tsx
@@ -9,6 +9,7 @@ import IntegrationStateBadge from "./IntegrationStateBadge";
 import ConsequenceDialog, { type ConsequenceCopy } from "./ConsequenceDialog";
 import RestoreDialog from "./RestoreDialog";
 import RaycastPlanNotice from "./RaycastPlanNotice";
+import DroidReasoningDefaultsPanel from "./DroidReasoningDefaultsPanel";
 import { RollbackHistory } from "./RollbackHistory";
 import { describeRefusal } from "./refusal-copy";
 import {
@@ -123,7 +124,16 @@ export default function FileIntegrationPage({
 }) {
   const t = useT();
   const scopeKey = profileId === undefined ? client : `${client}:${profileId}`;
+  const [draftScope, setDraftScope] = useState(scopeKey);
   const [pending, setPending] = useState(false);
+  const [droidReasoningDraft, setDroidReasoningDraft] = useState<{
+    scopeKey: string;
+    values: Record<string, string>;
+  } | null>(null);
+  if (draftScope !== scopeKey) {
+    setDraftScope(scopeKey);
+    setDroidReasoningDraft(null);
+  }
   const [failure, setFailure] = useState<string | null>(null);
   const [restoring, setRestoring] = useState<IntegrationJournalRow | null>(null);
   /* The row awaiting delete confirmation. */
@@ -133,6 +143,7 @@ export default function FileIntegrationPage({
     plan: IntegrationMutationPlan | null;
     loading: boolean;
     failure: string | null;
+    droidReasoningDefaults?: Record<string, string>;
   } | null>(null);
   const previewAbortRef = useRef<AbortController | null>(null);
   const previewGenerationRef = useRef(0);
@@ -182,8 +193,21 @@ export default function FileIntegrationPage({
     void historyResource.refresh();
   };
 
-  const requestMutation = async (operation: Exclude<IntegrationPlanOperation, "restore">) => {
+  const resetDroidDraft = () => {
+    setDroidReasoningDraft(null);
+    refresh();
+  };
+
+  const requestMutation = async (
+    operation: Exclude<IntegrationPlanOperation, "restore">,
+    reasoningDefaults = client === "droid" && operation !== "disable"
+      ? (droidReasoningDraft?.scopeKey === scopeKey
+        ? droidReasoningDraft.values
+        : undefined)
+      : undefined,
+  ) => {
     if (!status || pending || plannedMutation) return;
+    const defaultsSnapshot = reasoningDefaults === undefined ? undefined : { ...reasoningDefaults };
     const controller = new AbortController();
     const generation = previewGenerationRef.current + 1;
     previewGenerationRef.current = generation;
@@ -191,10 +215,10 @@ export default function FileIntegrationPage({
     previewAbortRef.current = controller;
     setPlannedMutation({ operation, plan: null, loading: true, failure: null });
     try {
-      const plan = await previewIntegrationMutation(apiBase, client, operation, controller.signal, profileId);
+      const plan = await previewIntegrationMutation(apiBase, client, operation, controller.signal, profileId, defaultsSnapshot);
       if (controller.signal.aborted || generation !== previewGenerationRef.current) return;
       previewAbortRef.current = null;
-      setPlannedMutation({ operation, plan, loading: false, failure: null });
+      setPlannedMutation({ operation, plan, loading: false, failure: null, droidReasoningDefaults: defaultsSnapshot });
     } catch (error) {
       if (controller.signal.aborted || generation !== previewGenerationRef.current) return;
       previewAbortRef.current = null;
@@ -224,8 +248,12 @@ export default function FileIntegrationPage({
         overwriteConflict: plan.operation === "overwrite",
         profileId,
         binding: bindingFor(plan),
+        ...(plan.operation !== "disable" && plannedMutation?.droidReasoningDefaults !== undefined
+          ? { droidReasoningDefaults: plannedMutation.droidReasoningDefaults }
+          : {}),
       });
       setPlannedMutation(null);
+      if (client === "droid") setDroidReasoningDraft(null);
     } catch (error) {
       refresh();
       if (error instanceof IntegrationApiError && error.stalePlan) throw error;
@@ -314,6 +342,20 @@ export default function FileIntegrationPage({
         </button>
       )}
 
+      {client === "droid" && status.droidReasoning && (
+        <DroidReasoningDefaultsPanel
+          reasoning={status.droidReasoning}
+          defaults={droidReasoningDraft?.scopeKey === scopeKey
+            ? droidReasoningDraft.values
+            : status.droidReasoning.defaults}
+          disabled={pending || plannedMutation !== null}
+          onChange={values => setDroidReasoningDraft({ scopeKey, values })}
+          onReview={() => void requestMutation("apply", (droidReasoningDraft?.scopeKey === scopeKey
+            ? droidReasoningDraft.values
+            : status.droidReasoning?.defaults) ?? {})}
+        />
+      )}
+
       {/*
         Conflict used to be a dead end: the switch locks, the page explains why,
         and the only way forward was to open the file and edit it by hand -- which
@@ -385,7 +427,7 @@ export default function FileIntegrationPage({
           row={restoring}
           profileId={profileId}
           onClose={() => setRestoring(null)}
-          onRestored={refresh}
+          onRestored={() => { if (client === "droid") resetDroidDraft(); else refresh(); }}
           onReconcile={refresh}
         />
       )}
diff --git a/gui/src/pages/integrations/integration-api.ts b/gui/src/pages/integrations/integration-api.ts
index 873e28683fa..f56fee8c210 100644
--- a/gui/src/pages/integrations/integration-api.ts
+++ b/gui/src/pages/integrations/integration-api.ts
@@ -81,6 +81,18 @@ export interface IntegrationStatus {
   profileId?: number;
   enabled?: boolean;
   raycast?: RaycastInstall;
+  droidReasoning?: DroidReasoningStatus;
+}
+
+export interface DroidReasoningModel {
+  model: string;
+  label: string;
+  efforts: string[];
+}
+
+export interface DroidReasoningStatus {
+  models: DroidReasoningModel[];
+  defaults: Record<string, string>;
 }
 
 /** A candidate issue can block adding Kilo while removal still targets its recorded file. */
@@ -165,6 +177,7 @@ export interface ToggleIntegrationOptions {
   overwriteConflict?: boolean;
   profileId?: number;
   binding?: IntegrationPlanBinding;
+  droidReasoningDefaults?: Record<string, string>;
 }
 
 export interface RestoreIntegrationOptions {
@@ -465,9 +478,14 @@ export async function previewIntegrationMutation(
   operation: Exclude<IntegrationPlanOperation, "restore">,
   signal?: AbortSignal,
   profileId?: number,
+  droidReasoningDefaults?: Record<string, string>,
 ) {
   const path = profileId === undefined ? "/api/client-integrations/preview" : `${profilePath(profileId)}/preview`;
-  const requestBody = profileId === undefined ? { clientId: client, operation } : { operation };
+  const requestBody = {
+    ...(profileId === undefined ? { clientId: client } : {}),
+    operation,
+    ...(client === "droid" && droidReasoningDefaults !== undefined ? { droidReasoningDefaults } : {}),
+  };
   const plan = parseIntegrationMutationPlan(await readResponse<unknown>(await fetch(`${apiBase}${path}`, {
     method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(requestBody), signal,
   })));
@@ -492,14 +510,15 @@ export async function previewIntegrationRestore(
 }
 
 export async function toggleIntegration(apiBase: string, client: FileIntegrationClientId, options: ToggleIntegrationOptions) {
-  const { enabled, signal, overwriteConflict, profileId, binding } = options;
+  const { enabled, signal, overwriteConflict, profileId, binding, droidReasoningDefaults } = options;
   const expectedOperation: IntegrationPlanOperation = enabled ? (overwriteConflict ? "overwrite" : "apply") : "disable";
   let result: IntegrationToggleResult | { ok: false; message?: string; results?: unknown };
   try {
     result = await readResponse<IntegrationToggleResult | { ok: false; message?: string; results?: unknown }>(await fetch(`${apiBase}${clientPath(client, profileId)}`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ enabled, ...(overwriteConflict === true ? { overwriteConflict: true } : {}), ...binding }),
+      body: JSON.stringify({ enabled, ...(overwriteConflict === true ? { overwriteConflict: true } : {}), ...binding,
+        ...(client === "droid" && droidReasoningDefaults !== undefined ? { droidReasoningDefaults } : {}) }),
       signal,
     }));
   } catch (error) {
diff --git a/gui/src/styles-integrations.css b/gui/src/styles-integrations.css
index e894bcfb454..98d70c9354c 100644
--- a/gui/src/styles-integrations.css
+++ b/gui/src/styles-integrations.css
@@ -55,6 +55,19 @@
 .integration-client-head { display: flex; align-items: center; gap: 10px; }
 .integration-client-head h3 { margin: 0; }
 
+.droid-reasoning-panel { display: flex; flex-direction: column; gap: 12px; margin: 16px 0; padding: 14px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--raised); }
+.droid-reasoning-heading { display: flex; align-items: flex-start; justify-content: space-between; flex-wrap: wrap; gap: 12px; }
+.droid-reasoning-heading h4, .droid-reasoning-heading p { margin: 0; }
+.droid-reasoning-heading p { margin-top: 4px; }
+.droid-reasoning-list, .droid-reasoning-unsupported ul { list-style: none; padding: 0; margin: 0; }
+.droid-reasoning-row { display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 10px; padding: 10px 0; border-top: 1px solid var(--border-soft); }
+.droid-reasoning-model { display: grid; gap: 2px; min-width: 0; }
+.droid-reasoning-model code, .droid-reasoning-unsupported code { overflow-wrap: anywhere; }
+.droid-reasoning-unsupported { padding-top: 10px; border-top: 1px solid var(--border-soft); }
+.droid-reasoning-unsupported p { margin: 0 0 8px; color: var(--red); font-weight: var(--weight-semibold); }
+.droid-reasoning-unsupported li { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; padding: 4px 0; }
+.droid-reasoning-unsupported .btn { margin-left: auto; }
+
 /* One brand mark, four surfaces. Sized from a custom property so the same three
    rules serve the 14px tab strip, the 20px overview card and the 24px client
    page header without a variant class per size. */
diff --git a/gui/tests/integrations-surfaces.test.tsx b/gui/tests/integrations-surfaces.test.tsx
index 9ca790c64b6..6c7dedb0385 100644
--- a/gui/tests/integrations-surfaces.test.tsx
+++ b/gui/tests/integrations-surfaces.test.tsx
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, expect, test } from "bun:test";
 import { Window } from "happy-dom";
 import { act } from "react";
 import type { Root } from "react-dom/client";
+import { setClientResourceData } from "../src/client-resource";
 
 /**
  * Mounted behavior for the Integrations surfaces.
@@ -237,7 +238,7 @@ afterEach(async () => {
 
 async function mountClient(
   active = true,
-  client: "hermes" | "dsh" | "kilo" = "hermes",
+  client: "hermes" | "dsh" | "kilo" | "droid" = "hermes",
 ): Promise<void> {
   const [{ createRoot }, { LanguageProvider }, { default: FileIntegrationPage }] = await Promise.all([
     import("react-dom/client"),
@@ -262,7 +263,7 @@ async function mountClient(
  * replays the first response and the new `stateResponse` has no effect. Rotating
  * the base is what makes a state sweep in a single test possible at all.
  */
-async function remountClient(client: "hermes" | "dsh" | "kilo" = "hermes"): Promise<void> {
+async function remountClient(client: "hermes" | "dsh" | "kilo" | "droid" = "hermes"): Promise<void> {
   if (root) {
     const current = root;
     await act(async () => { current.unmount(); });
@@ -293,6 +294,98 @@ test("the DSH surface uses localized ownership semantics and its own API route",
   expect(requests.some(request => request.url.endsWith("/api/client-integrations/dsh"))).toBe(true);
 });
 
+test("Droid reasoning defaults use one frozen snapshot for review and commit", async () => {
+  let savedDefaults: Record<string, string> = {};
+  stateResponse = () => json(status({
+    clientId: "droid",
+    configPath: "/tmp/factory/settings.json",
+    droidReasoning: {
+      models: [{ model: "openai/gpt-test", label: "Test model", efforts: ["low", "high"] }],
+      defaults: savedDefaults,
+    },
+  }));
+  putResponse = request => {
+    savedDefaults = (request.body as { droidReasoningDefaults?: Record<string, string> }).droidReasoningDefaults ?? {};
+    return json({ ok: true, clientId: "droid", changed: true, state: "current", message: "saved" });
+  };
+  await mountClient(true, "droid");
+
+  expect(container.textContent).toContain("A default is used only when a request omits its reasoning effort");
+  expect(buttonByText("Save / review changes")?.disabled).toBe(false);
+  const selector = container.querySelector<HTMLButtonElement>('[role="combobox"]')!;
+  await act(async () => { selector.click(); });
+  const high = Array.from(testWindow.document.querySelectorAll('[role="option"]')).find(option => option.textContent === "high") as HTMLButtonElement;
+  await act(async () => { high.click(); });
+  await act(async () => { buttonByText("Save / review changes")!.click(); });
+  await act(async () => { await new Promise<void>(resolve => testWindow.setTimeout(resolve, 20)); });
+
+  const preview = requests.find(request => request.method === "POST" && request.url.endsWith("/api/client-integrations/preview"));
+  expect(preview?.body).toMatchObject({
+    clientId: "droid",
+    operation: "apply",
+    droidReasoningDefaults: { "openai/gpt-test": "high" },
+  });
+  expect(container.querySelector<HTMLButtonElement>('[role="combobox"]')?.disabled).toBe(true);
+  await confirmDialog("Apply");
+
+  const mutation = requests.find(request => request.method === "PUT" && request.url.endsWith("/api/client-integrations/droid"));
+  expect(mutation?.body).toMatchObject({
+    enabled: true,
+    droidReasoningDefaults: { "openai/gpt-test": "high" },
+  });
+  expect(savedDefaults).toEqual({ "openai/gpt-test": "high" });
+  expect(container.querySelector<HTMLButtonElement>('[role="combobox"]')?.disabled).toBe(false);
+
+  savedDefaults = { "openai/gpt-test": "low" };
+  await act(async () => {
+    setClientResourceData(`integration-state:${apiBase}:droid`, status({
+      clientId: "droid",
+      configPath: "/tmp/factory/settings.json",
+      droidReasoning: {
+        models: [{ model: "openai/gpt-test", label: "Test model", efforts: ["low", "high"] }],
+        defaults: savedDefaults,
+      },
+    }));
+  });
+  expect(container.querySelector<HTMLButtonElement>('[role="combobox"]')?.textContent).toContain("low");
+});
+
+test("Droid refresh omits unsupported saved defaults while an explicit edit stays frozen through confirm", async () => {
+  stateResponse = () => json(status({
+    clientId: "droid",
+    state: "stale",
+    configPath: "/tmp/factory/settings.json",
+    droidReasoning: {
+      models: [{ model: "openai/gpt-test", label: "Test model", efforts: ["low"] }],
+      defaults: { "openai/gpt-test": "high" },
+    },
+  }));
+  await mountClient(true, "droid");
+
+  await act(async () => { buttonByText("Update")!.click(); });
+  await act(async () => { await new Promise<void>(resolve => testWindow.setTimeout(resolve, 20)); });
+  const refreshPreview = requests.find(request => request.method === "POST" && request.url.endsWith("/api/client-integrations/preview"));
+  expect(refreshPreview?.body).not.toHaveProperty("droidReasoningDefaults");
+
+  const dialog = container.querySelector("dialog[open]")!;
+  const close = Array.from(dialog.querySelectorAll("button")).find(button => button.textContent?.trim() === "Close") as HTMLButtonElement;
+  await act(async () => { close.click(); });
+
+  const selector = container.querySelector<HTMLButtonElement>('[role="combobox"]')!;
+  await act(async () => { selector.click(); });
+  const low = Array.from(testWindow.document.querySelectorAll('[role="option"]')).find(option => option.textContent === "low") as HTMLButtonElement;
+  await act(async () => { low.click(); });
+  await act(async () => { buttonByText("Save / review changes")!.click(); });
+  await act(async () => { await new Promise<void>(resolve => testWindow.setTimeout(resolve, 20)); });
+
+  const previews = requests.filter(request => request.method === "POST" && request.url.endsWith("/api/client-integrations/preview"));
+  expect(previews[1]?.body).toMatchObject({ droidReasoningDefaults: { "openai/gpt-test": "low" } });
+  expect(container.querySelector<HTMLButtonElement>('[role="combobox"]')?.disabled).toBe(true);
+  await confirmDialog("Apply");
+  const mutation = requests.find(request => request.method === "PUT" && request.url.endsWith("/api/client-integrations/droid"));
+  expect(mutation?.body).toMatchObject({ droidReasoningDefaults: { "openai/gpt-test": "low" } });
+});
+
 function buttons(): HTMLButtonElement[] {
   return Array.from(container.querySelectorAll("button")) as unknown as HTMLButtonElement[];
 }
diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json
index 646700d05c6..bd500314276 100644
--- a/scripts/test-layout/layout.json
+++ b/scripts/test-layout/layout.json
@@ -2,6 +2,9 @@
   "version": 1,
   "root": "tests",
   "explicit": {
+    "droid-managed-reasoning-defaults.test.ts": "clients",
+    "management-droid-reasoning-defaults.test.ts": "server",
+    "droid-reasoning-defaults.test.ts": "responses",
     "claude-intercept-on-demand.test.ts": "claude-integration",
     "main-account-hard-lock-thresholds.test.ts": "codex-integration",
     "main-account-external-usage.test.ts": "codex-integration",
diff --git a/src/clients/config-export.ts b/src/clients/config-export.ts
index 63efee0c0f3..9d940576cc3 100644
--- a/src/clients/config-export.ts
+++ b/src/clients/config-export.ts
@@ -30,7 +30,7 @@ import { probeHostname } from "../server/proxy-liveness";
 import type { OcxConfig } from "../types";
 
 export type { ConfigFormat } from "../integrations/serialize";
-export type { ManagedFragment, ManagedContribution, BuildContribution, OpencodeLaunchEnv, OpencodeCatalogModel, ExportModel, ExportContext, ExportClientId, ExportClientSpec, PiModelEntry } from "./config-export/contracts";
+export type { ManagedFragment, ManagedContribution, BuildContribution, OpencodeLaunchEnv, OpencodeCatalogModel, ExportModel, ExportContext, ExportClientId, ExportClientSpec, PiModelEntry, DroidReasoningDefaults } from "./config-export/contracts";
 export { OPENCODE_PROVIDER_ID, OPENCODE_CONFIG_SCHEMA, OPENCODE_API_KEY_ENV, OPENCODE_API_KEY_ENV_REF, KILO_API_KEY_ENV, KILO_API_KEY_ENV_REF, KILO_CONFIG_SCHEMA, HERMES_API_KEY_ENV, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV, OPENCLAW_API_KEY_ENV_REF, LOOPBACK_API_KEY_PLACEHOLDER, GAJAE_API_KEY_ENV, SCHEMA_REQUIRED_OUTPUT_BUDGET, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG } from "./config-export/constants";
 export { normalizeExportModels } from "./config-export/model-metadata";
 export type { OmpModelEntry, OmpProviderBlock, OmpGeneratedConfig } from "./config-export/omp";
@@ -51,7 +51,7 @@ export type { DshReasoningEffort, DshWireReasoningEffort, DshModelEntry, DshProv
 export type { McodeProviderBlock, McodeModelEntry, McodeGeneratedConfig } from "./config-export/mcode";
 export type { RaycastAbility, RaycastAbilityName, RaycastModelEntry, RaycastProviderEntry, RaycastGeneratedConfig } from "./config-export/raycast";
 export { buildRaycastClientConfig, summarizeRaycast, buildRaycastContribution } from "./config-export/raycast";
-export { droidHomeDir, droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidContribution } from "./config-export/droid";
+export { droidHomeDir, droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidContribution, droidReasoningModels, droidDefaultsFromOwnedRows, validateDroidReasoningDefaults } from "./config-export/droid";
 export type { DroidModelEntry, DroidGeneratedConfig } from "./config-export/droid";
 
 import type { OpencodeLaunchEnv, OpencodeCatalogModel, ExportContext, PiModelEntry, ManagedContribution, ManagedFragment, ExportClientId, ExportClientSpec } from "./config-export/contracts";
diff --git a/src/clients/config-export/contracts.ts b/src/clients/config-export/contracts.ts
index f32d4abff96..9898d5e9a85 100644
--- a/src/clients/config-export/contracts.ts
+++ b/src/clients/config-export/contracts.ts
@@ -2,6 +2,8 @@
 import type { OcxConfig } from "../../types";
 import type { ConfigFormat } from "../../integrations/serialize";
 
+export const DROID_DEFAULT_EFFORT_HEADER = "x-opencodex-droid-default-effort";
+
 /**
  * One entry opencodex owns inside a client's config: the JSON path to it and
  * the value we put there.
@@ -88,8 +90,12 @@ export interface ExportContext {
    * admission from `apiKey` to the `x-opencodex-api-key` header.
    */
   config?: OcxConfig;
+  droidReasoningDefaults?: DroidReasoningDefaults;
 }
 
+/** Namespaced model selector to one of that model's declared reasoning efforts. */
+export type DroidReasoningDefaults = Record<string, string>;
+
 export type ExportClientId =
   | "opencode"
   | "pi"
diff --git a/src/clients/config-export/droid.ts b/src/clients/config-export/droid.ts
index 1dfc14556b0..909ea3347d0 100644
--- a/src/clients/config-export/droid.ts
+++ b/src/clients/config-export/droid.ts
@@ -1,9 +1,11 @@
 import { win32, join } from "node:path";
 import { homedir } from "node:os";
 import { exportPresentationLabel } from "../model-presentation";
-import type { ExportContext, ManagedContribution, OpencodeLaunchEnv } from "./contracts";
+import type { DroidReasoningDefaults, ExportContext, ExportModel, ManagedContribution, OpencodeLaunchEnv } from "./contracts";
 import { normalizeExportModels } from "./model-metadata";
-import { formatSelectorConjunction } from "../../integrations/merge";
+import { formatSelectorConjunction, readPath } from "../../integrations/merge";
+
+import { DROID_DEFAULT_EFFORT_HEADER } from "./contracts";
 
 /** Factory personal settings: https://docs.factory.ai/model-independence/byok */
 export interface DroidModelEntry {
@@ -12,6 +14,7 @@ export interface DroidModelEntry {
   baseUrl: string;
   provider: "generic-chat-completion-api";
   noImageSupport: boolean;
+  extraHeaders?: Record<string, string>;
 }
 
 export interface DroidGeneratedConfig { customModels: DroidModelEntry[] }
@@ -43,11 +46,59 @@ function buildDroidRows(ctx: ExportContext): Array<{ row: DroidModelEntry; selec
       baseUrl: ctx.baseUrl,
       provider: "generic-chat-completion-api",
       noImageSupport: !model.inputModalities?.includes("image"),
+      ...(ctx.droidReasoningDefaults && Object.hasOwn(ctx.droidReasoningDefaults, model.namespaced)
+        ? { extraHeaders: { [DROID_DEFAULT_EFFORT_HEADER]: ctx.droidReasoningDefaults[model.namespaced]! } }
+        : {}),
     } });
   }
   return rows;
 }
 
+export function droidReasoningModels(models: readonly ExportModel[]): Array<{ model: string; label: string; efforts: string[] }> {
+  const effortsByModel = new Map(normalizeExportModels(models).map(model => [model.namespaced, model.reasoningEfforts ?? []]));
+  return buildDroidRows({ baseUrl: "", models }).map(({ row }) => ({
+    model: row.model,
+    label: row.displayName.replace(/^OpenCodex: /, ""),
+    efforts: effortsByModel.get(row.model) ?? [],
+  }));
+}
+
+export function droidDefaultsFromOwnedRows(
+  ctx: ExportContext,
+  document: unknown,
+  fragmentPaths: readonly (readonly string[])[],
+): DroidReasoningDefaults {
+  const exportableModels = new Set(droidReasoningModels(ctx.models).map(model => model.model));
+  const defaults: DroidReasoningDefaults = {};
+  for (const path of fragmentPaths) {
+    if (path.length !== 2 || path[0] !== "customModels") continue;
+    const value = readPath(document, path);
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const current = value as Record<string, unknown>;
+    if (typeof current.model !== "string" || !exportableModels.has(current.model)) continue;
+    const headers = current.extraHeaders;
+    if (!headers || typeof headers !== "object" || Array.isArray(headers)) continue;
+    const header = headers as Record<string, unknown>;
+    if (typeof header[DROID_DEFAULT_EFFORT_HEADER] !== "string") continue;
+    defaults[current.model] = header[DROID_DEFAULT_EFFORT_HEADER] as string;
+  }
+  return defaults;
+}
+
+export function validateDroidReasoningDefaults(
+  models: readonly ExportModel[],
+  defaults: unknown,
+): string | null {
+  if (!defaults || typeof defaults !== "object" || Array.isArray(defaults)) return "droidReasoningDefaults must be an object";
+  const addressable = new Map(droidReasoningModels(models).map(model => [model.model, model.efforts]));
+  for (const [model, effort] of Object.entries(defaults)) {
+    const efforts = addressable.get(model);
+    if (!efforts) return `model ${model} is not currently exportable to Droid`;
+    if (typeof effort !== "string" || !efforts.includes(effort)) return `effort for ${model} is not declared by that model`;
+  }
+  return null;
+}
+
 export function buildDroidClientConfig(ctx: ExportContext): DroidGeneratedConfig {
   const rows = buildDroidRows(ctx);
   if (ctx.models.length > 0 && rows.length === 0) {
diff --git a/src/integrations/mutation-plan.ts b/src/integrations/mutation-plan.ts
index c35ee4e27d5..9a680db2227 100644
--- a/src/integrations/mutation-plan.ts
+++ b/src/integrations/mutation-plan.ts
@@ -36,7 +36,7 @@ import {
 } from "./registry";
 import { declaredIntegrationTarget, resolveIntegrationTarget, type IntegrationTarget } from "./target";
 import { shouldInjectApiAuthHeader } from "../codex/inject";
-import { classifyIntegration, exportContextOf, readPath, type IntegrationState, type StateReason } from "./state";
+import { buildIntegrationContribution, classifyIntegration, exportContextOf, readPath, type IntegrationState, type StateReason } from "./state";
 import { inspectKiloCandidates } from "./kilo-candidates";
 import { InvalidSelectorError } from "./merge";
 import { createIntegrationStateStore, type IntegrationStateStore } from "./store";
@@ -791,6 +791,8 @@ export interface IntegrationWriteInput {
   models: readonly ExportModel[];
   config: OcxConfig;
   port: number;
+  /** Explicit Droid-only defaults; omitted means retain matching owned rows. */
+  droidReasoningDefaults?: Record<string, string>;
   env?: NodeJS.ProcessEnv;
   home?: string;
   store?: IntegrationStateStore;
@@ -936,13 +938,13 @@ export function observeIntegration(
    * reads a different document there, and a write in the config file's shape
    * would be as unread as a write to the config file itself.
    */
-  const contribution = effective.buildContribution(exportContextOf(input));
   // A record proves ownership of the file it was written FOR. Matching only by
   // client id let a record for one home authorize a write to another whose
   // bytes happened to hash the same — which deleted a config we never touched.
   const record = stored && stored.clientId === clientId && stored.configPath === configPath
     ? stored
     : null;
+  const contribution = buildIntegrationContribution(input, effective, parsed, record);
   if (clientId === "droid" && input.models.length > 0 && contribution.fragments.length === 0 && !record) {
     return { failed: observationFailure("unsafe", "unsafe", "Factory Droid has no addressable models in the selected catalog") } as const;
   }
diff --git a/src/integrations/state.ts b/src/integrations/state.ts
index 1e396eb8659..031164237ad 100644
--- a/src/integrations/state.ts
+++ b/src/integrations/state.ts
@@ -10,7 +10,7 @@
  */
 import { createClineIO } from "./cline-io";
 import { parseClineDocument } from "./cline-document";
-import { ClientPathError, EXPORT_CLIENTS, opencodeProxyBaseUrl, type ExportModel, type ManagedContribution } from "../clients/config-export";
+import { ClientPathError, EXPORT_CLIENTS, opencodeProxyBaseUrl, droidDefaultsFromOwnedRows, type ExportModel, type ManagedContribution } from "../clients/config-export";
 import type { ConfigFormat } from "../clients/config-export";
 import type { OcxConfig } from "../types";
 import { PARSE_FAILED, loadTarget, parseConfig, type IntegrationIO } from "./config-io";
@@ -449,6 +449,7 @@ export interface IntegrationStateInput {
   models: readonly ExportModel[];
   config: OcxConfig;
   port: number;
+  droidReasoningDefaults?: Record<string, string>;
   env?: NodeJS.ProcessEnv;
   home?: string;
   /** The whole integration state store, bound to one root. */
@@ -462,7 +463,8 @@ export function exportContextOf(input: {
   models: readonly ExportModel[];
   config: OcxConfig;
   port: number;
-}): { baseUrl: string; models: readonly ExportModel[]; config: OcxConfig } {
+  droidReasoningDefaults?: Record<string, string>;
+}): { baseUrl: string; models: readonly ExportModel[]; config: OcxConfig; droidReasoningDefaults?: Record<string, string> } {
   return {
     /*
      * Composed through the SAME helper `ocx export` uses. Interpolating the
@@ -476,9 +478,41 @@ export function exportContextOf(input: {
     baseUrl: opencodeProxyBaseUrl(input.port, input.config.hostname, input.config),
     models: input.models,
     config: input.config,
+    ...(input.droidReasoningDefaults === undefined ? {} : { droidReasoningDefaults: input.droidReasoningDefaults }),
   };
 }
 
+export function buildIntegrationContribution(
+  input: IntegrationStateInput,
+  effective: IntegrationTarget,
+  parsed: unknown,
+  record: OwnershipRecord | null,
+): ManagedContribution {
+  const context = exportContextOf(input);
+  if (input.clientId === "droid" && input.droidReasoningDefaults === undefined && record?.configPath === effective.configPath) {
+    const inherited = recordedDroidContributionMatches(parsed, record)
+      ? droidDefaultsFromOwnedRows(context, parsed, record.fragmentPaths)
+      : {};
+    if (Object.keys(inherited).length > 0) context.droidReasoningDefaults = inherited;
+  }
+  return effective.buildContribution(context);
+}
+
+function recordedDroidContributionMatches(document: unknown, record: OwnershipRecord): boolean {
+  try {
+    const fragments = record.fragmentPaths.flatMap(path => {
+      const value = readPath(document, path);
+      return value === undefined ? [] : [{ path, value }];
+    });
+    if (fragments.length !== record.fragmentPaths.length) return false;
+    const observed: ManagedContribution = { clientId: "droid", fragments };
+    return record.semanticBlockFingerprint === fingerprint(semanticContribution(observed))
+      || record.blockFingerprint === fingerprint(canonicalContribution(observed));
+  } catch {
+    return false;
+  }
+}
+
 let retriedThisProcess = false;
 
 /**
@@ -535,9 +569,7 @@ export function readIntegrationState(input: IntegrationStateInput): IntegrationS
   try {
     // One resolution for both, so a client whose paths come from mutable state
     // cannot report one account's install beside another account's config path.
-    const context = exportContextOf(input);
-    const paths = input.resolvedPaths ?? resolveIntegrationPaths(input.clientId, input.env, input.home, context);
-    if (input.clientId === "droid" && input.resolvedPaths) assertDroidPathsUnambiguous(paths.detectDir, context);
+    const paths = resolveStatePaths(input);
     installed = io.statKind(paths.detectDir) === "dir";
     if (input.clientId === "cline") io = createClineIO(io, paths.configPath, store);
     /*
@@ -608,7 +640,7 @@ export function readIntegrationState(input: IntegrationStateInput): IntegrationS
   const parsed = input.clientId === "cline"
     ? parseClineDocument(loaded.before)
     : parseConfig(loaded.before, effective.format, EXPORT_CLIENTS[input.clientId].jsonc ? { jsonc: true } : undefined);
-  const contribution = effective.buildContribution(exportContextOf(input));
+  const contribution = buildIntegrationContribution(input, effective, parsed, record);
   if (input.clientId === "droid" && input.models.length > 0 && contribution.fragments.length === 0
     && (!record || record.configPath !== configPath)) {
     return { clientId: input.clientId, state: "unsafe", installed, configPath,
@@ -650,3 +682,33 @@ export function readIntegrationState(input: IntegrationStateInput): IntegrationS
     ...retention,
   };
 }
+
+function resolveStatePaths(input: IntegrationStateInput): { configPath: string; detectDir: string } {
+  const context = exportContextOf(input);
+  const paths = input.resolvedPaths ?? resolveIntegrationPaths(input.clientId, input.env, input.home, context);
+  if (input.clientId === "droid" && input.resolvedPaths) assertDroidPathsUnambiguous(paths.detectDir, context);
+  return paths;
+}
+
+export function readOwnedDroidReasoningDefaults(input: IntegrationStateInput): Record<string, string> {
+  if (input.clientId !== "droid") return {};
+  const store = input.store ?? createIntegrationStateStore();
+  const io = input.io ?? store.io();
+  try {
+    const paths = resolveStatePaths(input);
+    const record = store.readRecords().droid;
+    if (!record || record.clientId !== "droid" || record.configPath !== paths.configPath) return {};
+    const effective = resolveIntegrationTarget({
+      clientId: "droid", configPath: paths.configPath, io, record, env: input.env, home: input.home,
+    });
+    const loaded = loadTarget(io, effective.configPath);
+    if (!loaded.ok) return {};
+    const parsed = parseConfig(loaded.before, "json");
+    if (parsed === PARSE_FAILED) return {};
+    if (!recordedDroidContributionMatches(parsed, record)) return {};
+    return droidDefaultsFromOwnedRows(exportContextOf(input), parsed, record.fragmentPaths);
+  } catch (error) {
+    if (error instanceof ClientPathError) return {};
+    throw error;
+  }
+}
diff --git a/src/integrations/writer.ts b/src/integrations/writer.ts
index b364694c5fc..19c6edf494d 100644
--- a/src/integrations/writer.ts
+++ b/src/integrations/writer.ts
@@ -18,7 +18,7 @@ import { shouldInjectApiAuthHeader } from "../codex/inject";
 import { detachedConfigSnapshot } from "../config/admitted-identity";
 import { copyPlainData } from "../lib/plain-data";
 import type { OcxConfig } from "../types";
-import { defaultIntegrationIO, loadTarget, type IntegrationIO } from "./config-io";
+import { defaultIntegrationIO, loadTarget, parseConfig, type IntegrationIO } from "./config-io";
 import { inspectKiloCandidates } from "./kilo-candidates";
 import {
   fingerprint,
@@ -43,7 +43,7 @@ import {
   type IntegrationClientId,
 } from "./registry";
 import { declaredIntegrationTarget } from "./target";
-import { exportContextOf } from "./state";
+import { buildIntegrationContribution, exportContextOf } from "./state";
 import type { IntegrationState } from "./state";
 import { serializeDocument, UnserializableValueError } from "./serialize";
 import { ClientPathError } from "../clients/config-export";
@@ -713,7 +713,11 @@ export function restoreIntegration(input: IntegrationRestoreInput): WriteOutcome
   // exact bytes when the snapshot was taken. Re-deriving it from the file would
   // mean guessing which entries are ours, and a wrong guess deletes a user's.
   const restoredRecord = entry.priorRecord;
-  const fresh = rowTarget.buildContribution(exportContextOf(input));
+  const fresh = buildIntegrationContribution(
+    { ...input, droidReasoningDefaults: undefined }, rowTarget,
+    clientId === "droid" && restoredText !== null ? parseConfig(restoredText, "json") : undefined,
+    restoredRecord,
+  );
   /*
    * Does the restored record actually describe the restored bytes?
    *
@@ -812,6 +816,12 @@ function freezeIntegrationInput(input: IntegrationWriteInput): FrozenIntegration
   if (!models.ok) {
     throw new UncopyableIntegrationInputError("the model roster could not be captured for this write");
   }
+  const droidReasoningDefaults = input.droidReasoningDefaults === undefined
+    ? undefined
+    : copyPlainData(input.droidReasoningDefaults);
+  if (droidReasoningDefaults !== undefined && !droidReasoningDefaults.ok) {
+    throw new UncopyableIntegrationInputError("Droid reasoning defaults could not be captured for this write");
+  }
   /*
    * One resolution for both paths. Aside derives them from the account id in
    * its manifest, so two independent calls could verify one account's install
@@ -828,7 +838,11 @@ function freezeIntegrationInput(input: IntegrationWriteInput): FrozenIntegration
    * checked in one state and written from another, which is the substitution the fingerprint
    * exists to prevent. Copying both here gives the plan and the document one input.
    */
-  return { ...input, config, models: models.value, env, home, store, io, resolvedPaths };
+  return {
+    ...input, config, models: models.value,
+    ...(droidReasoningDefaults === undefined ? {} : { droidReasoningDefaults: droidReasoningDefaults.value }),
+    env, home, store, io, resolvedPaths,
+  };
 }
 
 function tryFreezeIntegrationInput(input: IntegrationWriteInput):
diff --git a/src/server/chat-completions.ts b/src/server/chat-completions.ts
index a438545b340..108a105c6d2 100644
--- a/src/server/chat-completions.ts
+++ b/src/server/chat-completions.ts
@@ -86,6 +86,7 @@ import { parseRequestEffortRowId } from "./effort-row";
 import { parseSyntheticRowId } from "./fast-row";
 import { isCanonicalOpenAiForwardProvider } from "../providers/openai-tiers";
 import { CODEX_RESERVE_HELPER_UNSUPPORTED_MESSAGE, isCodexReserveHelperUnsupported } from "../codex/loopback-target";
+import { applyDroidReasoningDefault, droidReasoningDefault, DROID_DEFAULT_EFFORT_HEADER } from "./droid-reasoning-default";
 
 type Rec = Record<string, unknown>;
 
@@ -157,6 +158,9 @@ async function handleChatCompletionsWithBudget(
 
   const requestedModel = chatBody.model as string;
   const { fastRow, effortRow } = parseSyntheticRowId(requestedModel, config);
+  const droidDefaultEffort = effortRow
+    ? undefined
+    : droidReasoningDefault(req.headers.get(DROID_DEFAULT_EFFORT_HEADER), chatBody);
   if (effortRow) chatBody.model = effortRow.baseId;
   if (fastRow) {
     chatBody.model = fastRow.baseId;
@@ -198,6 +202,9 @@ async function handleChatCompletionsWithBudget(
       getOrAllocateRequestSessionLane(req),
       routedProvider,
     );
+    if (!route.combo && route.routeKind !== "policy") {
+      applyDroidReasoningDefault(chatBody, droidDefaultEffort, { provider: route.provider, modelId: route.modelId });
+    }
     logCtx.model = route.modelId;
     logCtx.providerAdapter = route.provider.adapter;
     logCtx.requestedModel = requestedModel;
@@ -442,6 +449,9 @@ async function handleChatCompletionsWithBudget(
     abortSignal: req.signal,
     // Body is Responses-shaped by now, but the client spoke Chat Completions.
     inboundWire: "chat",
+    ...((settledRoute?.combo || settledRoute?.routeKind === "policy") && droidDefaultEffort
+      ? { droidDefaultEffort }
+      : {}),
     // PF-07: the combo sends eligible candidates natively from this envelope.
     ...(envelope && nativeChatCombos ? {
       protocolSource: createNativeChatComboSource({
diff --git a/src/server/droid-reasoning-default.ts b/src/server/droid-reasoning-default.ts
new file mode 100644
index 00000000000..2d07556afa3
--- /dev/null
+++ b/src/server/droid-reasoning-default.ts
@@ -0,0 +1,50 @@
+import { CODEX_REASONING_LEVELS, configuredReasoningEfforts, isDeclaredReasoningEffort } from "../reasoning-effort";
+import { isPlainObject } from "../lib/plain-data";
+import type { OcxProviderConfig } from "../types";
+
+export { DROID_DEFAULT_EFFORT_HEADER } from "../clients/config-export/contracts";
+
+type ChatRequestBody = Record<string, unknown>;
+type DroidReasoningTarget = { provider: OcxProviderConfig; modelId: string };
+
+function hasExplicitEffort(body: ChatRequestBody): boolean {
+  return Object.hasOwn(body, "reasoning_effort")
+    || (isPlainObject(body.reasoning) && Object.hasOwn(body.reasoning, "effort"));
+}
+
+/** Read before the Chat body is bridged: the bridge drops null and unknown efforts, which still count as explicit. */
+export function droidReasoningDefault(header: string | null, chatBody: ChatRequestBody): string | undefined {
+  return header && isDeclaredReasoningEffort(header) && !hasExplicitEffort(chatBody) ? header : undefined;
+}
+
+function pendingDefault(
+  body: ChatRequestBody,
+  defaultEffort: string | undefined,
+  target: DroidReasoningTarget,
+): string | undefined {
+  if (!defaultEffort || hasExplicitEffort(body)) return undefined;
+  const supportedEfforts = configuredReasoningEfforts(target.provider, target.modelId)
+    ?? CODEX_REASONING_LEVELS.map(level => level.effort);
+  return supportedEfforts.includes(defaultEffort) ? defaultEffort : undefined;
+}
+
+export function applyDroidReasoningDefault(
+  body: ChatRequestBody,
+  defaultEffort: string | undefined,
+  target: DroidReasoningTarget,
+): void {
+  const effort = pendingDefault(body, defaultEffort, target);
+  if (effort) body.reasoning_effort = effort;
+}
+
+export function applyDroidResponsesReasoningDefault(
+  body: unknown,
+  defaultEffort: string | undefined,
+  target: DroidReasoningTarget,
+): boolean {
+  if (!isPlainObject(body)) return false;
+  const effort = pendingDefault(body, defaultEffort, target);
+  if (!effort) return false;
+  body.reasoning = { ...(isPlainObject(body.reasoning) ? body.reasoning : {}), effort };
+  return true;
+}
diff --git a/src/server/management/integration-routes.ts b/src/server/management/integration-routes.ts
index 7ae8a16d466..b87a4343713 100644
--- a/src/server/management/integration-routes.ts
+++ b/src/server/management/integration-routes.ts
@@ -24,7 +24,8 @@ import {
   type IntegrationClientId,
 } from "../../integrations/registry";
 import { detectRaycast, type RaycastInstall } from "../../integrations/raycast-detect";
-import { readIntegrationState } from "../../integrations/state";
+import { readIntegrationState, readOwnedDroidReasoningDefaults } from "../../integrations/state";
+import { droidReasoningModels, validateDroidReasoningDefaults } from "../../clients/config-export";
 import { createIntegrationStateStore, type IntegrationStateStore } from "../../integrations/store";
 import {
   applyIntegrationCoordinated,
@@ -74,6 +75,10 @@ export type IntegrationStateEnvelope = {
    * the shared `IntegrationStatus`, which describes the file, not the app.
    */
   raycast?: RaycastInstall;
+  droidReasoning?: {
+    models: Array<{ model: string; label: string; efforts: string[] }>;
+    defaults: Record<string, string>;
+  };
 } & IntegrationStateRecord;
 
 export interface IntegrationStateListEnvelope {
@@ -241,12 +246,14 @@ async function buildIntegrationWriteInput(
   clientId: IntegrationClientId,
   ctx: ManagementContext,
   store: IntegrationStateStore,
+  droidReasoningDefaults?: Record<string, string>,
 ): Promise<IntegrationWriteInput> {
   return {
     clientId,
     models: await loadExportModels(ctx.config),
     config: ctx.config,
     port: Number(ctx.url.port) || ctx.config.port,
+    ...(droidReasoningDefaults === undefined ? {} : { droidReasoningDefaults: { ...droidReasoningDefaults } }),
     store,
     io: integrationMutationTestHooks?.io,
     ...pathOverrides(),
@@ -265,6 +272,7 @@ async function buildIntegrationPreviewInput(
   clientId: IntegrationClientId,
   ctx: ManagementContext,
   store: IntegrationStateStore,
+  droidReasoningDefaults?: Record<string, string>,
 ): Promise<{ input: IntegrationWriteInput; identity: string } | null> {
   const snapshot = previewExportSnapshot(ctx.config);
   // No cached roster means no honest snapshot to plan against. Gathering one here would make a
@@ -277,6 +285,7 @@ async function buildIntegrationPreviewInput(
       models: snapshot.models,
       config: ctx.config,
       port: Number(ctx.url.port) || ctx.config.port,
+      ...(droidReasoningDefaults === undefined ? {} : { droidReasoningDefaults: { ...droidReasoningDefaults } }),
       store,
       io: integrationMutationTestHooks?.io,
       ...pathOverrides(),
@@ -309,6 +318,31 @@ function invalidClientResponse(ctx: ManagementContext): Response {
   }, 400, ctx.req, ctx.config);
 }
 
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    && Object.values(value).every(item => typeof item === "string");
+}
+
+function invalidDroidDefaultsResponse(ctx: ManagementContext, message: string): Response {
+  return jsonResponse({ error: message, code: "invalid_droid_reasoning_defaults" }, 400, ctx.req, ctx.config);
+}
+
+function readDroidReasoningDefaults(
+  ctx: ManagementContext,
+  body: Record<string, unknown>,
+  clientId: string,
+  operation: IntegrationPlanOperation,
+): Record<string, string> | Response | undefined {
+  if (!Object.hasOwn(body, "droidReasoningDefaults")) return undefined;
+  if (clientId !== "droid" || (operation !== "apply" && operation !== "overwrite")) {
+    return invalidDroidDefaultsResponse(ctx, "droidReasoningDefaults is allowed only for Droid apply or overwrite");
+  }
+  const defaults = body.droidReasoningDefaults;
+  return isStringRecord(defaults)
+    ? defaults
+    : invalidDroidDefaultsResponse(ctx, "droidReasoningDefaults must map model names to effort strings");
+}
+
 /**
  * No cached model roster, so there is nothing honest to plan against.
  *
@@ -364,6 +398,7 @@ function stalePlanGuard(
   request: PreviewRequest,
   fingerprint: string,
   capturedIdentity: string | null,
+  droidReasoningDefaults?: Record<string, string>,
 ): {
   revalidate: NonNullable<CoordinatedIntegrationOptions["revalidate"]>;
   response: () => Response | null;
@@ -379,7 +414,7 @@ function stalePlanGuard(
        * without ever swapping the roster this mutation is about to use.
        */
       if (exportSnapshotIdentity(ctx.config) !== capturedIdentity) {
-        const refreshed = await buildIntegrationPreviewInput(clientId, ctx, store);
+        const refreshed = await buildIntegrationPreviewInput(clientId, ctx, store, droidReasoningDefaults);
         stale = refreshed === null ? "unavailable" : previewIntegration(refreshed.input, request);
         return { ok: false, reason: "conflict", state: "conflict", clientId, message: "the model roster changed while confirming" };
       }
@@ -723,9 +758,17 @@ export async function handleIntegrationRoutes(ctx: ManagementContext): Promise<R
         code: "invalid_preview_operation",
       }, 400, req, ctx.config);
     }
+    const droidDefaults = readDroidReasoningDefaults(ctx, parsed, previewClient, operation);
+    if (droidDefaults instanceof Response) return droidDefaults;
     try {
-      const captured = await buildIntegrationPreviewInput(previewClient as IntegrationClientId, ctx, integrationStore());
+      const captured = await buildIntegrationPreviewInput(
+        previewClient as IntegrationClientId, ctx, integrationStore(), droidDefaults,
+      );
       if (!captured) return previewUnavailableResponse(ctx);
+      if (droidDefaults !== undefined) {
+        const invalid = validateDroidReasoningDefaults(captured.input.models, droidDefaults);
+        if (invalid) return invalidDroidDefaultsResponse(ctx, invalid);
+      }
       return jsonResponse(previewIntegration(captured.input, { operation }), 200, req, ctx.config);
     } catch (error) {
       return internalErrorResponse(error, ctx);
@@ -907,7 +950,15 @@ export async function handleIntegrationRoutes(ctx: ManagementContext): Promise<R
       // process spawn, and no other client's read should pay for it.
       const envelope: IntegrationStateEnvelope = requestedClient === "raycast"
         ? { ...state, raycast: (raycastDetectTestHook ?? detectRaycast)() }
-        : state;
+        : requestedClient === "droid"
+          ? {
+              ...state,
+              droidReasoning: {
+                models: droidReasoningModels(input.models),
+                defaults: readOwnedDroidReasoningDefaults(input),
+              },
+            }
+          : state;
       return jsonResponse(envelope, 200, req, ctx.config);
     } catch (error) {
       return internalErrorResponse(error, ctx);
@@ -944,6 +995,8 @@ export async function handleIntegrationRoutes(ctx: ManagementContext): Promise<R
   const requestedOperation: IntegrationPlanOperation = parsed.enabled
     ? (parsed.overwriteConflict === true ? "overwrite" : "apply")
     : "disable";
+  const droidDefaults = readDroidReasoningDefaults(ctx, parsed, requestedClient, requestedOperation);
+  if (droidDefaults instanceof Response) return droidDefaults;
   const binding = planBindingOf(parsed);
   if (binding === "half") return halfBoundResponse(ctx);
   if (binding === "unknown-operation" || (binding !== "none" && binding.operation !== requestedOperation)) {
@@ -964,11 +1017,15 @@ export async function handleIntegrationRoutes(ctx: ManagementContext): Promise<R
      */
     const boundToggle = binding === "none"
       ? null
-      : await buildIntegrationPreviewInput(requestedClient, ctx, integrationStore());
+      : await buildIntegrationPreviewInput(requestedClient, ctx, integrationStore(), droidDefaults);
     if (binding !== "none" && boundToggle === null) return previewUnavailableResponse(ctx);
     const input = boundToggle
       ? boundToggle.input
-      : await buildIntegrationWriteInput(requestedClient, ctx, integrationStore());
+      : await buildIntegrationWriteInput(requestedClient, ctx, integrationStore(), droidDefaults);
+    if (droidDefaults !== undefined) {
+      const invalid = validateDroidReasoningDefaults(input.models, droidDefaults);
+      if (invalid) return invalidDroidDefaultsResponse(ctx, invalid);
+    }
     const guard = binding === "none" ? null : stalePlanGuard(
       requestedClient,
       ctx,
@@ -976,6 +1033,7 @@ export async function handleIntegrationRoutes(ctx: ManagementContext): Promise<R
       { operation: binding.operation },
       binding.fingerprint,
       boundToggle === null ? null : boundToggle.identity,
+      droidDefaults,
     );
     const result = await runIntegrationMutationFlight(
       requestedClient,
diff --git a/src/server/responses/core-combo-native.ts b/src/server/responses/core-combo-native.ts
index c70af618f51..def89782bab 100644
--- a/src/server/responses/core-combo-native.ts
+++ b/src/server/responses/core-combo-native.ts
@@ -34,6 +34,7 @@ import {
 import { captureRouteStaticPolicy, routeConcreteModel } from "../../router";
 import { comboDefaultEffort, concreteComboRequestBody, getCombo } from "../../combos";
 import { supportedLadderFor } from "../effort-policy";
+import { applyDroidReasoningDefault } from "../droid-reasoning-default";
 import { resolveWireProtocolOverride } from "../adapter-resolve";
 import { resolveOpenCodeGoTransport } from "../../providers/opencode-go-transport";
 import { getOrAllocateRequestSessionLane } from "../request-log-conversation";
@@ -105,10 +106,11 @@ export function createComboProtocolLanes(input: {
   config: OcxConfig;
   logCtx: RequestLogContext;
   admission: DataPlaneAdmission | undefined;
+  droidDefaultEffort?: string;
   comboId: string;
   targets: readonly ComboTarget[];
 }): ComboProtocolLanes | undefined {
-  const { source, req, config, logCtx, admission, comboId, targets } = input;
+  const { source, req, config, logCtx, admission, droidDefaultEffort, comboId, targets } = input;
   if (!source) return undefined;
   const envelope = source.envelope;
   const reject = resolveProtocolSettings(config).unrepresentable === "reject";
@@ -207,6 +209,10 @@ export function createComboProtocolLanes(input: {
       const route = settle(target, targetRoute);
       const body = nativeBody(target, route);
       if (!route || !body) return undefined;
+      applyDroidReasoningDefault(body, droidDefaultEffort, {
+        provider: targetRoute.provider,
+        modelId: targetRoute.modelId,
+      });
       applyComboEffort(body, config, comboId, target, targetRoute);
       return { route, body, sendBudget: targetSendBudget };
     },
diff --git a/src/server/responses/core-combo.ts b/src/server/responses/core-combo.ts
index 7f4305bb51f..05ee166d9a6 100644
--- a/src/server/responses/core-combo.ts
+++ b/src/server/responses/core-combo.ts
@@ -65,6 +65,8 @@ import {
   recoverEncryptedAgentTaskWithResult,
 } from "./agent-task-recovery";
 import { isThreadSpawnRequest, supportedLadderFor } from "../effort-policy";
+import { applyDroidResponsesReasoningDefault } from "../droid-reasoning-default";
+import { isPlainObject } from "../../lib/plain-data";
 import {
   clientCancelledResponse,
   comboUnavailable,
@@ -327,6 +329,7 @@ export async function executeComboResponses(
     config,
     logCtx,
     admission: options.admission,
+    droidDefaultEffort: options.droidDefaultEffort,
     comboId,
     targets: combo.targets,
   });
@@ -709,8 +712,13 @@ export async function executeComboResponses(
       modelId: targetRoute.modelId,
     });
     const initialJevDecision = firstComboTarget ? jevDecision : undefined;
+    const childInput = options.droidDefaultEffort && isPlainObject(body) ? { ...body } : body;
+    applyDroidResponsesReasoningDefault(childInput, options.droidDefaultEffort, {
+      provider: targetRoute.provider,
+      modelId: targetRoute.modelId,
+    });
     const childBody = concreteComboRequestBody(
-      body,
+      childInput,
       pick.target,
       initialJevDecision ? initialJevDecision.effort : comboDefaultEffort(config, comboId),
       initialJevDecision?.effort === null ? [] : targetReasoningEfforts,
diff --git a/src/server/responses/core-normalize.ts b/src/server/responses/core-normalize.ts
index 43d6ce7dec7..6024df7de4a 100644
--- a/src/server/responses/core-normalize.ts
+++ b/src/server/responses/core-normalize.ts
@@ -38,6 +38,7 @@ import { isInjectionDebugEnabled } from "../../lib/debug-settings";
 import { injectionDebugLog } from "../../lib/injection-debug-log";
 import { recordAttemptRequestedEffort } from "../request-log";
 import type { ResolvedFastPolicy } from "../../providers/fastwire";
+import { applyDroidResponsesReasoningDefault } from "../droid-reasoning-default";
 import { applyXaiOauthFastModel, xaiOauthFastModelForDecision } from "../../providers/xai-fast-model";
 
 /** Preview the billed xAI lane without mutating request state or resolving credentials. */
@@ -140,9 +141,15 @@ export async function applyFinalRouteRequestNormalization(args: {
   inboundWire: InboundWire;
   inboundTransport?: "websocket";
   claudeGoAffinity?: HandleResponsesOptions["claudeGoAffinity"];
+  droidDefaultEffort?: HandleResponsesOptions["droidDefaultEffort"];
 }): Promise<void> {
   const { parsed, route, config, req, logCtx, inboundWire, inboundTransport } = args;
   const effortSelector = prepareEffortNormalization(parsed, route);
+  if (applyDroidResponsesReasoningDefault(
+    parsed._rawBody,
+    args.droidDefaultEffort,
+    { provider: route.provider, modelId: route.modelId },
+  )) parsed.options.reasoning = args.droidDefaultEffort;
 
   // Only Anthropic message routes retain the Codex-facing selector. Other providers must keep
   // their existing response.model contract even when their public and wire model ids differ.
diff --git a/src/server/responses/core-options.ts b/src/server/responses/core-options.ts
index cacb771b4c7..680d13840e7 100644
--- a/src/server/responses/core-options.ts
+++ b/src/server/responses/core-options.ts
@@ -131,6 +131,8 @@ export interface HandleResponsesOptions {
    * it. Omitted means a genuine Responses inbound.
    */
   inboundWire?: InboundWire;
+  /** Droid's per-request effort default; each concrete combo or policy target applies it only if its ladder allows it. */
+  droidDefaultEffort?: string;
   /** PF-07: the Chat source a combo child may send natively; set only by the Chat ingress. */
   protocolSource?: import("./core-combo-native").ComboProtocolSource;
   /** Internal transport identity for route-scoped upstream compatibility policy. */
diff --git a/src/server/responses/request-prepare.ts b/src/server/responses/request-prepare.ts
index b42fc03238e..6dcfdb4d53c 100644
--- a/src/server/responses/request-prepare.ts
+++ b/src/server/responses/request-prepare.ts
@@ -1222,6 +1222,7 @@ export async function prepareResponsesRequest(
     inboundWire,
     inboundTransport: options.inboundTransport,
     claudeGoAffinity: options.claudeGoAffinity,
+    droidDefaultEffort: options.droidDefaultEffort,
   });
   try {
     assertPolicyNormalizedRoute(policyScope, admittedPolicyRoute, route);
diff --git a/structure/clients/integrations.md b/structure/clients/integrations.md
index 541e566762a..1fc1d003b66 100644
--- a/structure/clients/integrations.md
+++ b/structure/clients/integrations.md
@@ -63,6 +63,32 @@ compare and before taking a snapshot. Droid has no writer lock, so a competing
 settings file can still appear after this check and before the write.
 No Droid file is written by detection or on the proxy request path.
 
+### Droid reasoning defaults
+
+The Droid page stores a sparse model-to-effort map in its owned model rows through
+`extraHeaders.x-opencodex-droid-default-effort`. There is no separate proxy-wide
+default. The single-client status projects the owned defaults and the current
+export roster's declared effort choices into `droidReasoning`. Defaults use the
+same path and competing-settings checks as status, including pre-resolved paths;
+an ambiguous legacy model ID or managed endpoint suppresses the projected map.
+
+Preview and apply accept optional `droidReasoningDefaults`. Omission preserves
+owned defaults; an empty map clears them. A supplied map is validated against the
+same roster used to build the contribution, and the contribution participates in
+the preview fingerprint and frozen mutation input. Refresh preserves defaults only
+while the exact namespaced selector remains in the roster. Provider, model, and
+combo alias names are mutable selectors rather than stable identities, so renaming
+one removes the old managed row and its default; the replacement row starts without
+a default. Ordinary refresh omits the map unless the user has edited it, so an
+unsupported saved value does not block unrelated refresh. Removing models uses the
+ordinary removal preview. Disable and restore remove or restore the rows and their
+defaults as one owned value.
+
+The request preference is interpreted after initial Chat route selection and before
+concrete dispatch under the
+[inbound effort contract](../data-planes/inbound-compat.md#droid-request-defaults).
+It never authenticates a client or changes admission policy.
+
 ## Cursor installed capability reads
 
 `src/integrations/cursor-effort-table.ts` reads the installed agent bundle through one regular-file
diff --git a/structure/data-planes/inbound-compat.md b/structure/data-planes/inbound-compat.md
index 8e33465978b..e899deaadf7 100644
--- a/structure/data-planes/inbound-compat.md
+++ b/structure/data-planes/inbound-compat.md
@@ -81,6 +81,26 @@ Shared parsing and streaming follow the [request-copy](../transports/byte-accoun
 
 ## Chat Completions inbound native path
 
+### Droid request defaults
+
+`src/server/droid-reasoning-default.ts` reads the model-scoped
+`x-opencodex-droid-default-effort` preference at Chat ingress for both native and
+translated routes. A canonical value fills `reasoning_effort` only when neither
+that property nor nested `reasoning.effort` is present. A concrete route validates
+the preference against that model's effective reasoning ladder. Combo and policy
+routes retain it as logical request intent until each concrete attempt applies the
+existing target-specific reasoning normalization, so an incompatible first target
+cannot discard it for a compatible fallback. With no configured or metadata ladder,
+the routed catalog's canonical fallback ladder applies; an explicit empty per-model
+ladder stays empty. Unsupported or invalid defaults have no effect; even an explicit
+null or invalid effort suppresses the default and retains the existing request
+semantics. Synthetic effort rows keep their selected effort. Provider headers do
+not forward this internal preference. Existing pins and caps run afterward with
+their usual authority. The [Droid integration](../clients/integrations.md#droid-reasoning-defaults)
+owns the persisted per-model values.
+
+### Route selection
+
 `POST /v1/chat/completions` sends eligible `openai-chat` routes directly to the provider's Chat
 Completions endpoint. Route selection reads the raw Chat body and the native request keeps that body
 as its wire source; a Responses projection is constructed only after the native route is declined
diff --git a/structure/gui-and-management-api.md b/structure/gui-and-management-api.md
index 89c05c8a39d..2243834c71b 100644
--- a/structure/gui-and-management-api.md
+++ b/structure/gui-and-management-api.md
@@ -74,6 +74,13 @@ the web route. The native panel introduces no management endpoint or credential
 
 ## Dashboard serving
 
+The Factory Droid integration page edits the
+[owned model defaults](clients/integrations.md#droid-reasoning-defaults). Its draft
+is included in the existing preview and confirmation request, with editing
+disabled while confirmation is open. The page reloads committed values after a
+successful mutation or restore. No separate settings-save endpoint bypasses the
+integration writer or its ownership checks.
+
 Account refresh actions follow the [credential refresh-lock identity contract](catalog.md#accounts-namespaces-and-pool-rotation): a held unreadable lock is distinct from one this process may release, and path-probe errors preserve the callback outcome. Cooperating lock metadata changes serialize through the existing SQLite mutation transaction; release keeps the descriptor open through identity comparison and any unlink, then closes it. Failed metadata writes remove only a matching owned path after successful coordination; unknown identity, failed probes or unavailable coordination retain the path for stale recovery. Async refresh work holds no metadata transaction. The bundled React dashboard is built into `gui/dist` and served by the same Bun proxy. `ocx gui` starts
 the proxy when needed and opens `http://localhost:<port>`, or `http://127.0.0.1:<management port>` when `hub.managementIngress.enabled` is true — see [the hub management dashboard address](runtime.md#hub-management-dashboard-address).
 
diff --git a/tests/clients/droid-managed-reasoning-defaults.test.ts b/tests/clients/droid-managed-reasoning-defaults.test.ts
new file mode 100644
index 00000000000..93eca412c5b
--- /dev/null
+++ b/tests/clients/droid-managed-reasoning-defaults.test.ts
@@ -0,0 +1,154 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ExportModel } from "../../src/clients/config-export";
+import { droidConfigPath } from "../../src/clients/config-export";
+import { INTEGRATION_CLIENTS } from "../../src/integrations/registry";
+import { readIntegrationState, readOwnedDroidReasoningDefaults } from "../../src/integrations/state";
+import { createIntegrationStateStore, type IntegrationStateStore } from "../../src/integrations/store";
+import { refreshOwnedCatalogIntegrations } from "../../src/integrations/catalog-refresh";
+import { applyIntegration, disableIntegration, overwriteIntegration, restoreIntegration } from "../../src/integrations/writer";
+import type { OcxConfig } from "../../src/types";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const CONFIG = {
+  port: 10100, hostname: "127.0.0.1", defaultProvider: "mock",
+  providers: { mock: { adapter: "openai-chat", baseUrl: "http://127.0.0.1/v1" } },
+} as OcxConfig;
+const MODEL: ExportModel = {
+  namespaced: "mock/chat", provider: "mock", id: "chat", displayName: "Chat Model",
+  reasoningEfforts: ["low", "high"], inputModalities: ["text"],
+};
+const HEADER = "x-opencodex-droid-default-effort";
+let home: string;
+let store: IntegrationStateStore;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "ocx-droid-effort-home-"));
+  store = createIntegrationStateStore(mkdtempSync(join(tmpdir(), "ocx-droid-effort-store-")));
+});
+
+afterEach(() => {
+  removeTreeWithRetry(home);
+  removeTreeWithRetry(store.root);
+});
+
+function input(models: readonly ExportModel[] = [MODEL], extra: Partial<{ port: number; config: OcxConfig; droidReasoningDefaults: Record<string, string> }> = {}) {
+  const port = extra.port ?? 10100;
+  return {
+    clientId: "droid" as const, models, config: extra.config ?? CONFIG, port,
+    env: {}, home, store, ...("droidReasoningDefaults" in extra ? { droidReasoningDefaults: extra.droidReasoningDefaults } : {}),
+  };
+}
+
+function install(): string {
+  mkdirSync(INTEGRATION_CLIENTS.droid.detectDir({}, home), { recursive: true });
+  const path = droidConfigPath({}, home);
+  writeFileSync(path, '{"customModels":[]}\n');
+  return path;
+}
+
+function settings(path: string): { customModels: Array<Record<string, unknown>> } {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+describe("Droid managed reasoning defaults", () => {
+  test("persists on the owned row, clears explicitly, and restores with the prior settings", () => {
+    const path = install();
+    expect(applyIntegration({ ...input(), droidReasoningDefaults: { "mock/chat": "high" } }).ok).toBe(true);
+    expect(settings(path).customModels[0]).toMatchObject({ extraHeaders: { [HEADER]: "high" } });
+    expect(readIntegrationState(input()).state).toBe("current");
+    expect(readOwnedDroidReasoningDefaults(input())).toEqual({ "mock/chat": "high" });
+
+    expect(overwriteIntegration({ ...input(), droidReasoningDefaults: {} }).ok).toBe(true);
+    expect(settings(path).customModels[0]).not.toHaveProperty("extraHeaders");
+    const overwriteId = store.listOperations("droid")[0]!.opId;
+    expect(restoreIntegration({ ...input(), opId: overwriteId })).toMatchObject({ ok: true, state: "current" });
+    expect(settings(path).customModels[0]).toMatchObject({ extraHeaders: { [HEADER]: "high" } });
+    expect(disableIntegration(input()).ok).toBe(true);
+    expect(settings(path).customModels).toEqual([]);
+    const disableId = store.listOperations("droid")[0]!.opId;
+    expect(restoreIntegration({ ...input(), opId: disableId })).toMatchObject({ ok: true, state: "current" });
+    expect(readIntegrationState(input()).state).toBe("current");
+  });
+
+  test("refresh keeps a selected effort through port, label, and capability changes", async () => {
+    const path = install();
+    expect(applyIntegration({ ...input(), droidReasoningDefaults: { "mock/chat": "high" } }).ok).toBe(true);
+    const changedModel: ExportModel = {
+      ...MODEL, displayName: "Renamed Chat", inputModalities: ["text", "image"], reasoningEfforts: ["low"],
+    };
+    const config = { ...CONFIG, port: 10101 };
+    const results = await refreshOwnedCatalogIntegrations({
+      models: [changedModel], config, port: 10101, env: {}, home, store,
+    }, ["droid"]);
+    expect(results).toEqual([{ client: "droid", ok: true, changed: true }]);
+    expect(settings(path).customModels).toEqual([{
+      model: "mock/chat", displayName: "OpenCodex: Renamed Chat", baseUrl: "http://127.0.0.1:10101/v1",
+      provider: "generic-chat-completion-api", noImageSupport: false,
+      extraHeaders: { [HEADER]: "high" },
+    }]);
+    expect(readOwnedDroidReasoningDefaults(input([changedModel], { port: 10101, config }))).toEqual({ "mock/chat": "high" });
+  });
+
+  test.each([
+    ["provider", { ...MODEL, namespaced: "renamed/chat", provider: "renamed" }],
+    ["model", { ...MODEL, namespaced: "mock/renamed", id: "renamed" }],
+    ["combo alias", { ...MODEL, namespaced: "combo/renamed", provider: "combo", id: "renamed" }],
+  ] as const)("refresh clears a selected effort after a %s selector rename", async (_kind, changedModel) => {
+    const path = install();
+    expect(applyIntegration({ ...input(), droidReasoningDefaults: { "mock/chat": "high" } }).ok).toBe(true);
+
+    const results = await refreshOwnedCatalogIntegrations({
+      models: [changedModel], config: CONFIG, port: 10100, env: {}, home, store,
+    }, ["droid"]);
+
+    expect(results).toEqual([{ client: "droid", ok: true, changed: true }]);
+    expect(settings(path).customModels).toEqual([{
+      model: changedModel.namespaced, displayName: "OpenCodex: Chat Model",
+      baseUrl: "http://127.0.0.1:10100/v1", provider: "generic-chat-completion-api",
+      noImageSupport: true,
+    }]);
+    expect(readOwnedDroidReasoningDefaults(input([changedModel]))).toEqual({});
+  });
+
+  test("a changed owned header remains a conflict and is not projected as ours", () => {
+    const path = install();
+    expect(applyIntegration({ ...input(), droidReasoningDefaults: { "mock/chat": "high" } }).ok).toBe(true);
+    const document = settings(path);
+    document.customModels[0]!.extraHeaders = { [HEADER]: "low" };
+    writeFileSync(path, JSON.stringify(document));
+
+    expect(readIntegrationState(input()).state).toBe("conflict");
+    expect(readOwnedDroidReasoningDefaults(input())).toEqual({});
+    expect(applyIntegration(input()).ok).toBe(false);
+    expect(settings(path).customModels[0]).toMatchObject({ extraHeaders: { [HEADER]: "low" } });
+  });
+
+  test.each(["model", "endpoint"])("ambiguous legacy %s rows suppress defaults for resolved and unresolved paths", (collision) => {
+    const path = install();
+    expect(applyIntegration({ ...input(), droidReasoningDefaults: { "mock/chat": "high" } }).ok).toBe(true);
+    const detectDir = INTEGRATION_CLIENTS.droid.detectDir({}, home);
+    writeFileSync(join(detectDir, "config.json"), JSON.stringify({ custom_models: [{
+      display_name: "Personal",
+      model: collision === "model" ? "mock/chat" : "another/model",
+      base_url: collision === "endpoint" ? "http://localhost:10100/v1" : "http://localhost:11434/v1",
+    }] }));
+    for (const target of [input(), { ...input(), resolvedPaths: { configPath: path, detectDir } }]) {
+      expect(readIntegrationState(target).state).toBe("unsafe");
+      expect(readOwnedDroidReasoningDefaults(target)).toEqual({});
+    }
+  });
+
+  test("foreign rows with a matching model name do not supply inherited defaults", () => {
+    const path = install();
+    const foreign = {
+      model: "mock/chat", displayName: "Personal", baseUrl: "http://localhost:11434/v1",
+      provider: "generic-chat-completion-api", extraHeaders: { [HEADER]: "high" },
+    };
+    writeFileSync(path, JSON.stringify({ customModels: [foreign] }));
+    expect(readOwnedDroidReasoningDefaults(input())).toEqual({});
+    expect(readIntegrationState(input()).state).toBe("absent");
+  });
+});
diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json
index f25fa0b2e99..f0ba18e2708 100644
--- a/tests/fixtures/test-layout-expected.json
+++ b/tests/fixtures/test-layout-expected.json
@@ -1,4 +1,7 @@
 {
+  "droid-managed-reasoning-defaults.test.ts": "clients",
+  "management-droid-reasoning-defaults.test.ts": "server",
+  "droid-reasoning-defaults.test.ts": "responses",
   "claude-intercept-on-demand.test.ts": "claude-integration",
   "main-account-hard-lock-thresholds.test.ts": "codex-integration",
   "main-account-external-usage.test.ts": "codex-integration",
diff --git a/tests/responses/droid-reasoning-defaults.test.ts b/tests/responses/droid-reasoning-defaults.test.ts
new file mode 100644
index 00000000000..41fa9c133a4
--- /dev/null
+++ b/tests/responses/droid-reasoning-defaults.test.ts
@@ -0,0 +1,267 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { handleChatCompletions } from "../../src/server/chat-completions";
+import { effortRowId } from "../../src/server/effort-row";
+import { clearHealthHistoryCacheForTests } from "../../src/routing/health";
+import { closeRequestHistoryIndex } from "../../src/routing/history/indexer";
+import type { OcxConfig, OcxProviderConfig } from "../../src/types";
+import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
+import { createTempHome, type TempHome } from "../helpers/temp-home";
+
+const upstreamServers: Array<ReturnType<typeof Bun.serve>> = [];
+let releaseSpendHome: (() => void) | undefined;
+let testHome: TempHome;
+
+beforeEach(() => {
+  testHome = createTempHome("ocx-droid-reasoning-default-");
+});
+
+afterEach(() => {
+  for (const server of upstreamServers.splice(0)) server.stop(true);
+  releaseSpendHome?.();
+  releaseSpendHome = undefined;
+  clearHealthHistoryCacheForTests();
+  closeRequestHistoryIndex();
+  testHome.remove();
+});
+
+function upstream() {
+  const captured: Array<{ path: string; headers: Headers; body: Record<string, unknown> }> = [];
+  const server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      const body = await req.json() as Record<string, unknown>;
+      captured.push({ path: new URL(req.url).pathname, headers: new Headers(req.headers), body });
+      if (body.stream === true) {
+        return new Response([
+          `data: ${JSON.stringify({ choices: [{ index: 0, delta: { role: "assistant", content: "ok" } }] })}\n\n`,
+          `data: ${JSON.stringify({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1 } })}\n\n`,
+          "data: [DONE]\n\n",
+        ].join(""), { headers: { "content-type": "text/event-stream" } });
+      }
+      return Response.json({
+        id: "chatcmpl_mock",
+        object: "chat.completion",
+        choices: [{ index: 0, message: { role: "assistant", content: "ok" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+      });
+    },
+  });
+  upstreamServers.push(server);
+  return { captured, baseUrl: `${server.url}v1` };
+}
+
+function failingUpstream() {
+  const captured: Array<{ headers: Headers; body: Record<string, unknown> }> = [];
+  const server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      captured.push({ headers: new Headers(req.headers), body: await req.json() as Record<string, unknown> });
+      return Response.json({
+        error: { type: "server_error", code: "upstream_server_error", message: "busy" },
+      }, { status: 500 });
+    },
+  });
+  upstreamServers.push(server);
+  return { captured, baseUrl: `${server.url}v1` };
+}
+
+async function send(
+  lane: "native" | "translated",
+  headers: Record<string, string>,
+  extraBody: Record<string, unknown> = {},
+  policy: { pin?: string; cap?: string; modelEfforts?: string[]; omitProviderLadder?: boolean; syntheticEffortRows?: boolean } = {},
+  requestModel = "mock/model",
+) {
+  releaseSpendHome ??= acquireOwnedSpendHome();
+  const mock = upstream();
+  const provider: OcxProviderConfig = {
+    adapter: "openai-chat",
+    baseUrl: mock.baseUrl,
+    apiKey: "fixture",
+    allowPrivateNetwork: true,
+    ...(policy.pin ? { modelPinnedReasoningEfforts: { model: policy.pin } } : {}),
+    ...(!policy.omitProviderLadder ? { reasoningEfforts: ["none", "minimal", "low", "medium", "high"] } : {}),
+    ...(policy.modelEfforts ? { modelReasoningEfforts: { model: policy.modelEfforts } } : {}),
+  };
+  const config = {
+    defaultProvider: "mock",
+    providers: { mock: provider },
+    ...(policy.syntheticEffortRows ? { cursorEffortRows: true } : {}),
+    ...(policy.cap ? { effortCap: policy.cap } : {}),
+  } as OcxConfig;
+  const response = await handleChatCompletions(new Request("http://localhost/v1/chat/completions", {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify({
+      model: requestModel,
+      stream: false,
+      messages: [{ role: "user", content: "hello" }],
+      ...(lane === "translated" ? { store: true } : {}),
+      ...extraBody,
+    }),
+  }), config, { model: "", provider: "" });
+  await response.text();
+  expect(response.status).toBe(200);
+  expect(mock.captured).toHaveLength(1);
+  return mock.captured[0]!;
+}
+
+for (const lane of ["native", "translated"] as const) {
+  test(`${lane} Chat applies a Droid default before dispatch and consumes its header`, async () => {
+    const sent = await send(lane, { "x-opencodex-droid-default-effort": "high" });
+    expect(sent.body.reasoning_effort ?? (sent.body.reasoning as Record<string, unknown> | undefined)?.effort).toBe("high");
+    expect(sent.headers.has("x-opencodex-droid-default-effort")).toBe(false);
+    expect(sent.path).toBe("/v1/chat/completions");
+    expect(sent.body.stream).toBe(lane === "translated");
+  });
+
+  test(`${lane} Chat leaves explicit effort values and invalid defaults alone`, async () => {
+    const medium = await send(lane, { "x-opencodex-droid-default-effort": "high" }, { reasoning_effort: "medium" });
+    expect(medium.body.reasoning_effort ?? (medium.body.reasoning as Record<string, unknown> | undefined)?.effort).toBe("medium");
+    for (const explicit of [
+      { reasoning_effort: null },
+      { reasoning_effort: "not-a-canonical-effort" },
+      { reasoning: { effort: "low" } },
+    ]) {
+      const baseline = await send(lane, {}, explicit);
+      const withHeader = await send(lane, { "x-opencodex-droid-default-effort": "high" }, explicit);
+      expect(withHeader.body).toEqual(baseline.body);
+    }
+    const baselineNone = await send(lane, {}, { reasoning_effort: "none" });
+    const withHeaderNone = await send(lane, { "x-opencodex-droid-default-effort": "high" }, { reasoning_effort: "none" });
+    expect(withHeaderNone.body).toEqual(baselineNone.body);
+    const absent = await send(lane, { "x-opencodex-droid-default-effort": "not-valid" });
+    expect(Object.hasOwn(absent.body, "reasoning_effort")).toBe(false);
+    expect(Object.hasOwn(absent.body, "reasoning")).toBe(false);
+    const noHeader = await send(lane, {});
+    expect(Object.hasOwn(noHeader.body, "reasoning_effort")).toBe(false);
+    expect(Object.hasOwn(noHeader.body, "reasoning")).toBe(false);
+  });
+
+  test(`${lane} Chat accepts declared minimal and none defaults`, async () => {
+    for (const effort of ["minimal", "none"]) {
+      const explicit = await send(lane, {}, { reasoning_effort: effort });
+      const defaulted = await send(lane, { "x-opencodex-droid-default-effort": effort });
+      expect(defaulted.body).toEqual(explicit.body);
+      if (lane === "native") expect(defaulted.body.reasoning_effort).toBe(effort);
+    }
+  });
+
+  test(`${lane} Chat applies a low model pin after the Droid high default`, async () => {
+    const sent = await send(lane, { "x-opencodex-droid-default-effort": "high" }, {}, { pin: "low" });
+    expect(sent.body.reasoning_effort ?? (sent.body.reasoning as Record<string, unknown> | undefined)?.effort).toBe("low");
+  });
+
+  test(`${lane} Chat uses the export fallback ladder when no ladder is configured`, async () => {
+    const sent = await send(lane, { "x-opencodex-droid-default-effort": "high" }, {}, { omitProviderLadder: true });
+    expect(sent.body.reasoning_effort ?? (sent.body.reasoning as Record<string, unknown> | undefined)?.effort).toBe("high");
+  });
+
+  test(`${lane} Chat respects an empty per-model ladder`, async () => {
+    const sent = await send(lane, { "x-opencodex-droid-default-effort": "high" }, {}, { omitProviderLadder: true, modelEfforts: [] });
+    expect(Object.hasOwn(sent.body, "reasoning_effort")).toBe(false);
+    expect(Object.hasOwn(sent.body, "reasoning")).toBe(false);
+  });
+
+  test(`${lane} Chat ignores a Droid default outside the resolved namespaced model ladder`, async () => {
+    const sent = await send(lane, { "x-opencodex-droid-default-effort": "high" }, {}, { modelEfforts: ["low"] });
+    expect(Object.hasOwn(sent.body, "reasoning_effort")).toBe(false);
+    expect(Object.hasOwn(sent.body, "reasoning")).toBe(false);
+  });
+
+  test(`${lane} Chat preserves an explicit effort even when outside the model ladder`, async () => {
+    const extra = { reasoning_effort: "high" };
+    const baseline = await send(lane, {}, extra, { modelEfforts: ["low"] });
+    const withHeader = await send(lane, { "x-opencodex-droid-default-effort": "low" }, extra, { modelEfforts: ["low"] });
+    expect(withHeader.body).toEqual(baseline.body);
+  });
+
+  test(`${lane} Chat applies a qualifying low effort cap after the Droid high default`, async () => {
+    const tools = [
+      { type: "function", function: { name: "spawn_agent", parameters: { type: "object", properties: {} } } },
+      { type: "function", function: { name: "send_message", parameters: { type: "object", properties: {} } } },
+    ];
+    const sent = await send(lane, { "x-opencodex-droid-default-effort": "high" }, { tools }, { cap: "low" });
+    expect(sent.body.reasoning_effort ?? (sent.body.reasoning as Record<string, unknown> | undefined)?.effort).toBe("low");
+  });
+}
+
+test("Chat synthetic low effort row takes precedence over the Droid high default", async () => {
+  const rowId = effortRowId("mock/model", "low");
+  const sent = await send(
+    "translated",
+    { "x-opencodex-droid-default-effort": "high" },
+    {},
+    { omitProviderLadder: true, syntheticEffortRows: true },
+    rowId,
+  );
+  expect(sent.body.reasoning?.effort ?? sent.body.reasoning_effort).toBe("low");
+});
+
+function sentEffort(captured: { body: Record<string, unknown> }) {
+  return captured.body.reasoning_effort ?? (captured.body.reasoning as Record<string, unknown> | undefined)?.effort;
+}
+
+type FallbackRoute = "bridge combo" | "native combo" | "policy";
+let fallbackRun = 0;
+
+async function sendFallback(route: FallbackRoute, extraBody: Record<string, unknown>, droidHeader: boolean) {
+  releaseSpendHome ??= acquireOwnedSpendHome();
+  const first = failingUpstream();
+  const second = upstream();
+  const routeId = `fallback-${++fallbackRun}`;
+  const targets = [{ provider: "first", model: "m1" }, { provider: "second", model: "m2" }];
+  const config = {
+    defaultProvider: "first",
+    providers: {
+      first: {
+        adapter: "openai-chat", baseUrl: first.baseUrl, apiKey: "fixture", models: ["m1"],
+        allowPrivateNetwork: true, modelReasoningEfforts: { m1: ["low", "high"] },
+        transientRetryOn5xx: { attempts: 1 },
+      },
+      second: {
+        adapter: "openai-chat", baseUrl: second.baseUrl, apiKey: "fixture", models: ["m2"],
+        allowPrivateNetwork: true, modelReasoningEfforts: { m2: ["low"] },
+      },
+    },
+    ...(route === "policy"
+      ? { routingProfiles: { [routeId]: { candidates: targets } } }
+      : { combos: { [routeId]: { strategy: "failover", targets } } }),
+    ...(route === "native combo" ? { protocols: { rollout: { nativeChatCombos: true } } } : {}),
+  } as OcxConfig;
+  const response = await handleChatCompletions(new Request("http://localhost/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...(droidHeader ? { "x-opencodex-droid-default-effort": "high" } : {}),
+    },
+    body: JSON.stringify({
+      model: `${route === "policy" ? "policy" : "combo"}/${routeId}`,
+      stream: false,
+      messages: [{ role: "user", content: "hello" }],
+      ...extraBody,
+    }),
+  }), config, { model: "", provider: "" });
+  await response.text();
+  expect(response.status).toBe(200);
+  expect(first.captured).toHaveLength(1);
+  expect(second.captured).toHaveLength(1);
+  expect(first.captured[0]!.headers.has("x-opencodex-droid-default-effort")).toBe(false);
+  expect(second.captured[0]!.headers.has("x-opencodex-droid-default-effort")).toBe(false);
+  if (route !== "policy") expect(first.captured[0]!.body.stream).toBe(route === "bridge combo");
+  return [sentEffort(first.captured[0]!), sentEffort(second.captured[0]!)];
+}
+
+for (const route of ["bridge combo", "native combo", "policy"] as const) {
+  test(`Chat ${route} applies the Droid default only on targets whose ladder has it`, async () => {
+    expect(await sendFallback(route, {}, true)).toEqual(["high", undefined]);
+  });
+
+  test(`Chat ${route} keeps explicit caller effort ahead of the Droid default`, async () => {
+    expect(await sendFallback(route, { reasoning_effort: "low" }, true)).toEqual(["low", "low"]);
+    for (const reasoning_effort of [null, "not-a-canonical-effort"]) {
+      const baseline = await sendFallback(route, { reasoning_effort }, false);
+      expect(await sendFallback(route, { reasoning_effort }, true)).toEqual(baseline);
+    }
+  });
+}
diff --git a/tests/server/management-droid-reasoning-defaults.test.ts b/tests/server/management-droid-reasoning-defaults.test.ts
new file mode 100644
index 00000000000..4cbbd1dec6f
--- /dev/null
+++ b/tests/server/management-droid-reasoning-defaults.test.ts
@@ -0,0 +1,145 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { droidConfigPath, droidHomeDir } from "../../src/clients/config-export";
+import { INTEGRATION_CLIENTS } from "../../src/integrations/registry";
+import { createIntegrationStateStore, type IntegrationStateStore } from "../../src/integrations/store";
+import { handleManagementAPI } from "../../src/server/management-api";
+import { loadExportModels, resetExportSnapshotForTests } from "../../src/server/management/model-rows";
+import { setIntegrationMutationFlightTestHooks, setIntegrationPathTestHooks } from "../../src/server/management/integration-routes";
+import type { OcxConfig } from "../../src/types";
+import { catalogConvergenceFactory } from "../helpers/catalog-convergence";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const HEADER = "x-opencodex-droid-default-effort";
+const routeEnv = {} as NodeJS.ProcessEnv;
+let root: string;
+let home: string;
+let store: IntegrationStateStore;
+let config: OcxConfig;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "ocx-management-droid-effort-"));
+  home = join(root, "home");
+  mkdirSync(home, { recursive: true });
+  store = createIntegrationStateStore(join(root, "store", "integrations"));
+  config = {
+    port: 10100, hostname: "127.0.0.1", defaultProvider: "a",
+    providers: {
+      a: {
+        adapter: "openai-chat", baseUrl: "https://a.example/v1", liveModels: false,
+        models: ["m1"], modelReasoningEfforts: { m1: ["low", "high"] },
+      },
+    },
+  } as unknown as OcxConfig;
+  resetExportSnapshotForTests();
+  setIntegrationMutationFlightTestHooks({ store });
+  setIntegrationPathTestHooks({ env: routeEnv, home });
+});
+
+afterEach(() => {
+  resetExportSnapshotForTests();
+  setIntegrationMutationFlightTestHooks(null);
+  setIntegrationPathTestHooks(null);
+  removeTreeWithRetry(root);
+});
+
+async function api(path: string, init: RequestInit = {}): Promise<Response> {
+  const url = new URL(`http://127.0.0.1:10100${path}`);
+  const response = await handleManagementAPI(
+    new Request(url, { ...init, headers: { Host: url.host, ...(init.headers ?? {}) } }),
+    url,
+    config,
+    { saveConfigPreservingClaudeCode: () => {}, createManagementConvergeCodex: catalogConvergenceFactory() },
+  );
+  expect(response).not.toBeNull();
+  return response!;
+}
+
+async function postPreview(body: unknown): Promise<Response> {
+  return api("/api/client-integrations/preview", {
+    method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body),
+  });
+}
+
+async function putDroid(body: unknown): Promise<Response> {
+  return api("/api/client-integrations/droid", {
+    method: "PUT", headers: { "content-type": "application/json" }, body: JSON.stringify(body),
+  });
+}
+
+async function setupCatalog(): Promise<string> {
+  await loadExportModels(config, [{ id: "m1", provider: "a", reasoningEfforts: ["low", "high"] }]);
+  mkdirSync(droidHomeDir(routeEnv, home), { recursive: true });
+  const path = droidConfigPath(routeEnv, home);
+  writeFileSync(path, '{"customModels":[]}\n');
+  return path;
+}
+
+describe("Droid reasoning defaults management contract", () => {
+  test("preview binds the supplied map, commit persists it, and status projects owned values", async () => {
+    const path = await setupCatalog();
+    const defaults = { "a/m1": "high" };
+    const preview = await postPreview({ clientId: "droid", operation: "apply", droidReasoningDefaults: defaults });
+    expect(preview.status).toBe(200);
+    const plan = await preview.json() as { canApply: boolean; fingerprint: string };
+    expect(plan.canApply).toBe(true);
+
+    const commit = await putDroid({ enabled: true, operation: "apply", planFingerprint: plan.fingerprint, droidReasoningDefaults: defaults });
+    expect(commit.status).toBe(200);
+    const settings = JSON.parse(readFileSync(path, "utf8")) as { customModels: Array<Record<string, unknown>> };
+    expect(settings.customModels[0]).toMatchObject({ extraHeaders: { [HEADER]: "high" } });
+
+    const status = await api("/api/client-integrations/droid");
+    expect(status.status).toBe(200);
+    const projected = await status.json() as {
+      clientId: string; state: string;
+      droidReasoning: { models: Array<{ model: string; label: string; efforts: string[] }>; defaults: Record<string, string> };
+    };
+    expect(projected.clientId).toBe("droid");
+    expect(projected.state).toBe("current");
+    expect(projected.droidReasoning.models.find(model => model.model === "a/m1")).toEqual({
+      model: "a/m1", label: "M1", efforts: ["low", "high"],
+    });
+    expect(projected.droidReasoning.defaults).toEqual(defaults);
+  });
+
+  test("preview and commit reject undeclared models or efforts", async () => {
+    await setupCatalog();
+    for (const droidReasoningDefaults of [{ "a/missing": "high" }, { "a/m1": "medium" }]) {
+      const preview = await postPreview({ clientId: "droid", operation: "apply", droidReasoningDefaults });
+      expect(preview.status).toBe(400);
+      expect(await preview.json()).toMatchObject({ code: "invalid_droid_reasoning_defaults" });
+      const commit = await putDroid({ enabled: true, droidReasoningDefaults });
+      expect(commit.status).toBe(400);
+      expect(await commit.json()).toMatchObject({ code: "invalid_droid_reasoning_defaults" });
+    }
+  });
+
+  test("changing the defaults after preview refuses the write", async () => {
+    const path = await setupCatalog();
+    const before = readFileSync(path, "utf8");
+    const preview = await postPreview({
+      clientId: "droid", operation: "apply", droidReasoningDefaults: { "a/m1": "high" },
+    });
+    expect(preview.status).toBe(200);
+    const plan = await preview.json() as { fingerprint: string };
+    const changed = await putDroid({
+      enabled: true, operation: "apply", planFingerprint: plan.fingerprint,
+      droidReasoningDefaults: { "a/m1": "low" },
+    });
+    expect(changed.status).toBe(409);
+    expect(await changed.json()).toMatchObject({ code: "integration_preview_stale" });
+    expect(readFileSync(path, "utf8")).toBe(before);
+    expect(store.listOperations("droid")).toEqual([]);
+  });
+
+  test("the map is rejected for another client and for disable", async () => {
+    await setupCatalog();
+    const otherClient = await postPreview({ clientId: "dsh", operation: "apply", droidReasoningDefaults: {} });
+    expect(otherClient.status).toBe(400);
+    const disabled = await putDroid({ enabled: false, droidReasoningDefaults: {} });
+    expect(disabled.status).toBe(400);
+  });
+});