@mjasnikovs/pi-task 0.38.31 → 0.39.0

package/dist/config/register.d.ts

@@ -1,10 +1,12 @@
 import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { SettingsList } 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';
-import { type ReasoningGroup } from './reasoning.js';
+import { type GroupSetting, type ChildGroup } from './reasoning.js';
 type Theme = ExtensionCommandContext['ui']['theme'];
 /**
  * Frames a child component (the settings list) in a rounded border with a title
@@ -54,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
@@ -73,6 +75,17 @@ export interface ConfigItem {
     description: string;
     /** Offered values. Omitted for a boolean, which is always on/off. */
     values?: string[];
+    /**
+     * Rows whose choice is a LIST, not a cycle. Present ⇒ Enter opens a picker
+     * instead of stepping `values`.
+     *
+     * A FUNCTION of the draft config, evaluated at Enter-time, because what a row
+     * may offer can depend on another row the user changed while the panel was
+     * open: a group's thinking options narrow to what its chosen model declares.
+     * `values` stays the STATIC complete vocabulary, because that is what the
+     * round-trip property in config-items.test.ts quantifies over.
+     */
+    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. */
@@ -92,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' | '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;
@@ -100,6 +113,18 @@ export declare const SECTIONS: ReadonlyArray<{
 }>;
 /** Marks a header row, so onChange can ignore one and tests can find them. */
 export declare const SECTION_ID_PREFIX = "section:";
+/**
+ * Is this row scenery rather than a setting?
+ *
+ * Reads the ID, not `values`. Those two agreed only while every real row cycled
+ * a list: a picker row has a `submenu` and may carry `values` purely for the
+ * round-trip contract, so "no values" stopped meaning "not a row". Both
+ * `sectionHeader` and `sectionGap` already stamp the prefix, so this is exact
+ * rather than a heuristic, and all three consumers ask the same question.
+ */
+export declare const isSectionRow: (item: {
+    id: string;
+}) => boolean;
 /**
  * Every setting rendered by /task-config, in display order.
  *
@@ -114,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
@@ -123,15 +148,95 @@ 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 REASONING_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: ReasoningGroup): string;
-export declare function reasoningItems(): ConfigItem[];
+export declare function stepRowLabel(group: ChildGroup): string;
+/**
+ * What this machine can offer a model row, and what each offer can DO.
+ *
+ * `facts` is what lets the thinking rows narrow: a group pinned to a
+ * `reasoning: false` model may only be offered `off`. It answers `undefined` for
+ * a spec it cannot resolve — a vanished model, or `inherit` before a session
+ * exists — and every consumer reads that as "offer everything", which is exactly
+ * today's behaviour.
+ */
+export interface ModelCatalog {
+    /** Offerable `provider/id` specs, without `inherit`. */
+    specs: readonly string[];
+    /** Human note per spec, e.g. an extension-provided provider's warning. */
+    note?: (spec: string) => string | undefined;
+    facts: (spec: string) => ReasoningModelFacts | undefined;
+}
+/** No registry reachable. Every row still renders; nothing narrows. */
+export declare const EMPTY_CATALOG: ModelCatalog;
+/**
+ * The levels a row may offer, given the model that row's group will run on.
+ *
+ * The INTERSECTION with `REASONING_SETTINGS`, not `supportedThinkingLevels`
+ * directly: that returns the whole ladder including `xhigh` and `max`, which
+ * this menu excludes on purpose (see reasoning.ts) because pi's own UI may not
+ * offer them. A model declaring `xhigh` must not smuggle it in here.
+ */
+export declare function offeredLevels(facts: ReasoningModelFacts | undefined): GroupSetting[];
+/**
+ * `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.
  *
@@ -142,7 +247,7 @@ export declare function reasoningItems(): ConfigItem[];
  * it, nudging `research` while in `off` would silently return every other group
  * to whatever the stored table happened to hold.
  */
-export declare function applyReasoningLevel(cfg: PiTaskConfig, group: ReasoningGroup, chosen: string): void;
+export declare function applyReasoningLevel(cfg: PiTaskConfig, group: ChildGroup, chosen: string): void;
 /**
  * Tallest body the settings list can render, so {@link BorderedBox} can pad
  * every frame to it and hold the border still. Mirrors SettingsList's own
@@ -157,17 +262,32 @@ export type PanelItem = {
     description: string;
     currentValue: string;
     /**
-     * Omitted ONLY by a section header. SettingsList cycles a row on Enter when
-     * this is a non-empty array, so leaving it off is what makes a header inert
-     * — the header does not need its own branch anywhere.
+     * The values a cycling row steps through. A section header carries none.
+     *
+     * It is NOT what marks a header any more — {@link isSectionRow} reads the id
+     * for that. A model row legitimately has both a `values` list and a
+     * `submenu`, so "no values" and "not a row" stopped being the same fact the
+     * moment pickers existed.
      */
     values?: string[];
+    /**
+     * Enter-time options for a picker row, already closed over the draft config
+     * by {@link renderRows}.
+     *
+     * Deliberately NOT called `submenu`: pi-tui's `SettingItem.submenu` is a
+     * COMPONENT FACTORY, and a PanelItem is handed to `SettingsList` directly by
+     * tests and by the headless path. Two different things under one name would
+     * make PanelItem stop being assignable to SettingItem, for no gain.
+     * {@link createSettingsPanel} is where a theme exists, so it is where these
+     * options become a component.
+     */
+    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;
 };
@@ -181,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;
 /**
@@ -198,17 +318,17 @@ onChange: (id: string, newValue: string, list: SettingsList) => void, onCancel:
  * Fixed rows come before discovered ones within a section, so a freshly
  * installed extension appends rather than reshuffling the menu.
  */
-export declare function configRows(installed: InstalledExtension[], tools?: readonly GuardableTool[]): ConfigItem[];
+export declare function configRows(installed: InstalledExtension[], tools?: readonly GuardableTool[], catalog?: ModelCatalog): ConfigItem[];
 /** Render `rows` for the current config, grouped under their section headers. */
 export declare function renderRows(cfg: PiTaskConfig, rows: readonly ConfigItem[]): PanelItem[];
 /** The full settings row list for the current config, in menu order. */
-export declare function panelItems(cfg: PiTaskConfig, installed: InstalledExtension[], tools?: readonly GuardableTool[]): PanelItem[];
+export declare function panelItems(cfg: PiTaskConfig, installed: InstalledExtension[], tools?: readonly GuardableTool[], catalog?: ModelCatalog): PanelItem[];
 /**
  * Re-ask every row what it now displays, and write the answers back.
  *
  * 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