@mjasnikovs/pi-task 0.38.32 → 0.39.1

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/group-args.d.ts

@@ -1,21 +1,33 @@
 /**
- * The live-config bridge for per-group child settings: group in, argv fragment out.
+ * The live-config bridge for per-group child settings: group in, argv fragment
+ * out — plus the session's model snapshot, which the argv needs and which only a
+ * session_start with a `ctx` can produce.
  *
  * Separate from reasoning.ts and group-models.ts because those must take no
  * import with a runtime side effect — see their headers. The `getConfig()` read
  * lives here instead: this file imports them and nothing in config/ imports it
  * back, so the graph stays a tree.
  *
- * Read PER CALL, never cached at module scope, so a /task-config change lands on
- * the next child without a restart. Same contract `childBaseArgs` keeps.
+ * Config is read PER CALL, never cached at module scope, so a /task-config
+ * change lands on the next child without a restart. Same contract
+ * `childBaseArgs` keeps. The snapshot is the one deliberate exception, and it is
+ * a snapshot of the REGISTRY, not of config.
  */
 import { type PiTaskConfig } from './config.js';
 import type { ChildGroup } from './groups.js';
-export declare function setUnusableSpecs(specs: Iterable<string>): void;
-export declare function isSpecUsable(spec: string): boolean;
-export declare function setGroupWindows(windows: Readonly<Partial<Record<ChildGroup, number>>>): void;
-/** The group's own window, or `undefined` for "caller keeps its fallback". */
+import type { GroupModelSnapshot } from '../shared/model-resolve.js';
+export declare function setGroupModels(snapshot: Readonly<Partial<Record<ChildGroup, GroupModelSnapshot>>>): void;
+/**
+ * The group's own window, or `undefined` for "caller keeps its fallback".
+ *
+ * The number drives `StallDetector`'s churn rule, where the two error directions
+ * are NOT symmetric: too large fires late (degraded, and the no-new-ground rule
+ * still covers it), too small fires early and KILLS A HEALTHY CHILD. So an
+ * absent answer means "use the parent's", never a guess.
+ */
 export declare function groupWindow(group: ChildGroup): number | undefined;
+export declare function setModelEndpoints(endpoints: ReadonlyMap<string, string>): void;
+export declare function modelEndpoint(spec: string): string | undefined;
 /**
  * The `['--model', spec]` fragment for a group, or `[]` for `inherit` and for a
  * spec this session proved unresolvable.
@@ -26,14 +38,17 @@ export declare function groupWindow(group: ChildGroup): number | undefined;
  * `reasoning: true` onto it, inherits the provider's default baseUrl and answers
  * at exit 0. Dropping the flag runs the same child the user got last week and
  * says so out loud; passing it runs a model nobody chose and says nothing.
+ *
+ * The verdict applies to the spec it was proven on: a cell changed since
+ * session_start is emitted, and pi decides.
  */
 export declare function groupModelArgs(group: ChildGroup, cfg?: PiTaskConfig): string[];
 /**
  * The `['--thinking', level]` fragment for a group, or `[]` when the group is
  * `inherit` and the child should keep falling back to settings.json.
  *
- * Still exported on its own: the host-session turn (implementation-hold.ts) and
- * the settings UI (register.ts) need the level rather than a whole fragment.
+ * Exported for its own tests only: the per-call config read is a contract on
+ * each half, and only the half on its own can assert it.
  */
 export declare function groupThinkingArgs(group: ChildGroup, cfg?: PiTaskConfig): string[];
 /**

package/dist/config/group-args.js

@@ -1,22 +1,26 @@
 /**
- * The live-config bridge for per-group child settings: group in, argv fragment out.
+ * The live-config bridge for per-group child settings: group in, argv fragment
+ * out — plus the session's model snapshot, which the argv needs and which only a
+ * session_start with a `ctx` can produce.
  *
  * Separate from reasoning.ts and group-models.ts because those must take no
  * import with a runtime side effect — see their headers. The `getConfig()` read
  * lives here instead: this file imports them and nothing in config/ imports it
  * back, so the graph stays a tree.
  *
- * Read PER CALL, never cached at module scope, so a /task-config change lands on
- * the next child without a restart. Same contract `childBaseArgs` keeps.
+ * Config is read PER CALL, never cached at module scope, so a /task-config
+ * change lands on the next child without a restart. Same contract
+ * `childBaseArgs` keeps. The snapshot is the one deliberate exception, and it is
+ * a snapshot of the REGISTRY, not of config.
  */
 import { getConfig } from './config.js';
 import { MODEL_INHERIT, modelArgs } from './group-models.js';
 import { resolveReasoning, thinkingArgs } from './reasoning.js';
 /**
- * Specs this session has proven a child cannot resolve.
+ * What this session resolved each group's model cell to.
  *
- * WHY A SESSION-SCOPED SET AND NOT A LOOKUP
- * -----------------------------------------
+ * WHY A SESSION-SCOPED SNAPSHOT AND NOT A LOOKUP
+ * ----------------------------------------------
  * The honest question is "can a `--no-extensions` child resolve this spec?", and
  * only `ctx.modelRegistry` can answer it. Five of the six argv producers have no
  * `ctx` — `pi-worker`, `pi-worker-docs`, `docs-core`, `fetch-core` and
@@ -26,41 +30,43 @@ import { resolveReasoning, thinkingArgs } from './reasoning.js';
  * this project does not depend on pi-ai.
  *
  * So it is answered ONCE, at session_start, where ctx exists and every task is
- * still in the future, and the verdict is left here.
+ * still in the future, and the whole verdict is left here — usability and the
+ * context window from ONE walk, so the argv and the churn rule can never
+ * disagree about which model a group runs on.
  *
  * EMPTY MEANS EMIT. A host that never fires session_start therefore behaves
  * exactly as it does today — the failure direction is "pi decides", never "we
  * silently dropped a flag nobody checked".
  */
-let unusableSpecs = new Set();
-export function setUnusableSpecs(specs) {
-    unusableSpecs = new Set(specs);
-}
-export function isSpecUsable(spec) {
-    return !unusableSpecs.has(spec);
+let groupModels = {};
+export function setGroupModels(snapshot) {
+    groupModels = { ...snapshot };
 }
 /**
- * The context window of each group's model, resolved in the SAME session pass
- * that filled {@link setUnusableSpecs}.
- *
- * It lives here for the same reason that set does — `child-runner` and the
- * workers have no `ctx`, so they cannot ask a registry — and it is filled by the
- * same walk, so the two can never disagree about which model a group runs on.
+ * The group's own window, or `undefined` for "caller keeps its fallback".
  *
  * The number drives `StallDetector`'s churn rule, where the two error directions
  * are NOT symmetric: too large fires late (degraded, and the no-new-ground rule
  * still covers it), too small fires early and KILLS A HEALTHY CHILD. So an
  * absent answer means "use the parent's", never a guess.
  */
-let groupWindows = {};
-export function setGroupWindows(windows) {
-    groupWindows = { ...windows };
-}
-/** The group's own window, or `undefined` for "caller keeps its fallback". */
 export function groupWindow(group) {
-    const w = groupWindows[group];
+    const w = groupModels[group]?.contextWindow;
     return w !== undefined && w > 0 ? w : undefined;
 }
+/**
+ * `spec → baseUrl` for every model the session can use, from the same
+ * session_start pass. Read by the dead-backend probe (shared/model-endpoint.ts),
+ * which runs where no `ctx` exists. Empty until a session starts, and the probe
+ * reads "no url" as "cannot see this server, so never kill".
+ */
+let modelEndpoints = new Map();
+export function setModelEndpoints(endpoints) {
+    modelEndpoints = new Map(endpoints);
+}
+export function modelEndpoint(spec) {
+    return modelEndpoints.get(spec);
+}
 /**
  * The `['--model', spec]` fragment for a group, or `[]` for `inherit` and for a
  * spec this session proved unresolvable.
@@ -71,19 +77,23 @@ export function groupWindow(group) {
  * `reasoning: true` onto it, inherits the provider's default baseUrl and answers
  * at exit 0. Dropping the flag runs the same child the user got last week and
  * says so out loud; passing it runs a model nobody chose and says nothing.
+ *
+ * The verdict applies to the spec it was proven on: a cell changed since
+ * session_start is emitted, and pi decides.
  */
 export function groupModelArgs(group, cfg) {
     const spec = (cfg ?? getConfig()).groupModels[group];
     if (spec === undefined || spec === MODEL_INHERIT)
         return [];
-    return isSpecUsable(spec) ? modelArgs(spec) : [];
+    const proven = groupModels[group];
+    return proven?.spec === spec && !proven.usable ? [] : modelArgs(spec);
 }
 /**
  * The `['--thinking', level]` fragment for a group, or `[]` when the group is
  * `inherit` and the child should keep falling back to settings.json.
  *
- * Still exported on its own: the host-session turn (implementation-hold.ts) and
- * the settings UI (register.ts) need the level rather than a whole fragment.
+ * Exported for its own tests only: the per-call config read is a contract on
+ * each half, and only the half on its own can assert it.
  */
 export function groupThinkingArgs(group, cfg) {
     // The default is evaluated HERE, per call. Hoisting the read to module scope

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.'
 };