@mjasnikovs/pi-task 0.38.31 → 0.39.0

package/dist/task/research-worker.d.ts

@@ -24,7 +24,7 @@ import type { DebugLine } from './debug-log.js';
 /**
  * One research worker's row. `section` is the heading its output is assembled
  * and cached under; `label` is its child NAME — what the loader and the debug
- * trail print, and the key into `REASONING_GROUP_BY_CHILD` (config/reasoning.ts).
+ * trail print, and the key into `GROUP_BY_CHILD` (config/groups.ts).
  */
 export interface ResearchWorkerSpec {
     section: string;
@@ -72,7 +72,7 @@ export interface ResearchWorkerRun {
     signal: AbortSignal;
     spawn?: SpawnFn;
     /** The `--thinking` fragment for a named child. */
-    thinkingFor: (label: string) => string[];
+    groupArgsFor: (label: string) => string[];
     logDebug?: (msg: string, kind?: DebugLine) => void;
     onChildOutput?: (line: string) => void;
     /** Record one finished worker's timing splits. */

package/dist/task/research-worker.js

@@ -241,7 +241,7 @@ export async function runResearchWorker(spec, run, prior = []) {
         // config/reasoning.ts is where each one's level lives, so this
         // line decides what THIS worker runs at for a default-mode
         // user.
-        thinking: run.thinkingFor(spec.label),
+        groupArgs: run.groupArgsFor(spec.label),
         ...(spec.tools ? { tools: spec.tools } : {}),
         ...(spec.extensions ? { extensions: spec.extensions } : {}),
         // The three lever spreads that would otherwise sit here are the

package/dist/workers/docs-core.js

@@ -11,7 +11,7 @@ import { runChild } from '../shared/child-process.js';
 import { docsLookup } from './docs-lookup.js';
 import { buildExtractionPrompt } from './abstention.js';
 import {} from '../shared/child-output.js';
-import { groupThinkingArgs } from '../config/reasoning-args.js';
+import { groupChildArgs } from '../config/group-args.js';
 const DEFAULT_LIMIT = PACKAGE_RETRIEVE_LIMIT;
 const DEFAULT_BUDGET = RETRIEVE_CONTENT_BUDGET;
 const NO_CACHE_HEAD = 25_000;
@@ -550,7 +550,7 @@ export async function docsFocused(input) {
         spawn,
         // The `extraction` group's level. Resolved at the call site so neither
         // the lookup nor the extractor reads ambient config.
-        thinking: groupThinkingArgs('extraction')
+        groupArgs: groupChildArgs('extraction')
     });
     const extraction = r.extraction;
     const base = {

package/dist/workers/docs-lookup.d.ts

@@ -36,10 +36,11 @@ export interface DocsLookupInput {
     signal?: AbortSignal;
     spawn?: SpawnFn;
     /**
-     * The `extraction` group's `--thinking` fragment. Resolved by the CALLER so
-     * this module — like the extractor it wraps — never reads ambient config.
+     * The `extraction` group's argv fragment — its model and its thinking level.
+     * Resolved by the CALLER so this module, like the extractor it wraps, never
+     * reads ambient config.
      */
-    thinking: readonly string[];
+    groupArgs: readonly string[];
 }
 export type DocsLookup = {
     kind: 'answer';

package/dist/workers/docs-lookup.js

@@ -28,7 +28,7 @@ export async function docsLookup(input) {
         cwd: input.cwd,
         signal: input.signal,
         spawn: input.spawn,
-        thinking: input.thinking,
+        groupArgs: input.groupArgs,
         abortedMessage: input.corpus.abortedMessage
     });
     if (!extraction.ok)

package/dist/workers/fetch-core.js

@@ -2,7 +2,7 @@ import { fetchAndClean as defaultFetchAndClean } from './html-clean.js';
 import { runFocusedExtraction } from './focused-extractor.js';
 import { abstentionSentence } from './abstention.js';
 import {} from '../shared/child-output.js';
-import { groupThinkingArgs } from '../config/reasoning-args.js';
+import { groupChildArgs } from '../config/group-args.js';
 const CONTENT_BUDGET = 30_000;
 const HEAD_CHARS = 25_000;
 const TAIL_CHARS = 5_000;
@@ -79,7 +79,7 @@ export async function fetchFocused(input) {
         spawn: input.spawn,
         // The `extraction` group's level. Resolved at the call site so the
         // extractor itself never reads ambient config.
-        thinking: groupThinkingArgs('extraction'),
+        groupArgs: groupChildArgs('extraction'),
         abortedMessage: 'Fetch aborted.'
     });
     const base = {

package/dist/workers/focused-extractor.d.ts

@@ -3,12 +3,13 @@ import { type ExcerptVerification } from '../shared/child-output.js';
 /**
  * The argv every focused extraction child runs with: the shared child base — any whitelisted
  * extensions, then `--print --no-skills --no-extensions --no-prompt-templates
- * --no-context-files --no-session` — then the caller's thinking fragment, then `--no-tools`.
+ * --no-context-files --no-session` — then the caller's group fragment (its model and its
+ * thinking level), then `--no-tools`.
  *
  * `--no-tools` is the contract, not a default: the child is given all the content it may use
  * inside its prompt, so a tool call could only reach for something unsourced.
  */
-export declare const focusedChildArgs: (thinking?: readonly string[]) => string[];
+export declare const focusedChildArgs: (groupArgs?: readonly string[]) => string[];
 export interface FocusedRequest {
     /** The fully assembled prompt, including the content block. Delivered on stdin. */
     prompt: string;
@@ -42,7 +43,7 @@ export interface FocusedRequest {
      * `focusedChildArgs` read ambient config, and a function that reads config
      * internally cannot be tested without the developer's own machine state.
      */
-    thinking?: readonly string[];
+    groupArgs?: readonly string[];
 }
 /** What every outcome carries, success or failure — the raw child evidence. */
 interface FocusedChildEvidence {

package/dist/workers/focused-extractor.js

@@ -29,14 +29,15 @@ import { formatChildFailure } from './shared.js';
 /**
  * The argv every focused extraction child runs with: the shared child base — any whitelisted
  * extensions, then `--print --no-skills --no-extensions --no-prompt-templates
- * --no-context-files --no-session` — then the caller's thinking fragment, then `--no-tools`.
+ * --no-context-files --no-session` — then the caller's group fragment (its model and its
+ * thinking level), then `--no-tools`.
  *
  * `--no-tools` is the contract, not a default: the child is given all the content it may use
  * inside its prompt, so a tool call could only reach for something unsourced.
  */
-export const focusedChildArgs = (thinking = []) => [
+export const focusedChildArgs = (groupArgs = []) => [
     ...childBaseArgs(),
-    ...thinking,
+    ...groupArgs,
     '--no-tools'
 ];
 /**
@@ -49,7 +50,7 @@ export const focusedChildArgs = (thinking = []) => [
  */
 export async function runFocusedExtraction(req) {
     const spawn = req.spawn ?? defaultSpawn;
-    const invocation = getPiInvocation(focusedChildArgs(req.thinking), req.prompt);
+    const invocation = getPiInvocation(focusedChildArgs(req.groupArgs), req.prompt);
     const child = await runChild(spawn, invocation, req.cwd, req.signal);
     const evidence = {
         exitCode: child.exitCode,

package/dist/workers/index.js

@@ -4,6 +4,7 @@ import { registerPiWorkerFetch } from './pi-worker-fetch.js';
 import { registerPiWorkerDocs } from './pi-worker-docs.js';
 import { registerBraveKeyWarning } from './brave-warning.js';
 import { registerReasoningWarning } from './reasoning-warning.js';
+import { registerModelWarning } from './model-warning.js';
 export function registerWorkers(pi) {
     registerPiWorker(pi);
     registerPiWorkerSearch(pi);
@@ -11,4 +12,5 @@ export function registerWorkers(pi) {
     registerPiWorkerDocs(pi);
     registerBraveKeyWarning(pi);
     registerReasoningWarning(pi);
+    registerModelWarning(pi);
 }

package/dist/workers/model-warning.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Resolve every model cell ONCE per session, and say what does not work.
+ *
+ * WHY HERE AND NOT AT ARGV TIME
+ * -----------------------------
+ * 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` at all, and the answer cannot be read from disk either: models.json plus
+ * models-store.json are only part of the catalogue, since pi-ai ships built-in
+ * lists for 39 providers and this project does not depend on pi-ai. So it is
+ * asked at `session_start`, where ctx exists and every task is still in the
+ * future, and the verdict is left in group-args.ts for the producers to consult.
+ *
+ * WHY DROPPING THE FLAG IS THE RIGHT DEGRADE
+ * ------------------------------------------
+ * A spec whose model is gone but whose PROVIDER still has other models does not
+ * make pi exit. `buildFallbackModel` invents a synthetic model id, forces
+ * `reasoning: true` onto it, inherits the provider's default baseUrl, and
+ * answers at exit 0 — so the child silently runs a model nobody chose. Dropping
+ * the flag runs the child exactly as it ran last week and names the cell.
+ *
+ * A SEPARATE hint from the reasoning one, with its own widget key: the two have
+ * different fixes (`models.json` vs `/task-config`) and that line is already at
+ * its length budget.
+ */
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { type ChildGroup } from '../config/groups.js';
+/** One cell that will not do what it says. */
+export interface ModelProblem {
+    group: ChildGroup;
+    spec: string;
+    /**
+     * `unresolved` — no such model here, so the flag is dropped.
+     * `extension` — resolvable only because a host extension registered its
+     * provider. Children run `--no-extensions`, which disables DISCOVERY only,
+     * so it works exactly when that extension is in the child whitelist. We
+     * cannot tell which extension registered it: `getRegisteredProviderIds()`
+     * gives ids, and the `{name, config, extensionPath}` triples live in the
+     * runner's internal state. So this is a warning, not a drop — and getting it
+     * wrong fails loudly anyway, since the child's resolver reports "not found"
+     * and exits 1.
+     */
+    why: 'unresolved' | 'extension';
+}
+/** The registry questions this needs, so a test can answer them with a literal. */
+export interface ModelLookup {
+    find: (provider: string, id: string) => unknown;
+    extensionProviders: ReadonlySet<string>;
+}
+export declare function findModelProblems(lookup: ModelLookup, specs: Readonly<Record<ChildGroup, string>>): ModelProblem[];
+/**
+ * The hint line, or null when every cell is fine.
+ *
+ * Names at most two cells per cause and appends `(+N more)`, the same budget the
+ * reasoning line keeps and for the same reason.
+ */
+export declare function formatModelWarning(problems: readonly ModelProblem[]): string | null;
+export declare function registerModelWarning(pi: ExtensionAPI, 
+/** Injected by tests, which must not depend on the developer's saved config. */
+readSpecs?: () => Readonly<Record<ChildGroup, string>>): void;
+/**
+ * Answer, once, what every model cell resolves to — and leave both answers where
+ * the code that has no `ctx` can read them.
+ *
+ * `unresolved` only feeds the argv drop: an extension-provided model may well
+ * work, since children load explicitly whitelisted extensions, and dropping its
+ * flag would break a config that is merely fragile.
+ */
+export declare function resolveModelCells(ctx: ExtensionContext, specs: Readonly<Record<ChildGroup, string>>): ModelProblem[];

package/dist/workers/model-warning.js

@@ -0,0 +1,113 @@
+import { getConfig } from '../config/config.js';
+import { setGroupWindows, setUnusableSpecs } from '../config/group-args.js';
+import { MODEL_INHERIT, splitSpec } from '../config/group-models.js';
+import { CHILD_GROUPS } from '../config/groups.js';
+import { contextWindowForSpec } from '../task/context-usage.js';
+import { registerSessionHint } from './session-hint.js';
+const WIDGET_KEY = 'pi-task-model-warning';
+export function findModelProblems(lookup, specs) {
+    const out = [];
+    for (const group of CHILD_GROUPS) {
+        const spec = specs[group];
+        if (spec === MODEL_INHERIT)
+            continue;
+        const parts = splitSpec(spec);
+        if (!parts || lookup.find(parts.provider, parts.id) === undefined) {
+            out.push({ group, spec, why: 'unresolved' });
+            continue;
+        }
+        if (lookup.extensionProviders.has(parts.provider)) {
+            out.push({ group, spec, why: 'extension' });
+        }
+    }
+    return out;
+}
+/**
+ * The hint line, or null when every cell is fine.
+ *
+ * Names at most two cells per cause and appends `(+N more)`, the same budget the
+ * reasoning line keeps and for the same reason.
+ */
+export function formatModelWarning(problems) {
+    if (problems.length === 0)
+        return null;
+    const list = (why) => {
+        const hits = problems.filter(p => p.why === why);
+        const shown = hits.slice(0, 2).map(p => `${p.group}→${p.spec}`);
+        return shown.join(', ') + (hits.length > 2 ? ` (+${hits.length - 2} more)` : '');
+    };
+    const parts = [];
+    if (problems.some(p => p.why === 'unresolved')) {
+        parts.push(`no such model here — ${list('unresolved')}. Those steps run on pi's default `
+            + 'instead; fix the entry in ~/.pi/agent/models.json or pick another model in '
+            + '/task-config');
+    }
+    if (problems.some(p => p.why === 'extension')) {
+        parts.push(`provider comes from an extension — ${list('extension')}. Children run `
+            + '--no-extensions, so add that extension under "child extensions" in '
+            + '/task-config or those steps exit 1');
+    }
+    return `⚠ pi-task models: ${parts.join('. Also: ')}`;
+}
+export function registerModelWarning(pi, 
+/** Injected by tests, which must not depend on the developer's saved config. */
+readSpecs = () => getConfig().groupModels) {
+    // TWO handlers, deliberately. The resolution pass must run in EVERY mode:
+    // `registerSessionHint` returns early when `ctx.mode !== 'tui'`, so folding
+    // this into it would leave the argv drop and the churn windows disarmed for
+    // every headless and `--print` run — a guard that only works when someone is
+    // watching is not a guard.
+    pi.on('session_start', (_event, ctx) => {
+        resolveModelCells(ctx, readSpecs());
+    });
+    registerSessionHint(pi, WIDGET_KEY, ctx => {
+        const text = formatModelWarning(findModelProblems(lookupFor(ctx), readSpecs()));
+        return text === null ? null : { text };
+    });
+}
+/**
+ * Answer, once, what every model cell resolves to — and leave both answers where
+ * the code that has no `ctx` can read them.
+ *
+ * `unresolved` only feeds the argv drop: an extension-provided model may well
+ * work, since children load explicitly whitelisted extensions, and dropping its
+ * flag would break a config that is merely fragile.
+ */
+export function resolveModelCells(ctx, specs) {
+    const problems = findModelProblems(lookupFor(ctx), specs);
+    setUnusableSpecs(problems.filter(p => p.why === 'unresolved').map(p => p.spec));
+    // The SAME walk fills the window table, so the argv and the churn rule can
+    // never disagree about which model a group runs on.
+    //
+    // An `inherit` cell gets NO entry, not the parent's window. Storing one
+    // would freeze a session_start snapshot in front of the live per-run value,
+    // so a user who switches the session model with Ctrl+P to a bigger one would
+    // have every child judged against the old window — the churn rule then fires
+    // early and kills a healthy child.
+    //
+    // The whole walk is guarded because `ctx.model` and `ctx.modelRegistry` are
+    // GETTERS that call `assertActive()` and throw on a stale context. Losing the
+    // windows must not also lose the `setUnusableSpecs` above it, nor the hint.
+    try {
+        setGroupWindows(Object.fromEntries(CHILD_GROUPS.filter(g => specs[g] !== MODEL_INHERIT).map(g => [g, contextWindowForSpec(ctx, specs[g])])));
+    }
+    catch {
+        setGroupWindows({});
+    }
+    return problems;
+}
+function lookupFor(ctx) {
+    try {
+        const registry = ctx.modelRegistry;
+        return {
+            find: (provider, id) => registry.find(provider, id),
+            extensionProviders: new Set(registry.getRegisteredProviderIds())
+        };
+    }
+    catch {
+        // A registry that cannot answer must not condemn every cell. Claiming
+        // every spec is unresolved would drop every --model flag on a session
+        // whose runtime simply was not ready.
+        return { find: () => ({}), extensionProviders: new Set() };
+    }
+}

package/dist/workers/pi-worker-core.d.ts

@@ -157,15 +157,15 @@ export interface RunWorkerInput {
         promptCharsBefore: number;
     }) => void;
     /**
-     * An already-resolved `['--thinking', level]` fragment, or `[]`/omitted to
-     * inherit the session default exactly as before.
+     * An already-resolved group fragment — `--model` then `--thinking` — or
+     * `[]`/omitted to inherit both defaults exactly as before.
      *
-     * Resolved by the CALLER because runWorker serves three different reasoning
-     * groups — the research workers, the post-implementation gates, and the
-     * ad-hoc `pi-worker` tool — and has nothing in its input that tells them
-     * apart. Guessing here would give a verify gate the research workers' level.
+     * Resolved by the CALLER because runWorker serves three different groups —
+     * the research workers, the post-implementation gates, and the ad-hoc
+     * `pi-worker` tool — and has nothing in its input that tells them apart.
+     * Guessing here would give a verify gate the research workers' model.
      */
-    thinking?: readonly string[];
+    groupArgs?: readonly string[];
     /**
      * Called once per DISCARDED attempt, at the moment the worker decides to
      * re-spawn — the only window in which a restart is observable at all.

package/dist/workers/pi-worker-core.js

@@ -8,7 +8,8 @@ import { LoopDetector, MAX_LOOP_RESTARTS } from '../task/loop-detector.js';
 import { StallDetector, formatStallHint } from '../task/stall-detector.js';
 import { formatLoopHint, isConnectionError, connectionRetryBackoffMs } from '../task/child-runner.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
-import { discoverModelEndpoints, probeModelEndpoints } from '../shared/model-endpoint.js';
+import { childModelEndpoints, probeModelEndpoints } from '../shared/model-endpoint.js';
+import { modelSpecFromArgs } from '../config/group-models.js';
 import { streamStallHint } from '../shared/stream-watchdog.js';
 import { classifyWorkerFailure } from './worker-failure.js';
 import { CARRY_FORWARD_IDS, RESTART_ORDER } from './worker-kill.js';
@@ -344,7 +345,7 @@ export async function runWorker(input) {
     // moments before close and leave workMs at nearly zero.
     const baseArgs = [
         ...childBaseArgs(input.extensions ?? []),
-        ...(input.thinking ?? []),
+        ...(input.groupArgs ?? []),
         '--mode',
         'json',
         '--tools',
@@ -449,7 +450,7 @@ export async function runWorker(input) {
                             // Kept as data so a resolved policy stays plain
                             // comparable data — see StalledGuard.probe.
                             probe: guards.stalled.probe
-                                ?? (() => probeModelEndpoints(discoverModelEndpoints()))
+                                ?? (() => probeModelEndpoints(childModelEndpoints(modelSpecFromArgs(input.groupArgs ?? []))))
                         }
                     }),
                 ...(guards['stream-stall'] ? { streamInactivityMs: guards['stream-stall'] } : {}),

package/dist/workers/pi-worker-docs.js

@@ -16,7 +16,7 @@ import { normalizeQuery } from './research-cache.js';
 import { projectDocsRaw } from './docs-project.js';
 import { projectDocsBudget, projectDocsBudgetExhausted } from '../task/research-fanout-budget.js';
 import { isAbstention } from './abstention.js';
-import { groupThinkingArgs } from '../config/reasoning-args.js';
+import { groupChildArgs } from '../config/group-args.js';
 const RENDER_QUERY_MAX = 100;
 const Params = Type.Object({
     module: Type.String({
@@ -139,7 +139,7 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 cwd: ctx.cwd,
                 signal,
                 spawn,
-                thinking: groupThinkingArgs('extraction')
+                groupArgs: groupChildArgs('extraction')
             });
             // ── Project source lookup ───────────────────────────────────────
             if (params.module === '.') {

package/dist/workers/pi-worker.js

@@ -14,9 +14,9 @@
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from '@sinclair/typebox';
 import { getConfig } from '../config/config.js';
-import { groupThinkingArgs } from '../config/reasoning-args.js';
+import { groupChildArgs } from '../config/group-args.js';
 import { runWorker } from './pi-worker-core.js';
-import { getParentContextWindow } from '../task/context-usage.js';
+import { contextWindowForGroup } from '../task/context-usage.js';
 import { childFailureReason, formatChildFailure, makeWorkerTool, workerAnswer, workerUnavailable } from './shared.js';
 const RENDER_PROMPT_MAX = 120;
 const WorkerParams = Type.Object({
@@ -66,8 +66,8 @@ export function registerPiWorker(pi) {
                 // this codebase passes `-m`, so the parent's model IS the child's
                 // model and its window is the honest one. Without this the churn
                 // rule cannot fire — see RunWorkerInput.contextWindow.
-                contextWindow: getParentContextWindow(ctx) || 'unknown',
-                thinking: groupThinkingArgs('research')
+                contextWindow: contextWindowForGroup(ctx, 'research') || 'unknown',
+                groupArgs: groupChildArgs('research')
             });
             const details = { exitCode: result.exitCode };
             const failure = formatChildFailure(result, 'Worker aborted.');

package/dist/workers/reasoning-warning.d.ts

@@ -20,19 +20,22 @@
  * silences it: an all-`inherit` table yields no mismatches for any model.
  */
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import { type GroupSetting, type ReasoningGroup } from '../config/reasoning.js';
+import { type GroupSetting, type ChildGroup } from '../config/reasoning.js';
 import { type ReasoningMismatch } from '../shared/reasoning-capability.js';
 import { type ChatTemplateCaps } from '../shared/model-endpoint.js';
 /**
  * The warning line for a set of mismatches.
  *
- * Names the MODEL it checked, because children carry no `-m` and resolve pi's
- * default model, which need not be the host session's — a warning that does not
- * say what it looked at cannot be acted on. Names at most two groups and appends
- * `(+N more)` only when there are more than two, since a line long enough to list
- * every group is a line nobody reads. Null when nothing mismatched.
+ * Each item names its OWN model — `phase@acme/small medium→off` — because groups
+ * can now run on different ones. A single leading `model "X" will not run …`
+ * would be a lie about what was checked the moment two groups differ, and a
+ * warning that misdescribes its own subject cannot be acted on.
+ *
+ * Names at most two groups and appends `(+N more)` only when there are more than
+ * two, since a line long enough to list every group is a line nobody reads. Null
+ * when nothing mismatched.
  */
-export declare function formatReasoningWarning(modelName: string, mismatches: readonly ReasoningMismatch[]): string | null;
+export declare function formatReasoningWarning(mismatches: readonly ReasoningMismatch[]): string | null;
 /**
  * The extra cause line, when the SERVER disagrees with models.json.
  *
@@ -49,11 +52,16 @@ export declare function registerReasoningWarning(pi: ExtensionAPI,
  * `session_start` so a /task-config change since the last session counts.
  * Injected by tests, which must not depend on the developer's saved config.
  */
-readSettings?: () => Readonly<Record<ReasoningGroup, GroupSetting>>, 
+readSettings?: () => Readonly<Record<ChildGroup, GroupSetting>>, 
 /**
  * The server-side chat-template probe. Injected so the REFINE path — the
  * only half of this hint that talks to a network — is drivable at all; with
  * the real probe it is reachable only from a model entry carrying a
  * `baseUrl`, which no test model has.
  */
-probe?: (baseUrl: string) => Promise<ChatTemplateCaps | null>): void;
+probe?: (baseUrl: string) => Promise<ChatTemplateCaps | null>, 
+/**
+ * Which model each group runs on. Injected for the same reason `readSettings`
+ * is: a test must not depend on the developer's saved config.
+ */
+readSpecs?: () => Readonly<Record<ChildGroup, string>>): void;

package/dist/workers/reasoning-warning.js

@@ -22,27 +22,31 @@
 import { getConfig } from '../config/config.js';
 import { effectiveReasoning } from '../config/reasoning.js';
 import { reasoningMismatches } from '../shared/reasoning-capability.js';
+import { MODEL_INHERIT, splitSpec } from '../config/group-models.js';
 import { probeChatTemplateCaps } from '../shared/model-endpoint.js';
 import { registerSessionHint } from './session-hint.js';
 const WIDGET_KEY = 'pi-task-reasoning-warning';
 /**
  * The warning line for a set of mismatches.
  *
- * Names the MODEL it checked, because children carry no `-m` and resolve pi's
- * default model, which need not be the host session's — a warning that does not
- * say what it looked at cannot be acted on. Names at most two groups and appends
- * `(+N more)` only when there are more than two, since a line long enough to list
- * every group is a line nobody reads. Null when nothing mismatched.
+ * Each item names its OWN model — `phase@acme/small medium→off` — because groups
+ * can now run on different ones. A single leading `model "X" will not run …`
+ * would be a lie about what was checked the moment two groups differ, and a
+ * warning that misdescribes its own subject cannot be acted on.
+ *
+ * Names at most two groups and appends `(+N more)` only when there are more than
+ * two, since a line long enough to list every group is a line nobody reads. Null
+ * when nothing mismatched.
  */
-export function formatReasoningWarning(modelName, mismatches) {
+export function formatReasoningWarning(mismatches) {
     if (mismatches.length === 0)
         return null;
     const shown = mismatches
         .slice(0, 2)
-        .map(m => `${m.group} ${m.wanted}→${m.actual}`)
+        .map(m => `${m.group}@${m.modelName} ${m.wanted}→${m.actual}`)
         .join(', ');
     const rest = mismatches.length > 2 ? ` (+${mismatches.length - 2} more)` : '';
-    return (`⚠ pi-task: model "${modelName}" will not run the reasoning levels /task-config asks `
+    return ('⚠ pi-task: some steps will not run the reasoning levels /task-config asks '
         + `for — ${shown}${rest}. pi clamps to what the model declares. Fix "reasoning" / `
         + '"thinkingLevelMap" for it in ~/.pi/agent/models.json, or set those steps back to '
         + '"inherit" in /task-config');
@@ -82,31 +86,74 @@ readSettings = () => effectiveReasoning(getConfig()),
  * the real probe it is reachable only from a model entry carrying a
  * `baseUrl`, which no test model has.
  */
-probe = probeChatTemplateCaps) {
+probe = probeChatTemplateCaps, 
+/**
+ * Which model each group runs on. Injected for the same reason `readSettings`
+ * is: a test must not depend on the developer's saved config.
+ */
+readSpecs = () => getConfig().groupModels) {
     registerSessionHint(pi, WIDGET_KEY, ctx => {
-        const model = ctx.model;
-        const mismatches = reasoningMismatches(model, readSettings());
-        if (mismatches.length === 0)
-            return null;
-        const base = formatReasoningWarning(model?.name ?? model?.id ?? 'unknown', mismatches);
+        const facts = (g) => groupModelFacts(ctx, readSpecs()[g]);
+        const mismatches = reasoningMismatches(facts, readSettings());
+        const base = formatReasoningWarning(mismatches);
         if (base === null)
             return null;
         // Fire-and-forget: the server probe only ever REFINES the cause line, so it
         // must not delay the warning or be able to prevent it. `probeChatTemplateCaps`
         // carries its own short timeout and returns null on any failure, so a
         // backend that does not answer `/props` costs nothing.
-        const baseUrl = model?.baseUrl;
-        if (model === undefined || baseUrl === undefined || baseUrl === '')
+        //
+        // One probe per DISTINCT baseUrl among the mismatching groups, not one
+        // per group: eleven groups usually collapse to one or two servers, and
+        // four research workers on one server would otherwise print the same
+        // sentence four times. `allSettled`, so one dead endpoint cannot blank
+        // the line for the others.
+        const probes = distinctBackends(mismatches, facts);
+        if (probes.length === 0)
             return { text: base };
-        const declares = model.reasoning;
         return {
             text: base,
-            refine: probe(baseUrl).then(caps => {
-                if (caps === null)
-                    return null;
-                const extra = formatCapabilityConflict(caps.supportsReasoningEffort, declares);
-                return extra === null ? null : base + extra;
+            refine: Promise.allSettled(probes.map(async (b) => {
+                const caps = await probe(b.baseUrl);
+                return caps === null ? null : (formatCapabilityConflict(caps.supportsReasoningEffort, b.declares));
+            })).then(results => {
+                const causes = new Set(results.flatMap(r => r.status === 'fulfilled' && r.value !== null ? [r.value] : []));
+                return causes.size === 0 ? null : base + [...causes].join('');
             })
         };
     });
 }
+/** What one group runs on, as {@link reasoningMismatches} wants it. */
+function groupModelFacts(ctx, spec) {
+    // `inherit` is the session's model. That is decision 3 of the model table —
+    // children are NOT switched to follow the host — and the honest value is
+    // settings.json's default, which need not be the session's. Naming the
+    // session's model is still the better of the two: it is the one the user can
+    // see, and on every machine with one provider the two agree.
+    const model = spec === MODEL_INHERIT ?
+        ctx.model
+        : (() => {
+            const parts = splitSpec(spec);
+            return parts ? ctx.modelRegistry.find(parts.provider, parts.id) : undefined;
+        })();
+    if (!model)
+        return undefined;
+    return {
+        name: model.name || model.id,
+        reasoning: model.reasoning,
+        ...(model.thinkingLevelMap === undefined ? {} : { thinkingLevelMap: model.thinkingLevelMap }),
+        ...(model.baseUrl ? { baseUrl: model.baseUrl } : {})
+    };
+}
+/** The distinct servers behind a set of mismatches, deduped by URL. */
+function distinctBackends(mismatches, facts) {
+    const byUrl = new Map();
+    for (const m of mismatches) {
+        const f = facts(m.group);
+        if (!f?.baseUrl)
+            continue;
+        if (!byUrl.has(f.baseUrl))
+            byUrl.set(f.baseUrl, { baseUrl: f.baseUrl, declares: f.reasoning });
+    }
+    return [...byUrl.values()];
+}

package/package.json

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