@mjasnikovs/pi-task 0.38.32 → 0.39.0

package/README.md

@@ -214,8 +214,8 @@ Run `/task-config` to toggle pi-task's behavior in an editor dialog. Settings pe
 | **command timeout** | 15 min | Wall-clock ceiling on a **single** tool execution. Local models routinely run a command that never returns (a hung build, a dev server, a check with no timeout) and the run wedges until you abort by hand — pi's bash tool has an optional timeout with no default, so this is the missing one. One knob, two surfaces: in the main session the overrun call is cancelled (killing the tool's whole process tree) plus a reminder turn; in the verify/fix gate children the child is killed and re-spawned with a hint, halving the ceiling on repeat hangs. Choices: 5/10/15/30 min or **off** — off unguards both surfaces, gates included. |
 | **stuck reply retry** | 10 min | Inactivity ceiling on the **model stream**. A hung or silently-dropped stream throws nothing at all, so neither the connection-error retry (it needs a reported error) nor the **command timeout** (tool calls only) nor the dead-backend stall guard (a reachable endpoint reads as proof of life) can see it — an mx5 run lost ~2.9h to three of them while the model server stayed healthy. Measured as time since the **last stream event of any kind**, so a slow model emitting one token every 30s is never touched, and it pauses while a tool runs. On expiry the main session aborts the turn (through the same channel the command watchdog uses) and posts a resume reminder; a child is killed and routed into the existing connection-error retry. Choices: 5/10/20/30 min or **off**. Keep it generous on local backends — prompt processing on a large context legitimately emits nothing for minutes. |
 | **yolo mode** | off | **Unattended runs.** Wherever pi-task would stop and ask, it takes the option already marked RECOMMENDED, stamps the artifact `(YOLO)` so an audit can tell a machine decided, and shows no prompt at all — clarify/grill answers, the verify-FAIL picker (auto-**Accept**, recorded as a yolo debt), and the final-gate picker (autofix while the budget lasts, then leave the run FAILED). A question with no recommendation is **skipped**, never invented. For throwaway/test projects nobody is watching; a real run should decide these itself. |
-| **model: …** | all inherit | One row per group of steps, choosing which model that group's children run on — research and planning on a strong model, the rest on a cheap one. Offered from `pi.modelRegistry.getAvailable()`, stored as the canonical `provider/id` that pi's own `--model` takes, and picked from a filterable list rather than cycled. **inherit** emits no flag at all, so an all-inherit table is byte-identical to a build without this feature; that is the shipped default, because which models exist is a property of your machine and nothing here can be measured for you. Choosing a model NARROWS that group's **think:** row to the levels it declares, and re-clamps a level already stored — pi erases a level a model cannot do, silently, so a cell offering one would be a lie. A stored model this machine cannot resolve is never erased (you may have set it on another machine): the flag is dropped, the step runs on pi's default, and a startup hint names the cell. Two rows deserve care: a provider registered by a host **extension** needs that extension enabled under **ext: …** or those children exit 1; and **model: implementation** is not free — it is *your* session, switched for the turn and switched back, and a model switch re-bills the whole prompt as a cache miss, twice per task. |
-| **reasoning** | default | How much the helper sessions think before answering. Local models differ sharply here: some break without reasoning, some waste minutes with it, and some cannot do it at all. The eleven **think:** rows below set one level per group of steps — the four research workers and their shared fallback, spec phases, /task-auto planning, /task-plan, the checking gates, the small extraction children, and the implementation turn itself. **default** uses the table pi-task has measured, **on** and **off** force one answer everywhere, and **custom** is whatever the think: rows say (changing any of them switches to custom). A step on **inherit** passes no flag at all, so it uses whatever thinking level pi itself is set to — which is what every step did before this setting existed, and is what every cell of the measured table currently holds. The think: rows always show what a step *actually* runs at, not what the stored table says. Three tiers of model exist and pi-task tells them apart: full levels (`reasoning_effort` in the chat template, e.g. Qwen3.8), on/off only (e.g. Qwen3.6, Gemma 4), and none at all. pi silently CLAMPS a level a model does not declare — a level you set can be erased, and an `off` can be clamped back up to `medium` — so a startup warning names each step, the model IT runs on, and the level that model will not honour. It never fires while every step is on inherit. |
+| **profile** | default | How much the helper sessions think, in one word, for every step at once. Local models differ sharply here: some break without reasoning, some waste minutes with it, and some cannot do it at all. **default** uses the per-step table pi-task has measured, **on** and **off** force one answer everywhere and ignore that table, and **custom** is whatever the step rows say — changing any of them switches this to custom. A step on **inherit** passes no flag at all, so it uses whatever thinking level pi itself is set to, which is what every step did before this setting existed. |
+| **steps: …** | all `inherit` | One row per group of steps, carrying BOTH dials: the model those children run on and the level they think at, shown as `level · model`. Enter walks a two-step picker — model first, then level — and **the level step offers only what that model declares, opening on the one that will actually run**. That is the whole point of the merge: pi silently CLAMPS a level a model cannot do (a level you set can be erased, and an `off` can be clamped back up to `medium`), so instead of discovering that later you watch the cursor land on the level you are really getting. Models are offered from `pi.modelRegistry.getAvailable()` and stored as the canonical `provider/id` that pi's own `--model` takes. **inherit** on the model half emits no flag, so an all-inherit table is byte-identical to a build without this feature; that is the shipped default, because which models exist is a property of your machine and nothing here can be measured for you. A stored model this machine cannot resolve is never erased (you may have set it on another machine): the flag is dropped, the step runs on pi's default, and a startup hint names the step. Two need care — a provider registered by a host **extension** needs that extension enabled under **ext: …** or those children exit 1; and **implementation** is not free, because it is *your* session moved for the turn and moved back, and a model switch re-bills the whole prompt as a cache miss, twice per task. |
 | **debug logs** | events | How much of a run is written to `.pi-tasks/*-debug.log`. **`events`** keeps decisions and guard actions — which phase ran, why a worker was retried, what the git-state guard restored, what a write-capable child changed on disk, why a gate returned FAIL — a few lines per task. **`full`** adds every line the child model emitted and every tool result; that's ~85% of the bytes (a real 247 KB `verify-debug.log` is 1315 lines, 521 of them tool dumps) and is what you want while actively debugging. **`off`** writes nothing. Nothing in pi-task ever reads these files back, so the setting cannot change how a run behaves — only whether you can explain it afterwards, and a log not written can't be recovered later. |
 | **watch: …** | all on | One toggle per tool in the live session, deciding whether **command timeout** applies to it. The list is discovered from `pi.getAllTools()` when the menu opens — built-ins first, then each extension's tools with the owning entry-point path in the description — so nothing is typed by hand and an uninstalled tool just stops being listed. Turn one **off** only for a tool that already owns a longer bounded, cancellable contract of its own (the guard exists because pi's `bash` has an optional timeout with *no* default — that reasoning doesn't transfer to a tool that has one). Two things to know before you do: a genuine hang in an unwatched tool is caught by nothing, since **stuck reply retry** is paused for the whole time any tool runs; and an unwatched tool is still killed as collateral if a *watched* sibling in the same turn overruns, because pi runs sibling tool calls concurrently and the abort ends the whole turn. Stored as exemptions, so the default and every tool pi-task has never seen stay guarded. |
 | **ext: …** | all off | One toggle per installed host `pi` extension, loading it into every child session by explicit path. Children otherwise run with extensions off, so a provider registered by an extension (e.g. `pi-lmstudio`) doesn't exist in them and they can't resolve the default model. Children also inherit the extension's tools and hooks, so only enable ones you trust. The list is strictly additive (discovery stays off), and an entry whose file is gone is skipped at spawn time, never fatal. |

package/dist/config/option-picker.d.ts

@@ -1,5 +1,5 @@
 /**
- * The submenu a /task-config row opens on Enter, when cycling is the wrong verb.
+ * The two-step picker a /task-config step row opens on Enter.
  *
  * WHY A SUBMENU AND NOT `ctx.ui.select`
  * -------------------------------------
@@ -9,8 +9,8 @@
  * in place of the list and delegates input to it. And its `done(v)` calls
  * `onChange(id, v)` with exactly the returned value while `done(undefined)`
  * writes nothing — the same one-value contract every cycling row uses, so the
- * panel's dispatch needs no branch and a model list of 200 costs one write
- * instead of 200.
+ * panel's dispatch needs no branch and a pair chosen out of two long lists costs
+ * ONE write.
  *
  * WHY NOT A BARE `SelectList`
  * ---------------------------
@@ -26,17 +26,45 @@ import { Container } from '@earendil-works/pi-tui';
 import type { SelectItem } from '@earendil-works/pi-tui';
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 type Theme = ExtensionCommandContext['ui']['theme'];
+/** What the second stage offers, once the first has been answered. */
+export interface PairStage {
+    options: readonly SelectItem[];
+    /**
+     * The option to open on — the value that will ACTUALLY run.
+     *
+     * Supplied by the caller rather than derived here, because deciding it is
+     * the clamp, and the clamp belongs to the config layer that owns the model's
+     * declared ladder. It is what makes the auto-switch visible: pick a model
+     * that cannot do `medium` and this stage opens on `off`.
+     */
+    preselect: string;
+}
+export interface PairOptions {
+    first: readonly SelectItem[];
+    second: (firstValue: string) => PairStage;
+    /** Which half of the stored value stage one opens on. */
+    firstOf: (value: string) => string;
+    /** How the two answers become the one string the row stores. */
+    join: (first: string, second: string) => string;
+}
 /**
- * A filterable one-of picker.
+ * Model, then thinking level, as one choice.
+ *
+ * Two stages rather than one flat list of every legal pair: the pair space is
+ * models × levels, and the common edit is "change the model, keep the level" —
+ * a flat list would make that re-pick both every time.
  *
- * `currentValue` may match NO option — that is the vanished-model case, where
- * the stored spec is still shown by the row and must still be openable. It
- * simply starts at the top rather than refusing to render.
+ * Escape at EITHER stage cancels the whole thing. Going back one step would be
+ * friendlier, but a TUI select owns up, down, enter and escape and has no fifth
+ * key to spare, and a half-answered pair must never reach `done`.
  */
-export declare class OptionPicker extends Container {
-    private readonly input;
-    private readonly list;
-    constructor(options: readonly SelectItem[], currentValue: string, theme: Theme, done: (value?: string) => void);
+export declare class PairPicker extends Container {
+    private readonly options;
+    private readonly theme;
+    private readonly done;
+    private stage;
+    constructor(options: PairOptions, currentValue: string, theme: Theme, done: (value?: string) => void);
+    private openSecond;
     handleInput(data: string): void;
 }
 export {};

package/dist/config/option-picker.js

@@ -1,5 +1,5 @@
 /**
- * The submenu a /task-config row opens on Enter, when cycling is the wrong verb.
+ * The two-step picker a /task-config step row opens on Enter.
  *
  * WHY A SUBMENU AND NOT `ctx.ui.select`
  * -------------------------------------
@@ -9,8 +9,8 @@
  * in place of the list and delegates input to it. And its `done(v)` calls
  * `onChange(id, v)` with exactly the returned value while `done(undefined)`
  * writes nothing — the same one-value contract every cycling row uses, so the
- * panel's dispatch needs no branch and a model list of 200 costs one write
- * instead of 200.
+ * panel's dispatch needs no branch and a pair chosen out of two long lists costs
+ * ONE write.
  *
  * WHY NOT A BARE `SelectList`
  * ---------------------------
@@ -35,23 +35,29 @@ function selectTheme(theme) {
     };
 }
 /**
- * A filterable one-of picker.
+ * A filterable list with a text filter above it.
  *
- * `currentValue` may match NO option — that is the vanished-model case, where
- * the stored spec is still shown by the row and must still be openable. It
- * simply starts at the top rather than refusing to render.
+ * Split out because both stages are one of these and the routing is the part
+ * that is easy to get wrong: `SelectList` owns four keys and drops the rest, so
+ * everything else has to be handed to the `Input` and the filter re-applied.
  */
-export class OptionPicker extends Container {
+class FilterList extends Container {
+    onPick;
+    onCancel;
     input = new Input();
     list;
-    constructor(options, currentValue, theme, done) {
+    constructor(options, preselect, theme, onPick, onCancel) {
         super();
+        this.onPick = onPick;
+        this.onCancel = onCancel;
         this.list = new SelectList([...options], PICKER_VISIBLE, selectTheme(theme));
-        const at = options.findIndex(o => o.value === currentValue);
+        // A `preselect` matching no option is normal, not an error: a row can
+        // hold a spec the catalog no longer offers, and it must still open.
+        const at = options.findIndex(o => o.value === preselect);
         if (at !== -1)
             this.list.setSelectedIndex(at);
-        this.list.onSelect = item => done(item.value);
-        this.list.onCancel = () => done(undefined);
+        this.list.onSelect = item => this.onPick(item.value);
+        this.list.onCancel = () => this.onCancel();
         this.addChild(this.input);
         this.addChild(this.list);
     }
@@ -71,3 +77,37 @@ export class OptionPicker extends Container {
         this.list.setFilter(this.input.getValue());
     }
 }
+/**
+ * Model, then thinking level, as one choice.
+ *
+ * Two stages rather than one flat list of every legal pair: the pair space is
+ * models × levels, and the common edit is "change the model, keep the level" —
+ * a flat list would make that re-pick both every time.
+ *
+ * Escape at EITHER stage cancels the whole thing. Going back one step would be
+ * friendlier, but a TUI select owns up, down, enter and escape and has no fifth
+ * key to spare, and a half-answered pair must never reach `done`.
+ */
+export class PairPicker extends Container {
+    options;
+    theme;
+    done;
+    stage;
+    constructor(options, currentValue, theme, done) {
+        super();
+        this.options = options;
+        this.theme = theme;
+        this.done = done;
+        this.stage = new FilterList(options.first, options.firstOf(currentValue), theme, first => this.openSecond(first), () => done(undefined));
+        this.addChild(this.stage);
+    }
+    openSecond(first) {
+        const { options: second, preselect } = this.options.second(first);
+        this.stage = new FilterList(second, preselect, this.theme, level => this.done(this.options.join(first, level)), () => this.done(undefined));
+        this.clear();
+        this.addChild(this.stage);
+    }
+    handleInput(data) {
+        this.stage.handleInput(data);
+    }
+}

package/dist/config/reasoning.d.ts

@@ -104,13 +104,16 @@ export declare function effectiveReasoning(cfg: PiTaskConfig): Record<ChildGroup
  * version before this feature existed.
  */
 export declare function thinkingArgs(setting: GroupSetting): string[];
-/** One honest sentence per group, for the /task-config rows. */
-export declare const REASONING_GROUP_HELP: Readonly<Record<ChildGroup, string>>;
 /**
- * One honest sentence per model row.
+ * One honest sentence per step, for the merged /task-config rows.
  *
- * They are NOT the reasoning help reworded. A model cell answers a different
- * question — which machine does this work — and one of them costs money every
- * turn rather than once per change, which is a thing the row has to say.
+ * ONE table, not the model help and the reasoning help concatenated. The panel
+ * sizes every frame from its tallest description (`settingsBodyHeight`), so
+ * gluing two paragraphs together for `implementation` would permanently add
+ * about six rows to the whole menu — for a row most users never open.
+ *
+ * What survives the merge is the part that is not guessable: which children the
+ * step actually spawns, what was MEASURED about its thinking level, and the one
+ * cost that is paid per turn rather than per change.
  */
-export declare const MODEL_GROUP_HELP: Readonly<Record<ChildGroup, string>>;
+export declare const STEP_GROUP_HELP: Readonly<Record<ChildGroup, string>>;

package/dist/config/reasoning.js

@@ -105,12 +105,23 @@ export function effectiveReasoning(cfg) {
 export function thinkingArgs(setting) {
     return setting === 'inherit' ? [] : ['--thinking', setting];
 }
-/** One honest sentence per group, for the /task-config rows. */
-export const REASONING_GROUP_HELP = {
-    research: 'The pi-worker subagent tool, and the fallback for any research worker below '
-        + 'whose own level is unset. Read-only exploration loops.',
+/**
+ * One honest sentence per step, for the merged /task-config rows.
+ *
+ * ONE table, not the model help and the reasoning help concatenated. The panel
+ * sizes every frame from its tallest description (`settingsBodyHeight`), so
+ * gluing two paragraphs together for `implementation` would permanently add
+ * about six rows to the whole menu — for a row most users never open.
+ *
+ * What survives the merge is the part that is not guessable: which children the
+ * step actually spawns, what was MEASURED about its thinking level, and the one
+ * cost that is paid per turn rather than per change.
+ */
+export const STEP_GROUP_HELP = {
+    research: 'The pi-worker subagent tool, and the fallback for any research worker below. '
+        + 'Long read-only loops, where a cheap fast model pays off.',
     'research:files': 'Research worker 1 of 4: maps which files the task will touch. Read-heavy. '
-        + 'Measured: the two arms tie, so it runs without thinking.',
+        + 'Measured: the two thinking arms tie, so it runs without.',
     'research:apis': 'Research worker 2 of 4: the symbols and signatures the task must call. '
         + 'Read-heavy, docs- and search-capable.',
     'research:context': 'Research worker 3 of 4: how the project is put together. One of the two that '
@@ -125,31 +136,7 @@ export const REASONING_GROUP_HELP = {
     gate: 'The checks that run after code is written: verify, enforce, lint-fix, autofix.',
     extraction: 'The small no-tools children that pull one answer out of a fetched page or '
         + 'a docs chunk.',
-    implementation: 'The main session turn that actually writes the code. Changing this briefly '
-        + "changes pi's own thinking level, and puts it back afterwards."
-};
-/**
- * One honest sentence per model row.
- *
- * They are NOT the reasoning help reworded. A model cell answers a different
- * question — which machine does this work — and one of them costs money every
- * turn rather than once per change, which is a thing the row has to say.
- */
-export const MODEL_GROUP_HELP = {
-    research: 'The pi-worker subagent tool, and the fallback for any research worker below. '
-        + 'Long read-only loops: a cheap fast model pays off here.',
-    'research:files': 'Research worker 1 of 4: maps which files the task will touch.',
-    'research:apis': 'Research worker 2 of 4: the symbols and signatures the task must call.',
-    'research:context': 'Research worker 3 of 4: how the project is put together.',
-    'research:tooling': 'Research worker 4 of 4: the commands that build, test and run it.',
-    phase: 'Refining your request, generating and answering the clarifying questions, '
-        + 'writing the spec, and critiquing it.',
-    planning: "/task-auto's planners: splitting a design document into tasks.",
-    plan: "/task-plan's interactive question-and-answer children.",
-    gate: 'The checks that run after code is written: verify, enforce, lint-fix, autofix.',
-    extraction: 'The small no-tools children that pull one answer out of a page or a docs chunk.',
-    implementation: 'The main session turn that writes the code — YOUR session, switched for the turn and '
-        + 'switched back. Unlike every row above, this one is not free: a model switch re-bills '
-        + 'the whole prompt as a cache miss, twice per task. Leave it on inherit unless you '
-        + 'want a different model than the one you are reading this in.'
+    implementation: 'The main session turn that writes the code — YOUR session, moved for the turn and '
+        + 'moved back. Unlike every step above, the model half here is not free: a switch '
+        + 're-bills the whole prompt as a cache miss, twice per task.'
 };

package/dist/config/register.d.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { SettingsList } from '@earendil-works/pi-tui';
-import type { Component, SelectItem } from '@earendil-works/pi-tui';
+import type { Component } from '@earendil-works/pi-tui';
 import { type ReasoningModelFacts } from '../shared/reasoning-capability.js';
+import { type PairOptions } from './option-picker.js';
 import { type PiTaskConfig } from './config.js';
 import { type InstalledExtension } from './extension-list.js';
 import { type GuardableTool } from './tool-list.js';
@@ -55,7 +56,7 @@ declare class BorderedBox implements Component {
 export interface ConfigItem {
     /**
      * The row's id. A `keyof PiTaskConfig` for a fixed setting; a prefixed
-     * string (`reason:`, `tool:`, `ext:`) for a DISCOVERED one.
+     * string (`step:`, `tool:`, `ext:`) for a DISCOVERED one.
      *
      * It is `string`, not `keyof PiTaskConfig`, and that is what lets the three
      * dynamic families BE rows instead of bypassing them — so the round-trip
@@ -84,7 +85,7 @@ export interface ConfigItem {
      * `values` stays the STATIC complete vocabulary, because that is what the
      * round-trip property in config-items.test.ts quantifies over.
      */
-    submenu?: (cfg: PiTaskConfig) => SelectItem[];
+    picker?: (cfg: PiTaskConfig) => PairOptions;
     /** What the panel shows for the current value. */
     format: (cfg: PiTaskConfig) => string;
     /** Write the chosen label back. A value it does not recognise is ignored. */
@@ -104,7 +105,7 @@ export interface ConfigItem {
  * exemptions from it) end up separated by rows that have nothing to do with
  * them. The headers are inert rows: no `values`, so Enter does nothing on them.
  */
-export type Section = 'session' | 'checks' | 'research' | 'models' | 'reasoning' | 'timeouts' | 'unattended' | 'logging' | 'extensions';
+export type Section = 'session' | 'checks' | 'research' | 'profile' | 'reasoning' | 'timeouts' | 'unattended' | 'logging' | 'extensions';
 /** Section order, and the label each header renders. */
 export declare const SECTIONS: ReadonlyArray<{
     key: Section;
@@ -138,7 +139,7 @@ export declare function toolItems(tools: readonly GuardableTool[]): ConfigItem[]
 /** Apply a per-tool watchdog toggle to the exemption list (idempotent both ways). */
 export declare function applyToolToggle(exempt: readonly string[], toolName: string, watched: boolean): string[];
 /**
- * The label for one `think:` row.
+ * The label for one step row.
  *
  * A group whose name carries a colon is a CHILD of the group before the colon —
  * `research:files` is one of the four workers `research` fans out to. Rendered
@@ -147,14 +148,18 @@ export declare function applyToolToggle(exempt: readonly string[], toolName: str
  * parent is also a row.
  *
  * So a child is drawn as a tree branch under its parent and loses the repeated
- * `think: research:` prefix, the same text at the head of four consecutive
- * lines. `└─` on the last child, `├─` on the rest, decided from the group's
- * position in {@link CHILD_GROUPS} rather than a hand-kept list — adding a
- * fifth worker moves the corner on its own.
+ * `research:` prefix, the same text at the head of four consecutive lines. `└─`
+ * on the last child, `├─` on the rest, decided from the group's position in
+ * {@link CHILD_GROUPS} rather than a hand-kept list — adding a fifth worker
+ * moves the corner on its own.
+ *
+ * A parentless group is its own bare name. It carried a `think: ` prefix while
+ * there were two families to tell apart; with one row per step there is nothing
+ * to disambiguate, and the prefix was the widest thing in the column.
  *
  * Leading spaces survive: SettingsList pads the label right, never trims it.
  */
-export declare function reasoningRowLabel(group: ChildGroup): string;
+export declare function stepRowLabel(group: ChildGroup): string;
 /**
  * What this machine can offer a model row, and what each offer can DO.
  *
@@ -173,26 +178,6 @@ export interface ModelCatalog {
 }
 /** No registry reachable. Every row still renders; nothing narrows. */
 export declare const EMPTY_CATALOG: ModelCatalog;
-export declare function modelItems(catalog: ModelCatalog): ConfigItem[];
-/**
- * Write a group's model, and RE-CLAMP its thinking cell in the same write.
- *
- * Narrowing the picker does nothing about a level already stored from before the
- * model was chosen: on its own it would freeze a lie into a cell it has just
- * made unconfigurable. `syncRows` re-renders every row, so the user sees the
- * level move.
- *
- * The clamp reads `resolveReasoning`, NOT `cfg.reasoningLevels[group]`. In mode
- * `on` or `off` the stored table is ignored entirely, so a user in `on` who
- * picks a non-reasoning model has a stored cell that says nothing and an
- * effective `medium` the model will erase — and comparing the stored cell would
- * see no clamp and stay silent about a real lie.
- *
- * Guarded on the clamp actually MOVING something, because `applyReasoningLevel`
- * flips the whole table to `custom`, and picking a fully-capable model must not
- * do that as a side effect.
- */
-export declare function applyGroupModel(cfg: PiTaskConfig, group: ChildGroup, chosen: string, catalog: ModelCatalog): void;
 /**
  * The levels a row may offer, given the model that row's group will run on.
  *
@@ -202,7 +187,56 @@ export declare function applyGroupModel(cfg: PiTaskConfig, group: ChildGroup, ch
  * offer them. A model declaring `xhigh` must not smuggle it in here.
  */
 export declare function offeredLevels(facts: ReasoningModelFacts | undefined): GroupSetting[];
-export declare function reasoningItems(catalog?: ModelCatalog): ConfigItem[];
+/**
+ * `level · provider/id`, the one string a step row shows and accepts.
+ *
+ * THE LEVEL COMES FIRST, and that is a display decision with teeth.
+ * `SettingsList` truncates a value from the RIGHT, so whatever is last is what
+ * silently disappears — and a real local model id (`local/Qwen3.8-27B-UD-Q4_K_XL
+ * .gguf`) is wide enough to consume the whole column on its own. Level-first
+ * means the half that falls off is the one still identifiable from its head, and
+ * the levels line up as a column you can read down.
+ */
+export declare function formatStepValue(spec: string, level: GroupSetting): string;
+/**
+ * The two halves back out, or `undefined` for anything not of that shape.
+ *
+ * Split on the FIRST separator, because the level leads and is a closed set,
+ * while a `provider/id` could conceivably contain one.
+ */
+export declare function parseStepValue(value: string): {
+    spec: string;
+    level: GroupSetting;
+} | undefined;
+/**
+ * One row per step, carrying BOTH dials.
+ *
+ * They were two parallel blocks of eleven, and the coupling between them was
+ * invisible: choosing a model re-clamps that step's thinking level, but the row
+ * that moved was eleven rows away from the row you touched. One row shows the
+ * pair, and the two-step picker shows the clamp happening.
+ *
+ * `values` is the LEGAL cross product — every model against only the levels that
+ * model declares. Nothing renders it: the picker offers two short lists, and the
+ * round-trip property in config-items.test.ts is its only reader. Building it
+ * from `offeredLevels` rather than the full ladder is what makes the property
+ * true, because a pair the model cannot honour would be clamped by `apply` and
+ * would not round-trip.
+ */
+export declare function stepItems(catalog?: ModelCatalog): ConfigItem[];
+/**
+ * Write both halves of a step row, atomically.
+ *
+ * Atomically matters for the round-trip property, which starts from a FRESH
+ * config every iteration: a value that wrote only one half would leave the other
+ * at its default and render as something else.
+ *
+ * The level is re-clamped even though the picker only ever offers legal pairs.
+ * The picker is not the only door — `values` is built when the panel opens, and
+ * a registry that moved underneath it would otherwise let an unhonourable level
+ * through.
+ */
+export declare function applyStepValue(cfg: PiTaskConfig, group: ChildGroup, chosen: string, catalog: ModelCatalog): void;
 /**
  * Apply one group row's new value.
  *
@@ -247,13 +281,13 @@ export type PanelItem = {
      * {@link createSettingsPanel} is where a theme exists, so it is where these
      * options become a component.
      */
-    submenuOptions?: () => SelectItem[];
+    pickerOptions?: () => PairOptions;
     /**
      * What the headless one-line rendering calls this row, when `label` reads
      * only in the panel. A tree branch means nothing on a line of `|`-joined
-     * rows: `├─ files` there names no parent, where `think: research:files`
-     * does. Set by the reasoning rows; every other row leaves it off and its
-     * `label` is used.
+     * rows: `├─ files` there names no parent, where `step: research:files`
+     * does. Set by the step rows; every other row leaves it off and its `label`
+     * is used.
      */
     headlessLabel?: string;
 };
@@ -267,10 +301,10 @@ export declare function createSettingsPanel(items: PanelItem[], theme: Theme,
  * Called with the row's id, its new value, and the LIST ITSELF.
  *
  * The list is handed back because some rows change what OTHER rows display:
- * flipping `reasoning` to off means every `think:` row now runs at off, and
- * a row's `currentValue` is a snapshot taken when the panel was built.
- * Without a way to write the others back, the menu would show
- * `reasoning off` beside rows still claiming `inherit`.
+ * flipping `profile` to off means every `step:` row now runs at off, and a
+ * row's `currentValue` is a snapshot taken when the panel was built. Without
+ * a way to write the others back, the menu would show `profile off` beside
+ * rows still claiming `inherit`.
  */
 onChange: (id: string, newValue: string, list: SettingsList) => void, onCancel: () => void): BorderedBox;
 /**
@@ -294,7 +328,7 @@ export declare function panelItems(cfg: PiTaskConfig, installed: InstalledExtens
  *
  * A row's `currentValue` in the live list is a snapshot taken when the panel was
  * built, and rows describe each other: cycling `reasoning` to `off` changes what
- * every `think:` row runs at, and cycling one group row flips the mode, which
+ * every `step:` row runs at, and setting one step row flips the profile, which
  * changes all the others.
  *
  * This runs after ANY change, over EVERY row. Re-reading a `format` costs

package/dist/config/register.js

@@ -1,14 +1,14 @@
 import { getKeybindings, SettingsList, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
 import { clampToModel, supportedThinkingLevels } from '../shared/reasoning-capability.js';
-import { isModelSpec, MODEL_INHERIT, splitSpec } from './group-models.js';
-import { OptionPicker } from './option-picker.js';
+import { MODEL_INHERIT, splitSpec } from './group-models.js';
+import { PairPicker } from './option-picker.js';
 import { registerBridgeCommand } from '../remote/bridge.js';
 import { readPkgVersion } from '../shared/pkg-version.js';
 import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../workers/search-types.js';
 import { COMMAND_TIMEOUT_OPTIONS, DEBUG_LOG_OPTIONS, getConfig, sanitizeDebugLogs, saveConfig, STREAM_INACTIVITY_OPTIONS } from './config.js';
 import { listInstalledExtensions } from './extension-list.js';
 import { listGuardableTools } from './tool-list.js';
-import { CHILD_GROUPS, REASONING_MODES, sanitizeReasoningMode, REASONING_GROUP_HELP, MODEL_GROUP_HELP, REASONING_SETTINGS, effectiveReasoning, resolveReasoning } from './reasoning.js';
+import { CHILD_GROUPS, REASONING_MODES, sanitizeReasoningMode, STEP_GROUP_HELP, REASONING_SETTINGS, effectiveReasoning, resolveReasoning } from './reasoning.js';
 // Version in the title so a bug report or screenshot says which build it came
 // from without anyone having to go look it up.
 const CONFIG_TITLE = `pi-task ${readPkgVersion()} settings`;
@@ -76,12 +76,20 @@ export const SECTIONS = [
     { key: 'session', title: 'session' },
     { key: 'checks', title: 'after each task' },
     { key: 'research', title: 'research' },
-    // Immediately before `reasoning`, and a BLOCK of its own rather than a
-    // second column on the think: rows. Interleaving would double one block to
-    // 22 rows and print the `├─ files` tree branches twice, meaning two
-    // different things a line apart.
-    { key: 'models', title: 'models' },
-    { key: 'reasoning', title: 'reasoning' },
+    // The global override gets its own heading, so it cannot be mistaken for a
+    // twelfth step. It is one row, and `renderRows` drops an empty section, so
+    // this costs a header and a blank line and nothing else.
+    //
+    // Both titles are SHORT on purpose. `SettingsList` sizes its label column
+    // from the widest item it holds — headers included — so a long heading is
+    // taken straight out of every row's value column, and the first thing to
+    // fall off the right is the thinking level.
+    { key: 'profile', title: 'profile' },
+    // ONE block for both dials. They shipped as two parallel blocks of eleven,
+    // which put a step's two settings eleven rows apart and hid the coupling
+    // between them: choosing a model re-clamps that step's thinking level, and
+    // nobody could see it happen.
+    { key: 'reasoning', title: 'steps' },
     { key: 'unattended', title: 'unattended' },
     { key: 'logging', title: 'logging' },
     { key: 'extensions', title: 'child extensions' },
@@ -229,15 +237,17 @@ export const ITEMS = [
         + 'For throwaway projects you are not watching'),
     {
         id: 'reasoningMode',
-        section: 'reasoning',
-        label: 'reasoning',
-        description: 'How much the helper sessions think before answering. "default" uses the '
-            + 'per-step table pi-task has measured, "on" and "off" force one answer '
-            + 'everywhere, and "custom" is whatever you set in the "think:" rows below. '
-            + 'Those rows always show what each step actually runs at, and changing one '
-            + 'switches this to custom. A step left on "inherit" uses whatever thinking '
-            + 'level pi itself is set to, which is what every step did before this setting '
-            + 'existed',
+        // Its OWN section, above the per-step block it governs. Sitting inside
+        // that block it read as a twelfth step called `reasoning` — a global
+        // override disguised as one more per-step row.
+        section: 'profile',
+        label: 'profile',
+        description: 'How much every step below thinks, in one word. "default" uses the per-step '
+            + 'table pi-task has measured, "on" and "off" force one answer everywhere and '
+            + 'IGNORE the rows below, and "custom" is whatever those rows say. They always '
+            + 'show what each step actually runs at, so changing one switches this to '
+            + 'custom. A step left on "inherit" uses whatever thinking level pi itself is '
+            + 'set to, which is what every step did before this setting existed',
         values: [...REASONING_MODES],
         format: cfg => String(cfg.reasoningMode),
         apply: (cfg, chosen) => {
@@ -340,9 +350,9 @@ export function applyToolToggle(exempt, toolName, watched) {
  *    though the custom table underneath is untouched, which is the honest
  *    answer to "what will my next child do".
  */
-const REASON_ID_PREFIX = 'reason:';
+const STEP_ID_PREFIX = 'step:';
 /**
- * The label for one `think:` row.
+ * The label for one step row.
  *
  * A group whose name carries a colon is a CHILD of the group before the colon —
  * `research:files` is one of the four workers `research` fans out to. Rendered
@@ -351,88 +361,27 @@ const REASON_ID_PREFIX = 'reason:';
  * parent is also a row.
  *
  * So a child is drawn as a tree branch under its parent and loses the repeated
- * `think: research:` prefix, the same text at the head of four consecutive
- * lines. `└─` on the last child, `├─` on the rest, decided from the group's
- * position in {@link CHILD_GROUPS} rather than a hand-kept list — adding a
- * fifth worker moves the corner on its own.
+ * `research:` prefix, the same text at the head of four consecutive lines. `└─`
+ * on the last child, `├─` on the rest, decided from the group's position in
+ * {@link CHILD_GROUPS} rather than a hand-kept list — adding a fifth worker
+ * moves the corner on its own.
+ *
+ * A parentless group is its own bare name. It carried a `think: ` prefix while
+ * there were two families to tell apart; with one row per step there is nothing
+ * to disambiguate, and the prefix was the widest thing in the column.
  *
  * Leading spaces survive: SettingsList pads the label right, never trims it.
  */
-export function reasoningRowLabel(group) {
+export function stepRowLabel(group) {
     const colon = group.indexOf(':');
     if (colon < 0)
-        return `think: ${group}`;
+        return group;
     const parent = group.slice(0, colon);
     const nextIsSibling = CHILD_GROUPS[CHILD_GROUPS.indexOf(group) + 1]?.startsWith(`${parent}:`);
     return `   ${nextIsSibling ? '├─' : '└─'} ${group.slice(colon + 1)}`;
 }
-const MODEL_ID_PREFIX = 'model:';
 /** No registry reachable. Every row still renders; nothing narrows. */
 export const EMPTY_CATALOG = { specs: [], facts: () => undefined };
-export function modelItems(catalog) {
-    return CHILD_GROUPS.map(group => ({
-        id: MODEL_ID_PREFIX + group,
-        section: 'models',
-        label: reasoningRowLabel(group).replace('think: ', 'model: '),
-        headlessLabel: `model: ${group}`,
-        description: MODEL_GROUP_HELP[group],
-        // The COMPLETE accepted vocabulary, which is what the round-trip
-        // property quantifies over. With nothing discovered it is `['inherit']`:
-        // length 1, still selectable, still not a header. No degenerate case.
-        values: [MODEL_INHERIT, ...catalog.specs],
-        submenu: () => [
-            { value: MODEL_INHERIT, label: MODEL_INHERIT, description: "pi's own default" },
-            ...catalog.specs.map(spec => ({
-                value: spec,
-                label: spec,
-                ...(catalog.note?.(spec) === undefined ? {} : { description: catalog.note(spec) })
-            }))
-        ],
-        // VERBATIM, even when absent from `values` — the vanished-model case,
-        // where the row must still say what the config holds so the hint that
-        // names it has something to point at.
-        format: cfg => cfg.groupModels[group],
-        apply: (cfg, chosen) => applyGroupModel(cfg, group, chosen, catalog)
-    }));
-}
-/**
- * Write a group's model, and RE-CLAMP its thinking cell in the same write.
- *
- * Narrowing the picker does nothing about a level already stored from before the
- * model was chosen: on its own it would freeze a lie into a cell it has just
- * made unconfigurable. `syncRows` re-renders every row, so the user sees the
- * level move.
- *
- * The clamp reads `resolveReasoning`, NOT `cfg.reasoningLevels[group]`. In mode
- * `on` or `off` the stored table is ignored entirely, so a user in `on` who
- * picks a non-reasoning model has a stored cell that says nothing and an
- * effective `medium` the model will erase — and comparing the stored cell would
- * see no clamp and stay silent about a real lie.
- *
- * Guarded on the clamp actually MOVING something, because `applyReasoningLevel`
- * flips the whole table to `custom`, and picking a fully-capable model must not
- * do that as a side effect.
- */
-export function applyGroupModel(cfg, group, chosen, catalog) {
-    // MEMBERSHIP, not just shape. A stored spec naming a vanished model must
-    // survive — that is the sanitizer's job, and `format` still renders it — but
-    // it may only ever ARRIVE here from the picker, which offers exactly these.
-    // Without this, the panel could write a spec this machine cannot resolve.
-    if (!isModelSpec(chosen))
-        return;
-    if (chosen !== MODEL_INHERIT && !catalog.specs.includes(chosen))
-        return;
-    cfg.groupModels = { ...cfg.groupModels, [group]: chosen };
-    const facts = catalog.facts(chosen);
-    if (facts === undefined)
-        return;
-    const wanted = resolveReasoning(group, cfg);
-    if (wanted === 'inherit')
-        return;
-    const clamped = clampToModel(facts, wanted);
-    if (clamped !== wanted)
-        applyReasoningLevel(cfg, group, clamped);
-}
 /**
  * The levels a row may offer, given the model that row's group will run on.
  *
@@ -447,30 +396,171 @@ export function offeredLevels(facts) {
     const supported = supportedThinkingLevels(facts);
     return REASONING_SETTINGS.filter(s => s === 'inherit' || supported.includes(s));
 }
-export function reasoningItems(catalog = EMPTY_CATALOG) {
+/** The separator between a step row's two halves. */
+const PAIR_SEP = ' \u00b7 ';
+/**
+ * `level · provider/id`, the one string a step row shows and accepts.
+ *
+ * THE LEVEL COMES FIRST, and that is a display decision with teeth.
+ * `SettingsList` truncates a value from the RIGHT, so whatever is last is what
+ * silently disappears — and a real local model id (`local/Qwen3.8-27B-UD-Q4_K_XL
+ * .gguf`) is wide enough to consume the whole column on its own. Level-first
+ * means the half that falls off is the one still identifiable from its head, and
+ * the levels line up as a column you can read down.
+ */
+export function formatStepValue(spec, level) {
+    return `${level}${PAIR_SEP}${spec}`;
+}
+/**
+ * The two halves back out, or `undefined` for anything not of that shape.
+ *
+ * Split on the FIRST separator, because the level leads and is a closed set,
+ * while a `provider/id` could conceivably contain one.
+ */
+export function parseStepValue(value) {
+    const at = value.indexOf(PAIR_SEP);
+    if (at <= 0)
+        return undefined;
+    const level = value.slice(0, at);
+    const spec = value.slice(at + PAIR_SEP.length);
+    if (spec === '' || !REASONING_SETTINGS.includes(level))
+        return undefined;
+    return { spec, level: level };
+}
+/**
+ * One row per step, carrying BOTH dials.
+ *
+ * They were two parallel blocks of eleven, and the coupling between them was
+ * invisible: choosing a model re-clamps that step's thinking level, but the row
+ * that moved was eleven rows away from the row you touched. One row shows the
+ * pair, and the two-step picker shows the clamp happening.
+ *
+ * `values` is the LEGAL cross product — every model against only the levels that
+ * model declares. Nothing renders it: the picker offers two short lists, and the
+ * round-trip property in config-items.test.ts is its only reader. Building it
+ * from `offeredLevels` rather than the full ladder is what makes the property
+ * true, because a pair the model cannot honour would be clamped by `apply` and
+ * would not round-trip.
+ */
+export function stepItems(catalog = EMPTY_CATALOG) {
+    const specs = [MODEL_INHERIT, ...catalog.specs];
     return CHILD_GROUPS.map(group => ({
-        id: REASON_ID_PREFIX + group,
+        id: STEP_ID_PREFIX + group,
         section: 'reasoning',
-        label: reasoningRowLabel(group),
-        headlessLabel: `think: ${group}`,
-        description: REASONING_GROUP_HELP[group],
-        values: [...REASONING_SETTINGS],
-        // A submenu, not a cycle, because what this row may offer depends on the
-        // model row above it — which the user can change while the panel is
-        // open. `values` is static and computed when the rows are built, and
-        // `syncRows` can only re-ask `format`; a factory runs at Enter-time.
-        submenu: (cfg) => offeredLevels(catalog.facts(cfg.groupModels[group])).map(level => ({
-            value: level,
-            label: level
-        })),
-        // The EFFECTIVE level, not cfg.reasoningLevels[group]: in default/on/off
-        // the stored table is not what runs, and a row that shows a value the
-        // run does not use is worse than no row. As a FUNCTION rather than a
-        // snapshot, so `syncRows` can re-ask after any change.
-        format: cfg => resolveReasoning(group, cfg),
-        apply: (cfg, chosen) => applyReasoningLevel(cfg, group, chosen)
+        label: stepRowLabel(group),
+        headlessLabel: `step: ${group}`,
+        description: STEP_GROUP_HELP[group],
+        values: specs.flatMap(spec => offeredLevels(catalog.facts(spec)).map(level => formatStepValue(spec, level))),
+        // Built at ENTER-time from the LIVE draft, not when the rows were made:
+        // stage two narrows to the model chosen in stage one, and the user can
+        // have changed another row since the panel opened.
+        picker: cfg => stepPicker(group, cfg, catalog),
+        // The model half VERBATIM even when the catalog no longer offers it — the
+        // vanished-model case, where the row is the only place the user can see
+        // what their config actually holds. The thinking half is the EFFECTIVE
+        // level, not the stored cell: in mode default/on/off the stored table is
+        // not what runs, and a row showing a value the run does not use is worse
+        // than no row.
+        format: cfg => formatStepValue(cfg.groupModels[group], resolveReasoning(group, cfg)),
+        apply: (cfg, chosen) => applyStepValue(cfg, group, chosen, catalog)
     }));
 }
+/**
+ * The two lists behind one step row.
+ *
+ * Stage two is where the coupling becomes visible. It offers only the levels the
+ * chosen model declares, and it OPENS on the level that will actually run — the
+ * current one when that model can honour it, otherwise the clamp, with the
+ * reason written beside it. Picking a model that cannot think is therefore not a
+ * silent downgrade discovered later; it is the option the cursor is already on.
+ */
+function stepPicker(group, cfg, catalog) {
+    const held = cfg.groupModels[group];
+    // The row's CURRENT model leads stage one when the catalog cannot offer it.
+    // Without this, opening the row to nudge only the level would silently
+    // rewrite the model to `inherit`: `FilterList` falls back to index 0 when
+    // the preselect matches nothing, and the two dials are one row now, so there
+    // is no way to touch the level without confirming a model. That would erase
+    // a spec set on the user's other machine — the one thing the loader, the
+    // format function and the startup hint all go out of their way to preserve.
+    const missing = held !== MODEL_INHERIT && !catalog.specs.includes(held);
+    return {
+        first: [
+            ...(missing ?
+                [{ value: held, label: held, description: 'not available here — kept as-is' }]
+                : []),
+            { value: MODEL_INHERIT, label: MODEL_INHERIT, description: "pi's own default" },
+            ...catalog.specs.map(spec => ({
+                value: spec,
+                label: spec,
+                ...(catalog.note?.(spec) === undefined ? {} : { description: catalog.note(spec) })
+            }))
+        ],
+        second: spec => {
+            const facts = catalog.facts(spec);
+            const offered = offeredLevels(facts);
+            const wanted = resolveReasoning(group, cfg);
+            const clamped = facts === undefined || wanted === 'inherit' ?
+                wanted
+                : clampToModel(facts, wanted);
+            // Back inside the menu's own vocabulary. `clampToModel` walks UP
+            // first and knows the whole ladder, so a model declaring `xhigh`
+            // can land on a level `offeredLevels` deliberately excludes — and
+            // then stage two would open on `inherit` with the explanation
+            // attached to no row at all.
+            const runs = offered.includes(clamped) ? clamped : (offered.at(-1) ?? 'inherit');
+            return {
+                options: offered.map(level => ({
+                    value: level,
+                    label: level,
+                    ...(level === runs && runs !== wanted ?
+                        { description: `${spec} cannot do ${wanted}` }
+                        : {})
+                })),
+                preselect: runs
+            };
+        },
+        firstOf: value => parseStepValue(value)?.spec ?? value,
+        join: (spec, level) => formatStepValue(spec, level)
+    };
+}
+/**
+ * Write both halves of a step row, atomically.
+ *
+ * Atomically matters for the round-trip property, which starts from a FRESH
+ * config every iteration: a value that wrote only one half would leave the other
+ * at its default and render as something else.
+ *
+ * The level is re-clamped even though the picker only ever offers legal pairs.
+ * The picker is not the only door — `values` is built when the panel opens, and
+ * a registry that moved underneath it would otherwise let an unhonourable level
+ * through.
+ */
+export function applyStepValue(cfg, group, chosen, catalog) {
+    const pair = parseStepValue(chosen);
+    if (pair === undefined)
+        return;
+    // MEMBERSHIP, not just shape: the panel may only ever write what the picker
+    // showed. That is `inherit`, the catalog's own specs, and — when the catalog
+    // cannot offer it — the spec this cell ALREADY holds, which stage one keeps
+    // at its head precisely so the level can be changed without discarding it.
+    // Re-writing the value that is already there is not a new unresolvable spec.
+    if (pair.spec !== MODEL_INHERIT
+        && pair.spec !== cfg.groupModels[group]
+        && !catalog.specs.includes(pair.spec)) {
+        return;
+    }
+    cfg.groupModels = { ...cfg.groupModels, [group]: pair.spec };
+    const facts = catalog.facts(pair.spec);
+    const level = facts === undefined || pair.level === 'inherit' ?
+        pair.level
+        : clampToModel(facts, pair.level);
+    // Only when it MOVES something: `applyReasoningLevel` flips the whole table
+    // to `custom`, and picking a pair the config already runs must not do that
+    // as a side effect.
+    if (level !== resolveReasoning(group, cfg))
+        applyReasoningLevel(cfg, group, level);
+}
 /**
  * Apply one group row's new value.
  *
@@ -621,10 +711,10 @@ export function createSettingsPanel(items, theme,
  * Called with the row's id, its new value, and the LIST ITSELF.
  *
  * The list is handed back because some rows change what OTHER rows display:
- * flipping `reasoning` to off means every `think:` row now runs at off, and
- * a row's `currentValue` is a snapshot taken when the panel was built.
- * Without a way to write the others back, the menu would show
- * `reasoning off` beside rows still claiming `inherit`.
+ * flipping `profile` to off means every `step:` row now runs at off, and a
+ * row's `currentValue` is a snapshot taken when the panel was built. Without
+ * a way to write the others back, the menu would show `profile off` beside
+ * rows still claiming `inherit`.
  */
 onChange, onCancel) {
     const headerLabels = new Set(items.filter(isSectionRow).map(i => i.label));
@@ -639,11 +729,11 @@ onChange, onCancel) {
      * crosses a section boundary.
      */
     let submenuOpen = false;
-    const settingItems = items.map(({ submenuOptions, ...row }) => submenuOptions === undefined ? row : ({
+    const settingItems = items.map(({ pickerOptions, ...row }) => pickerOptions === undefined ? row : ({
         ...row,
         submenu: (currentValue, done) => {
             submenuOpen = true;
-            return new OptionPicker(submenuOptions(), currentValue, theme, v => {
+            return new PairPicker(pickerOptions(), currentValue, theme, v => {
                 submenuOpen = false;
                 done(v);
             });
@@ -651,7 +741,7 @@ onChange, onCancel) {
     }));
     const list = new SettingsList(settingItems, MAX_VISIBLE, makeTheme(theme, label => headerLabels.has(label.trimEnd())), (id, newValue) => onChange(id, newValue, list), onCancel);
     return new BorderedBox(new SkipInertRows(list, items.map(i => !isSectionRow(i)
-        && ((i.values?.length ?? 0) > 0 || i.submenuOptions !== undefined)), () => submenuOpen), CONFIG_TITLE, s => theme.fg('borderMuted', s), s => theme.fg('accent', theme.bold(s)), settingsBodyHeight(items.map(i => i.description), MAX_VISIBLE, OVERLAY_WIDTH - 8));
+        && ((i.values?.length ?? 0) > 0 || i.pickerOptions !== undefined)), () => submenuOpen), CONFIG_TITLE, s => theme.fg('borderMuted', s), s => theme.fg('accent', theme.bold(s)), settingsBodyHeight(items.map(i => i.description), MAX_VISIBLE, OVERLAY_WIDTH - 8));
 }
 /**
  * Every settings row for this session, fixed and DISCOVERED, in menu order.
@@ -671,13 +761,7 @@ catalog = EMPTY_CATALOG) {
     // The discovered rows carry a section like every other row — the per-tool
     // watchdog exemptions under `timeouts` (they are exemptions FROM that
     // timeout), and the per-extension toggles under their own heading.
-    return [
-        ...ITEMS,
-        ...modelItems(catalog),
-        ...reasoningItems(catalog),
-        ...toolItems(tools),
-        ...extensionItems(installed)
-    ];
+    return [...ITEMS, ...stepItems(catalog), ...toolItems(tools), ...extensionItems(installed)];
 }
 /** Render `rows` for the current config, grouped under their section headers. */
 export function renderRows(cfg, rows) {
@@ -691,7 +775,7 @@ export function renderRows(cfg, rows) {
             description: i.description,
             currentValue: i.format(cfg),
             values: i.values ?? ['on', 'off'],
-            ...(i.submenu === undefined ? {} : { submenuOptions: () => i.submenu(cfg) }),
+            ...(i.picker === undefined ? {} : { pickerOptions: () => i.picker(cfg) }),
             ...(i.headlessLabel === undefined ? {} : { headlessLabel: i.headlessLabel })
         }));
         // An empty section prints no header. `extensions` has no fixed rows at
@@ -713,7 +797,7 @@ export function panelItems(cfg, installed, tools = [], catalog = EMPTY_CATALOG)
  *
  * A row's `currentValue` in the live list is a snapshot taken when the panel was
  * built, and rows describe each other: cycling `reasoning` to `off` changes what
- * every `think:` row runs at, and cycling one group row flips the mode, which
+ * every `step:` row runs at, and setting one step row flips the profile, which
  * changes all the others.
  *
  * This runs after ANY change, over EVERY row. Re-reading a `format` costs
@@ -725,7 +809,7 @@ export function syncRows(cfg, rows, list) {
         list.updateValue(row.id, row.format(cfg));
 }
 /**
- * The model rows' offer list, read live when the menu opens.
+ * The step rows' model offer list, read live when the menu opens.
  *
  * `getAvailable()`, never `getAll()`: an unauthed model would spawn a child that
  * exits 1 on every phase of that group, and offering it would be offering a

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.38.32",
+    "version": "0.39.0",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",