@jopqior/pi-subagents-model-selector 0.1.0 → 1.0.1

package/README.md

@@ -42,21 +42,24 @@ If the core is missing, failed to load, or lacks `registerSpawnSelectionProvider
 
 ## Behavior
 
-Every **new** run in an enabled root's in-process tree asks twice: model, then thinking.
+Every **new** run in an enabled root's in-process tree opens one `/model`-style form: model, thinking, and Submit.
 Foreground tool calls, background tool calls, and `SubagentsService.spawn()` all go through the same gate.
 
 The operator's pair is applied after ordinary call and config resolution.
 It overrides defaults, explicit `model`/`thinking` arguments, and `locked:` values for those two fields only.
 Other locked fields are unchanged.
 
-The catalogue is every authenticated available model of the session whose manager is spawning — not a process-global list, and not `/scoped-models`.
-A model that supports only `off` still shows `off` and requires confirmation.
+The all-tab catalogue is every authenticated available model of the session whose manager is spawning — not a process-global list.
+The scoped tab is `ctx.scopedModels` intersected with that catalogue, and is hidden when the intersection is empty.
+Ctrl+S toggles all/scoped when the scoped tab exists.
+A model that supports only `off` still shows `off` and requires an explicit choice on the thinking tab.
 
 Concurrent requests are FIFO at the root chooser.
-A queued run does not open a dialog until it is admitted.
-Cancel either dialog stops that run without creating a workspace or child session.
+A queued run does not open the form until it is admitted.
+Cancel the form stops that run without creating a workspace or child session.
 
-Missing UI, a UI that is not yet attached, an empty catalogue, or an invalid selection fails that run explicitly.
+A missing TUI, a UI that is not yet attached, an empty catalogue, or an invalid selection fails that run explicitly.
+Print, JSON, and RPC sessions fail closed — there is no `ui.select` fallback.
 There is no default, timeout, remembered choice, or retry.
 
 Nested children still route to the root UI, including when this package is excluded from them.
@@ -68,15 +71,13 @@ The parent's active model, thinking level, agent files, and tool-call arguments
 ## Lifecycle
 
 The extension captures `getSubagentsService()` once during initialization and registers the provider immediately, before any `session_start` handler can spawn.
-It attaches `ctx.ui.select` at `session_start` and closes the chooser at `session_shutdown`.
+It attaches `ctx.ui.custom` at `session_start` when `ctx.mode` is `tui`, and closes the chooser at `session_shutdown`.
 A request that arrives before the UI is attached fails closed rather than waiting for a later sequential handler.
 
-Print, JSON, and other non-interactive sessions cannot satisfy the selection requirement.
-
 ## Limitations
 
 - Out-of-process children and third-party session factories are not covered.
-- The dialogs are Pi's generic `ui.select()`, not the native `/model` picker.
+- The form rebuilds the `/model` experience without mounting Pi's `ModelSelectorComponent` (no type-to-filter on the thinking tab, no set-as-default).
 - Public task status stays `running` while waiting.
   Pending selection is private widget, foreground, and background wording.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jopqior/pi-subagents-model-selector",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "description": "Pi extension that asks for model and thinking before every new pi-subagents run.",
   "type": "module",
   "imports": {
@@ -44,7 +44,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.84.4",
-    "@earendil-works/pi-coding-agent": ">=0.84.4"
+    "@earendil-works/pi-coding-agent": ">=0.84.4",
+    "@earendil-works/pi-tui": ">=0.84.4"
   },
   "dependencies": {
     "@jopqior/pi-subagents": "^1.0.0"
@@ -53,6 +54,7 @@
     "@biomejs/biome": "^2.5.11",
     "@earendil-works/pi-ai": "0.84.4",
     "@earendil-works/pi-coding-agent": "0.84.4",
+    "@earendil-works/pi-tui": "0.84.4",
     "@types/node": "^22.15.3",
     "rumdl": "0.2.24",
     "typescript": "^6.0.3",

package/src/index.ts

@@ -7,8 +7,10 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
 import { getSubagentsService } from "@jopqior/pi-subagents";
 import { ModelSelector } from "./model-selector";
+import { presentSelectionForm } from "./selection-form-component";
 
 const MISSING_CORE_MESSAGE =
   "@jopqior/pi-subagents-model-selector requires @jopqior/pi-subagents with registerSpawnSelectionProvider, loaded before this extension.";
@@ -34,9 +36,18 @@ export default function piSubagentsModelSelectorExtension(
 
   pi.on("session_start", (_event, ctx) => {
     chooser.attachUI({
-      hasUI: ctx.hasUI,
-      select: (title, options, signal) =>
-        ctx.ui.select(title, options, { signal }),
+      isTui: ctx.mode === "tui",
+      sessionFacts: () => ({
+        currentModel: ctx.model,
+        scopedModels: ctx.scopedModels,
+        defaultModel: readDefaultModel(ctx.cwd),
+      }),
+      presentForm: (input, signal) =>
+        presentSelectionForm(
+          (factory, options) => ctx.ui.custom(factory, options),
+          input,
+          signal,
+        ),
     });
   });
 
@@ -45,3 +56,19 @@ export default function piSubagentsModelSelectorExtension(
     registration.dispose();
   });
 }
+
+function readDefaultModel(
+  cwd: string,
+): { provider: string; id: string } | undefined {
+  try {
+    const settings = SettingsManager.create(cwd);
+    const provider = settings.getDefaultProvider();
+    const id = settings.getDefaultModel();
+    if (!provider || !id) {
+      return undefined;
+    }
+    return { provider, id };
+  } catch {
+    return undefined;
+  }
+}

package/src/model-search-text.ts

@@ -0,0 +1,19 @@
+/**
+ * model-search-text.ts — Haystack for the spawn form's model filter.
+ *
+ * Copied from Pi 0.84.4 `getModelSelectorSearchText`, which is not a public
+ * SDK export. The bare model id is kept out of the leading position so a
+ * provider-prefixed query ranks before proxy-provider ids.
+ */
+
+export interface ModelSearchItem {
+  readonly id: string;
+  readonly provider: string;
+  readonly name?: string;
+}
+
+export function getModelSelectorSearchText(item: ModelSearchItem): string {
+  const { id, provider } = item;
+  const name = item.name ? ` ${item.name}` : "";
+  return `${provider} ${provider}/${id} ${provider} ${id}${name}`;
+}

package/src/model-selector.ts

@@ -1,36 +1,45 @@
 /**
- * model-selector.ts — Two public Pi dialogs for one spawn selection.
+ * model-selector.ts — One TUI form for spawn model and thinking.
  *
- * Model first, then thinking. Every option — including a single `off` — is
- * confirmed explicitly. Missing UI is an error, not an approval.
+ * Missing TUI is an error, not an approval. Cancel returns undefined and
+ * creates no child. Concurrent requests stay FIFO at the queue.
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import type { ScopedModel } from "@earendil-works/pi-coding-agent";
 import type {
   SpawnSelection,
   SpawnSelectionProvider,
   SpawnSelectionRequest,
 } from "@jopqior/pi-subagents";
+import type { SelectionFormInput, SelectionFormResult } from "./selection-form";
+import { modelTitle } from "./selection-labels";
 import {
   SelectionQueue,
   SelectionQueueCancelledError,
   SelectionQueueClosedError,
 } from "./selection-queue";
 
-const DESCRIPTION_LIMIT = 80;
-
-const NO_UI = "Spawn model selection requires an interactive UI.";
+const NO_UI = "Spawn model selection requires a TUI.";
 const NO_MODELS = "No models are available to select.";
 const CLOSED = "Spawn model selection is closed.";
 
+export interface SelectionSessionFacts {
+  readonly currentModel: Model<Api> | undefined;
+  readonly scopedModels: readonly ScopedModel[];
+  readonly defaultModel:
+    | { readonly provider: string; readonly id: string }
+    | undefined;
+}
+
 export interface SelectionUIPort {
-  readonly hasUI: boolean;
-  select(
-    title: string,
-    options: string[],
+  readonly isTui: boolean;
+  sessionFacts(): SelectionSessionFacts;
+  presentForm(
+    input: SelectionFormInput,
     signal: AbortSignal,
-  ): Promise<string | undefined>;
+  ): Promise<SelectionFormResult>;
 }
 
 export class ModelSelector implements SpawnSelectionProvider {
@@ -84,7 +93,7 @@ export class ModelSelector implements SpawnSelectionProvider {
     if (this.queue.closed) {
       throw new Error(CLOSED);
     }
-    if (!this.ui?.hasUI) {
+    if (!this.ui?.isTui) {
       throw new Error(NO_UI);
     }
     if (request.availableModels.length === 0) {
@@ -101,54 +110,28 @@ export class ModelSelector implements SpawnSelectionProvider {
       return undefined;
     }
     const ui = this.ui;
-    if (!ui?.hasUI) {
+    if (!ui?.isTui) {
       throw new Error(NO_UI);
     }
-
-    const labels = request.availableModels.map(modelLabel);
-    const modelChoice = await ui.select(
-      modelTitle(request),
-      [...labels],
+    const facts = ui.sessionFacts();
+    const result = await ui.presentForm(
+      {
+        title: modelTitle(request),
+        availableModels: request.availableModels,
+        currentModel: facts.currentModel,
+        scopedModels: facts.scopedModels,
+        defaultModel: facts.defaultModel,
+        levelsFor: this.levelsFor,
+      },
       dialogSignal,
     );
     if (
-      modelChoice === undefined ||
+      result.kind === "cancel" ||
       this.abandoned(requestSignal, dialogSignal)
     ) {
       return undefined;
     }
-    const modelIndex = labels.indexOf(modelChoice);
-    const model =
-      modelIndex < 0 ? undefined : request.availableModels[modelIndex];
-    if (model === undefined) {
-      throw new Error(
-        `Selected option ${JSON.stringify(modelChoice)} does not match any offered model.`,
-      );
-    }
-
-    const levels = [...this.levelsFor(model)];
-    if (levels.length === 0) {
-      throw new Error(
-        `Model ${model.provider}/${model.id} has no supported thinking levels.`,
-      );
-    }
-    const thinkingChoice = await ui.select(
-      thinkingTitle(model),
-      [...levels],
-      dialogSignal,
-    );
-    if (
-      thinkingChoice === undefined ||
-      this.abandoned(requestSignal, dialogSignal)
-    ) {
-      return undefined;
-    }
-    if (!isListedLevel(thinkingChoice, levels)) {
-      throw new Error(
-        `Selected thinking level ${JSON.stringify(thinkingChoice)} is not supported.`,
-      );
-    }
-    return { model, thinkingLevel: thinkingChoice };
+    return { model: result.model, thinkingLevel: result.thinkingLevel };
   }
 
   private abandoned(
@@ -158,29 +141,3 @@ export class ModelSelector implements SpawnSelectionProvider {
     return this.queue.closed || requestSignal.aborted || dialogSignal.aborted;
   }
 }
-
-function isListedLevel(
-  value: string,
-  levels: readonly SpawnSelection["thinkingLevel"][],
-): value is SpawnSelection["thinkingLevel"] {
-  return levels.some((level) => level === value);
-}
-
-function modelLabel(model: Model<Api>): string {
-  return `${model.provider}/${model.id} — ${model.name}`;
-}
-
-function boundDescription(description: string): string {
-  if (description.length <= DESCRIPTION_LIMIT) {
-    return description;
-  }
-  return `${description.slice(0, DESCRIPTION_LIMIT - 1)}…`;
-}
-
-function modelTitle(request: SpawnSelectionRequest): string {
-  return `Select model for ${request.agentType} ${request.agentId} — ${boundDescription(request.description)}`;
-}
-
-function thinkingTitle(model: Model<Api>): string {
-  return `Select thinking level for ${model.provider}/${model.id} (${model.name})`;
-}

package/src/selection-form-component.ts

@@ -0,0 +1,242 @@
+/**
+ * selection-form-component.ts — TUI adapter for the spawn selection form.
+ *
+ * Maps raw keys onto form events, owns the search Input, and bridges the
+ * queue's abort signal to `done` because `ui.custom` has no `signal` option.
+ */
+
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { modelsAreEqual } from "@earendil-works/pi-ai";
+import { type Component, Input, matchesKey } from "@earendil-works/pi-tui";
+import {
+  createSelectionFormState,
+  reduceSelectionForm,
+  type SelectionFormEvent,
+  type SelectionFormInput,
+  type SelectionFormResult,
+  type SelectionFormState,
+  viewSelectionForm,
+} from "./selection-form";
+
+const MAX_VISIBLE = 10;
+
+interface FormTheme {
+  fg(color: string, text: string): string;
+}
+
+interface FormKeybindings {
+  matches(data: string, action: string): boolean;
+}
+
+type FormCustom = (
+  factory: (
+    tui: { requestRender: () => void },
+    theme: FormTheme,
+    keybindings: FormKeybindings,
+    done: (result: SelectionFormResult) => void,
+  ) => Component,
+  options?: { overlay?: boolean },
+) => Promise<SelectionFormResult>;
+
+export function presentSelectionForm(
+  custom: FormCustom,
+  input: SelectionFormInput,
+  signal: AbortSignal,
+): Promise<SelectionFormResult> {
+  if (signal.aborted) {
+    return Promise.resolve({ kind: "cancel" });
+  }
+  return custom(
+    (tui, theme, keybindings, done) => {
+      let closed = false;
+      const finish = (result: SelectionFormResult): void => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        signal.removeEventListener("abort", onAbort);
+        done(result);
+      };
+      const onAbort = (): void => {
+        finish({ kind: "cancel" });
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      return new SelectionFormComponent(
+        input,
+        theme,
+        keybindings,
+        () => {
+          tui.requestRender();
+        },
+        finish,
+      );
+    },
+    { overlay: false },
+  );
+}
+
+class SelectionFormComponent implements Component {
+  private state: SelectionFormState;
+  private readonly search = new Input();
+
+  constructor(
+    private readonly input: SelectionFormInput,
+    private readonly theme: FormTheme,
+    private readonly keybindings: FormKeybindings,
+    private readonly requestRender: () => void,
+    private readonly finish: (result: SelectionFormResult) => void,
+  ) {
+    this.state = createSelectionFormState(input);
+    this.search.focused = true;
+  }
+
+  invalidate(): void {
+    // No cached rendering state to clear.
+  }
+
+  render(width: number): string[] {
+    const view = viewSelectionForm(this.state, this.input);
+    const lines: string[] = [this.theme.fg("accent", this.input.title), ""];
+    if (view.hasScoped) {
+      const allText =
+        view.scope === "all"
+          ? this.theme.fg("accent", "all")
+          : this.theme.fg("muted", "all");
+      const scopedText =
+        view.scope === "scoped"
+          ? this.theme.fg("accent", "scoped")
+          : this.theme.fg("muted", "scoped");
+      lines.push(
+        `${this.theme.fg("muted", "Scope: ")}${allText}${this.theme.fg("muted", " | ")}${scopedText}`,
+      );
+      lines.push(this.theme.fg("muted", "Ctrl+S scope (all/scoped)"));
+    } else {
+      lines.push(
+        this.theme.fg(
+          "warning",
+          "Only showing models from configured providers. Use /login to add providers.",
+        ),
+      );
+    }
+    lines.push("");
+    if (view.tab === "model") {
+      this.search.focused = true;
+      lines.push(...this.search.render(width));
+      lines.push("");
+      lines.push(...this.renderModelRows(view.models, view.highlightedIndex));
+    } else if (view.tab === "thinking") {
+      this.search.focused = false;
+      for (const [index, level] of view.thinkingLevels.entries()) {
+        const selected = index === view.thinkingHighlight;
+        const chosen =
+          level === view.thinkingLevel ? this.theme.fg("success", " ✓") : "";
+        const prefix = selected ? this.theme.fg("accent", "→ ") : "  ";
+        const label = selected ? this.theme.fg("accent", level) : level;
+        lines.push(`${prefix}${label}${chosen}`);
+      }
+    } else {
+      const model = view.pendingModel;
+      const modelLabel = model ? `${model.id} [${model.provider}]` : "(none)";
+      lines.push(`Model: ${modelLabel}`);
+      lines.push(`Thinking: ${view.thinkingLevel ?? "(none)"}`);
+      if (view.submitMessage) {
+        lines.push(this.theme.fg("warning", view.submitMessage));
+      }
+    }
+    lines.push("");
+    lines.push(this.theme.fg("dim", "Tab cycle · Enter confirm · Esc cancel"));
+    return lines;
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "ctrl+s")) {
+      this.apply({ type: "toggleScope" });
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.apply({ type: "cancel" });
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.input.tab")) {
+      this.apply({ type: "moveTab", direction: "next" });
+      return;
+    }
+    if (matchesKey(data, "shift+tab")) {
+      this.apply({ type: "moveTab", direction: "prev" });
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.up")) {
+      this.apply({ type: "moveRow", direction: "up" });
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.down")) {
+      this.apply({ type: "moveRow", direction: "down" });
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.confirm")) {
+      this.apply({ type: "confirmTab" });
+      return;
+    }
+    if (this.state.tab === "model") {
+      this.search.handleInput(data);
+      this.apply({ type: "filter", query: this.search.getValue() });
+    }
+  }
+
+  private apply(event: SelectionFormEvent): void {
+    this.state = reduceSelectionForm(this.state, event, this.input);
+    if (this.state.status.kind !== "open") {
+      this.finish(this.state.status);
+      return;
+    }
+    this.requestRender();
+  }
+
+  private renderModelRows(
+    models: readonly Model<Api>[],
+    selectedIndex: number,
+  ): string[] {
+    const lines: string[] = [];
+    if (models.length === 0) {
+      lines.push(this.theme.fg("muted", "  No matching models"));
+      return lines;
+    }
+    const startIndex = Math.max(
+      0,
+      Math.min(
+        selectedIndex - Math.floor(MAX_VISIBLE / 2),
+        models.length - MAX_VISIBLE,
+      ),
+    );
+    const endIndex = Math.min(startIndex + MAX_VISIBLE, models.length);
+    for (let index = startIndex; index < endIndex; index++) {
+      const model = models[index];
+      const isSelected = index === selectedIndex;
+      const isCurrent = modelsAreEqual(this.input.currentModel, model);
+      const isDefault =
+        this.input.defaultModel?.provider === model.provider &&
+        this.input.defaultModel.id === model.id;
+      const defaultBadge = isDefault
+        ? this.theme.fg("muted", " · default")
+        : "";
+      const checkmark = isCurrent ? this.theme.fg("success", " ✓") : "";
+      const providerBadge = this.theme.fg("muted", `[${model.provider}]`);
+      if (isSelected) {
+        lines.push(
+          `${this.theme.fg("accent", "→ ")}${this.theme.fg("accent", model.id)} ${providerBadge}${defaultBadge}${checkmark}`,
+        );
+      } else {
+        lines.push(`  ${model.id} ${providerBadge}${defaultBadge}${checkmark}`);
+      }
+    }
+    if (startIndex > 0 || endIndex < models.length) {
+      lines.push(
+        this.theme.fg("muted", `  (${selectedIndex + 1}/${models.length})`),
+      );
+    }
+    const selected = models[selectedIndex];
+    lines.push("");
+    lines.push(this.theme.fg("muted", `  Model Name: ${selected.name}`));
+    return lines;
+  }
+}

package/src/selection-form.ts

@@ -0,0 +1,411 @@
+/**
+ * selection-form.ts — Pure spawn-selection form state.
+ *
+ * Reduce over decoded events. Rendering and keymaps live in the TUI adapter.
+ */
+
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { modelsAreEqual } from "@earendil-works/pi-ai";
+import { fuzzyFilter } from "@earendil-works/pi-tui";
+import type { SpawnSelection } from "@jopqior/pi-subagents";
+import { getModelSelectorSearchText } from "./model-search-text";
+
+const TABS = ["model", "thinking", "submit"] as const;
+
+export type SelectionTab = (typeof TABS)[number];
+export type SelectionScope = "all" | "scoped";
+
+export type SelectionFormResult =
+  | {
+      readonly kind: "submit";
+      readonly model: Model<Api>;
+      readonly thinkingLevel: SpawnSelection["thinkingLevel"];
+    }
+  | { readonly kind: "cancel" };
+
+export type SelectionFormStatus =
+  | { readonly kind: "open" }
+  | SelectionFormResult;
+
+export type SelectionFormEvent =
+  | { readonly type: "toggleScope" }
+  | { readonly type: "moveRow"; readonly direction: "up" | "down" }
+  | { readonly type: "filter"; readonly query: string }
+  | { readonly type: "moveTab"; readonly direction: "next" | "prev" }
+  | { readonly type: "confirmTab" }
+  | { readonly type: "cancel" };
+
+export interface SelectionFormInput {
+  readonly title: string;
+  readonly availableModels: readonly Model<Api>[];
+  readonly currentModel: Model<Api> | undefined;
+  readonly scopedModels: readonly { readonly model: Model<Api> }[];
+  readonly defaultModel:
+    | { readonly provider: string; readonly id: string }
+    | undefined;
+  readonly levelsFor: (
+    model: Model<Api>,
+  ) => readonly SpawnSelection["thinkingLevel"][];
+}
+
+export interface SelectionFormState {
+  readonly tab: SelectionTab;
+  readonly scope: SelectionScope;
+  readonly query: string;
+  readonly highlightedIndex: number;
+  readonly thinkingHighlight: number;
+  readonly thinkingLevel: SpawnSelection["thinkingLevel"] | undefined;
+  readonly submitMessage: string | undefined;
+  readonly status: SelectionFormStatus;
+}
+
+export interface SelectionFormView extends SelectionFormState {
+  readonly hasScoped: boolean;
+  readonly models: readonly Model<Api>[];
+  readonly pendingModel: Model<Api> | undefined;
+  readonly thinkingLevels: readonly SpawnSelection["thinkingLevel"][];
+  readonly canSubmit: boolean;
+}
+
+export function createSelectionFormState(
+  input: SelectionFormInput,
+): SelectionFormState {
+  const scope: SelectionScope =
+    scopedCatalogue(input).length > 0 ? "scoped" : "all";
+  const active = activeModels(scope, input);
+  const currentIndex = active.findIndex((model) =>
+    modelsAreEqual(input.currentModel, model),
+  );
+  return {
+    tab: "model",
+    scope,
+    query: "",
+    highlightedIndex: currentIndex >= 0 ? currentIndex : 0,
+    thinkingHighlight: 0,
+    thinkingLevel: undefined,
+    submitMessage: undefined,
+    status: { kind: "open" },
+  };
+}
+
+export function reduceSelectionForm(
+  state: SelectionFormState,
+  event: SelectionFormEvent,
+  input: SelectionFormInput,
+): SelectionFormState {
+  if (state.status.kind !== "open" && event.type !== "cancel") {
+    return state;
+  }
+  switch (event.type) {
+    case "toggleScope":
+      return toggleScope(state, input);
+    case "moveRow":
+      return moveRow(state, event.direction, input);
+    case "filter":
+      return applyFilter(state, event.query, input);
+    case "moveTab":
+      return moveTab(state, event.direction);
+    case "confirmTab":
+      return confirmTab(state, input);
+    case "cancel":
+      return { ...state, status: { kind: "cancel" } };
+  }
+}
+
+export function viewSelectionForm(
+  state: SelectionFormState,
+  input: SelectionFormInput,
+): SelectionFormView {
+  const models = visibleModels(state, input);
+  const pendingModel = modelAt(models, state.highlightedIndex);
+  const thinkingLevels = pendingModel ? input.levelsFor(pendingModel) : [];
+  return {
+    ...state,
+    hasScoped: scopedCatalogue(input).length > 0,
+    models,
+    pendingModel,
+    thinkingLevels,
+    canSubmit: pendingModel !== undefined && state.thinkingLevel !== undefined,
+  };
+}
+
+function toggleScope(
+  state: SelectionFormState,
+  input: SelectionFormInput,
+): SelectionFormState {
+  if (scopedCatalogue(input).length === 0) {
+    return state;
+  }
+  const scope: SelectionScope = state.scope === "all" ? "scoped" : "all";
+  const active = activeModels(scope, input);
+  const currentIndex = active.findIndex((model) =>
+    modelsAreEqual(input.currentModel, model),
+  );
+  const highlightedIndex = state.query
+    ? 0
+    : currentIndex >= 0
+      ? currentIndex
+      : 0;
+  return syncModelCursor({ ...state, scope, highlightedIndex }, input);
+}
+
+function applyFilter(
+  state: SelectionFormState,
+  query: string,
+  input: SelectionFormInput,
+): SelectionFormState {
+  return syncModelCursor(
+    {
+      ...state,
+      query,
+      highlightedIndex: query ? 0 : state.highlightedIndex,
+      submitMessage: undefined,
+    },
+    input,
+  );
+}
+
+function moveRow(
+  state: SelectionFormState,
+  direction: "up" | "down",
+  input: SelectionFormInput,
+): SelectionFormState {
+  if (state.tab === "thinking") {
+    const levels = currentThinkingLevels(state, input);
+    if (levels.length === 0) {
+      return state;
+    }
+    return {
+      ...state,
+      thinkingHighlight: wrapIndex(
+        state.thinkingHighlight,
+        levels.length,
+        direction,
+      ),
+    };
+  }
+  if (state.tab !== "model") {
+    return state;
+  }
+  const models = visibleModels(state, input);
+  if (models.length === 0) {
+    return state;
+  }
+  return syncModelCursor(
+    {
+      ...state,
+      highlightedIndex: wrapIndex(
+        state.highlightedIndex,
+        models.length,
+        direction,
+      ),
+    },
+    input,
+  );
+}
+
+function moveTab(
+  state: SelectionFormState,
+  direction: "next" | "prev",
+): SelectionFormState {
+  const index = TABS.indexOf(state.tab);
+  const next =
+    direction === "next"
+      ? (index + 1) % TABS.length
+      : (index + TABS.length - 1) % TABS.length;
+  return { ...state, tab: TABS[next], submitMessage: undefined };
+}
+
+function confirmTab(
+  state: SelectionFormState,
+  input: SelectionFormInput,
+): SelectionFormState {
+  if (state.tab === "model") {
+    if (
+      modelAt(visibleModels(state, input), state.highlightedIndex) === undefined
+    ) {
+      return state;
+    }
+    return { ...state, tab: "thinking", submitMessage: undefined };
+  }
+  if (state.tab === "thinking") {
+    const levels = currentThinkingLevels(state, input);
+    const chosen = modelAt(levels, state.thinkingHighlight);
+    if (chosen === undefined) {
+      return state;
+    }
+    return {
+      ...state,
+      thinkingLevel: chosen,
+      tab: "submit",
+      submitMessage: undefined,
+    };
+  }
+  const model = modelAt(visibleModels(state, input), state.highlightedIndex);
+  if (model === undefined) {
+    return { ...state, submitMessage: "Select a model." };
+  }
+  if (state.thinkingLevel === undefined) {
+    return { ...state, submitMessage: "Select a thinking level." };
+  }
+  return {
+    ...state,
+    submitMessage: undefined,
+    status: { kind: "submit", model, thinkingLevel: state.thinkingLevel },
+  };
+}
+
+function syncModelCursor(
+  state: SelectionFormState,
+  input: SelectionFormInput,
+): SelectionFormState {
+  const models = visibleModels(state, input);
+  const highlightedIndex = Math.min(
+    state.highlightedIndex,
+    Math.max(0, models.length - 1),
+  );
+  const next = { ...state, highlightedIndex };
+  const levels = currentThinkingLevels(next, input);
+  const kept =
+    next.thinkingLevel !== undefined && levels.includes(next.thinkingLevel)
+      ? next.thinkingLevel
+      : undefined;
+  return {
+    ...next,
+    thinkingLevel: kept,
+    thinkingHighlight:
+      kept === undefined ? 0 : Math.max(0, levels.indexOf(kept)),
+  };
+}
+
+function currentThinkingLevels(
+  state: SelectionFormState,
+  input: SelectionFormInput,
+): readonly SpawnSelection["thinkingLevel"][] {
+  const model = modelAt(visibleModels(state, input), state.highlightedIndex);
+  return model ? input.levelsFor(model) : [];
+}
+
+function visibleModels(
+  state: SelectionFormState,
+  input: SelectionFormInput,
+): readonly Model<Api>[] {
+  return filterModels(activeModels(state.scope, input), state.query, input);
+}
+
+function activeModels(
+  scope: SelectionScope,
+  input: SelectionFormInput,
+): readonly Model<Api>[] {
+  if (scope === "scoped") {
+    const scoped = scopedCatalogue(input);
+    if (scoped.length > 0) {
+      return scoped;
+    }
+  }
+  return sortModels(input.availableModels, input);
+}
+
+function scopedCatalogue(input: SelectionFormInput): readonly Model<Api>[] {
+  const matched: Model<Api>[] = [];
+  for (const scoped of input.scopedModels) {
+    const catalogue = input.availableModels.find(
+      (model) =>
+        model.provider === scoped.model.provider &&
+        model.id === scoped.model.id,
+    );
+    if (
+      catalogue &&
+      !matched.some(
+        (model) =>
+          model.provider === catalogue.provider && model.id === catalogue.id,
+      )
+    ) {
+      matched.push(catalogue);
+    }
+  }
+  return sortModels(matched, input);
+}
+
+function sortModels(
+  models: readonly Model<Api>[],
+  input: SelectionFormInput,
+): Model<Api>[] {
+  return [...models].sort((a, b) => {
+    const aCurrent = modelsAreEqual(input.currentModel, a);
+    const bCurrent = modelsAreEqual(input.currentModel, b);
+    if (aCurrent !== bCurrent) {
+      return aCurrent ? -1 : 1;
+    }
+    const aDefault = isDefaultModel(a, input.defaultModel);
+    const bDefault = isDefaultModel(b, input.defaultModel);
+    if (aDefault !== bDefault) {
+      return aDefault ? -1 : 1;
+    }
+    return a.provider.localeCompare(b.provider);
+  });
+}
+
+function filterModels(
+  models: readonly Model<Api>[],
+  query: string,
+  input: SelectionFormInput,
+): readonly Model<Api>[] {
+  if (!query) {
+    return models;
+  }
+  const filtered = fuzzyFilter([...models], query, (model) =>
+    modelHaystack(model, input),
+  );
+  if (!isDefaultSearch(query)) {
+    return filtered;
+  }
+  const defaults = models.filter((model) =>
+    isDefaultModel(model, input.defaultModel),
+  );
+  const keys = new Set(
+    defaults.map((model) => `${model.provider}\0${model.id}`),
+  );
+  return [
+    ...defaults,
+    ...filtered.filter((model) => !keys.has(`${model.provider}\0${model.id}`)),
+  ];
+}
+
+function modelHaystack(model: Model<Api>, input: SelectionFormInput): string {
+  const text = getModelSelectorSearchText({
+    id: model.id,
+    provider: model.provider,
+    name: model.name,
+  });
+  return isDefaultModel(model, input.defaultModel) ? `${text} default` : text;
+}
+
+function isDefaultSearch(query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  return normalized.length > 0 && "default".startsWith(normalized);
+}
+
+function isDefaultModel(
+  model: Model<Api>,
+  defaultModel: SelectionFormInput["defaultModel"],
+): boolean {
+  return (
+    defaultModel?.provider === model.provider && defaultModel.id === model.id
+  );
+}
+
+function modelAt<T>(items: readonly T[], index: number): T | undefined {
+  return index >= 0 && index < items.length ? items[index] : undefined;
+}
+
+function wrapIndex(
+  index: number,
+  length: number,
+  direction: "up" | "down",
+): number {
+  if (direction === "down") {
+    return index === length - 1 ? 0 : index + 1;
+  }
+  return index === 0 ? length - 1 : index - 1;
+}

package/src/selection-labels.ts

@@ -0,0 +1,17 @@
+/**
+ * selection-labels.ts — Title and description bounds for the spawn form.
+ */
+import type { SpawnSelectionRequest } from "@jopqior/pi-subagents";
+
+const DESCRIPTION_LIMIT = 80;
+
+export function boundDescription(description: string): string {
+  if (description.length <= DESCRIPTION_LIMIT) {
+    return description;
+  }
+  return `${description.slice(0, DESCRIPTION_LIMIT - 1)}…`;
+}
+
+export function modelTitle(request: SpawnSelectionRequest): string {
+  return `Select model for ${request.agentType} ${request.agentId} — ${boundDescription(request.description)}`;
+}