@mjasnikovs/pi-task 0.38.30 → 0.38.32

package/dist/task/loop-detector.d.ts

@@ -12,7 +12,19 @@
  *
  * Either pattern returns a LoopHit so the caller can kill the child and re-spawn
  * with a hint. No I/O. No imports from index.ts. Trivially unit-testable.
+ *
+ * The three tuning constants live here rather than in child-runner.ts because
+ * worker-profiles.ts reads them at module top level to build DEFAULT_LOOP_DETECTOR.
+ * From child-runner.ts that is a cycle — child-runner → worker-profiles →
+ * child-runner — and the failure is a TDZ ReferenceError on import order, which
+ * no compile step catches. This module imports nothing, so it cannot close one.
  */
+/** Recent tool calls the exact-repeat rule looks back over. */
+export declare const LOOP_WINDOW = 20;
+/** Repeats of one key within the window that trip the detector. */
+export declare const LOOP_THRESHOLD = 5;
+/** Re-spawns allowed after a loop kill — 3 attempts total with the initial one. */
+export declare const MAX_LOOP_RESTARTS = 2;
 export interface ToolCall {
     name: string;
     args: unknown;
@@ -27,6 +39,12 @@ export interface LoopHit {
  * Arrays preserve their order (positional). undefined / primitives passthrough.
  */
 export declare function stableStringify(value: unknown): string;
+/**
+ * The exact-match identity of a tool call. Exported because implementation-guards.ts
+ * keys its own per-call strike count on it, and a second hand-written copy of this
+ * expression is free to drift away from the one `record` uses.
+ */
+export declare function loopKey(call: ToolCall): string;
 /**
  * The primary file path a tool call targets, mirroring summarizeToolArgs' field
  * precedence. Returns null when the call names no path (e.g. bash, or a grep

package/dist/task/loop-detector.js

@@ -12,7 +12,19 @@
  *
  * Either pattern returns a LoopHit so the caller can kill the child and re-spawn
  * with a hint. No I/O. No imports from index.ts. Trivially unit-testable.
+ *
+ * The three tuning constants live here rather than in child-runner.ts because
+ * worker-profiles.ts reads them at module top level to build DEFAULT_LOOP_DETECTOR.
+ * From child-runner.ts that is a cycle — child-runner → worker-profiles →
+ * child-runner — and the failure is a TDZ ReferenceError on import order, which
+ * no compile step catches. This module imports nothing, so it cannot close one.
  */
+/** Recent tool calls the exact-repeat rule looks back over. */
+export const LOOP_WINDOW = 20;
+/** Repeats of one key within the window that trip the detector. */
+export const LOOP_THRESHOLD = 5;
+/** Re-spawns allowed after a loop kill — 3 attempts total with the initial one. */
+export const MAX_LOOP_RESTARTS = 2;
 /**
  * JSON.stringify with sorted object keys so {a:1,b:2} and {b:2,a:1} hash equal.
  * Arrays preserve their order (positional). undefined / primitives passthrough.
@@ -28,6 +40,14 @@ export function stableStringify(value) {
         return sorted;
     });
 }
+/**
+ * The exact-match identity of a tool call. Exported because implementation-guards.ts
+ * keys its own per-call strike count on it, and a second hand-written copy of this
+ * expression is free to drift away from the one `record` uses.
+ */
+export function loopKey(call) {
+    return `${call.name}\x00${stableStringify(call.args)}`;
+}
 /**
  * The primary file path a tool call targets, mirroring summarizeToolArgs' field
  * precedence. Returns null when the call names no path (e.g. bash, or a grep
@@ -78,7 +98,7 @@ export class LoopDetector {
     threshold;
     pathThreshold;
     buf = [];
-    constructor(window = 20, threshold = 5, 
+    constructor(window = LOOP_WINDOW, threshold = LOOP_THRESHOLD, 
     /** Revisits of one path needed to trip; defaults to the exact threshold. */
     pathThreshold = threshold) {
         this.window = window;
@@ -87,7 +107,7 @@ export class LoopDetector {
     }
     /** Record a tool call. Returns LoopHit if either threshold is breached, else null. */
     record(call) {
-        const key = `${call.name}\x00${stableStringify(call.args)}`;
+        const key = loopKey(call);
         const offset = readOffset(call.args);
         this.buf.push({ key, path: primaryPath(call.args), offset, end: readEnd(call.args, offset) });
         if (this.buf.length > this.window)

package/dist/task/model-hold-stash.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The crash half of the implementation hold.
+ *
+ * `release()` runs in a `finally`, and a `finally` does not run for SIGKILL, a
+ * segfault, or the power going out. An implementation turn is measured in hours.
+ * Without this, one of those leaves pi's GLOBAL `defaultModel` pointing at the
+ * implementation model — and because children carry no `-m` and resolve that
+ * same default, every child of every future run, in every project, quietly
+ * follows it until the user notices.
+ *
+ * So acquire leaves a note on disk and release removes it. A later session
+ * finds the note and puts the model back.
+ */
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+/**
+ * Both halves of the switch, as `provider/id` strings.
+ *
+ * `applied` is what makes the restore safe to run in a second, unrelated
+ * session: it is the value we are allowed to overwrite, and nothing else.
+ */
+export interface StashRecord {
+    before: string;
+    applied: string;
+}
+/** The seam, so the hold's tests never touch a real home directory. */
+export interface HoldStash {
+    read(): StashRecord | undefined;
+    write(record: StashRecord): void;
+    clear(): void;
+}
+export declare function readHoldStash(): StashRecord | undefined;
+export declare function writeHoldStash(record: StashRecord): void;
+export declare function clearHoldStash(): void;
+/**
+ * Register the crash restore. Runs once per `session_start`, before any task.
+ *
+ * It reaches for `pi.setModel` rather than writing `settings.json` itself:
+ * pi-task has no sanctioned way to write that file, and inventing one would fork
+ * the format. Everything it can go wrong on — no registry, a model that has
+ * since vanished, a rejected auth check — ends the same way, with the note
+ * dropped, because a restore that cannot happen must not re-fire forever.
+ */
+export declare function registerModelHoldRestore(pi: ExtensionAPI): void;

package/dist/task/model-hold-stash.js

@@ -0,0 +1,70 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { splitSpec } from '../config/group-models.js';
+import { defaultModelRef } from '../shared/model-endpoint.js';
+import { stateFile } from '../shared/data-home.js';
+import { restoreHeldModel } from './implementation-hold.js';
+const stashPath = () => stateFile('model-hold.json');
+export function readHoldStash() {
+    try {
+        const j = JSON.parse(fs.readFileSync(stashPath(), 'utf8'));
+        if (typeof j.before !== 'string' || typeof j.applied !== 'string')
+            return undefined;
+        if (j.before === '' || j.applied === '')
+            return undefined;
+        return { before: j.before, applied: j.applied };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeHoldStash(record) {
+    try {
+        const p = stashPath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(record));
+    }
+    catch {
+        // A stash we cannot write costs us the crash restore, not the turn.
+    }
+}
+export function clearHoldStash() {
+    try {
+        fs.rmSync(stashPath(), { force: true });
+    }
+    catch {
+        /* already gone */
+    }
+}
+/**
+ * Register the crash restore. Runs once per `session_start`, before any task.
+ *
+ * It reaches for `pi.setModel` rather than writing `settings.json` itself:
+ * pi-task has no sanctioned way to write that file, and inventing one would fork
+ * the format. Everything it can go wrong on — no registry, a model that has
+ * since vanished, a rejected auth check — ends the same way, with the note
+ * dropped, because a restore that cannot happen must not re-fire forever.
+ */
+export function registerModelHoldRestore(pi) {
+    pi.on('session_start', (_event, ctx) => {
+        const model = {
+            current: () => {
+                const m = ctx.model;
+                return m ? { spec: `${m.provider}/${m.id}`, handle: m } : undefined;
+            },
+            resolve: spec => {
+                const parts = splitSpec(spec);
+                return parts ? ctx.modelRegistry.find(parts.provider, parts.id) : undefined;
+            },
+            apply: handle => pi.setModel(handle)
+        };
+        // The saved default, read from the file the crash left wrong — not from
+        // `ctx.model`, which a `--model` flag or a resumed session can make say
+        // something else entirely.
+        const saved = () => {
+            const ref = defaultModelRef();
+            return ref && `${ref.provider}/${ref.id}`;
+        };
+        void restoreHeldModel(model, saved).catch(() => { });
+    });
+}

package/dist/task/orchestrator.d.ts

@@ -21,9 +21,18 @@ import { type WidgetState } from './widget.js';
 import { type RunTaskFn } from './gate-deps.js';
 import { type GateDeps } from './task-gates.js';
 import { type PhaseSeams } from './child-runner.js';
-import { type ThinkingControl } from './implementation-thinking.js';
+import { type ImplementationControls } from './implementation-hold.js';
 import { type RunEnd } from './run-end.js';
 import { type SuperviseOptions } from './implementation-turn.js';
+/**
+ * pi's own `Model`, named WITHOUT importing `@earendil-works/pi-ai` — which is
+ * neither a dependency, a devDependency nor a peerDependency of this package
+ * (see shared/model-endpoint.ts's header). The context already carries the type,
+ * so deriving it costs nothing and adds no edge to the dependency graph.
+ */
+type PiModel = NonNullable<ExtensionCommandContext['model']>;
+/** Both halves of the implementation hold, over the live session. */
+export declare function piImplementationControls(ctx: ExtensionCommandContext): ImplementationControls<PiModel>;
 /**
  * Everything one TaskRunner needs, as one object. The runner is the shared core
  * under `runSingleTask` (and so under /task-auto's per-task loop), so this is the
@@ -163,11 +172,14 @@ export interface RunSingleTaskOptions extends Pick<TaskRunnerOptions, 'resumeId'
      */
     notifyFinish?: boolean;
     /**
-     * How the implementation turn's thinking level is read and written. Defaults
-     * to the live pi session; injectable so the hold-and-restore is assertable
-     * with no real session to restore.
+     * How the implementation turn's MODEL and thinking level are read and
+     * written. Defaults to the live pi session; injectable so the
+     * hold-and-restore is assertable with no real session to restore.
+     *
+     * One object rather than two, because the two must be acquired and released
+     * in one order and a caller handed two seams could supply half of one.
      */
-    thinkingControl?: ThinkingControl;
+    implementationControls?: ImplementationControls<never>;
 }
 export interface RunSingleTaskResult {
     taskId: string;
@@ -223,3 +235,4 @@ export declare function runGatedTask(ctx: ExtensionCommandContext, cwd: string,
     deps?: GateDeps;
 }): Promise<void>;
 export declare function registerTask(pi: ExtensionAPI): void;
+export {};

package/dist/task/orchestrator.js

@@ -26,6 +26,7 @@ import { readTextFile } from '../shared/fs-text.js';
 import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
 import { armImplWidget, disarmImplWidget, setupImplWidget } from './impl-widget.js';
+import { armImplementationGuard, disarmImplementationGuard } from './implementation-guards.js';
 import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { getConfig } from '../config/config.js';
@@ -37,7 +38,8 @@ import { findDeliveryPhantoms, formatApiOverrideBanner } from '../workers/phanto
 import { titleForDisplay } from './parsers.js';
 import { USER_CANCELLED } from './child-runner.js';
 import { cancelCheckpoint } from './cancel-points.js';
-import { holdImplementationThinking } from './implementation-thinking.js';
+import { splitSpec } from '../config/group-models.js';
+import { holdImplementation } from './implementation-hold.js';
 import { rearmCancelListener } from './cancel-input.js';
 import { takeHeldInput } from './mid-run-input.js';
 import { withRun, announceTerminal } from './run-bracket.js';
@@ -73,7 +75,38 @@ function piThinkingControl() {
     const api = piApi;
     if (!api)
         return { get: () => 'off', set: () => { } };
-    return { get: () => api.getThinkingLevel(), set: level => api.setThinkingLevel(level) };
+    return {
+        get: () => api.getThinkingLevel(),
+        set: (level) => api.setThinkingLevel(level)
+    };
+}
+/**
+ * The live session's model, as a {@link ModelControl} over pi's own `Model`.
+ *
+ * `current()` reads `ctx.model`, which is a live GETTER on the extension context
+ * (pi's `core/extensions/runner.js`), so a read after a set is the new value.
+ * `resolve` goes through `find(provider, id)` — EXACT, deliberately stricter
+ * than pi's own CLI, which also substring-matches. We store a canonical
+ * `provider/id`, so exact is the only match that should ever count, and being
+ * stricter here can only cost us a hold we then decline to take.
+ */
+function piModelControl(ctx) {
+    const api = piApi;
+    return {
+        current: () => {
+            const m = ctx.model;
+            return m ? { spec: `${m.provider}/${m.id}`, handle: m } : undefined;
+        },
+        resolve: spec => {
+            const parts = splitSpec(spec);
+            return parts ? ctx.modelRegistry.find(parts.provider, parts.id) : undefined;
+        },
+        apply: async (handle) => (api ? api.setModel(handle) : false)
+    };
+}
+/** Both halves of the implementation hold, over the live session. */
+export function piImplementationControls(ctx) {
+    return { thinking: piThinkingControl(), model: piModelControl(ctx) };
 }
 // ─── TaskRunner class ────────────────────────────────────────────────────────
 /** Encapsulates the full lifecycle of a single pi-task run. */
@@ -364,12 +397,24 @@ export class TaskRunner {
         };
         if (this._sendSpec) {
             armImplWidget(meta, { oneShot: !this._implAwaited });
+            // Same lifetime as the widget, and for the same reason: an awaited run
+            // spans resume and steer turns, a fire-and-forget one does not.
+            armImplementationGuard({ oneShot: !this._implAwaited });
+            let delivered = false;
             try {
                 await this._sendSpec(spec);
+                delivered = true;
             }
             finally {
-                if (this._implAwaited)
+                // Arming precedes delivery because the turn can begin inside it. So a
+                // delivery that THREW leaves a guard watching a turn that will never
+                // run: pi's `prompt` rejects on a compaction already in progress, a
+                // missing model, or a failed auth. The next unrelated turn would
+                // inherit it, and this guard can end a turn outright.
+                if (this._implAwaited || !delivered) {
                     disarmImplWidget();
+                    disarmImplementationGuard();
+                }
             }
             return;
         }
@@ -377,12 +422,24 @@ export class TaskRunner {
             throw new Error('extension not initialised (no ExtensionAPI captured)');
         }
         armImplWidget(meta, { oneShot: true });
+        armImplementationGuard({ oneShot: true });
+        // Same reason as the awaited path's `delivered` flag: this send can throw
+        // SYNCHRONOUSLY — the loader gates every ExtensionAPI action behind
+        // `assertActive()` — and a guard left armed over a turn that never starts
+        // is inherited by the next one, which it can terminate.
         // Always name a delivery mode. pi's `prompt()` consults `streamingBehavior`
         // only inside `if (this.isStreaming)`, so naming one is inert on an idle
         // session and queues on a busy one — correct in both cases, where an
         // isIdle() check is a check-then-act race that loses to any turn starting
         // in between.
-        piApi.sendUserMessage(spec, { deliverAs: 'followUp' });
+        try {
+            piApi.sendUserMessage(spec, { deliverAs: 'followUp' });
+        }
+        catch (e) {
+            disarmImplWidget();
+            disarmImplementationGuard();
+            throw e;
+        }
     }
     /**
      * The spec as the implementer should receive it (Layer B). Layer A strips phantom
@@ -462,7 +519,7 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                     // The autofix re-runner (gateRunTask) re-enters runSingleTask
                     // and so re-enters this closure, which is why the hold lives
                     // here rather than at either call site.
-                    const release = holdImplementationThinking(opts.thinkingControl ?? piThinkingControl());
+                    const release = await holdImplementation(opts.implementationControls ?? piImplementationControls(newCtx));
                     try {
                         // Queue-or-run: naming a delivery mode means pi's
                         // "Agent is already processing" throw is unreachable here.
@@ -482,7 +539,7 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                         }
                     }
                     finally {
-                        release();
+                        await release();
                     }
                 },
                 seams: opts.seams,

package/dist/task/phases.js

@@ -38,7 +38,7 @@ import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from '.
 import { readRequirements, buildRequirementsBlock, buildOwnedRequirementsBlock, readOwnedRequirements, writeOwnedRequirements, ownedForTitle, appendOwnedConstraints } from './requirements.js';
 import { detachUnsatisfiableRequirements, claimPendingRequirements, unclaimedPendingRequirements, formatReassignActions } from './owned-freeze-reassign.js';
 import { trackedSourceOracle } from './owned-freeze-conflict.js';
-import { thinkingForChild, runPhaseChild, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
+import { groupArgsForChild, runPhaseChild, runWithEmphasisRetry, prependHint, USER_CANCELLED, CommandTimeoutError, isFatalChildCause } from './child-runner.js';
 import { runResearchWorker, researchWorkerCacheHeading } from './research-worker.js';
 import { SessionUI } from '../remote/bridge.js';
 import { isYoloMode, yoloPickAutoAnswer } from './yolo.js';
@@ -301,7 +301,16 @@ export async function phaseVerifyTooling(deps, research) {
     try {
         verifyOutput = await runPhaseChild(deps, 'verify-tooling', 'read,bash', VERIFY_TOOLING_PROMPT(toolingList));
     }
-    catch {
+    catch (e) {
+        if (isFatalChildCause(e))
+            throw e;
+        // The fallback ships the tooling list UNVERIFIED, which is the right
+        // degrade for a child that merely failed. A hung command is different: it
+        // cost the ceiling on every strike and says the SPEC named something
+        // unbounded, so it is the one cause worth a trail line rather than silence.
+        if (e instanceof CommandTimeoutError) {
+            deps.logDebug?.(`verify-tooling: ${e.message} — shipping the list unverified`);
+        }
         return replaceToolingWithVerified(research, commands);
     }
     const parsed = parseVerifyToolingOutput(verifyOutput);
@@ -645,7 +654,7 @@ export async function phaseResearch(deps, refined) {
         // questions, so one shared `research` cell is the tempting shape —
         // but the four cells do not ship identical, so sharing one would
         // silently change three of them. See config/reasoning.ts.
-        thinkingFor: thinkingForChild,
+        groupArgsFor: groupArgsForChild,
         logDebug: deps.logDebug,
         onChildOutput: deps.onChildOutput,
         record: recordWorker,
@@ -761,7 +770,9 @@ export async function phaseAutoAnswer(deps, refined, research, question) {
                     if (autoAnswerHasTag(text2))
                         reasked = parseAutoAnswer(text2);
                 }
-                catch {
+                catch (e) {
+                    if (isFatalChildCause(e))
+                        throw e;
                     reasked = null;
                 }
                 if (reasked === null
@@ -1024,7 +1035,9 @@ extraDefects) {
             // needs no file access.
             verdict = await runPhaseChild(deps, 'critique-triage', '', CRITIQUE_TRIAGE_PROMPT(spec, refined, qa, contractsBlock));
         }
-        catch {
+        catch (e) {
+            if (isFatalChildCause(e))
+                throw e;
             verdict = null;
         }
         deps.recordSubStep?.('triage', Date.now() - tTriage);

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 {
@@ -78,7 +79,8 @@ export type FocusedResult = FocusedFailure | FocusedAnswer;
  * `<answer>`/`<excerpt>` and verify the excerpt against `verifyAgainst`.
  *
  * Never retries — a re-ask of a deterministic extraction over unchanged content is a second
- * bill for the same answer. Exactly one child is spawned per call.
+ * bill for the same answer. Exactly one child is spawned per call, on every path including
+ * the empty-output failure below.
  */
 export declare function runFocusedExtraction(req: FocusedRequest): Promise<FocusedResult>;
 export {};

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'
 ];
 /**
@@ -44,11 +45,12 @@ export const focusedChildArgs = (thinking = []) => [
  * `<answer>`/`<excerpt>` and verify the excerpt against `verifyAgainst`.
  *
  * Never retries — a re-ask of a deterministic extraction over unchanged content is a second
- * bill for the same answer. Exactly one child is spawned per call.
+ * bill for the same answer. Exactly one child is spawned per call, on every path including
+ * the empty-output failure below.
  */
 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,
@@ -59,6 +61,16 @@ export async function runFocusedExtraction(req) {
     const failure = formatChildFailure(child, req.abortedMessage);
     if (failure !== null)
         return { ok: false, failure, ...evidence };
+    // A dropped provider exits 0 with empty text, and TEXT mode never populates
+    // `modelError`. Returned as an empty answer it is MEMOISED: both caches keep
+    // it and re-serve a dead socket as a real answer for the rest of the run.
+    if (child.stdout.trim().length === 0) {
+        return {
+            ok: false,
+            failure: 'Worker exited 0 without writing anything — no answer to parse',
+            ...evidence
+        };
+    }
     const parsed = parseChildOutput(child.stdout);
     const excerptCheck = parsed.excerpt ? verifyExcerpt(parsed.excerpt, req.verifyAgainst) : undefined;
     return {

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);
 }