@mjasnikovs/pi-task 0.38.32 → 0.39.1

package/dist/config/register.js

@@ -1,14 +1,15 @@
 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 { effectiveSetting, offeredLevels } from '../shared/reasoning-capability.js';
+import { resolveModel, specOf } from '../shared/model-resolve.js';
+import { MODEL_INHERIT } 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 +77,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 +238,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 +351,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,36 +362,120 @@ 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) {
+/** 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: 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: () => [
+        id: STEP_ID_PREFIX + group,
+        section: 'reasoning',
+        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,
@@ -388,88 +483,58 @@ export function modelItems(catalog) {
                 ...(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)
-    }));
+        second: spec => {
+            const facts = catalog.facts(spec);
+            const wanted = resolveReasoning(group, cfg);
+            const runs = effectiveSetting(facts, wanted);
+            return {
+                options: offeredLevels(facts).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 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.
+ * Write both halves of a step row, atomically.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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 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))
+export function applyStepValue(cfg, group, chosen, catalog) {
+    const pair = parseStepValue(chosen);
+    if (pair === undefined)
         return;
-    if (chosen !== MODEL_INHERIT && !catalog.specs.includes(chosen))
+    // 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]: 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.
- *
- * 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 function offeredLevels(facts) {
-    if (facts === undefined)
-        return [...REASONING_SETTINGS];
-    const supported = supportedThinkingLevels(facts);
-    return REASONING_SETTINGS.filter(s => s === 'inherit' || supported.includes(s));
-}
-export function reasoningItems(catalog = EMPTY_CATALOG) {
-    return CHILD_GROUPS.map(group => ({
-        id: REASON_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)
-    }));
+    }
+    cfg.groupModels = { ...cfg.groupModels, [group]: pair.spec };
+    const level = effectiveSetting(catalog.facts(pair.spec), 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 +686,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 +704,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 +716,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 +736,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 +750,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 +772,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 +784,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
@@ -747,47 +806,27 @@ function liveCatalog(ctx) {
     // registry that cannot answer must cost the model rows, never the menu.
     // Every row below still renders; `EMPTY_CATALOG` offers only `inherit` and
     // narrows nothing, which is exactly the pre-feature panel.
-    let registry;
     let available;
-    let fromExtension;
     try {
-        registry = ctx.modelRegistry;
-        available = registry.getAvailable();
-        fromExtension = new Set(registry.getRegisteredProviderIds());
+        available = ctx.modelRegistry.getAvailable();
     }
     catch {
         return EMPTY_CATALOG;
     }
     return {
-        specs: available.map(m => `${m.provider}/${m.id}`),
-        note: spec => {
-            const parts = splitSpec(spec);
-            return parts && fromExtension.has(parts.provider) ?
-                'provider comes from an extension — whitelist it under child extensions, '
-                    + "or this group's children exit 1"
-                : undefined;
-        },
-        facts: spec => {
-            // `inherit` means the session's own model, which is what a child
-            // resolves today. Its facts are what the thinking row must narrow to.
-            if (spec === MODEL_INHERIT)
-                return ctx.model;
-            const parts = splitSpec(spec);
-            return parts ? registry.find(parts.provider, parts.id) : undefined;
-        }
+        specs: available.map(specOf),
+        note: spec => resolveModel(ctx, spec)?.fromExtension ?
+            'provider comes from an extension — whitelist it under child extensions, '
+                + "or this group's children exit 1"
+            : undefined,
+        facts: spec => resolveModel(ctx, spec)
     };
 }
 async function handleTaskConfig(_args, ctx, getTools = () => []) {
-    const cfg = {
-        ...getConfig(),
-        extensionWhitelist: [...getConfig().extensionWhitelist],
-        commandTimeoutExemptTools: [...getConfig().commandTimeoutExemptTools],
-        // Copied for the same reason as the two arrays above: the panel mutates
-        // its own draft, and sharing the live object would apply half-made
-        // choices to running children before the user finished choosing.
-        reasoningLevels: { ...getConfig().reasoningLevels },
-        groupModels: { ...getConfig().groupModels }
-    };
+    // A deep copy: the panel mutates its own draft, and sharing the live object
+    // would apply half-made choices to running children before the user
+    // finished choosing.
+    const cfg = structuredClone(getConfig());
     // Enumerated live at open so an installed extension appears and an
     // uninstalled one vanishes without pi-task doing any bookkeeping. A failed
     // enumeration only costs the extension toggles, never the whole menu.

package/dist/shared/child-process.d.ts

@@ -1,4 +1,6 @@
 import type { EventEmitter } from 'node:events';
+import type { CommandKillReason } from './command-watchdog.js';
+import type { LoopHit } from '../task/loop-detector.js';
 /** Grace period between SIGTERM and SIGKILL (ms). */
 export declare const KILL_GRACE_MS = 5000;
 /** Base flags shared by all child pi invocations. */
@@ -36,11 +38,41 @@ export type SpawnFn = (command: string, args: ReadonlyArray<string>, options: {
      *  model children (json-events); plumbing stays in-group. */
     detached?: boolean;
 }) => ProcLike;
+/**
+ * Why runChild killed the child. Five sources converge on one kill path, and
+ * each names itself here rather than in its own flag — so a consumer reads ONE
+ * field, and a sixth source is one more member, not a fourth boolean that every
+ * consumer has to remember to test before `aborted`.
+ *
+ * `aborted` is the caller's signal with no cause attached: a user cancel, or a
+ * wall clock that aborts without saying so. `command-timeout` also arrives
+ * through the signal, but the watchdog aborts WITH its kill as the reason
+ * (command-watchdog.ts), which is how it stays a member here instead of an
+ * out-of-band query.
+ */
+export type ChildKill = {
+    by: 'aborted';
+} | {
+    by: 'loop';
+    hit: LoopHit;
+} | {
+    by: 'stream-stall';
+    idleMs: number;
+} | {
+    by: 'stalled';
+} | CommandKillReason;
 export interface ChildResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    /** true exactly when `kill` is set. Kept as a flag for the text-mode callers. */
     aborted: boolean;
+    /**
+     * Set when WE ended the child. Its exit status then describes our SIGTERM
+     * and says nothing about the child's verdict, so a consumer must read this
+     * before the exit code.
+     */
+    kill?: ChildKill;
     /** Extracted assistant text (only populated in json-events mode). */
     text?: string;
     /**
@@ -51,24 +83,6 @@ export interface ChildResult {
      * Only populated in json-events mode.
      */
     modelError?: string;
-    /**
-     * true when the stall guard killed the child: no output for the stall
-     * window AND the model endpoint probe found the backend unreachable.
-     * Callers must check this BEFORE `aborted` — the kill sets aborted too,
-     * and without the flag it would mislabel as a user cancel.
-     */
-    stalled?: boolean;
-    /**
-     * true when the STREAM watchdog killed the child: no output at all for the
-     * configured inactivity window, regardless of whether the backend answers a
-     * probe. Distinct from `stalled`, which requires an UNREACHABLE endpoint —
-     * these hangs have a perfectly healthy server and a dead stream, so the
-     * probe path could never fire. Callers must check this BEFORE `aborted`
-     * (the kill sets aborted too) and route it into the connection-error retry.
-     */
-    streamStalled?: {
-        idleMs: number;
-    };
 }
 export interface ToolCall {
     name: string;
@@ -83,19 +97,7 @@ export interface ToolCall {
      */
     toolCallId?: string;
 }
-export interface LoopHit {
-    call: ToolCall;
-    count: number;
-    windowSize: number;
-    /**
-     * Set when the kill came from the whole-run StallDetector rather than the
-     * short-window LoopDetector, naming which of its two rules tripped
-     * (task/stall-detector.ts). Absent for an ordinary loop hit. Carried here so
-     * a stall rides the kill/restart plumbing the loop hit already has instead of
-     * needing a second channel.
-     */
-    stall?: 'no-new-ground' | 'context-churn';
-}
+export type { LoopHit } from '../task/loop-detector.js';
 export interface ContextSnapshot {
     tokens: number;
     contextWindow: number;
@@ -215,7 +217,7 @@ export declare class JsonEventSink {
     private buf;
     constructor(opts: RunChildJsonEventsOptions, 
     /** Invoked when onToolCall reports a loop hit — runChild kills the child. */
-    onLoopKill: () => void);
+    onLoopKill: (hit: LoopHit) => void);
     /** Feed a raw stdout chunk: parse every complete line, buffer the partial tail. */
     feed(chunk: string): void;
     /** Flush a trailing event that wasn't newline-terminated (call on close). */