@yagni-app/code-staging 1.1.4-staging.1424.1 → 1.1.4-staging.1426.1

package/dist/extension/bgJobsPanel.js

@@ -16,6 +16,7 @@
 import { Box, Container, Key, Text, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { logEvent } from "./errorSink.js";
 import { listBgJobs } from "./bgJobs.js";
+import { PanelBorder } from "./panelBorder.js";
 /** The content frame's horizontal padding (SandboxPanel's CONTENT_PADDING_X). */
 export const CONTENT_PADDING_X = 2;
 /** Max rendered output lines in the detail view. */
@@ -100,17 +101,6 @@ export function formatPanelSubtitle(jobs) {
 }
 // ---------------------------------------------------------------------------
 // The panel: SandboxPanel's structure (Container + Border + Box + Border).
-/** Full-width border line (the house pattern, color fn passed explicitly). */
-class Border {
-    color;
-    constructor(color) {
-        this.color = color;
-    }
-    render(width) {
-        return [this.color("─".repeat(Math.max(1, width)))];
-    }
-    invalidate() { }
-}
 export class BgJobsPanel extends Container {
     deps;
     theme;
@@ -138,9 +128,9 @@ export class BgJobsPanel extends Container {
         this.content.addChild(new Text("", 0, 0));
         this.content.addChild(new Text("", 0, 0));
         this.content.addChild(new Text("", 0, 0));
-        this.addChild(new Border((s) => theme.fg("borderMuted", s)));
+        this.addChild(new PanelBorder((s) => theme.fg("borderMuted", s)));
         this.addChild(this.content);
-        this.addChild(new Border((s) => theme.fg("borderMuted", s)));
+        this.addChild(new PanelBorder((s) => theme.fg("borderMuted", s)));
         this.rebuild();
     }
     dispose() {

package/dist/extension/decisionRubric.d.ts

@@ -19,7 +19,12 @@ export declare const RECORD_NEVER: string;
  * How the decision text itself must read. The ledger shows the decision as
  * the headline and the question beneath it, so an answer-shaped decision
  * ("No. Surface the decline.") reads as a fragment on every surface that
- * renders it.
+ * renders it, and a decision that carries its own reasoning reads as a
+ * paragraph in headline type. The ruling is the decision; the constraints,
+ * specifics, and reasoning belong in the rationale, where retrieval indexes
+ * them just the same (the embedding document is question + decision +
+ * rationale) and contested detection, which compares decision against
+ * decision, is not muddied by shared context words.
  */
 export declare const DECISION_STATEMENT: string;
 /**
@@ -27,5 +32,5 @@ export declare const DECISION_STATEMENT: string;
  * never, and how the decision text must read, so every surface that records
  * a decision produces one the headline-first ledger can render whole.
  */
-export declare const RECORD_DECISION_RUBRIC = "Record a decision only when it is consequential: a product-intent, architecture, or team-convention call that another engineer would need to know and that is not already written down, especially one a human just settled by answering a question or correcting you. Never record taste, styling, naming of a local variable, formatting, a workaround, a restatement of the code change, or anything the user is still experimenting with; when in doubt, do not record it. Write the decision as a standalone statement that reads without the question: name the subject and what was chosen (\"Checkout surfaces a declined card to the customer instead of retrying it\"), never a bare yes or no or an answer that only makes sense under the question.";
+export declare const RECORD_DECISION_RUBRIC = "Record a decision only when it is consequential: a product-intent, architecture, or team-convention call that another engineer would need to know and that is not already written down, especially one a human just settled by answering a question or correcting you. Never record taste, styling, naming of a local variable, formatting, a workaround, a restatement of the code change, or anything the user is still experimenting with; when in doubt, do not record it. Write the decision as a standalone statement that reads without the question: name the subject and what was chosen (\"Checkout surfaces a declined card to the customer instead of retrying it\"), never a bare yes or no or an answer that only makes sense under the question. Keep the decision to the ruling itself, one or two sentences; put the constraints, specifics, and reasoning behind it in the rationale, not the decision.";
 //# sourceMappingURL=decisionRubric.d.ts.map

package/dist/extension/decisionRubric.js

@@ -25,12 +25,18 @@ export const RECORD_NEVER = "Never record taste, styling, naming of a local vari
  * How the decision text itself must read. The ledger shows the decision as
  * the headline and the question beneath it, so an answer-shaped decision
  * ("No. Surface the decline.") reads as a fragment on every surface that
- * renders it.
+ * renders it, and a decision that carries its own reasoning reads as a
+ * paragraph in headline type. The ruling is the decision; the constraints,
+ * specifics, and reasoning belong in the rationale, where retrieval indexes
+ * them just the same (the embedding document is question + decision +
+ * rationale) and contested detection, which compares decision against
+ * decision, is not muddied by shared context words.
  */
 export const DECISION_STATEMENT = "Write the decision as a standalone statement that reads without the question: name " +
     "the subject and what was chosen (\"Checkout surfaces a declined card to the customer " +
     "instead of retrying it\"), never a bare yes or no or an answer that only makes sense " +
-    "under the question.";
+    "under the question. Keep the decision to the ruling itself, one or two sentences; put " +
+    "the constraints, specifics, and reasoning behind it in the rationale, not the decision.";
 /**
  * The rubric as one paragraph for persona bodies and task templates: when,
  * never, and how the decision text must read, so every surface that records

package/dist/extension/footer.d.ts

@@ -3,9 +3,14 @@
  *
  * Renders three lines:
  *   1. folder  ·  [worktree]  ·  branch        (git context; ~-path fallback off-repo)
- *   2. ↑in ↓out $cost  ·  ctx%                 (session stats; context % is an integer)
+ *   2. ◆ tier  ·  mode  ·  ↑in ↓out $cost  ·  ctx%   (the rung in play, permission mode,
+ *                                               session stats; context % is an integer)
  *   3. extension statuses                       (branding, todo counter, mode) joined by " · "
  *
+ * The tier segment is the footer's answer to "what am I driving on" now that
+ * the rung is a dial (/model, Ctrl+L, /tier): it reads `ctx.model` live on
+ * every render, so a switch shows the moment the footer repaints.
+ *
  * --- How to customize the status bar (for future tickets) ---
  *
  * LIFECYCLE: `ctx.ui.setFooter()` is NOT available at extension factory time.
@@ -42,6 +47,17 @@ import type { ExtensionContext, ReadonlyFooterDataProvider, Theme } from "@earen
 import type { ChildUsageHandle } from "./childUsage.js";
 import type { ModeHolder, PermissionMode } from "./permission/gate.js";
 export declare const BRANCH_MAX_WIDTH = 60;
+/** The glyph in front of the tier segment (the desktop start chips' rung mark). */
+export declare const TIER_GLYPH = "\u25C6";
+/**
+ * The footer's tier label for the model a session is on: the rate-card name
+ * for a selectable rung, the catalog name (or id) for anything else, null
+ * when there is no model yet. PURE.
+ */
+export declare function footerTierLabel(model: {
+    id: string;
+    name?: string;
+} | undefined): string | null;
 export declare function cyclePermissionMode(current: PermissionMode): PermissionMode;
 export declare function isShiftTab(data: string): boolean;
 export declare const GIT_MUTATING_PATTERN: RegExp;
@@ -94,7 +110,12 @@ export declare function detectGitInfo(cwd: string, home: string | undefined): Gi
 /** Pure line-builder, exported for tests. All data injected; colors via theme. */
 export declare function renderFooterLines(input: {
     git: GitInfo;
-    /** Current permission mode; shown on line 2 to the left of the stats as "<mode> mode". */
+    /**
+     * The rung in play, already resolved to its label ("Advanced"); leads
+     * line 2 as "◆ Advanced". Null hides the segment (no model yet).
+     */
+    tier?: string | null;
+    /** Current permission mode; shown on line 2 after the tier as "<mode> mode". */
     mode?: PermissionMode | null;
     /** Formatted `+N -M` / `±`, or null when clean — appended to the branch as `[ … ]`. */
     diff?: string | null;

package/dist/extension/footer.js

@@ -3,9 +3,14 @@
  *
  * Renders three lines:
  *   1. folder  ·  [worktree]  ·  branch        (git context; ~-path fallback off-repo)
- *   2. ↑in ↓out $cost  ·  ctx%                 (session stats; context % is an integer)
+ *   2. ◆ tier  ·  mode  ·  ↑in ↓out $cost  ·  ctx%   (the rung in play, permission mode,
+ *                                               session stats; context % is an integer)
  *   3. extension statuses                       (branding, todo counter, mode) joined by " · "
  *
+ * The tier segment is the footer's answer to "what am I driving on" now that
+ * the rung is a dial (/model, Ctrl+L, /tier): it reads `ctx.model` live on
+ * every render, so a switch shows the moment the footer repaints.
+ *
  * --- How to customize the status bar (for future tickets) ---
  *
  * LIFECYCLE: `ctx.ui.setFooter()` is NOT available at extension factory time.
@@ -43,10 +48,23 @@ import { statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { createDiffStatCache, formatDiffStat } from "./diffStat.js";
+import { isSelectableTier, tierLabel } from "./tierCommand.js";
 export const BRANCH_MAX_WIDTH = 60;
 const WORKTREE_MAX_WIDTH = 30;
 /** Section separator: single space + middle dot + single space. */
 const SEP = " · ";
+/** The glyph in front of the tier segment (the desktop start chips' rung mark). */
+export const TIER_GLYPH = "◆";
+/**
+ * The footer's tier label for the model a session is on: the rate-card name
+ * for a selectable rung, the catalog name (or id) for anything else, null
+ * when there is no model yet. PURE.
+ */
+export function footerTierLabel(model) {
+    if (!model)
+        return null;
+    return isSelectableTier(model.id) ? tierLabel(model.id) : model.name || model.id;
+}
 const MODE_CYCLE = ["auto", "review", "plan"];
 export function cyclePermissionMode(current) {
     const idx = MODE_CYCLE.indexOf(current);
@@ -244,7 +262,7 @@ export function renderFooterLines(input, theme, width, padX = 0) {
         }
     }
     const line1 = pad + truncateToWidth(line1Parts.join(sep), contentWidth, dim("…"));
-    // Line 2: [mode ·] ↑in ↓out $cost · ctx%
+    // Line 2: [◆ tier ·] [mode ·] ↑in ↓out $cost · ctx%
     // Child-process spend (subagents, advisor, /go) joins the driver totals so
     // the footer matches the per-child receipts and /cost's session scope.
     const child = input.childUsage;
@@ -261,6 +279,8 @@ export function renderFooterLines(input, theme, width, padX = 0) {
     const stats = statParts.join(" ");
     const percentText = input.contextPercent === null ? "?" : `${Math.round(input.contextPercent)}%`;
     const line2Parts = [];
+    if (input.tier)
+        line2Parts.push(theme.fg("accent", `${TIER_GLYPH} ${input.tier}`));
     if (input.mode) {
         const modeLabel = modeDisplay(input.mode);
         line2Parts.push(theme.fg(modeLabel.color, modeLabel.text) + dim(" (shift+tab to change)"));
@@ -306,6 +326,7 @@ export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle, chil
                     .map(([, text]) => text);
                 return renderFooterLines({
                     git: gitInfo(),
+                    tier: footerTierLabel(ctx.model),
                     mode: modeHolder?.get() ?? null,
                     diff: formatDiffStat(diffStatCache?.get() ?? null),
                     usage: collectUsage(ctx.sessionManager),

package/dist/extension/index.js

@@ -61,7 +61,8 @@ import { flushSpool as defaultFlushSpool } from "./spool.js";
 import { makeAuthedFetch, makeTokenProvider } from "./tokenProvider.js";
 import { attributionHeaders, fetchCatalog as defaultFetchCatalog, fetchContextBrief as defaultFetchContextBrief, getToken, getTokenExpiresAt as defaultGetTokenExpiresAt, getWorkspaceId as defaultGetWorkspaceId, isDriverCaller, resolveBaseUrl, tokenExpiryNotice, } from "./config.js";
 import { buildYagniProvider } from "./provider.js";
-import { orderDriverCatalog, registerStartTierGuard, registerTierCommand } from "./tierCommand.js";
+import { orderDriverCatalog, registerStartTierGuard, registerTierCommand, trailReason } from "./tierCommand.js";
+import { makeModelPickerListener } from "./modelPicker.js";
 import { registerChipEditor } from "./chipEditor.js";
 import { registerSlashCommandFilter } from "./slashCommandFilter.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
@@ -1186,11 +1187,12 @@ export async function registerYagni(pi, deps = {}) {
         // count as costHud's "Excludes N earlier /go runs." note.
         droppedSessionRuns,
     });
-    // The manual tier dial. `/model` (pi's own picker) now lists the four rungs
-    // because the driver catalog carries them; `/tier` is the tier-language
-    // sibling that reports and switches inline. The start guard is what keeps
-    // "movable" from becoming "parked on peak" — driver sessions only, since a
-    // child or eval lane names its tier on the command line.
+    // The manual tier dial. `/model` and Ctrl+L open YAGNI's own picker (the
+    // terminal-input listener wired on session_start below, modelPicker.ts);
+    // `/tier` is the tier-language sibling that reports and switches inline.
+    // The start guard is what keeps "movable" from becoming "parked on peak" —
+    // driver sessions only, since a child or eval lane names its tier on the
+    // command line.
     if (!evalMode && driver) {
         registerTierCommand(pi);
         registerStartTierGuard(pi);
@@ -1677,10 +1679,11 @@ export async function registerYagni(pi, deps = {}) {
             const mastheadCwd = formatCwd(process.cwd(), process.env.HOME);
             ctx.ui?.setHeader?.((_tui, theme) => new Text(buildMastheadString(theme, { version: mastheadVersion, cwd: mastheadCwd })));
             // Replace the built-in footer with the YAGNI status bar: folder +
-            // [worktree] + branch on line 1, model + token/cost stats + integer
-            // context % on line 2, and extension statuses (brand, todos, mode) on
-            // line 3. The factory captures ctx so the footer can read session data
-            // (token stats, context usage) that isn't on the footerData provider.
+            // [worktree] + branch on line 1; the tier in play, the permission mode,
+            // token/cost stats and integer context % on line 2; and extension
+            // statuses (brand, todos, mode) on line 3. The factory captures ctx so
+            // the footer can read session data (the model, token stats, context
+            // usage) that isn't on the footerData provider.
             ctx.ui?.setFooter?.((tui, theme, footerData) => createYagniFooterFactory(ctx, modeHolder, footerInvalidateHandle, childUsage)(tui, theme, footerData));
             ctx.ui?.onTerminalInput?.((data) => {
                 if (isShiftTab(data)) {
@@ -1690,6 +1693,24 @@ export async function registerYagni(pi, deps = {}) {
                 }
                 return undefined;
             });
+            // YAGNI's own model picker in place of pi's: Ctrl+L and Enter on a
+            // `/model` line are consumed here, before the editor sees them, and
+            // mount modelPicker.ts's panel. Driver sessions only, like /tier.
+            if (!evalMode && driver && ctx.hasUI) {
+                try {
+                    ctx.ui?.onTerminalInput?.(makeModelPickerListener(pi, ctx, { footer: footerInvalidateHandle }));
+                }
+                catch (err) {
+                    // The picker is a convenience over /tier; it must never break
+                    // session start. But a "Ctrl+L does nothing" report needs a trail.
+                    logEvent({
+                        source: "tier",
+                        level: "warn",
+                        event: "model_picker_register_failed",
+                        fields: { reason: trailReason(err) },
+                    });
+                }
+            }
             // Label the collapsed chain-of-thought line so users know it is reasoning
             // and how to reveal the full trace. Harmless when reasoning is expanded
             // (the label only shows on hidden thinking blocks). Fails closed to pi's

package/dist/extension/modelPicker.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The model picker: YAGNI's own `/model` and Ctrl+L.
+ *
+ * pi ships a model selector for `/model` and Ctrl+L, and with the four rungs
+ * registered it did list them. It also rendered them the way pi renders any
+ * provider's catalog: raw ids (`advanced`) under a lowercase provider badge
+ * (`[yagni]`), the rung in play hoisted to the top so the order changed with
+ * every switch, and a "Use /login to add providers" hint that is pi's
+ * multi-provider story, not this product's (YAGNI maintains the models a
+ * workspace can drive on; there is nothing to log in to). None of that is
+ * adjustable in place: the strings and the sort live inside pi's compiled
+ * component, `/model` is dispatched from pi's built-in command ladder before
+ * any extension command is consulted, and `app.model.select` is a reserved
+ * keybinding `registerShortcut` cannot take.
+ *
+ * What CAN be owned is the keystroke. Extension `onTerminalInput` listeners
+ * run before the focused editor sees anything (the same mechanism index.ts
+ * uses for shift+tab), so this module consumes Ctrl+L and an Enter on a
+ * `/model` line, and mounts its own panel through `ctx.ui.custom` in their
+ * place. The panel is built on the sandbox panel reference
+ * (`sandbox/panel.ts`): Border · padded Box · Border, a SelectList, pi-tui's
+ * `matchesKey` for every key. It lists the rate card's ladder in ladder order
+ * with the capitalized lane names, marks the rung in play and preselects it,
+ * and says "YAGNI" the way the product does.
+ *
+ * Switching goes through `switchTier`, the same path as `/tier`, so the
+ * trail entries and notices are one set. Headless (`--mode rpc`, print) is
+ * untouched: the desktop composer has its own pill, and there is no terminal
+ * input to listen to.
+ */
+import type { ExtensionAPI, ExtensionContext, TerminalInputHandler } from "@earendil-works/pi-coding-agent";
+import { Container } from "@earendil-works/pi-tui";
+import type { FooterInvalidateHandle } from "./footer.js";
+import type { RenderTheme } from "./subagentRender.js";
+import { type SelectableTier } from "./tierCommand.js";
+/** The panel's title line. The provider word is the product's, capitalized. */
+export declare const MODEL_PICKER_TITLE = "YAGNI model tier";
+/** The panel's footer line: the keys that work, nothing about providers. */
+export declare const MODEL_PICKER_FOOTER = "up/down to navigate \u00B7 Enter to select \u00B7 Esc to close";
+/** One row of the picker. PURE data; the panel renders it. */
+export interface PickerRow {
+    tier: SelectableTier;
+    /** The capitalized lane name, with {@link CURRENT_MARK} when in play. */
+    label: string;
+    description: string;
+    current: boolean;
+}
+/**
+ * The rows to offer: the ladder in {@link SELECTABLE_TIERS} order, filtered
+ * to the rungs the registry actually holds (a workspace whose catalog omits
+ * one must not get a row that fails on select), with the rung in play
+ * marked. PURE.
+ */
+export declare function pickerRows(available: readonly string[], currentId: string | undefined): PickerRow[];
+/** What an Enter on the editor's current text is asking for. */
+export type ModelCommand = {
+    kind: "open";
+} | {
+    kind: "set";
+    tier: SelectableTier;
+};
+/**
+ * Read a `/model` line the way pi's own ladder would have: a bare `/model`
+ * opens the picker; `/model <rung>` switches directly when the argument
+ * names a rung; any other argument opens the picker (pi would have opened
+ * its selector pre-filtered; there are four rows here, so a filter buys
+ * nothing). Anything that is not a `/model` line is `null` and passes
+ * through to the editor untouched. PURE.
+ */
+export declare function parseModelCommand(editorText: string): ModelCommand | null;
+/** True for the keystroke pi binds to its own selector (`app.model.select`). */
+export declare function isModelPickerKey(data: string): boolean;
+/**
+ * The picker panel. Structure: top border · title · blank · rows · blank ·
+ * footer · bottom border. pi focuses this root and calls its handleInput;
+ * Esc closes with no choice, everything else goes to the SelectList, whose
+ * Enter resolves with the chosen rung.
+ */
+export declare class ModelPickerPanel extends Container {
+    private readonly list;
+    private readonly done;
+    constructor(rows: readonly PickerRow[], theme: RenderTheme, done: (tier?: SelectableTier) => void);
+    handleInput(data: string): void;
+}
+/** What the picker needs from the session beyond the pi API. */
+export interface ModelPickerDeps {
+    /** Repaints the footer after a switch so its tier segment follows. */
+    footer?: Pick<FooterInvalidateHandle, "requestRender">;
+}
+/** The slice of the session context the picker reads. */
+type PickerContext = Pick<ExtensionContext, "model" | "modelRegistry" | "hasUI" | "ui">;
+/**
+ * Mount the panel in the editor slot and apply the choice. Resolves when the
+ * panel has closed and any switch has settled.
+ */
+export declare function openModelPicker(pi: ExtensionAPI, ctx: PickerContext, deps?: ModelPickerDeps): Promise<void>;
+/** Mount the panel and resolve with the chosen rung, or undefined on Esc. */
+export declare function pickTier(ctx: PickerContext): Promise<SelectableTier | undefined>;
+/**
+ * The notice when either path the listener runs (opening the picker, or the
+ * direct switch behind `/model <rung>`) throws. Worded for both: what failed
+ * is the change of tier, whichever way it was asked for. The trail entry
+ * carries the reason.
+ */
+export declare const MODEL_PICKER_FAILED_NOTICE = "Could not change the model tier. Use /tier <rung> instead.";
+/**
+ * The terminal-input listener, installed by index.ts on `session_start` (TUI
+ * driver sessions only, right after the shift+tab listener): Ctrl+L opens
+ * the picker; Enter on a `/model` line clears the editor and either switches
+ * or opens; everything else passes through.
+ *
+ * The listener tracks which of two things is in flight, because they want
+ * opposite treatment of Enter:
+ *
+ *   - **A panel is up.** A further Ctrl+L is swallowed (pi's selector must
+ *     not open on top, and the panel has no use for it), but Enter passes
+ *     through UNTOUCHED. The panel is the focused component then, and it
+ *     needs that Enter to select; the editor may still hold the `/model`
+ *     line that opened it, and reading it here would eat the keystroke the
+ *     panel is waiting for.
+ *   - **A switch is in flight, no panel.** The editor is focused, so an
+ *     Enter on a `/model` line that passed through would reach pi's own
+ *     command ladder and open pi's selector, the very thing this module
+ *     exists to prevent. That Enter is consumed but the line is NOT cleared:
+ *     the text survives, and Enter acts on it once the switch has settled.
+ *     Enter on any other text passes through as always.
+ *
+ * Nothing is cleared unless the listener actually acts on it.
+ */
+export declare function makeModelPickerListener(pi: ExtensionAPI, ctx: PickerContext, deps?: ModelPickerDeps): TerminalInputHandler;
+export {};
+//# sourceMappingURL=modelPicker.d.ts.map

package/dist/extension/modelPicker.js

@@ -0,0 +1,244 @@
+/**
+ * The model picker: YAGNI's own `/model` and Ctrl+L.
+ *
+ * pi ships a model selector for `/model` and Ctrl+L, and with the four rungs
+ * registered it did list them. It also rendered them the way pi renders any
+ * provider's catalog: raw ids (`advanced`) under a lowercase provider badge
+ * (`[yagni]`), the rung in play hoisted to the top so the order changed with
+ * every switch, and a "Use /login to add providers" hint that is pi's
+ * multi-provider story, not this product's (YAGNI maintains the models a
+ * workspace can drive on; there is nothing to log in to). None of that is
+ * adjustable in place: the strings and the sort live inside pi's compiled
+ * component, `/model` is dispatched from pi's built-in command ladder before
+ * any extension command is consulted, and `app.model.select` is a reserved
+ * keybinding `registerShortcut` cannot take.
+ *
+ * What CAN be owned is the keystroke. Extension `onTerminalInput` listeners
+ * run before the focused editor sees anything (the same mechanism index.ts
+ * uses for shift+tab), so this module consumes Ctrl+L and an Enter on a
+ * `/model` line, and mounts its own panel through `ctx.ui.custom` in their
+ * place. The panel is built on the sandbox panel reference
+ * (`sandbox/panel.ts`): Border · padded Box · Border, a SelectList, pi-tui's
+ * `matchesKey` for every key. It lists the rate card's ladder in ladder order
+ * with the capitalized lane names, marks the rung in play and preselects it,
+ * and says "YAGNI" the way the product does.
+ *
+ * Switching goes through `switchTier`, the same path as `/tier`, so the
+ * trail entries and notices are one set. Headless (`--mode rpc`, print) is
+ * untouched: the desktop composer has its own pill, and there is no terminal
+ * input to listen to.
+ */
+import { Box, Container, Key, SelectList, Text, matchesKey, } from "@earendil-works/pi-tui";
+import { logEvent } from "./errorSink.js";
+import { PanelBorder } from "./panelBorder.js";
+import { SELECTABLE_TIERS, TIER_BLURB, TIER_LABEL, YAGNI_PROVIDER, isSelectableTier, switchTier, trailReason, } from "./tierCommand.js";
+/** The panel's title line. The provider word is the product's, capitalized. */
+export const MODEL_PICKER_TITLE = "YAGNI model tier";
+/** The panel's footer line: the keys that work, nothing about providers. */
+export const MODEL_PICKER_FOOTER = "up/down to navigate · Enter to select · Esc to close";
+/** The mark on the rung in play. */
+const CURRENT_MARK = " ✓";
+/**
+ * The rows to offer: the ladder in {@link SELECTABLE_TIERS} order, filtered
+ * to the rungs the registry actually holds (a workspace whose catalog omits
+ * one must not get a row that fails on select), with the rung in play
+ * marked. PURE.
+ */
+export function pickerRows(available, currentId) {
+    const have = new Set(available);
+    return SELECTABLE_TIERS.filter((tier) => have.has(tier)).map((tier) => {
+        const current = tier === currentId;
+        return {
+            tier,
+            label: current ? `${TIER_LABEL[tier]}${CURRENT_MARK}` : TIER_LABEL[tier],
+            description: TIER_BLURB[tier],
+            current,
+        };
+    });
+}
+/**
+ * Read a `/model` line the way pi's own ladder would have: a bare `/model`
+ * opens the picker; `/model <rung>` switches directly when the argument
+ * names a rung; any other argument opens the picker (pi would have opened
+ * its selector pre-filtered; there are four rows here, so a filter buys
+ * nothing). Anything that is not a `/model` line is `null` and passes
+ * through to the editor untouched. PURE.
+ */
+export function parseModelCommand(editorText) {
+    const text = editorText.trim();
+    if (text === "/model")
+        return { kind: "open" };
+    if (!text.startsWith("/model "))
+        return null;
+    const arg = text.slice("/model ".length).trim().toLowerCase();
+    return isSelectableTier(arg) ? { kind: "set", tier: arg } : { kind: "open" };
+}
+/** True for the keystroke pi binds to its own selector (`app.model.select`). */
+export function isModelPickerKey(data) {
+    return matchesKey(data, Key.ctrl("l"));
+}
+/** Horizontal breathing room for panel content (the sandbox panel's). */
+const CONTENT_PADDING_X = 2;
+function selectListTheme(theme) {
+    return {
+        selectedPrefix: (t) => theme.fg("accent", t),
+        selectedText: (t) => theme.fg("accent", t),
+        description: (t) => theme.fg("muted", t),
+        scrollInfo: (t) => theme.fg("muted", t),
+        noMatch: (t) => theme.fg("muted", t),
+    };
+}
+/**
+ * The picker panel. Structure: top border · title · blank · rows · blank ·
+ * footer · bottom border. pi focuses this root and calls its handleInput;
+ * Esc closes with no choice, everything else goes to the SelectList, whose
+ * Enter resolves with the chosen rung.
+ */
+export class ModelPickerPanel extends Container {
+    list;
+    done;
+    constructor(rows, theme, done) {
+        super();
+        this.done = done;
+        const items = rows.map((row) => ({
+            value: row.tier,
+            label: row.label,
+            description: row.description,
+        }));
+        this.list = new SelectList(items, SELECTABLE_TIERS.length, selectListTheme(theme));
+        // The rung in play is where the cursor starts, never the first row: a
+        // stray Enter re-selects what the session already drives on.
+        const currentIndex = rows.findIndex((row) => row.current);
+        if (currentIndex >= 0)
+            this.list.setSelectedIndex(currentIndex);
+        this.list.onSelect = (item) => {
+            this.done(isSelectableTier(item.value) ? item.value : undefined);
+        };
+        this.list.onCancel = () => this.done();
+        const content = new Box(CONTENT_PADDING_X, 0);
+        content.addChild(new Text(theme.bold(MODEL_PICKER_TITLE), 0, 0));
+        content.addChild(new Text("", 0, 0));
+        content.addChild(this.list);
+        content.addChild(new Text(theme.fg("muted", MODEL_PICKER_FOOTER), 0, 1));
+        this.addChild(new PanelBorder((s) => theme.fg("borderMuted", s)));
+        this.addChild(content);
+        this.addChild(new PanelBorder((s) => theme.fg("borderMuted", s)));
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape)) {
+            this.done();
+            return;
+        }
+        this.list.handleInput(data);
+        this.invalidate();
+    }
+}
+/**
+ * Mount the panel in the editor slot and apply the choice. Resolves when the
+ * panel has closed and any switch has settled.
+ */
+export async function openModelPicker(pi, ctx, deps = {}) {
+    const tier = await pickTier(ctx);
+    if (!tier)
+        return;
+    await applyTier(pi, ctx, tier, deps);
+}
+/** Mount the panel and resolve with the chosen rung, or undefined on Esc. */
+export async function pickTier(ctx) {
+    const available = SELECTABLE_TIERS.filter((tier) => ctx.modelRegistry.find(YAGNI_PROVIDER, tier) !== undefined);
+    const rows = pickerRows(available, ctx.model?.id);
+    if (rows.length === 0) {
+        if (ctx.hasUI)
+            ctx.ui.notify("No YAGNI model tiers are available on this workspace.", "error");
+        return undefined;
+    }
+    return ctx.ui.custom((_tui, theme, _keybindings, done) => new ModelPickerPanel(rows, theme, done));
+}
+/** Switch through the shared path and repaint the footer's tier segment. */
+async function applyTier(pi, ctx, tier, deps) {
+    await switchTier(pi, ctx, tier);
+    deps.footer?.requestRender();
+}
+/**
+ * The notice when either path the listener runs (opening the picker, or the
+ * direct switch behind `/model <rung>`) throws. Worded for both: what failed
+ * is the change of tier, whichever way it was asked for. The trail entry
+ * carries the reason.
+ */
+export const MODEL_PICKER_FAILED_NOTICE = "Could not change the model tier. Use /tier <rung> instead.";
+/**
+ * The terminal-input listener, installed by index.ts on `session_start` (TUI
+ * driver sessions only, right after the shift+tab listener): Ctrl+L opens
+ * the picker; Enter on a `/model` line clears the editor and either switches
+ * or opens; everything else passes through.
+ *
+ * The listener tracks which of two things is in flight, because they want
+ * opposite treatment of Enter:
+ *
+ *   - **A panel is up.** A further Ctrl+L is swallowed (pi's selector must
+ *     not open on top, and the panel has no use for it), but Enter passes
+ *     through UNTOUCHED. The panel is the focused component then, and it
+ *     needs that Enter to select; the editor may still hold the `/model`
+ *     line that opened it, and reading it here would eat the keystroke the
+ *     panel is waiting for.
+ *   - **A switch is in flight, no panel.** The editor is focused, so an
+ *     Enter on a `/model` line that passed through would reach pi's own
+ *     command ladder and open pi's selector, the very thing this module
+ *     exists to prevent. That Enter is consumed but the line is NOT cleared:
+ *     the text survives, and Enter acts on it once the switch has settled.
+ *     Enter on any other text passes through as always.
+ *
+ * Nothing is cleared unless the listener actually acts on it.
+ */
+export function makeModelPickerListener(pi, ctx, deps = {}) {
+    let busy = null;
+    const run = (phase, work) => {
+        busy = phase;
+        void work()
+            .catch((err) => {
+            logEvent({ source: "tier", level: "warn", event: "model_picker_failed", fields: { reason: trailReason(err) } });
+            try {
+                if (ctx.hasUI)
+                    ctx.ui.notify(MODEL_PICKER_FAILED_NOTICE, "error");
+            }
+            catch {
+                /* the trail entry is the durable half; a dead UI cannot undo it */
+            }
+        })
+            .finally(() => {
+            busy = null;
+        });
+    };
+    // The panel phase ends when the panel closes; the switch that follows a
+    // choice runs with the editor focused again, so it is its own phase.
+    const openThenSwitch = () => run("panel", async () => {
+        const tier = await pickTier(ctx);
+        if (!tier)
+            return;
+        busy = "switch";
+        await applyTier(pi, ctx, tier, deps);
+    });
+    return (data) => {
+        if (isModelPickerKey(data)) {
+            if (!busy)
+                openThenSwitch();
+            return { consume: true };
+        }
+        if (busy === "panel" || !matchesKey(data, Key.enter))
+            return undefined;
+        const command = parseModelCommand(ctx.ui.getEditorText());
+        if (!command)
+            return undefined;
+        if (busy === "switch")
+            return { consume: true };
+        ctx.ui.setEditorText("");
+        if (command.kind === "set") {
+            run("switch", () => applyTier(pi, ctx, command.tier, deps));
+        }
+        else {
+            openThenSwitch();
+        }
+        return { consume: true };
+    };
+}
+//# sourceMappingURL=modelPicker.js.map

package/dist/extension/panelBorder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The full-width border line every YAGNI panel frames itself with (the house
+ * DynamicBorder pattern: Border · padded Box · Border). The color function
+ * is passed in explicitly because extensions never read pi's global theme.
+ * One copy, shared by the sandbox, background-jobs, and model picker panels.
+ */
+export declare class PanelBorder {
+    private readonly color;
+    constructor(color: (s: string) => string);
+    render(width: number): string[];
+    invalidate(): void;
+}
+//# sourceMappingURL=panelBorder.d.ts.map

package/dist/extension/panelBorder.js

@@ -0,0 +1,17 @@
+/**
+ * The full-width border line every YAGNI panel frames itself with (the house
+ * DynamicBorder pattern: Border · padded Box · Border). The color function
+ * is passed in explicitly because extensions never read pi's global theme.
+ * One copy, shared by the sandbox, background-jobs, and model picker panels.
+ */
+export class PanelBorder {
+    color;
+    constructor(color) {
+        this.color = color;
+    }
+    render(width) {
+        return [this.color("─".repeat(Math.max(1, width)))];
+    }
+    invalidate() { }
+}
+//# sourceMappingURL=panelBorder.js.map

package/dist/extension/recordDecisionTool.js

@@ -33,7 +33,11 @@ const parameters = Type.Object({
     question: Type.String({ description: "The question that was decided, as another engineer would ask it." }),
     decision: Type.String({ description: `The direction taken. ${DECISION_STATEMENT}` }),
     kind: Type.Union([Type.Literal("product"), Type.Literal("architecture"), Type.Literal("convention")], { description: `What sort of call this is: ${DECISION_KIND_DESCRIPTION}.` }),
-    rationale: Type.String({ description: "Why: the durable reasoning a teammate would want six months later." }),
+    rationale: Type.String({
+        description: "Why: the durable reasoning a teammate would want six months later, plus the constraints and " +
+            "specifics that do not fit the one- or two-sentence decision. This is indexed for retrieval " +
+            "alongside the decision, so nothing is lost by putting detail here.",
+    }),
     repo: Type.Optional(Type.String()),
     workItemId: Type.Optional(Type.String()),
 });

package/dist/extension/sandbox/panel.js

@@ -22,6 +22,7 @@ import { Box, Container, HStack, Key, SelectList, Text, matchesKey, } from "@ear
 import { mergeRulesIntoSandbox } from "./config.js";
 import { resolveWorktreeGitAccess } from "./worktreeGit.js";
 import { logEvent } from "../errorSink.js";
+import { PanelBorder } from "../panelBorder.js";
 // ---------------------------------------------------------------------------
 // Pure derivation helpers (unit-tested; no TUI dependency)
 // ---------------------------------------------------------------------------
@@ -247,18 +248,6 @@ function selectListTheme(theme) {
         noMatch: (t) => theme.fg("muted", t),
     };
 }
-/** Full-width border line (the house DynamicBorder pattern, color fn passed
- * explicitly — extensions never read pi's global theme). */
-class Border {
-    color;
-    constructor(color) {
-        this.color = color;
-    }
-    render(width) {
-        return [this.color("─".repeat(Math.max(1, width)))];
-    }
-    invalidate() { }
-}
 /**
  * The /sandbox panel. Structure: top border · tab strip · blank · tab
  * content · blank · footer · bottom border. pi focuses this root and calls
@@ -288,9 +277,9 @@ export class SandboxPanel extends Container {
         this.content = new Box(CONTENT_PADDING_X, 0);
         this.content.addChild(new Text("", 0, 0)); // tab strip placeholder
         this.content.addChild(new Text("", 0, 0)); // body placeholder
-        this.addChild(new Border((s) => theme.fg("borderMuted", s)));
+        this.addChild(new PanelBorder((s) => theme.fg("borderMuted", s)));
         this.addChild(this.content);
-        this.addChild(new Border((s) => theme.fg("borderMuted", s)));
+        this.addChild(new PanelBorder((s) => theme.fg("borderMuted", s)));
         this.setTab(this.activeTab);
     }
     setTab(tab) {

package/dist/extension/tierCommand.d.ts

@@ -45,23 +45,40 @@
  * session on peak" after the fact. A rung that failed to move is invisible in
  * every other record, which is why the failures log at all.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 /** The provider the tier models are registered under (see provider.ts). */
 export declare const YAGNI_PROVIDER = "yagni";
 /**
- * The rungs a driver session may sit on, in PICKER ORDER.
- *
- * Order is the product statement, not an accident: the default leads, the two
- * cheaper rungs follow, and `peak` sits last. The backend catalog's own order
- * is strongest-first (`balanced`, `peak`, `advanced`, ...), which would put
- * peak in the first, most-clickable position of a picker it should never be
- * the resting state of.
+ * The rungs a driver session may sit on, in PICKER ORDER: the rate card's
+ * ladder, strongest first (`peak`, `advanced`, `standard`, `efficient`).
+ *
+ * The list reads the same way everywhere the tiers are named (the pricing
+ * page, the desktop start screen, the catalog), so the picker does not invent
+ * a second ordering. Peak leading the list is safe because list position is
+ * not what keeps a session off it: {@link registerStartTierGuard} refuses to
+ * OPEN on peak, and the picker preselects the rung in play rather than the
+ * first row, so a stray Enter never lands on peak by accident.
  */
-export declare const SELECTABLE_TIERS: readonly ["advanced", "standard", "efficient", "peak"];
+export declare const SELECTABLE_TIERS: readonly ["peak", "advanced", "standard", "efficient"];
 export type SelectableTier = (typeof SELECTABLE_TIERS)[number];
 /** The rung every interactive driver session opens on. */
 export declare const SESSION_START_TIER: SelectableTier;
+/**
+ * The customer-facing name of each rung: the rate card's capitalized lane
+ * names, the same words the backend catalog serves as `name`. Ids stay
+ * lowercase on the wire and in `/tier <arg>`; only what a person reads
+ * changes.
+ */
+export declare const TIER_LABEL: Record<SelectableTier, string>;
+/** One-line description per rung, for `/tier` with no argument. */
+export declare const TIER_BLURB: Record<SelectableTier, string>;
 export declare function isSelectableTier(value: string | undefined): value is SelectableTier;
+/**
+ * The label a person reads for a model id: the rate-card name for a
+ * selectable rung, the id itself for anything else the session may be on
+ * (`balanced`, a child's exact model), and "unknown" when there is none.
+ */
+export declare function tierLabel(id: string | undefined): string;
 /**
  * The driver's picker catalog: the four rungs, in {@link SELECTABLE_TIERS}
  * order, filtered against what the backend actually served.
@@ -138,17 +155,35 @@ export declare function formatTierSwitchFailed(requested: SelectableTier, curren
 /** The notice shown when a session is corrected off a never-start rung. PURE. */
 export declare function formatStartCorrection(from: string, to: SelectableTier): string;
 /**
- * Register `/tier`.
- *
- * pi already ships `/model` (and Ctrl+P), which now lists the four rungs
- * because the driver catalog carries them — that surface is left entirely to
- * pi rather than shadowed with a same-named command. `/tier` is the
- * tier-language sibling: it reports the current rung inline without opening a
- * picker, and switches in one line when the rung is already known.
+ * The slice of a command or session context a switch needs: the rung in
+ * play, the registry to resolve the target in, and a way to tell the
+ * developer what happened. Both `ExtensionCommandContext` and the
+ * `session_start` `ExtensionContext` satisfy it, which is what lets `/tier`
+ * and the model picker share one switch path.
+ */
+export type TierSwitchContext = Pick<ExtensionCommandContext, "model" | "modelRegistry" | "hasUI" | "ui">;
+/**
+ * Move the session to `tier`, the one switch path behind `/tier <rung>` and
+ * the model picker. Returns true when the rung moved.
  *
  * `setModel` resolves through `ctx.modelRegistry.find`, so a rung the
  * workspace's catalog never registered fails with a real message instead of
- * silently selecting nothing.
+ * silently selecting nothing. Mirrors the start guard's posture: a switch
+ * that does not land is logged AND named. `setModel` reaches a provider, so
+ * it can reject or throw; an uncaught throw here would escape the caller, and
+ * a silent one would leave a developer believing they moved rungs when they
+ * did not. Both end on the same durable trail entry.
+ */
+export declare function switchTier(pi: ExtensionAPI, ctx: TierSwitchContext, tier: SelectableTier): Promise<boolean>;
+/**
+ * Register `/tier`.
+ *
+ * The picker itself (`/model`, Ctrl+L) is YAGNI's own since modelPicker.ts:
+ * pi's built-in selector renders raw ids under a lowercase provider badge and
+ * a "/login to add providers" hint that has no meaning here, and it cannot be
+ * adjusted in place. `/tier` is the tier-language sibling: it reports the
+ * current rung inline without opening a picker, and switches in one line when
+ * the rung is already known. Both go through {@link switchTier}.
  */
 export declare function registerTierCommand(pi: ExtensionAPI): void;
 /**

package/dist/extension/tierCommand.js

@@ -50,29 +50,53 @@ import { scrubSecrets } from "./pipeline/scrubSecrets.js";
 /** The provider the tier models are registered under (see provider.ts). */
 export const YAGNI_PROVIDER = "yagni";
 /**
- * The rungs a driver session may sit on, in PICKER ORDER.
+ * The rungs a driver session may sit on, in PICKER ORDER: the rate card's
+ * ladder, strongest first (`peak`, `advanced`, `standard`, `efficient`).
  *
- * Order is the product statement, not an accident: the default leads, the two
- * cheaper rungs follow, and `peak` sits last. The backend catalog's own order
- * is strongest-first (`balanced`, `peak`, `advanced`, ...), which would put
- * peak in the first, most-clickable position of a picker it should never be
- * the resting state of.
+ * The list reads the same way everywhere the tiers are named (the pricing
+ * page, the desktop start screen, the catalog), so the picker does not invent
+ * a second ordering. Peak leading the list is safe because list position is
+ * not what keeps a session off it: {@link registerStartTierGuard} refuses to
+ * OPEN on peak, and the picker preselects the rung in play rather than the
+ * first row, so a stray Enter never lands on peak by accident.
  */
-export const SELECTABLE_TIERS = ["advanced", "standard", "efficient", "peak"];
+export const SELECTABLE_TIERS = ["peak", "advanced", "standard", "efficient"];
 /** The rung every interactive driver session opens on. */
 export const SESSION_START_TIER = "advanced";
 /** Rungs a session must never be left parked on at start. Peak only, today. */
 const NEVER_START_TIERS = new Set(["peak"]);
+/**
+ * The customer-facing name of each rung: the rate card's capitalized lane
+ * names, the same words the backend catalog serves as `name`. Ids stay
+ * lowercase on the wire and in `/tier <arg>`; only what a person reads
+ * changes.
+ */
+export const TIER_LABEL = {
+    peak: "Peak",
+    advanced: "Advanced",
+    standard: "Standard",
+    efficient: "Efficient",
+};
 /** One-line description per rung, for `/tier` with no argument. */
-const TIER_BLURB = {
+export const TIER_BLURB = {
+    peak: "strongest judgment, several times the spend",
     advanced: "the default driver rung",
     standard: "cheaper, for mechanical work",
     efficient: "cheapest, for search and triage",
-    peak: "strongest judgment, several times the spend",
 };
 export function isSelectableTier(value) {
     return !!value && SELECTABLE_TIERS.includes(value);
 }
+/**
+ * The label a person reads for a model id: the rate-card name for a
+ * selectable rung, the id itself for anything else the session may be on
+ * (`balanced`, a child's exact model), and "unknown" when there is none.
+ */
+export function tierLabel(id) {
+    if (isSelectableTier(id))
+        return TIER_LABEL[id];
+    return id ?? "unknown";
+}
 /**
  * The driver's picker catalog: the four rungs, in {@link SELECTABLE_TIERS}
  * order, filtered against what the backend actually served.
@@ -121,17 +145,17 @@ export function parseTierArg(args) {
 export function formatTierStatus(currentId) {
     const current = isSelectableTier(currentId) ? currentId : undefined;
     const head = current
-        ? `This session is on ${current} (${TIER_BLURB[current]}).`
+        ? `This session is on ${TIER_LABEL[current]} (${TIER_BLURB[current]}).`
         : `This session is on "${currentId ?? "unknown"}", which is not one of the selectable rungs.`;
-    const options = SELECTABLE_TIERS.map((t) => `  /tier ${t} - ${TIER_BLURB[t]}`).join("\n");
-    return `${head}\nSwitch with /tier <rung>, or pick from /model:\n${options}\nEvery session starts on ${SESSION_START_TIER}.`;
+    const options = SELECTABLE_TIERS.map((t) => `  /tier ${t} - ${TIER_LABEL[t]}: ${TIER_BLURB[t]}`).join("\n");
+    return `${head}\nSwitch with /tier <rung>, or pick from /model (Ctrl+L):\n${options}\nEvery session starts on ${TIER_LABEL[SESSION_START_TIER]}.`;
 }
 /** The notice shown when a switch lands. PURE. */
 export function formatTierSwitched(tier) {
     const parked = tier === "peak"
-        ? " Peak is priced for judgment, not for driving: the next session starts back on advanced."
+        ? ` Peak is priced for judgment, not for driving: the next session starts back on ${TIER_LABEL[SESSION_START_TIER]}.`
         : "";
-    return `Session tier is now ${tier} (${TIER_BLURB[tier]}).${parked}`;
+    return `Session tier is now ${TIER_LABEL[tier]} (${TIER_BLURB[tier]}).${parked}`;
 }
 /** Upper bound on a trail `reason`, in characters. */
 export const TRAIL_REASON_MAX = 180;
@@ -207,29 +231,80 @@ export function trailReason(err) {
 }
 /** The notice shown when a requested switch did not land. PURE. */
 export function formatTierSwitchFailed(requested, currentId) {
-    const still = currentId ? ` Still on ${currentId}.` : "";
-    return `Could not switch to ${requested}.${still}`;
+    const still = currentId ? ` Still on ${tierLabel(currentId)}.` : "";
+    return `Could not switch to ${TIER_LABEL[requested]}.${still}`;
 }
 /** The notice shown when a session is corrected off a never-start rung. PURE. */
 export function formatStartCorrection(from, to) {
-    return `Opened on ${to} rather than ${from}: sessions always start on ${to}. Use /tier ${from} to go back.`;
+    return `Opened on ${TIER_LABEL[to]} rather than ${tierLabel(from)}: sessions always start on ${TIER_LABEL[to]}. Use /tier ${from} to go back.`;
 }
 /**
- * Register `/tier`.
- *
- * pi already ships `/model` (and Ctrl+P), which now lists the four rungs
- * because the driver catalog carries them — that surface is left entirely to
- * pi rather than shadowed with a same-named command. `/tier` is the
- * tier-language sibling: it reports the current rung inline without opening a
- * picker, and switches in one line when the rung is already known.
+ * Move the session to `tier`, the one switch path behind `/tier <rung>` and
+ * the model picker. Returns true when the rung moved.
  *
  * `setModel` resolves through `ctx.modelRegistry.find`, so a rung the
  * workspace's catalog never registered fails with a real message instead of
- * silently selecting nothing.
+ * silently selecting nothing. Mirrors the start guard's posture: a switch
+ * that does not land is logged AND named. `setModel` reaches a provider, so
+ * it can reject or throw; an uncaught throw here would escape the caller, and
+ * a silent one would leave a developer believing they moved rungs when they
+ * did not. Both end on the same durable trail entry.
+ */
+export async function switchTier(pi, ctx, tier) {
+    const notify = (message, type) => {
+        if (ctx.hasUI)
+            ctx.ui.notify(message, type);
+    };
+    if (ctx.model?.id === tier) {
+        notify(`Already on ${TIER_LABEL[tier]}.`, "info");
+        return false;
+    }
+    const model = ctx.modelRegistry.find(YAGNI_PROVIDER, tier);
+    if (!model) {
+        logEvent({
+            source: "tier",
+            level: "warn",
+            event: "tier_switch_failed",
+            fields: { from: ctx.model?.id ?? "unknown", to: tier, reason: "registry_miss" },
+        });
+        notify(`The ${TIER_LABEL[tier]} tier is not available on this workspace.`, "error");
+        return false;
+    }
+    let ok = false;
+    let reason = "set_model_rejected";
+    try {
+        ok = await pi.setModel(model);
+    }
+    catch (err) {
+        reason = trailReason(err);
+    }
+    if (!ok) {
+        logEvent({
+            source: "tier",
+            level: "warn",
+            event: "tier_switch_failed",
+            fields: { from: ctx.model?.id ?? "unknown", to: tier, reason },
+        });
+    }
+    // A failed switch still has to leave the rung in play legible: that is
+    // the whole feature, and "could not switch" alone tells you nothing
+    // about what you are now driving on.
+    notify(ok ? formatTierSwitched(tier) : formatTierSwitchFailed(tier, ctx.model?.id), ok ? "info" : "error");
+    return ok;
+}
+/**
+ * Register `/tier`.
+ *
+ * The picker itself (`/model`, Ctrl+L) is YAGNI's own since modelPicker.ts:
+ * pi's built-in selector renders raw ids under a lowercase provider badge and
+ * a "/login to add providers" hint that has no meaning here, and it cannot be
+ * adjusted in place. `/tier` is the tier-language sibling: it reports the
+ * current rung inline without opening a picker, and switches in one line when
+ * the rung is already known. Both go through {@link switchTier}.
  */
 export function registerTierCommand(pi) {
     pi.registerCommand("tier", {
-        description: "Show or switch this session's model tier (advanced / standard / efficient / peak).",
+        description: "Show or switch this session's model tier (peak / advanced / standard / efficient).",
         handler: async (args, ctx) => {
             const notify = (message, type) => {
                 if (ctx.hasUI)
@@ -244,46 +319,7 @@ export function registerTierCommand(pi) {
                 notify(`"${request.input}" is not a tier. Choose one of: ${SELECTABLE_TIERS.join(", ")}.`, "warning");
                 return;
             }
-            if (ctx.model?.id === request.tier) {
-                notify(`Already on ${request.tier}.`, "info");
-                return;
-            }
-            const model = ctx.modelRegistry.find(YAGNI_PROVIDER, request.tier);
-            if (!model) {
-                logEvent({
-                    source: "tier",
-                    level: "warn",
-                    event: "tier_switch_failed",
-                    fields: { from: ctx.model?.id ?? "unknown", to: request.tier, reason: "registry_miss" },
-                });
-                notify(`The ${request.tier} tier is not available on this workspace.`, "error");
-                return;
-            }
-            // Mirrors the start guard's posture: a switch that does not land is
-            // logged AND named. `setModel` reaches a provider, so it can reject or
-            // throw; an uncaught throw here would escape the command handler, and a
-            // silent one would leave a developer believing they moved rungs when
-            // they did not. Both end on the same durable trail entry.
-            let ok = false;
-            let reason = "set_model_rejected";
-            try {
-                ok = await pi.setModel(model);
-            }
-            catch (err) {
-                reason = trailReason(err);
-            }
-            if (!ok) {
-                logEvent({
-                    source: "tier",
-                    level: "warn",
-                    event: "tier_switch_failed",
-                    fields: { from: ctx.model?.id ?? "unknown", to: request.tier, reason },
-                });
-            }
-            // A failed switch still has to leave the rung in play legible: that is
-            // the whole feature, and "could not switch" alone tells you nothing
-            // about what you are now driving on.
-            notify(ok ? formatTierSwitched(request.tier) : formatTierSwitchFailed(request.tier, ctx.model?.id), ok ? "info" : "error");
+            await switchTier(pi, ctx, request.tier);
         },
     });
 }
@@ -298,7 +334,7 @@ export function registerTierCommand(pi) {
  * fused the two and read as though pricing had caused the failure.
  */
 export function formatStartCorrectionFailed(from) {
-    return `Could not move this session off ${from}. That rung is priced for judgment rather than driving, so use /tier ${SESSION_START_TIER} unless you need it.`;
+    return `Could not move this session off ${tierLabel(from)}. That rung is priced for judgment rather than driving, so use /tier ${SESSION_START_TIER} unless you need it.`;
 }
 /**
  * Hold an interactive driver to {@link SESSION_START_TIER} at session start.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.4-staging.1424.1",
+  "version": "1.1.4-staging.1426.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "bd7d06bc8fc95da1e22d6b06146cf7a0ea20ad78"
+  "yagniSourceSha": "98dad92531848916fdbe681059451b8d03646409"
 }