@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/fusion/src/pi-settings.ts

@@ -0,0 +1,57 @@
+/**
+ * Persist pi's startup model into its global settings file
+ * ($PI_CODING_AGENT_DIR/settings.json, default ~/.pi/agent/settings.json) —
+ * the same keys pi's own `/model` ctrl+s writes
+ * (settings-manager.d.ts setDefaultModelAndProvider/setDefaultThinkingLevel).
+ * Atomic: write temp file + rename. Preserves every other key.
+ */
+
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function piSettingsPath(env: NodeJS.ProcessEnv = process.env, home = homedir()): string {
+  const envDir = env.PI_CODING_AGENT_DIR?.trim();
+  return join(envDir !== undefined && envDir.length > 0 ? envDir : join(home, ".pi", "agent"), "settings.json");
+}
+
+export function mergeDefaultModel(
+  raw: unknown,
+  patch: { provider: string; model: string; thinkingLevel?: string },
+): Record<string, unknown> {
+  const settings = typeof raw === "object" && raw !== null && !Array.isArray(raw) ? { ...(raw as Record<string, unknown>) } : {};
+  settings.defaultProvider = patch.provider;
+  settings.defaultModel = patch.model;
+  if (patch.thinkingLevel !== undefined) settings.defaultThinkingLevel = patch.thinkingLevel;
+  return settings;
+}
+
+/** pi's saved startup model (`provider/id`) and thinking level, if any. */
+export function readDefaultModel(deps: { readFile?: (p: string) => string; env?: NodeJS.ProcessEnv } = {}): { key?: string; thinking?: string } {
+  try {
+    const path = piSettingsPath(deps.env);
+    const raw = JSON.parse(deps.readFile !== undefined ? deps.readFile(path) : readFileSync(path, "utf8")) as Record<string, unknown>;
+    const key = typeof raw.defaultProvider === "string" && typeof raw.defaultModel === "string" ? `${raw.defaultProvider}/${raw.defaultModel}` : undefined;
+    return { key, thinking: typeof raw.defaultThinkingLevel === "string" ? raw.defaultThinkingLevel : undefined };
+  } catch {
+    return {};
+  }
+}
+
+export function persistDefaultModel(
+  patch: { provider: string; model: string; thinkingLevel?: string },
+  deps: { readFile?: (p: string) => string; env?: NodeJS.ProcessEnv } = {},
+): string {
+  const path = piSettingsPath(deps.env);
+  let current: unknown = {};
+  try {
+    current = JSON.parse(deps.readFile !== undefined ? deps.readFile(path) : readFileSync(path, "utf8")) as unknown;
+  } catch {
+    current = {};
+  }
+  const next = mergeDefaultModel(current, patch);
+  const tmp = `${path}.tmp-${String(process.pid)}`;
+  writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  renameSync(tmp, path);
+  return path;
+}

package/packages/fusion/src/picker.ts

@@ -30,10 +30,11 @@
  *
  * On the Fusion row, Tab cycles effort → lead → sidekick (Shift+Tab
  * reverses); the lead/sidekick focus opens an inline dropdown fed by the
- * preset lists.
+ * preset lists. With the effort control focused, Space toggles whether ←/→
+ * adjusts the lead's or the sidekick's effort (default: lead).
  */
 
-import { Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { frameOverlay } from "@pi-unipi/core";
 import {
   effortLabel,
@@ -67,6 +68,8 @@ export interface PickerState {
   active: ActiveSelection | undefined;
   /** The session's current model — its row lights up with ✓. */
   currentModelKey: ModelKey | undefined;
+  /** pi's persisted startup model — its row gets a dim `default` tag. */
+  defaultModelKey: ModelKey | undefined;
   effort: Readonly<Record<ModelKey, EffortLevel>>;
   /** Effort used for a model with no remembered level. */
   fallbackEffort: EffortLevel;
@@ -98,6 +101,8 @@ export interface PickerOptions {
   state: PickerState;
   theme: PickerTheme;
   onDone: (result: PickerResult) => void;
+  /** alt+enter: persist the highlighted row as the startup default (then apply). */
+  onSetDefault?: (result: PickerResult) => void;
   onRenderRequest?: (() => void) | undefined;
   /** Rows visible in the list window. */
   visibleRows?: number | undefined;
@@ -171,6 +176,7 @@ function pad(text: string, width: number): string {
 export class ModelPicker {
   private readonly theme: PickerTheme;
   private readonly onDone: (result: PickerResult) => void;
+  private readonly onSetDefault?: (result: PickerResult) => void;
   private readonly onRenderRequest: (() => void) | undefined;
   private readonly visibleRows: number;
   private readonly modelsByKey: Map<ModelKey, PickerModel>;
@@ -189,6 +195,8 @@ export class ModelPicker {
   private search = "";
   private selected = 0;
   private focus: FusionFocus = "effort";
+  /** Which side ←/→ adjusts on the Fusion row's effort control. */
+  private effortTarget: "lead" | "sidekick" = "lead";
   private dropdownIndex = 0;
   private done = false;
 
@@ -196,6 +204,7 @@ export class ModelPicker {
     this.state = options.state;
     this.theme = options.theme;
     this.onDone = options.onDone;
+    this.onSetDefault = options.onSetDefault;
     this.onRenderRequest = options.onRenderRequest;
     this.visibleRows = options.visibleRows ?? DEFAULT_VISIBLE_ROWS;
     this.modelsByKey = new Map(options.state.models.map((m) => [m.key, m]));
@@ -209,14 +218,21 @@ export class ModelPicker {
     this.priceRange = { min: prices.length > 0 ? Math.min(...prices) : 0, max: prices.length > 0 ? Math.max(...prices) : 0 };
     this.effort = { ...options.state.effort };
     const active = options.state.active;
-    this.lead =
-      (active?.kind === "fusion" ? active.lead : undefined) ??
-      options.state.fusionDefault.lead ??
-      options.state.fusionLeads[0];
-    this.sidekick =
-      (active?.kind === "fusion" ? active.sidekick : undefined) ??
-      options.state.fusionDefault.sidekick ??
-      options.state.fusionSidekicks[0];
+    // Saved keys can go stale (provider renamed a model, logged out); only
+    // accept ones still in the catalogue, else the Fusion row looks ready but
+    // cannot be applied.
+    const known = (...keys: (ModelKey | undefined)[]): ModelKey | undefined =>
+      keys.find((k) => k !== undefined && this.modelsByKey.has(k));
+    this.lead = known(
+      active?.kind === "fusion" ? active.lead : undefined,
+      options.state.fusionDefault.lead,
+      ...options.state.fusionLeads,
+    );
+    this.sidekick = known(
+      active?.kind === "fusion" ? active.sidekick : undefined,
+      options.state.fusionDefault.sidekick,
+      ...options.state.fusionSidekicks,
+    );
     this.fusionLeadEffort =
       (active?.kind === "fusion" ? active.leadEffort : undefined) ??
       (this.lead !== undefined ? this.effort[this.lead] : undefined) ??
@@ -266,8 +282,9 @@ export class ModelPicker {
       ...this.state.fusionLeads,
       ...this.state.fusionSidekicks,
     ];
-    // The whole catalogue always follows; the preset only controls ordering.
-    ordered.push(...this.state.models.map((m) => m.key));
+    // The preset IS the list; the rest of the catalogue appears only while
+    // searching (or when nothing is curated yet, so Fusion stays usable).
+    if (this.search.length > 0 || !this.hasPreset()) ordered.push(...this.state.models.map((m) => m.key));
     for (const key of ordered) {
       if (seen.has(key) || !this.modelsByKey.has(key)) continue;
       if (!this.matchesSearch(key)) continue;
@@ -286,9 +303,27 @@ export class ModelPicker {
     return this.rows()[this.selected];
   }
 
-  private dropdownItems(): ModelKey[] {
+  /** Whether any lead/sidekick is curated (and still in the catalogue). */
+  private hasPreset(): boolean {
+    return [...this.state.fusionLeads, ...this.state.fusionSidekicks].some((k) => this.modelsByKey.has(k));
+  }
+
+  /** Dropdown entries: only the curated list for this side. Typing searches
+   *  the whole catalogue (curated matches first, a dim separator, the rest);
+   *  an empty list offers the whole catalogue (Fusion works uncurated). */
+  private dropdownEntries(): Array<ModelKey | "sep"> {
     const source = this.focus === "lead" ? this.state.fusionLeads : this.state.fusionSidekicks;
-    return source.filter((k) => this.modelsByKey.has(k));
+    const listed = source.filter((k) => this.modelsByKey.has(k));
+    const curated = listed.filter((k) => this.matchesSearch(k));
+    if (listed.length > 0 && this.search.length === 0) return curated;
+    const rest = this.state.models.map((m) => m.key).filter((k) => !curated.includes(k) && this.matchesSearch(k));
+    if (curated.length === 0) return rest;
+    if (rest.length === 0) return curated;
+    return [...curated, "sep", ...rest];
+  }
+
+  private dropdownItems(): ModelKey[] {
+    return this.dropdownEntries().filter((e): e is ModelKey => e !== "sep");
   }
 
   // ── Input ────────────────────────────────────────────────────────────────
@@ -301,6 +336,7 @@ export class ModelPicker {
     if (matchesKey(data, Key.escape)) {
       if (inDropdown) {
         this.focus = "effort";
+        this.search = "";
         this.changed();
         return;
       }
@@ -309,15 +345,14 @@ export class ModelPicker {
     }
 
     const disabledFusion = row?.kind === "fusion" && !this.fusionAvailable();
-    if (
-      disabledFusion &&
-      (matchesKey(data, Key.tab) ||
-        matchesKey(data, Key.left) ||
-        matchesKey(data, Key.right) ||
-        matchesKey(data, Key.enter) ||
-        data === "\r")
-    ) {
-      return;
+    if (disabledFusion && !inDropdown) {
+      // Incomplete pair: Enter/Tab open the dropdown for the missing half.
+      if (matchesKey(data, Key.tab) || matchesKey(data, Key.enter) || data === "\r") {
+        this.openMissing();
+        this.changed();
+        return;
+      }
+      if (matchesKey(data, Key.left) || matchesKey(data, Key.right) || matchesKey(data, "alt+enter")) return;
     }
 
     if (inDropdown) {
@@ -329,11 +364,29 @@ export class ModelPicker {
       } else if (matchesKey(data, Key.tab)) {
         this.applyDropdown(items);
         this.cycleFocus(matchesKey(data, "shift+tab"));
+      } else if (matchesKey(data, "alt+enter")) {
+        this.applyDropdown(items);
+        if (!this.fusionAvailable()) this.openMissing();
+        else {
+          this.focus = "effort";
+          this.setDefault(row);
+          this.confirm(row);
+          return;
+        }
       } else if (matchesKey(data, Key.enter) || data === "\r") {
         this.applyDropdown(items);
-        this.focus = "effort";
+        this.search = "";
+        if (this.fusionAvailable()) this.focus = "effort";
+        else this.openMissing();
+      } else if (matchesKey(data, Key.backspace) || data === "\x7f") {
+        // Typing in a dropdown searches the whole catalogue.
+        this.search = this.search.slice(0, -1);
+        this.dropdownIndex = 0;
       } else {
-        return;
+        const ch = printable(data);
+        if (ch === undefined || ch === " ") return;
+        this.search += ch;
+        this.dropdownIndex = 0;
       }
       this.changed();
       return;
@@ -351,7 +404,11 @@ export class ModelPicker {
       const delta: -1 | 1 = matchesKey(data, Key.left) ? -1 : 1;
       if (row?.kind === "fusion") {
         // Fusion-row effort is its own state: never touches per-model memory.
-        if (this.focus === "effort") this.fusionLeadEffort = stepEffort(this.fusionLeadEffort, delta);
+        // Space picks which side ←/→ adjusts.
+        if (this.focus === "effort") {
+          if (this.effortTarget === "lead") this.fusionLeadEffort = stepEffort(this.fusionLeadEffort, delta);
+          else this.fusionSidekickEffort = stepEffort(this.fusionSidekickEffort, delta);
+        }
       } else if (row?.key !== undefined) {
         this.effort[row.key] = stepEffort(this.effortFor(row.key), delta);
       }
@@ -364,13 +421,27 @@ export class ModelPicker {
         return;
       }
     } else if (data === " " || matchesKey(data, Key.space)) {
-      // Space = quick action: stage the highlighted model as the Fusion lead.
+      // Space = quick action. On a model row it stages the highlighted model
+      // as the Fusion lead; on the Fusion row it toggles which side the
+      // effort control adjusts (Tab is taken by the lead/sidekick cycle).
+      if (row?.kind === "fusion") {
+        if (this.focus === "effort" && this.fusionAvailable()) {
+          this.effortTarget = this.effortTarget === "lead" ? "sidekick" : "lead";
+          this.changed();
+        }
+        return;
+      }
       if (row?.kind === "model" && !disabledFusion) {
         this.lead = row.key;
         this.changed();
         return;
       }
       return;
+    } else if (matchesKey(data, "alt+enter")) {
+      // Alt+Enter = apply AND keep it as the startup default.
+      this.setDefault(row);
+      this.confirm(row);
+      return;
     } else if (matchesKey(data, Key.enter) || data === "\r") {
       this.confirm(row);
       return;
@@ -399,6 +470,12 @@ export class ModelPicker {
     }
   }
 
+  /** Open the lead (or, if the lead is set, the sidekick) dropdown. */
+  private openMissing(): void {
+    this.focus = this.lead === undefined ? "effort" : "lead"; // cycleFocus steps one past this
+    this.cycleFocus();
+  }
+
   private applyDropdown(items: ModelKey[]): void {
     const pick = items[this.dropdownIndex];
     if (pick === undefined) return;
@@ -406,6 +483,31 @@ export class ModelPicker {
     else this.sidekick = pick;
   }
 
+  private setDefault(row: Row | undefined): void {
+    if (row === undefined || this.onSetDefault === undefined) return;
+    const mark = row.kind === "fusion" ? this.lead : row.key;
+    if (mark !== undefined) this.state.defaultModelKey = mark;
+    this.changed();
+    if (row.kind === "fusion") {
+      if (this.lead === undefined || this.sidekick === undefined) return;
+      this.onSetDefault({
+        type: "fusion",
+        lead: this.lead,
+        sidekick: this.sidekick,
+        leadEffort: this.fusionLeadEffort,
+        sidekickEffort: this.fusionSidekickEffort,
+        effortMap: { ...this.effort },
+      });
+    } else if (row.key !== undefined) {
+      this.onSetDefault({
+        type: "single",
+        model: row.key,
+        effort: this.effortFor(row.key),
+        effortMap: { ...this.effort },
+      });
+    }
+  }
+
   private confirm(row: Row | undefined): void {
     if (row === undefined) return;
     if (row.kind === "fusion") {
@@ -507,11 +609,16 @@ export class ModelPicker {
           : highlighted
             ? t.fg("accent", nameRaw)
             : t.fg("text", nameRaw);
-    const name = `${providerPrefix}${styled}`;
+    const name = `${providerPrefix}${styled}${row.kind === "model" && row.key === this.state.defaultModelKey ? ` ${t.fg("dim", "default")}` : ""}`;
     const badge = model?.badge;
     const badgeGlyph = badge === undefined ? "" : ` ${t.fg(badge === "new" ? "success" : badge === "promotion" ? "accent" : "warning", "✱")}`;
 
-    const level = row.kind === "fusion" ? this.fusionLeadEffort : this.effortFor(row.key);
+    const level =
+      row.kind === "fusion"
+        ? this.effortTarget === "lead"
+          ? this.fusionLeadEffort
+          : this.fusionSidekickEffort
+        : this.effortFor(row.key);
     const arrowsOn = !disabledFusion && highlighted && this.focus === "effort";
     const left = arrowsOn ? t.fg("accent", "←") : " ";
     const right = arrowsOn ? t.fg("accent", "→") : " ";
@@ -524,19 +631,24 @@ export class ModelPicker {
     let line = `${pointer} ${marker} ${pad(`${name}${badgeGlyph}`, nameCol)} ${left} ${this.bar(level, !disabledFusion && highlighted)} ${right} ${pad(label, 8)}`;
 
     if (row.kind === "fusion") {
-      if (disabledFusion) {
-        line += `   ${t.fg("dim", "not configured — open /unipi:settings → Fusion → Edit fusion presets…")}`;
-      } else {
+      if (!disabledFusion) {
         const leadName = this.nameOf(this.lead, 14);
         const sideName = this.nameOf(this.sidekick, 14);
         const leadFocused = highlighted && this.focus === "lead";
         const sideFocused = highlighted && this.focus === "sidekick";
+        // Each side shows its effort; a ▸ marks the side ←/→ adjusts.
+        const effortSuffix = (side: "lead" | "sidekick") => {
+          const lv = effortLabel(side === "lead" ? this.fusionLeadEffort : this.fusionSidekickEffort);
+          return highlighted && this.focus === "effort" && this.effortTarget === side
+            ? t.fg("accent", t.bold(` ▸${lv}`))
+            : t.fg("dim", ` ${lv}`);
+        };
         const leadText = leadFocused
-          ? `${t.fg("accent", t.bold("Lead"))} ${t.fg("accent", leadName)} ${t.fg("accent", "▾")}`
-          : `${t.fg("dim", "Lead")} ${t.fg("text", leadName)} ${t.fg("dim", "▾")}`;
+          ? `${t.fg("accent", t.bold("Lead"))} ${t.fg("accent", leadName)} ${t.fg("accent", "▾")}${effortSuffix("lead")}`
+          : `${t.fg("dim", "Lead")} ${t.fg("text", leadName)} ${t.fg("dim", "▾")}${effortSuffix("lead")}`;
         const sideText = sideFocused
-          ? `${t.fg("accent", t.bold("Sidekick"))} ${t.fg("accent", sideName)} ${t.fg("accent", "▾")}`
-          : `${t.fg("dim", "Sidekick")} ${t.fg("text", sideName)} ${t.fg("dim", "▾")}`;
+          ? `${t.fg("accent", t.bold("Sidekick"))} ${t.fg("accent", sideName)} ${t.fg("accent", "▾")}${effortSuffix("sidekick")}`
+          : `${t.fg("dim", "Sidekick")} ${t.fg("text", sideName)} ${t.fg("dim", "▾")}${effortSuffix("sidekick")}`;
         line += `   ${leadText}   ${sideText}`;
       }
     }
@@ -545,23 +657,37 @@ export class ModelPicker {
 
   private renderDropdown(width: number, nameCol: number): string[] {
     const t = this.theme;
+    const entries = this.dropdownEntries();
     const items = this.dropdownItems();
     const indent = " ".repeat(MARKER_COL + nameCol + 5);
     if (items.length === 0) {
-      return [`${indent}${t.fg("warning", `no ${this.focus} models in preset — open /unipi:settings → Fusion → "Edit fusion presets…"`)}`];
+      return [`${indent}${t.fg("warning", "no matching models")}`];
     }
-    const win = 6;
-    const start = Math.max(0, Math.min(this.dropdownIndex - Math.floor(win / 2), items.length - win));
-    const slice = items.slice(start, start + win);
-    return slice.map((key, i) => {
-      const idx = start + i;
-      const isCur = idx === this.dropdownIndex;
-      const isSet = key === (this.focus === "lead" ? this.lead : this.sidekick);
+    // Selectable index ↔ entry index mapping (a "sep" row renders but can't be picked).
+    const selectableIdx = new Map<ModelKey, number>();
+    items.forEach((key, i) => selectableIdx.set(key, i));
+    const firstEntryOfSel = items.map((key) => entries.indexOf(key));
+    const win = 8;
+    const selStart = Math.max(0, Math.min(this.dropdownIndex - Math.floor(win / 2), items.length - win));
+    const sliceStart = firstEntryOfSel[selStart] ?? 0;
+    const slice = entries.slice(sliceStart, sliceStart + win);
+    const above = sliceStart;
+    const below = Math.max(0, entries.length - (sliceStart + slice.length));
+    const more = (n: number, dir: string) => truncateToWidth(`${indent}${t.fg("dim", `${dir} ${String(n)} more`)}`, Math.max(1, width - 1));
+    return [
+      ...(above > 0 ? [more(above, "↑")] : []),
+      ...slice.map((entry) => {
+      if (entry === "sep") return truncateToWidth(`${indent}${t.fg("dim", "── all models ──")}`, Math.max(1, width - 1));
+      const selIdx = selectableIdx.get(entry) ?? 0;
+      const isCur = selIdx === this.dropdownIndex;
+      const isSet = entry === (this.focus === "lead" ? this.lead : this.sidekick);
       const glyph = isCur ? t.fg("accent", "▸") : " ";
-      const label = isCur ? t.fg("accent", t.bold(this.nameOf(key, 28))) : t.fg("text", this.nameOf(key, 28));
+      const label = isCur ? t.fg("accent", t.bold(this.nameOf(entry, 28))) : t.fg("text", this.nameOf(entry, 28));
       const star = isSet ? t.fg("dim", " *") : "";
       return truncateToWidth(`${indent}${glyph} ${label}${star}`, Math.max(1, width - 1));
-    });
+      }),
+      ...(below > 0 ? [more(below, "↓")] : []),
+    ];
   }
 
   private renderPricePanel(row: Row | undefined, width: number): string[] {
@@ -625,7 +751,9 @@ export class ModelPicker {
       const keyText = keys.map((k) => t.fg("text", k)).join(t.fg("dim", " · "));
       out.push(truncateToWidth(`  ${t.fg("dim", "Model key")}  ${keyText}`, width - 1));
     }
-    out.push(truncateToWidth(`  ${description}`, width - 1));
+    for (const line of wrapTextWithAnsi(`  ${description}`, Math.max(1, width - 1)).slice(0, 3)) {
+      out.push(truncateToWidth(line, width - 1));
+    }
     return out;
   }
 
@@ -633,13 +761,17 @@ export class ModelPicker {
     const t = this.theme;
     const parts: string[] = [];
     if (row?.kind === "fusion" && !this.fusionAvailable()) {
-      parts.push("↑↓ select", "esc cancel");
+      parts.push("↑↓ select", `enter pick ${this.lead === undefined ? "lead" : "sidekick"}`, "esc cancel");
     } else if (row?.kind === "fusion" && this.focus !== "effort") {
-      parts.push("↑↓ select", `tab ${this.focus === "lead" ? "sidekick" : "effort"}`, "enter apply", "esc collapse");
+      parts.push("↑↓ select", "type to search all models", `tab ${this.focus === "lead" ? "sidekick" : "effort"}`, "enter apply", "alt+enter set default", "esc collapse");
     } else {
       parts.push("↑↓ select");
-      if (row?.kind === "fusion") parts.push("tab lead");
-      parts.push("←→ effort", "enter/tab confirm", "space set lead", "esc cancel");
+      if (row?.kind === "fusion") {
+        const other = this.effortTarget === "lead" ? "sidekick" : "lead";
+        parts.push("tab lead", `←→ ${this.effortTarget} effort`, `space → ${other}`, "enter confirm", "alt+enter set default", "esc cancel");
+      } else {
+        parts.push("←→ effort", "enter/tab confirm", "alt+enter set default", "space set lead", "esc cancel");
+      }
     }
     return t.fg("dim", parts.join(" · "));
   }
@@ -675,6 +807,9 @@ export class ModelPicker {
         if (r === undefined) continue;
         const highlighted = i === this.selected;
         lines.push(this.renderRow(r, highlighted, width, nameCol));
+        if (r.kind === "fusion" && !this.fusionAvailable()) {
+          lines.push(truncateToWidth(`   ${t.fg("dim", "pick a lead and sidekick — the catalogue below works too (open /unipi:settings → Fusion → Edit fusion presets… to curate)")}`, Math.max(1, width - 1)));
+        }
         if (highlighted && r.kind === "fusion" && this.focus !== "effort") {
           lines.push(...this.renderDropdown(width, nameCol));
         }

package/packages/fusion/src/preset.ts

@@ -17,7 +17,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { getSettings, registerSettings, setSettings } from "@pi-unipi/core";
+import { getSettings, getSettingsScoped, registerSettings, setSettings } from "@pi-unipi/core";
+import { persistDefaultModel, readDefaultModel } from "./pi-settings.js";
 
 export const PRESET_SCHEMA_VERSION = 1;
 
@@ -206,6 +207,48 @@ export interface LoadedPreset {
   hasProjectLayer: boolean;
 }
 
+const STARTUP_THINKING = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+/**
+ * Hub → pi: a global write of `startup.*` becomes pi's own startup default
+ * (settings.json defaultProvider/defaultModel/defaultThinkingLevel — what
+ * pi's /model ctrl+s and the picker's alt+enter write). A single startup
+ * model also stops a remembered Fusion pair from overriding it at startup.
+ * Exported for tests.
+ */
+export function applyStartupSettings(layer: Record<string, unknown>, home = homedir()): boolean {
+  const startup = layer.startup as { model?: unknown; thinking?: unknown } | undefined;
+  const model = typeof startup?.model === "string" ? startup.model.trim() : "";
+  const thinking = typeof startup?.thinking === "string" && (STARTUP_THINKING as readonly string[]).includes(startup.thinking) ? startup.thinking : undefined;
+  const parts = model ? splitModelKey(model) : undefined;
+  const current = readDefaultModel();
+  if (parts === undefined && thinking === undefined) return false;
+  const nextKey = parts ? model : current.key;
+  if (nextKey === current.key && (thinking === undefined || thinking === current.thinking)) return false; // mirror echo
+  const target = nextKey ? splitModelKey(nextKey) : undefined;
+  if (target === undefined) return false;
+  persistDefaultModel({ provider: target.provider, model: target.id, thinkingLevel: thinking });
+  if (parts !== undefined) {
+    const path = globalPresetPath(home);
+    const existing = mergePresets(emptyPreset(), parsePreset(readJson(path)));
+    if (existing.active?.kind === "fusion" && existing.active.lead !== model) {
+      saveRuntimeState(path, { effort: existing.effort, recent: existing.recent, active: { kind: "single", model } });
+    }
+  }
+  return true;
+}
+
+/** pi → hub: show pi's real startup default in /unipi:settings (it also
+ *  changes through pi's /model ctrl+s and the picker's alt+enter). */
+export function mirrorStartupFromPi(cwd: string): void {
+  const { key, thinking } = readDefaultModel();
+  const shown = (getSettingsScoped("fusion", "global", cwd)?.startup ?? {}) as { model?: string; thinking?: string };
+  const patch: Record<string, string> = {};
+  if (key !== undefined && shown.model !== key) patch.model = key;
+  if (thinking !== undefined && shown.thinking !== thinking && (STARTUP_THINKING as readonly string[]).includes(thinking)) patch.thinking = thinking;
+  if (Object.keys(patch).length > 0) setSettings("fusion", { startup: patch }, "global", cwd);
+}
+
 // Registered with the unified settings hub: the DEFAULT PAIR is editable
 // there (model pickers, engine-layered). The curated arrays, effort, recent,
 // badges and prices remain in the preset files — the hub action "Edit fusion presets…" owns
@@ -213,8 +256,19 @@ export interface LoadedPreset {
 registerSettings({
   namespace: "fusion",
   label: "Fusion",
-  defaults: { default: { lead: "", sidekick: "" } },
+  defaults: { default: { lead: "", sidekick: "" }, startup: { model: "" } },
+  onSet: (layer, scope) => {
+    if (scope === "global") applyStartupSettings(layer);
+  },
   schema: [
+    {
+      title: "Startup",
+      description: "The model pi opens with. /unipi:model → alt+enter sets the same thing (on the Fusion row it starts in Fusion).",
+      fields: [
+        { key: "startup.model", type: "model", label: "Startup model", capability: "text", emptyLabel: "pi default", scopes: ["global"] },
+        { key: "startup.thinking", type: "enum", label: "Startup thinking level", options: [...STARTUP_THINKING], scopes: ["global"] },
+      ],
+    },
     {
       title: "Default pair",
       description: "Used when the Fusion row is confirmed without editing",

package/packages/fusion/src/prompts.ts

@@ -52,7 +52,7 @@ You have a \`sidekick\` tool: a persistent subagent that works alongside you on
 - The sidekick remembers everything from previous handoffs (code it wrote, files it explored, your earlier instructions), so don't re-explain context it already has. Its runtime state also persists: background shells and processes it started (dev servers, DB connections, long-running commands) usually survive between handoffs. Every brief that involves servers or long-running processes must say what to do with them — e.g. "the server from the previous handoff may still be running; check and reuse it, restart only if it's gone or the code changed" — and, when a later handoff may need them, tell it to leave them running.
 - On each handoff give it: the goal, your plan, the constraints, the relevant files, and how to verify. Settle the consequential choices before handing off: the exact interface (signature, types, data shape, which existing helper to use) and the exact tests (cases, assertions, where to stub). Don't leave alternatives for it to pick; it will guess, and a wrong guess costs a whole extra round. A code snippet is fine when it is the clearest way to say it.
 - **Never make the sidekick redo work you already did.** Results you already derived go into the brief as settled inputs (the values, or the path to the file holding them), not as an invitation to recompute. Ask for re-derivation only when you have reason to doubt them.
-- Blocking dispatch is the default: a \`sidekick\` call waits and returns the report. Pass \`block: false\` only when you genuinely have parallel lead work to do meanwhile; don't start work redundant with what the sidekick is doing, and never poll \`read_subagent\` in a loop. When you have run out of parallel work and still need the report, wait with \`read_subagent\` (\`block: true\`) rather than ending your turn or guessing.
+- Blocking dispatch is the default: a \`sidekick\` call waits and returns the report. Pass \`block: false\` only when you genuinely have parallel lead work to do meanwhile; don't start work redundant with what the sidekick is doing, and never poll \`read_subagent\` in a loop. When you have run out of parallel work and still need the report, wait with \`read_subagent\` (\`block: true\`) rather than ending your turn or guessing. A background handoff cannot ask the user for approval: any tool call that would need approval is automatically denied, so run approval-needing work with a blocking handoff.
 - Calling \`sidekick\` again while a handoff is running injects the new message into that handoff as an interrupt — it never starts a second sidekick. Use it to redirect with a corrected brief, tell it to wrap up and report what it has, or send a purely informational update.
 - If the user sends a message while a handoff is in flight, act on it before going back to waiting: handle lead-only work yourself, and for anything that concerns the running handoff, send an interrupt. Resume waiting only once you have deliberately decided the message changes nothing for the sidekick.
 - Track the lead-only actions you have promised the user (messages, review replies, commit/PR updates) — the sidekick cannot do these, so a brief that includes one silently drops it. Do each one the moment the handoff returns, before dispatching a follow-up.