@mjasnikovs/pi-task 0.38.22 → 0.38.24

package/dist/task/phases.js

@@ -6,7 +6,6 @@ import { fileURLToPath } from 'node:url';
 import { docsFocused } from '../workers/docs-core.js';
 import { fetchFocused } from '../workers/fetch-core.js';
 import { runWorker } from '../workers/pi-worker-core.js';
-import { classifyWorkerFailure } from '../workers/worker-failure.js';
 import { findPhantomImports, formatApiCorrections, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { searchProviderKey } from '../workers/search-types.js';
 import { channelSet } from '../workers/worker-channels.js';
@@ -14,7 +13,6 @@ import { fanoutTimeoutPolicy, workerCarryForward, workerProgressCeilingMs, proje
 import { isIntegrationUnknown } from './unknown-routing.js';
 import { extractUserDirectives, preserveDirectivesBlock, enforceDirectives } from './user-directives.js';
 import { demoteUnsourcedAttributions } from './context-attribution.js';
-import { classifyContextSilence, countBullets } from './context-silence.js';
 import { getFileInventory } from './file-inventory.js';
 import { buildOrientation, orientationTier } from './orientation.js';
 import { getConfig } from '../config/config.js';
@@ -31,18 +29,18 @@ import { parseGrillQuestions, parseAutoAnswer, autoAnswerHasTag, parseVerifyTool
 import { compressTitle } from './title-label.js';
 import { parseVerifyBlock, validateSpecShape, validateRefineShape, stripSpecPreamble, isCritiqueClean } from './spec-validation.js';
 import { collectCritiqueDefects } from './critique-probes.js';
-import { buildOptionCards, resolveAnswer } from './question-dialog.js';
+import { settleQuestion } from './question-dialog.js';
 import { findSynthesizedApis, synthesizedApiReaskHint } from './api-synthesis.js';
 import { GREP_THEATER_RETRY_HINT } from './verify-quality.js';
 import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from './contracts.js';
 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 { runPhaseChild, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
+import { thinkingForChild, runPhaseChild, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
+import { runResearchWorker, researchWorkerCacheHeading } from './research-worker.js';
 import { SessionUI } from '../remote/bridge.js';
 import { isYoloMode, yoloPickAutoAnswer } from './yolo.js';
 import { QaTranscript, GRILL_QA_POLICY } from './qa-transcript.js';
-import { groupThinkingArgs } from '../config/reasoning-args.js';
 // ─── Re-export constants from their home modules ────────────────────────────
 export { MAX_GRILL_QUESTIONS };
 // ─── Tooling helpers ─────────────────────────────────────────────────────────
@@ -326,7 +324,7 @@ export async function phaseVerifyTooling(deps, research) {
  * Both halves of "given a channel" — the tools string and the `-e` path — come
  * from the same rows, so they cannot disagree.
  */
-function apisWorkerChannels() {
+export function apisWorkerChannels() {
     return channelSet([
         'pi-worker-docs',
         ...(searchConfigured() ? ['pi-worker-search', 'pi-worker-fetch'] : [])
@@ -360,15 +358,6 @@ export const RESEARCH_SEARCH_HINT = '\n\nLIVE WEB — use pi-worker-search for e
  * See single-read-guard.ts.
  */
 export const SINGLE_READ_EXTENSION_PATH = fileURLToPath(new URL('../workers/single-read-extension.js', import.meta.url));
-/**
- * Task-file heading under which a research worker's validated output is cached.
- * A resumed research phase reads these to skip workers that already succeeded,
- * instead of re-running all four from scratch when one of them fails — the
- * expensive case (e.g. 3 healthy workers thrown away because the 4th looped).
- */
-function researchWorkerCacheHeading(section) {
-    return `research worker ${section}`;
-}
 /**
  * The TOOLING worker only needs to know which verification commands the task
  * cares about — never the per-file edit list. Big refined prompts embed a long
@@ -392,136 +381,6 @@ export function scopedToolingGoal(refined) {
     const firstBullet = goal.search(/\n[ \t]*[-*]\s/);
     return firstBullet === -1 ? goal : goal.slice(0, firstBullet).trim();
 }
-/**
- * Classify a research worker's result so the phase can react per-worker instead
- * of treating every failure the same. Two distinct failure shapes:
- *
- *   - 'runaway' (loop-kill OR per-worker wall-clock timeout): the worker explored
- *     too long and was killed *after* burning its MAX_LOOP_RESTARTS restarts. It
- *     did real work and left partial text; the other three workers are unaffected.
- *     Failing the whole task here would throw away every already-good worker AND
- *     abort the entire auto-run over the weakest section — and because the loop is
- *     deterministic, a resume just re-loops and re-fails. So this DEGRADES: keep
- *     the partial answer (marked), cache it, move on. A loop-kill is a SIGTERM
- *     (exit 143) OR a clean exit 0 with truncated text, so loopHit/timedOut — not
- *     exitCode — are the reliable signal and are checked first.
- *
- *   - 'fatal' (non-zero exit that isn't a loop-kill, a provider error behind an
- *     empty answer, or a leaked never-executed tool call): the output is
- *     untrustworthy in a way partial text can't paper over (broken env, model
- *     disconnect, wrong tool-call dialect). These still throw — degrading them
- *     would launder a real breakage into a plausible-looking section.
- *
- *   - 'empty' (clean exit 0, no provider error, no loop/timeout — the model simply
- *     wrote nothing): NOT a failure. On an extremely simple task ("create a folder
- *     with an index.html in it") three of the four workers have genuinely nothing
- *     to report, and each worker prompt tells the model to emit ONLY what this task
- *     touches and to drop everything else — so silence is the CORRECT answer and
- *     was killing the whole task at research (issue #10). Measured live on the
- *     issue's own prompt (30 reps/worker, local Qwen3.6-27B): every APIS answer was
- *     semantically "there is nothing here", and 2/30 were literally zero bytes on a
- *     clean exit — the other 28 survived only because the model happened to wrap the
- *     same non-answer in a parenthetical, which is model style, not signal. The
- *     caller retries once and then accepts an explicit empty section; what stays
- *     fatal is silence WITH a reported cause, which is the masked-disconnect case
- *     this branch was written for and which `modelError` now names outright.
- *
- * Returns null when the result is trustworthy.
- */
-function classifyResearchWorker(name, result) {
-    // What KILLED the child, if anything — classified once, in the ladder that
-    // owns the precedence (workers/worker-failure.ts), because every kill path
-    // also sets `aborted` and a non-zero exit. This switch says only what each
-    // cause means to RESEARCH; being exhaustive, a new cause is a compile error
-    // here instead of falling through to the generic "exit N".
-    const failure = classifyWorkerFailure(result);
-    if (failure) {
-        switch (failure.kind) {
-            case 'loop': {
-                const argsStr = JSON.stringify(failure.hit.call.args);
-                return {
-                    kind: 'runaway',
-                    reason: `stuck in a loop — called ${failure.hit.call.name}(${argsStr}) `
-                        + `×${failure.hit.count} in the last ${failure.hit.windowSize} calls `
-                        + `and still looped after restarts`
-                };
-            }
-            case 'worker-timeout':
-                return { kind: 'runaway', reason: 'timed out after restarts' };
-            case 'command-timeout':
-                return {
-                    kind: 'runaway',
-                    reason: `ran a \`${failure.toolName}\` command that never returned and was killed `
-                        + 'after restarts'
-                };
-            case 'stream-stall':
-                return {
-                    kind: 'runaway',
-                    reason: `model stream went silent for ${failure.idleMs}ms after restarts`
-                };
-            case 'stalled':
-                return {
-                    kind: 'fatal',
-                    error: new Error(`Research ${name} worker: model server unreachable — the child produced no `
-                        + 'output and the model endpoint did not respond')
-                };
-            case 'leaked-tool-call':
-                return {
-                    kind: 'fatal',
-                    error: new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
-                        + `(${failure.text.trim()}) — it never ran`)
-                };
-            case 'aborted':
-            case 'exit':
-                return {
-                    kind: 'fatal',
-                    error: new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`)
-                };
-        }
-    }
-    if (result.text.trim().length === 0) {
-        // NOTHING CAME BACK — two different events wear the same face, and the whole
-        // point of this branch is to tell them apart:
-        //
-        //   FAILED, cause reported: pi delivers a failed turn as an empty assistant
-        //     message with stopReason "error" and exit 0, so the real cause used to be
-        //     discarded and reported as the useless "produced no output". Name it.
-        //   FAILED, child never spoke: no stdout at all means the child died before it
-        //     could run (unresolvable provider, missing key, bad argv) — it never
-        //     answered, so it cannot have answered "nothing".
-        //   EMPTY: a child that streamed, exited 0, reported no error, and wrote no
-        //     answer. The worker ran and the model had nothing to say — a real answer
-        //     on a task that touches nothing, not a failure.
-        if (result.modelError) {
-            return {
-                kind: 'fatal',
-                error: new Error(`Research ${name} worker: model error — ${result.modelError.slice(0, 200)}`)
-            };
-        }
-        if (!result.sawOutput) {
-            return {
-                kind: 'fatal',
-                error: new Error(`Research ${name} worker produced no output — the child never wrote a `
-                    + 'single byte, so it died before it could answer'
-                    + (result.stderr ? `: ${result.stderr.slice(-300)}` : ''))
-            };
-        }
-        return { kind: 'empty' };
-    }
-    return null;
-}
-/**
- * Build a degraded section body for a runaway worker: a one-line marker naming
- * the failure (so downstream phases and a human reading the task file know this
- * section is incomplete) followed by whatever partial answer the worker streamed
- * before it was killed. The marker is always present even when there is no
- * partial text, so an empty degrade is never mistaken for a real finding.
- */
-export function degradedSectionBody(name, reason, partial) {
-    const marker = `(degraded: research ${name} worker ${reason}; this section may be incomplete)`;
-    const body = partial.trim();
-    return body.length > 0 ? `${marker}\n\n${body}` : marker;
-}
 /**
  * Dependency names declared by the project manifest, used by the CONTEXT post-check to
  * tell "this bullet is about an external library" from "this bullet is about our source".
@@ -538,67 +397,6 @@ async function manifestDependencyNames(cwd) {
         return [];
     }
 }
-/**
- * The body written for a research section the worker confirmed has no entries.
- *
- * Three states have to stay distinguishable to anyone — human or later phase —
- * reading a research section, so each carries its own marker:
- *   `(none — …)`     the worker RAN and answered "nothing applies" (this)
- *   `(degraded: …)`  the worker was killed mid-answer, text may be partial
- *                    (degradedSectionBody)
- *   section absent   the worker never got that far — the phase threw
- *
- * Naming the worker inside the marker keeps it true after assembly, where the
- * section headings are all that separate the four workers' output.
- */
-export function emptySectionBody(name) {
-    return `(none — the ${name} worker ran and reported no entries for this task)`;
-}
-/**
- * A worker answer that IS the word "nothing" and carries no other content:
- * `(none)`, `N/A`, `- none`, `(no content)`, `(no entries)`. Live workers write
- * these often on a task that touches nothing (measured on the issue's prompt:
- * `(no content)`, `(no response)`, a bare `(none)` from the gate's own retry),
- * and each one means exactly what an empty answer means — so they are recorded
- * with the same marker rather than passed through in whatever shape the model
- * happened to pick. Deliberately NARROW: it matches only a lone token, never
- * prose like "(no APIs to list — this task creates a plain HTML file …)", which
- * carries a reason worth keeping.
- */
-const BARE_NONE_ANSWER = /^[-*\s]*\(?\s*(?:none|n\/?a|nothing|no (?:content|entries|response|items|results))\s*\.?\s*\)?\s*$/i;
-export function isBareNoneAnswer(text) {
-    return BARE_NONE_ANSWER.test(text.trim());
-}
-/**
- * Prepended on the ONE retry the empty-section gate triggers. A zero-byte answer is
- * ambiguous — a crashed worker looks exactly like a worker with nothing to say — so
- * the retry's only job is to remove the ambiguity: answer properly, or say "(none)"
- * in as many words.
- *
- * It must NOT turn into an invitation to skip the work: `(none)` is offered only
- * behind an explicit "after you have looked" condition, because this retry also
- * fires on a normal project where the first attempt died for an unrelated reason,
- * and an easy opt-out there would silence real research.
- *
- * MEASUREMENT OPEN. The recovery path's QUALITY on a real repo is being measured
- * (scripts live under /home/edgars/tmp/issue10: first FILES answer faulted to
- * empty, every other child live, against an uninterrupted control). First rep on
- * an earlier wording did NOT take the `(none)` exit but drifted into writing code
- * instead of listing paths — the deliverable-not-inputs failure the base prompt
- * already forbids below this preamble. Blast radius is bounded: the gate fires
- * only on a run that would otherwise have FAILED outright, so a mediocre recovered
- * section is strictly better than the dead task it replaces — but if the drift
- * reproduces, this preamble must restate the section's output contract, not just
- * demand an answer.
- */
-const EMPTY_SECTION_PREAMBLE = 'STOP. Your previous attempt returned an EMPTY answer — zero characters. An empty '
-    + 'response cannot be accepted, because it is indistinguishable from a worker that '
-    + 'crashed before it wrote anything. Answer again now, and do the research properly '
-    + 'this time: look first, then write what you found, in the required format. Only if '
-    + 'you have looked and there is genuinely nothing to report — the task touches no '
-    + 'existing file, needs no external symbol, or the project has no such tooling — write '
-    + 'exactly `(none)` and nothing else. Do not answer `(none)` to avoid the work, and '
-    + 'never answer with silence.';
 /**
  * Prepended to worker:apis's prompt on the ONE retry the zero-retrieval gate triggers. It
  * names the exact failure (a section written with no retrieval) so the correction is concrete,
@@ -876,212 +674,38 @@ export async function phaseResearch(deps, refined) {
         persistChain = next.catch(() => { });
         return next;
     };
-    // One worker, cache-skip to persist: on a resume, a worker whose cached
-    // output is already on disk is skipped — so when one worker fails and the
-    // phase is re-run, the others don't burn minutes regenerating work that was
-    // already good. Each worker is validated inline (not in a second pass), so
-    // only trustworthy text is ever cached.
-    //
-    // A fatal failure (crash/empty/leak) still throws — the already-cached
-    // workers survive for the resume. A runaway (loop/timeout) degrades to its
-    // partial output instead, so one weak worker can't abort a whole auto-run;
-    // the degraded section is cached too, so a resume doesn't re-loop it.
-    const runSpec = async (spec, prior) => {
-        const cacheHeading = researchWorkerCacheHeading(spec.section);
-        const cached = (await readSection(deps.cwd, deps.taskId, cacheHeading)) ?? '';
-        if (cached.trim().length > 0) {
-            deps.logDebug?.(`${spec.label}: cached — skipping re-run`);
-            updateProgress();
-            return { name: spec.section, text: cached.trim() };
-        }
-        deps.logDebug?.(`${spec.label}: start`);
-        const basePrompt = typeof spec.prompt === 'function' ? spec.prompt(prior) : spec.prompt;
-        const runOnce = (extraPreamble) => recordWorker(spec.label, runWorkerFn(spec.label, {
-            prompt: extraPreamble ? `${extraPreamble}\n\n${basePrompt}` : basePrompt,
-            cwd: deps.cwd,
-            signal: deps.signal,
-            spawn: deps.spawn,
-            // All four research workers share one group: they are the same
-            // job (read-only exploration of the repo) run over four
-            // questions, and a table that could set them apart would be
-            // four cells nobody has the trials to fill.
-            thinking: groupThinkingArgs('research'),
-            ...(spec.tools ? { tools: spec.tools } : {}),
-            ...(spec.extensions ? { extensions: spec.extensions } : {}),
-            // 5B SCALE arm — null unless both env vars are set. Only the
-            // docs-capable worker can fan out, so only it can be scaled.
-            ...(spec.fanoutBounded && fanoutTimeout ? { fanoutTimeout } : {}),
-            // 5B RESCUE. Applies to EVERY research worker, not just the
-            // docs-capable one: any worker that gets killed loses its work
-            // the same way. carry-forward stays OFF unless asked for
-            // (measured harmful on its own); the progress deadline SHIPPED
-            // ON in nexttask 9 and is null only when explicitly disabled.
-            ...(carryForward ? { carryForward: true } : {}),
-            ...(progressCeilingMs !== null ?
-                { progressTimeoutCeilingMs: progressCeilingMs }
-                : {}),
-            // One line per DISCARDED attempt. The `done` line below reports
-            // the final attempt only, so a worker that timed out twice at
-            // 240s and then answered used to log exactly like a clean one —
-            // 8 minutes of burned compute recoverable only by subtracting
-            // its own wait+work from the start/done timestamps.
-            onCarryForward: ci => {
-                deps.logDebug?.(`${spec.label}: CARRY-FORWARD injected into attempt ${ci.attempt}`
-                    + ` (${ci.chars} chars onto a ${ci.promptCharsBefore}-char prompt)`);
-            },
-            onRestart: rs => {
-                deps.logDebug?.(`${spec.label}: RESTART (attempt ${rs.attempt} discarded)`
-                    + ` reason=${rs.reason} wall=${rs.wallMs}ms`
-                    + ` wait=${rs.waitMs}ms work=${rs.workMs}ms`
-                    + (rs.detail ? ` — ${rs.detail}` : ''));
-                deps.onChildOutput?.(`${spec.label}: restart (${rs.reason})`);
-            },
-            onLine: line => {
-                // The one 'stream' site in this file: raw research-worker
-                // output. Every other logDebug here records a decision.
-                // onChildOutput drives the widget and is not gated.
-                deps.logDebug?.(`${spec.label}: ${line}`, 'stream');
-                deps.onChildOutput?.(`${spec.label}: ${line}`);
-            }
-        }));
-        let r = await runOnce();
-        // EMPTY-SECTION GATE (issue #10). A worker that returns zero bytes on a clean run
-        // used to fail the whole task ("Research APIS worker produced no output"), which is
-        // exactly what an extremely simple task provokes: with nothing on disk to survey and
-        // no external symbol in play, silence is the correct answer and the run died on it.
-        // Retry ONCE — silence is genuinely ambiguous, and a worker that crashed before
-        // writing deserves a second attempt — then accept an explicitly empty section. A
-        // provider error behind the silence is classified fatal below and never reaches here.
-        let confirmedEmpty = false;
-        if (classifyResearchWorker(spec.section, r)?.kind === 'empty') {
-            deps.logDebug?.(`${spec.label}: EMPTY answer on a clean exit — retrying once before`
-                + ' accepting the section as having no entries');
-            deps.onChildOutput?.(`${spec.label}: empty — retrying`);
-            const retry = await runOnce(EMPTY_SECTION_PREAMBLE);
-            if (retry.text.trim().length > 0) {
-                deps.logDebug?.(`${spec.label}: retry answered (len=${retry.text.trim().length})`
-                    + ' — replacing the empty section');
-                r = retry;
-            }
-            else {
-                confirmedEmpty = classifyResearchWorker(spec.section, retry)?.kind === 'empty';
-                deps.logDebug?.(`${spec.label}: retry STILL empty — `
-                    + (confirmedEmpty ?
-                        'the worker ran twice and reported no entries; recording the'
-                            + ' section as empty (NOT a failure)'
-                        : 'and this attempt did not run cleanly — failing the phase'));
-                if (!confirmedEmpty)
-                    r = retry;
-            }
-        }
-        // ZERO-RETRIEVAL GATE — a deterministic handle, not another instruction. A non-empty
-        // section produced with no grounding-retrieval call was written from memory; retry ONCE
-        // with a forced retrieval-first pass and keep the retry only if it actually retrieved.
-        if (spec.zeroRetrievalRetry
-            && r.groundingRetrievalCount === 0
-            && r.text.trim().length > 0) {
-            deps.logDebug?.(`${spec.label}: ZERO grounding-retrieval on a non-empty section`
-                + ' — every symbol is unverified memory; re-running once with a forced'
-                + ' retrieval-first pass');
-            deps.onChildOutput?.(`${spec.label}: zero-retrieval — retrying with forced retrieval`);
-            const retry = await runOnce(spec.zeroRetrievalRetry);
-            if (retry.groundingRetrievalCount > 0 && retry.text.trim().length > 0) {
-                deps.logDebug?.(`${spec.label}: retry grounded (${retry.groundingRetrievalCount} retrieval`
-                    + ' calls) — replacing the memory-written section');
-                r = retry;
-            }
-            else {
-                deps.logDebug?.(`${spec.label}: retry STILL zero-retrieval`
-                    + ` (calls=${retry.groundingRetrievalCount}, len=${retry.text.trim().length})`
-                    + ' — keeping the original (no regression, entry count preserved)');
-            }
-        }
-        // SILENT-RETRY GATE — a deterministic handle over the section body, not another
-        // instruction. A section that parses to ZERO bullets from a loop-degrade banner or a
-        // hallucinated non-bullet fragment (classifyContextSilence → genuineLoss) dropped
-        // context that was there to surface; retry ONCE with a forced-emit preamble and keep
-        // the retry only if it produces bullets. A legitimately-empty section (an honest
-        // "nothing to surface") and a fatal failure are BOTH left alone — the former is not a
-        // loss, the latter throws below and must stay a loud failure, not a silent retry.
-        const silentBodyOf = (res) => {
-            const f = classifyResearchWorker(spec.section, res);
-            if (f?.kind === 'fatal')
-                return null;
-            return f?.kind === 'runaway' ?
-                degradedSectionBody(spec.section, f.reason, res.text)
-                : res.text.trim();
-        };
-        // `confirmedEmpty` already spent a retry on exactly this ("you wrote nothing"), and
-        // the worker answered "nothing applies" a second time — re-asking here would just
-        // burn a third child for the same answer.
-        if (spec.retryIfSilent && !confirmedEmpty) {
-            const body = silentBodyOf(r);
-            const verdict = body === null ? null : classifyContextSilence(body);
-            if (verdict?.silent && verdict.genuineLoss) {
-                deps.logDebug?.(`${spec.label}: silent-retry first-silent cause=${verdict.cause}`
-                    + ` — zero bullets, re-running once with a forced-emit preamble`);
-                deps.onChildOutput?.(`${spec.label}: silent — retrying`);
-                const retry = await runOnce(spec.retryIfSilent);
-                const retryBody = silentBodyOf(retry);
-                const retryBullets = retryBody === null ? 0 : countBullets(retryBody);
-                if (retryBullets > 0) {
-                    deps.logDebug?.(`${spec.label}: silent-retry recovered bullets=${retryBullets}`
-                        + ' — replacing the silent section');
-                    r = retry;
-                }
-                else {
-                    deps.logDebug?.(`${spec.label}: silent-retry still-silent`
-                        + ` (bullets=${retryBullets}) — keeping the original`);
-                }
-            }
-        }
-        deps.logDebug?.(`${spec.label}: done exit=${r.exitCode} wait=${r.waitMs}ms work=${r.workMs}ms`
-            // attempts/total are the pair that makes wait+work honest: they are
-            // the FINAL attempt's split, and only `total` sees the discarded ones.
-            + ` attempts=${r.attempts} total=${r.totalWallMs}ms`
-            + (r.restarts.length > 0 ?
-                ` restarts=[${r.restarts.map(x => x.reason).join(',')}]`
-                : '')
-            // Attribution for the RESCUE arm: a run with zero restarts was
-            // never killed (the progress deadline did it), while a run that
-            // restarted and salvaged was killed but kept its work. Without
-            // this the two are indistinguishable in the logs, and "0
-            // timeouts" cannot be traced to the half that earned it.
-            + (r.salvagedFromDiscardedAttempt ? ' salvaged=1' : '')
-            + (r.stderr ? ` stderr=${r.stderr.slice(0, 300)}` : '')
-            + (r.leakedToolCall ? ` leaked=${r.leakedToolCall.trim().slice(0, 80)}` : ''));
-        updateProgress();
-        const failure = classifyResearchWorker(spec.section, r);
-        if (failure?.kind === 'fatal')
-            throw failure.error;
-        // A worker that answers "nothing applies" is recorded the same way whether it
-        // said so with zero bytes (confirmedEmpty) or with a bare "(none)"/"N/A" — the
-        // two are the same answer, and only the marker makes either one distinguishable
-        // from a worker that never answered at all.
-        const rawText = failure?.kind === 'runaway' ? degradedSectionBody(spec.section, failure.reason, r.text)
-            : confirmedEmpty || isBareNoneAnswer(r.text) ? emptySectionBody(spec.section)
-                : r.text.trim();
-        if (failure?.kind === 'runaway') {
-            deps.logDebug?.(`${spec.label}: degraded — ${failure.reason}`);
-        }
-        if (!confirmedEmpty && isBareNoneAnswer(r.text)) {
-            deps.logDebug?.(`${spec.label}: answered "${r.text.trim().slice(0, 40)}" — recording it as`
-                + ' an empty section (the worker ran and found nothing)');
-        }
-        // Post-check the worker's own output before it is persisted, so the cache a
-        // resume reads back is already gated. A degraded partial goes through it too —
-        // a truncated section can still carry a laundered claim.
-        const sectionText = spec.postProcess ? spec.postProcess(rawText) : rawText;
-        await persistSection(cacheHeading, sectionText);
-        return { name: spec.section, text: sectionText };
-    };
+    /**
+     * This phase's binding of the research-worker driver: everything about THIS
+     * RUN, gathered once, so each of the four rows is plain data.
+     */
+    const drive = (spec, prior) => runResearchWorker(spec, {
+        runWorker: runWorkerFn,
+        cwd: deps.cwd,
+        taskId: deps.taskId,
+        signal: deps.signal,
+        spawn: deps.spawn,
+        // ONE CELL PER WORKER since 2026-08-28. The four workers used to
+        // share the `research` cell on the grounds that they are the same
+        // job over four questions; the run logs disagree. The cells DO NOT
+        // ship identical — the evidence is on each of them in reasoning.ts.
+        thinkingFor: thinkingForChild,
+        logDebug: deps.logDebug,
+        onChildOutput: deps.onChildOutput,
+        record: recordWorker,
+        onDone: updateProgress,
+        readCached: async (heading) => (await readSection(deps.cwd, deps.taskId, heading)) ?? '',
+        persistSection,
+        carryForward,
+        fanoutTimeout,
+        progressCeilingMs
+    }, prior);
     const sections = [];
     if (!getConfig().parallelResearchWorkers) {
         // Default: ONE AT A TIME (see the A/B note above the specs) — a fatal
         // failure throws before later workers run, and each worker can see the
         // finished sections before it (APIS builds on the FILES map).
         for (const spec of workerSpecs) {
-            sections.push(await runSpec(spec, sections));
+            sections.push(await drive(spec, sections));
         }
     }
     else {
@@ -1091,7 +715,7 @@ export async function phaseResearch(deps, refined) {
         // before the failure is thrown. Assembly order stays the spec order
         // regardless of completion order. No prior sections exist here, so
         // prompt builders get none (APIS runs map-less, as before this option).
-        const settled = await Promise.allSettled(workerSpecs.map(spec => runSpec(spec, [])));
+        const settled = await Promise.allSettled(workerSpecs.map(spec => drive(spec, [])));
         for (const s of settled) {
             if (s.status === 'rejected')
                 throw s.reason;
@@ -1283,60 +907,31 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
             transcript.add('auto', plainQ, stripInlineMarkdown(auto.text));
         }
         else {
-            const plainSuggested = auto.suggested === undefined ? undefined : stripInlineMarkdown(auto.suggested);
-            const plainAlt = auto.alt === undefined ? undefined : stripInlineMarkdown(auto.alt);
             // YOLO: take the recommended option and never build the prompt (which
             // is also what suppresses its notification — see yolo.ts). An answer the
             // anti-synthesis guard demoted, or a question with no recommendation at
             // all, is SKIPPED instead: costing the spec one unanswered fork is the
             // guard direction, promoting a hallucination is not.
-            const yolo = yoloPickAutoAnswer(isYoloMode(), auto);
-            if (yolo !== null) {
-                // The YOLO stamp is a RECORD fact. It used to be pushed into the
-                // generator feedback too, against the rule stated a dozen lines
-                // below — the policy now decides, so the two cannot disagree.
-                if (yolo.kind === 'answer') {
-                    transcript.add('yolo', plainQ, stripInlineMarkdown(yolo.answer));
-                }
-                else {
-                    transcript.add('yolo-skip', plainQ, `(skipped — ${yolo.note})`);
-                }
-                continue;
-            }
-            // The picker cards and the reply mapping are shared with /task-auto's
-            // clarify loop and the plan session (question-dialog.ts) — all three
-            // used to write them out, and had drifted.
-            const pending = {
-                plain: plainQ,
-                shown: shownQ,
-                ...(plainSuggested !== undefined && {
-                    suggested: plainSuggested,
-                    shownSuggested: renderInlineMarkdown(auto.suggested, theme)
-                }),
-                ...(plainAlt !== undefined && {
-                    alt: plainAlt,
-                    shownAlt: renderInlineMarkdown(auto.alt, theme)
-                })
-            };
-            const options = buildOptionCards(pending);
-            widgetState.lastLine = `awaiting Q${n + 1}`;
-            const a = await ui.ask({
-                localTitle: shownQ,
-                displayQuestion: shownQ,
-                question: plainQ,
-                recommended: plainSuggested,
-                recommended2: plainAlt,
-                allowSkip: plainSuggested === undefined && plainAlt === undefined,
-                ...(options && { options })
-            });
-            if (a === undefined)
-                throw new Error(USER_CANCELLED);
+            //
             // Grill's generator sees NO provenance — its feedback is fed verbatim
             // into the next grill-gen prompt, where a suffix would describe how the
             // answer was obtained rather than what it was. That is
             // `GRILL_QA_POLICY.generatorSeesProvenance: false`, stated once.
-            const resolved = resolveAnswer(pending, a);
-            transcript.add(resolved.source === 'accepted' ? 'accepted' : 'typed', plainQ, resolved.answer);
+            const outcome = await settleQuestion({
+                ui,
+                transcript,
+                plain: plainQ,
+                shown: shownQ,
+                ...(auto.suggested !== undefined && { suggested: auto.suggested }),
+                ...(auto.alt !== undefined && { alt: auto.alt }),
+                render: md => renderInlineMarkdown(md, theme),
+                yolo: yoloPickAutoAnswer(isYoloMode(), auto),
+                onAsk: () => {
+                    widgetState.lastLine = `awaiting Q${n + 1}`;
+                }
+            });
+            if (outcome === 'cancelled')
+                throw new Error(USER_CANCELLED);
         }
     }
     if (transcript.length === 0)

package/dist/task/question-dialog.d.ts

@@ -29,6 +29,7 @@
  * actions. Those genuinely differ.
  */
 import type { AnswerSource } from './plan-io.js';
+import type { YoloPick } from './yolo.js';
 /** One question awaiting an answer, in both the stored and the displayed form. */
 export interface PendingQuestion {
     /** Plain text — persisted, and fed back to the model. */
@@ -69,3 +70,58 @@ export declare function resolveAnswer(p: PendingQuestion, raw: string): {
     answer: string;
     source: AnswerSource;
 };
+/**
+ * Everything one adaptive dialog needs to settle ONE question.
+ *
+ * `ui.ask` is typed structurally rather than as `SessionUI` so this module stays
+ * out of the remote bridge's import graph — the only thing it needs is the ask.
+ */
+export interface SettleQuestionInput {
+    ui: {
+        ask: (spec: {
+            localTitle: string;
+            displayQuestion: string;
+            question: string;
+            recommended?: string;
+            recommended2?: string;
+            allowSkip: boolean;
+            options?: Array<{
+                label: string;
+                value: string;
+            }>;
+        }) => Promise<string | undefined>;
+    };
+    /** Where the settled answer is recorded. */
+    transcript: {
+        add: (kind: SettledKind, question: string, answer: string) => void;
+    };
+    /** The question, plain (persisted / fed back) and rendered (displayed). */
+    plain: string;
+    shown: string;
+    /** The recommendation and the alternative, as the model wrote them (markdown). */
+    suggested?: string;
+    alt?: string;
+    /** Render inline markdown for display. */
+    render: (md: string) => string;
+    /**
+     * This site's already-decided YOLO outcome. A PARAMETER, not a hook: yolo.ts
+     * states why the policy is per-site (grill has an anti-synthesis channel to
+     * step aside from, clarify runs before research and has none), and settling a
+     * question must not become the place that decides one.
+     */
+    yolo: YoloPick;
+    /** Run just before the ask — grill's "awaiting Qn" widget line. */
+    onAsk?: () => void;
+}
+/** The provenance kinds settling one question can produce. */
+export type SettledKind = 'yolo' | 'yolo-skip' | 'accepted' | 'typed';
+/**
+ * Settle one question: YOLO short-circuit, cards, ask, record.
+ *
+ * Returns `'cancelled'` rather than throwing, because that is the one thing the
+ * two callers genuinely disagree about — grill throws `USER_CANCELLED` into the
+ * phase ladder, clarify announces and returns null from the plan. Everything
+ * before it was written out twice at ~50 lines each and had already drifted on
+ * `recommended2`, harmless today only because the bridge re-guards it.
+ */
+export declare function settleQuestion(input: SettleQuestionInput): Promise<'settled' | 'cancelled'>;