@mjasnikovs/pi-task 0.38.22 → 0.38.24

package/dist/config/register.d.ts

@@ -59,7 +59,18 @@ declare class BorderedBox implements Component {
  * because both read `format`.
  */
 export interface ConfigItem {
-    id: keyof PiTaskConfig;
+    /**
+     * The row's id. A `keyof PiTaskConfig` for a fixed setting; a prefixed
+     * string (`reason:`, `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. While the id was
+     * narrow, each family re-invented both directions by hand — a builder, an
+     * apply function, and an arm in a four-way prefix ladder 300 lines away —
+     * and the round-trip property `config-items.test.ts` runs over `ITEMS`
+     * covered none of them.
+     */
+    id: string;
     /**
      * Which titled block of the menu this row sits under. Rows are grouped by
      * section in {@link panelItems}, in the order the sections first appear in
@@ -75,6 +86,11 @@ export interface ConfigItem {
     format: (cfg: PiTaskConfig) => string;
     /** Write the chosen label back. A value it does not recognise is ignored. */
     apply: (cfg: PiTaskConfig, chosen: string) => void;
+    /**
+     * What the headless one-line rendering calls this row, when `label` reads
+     * only in the panel. See {@link PanelItem.headlessLabel}.
+     */
+    headlessLabel?: string;
 }
 /**
  * The titled blocks the settings menu is divided into.
@@ -102,31 +118,31 @@ export declare const SECTION_ID_PREFIX = "section:";
  * either of the two ladders this replaced.
  */
 export declare const ITEMS: ConfigItem[];
-export declare function extensionItems(extensions: InstalledExtension[], whitelist: readonly string[]): {
-    id: string;
-    label: string;
-    description: string;
-    currentValue: string;
-    values: string[];
-}[];
+export declare function extensionItems(extensions: InstalledExtension[]): ConfigItem[];
 /** Apply an extension toggle to the config's whitelist (idempotent both ways). */
 export declare function applyExtensionToggle(whitelist: readonly string[], entryPath: string, on: boolean): string[];
-export declare function toolItems(tools: readonly GuardableTool[], exempt: readonly string[]): {
-    id: string;
-    label: string;
-    description: string;
-    currentValue: string;
-    values: string[];
-}[];
+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[];
-export declare function reasoningItems(cfg: PiTaskConfig): {
-    id: string;
-    label: string;
-    description: string;
-    currentValue: string;
-    values: string[];
-}[];
+/**
+ * The label for one `think:` 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
+ * flat, those four read as four more peers of `research`, and the menu's one
+ * genuine hierarchy is invisible: the four are the only rows in the list whose
+ * parent is also a row.
+ *
+ * So a child is drawn as a tree branch under its parent and loses the repeated
+ * `think: research:` prefix, which is 15 columns of the same text on 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.
+ *
+ * Leading spaces survive: SettingsList pads the label right, never trims it.
+ */
+export declare function reasoningRowLabel(group: ReasoningGroup): string;
+export declare function reasoningItems(): ConfigItem[];
 /**
  * Apply one group row's new value.
  *
@@ -137,16 +153,6 @@ export declare function reasoningItems(cfg: PiTaskConfig): {
  * it, nudging `research` while in `off` would silently return the other six to
  * whatever the stored table happened to hold.
  */
-/**
- * Write every `think:` row's displayed value back from the config.
- *
- * Called after ANY change, not just a reasoning one, because the mode row and
- * the seven group rows are one control split across eight lines: cycling
- * `reasoning` to `off` changes what all seven of them run at, and cycling one
- * group row flips the mode, which changes the other six. A row showing a level
- * the run will not use is worse than no row.
- */
-export declare function refreshReasoningRows(cfg: PiTaskConfig, list: SettingsList): void;
 export declare function applyReasoningLevel(cfg: PiTaskConfig, group: ReasoningGroup, chosen: string): void;
 /**
  * Tallest body the settings list can render, so {@link BorderedBox} can pad
@@ -167,6 +173,14 @@ export type PanelItem = {
      * — the header does not need its own branch anywhere.
      */
     values?: string[];
+    /**
+     * 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.
+     */
+    headlessLabel?: string;
 };
 /**
  * Builds the framed settings panel. Split out of the command handler so the
@@ -184,7 +198,37 @@ export declare function createSettingsPanel(items: PanelItem[], theme: Theme,
  * beside seven rows still claiming `inherit` — which is what it did.
  */
 onChange: (id: string, newValue: string, list: SettingsList) => void, onCancel: () => void): BorderedBox;
+/**
+ * Every settings row for this session, fixed and DISCOVERED, in menu order.
+ *
+ * One list of `ConfigItem`s — so a row's display, its write-back and its section
+ * are one object, the dispatch is a lookup by id, and the round-trip properties
+ * in `config-items.test.ts` cover the reasoning, tool and extension families
+ * that used to bypass the row type entirely.
+ *
+ * Fixed rows come before discovered ones within a section, which is the order
+ * the hand-written `extra` map produced.
+ */
+export declare function configRows(installed: InstalledExtension[], tools?: readonly GuardableTool[]): 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[];
+/**
+ * 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
+ * all seven `think:` rows run at, and cycling one group row flips the mode,
+ * which changes the other six.
+ *
+ * This runs after ANY change, over EVERY row. Its predecessor,
+ * `refreshReasoningRows`, ran after any change too — but hard-coded the seven
+ * reasoning ids plus `reasoningMode` and touched none of the other ~30 rows, so
+ * the next cross-row dependency would have needed a fifth function. Re-reading a
+ * `format` costs nothing, which is why there is still no list of "changes that
+ * need a refresh" to keep correct.
+ */
+export declare function syncRows(cfg: PiTaskConfig, rows: readonly ConfigItem[], list: SettingsList): void;
 export declare function registerConfig(pi: ExtensionAPI): void;
 export {};

package/dist/config/register.js

@@ -5,7 +5,7 @@ import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../w
 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 { REASONING_GROUPS, REASONING_MODES, sanitizeReasoningMode, REASONING_GROUP_HELP, REASONING_SETTINGS, resolveReasoning } from './reasoning.js';
+import { REASONING_GROUPS, REASONING_MODES, sanitizeReasoningMode, REASONING_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`;
@@ -253,16 +253,22 @@ export const ITEMS = [
  * can tell an extension toggle from a PiTaskConfig field.
  */
 const EXT_ID_PREFIX = 'ext:';
-export function extensionItems(extensions, whitelist) {
+export function extensionItems(extensions) {
     return extensions.map(e => ({
         id: EXT_ID_PREFIX + e.path,
+        section: 'extensions',
         label: `ext: ${e.label}`,
         description: `Load this ${e.origin} extension in the helper sessions pi-task spawns. They run `
             + 'with extensions off by default, so turn this on when the extension provides the '
             + 'model they need (pi-lmstudio, for example). They also inherit its tools and '
             + `hooks, so only enable ones you trust. ${e.path}`,
-        currentValue: whitelist.includes(e.path) ? 'on' : 'off',
-        values: ['on', 'off']
+        values: ['on', 'off'],
+        format: cfg => (cfg.extensionWhitelist.includes(e.path) ? 'on' : 'off'),
+        apply: (cfg, chosen) => {
+            if (chosen !== 'on' && chosen !== 'off')
+                return;
+            cfg.extensionWhitelist = applyExtensionToggle(cfg.extensionWhitelist, e.path, chosen === 'on');
+        }
     }));
 }
 /** Apply an extension toggle to the config's whitelist (idempotent both ways). */
@@ -280,18 +286,24 @@ export function applyExtensionToggle(whitelist, entryPath, on) {
  * the config matches nothing.
  */
 const TOOL_ID_PREFIX = 'tool:';
-export function toolItems(tools, exempt) {
+export function toolItems(tools) {
     return tools.map(t => ({
         id: TOOL_ID_PREFIX + t.name,
+        section: 'timeouts',
         label: `watch: ${t.name}`,
         description: `Apply the command timeout to this tool. Leave it on unless the tool runs its own `
             + `bounded, cancellable work for longer than the timeout — turning it off means a `
             + `genuine hang in this tool will never be caught, and nothing else is watching `
             + `while a tool runs. ${t.origin}`,
+        values: ['on', 'off'],
         // Stored inverted: the config records the EXEMPTIONS, so an empty list
         // (and any tool pi-task has never heard of) stays guarded by default.
-        currentValue: exempt.includes(t.name) ? 'off' : 'on',
-        values: ['on', 'off']
+        format: cfg => (cfg.commandTimeoutExemptTools.includes(t.name) ? 'off' : 'on'),
+        apply: (cfg, chosen) => {
+            if (chosen !== 'on' && chosen !== 'off')
+                return;
+            cfg.commandTimeoutExemptTools = applyToolToggle(cfg.commandTimeoutExemptTools, t.name, chosen === 'on');
+        }
     }));
 }
 /** Apply a per-tool watchdog toggle to the exemption list (idempotent both ways). */
@@ -314,16 +326,45 @@ export function applyToolToggle(exempt, toolName, watched) {
  *    whole point of having measured it.
  */
 const REASON_ID_PREFIX = 'reason:';
-export function reasoningItems(cfg) {
+/**
+ * The label for one `think:` 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
+ * flat, those four read as four more peers of `research`, and the menu's one
+ * genuine hierarchy is invisible: the four are the only rows in the list whose
+ * parent is also a row.
+ *
+ * So a child is drawn as a tree branch under its parent and loses the repeated
+ * `think: research:` prefix, which is 15 columns of the same text on 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.
+ *
+ * Leading spaces survive: SettingsList pads the label right, never trims it.
+ */
+export function reasoningRowLabel(group) {
+    const colon = group.indexOf(':');
+    if (colon < 0)
+        return `think: ${group}`;
+    const parent = group.slice(0, colon);
+    const nextIsSibling = REASONING_GROUPS[REASONING_GROUPS.indexOf(group) + 1]?.startsWith(`${parent}:`);
+    return `   ${nextIsSibling ? '├─' : '└─'} ${group.slice(colon + 1)}`;
+}
+export function reasoningItems() {
     return REASONING_GROUPS.map(group => ({
         id: REASON_ID_PREFIX + group,
-        label: `think: ${group}`,
+        section: 'reasoning',
+        label: reasoningRowLabel(group),
+        headlessLabel: `think: ${group}`,
         description: REASONING_GROUP_HELP[group],
+        values: [...REASONING_SETTINGS],
         // 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.
-        currentValue: resolveReasoning(group, cfg),
-        values: [...REASONING_SETTINGS]
+        // 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)
     }));
 }
 /**
@@ -336,29 +377,13 @@ export function reasoningItems(cfg) {
  * it, nudging `research` while in `off` would silently return the other six to
  * whatever the stored table happened to hold.
  */
-/**
- * Write every `think:` row's displayed value back from the config.
- *
- * Called after ANY change, not just a reasoning one, because the mode row and
- * the seven group rows are one control split across eight lines: cycling
- * `reasoning` to `off` changes what all seven of them run at, and cycling one
- * group row flips the mode, which changes the other six. A row showing a level
- * the run will not use is worse than no row.
- */
-export function refreshReasoningRows(cfg, list) {
-    for (const group of REASONING_GROUPS) {
-        list.updateValue(REASON_ID_PREFIX + group, resolveReasoning(group, cfg));
-    }
-    list.updateValue('reasoningMode', cfg.reasoningMode);
-}
 export function applyReasoningLevel(cfg, group, chosen) {
     if (!REASONING_SETTINGS.includes(chosen))
         return;
     if (cfg.reasoningMode !== 'custom') {
-        const seeded = {};
-        for (const g of REASONING_GROUPS)
-            seeded[g] = resolveReasoning(g, cfg);
-        cfg.reasoningLevels = seeded;
+        // Freeze the table exactly as it runs today, then switch to custom, so
+        // opening one row cannot silently move the other six.
+        cfg.reasoningLevels = effectiveReasoning(cfg);
         cfg.reasoningMode = 'custom';
     }
     cfg.reasoningLevels = { ...cfg.reasoningLevels, [group]: chosen };
@@ -492,38 +517,70 @@ onChange, onCancel) {
     const list = new SettingsList(items, 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 => (i.values?.length ?? 0) > 0)), 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));
 }
-/** The full settings row list for the current config, in menu order. */
-export function panelItems(cfg, installed, tools = []) {
-    // The discovered rows belong to a section too — the per-tool watchdog
-    // exemptions under `timeouts` (they are exemptions FROM that timeout), and
-    // the per-extension toggles under their own heading.
-    const extra = {
-        reasoning: reasoningItems(cfg),
-        timeouts: toolItems(tools, cfg.commandTimeoutExemptTools),
-        extensions: extensionItems(installed, cfg.extensionWhitelist)
-    };
+/**
+ * Every settings row for this session, fixed and DISCOVERED, in menu order.
+ *
+ * One list of `ConfigItem`s — so a row's display, its write-back and its section
+ * are one object, the dispatch is a lookup by id, and the round-trip properties
+ * in `config-items.test.ts` cover the reasoning, tool and extension families
+ * that used to bypass the row type entirely.
+ *
+ * Fixed rows come before discovered ones within a section, which is the order
+ * the hand-written `extra` map produced.
+ */
+export function configRows(installed, tools = []) {
+    // 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, ...reasoningItems(), ...toolItems(tools), ...extensionItems(installed)];
+}
+/** Render `rows` for the current config, grouped under their section headers. */
+export function renderRows(cfg, rows) {
     const out = [];
     for (const { key, title } of SECTIONS) {
-        const rows = [
-            ...ITEMS.filter(i => i.section === key).map(({ id, label, description, values, format }) => ({
-                id: id,
-                label,
-                description,
-                currentValue: format(cfg),
-                values: values ?? ['on', 'off']
-            })),
-            ...(extra[key] ?? [])
-        ];
+        const inSection = rows
+            .filter(i => i.section === key)
+            .map(i => ({
+            id: i.id,
+            label: i.label,
+            description: i.description,
+            currentValue: i.format(cfg),
+            values: i.values ?? ['on', 'off'],
+            ...(i.headlessLabel === undefined ? {} : { headlessLabel: i.headlessLabel })
+        }));
         // An empty section prints no header. `extensions` has no fixed rows at
         // all, so with nothing installed the heading would otherwise sit alone.
-        if (rows.length === 0)
+        if (inSection.length === 0)
             continue;
         if (out.length > 0)
             out.push(sectionGap(title));
-        out.push(sectionHeader(title), ...rows);
+        out.push(sectionHeader(title), ...inSection);
     }
     return out;
 }
+/** The full settings row list for the current config, in menu order. */
+export function panelItems(cfg, installed, tools = []) {
+    return renderRows(cfg, configRows(installed, tools));
+}
+/**
+ * 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
+ * all seven `think:` rows run at, and cycling one group row flips the mode,
+ * which changes the other six.
+ *
+ * This runs after ANY change, over EVERY row. Its predecessor,
+ * `refreshReasoningRows`, ran after any change too — but hard-coded the seven
+ * reasoning ids plus `reasoningMode` and touched none of the other ~30 rows, so
+ * the next cross-row dependency would have needed a fifth function. Re-reading a
+ * `format` costs nothing, which is why there is still no list of "changes that
+ * need a refresh" to keep correct.
+ */
+export function syncRows(cfg, rows, list) {
+    for (const row of rows)
+        list.updateValue(row.id, row.format(cfg));
+}
 async function handleTaskConfig(_args, ctx, getTools = () => []) {
     const cfg = {
         ...getConfig(),
@@ -555,38 +612,23 @@ async function handleTaskConfig(_args, ctx, getTools = () => []) {
             .filter(i => i.label !== '')
             .map(i => i.values === undefined ?
             `[${i.label.trim()}]`
-            : `${i.label.padEnd(22)} ${i.currentValue}`);
+            : `${(i.headlessLabel ?? i.label).padEnd(22)} ${i.currentValue}`);
         ctx.ui.notify(lines.join('  |  '), 'info');
         return;
     }
-    await ctx.ui.custom((_tui, theme, _kb, done) => createSettingsPanel(panelItems(cfg, installed, tools), theme, (id, newValue, list) => {
-        // Header rows carry no `values`, so SettingsList never
-        // cycles them and this can only be a real setting.
-        if (id.startsWith(SECTION_ID_PREFIX))
-            return;
-        if (id.startsWith(EXT_ID_PREFIX)) {
-            cfg.extensionWhitelist = applyExtensionToggle(cfg.extensionWhitelist, id.slice(EXT_ID_PREFIX.length), newValue === 'on');
-        }
-        else if (id.startsWith(REASON_ID_PREFIX)) {
-            applyReasoningLevel(cfg, id.slice(REASON_ID_PREFIX.length), newValue);
-        }
-        else if (id.startsWith(TOOL_ID_PREFIX)) {
-            cfg.commandTimeoutExemptTools = applyToolToggle(cfg.commandTimeoutExemptTools, id.slice(TOOL_ID_PREFIX.length), newValue === 'on');
-        }
-        else {
-            // Every setting parses its own value. There is no generic
-            // fallback: the ladder this replaces ended in one that
-            // wrote `newValue === 'on'` into whatever field it was
-            // handed, so a new enum setting silently became a boolean
-            // until someone noticed.
-            ITEMS.find(item => item.id === id)?.apply(cfg, newValue);
-        }
-        // The reasoning rows describe each other, so they are
-        // re-read from the config after every change — including
-        // changes to unrelated rows, which costs nothing and means
-        // there is no list of "changes that need a refresh" to keep
-        // correct.
-        refreshReasoningRows(cfg, list);
+    // Built ONCE and shared by the renderer, the dispatch and the refresh, so
+    // all three necessarily agree about which rows exist.
+    const rows = configRows(installed, tools);
+    await ctx.ui.custom((_tui, theme, _kb, done) => createSettingsPanel(renderRows(cfg, rows), theme, (id, newValue, list) => {
+        // Every row parses its own value. There is no generic
+        // fallback and no prefix ladder: the ladder this replaces
+        // ended in one that wrote `newValue === 'on'` into whatever
+        // field it was handed, so a new enum setting silently became
+        // a boolean until someone noticed. A header row carries no
+        // `values`, so SettingsList never cycles it and it matches
+        // no row here anyway.
+        rows.find(row => row.id === id)?.apply(cfg, newValue);
+        syncRows(cfg, rows, list);
         saveConfig(cfg).catch(() => { });
     }, () => done(undefined)), { overlay: true, overlayOptions: { width: OVERLAY_WIDTH } });
 }

package/dist/shared/reasoning-capability.d.ts

@@ -24,7 +24,7 @@
  * transitive package to get twenty lines of arithmetic. SOURCE OF TRUTH is that
  * module; `reasoning-capability.test.ts` is where a change upstream shows up.
  */
-import type { ReasoningGroup, GroupSetting } from '../config/reasoning.js';
+import { type ReasoningGroup, type GroupSetting } from '../config/reasoning.js';
 /**
  * pi's own level ladder, in order. The order is the whole algorithm: an
  * unsupported level is resolved by walking UP first, then down.
@@ -80,7 +80,4 @@ export interface ReasoningMismatch {
  * about one direction while staying silent about the other would ship this
  * feature with its own measured failure mode unreported.
  */
-export declare function reasoningMismatches(model: ReasoningModelFacts | undefined, settings: ReadonlyArray<{
-    group: ReasoningGroup;
-    setting: GroupSetting;
-}>): ReasoningMismatch[];
+export declare function reasoningMismatches(model: ReasoningModelFacts | undefined, levels: Readonly<Record<ReasoningGroup, GroupSetting>>): ReasoningMismatch[];

package/dist/shared/reasoning-capability.js

@@ -1,3 +1,30 @@
+/**
+ * What pi will ACTUALLY send, given a model and a requested thinking level.
+ *
+ * WHY A LOCAL COPY OF PI'S CLAMP
+ * ------------------------------
+ * pi never reports that it ignored or downgraded a level. Measured live against
+ * this machine's llama-server, with a proxy capturing the request body:
+ *
+ *   1. a model with `reasoning: false` + `--thinking medium`
+ *        → the body carries NO reasoning field at all. No error, no warning.
+ *   2. `thinkingLevelMap: {off: null, ...}` + `--thinking off`
+ *        → silently clamped UP to `medium`. Thinking stays on.
+ *   3. `--thinking low` where `low: null`
+ *        → silently clamped to `medium`.
+ *
+ * All three are the same arithmetic, and it is pure: `getSupportedThinkingLevels`
+ * / `clampThinkingLevel` in @earendil-works/pi-ai's models module. Reproducing it
+ * lets one predicate — `clampToModel(m, wanted) !== wanted` — catch all three
+ * host-side, before a single request is sent.
+ *
+ * Reimplemented rather than imported because `@earendil-works/pi-ai` is neither a
+ * dependency nor a peerDependency of pi-task: it is present only because
+ * pi-coding-agent hoists it, so importing it would take a hard dependency on a
+ * transitive package to get twenty lines of arithmetic. SOURCE OF TRUTH is that
+ * module; `reasoning-capability.test.ts` is where a change upstream shows up.
+ */
+import { REASONING_GROUPS } from '../config/reasoning.js';
 /**
  * pi's own level ladder, in order. The order is the whole algorithm: an
  * unsupported level is resolved by walking UP first, then down.
@@ -64,16 +91,16 @@ export function clampToModel(model, level) {
  * about one direction while staying silent about the other would ship this
  * feature with its own measured failure mode unreported.
  */
-export function reasoningMismatches(model, settings) {
+export function reasoningMismatches(model, levels) {
     // No model resolved yet (session still starting, or none selected): say
     // nothing. A warning naming no model is noise, not information.
     if (!model)
         return [];
     const out = [];
-    for (const { group, setting } of settings) {
-        if (setting === 'inherit')
+    for (const group of REASONING_GROUPS) {
+        const wanted = levels[group];
+        if (wanted === 'inherit')
             continue;
-        const wanted = setting;
         const actual = clampToModel(model, wanted);
         if (actual !== wanted)
             out.push({ group, wanted, actual });

package/dist/task/auto-orchestrator.d.ts

@@ -29,6 +29,8 @@ export interface AutoDeps extends GateDeps, FinalGateStageDeps {
      */
     stashRef?: (cwd: string) => Promise<string | null>;
 }
+/** Wait for every plan-debug line written so far to reach disk. Tests only. */
+export declare function flushPlanDebug(): Promise<unknown>;
 /**
  * Expand any @file references in the feature text by appending each referenced
  * file's contents, so the planning children (clarify, decompose) always see the

package/dist/task/auto-orchestrator.js

@@ -47,7 +47,7 @@ import { granularityFloor, granularitySplitHint, isPlanShapeQuestion, isTooCoars
 import { mandatesTestsInSameChange, rewriteBatchTestPlan } from './batch-test-task.js';
 import { REQUIREMENT_EXTRACT_PROMPT, COVERAGE_MAP_PROMPT, parseRequirementLines, keepGroundedRequirements, capRequirements, writeOwnedRequirements, enumerateObligationPassages, uncoveredPassages, extractionRetryHint, parseCoverageMap, accountCoverage, isCrossCuttingRequirement, appendCarriedRequirements, buildRequirementsLedger } from './requirements.js';
 import { groundedCoverage } from './coverage-loop.js';
-import { buildOptionCards, resolveAnswer } from './question-dialog.js';
+import { settleQuestion } from './question-dialog.js';
 import { TERMINAL_OUTCOMES, formatAt, formatWhy } from './terminal-outcome.js';
 import { findSpecDanglingArtifacts, titlesCoverArtifact, danglingMissingText, danglingCarryText } from './artifact-closure.js';
 import { LAUNCH_EXTRACT_PROMPT, enumerateScriptCandidates, parseScriptLines, keepGroundedScripts, appendDeclaredScripts } from './launch-contract.js';
@@ -149,12 +149,28 @@ function mentionPath(token) {
  * default level. It is also the only channel the plan phase has: it runs before
  * any task file, hence any `TASK_NNNN-debug.log`, exists.
  */
+/**
+ * Every plan-debug write not yet on disk, chained.
+ *
+ * Fire-and-forget is right for production — a plan must never wait on its own
+ * trail — but it leaves nothing to synchronise on, and the twelve tests that
+ * read `plan-debug.log` back were racing the append that writes it. They failed
+ * intermittently on ENOENT, ~4ms in, at a rate that moved with how many other
+ * files the suite was running beside them. Chaining also serialises concurrent
+ * appends, which is what keeps a line whole.
+ */
+let planDebugChain = Promise.resolve();
+/** Wait for every plan-debug line written so far to reach disk. Tests only. */
+export function flushPlanDebug() {
+    return planDebugChain;
+}
 function logPlanDebug(cwd, msg) {
     if (!shouldLogDebug('event', debugLogLevel()))
         return;
     const line = `${new Date().toISOString()} ${msg}\n`;
     const dir = tasksDir(cwd);
-    fsp.mkdir(dir, { recursive: true })
+    planDebugChain = planDebugChain
+        .then(() => fsp.mkdir(dir, { recursive: true }))
         .then(() => fsp.appendFile(path.join(dir, 'plan-debug.log'), line))
         .catch(() => { });
 }
@@ -559,56 +575,27 @@ export async function elicitClarifications(ctx, cwd, deps, oriented) {
             transcript.add('auto-resolved', plainQ, autoResolved);
             continue;
         }
-        const plainSuggested = suggested === undefined ? undefined : stripInlineMarkdown(suggested);
-        const plainAlt = alt === undefined ? undefined : stripInlineMarkdown(alt);
         // YOLO: take the recommended option (index 0 / the green card) without ever
         // building the prompt. Clarify has no anti-synthesis channel — it runs before
         // any research — so the only step-aside here is a question that carries no
         // recommendation to take; that one is skipped rather than guessed.
-        const yolo = yoloPickAnswer(isYoloMode(), {
-            ...(plainSuggested !== undefined && { suggested: plainSuggested }),
-            ...(plainAlt !== undefined && { alt: plainAlt })
-        });
-        if (yolo !== null) {
-            if (yolo.kind === 'answer')
-                transcript.add('yolo', plainQ, yolo.answer);
-            else
-                transcript.add('yolo-skip', plainQ, `(skipped — ${yolo.note})`);
-            continue;
-        }
-        // The picker cards and the reply mapping are shared with /task's grill
-        // phase and the plan session (question-dialog.ts) — all three used to
-        // write them out, and had drifted.
-        const pending = {
+        const outcome = await settleQuestion({
+            ui,
+            transcript,
             plain: plainQ,
             shown: shownQ,
-            ...(plainSuggested !== undefined && {
-                suggested: plainSuggested,
-                shownSuggested: renderInlineMarkdown(suggested, theme)
-            }),
-            ...(plainAlt !== undefined && {
-                alt: plainAlt,
-                shownAlt: renderInlineMarkdown(alt, theme)
+            ...(suggested !== undefined && { suggested }),
+            ...(alt !== undefined && { alt }),
+            render: md => renderInlineMarkdown(md, theme),
+            yolo: yoloPickAnswer(isYoloMode(), {
+                ...(suggested !== undefined && { suggested: stripInlineMarkdown(suggested) }),
+                ...(alt !== undefined && { alt: stripInlineMarkdown(alt) })
             })
-        };
-        const options = buildOptionCards(pending);
-        const a = await ui.ask({
-            localTitle: shownQ,
-            displayQuestion: shownQ,
-            question: plainQ,
-            recommended: plainSuggested,
-            ...(plainAlt !== undefined && { recommended2: plainAlt }),
-            allowSkip: plainSuggested === undefined && plainAlt === undefined,
-            ...(options && { options })
         });
-        if (a === undefined) {
+        if (outcome === 'cancelled') {
             announceDone(ctx, '/task-auto cancelled.', 'warning');
             return null;
         }
-        // An accept covers both routes to it: submitting empty, and pressing the
-        // single green card. The suffix is the policy's, not this call site's.
-        const resolved = resolveAnswer(pending, a);
-        transcript.add(resolved.source === 'accepted' ? 'accepted' : 'typed', plainQ, resolved.answer);
     }
     if (transcript.length === 0) {
         ctx.ui.notify('No clarifying questions needed — planning tasks…', 'info');