feat: opt-in Nadir model routing and compaction settings

apps/mobile/src/features/settings/SettingsServerControlsRouteScreen.tsx

@@ -396,6 +396,34 @@ function ServerSettingsDetail(props: { readonly page: SettingsPage }) {
                     onValueChange={(value) => write({ enableAgentBrowserAccess: value })}
                   />
                 </SettingsSection>
+                <SettingsSection title="Nadir">
+                  <SettingsSwitchRow
+                    icon="arrow.triangle.branch"
+                    label="Nadir model routing"
+                    subtitle={managedSubtitle(
+                      "nadirRouting",
+                      projectSelected
+                        ? "Environment-wide setting. Select All projects to change it."
+                        : "Nadir picks each turn's model from the selected provider's list, never above yours unless your Nadir organization pins one. Sends the message text to getnadir.com and can delay a send by up to 2.5 seconds.",
+                    )}
+                    value={uniform("nadirRouting")}
+                    disabled={disabledFor("nadirRouting")}
+                    onValueChange={(value) => write({ nadirRouting: value })}
+                  />
+                  <SettingsSwitchRow
+                    icon="arrow.down.right.and.arrow.up.left"
+                    label="Nadir compaction"
+                    subtitle={managedSubtitle(
+                      "nadirCompaction",
+                      projectSelected
+                        ? "Environment-wide setting. Select All projects to change it."
+                        : "New Claude threads shrink bulky tool output with Nadir's compaction, keeping an exact copy. Needs Nadir installed (npx nadir-labs). No network calls.",
+                    )}
+                    value={uniform("nadirCompaction")}
+                    disabled={disabledFor("nadirCompaction")}
+                    onValueChange={(value) => write({ nadirCompaction: value })}
+                  />
+                </SettingsSection>
                 <AutoSettleSettingsRows write={write} pending={pendingWrites > 0} />
               </>
             ) : null}

apps/mobile/src/state/thread-outbox-model.ts

@@ -194,6 +194,22 @@ export function threadOutboxRetryDelayMs(attempt: number): number {
 
 export type ThreadOutboxDeliveryAction = "wait" | "remove" | "send";
 
+/**
+ * Whether a delivered send hands the composer's model pick back to the thread: only a new turn,
+ * which Nadir may route. An "auto" send into an active run steers it and keeps the model.
+ */
+export function releasesComposerModelPick(input: {
+  readonly nadirRouting: boolean;
+  readonly dispatchMode: ComposerDispatchMode | undefined;
+  readonly activeRunId: string | null;
+}): boolean {
+  return (
+    input.nadirRouting &&
+    (input.dispatchMode === undefined || input.dispatchMode === "auto") &&
+    input.activeRunId === null
+  );
+}
+
 export function resolveThreadOutboxDeliveryAction(input: {
   readonly isCreation: boolean;
   readonly threadExists: boolean;

apps/mobile/src/state/thread-outbox.test.ts

@@ -79,6 +79,7 @@ import {
   decodeQueuedThreadMessage,
   encodeQueuedThreadMessage,
   isQueuedThreadCreationSendable,
+  releasesComposerModelPick,
   resolveThreadOutboxDeliveryAction,
   resolveThreadOutboxDispatchStep,
   resolveThreadOutboxFailureAction,
@@ -1132,6 +1133,17 @@ describe("thread outbox", () => {
     ).toEqual({ step: "send" });
   });
 
+  it("hands the model pick back only after a new turn Nadir may route", () => {
+    const newTurn = { nadirRouting: true, dispatchMode: "auto", activeRunId: null } as const;
+    expect(releasesComposerModelPick(newTurn)).toBe(true);
+    expect(releasesComposerModelPick({ ...newTurn, dispatchMode: undefined })).toBe(true);
+    // An "auto" send into an active run steers it, and the pick is still the next turn's.
+    expect(releasesComposerModelPick({ ...newTurn, activeRunId: "run-active" })).toBe(false);
+    expect(releasesComposerModelPick({ ...newTurn, dispatchMode: "queue" })).toBe(false);
+    expect(releasesComposerModelPick({ ...newTurn, dispatchMode: "steer" })).toBe(false);
+    expect(releasesComposerModelPick({ ...newTurn, nadirRouting: false })).toBe(false);
+  });
+
   it("only removes a missing-thread message after shell synchronization is live", () => {
     expect(
       resolveThreadOutboxDeliveryAction({

apps/mobile/src/state/thread-task-permissions.test.ts

@@ -172,6 +172,7 @@ vi.mock("./use-composer-drafts", async () => {
     appendComposerDraftText: vi.fn(),
     mergeComposerDraftContent: vi.fn(),
     removeComposerDraftAttachment: vi.fn(),
+    rememberSentComposerPick: () => {},
     useComposerDraft: () => state.draft,
     useComposerDraftSettings: () => state.draft,
     questionAttachmentDraftsAtom: () => Atom.make({}),

apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts

@@ -153,6 +153,7 @@ vi.mock("./use-composer-drafts", async () => {
     }),
     replaceComposerDraftAttachments: vi.fn(),
     setFreshSessionPending: vi.fn(),
+    takeSentComposerPick: () => undefined,
     undoComposerDraftMerge: vi.fn(),
     updateComposerDraftSettings: vi.fn(),
     waitForComposerDraftsLoaded: vi.fn(),

apps/mobile/src/state/threadOutboxDelivery.ts

@@ -59,6 +59,7 @@ import {
 import { removeThreadOutboxMessage } from "./thread-outbox-removal";
 import {
   isQueuedThreadCreationSendable,
+  releasesComposerModelPick,
   resolveThreadOutboxDeliveryAction,
   resolveThreadOutboxDispatchStep,
   resolveThreadOutboxFailureAction,
@@ -78,8 +79,10 @@ import {
   type ComposerDraft,
   getComposerDraftSnapshot,
   mergeComposerDraftContent,
+  releaseComposerDraftModelSelection,
   replaceComposerDraftAttachments,
   removeDeliveredCloudQueuedMessage,
+  takeSentComposerPick,
   undoComposerDraftMerge,
   updateComposerDraftSettings,
   waitForComposerDraftsLoaded,
@@ -964,6 +967,21 @@ export function createThreadOutboxDelivery(): {
       return restoreQueuedMessage(persistedMessage, failure.message);
     }
     acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId);
+    // Nadir may run a new turn on another model; the picker then shows the one that ran.
+    const sentPick = takeSentComposerPick(queuedMessage.commandId);
+    if (
+      sentPick !== undefined &&
+      releasesComposerModelPick({
+        nadirRouting: currentConfig.settings?.nadirRouting === true,
+        dispatchMode: queuedMessage.dispatchMode,
+        activeRunId: thread.runtime?.activeRunId ?? null,
+      })
+    ) {
+      releaseComposerDraftModelSelection(
+        scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
+        sentPick,
+      );
+    }
     const delivered =
       (await completeQueuedMessageDelivery(
         persistedMessage,

apps/mobile/src/state/use-composer-drafts.test.ts

@@ -210,10 +210,13 @@ import {
   insertComposerDraftContext,
   insertComposerDraftText,
   rememberComposerDraftSelection,
+  rememberSentComposerPick,
+  releaseComposerDraftModelSelection,
   setComposerDraftAttachmentUpload,
   waitForComposerDraftsLoaded,
   setStickyComposerModelSelection,
   stickyComposerModelSelectionAtom,
+  takeSentComposerPick,
   undoComposerDraftMergeState,
   updateComposerDraftSettings,
 } from "./use-composer-drafts";
@@ -587,6 +590,23 @@ describe("mobile composer drafts", () => {
     expect(appAtomRegistry.get(composerDraftsAtom)[key]).toBeUndefined();
   });
 
+  it("releases only the pick a queued send used", () => {
+    const key = "environment-1:thread-picks";
+    const sol = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-6-sol" };
+    // A draft with no pick sends the thread's model, so a pick made while it waits stays.
+    rememberSentComposerPick("send-1", getComposerDraftSnapshot(key).modelSelection);
+    updateComposerDraftSettings(key, { modelSelection: sol });
+    expect(takeSentComposerPick("send-1")).toBeUndefined();
+    // Picking the sent model again is a new pick, so releasing the sent one leaves it.
+    rememberSentComposerPick("send-2", getComposerDraftSnapshot(key).modelSelection);
+    updateComposerDraftSettings(key, { modelSelection: { ...sol } });
+    const sent = takeSentComposerPick("send-2");
+    expect(sent).toBe(sol);
+    releaseComposerDraftModelSelection(key, sent!);
+    expect(getComposerDraftSnapshot(key).modelSelection).toEqual(sol);
+    expect(takeSentComposerPick("send-2")).toBeUndefined();
+  });
+
   it("drops chips and records for attachments a replace no longer keeps", () => {
     const key = "new-task:draft-1";
     const kept = {

apps/mobile/src/state/use-composer-drafts.ts

@@ -1328,6 +1328,22 @@ function updateComposerDrafts(
   schedulePersistComposerState();
 }
 
+// The draft pick each queued send used, by command id. A send from a draft with no pick has no
+// entry, so a pick made while it was queued stays. After a restart the entry is gone and the
+// picker keeps the pick. ponytail: a send that never delivers leaves its entry until then.
+const sentComposerPicks = new Map<string, ModelSelection>();
+
+export function rememberSentComposerPick(commandId: string, pick: ModelSelection | undefined) {
+  if (pick !== undefined) sentComposerPicks.set(commandId, pick);
+}
+
+/** The draft pick a queued send used, if it had one; forgotten once read. */
+export function takeSentComposerPick(commandId: string): ModelSelection | undefined {
+  const pick = sentComposerPicks.get(commandId);
+  sentComposerPicks.delete(commandId);
+  return pick;
+}
+
 export function setStickyComposerModelSelection(modelSelection: ModelSelection): void {
   appAtomRegistry.set(stickyComposerModelSelectionAtom, modelSelection);
   schedulePersistComposerState();

apps/mobile/src/state/use-thread-composer-state.ts

@@ -82,6 +82,7 @@ import {
   getComposerDraftSnapshot,
   isFreshSessionPending,
   mergeComposerDraftContent,
+  rememberSentComposerPick,
   removeComposerDraftAttachment,
   scheduleUnusedComposerAttachmentCleanup,
   setComposerDraftText,
@@ -799,6 +800,7 @@ export function useThreadComposerState(input: {
     const messageId = MessageId.make(metadata.messageId);
     onWillEnqueue?.();
     clearThreadComposerError(threadKey);
+    rememberSentComposerPick(metadata.commandId, draft.modelSelection);
     const enqueuePromise = enqueueThreadOutboxMessage({
       environmentId: selectedThreadShell.environmentId,
       threadId: selectedThreadShell.id,

apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts

@@ -96,6 +96,7 @@ import { WorktreeToolkit } from "../../mcp/toolkits/worktree/tools.ts";
 import { ThreadToolkit } from "../../mcp/toolkits/thread/tools.ts";
 import { OrchestratorToolkit } from "../../mcp/toolkits/orchestrator/tools.ts";
 import { ClaudeExecutableFileCheck } from "../../provider/Drivers/ClaudeExecutable.ts";
+import * as ServerSettings from "../../serverSettings.ts";
 import {
   BUNDLED_CLAUDE_MODEL_CATALOG,
   type ClaudeModelCatalog,
@@ -386,13 +387,25 @@ describe("ClaudeAdapterV2 runtime query policy", () => {
       nativeThreadId: "native-tool-search",
       resume: false,
       cwd: "/workspace",
-      sdkSettings: { env: { OTHER: "kept" } },
+      sdkSettings: {
+        env: { OTHER: "kept" },
+        hooks: {
+          PostToolUse: [{ matcher: "Write", hooks: [{ type: "command", command: "user-hook" }] }],
+        },
+      },
       toolSearchOverride: "true",
+      extraHooks: {
+        PostToolUse: [{ matcher: "Read", hooks: [{ type: "command", command: "x" }] }],
+      },
     });
     assert.deepEqual((options.settings as { env?: Record<string, string> }).env, {
       OTHER: "kept",
       ENABLE_TOOL_SEARCH: "true",
     });
+    assert.deepEqual((options.settings as { hooks?: Record<string, unknown> }).hooks?.PostToolUse, [
+      { matcher: "Write", hooks: [{ type: "command", command: "user-hook" }] },
+      { matcher: "Read", hooks: [{ type: "command", command: "x" }] },
+    ]);
   });
 
   it("sends the auto-compact window as the env var Claude Code prefers", () => {
@@ -4668,6 +4681,58 @@ describe("ClaudeAdapterV2 background wake turns", () => {
         ),
     );
 
+    it.effect("skips Nadir compaction when a custom home's settings already run it", () =>
+      Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-nadir-" });
+        const hostHome = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-host-home-" });
+        const script = path.join(home, "nadir", "context_session.py");
+        yield* fileSystem.makeDirectory(path.dirname(script), { recursive: true });
+        yield* fileSystem.writeFileString(script, "");
+        const injectsNadir = Effect.scoped(
+          Effect.gen(function* () {
+            const harness = yield* makeWakeHarnessWithOptions({
+              settings: { ...DEFAULT_CLAUDE_SETTINGS, homePath: home },
+            });
+            yield* harness.runtime.startTurn(
+              makeClaudeTestTurnInput({
+                threadId: harness.threadId,
+                providerThread: harness.providerThread,
+                now: yield* DateTime.now,
+                attemptId: RunAttemptId.make("attempt-nadir-custom-home"),
+                text: "Run git status.",
+                attachments: [],
+              }),
+            );
+            const settings = harness.getOpenedOptions()?.settings as ClaudeSdk.Settings | undefined;
+            return (settings?.hooks?.PostToolUse ?? []).some((matcher) =>
+              matcher.hooks.some((hook) => "args" in hook && hook.args?.[0] === script),
+            );
+          }),
+        ).pipe(
+          Effect.provide(ServerSettings.layerTest({ nadirCompaction: true })),
+          Effect.provideService(HostProcess.HomeDirectory, hostHome),
+          Effect.provideService(SpawnExecutableResolution, () => "/usr/bin/python3"),
+        );
+        assert.isTrue(yield* injectsNadir);
+        yield* fileSystem.writeFileString(
+          path.join(home, "settings.json"),
+          JSON.stringify({ enabledPlugins: { "nadir-route@nadir": true } }),
+        );
+        assert.isFalse(yield* injectsNadir);
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            IdAllocator.layer,
+            McpProviderSessions.layer,
+            NodeServices.layer,
+            NodeCrypto.layer,
+          ),
+        ),
+      ),
+    );
+
     // regression: #21806 only a missing custom settings file is benign; bad policy fails
     it.effect(
       "distinguishes missing custom settings from unreadable, malformed, or unresolved policy",