@mjasnikovs/pi-task 0.38.23 → 0.38.25

package/dist/shared/reasoning-capability.js

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

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

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

package/dist/task/auto-orchestrator.js

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

package/dist/task/child-runner.d.ts

@@ -81,32 +81,49 @@ export declare const USER_CANCELLED = "__user_cancelled__";
  * context-usage tracking. This is the typed convenience wrapper used by
  * phase-level code.
  */
-export declare function runChild(cwd: string, tools: string, prompt: string, signal: AbortSignal, onLine?: (line: string) => void, onContextUsage?: (snapshot: ContextSnapshot) => void, onToolCall?: (call: ToolCall) => LoopHit | null, spawnFn?: SpawnFn, 
-/** Internal `-e` extension paths for in-run guards (see childArgs). */
-extensions?: readonly string[], 
 /**
- * Every finished tool call's result text. The StallDetector's churn rule
- * needs the size of what actually entered the child's context, which the
- * CALL alone does not carry (task/stall-detector.ts).
- */
-onToolResult?: (text: string, isError: boolean) => void, 
-/**
- * The child's context window in tokens. Nothing in pi's event stream reports
- * one (issue #16), so the parent hands its own down — children carry no `-m`
- * and resolve the same default model. 0 / omitted = unknown, as before.
- */
-contextWindow?: number, 
-/**
- * The resolved `['--thinking', level]` fragment for this child's reasoning
- * group, or `[]`/omitted to inherit the session default as before.
+ * One child-pi invocation, as a value.
  *
- * A 13th trailing positional is not pretty. It is how `contextWindow` (the
- * 12th) was added, and an options-bag refactor of this signature is a
- * separate change from wiring one flag — doing both at once would put a
- * behaviour change inside a mechanical one. DEBT: convert to an options bag.
+ * WHY A RECORD. This was thirteen ordered positionals, and the thirteenth
+ * carried its own DEBT note saying so. Two production callers reached it, and
+ * they had already drifted: the degrade attempt wrote three bare `undefined`s to
+ * reach the later slots and passed the RAW signal, so it escaped the wall clock
+ * its own strike siblings run under — the same defect class this file already
+ * recorded for `runAutoInstall` and for the deleted `runPhaseWithLoopGuard`.
+ * Adjacent optionals of the same type can no longer swap without a type error.
  */
-thinking?: readonly string[]): Promise<PhaseRunResult>;
-interface PhaseDeps {
+export interface ChildRun {
+    cwd: string;
+    /** `''` means `--no-tools`. See childArgs. */
+    tools: string;
+    prompt: string;
+    signal: AbortSignal;
+    onLine?: (line: string) => void;
+    onContextUsage?: (snapshot: ContextSnapshot) => void;
+    onToolCall?: (call: ToolCall) => LoopHit | null;
+    spawn?: SpawnFn;
+    /** Internal `-e` extension paths for in-run guards (see childArgs). */
+    extensions?: readonly string[];
+    /**
+     * Every finished tool call's result text. The StallDetector's churn rule
+     * needs the size of what actually entered the child's context, which the
+     * CALL alone does not carry (task/stall-detector.ts).
+     */
+    onToolResult?: (text: string, isError: boolean) => void;
+    /**
+     * The child's context window in tokens. Nothing in pi's event stream reports
+     * one (issue #16), so the parent hands its own down — children carry no `-m`
+     * and resolve the same default model. 0 / omitted = unknown, as before.
+     */
+    contextWindow?: number;
+    /**
+     * The resolved `['--thinking', level]` fragment for this child's reasoning
+     * group, or `[]`/omitted to inherit the session default as before.
+     */
+    thinking?: readonly string[];
+}
+export declare function runChild({ cwd, tools, prompt, signal, onLine, onContextUsage, onToolCall, spawn: spawnFn, extensions, onToolResult, contextWindow, thinking }: ChildRun): Promise<PhaseRunResult>;
+export interface PhaseDeps {
     cwd: string;
     taskId: string;
     signal: AbortSignal;
@@ -211,7 +228,55 @@ interface PhaseDeps {
      */
     searchFn?: (input: SearchCoreInput) => Promise<SearchCoreResult>;
 }
-export type { PhaseDeps };
+/**
+ * The subset of `PhaseDeps` a CALLER may supply — every injectable seam, derived
+ * by naming what the runner owns instead of by listing what it does not.
+ *
+ * `TaskRunnerOptions` used to declare `spawnFn`, `runChild`, `runWorker` and a
+ * seven-name `Pick` called `lookups` separately; `RunSingleTaskOptions` re-picked
+ * all four, `runSingleTask` re-forwarded each by name, and the constructor spread
+ * them back together. Four coordinated edits, none of which failed to compile if
+ * you skipped one — the exact indictment this codebase already recorded against
+ * `ConfigItem`. Four seams (`timeoutMs`, `sleepFor`, `childExtensions`,
+ * `logDebug`) had in fact been left behind, so a runner-driven test of the
+ * connection-error rung really slept and the debug trail could not be asserted at
+ * all. Derived by `Omit`, a NEW seam field joins this with no second edit.
+ */
+export type PhaseSeams = Omit<PhaseDeps, 'cwd' | 'taskId' | 'signal' | 'onChildOutput' | 'onContextUsage' | 'contextWindow' | 'recordSubStep'>;
+/**
+ * Run a child pi and return its assistant text. Throws if exit code != 0.
+ *
+ * If the child leaks a tool call as plain text (wrong dialect — never executed),
+ * re-prompt with a correction hint up to MAX_LEAK_RETRIES times; if it keeps
+ * leaking, throw LeakedToolCallError rather than returning the unexecuted call.
+ * Empty completions and connection-class model errors share that same budget —
+ * see triageChildResult, which decides every one of those cases.
+ *
+ * THREE RUNAWAY GUARDS ride the same budget, because this is the runner every
+ * /task-auto planning child goes through (clarify, decompose, coverage,
+ * contract-extract) and until mx5-n 2026-08-14 it had none:
+ *   • a LoopDetector, so an identical repeated tool call is killed and
+ *     re-prompted instead of being allowed to fill the context window;
+ *   • a StallDetector, the backstop for the varied-args thrash the loop
+ *     detector's short window cannot see — the shape that actually cost us a
+ *     16-minute decompose child that was never going to return. It bounds
+ *     consecutive no-new-ground calls and total context churn, NOT elapsed time;
+ *   • PHASE_CHILD_TIMEOUT_MS, a hard wall clock, OFF by default because the
+ *     measured healthy range (610-927s for a reasoning-on decompose) overlaps
+ *     any value that would catch the pathology. See its comment.
+ * All three are checked BEFORE the triage ladder: we killed the child, so its
+ * exit status describes our SIGTERM and says nothing about its verdict.
+ */
+/**
+ * The `--thinking` fragment for a named child, or `[]` when the name is unmapped.
+ *
+ * An unmapped name INHERITS rather than throwing: a child that reaches the model
+ * with today's argv is always safe, and aborting a user's task over a missing
+ * table row would be a worse failure than the one it reports. The guard that
+ * makes the table complete is `reasoning-groups.test.ts`, which fails the BUILD —
+ * where someone can actually fix it.
+ */
+export declare function thinkingForChild(name: string): string[];
 export declare function runPhaseChild(deps: PhaseDeps, name: string, tools: string, prompt: string, opts?: PhaseChildOptions): Promise<string>;
 export declare function formatLoopHint(hit: LoopHit): string;
 /**

package/dist/task/child-runner.js

@@ -16,7 +16,7 @@ import { readSection, setTaskSection } from './task-io.js';
 import { streamStallCause } from '../shared/stream-watchdog.js';
 import { getConfig } from '../config/config.js';
 import { groupThinkingArgs } from '../config/reasoning-args.js';
-import { reasoningGroupForChild } from './reasoning-groups.js';
+import { reasoningGroupForChild } from '../config/reasoning.js';
 // ─── Loop detection constants ────────────────────────────────────────────────
 // Defined here (not in phases.ts) to avoid a circular dependency:
 //   phases.ts → child-runner.ts → phases.ts
@@ -167,37 +167,7 @@ thinking = []) {
 // Sentinel error thrown when the user dismisses a grill-me dialog.
 // Defined here (not in failure-classifier.ts) to avoid circular dependency.
 export const USER_CANCELLED = '__user_cancelled__';
-// ─── Core child runner (JSON event-stream mode) ─────────────────────────────
-/**
- * Run a child pi process with JSON event-stream output, loop detection, and
- * context-usage tracking. This is the typed convenience wrapper used by
- * phase-level code.
- */
-export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsage, onToolCall, spawnFn, 
-/** Internal `-e` extension paths for in-run guards (see childArgs). */
-extensions, 
-/**
- * Every finished tool call's result text. The StallDetector's churn rule
- * needs the size of what actually entered the child's context, which the
- * CALL alone does not carry (task/stall-detector.ts).
- */
-onToolResult, 
-/**
- * The child's context window in tokens. Nothing in pi's event stream reports
- * one (issue #16), so the parent hands its own down — children carry no `-m`
- * and resolve the same default model. 0 / omitted = unknown, as before.
- */
-contextWindow, 
-/**
- * The resolved `['--thinking', level]` fragment for this child's reasoning
- * group, or `[]`/omitted to inherit the session default as before.
- *
- * A 13th trailing positional is not pretty. It is how `contextWindow` (the
- * 12th) was added, and an options-bag refactor of this signature is a
- * separate change from wiring one flag — doing both at once would put a
- * behaviour change inside a mechanical one. DEBT: convert to an options bag.
- */
-thinking) {
+export async function runChild({ cwd, tools, prompt, signal, onLine, onContextUsage, onToolCall, spawn: spawnFn, extensions, onToolResult, contextWindow, thinking }) {
     const invocation = getPiInvocation(childArgs(tools, extensions, thinking), prompt);
     let loopHit;
     const result = await runChildUnified(spawnFn ?? spawn, invocation, cwd, signal, {
@@ -338,10 +308,30 @@ async function triageChildResult(deps, name, r, attempt, budget, verb) {
  * makes the table complete is `reasoning-groups.test.ts`, which fails the BUILD —
  * where someone can actually fix it.
  */
-function thinkingForChild(name) {
+export function thinkingForChild(name) {
     const group = reasoningGroupForChild(name);
     return group ? groupThinkingArgs(group) : [];
 }
+/**
+ * What a PHASE child's invocation carries, said once.
+ *
+ * Both callers of `runChild` in this file are phase children — the strike
+ * attempts and the no-tools degrade that rescues them — and everything they
+ * disagree about is in `over`. Anything not there is the same by construction,
+ * which is what the degrade's own comment ("the degrade changes the TOOLS, not
+ * the role") claimed while three bare `undefined`s quietly made it false.
+ */
+function phaseChildRun(deps, over) {
+    return {
+        cwd: deps.cwd,
+        onLine: deps.onChildOutput,
+        onContextUsage: deps.onContextUsage,
+        spawn: deps.spawn,
+        extensions: deps.childExtensions,
+        contextWindow: deps.contextWindow,
+        ...over
+    };
+}
 export async function runPhaseChild(deps, name, tools, prompt, opts = {}) {
     if (deps.runChild)
         return await deps.runChild(name, tools, prompt);
@@ -369,13 +359,21 @@ export async function runPhaseChild(deps, name, tools, prompt, opts = {}) {
         const clock = phaseTimeout(deps.signal, budgetMs);
         let r;
         try {
-            r = await runChild(deps.cwd, tools, prependHint(hint, prompt), clock.signal, deps.onChildOutput, snapshot => {
-                // Real window or nothing: noteContext ignores 0, and until
-                // deps.contextWindow existed 0 was all it ever saw, which
-                // left the churn rule permanently disarmed (issue #16).
-                stall.noteContext(snapshot.contextWindow);
-                deps.onContextUsage?.(snapshot);
-            }, call => detector.record(call) ?? stall.record(call), deps.spawn, deps.childExtensions, (text, isError) => stall.noteResult(text, isError), deps.contextWindow, thinking);
+            r = await runChild(phaseChildRun(deps, {
+                tools,
+                prompt: prependHint(hint, prompt),
+                signal: clock.signal,
+                thinking,
+                onContextUsage: snapshot => {
+                    // Real window or nothing: noteContext ignores 0, and until
+                    // deps.contextWindow existed 0 was all it ever saw, which
+                    // left the churn rule permanently disarmed (issue #16).
+                    stall.noteContext(snapshot.contextWindow);
+                    deps.onContextUsage?.(snapshot);
+                },
+                onToolCall: call => detector.record(call) ?? stall.record(call),
+                onToolResult: (text, isError) => stall.noteResult(text, isError)
+            }));
         }
         finally {
             clock.cleanup();
@@ -482,13 +480,36 @@ async function appendLoopEvent(cwd, taskId, phase, hit, strike, outcome) {
  */
 async function runDegradedFinalAttempt(deps, name, prompt, hit, loopHistory) {
     deps.logDebug?.(`${name}: loop budget exhausted — degrading to a no-tools final attempt`);
-    const r = await runChild(deps.cwd, '', // --no-tools: the model cannot read/grep/list, only answer
-    prependHint(formatDegradeHint(hit), prompt), deps.signal, deps.onChildOutput, deps.onContextUsage, undefined, deps.spawn, undefined, undefined, deps.contextWindow, 
-    // Same group as the attempts that led here. The degrade changes the
-    // TOOLS, not the role — running it at a different thinking level would
-    // make the fallback a different experiment from the thing it rescues.
-    thinkingForChild(name));
+    // BEHAVIOUR DELTA. This attempt now runs under the same wall clock as the
+    // strikes that led here. It used to pass `deps.signal` raw — one of the
+    // three drifts that came of reaching past bare `undefined`s to the later
+    // positionals — so the one attempt made after a loop budget was spent was
+    // also the one attempt that could hang forever.
+    const clock = phaseTimeout(deps.signal, deps.timeoutMs ?? PHASE_CHILD_TIMEOUT_MS);
+    let r;
+    try {
+        r = await runChild(phaseChildRun(deps, {
+            tools: '', // --no-tools: the model cannot read/grep/list, only answer
+            prompt: prependHint(formatDegradeHint(hit), prompt),
+            signal: clock.signal,
+            // Same group as the attempts that led here. The degrade changes the
+            // TOOLS, not the role — running it at a different thinking level would
+            // make the fallback a different experiment from the thing it rescues.
+            thinking: thinkingForChild(name)
+        }));
+    }
+    finally {
+        clock.cleanup();
+    }
     if (r.exitCode !== 0 || r.modelError || r.text.trim().length === 0) {
+        // A wall-clock kill is NOT a loop. The clock above is new here, and
+        // without this check a degrade that outran its budget was reported as
+        // "loop budget exhausted", carrying a loop history that did not cause it
+        // — the same mislabel class the worker-kill roster exists to prevent, on
+        // the very path that clock was added to guard.
+        if (clock.timedOut()) {
+            throw new PhaseTimeoutError(name, deps.timeoutMs ?? PHASE_CHILD_TIMEOUT_MS, 1);
+        }
         throw new LoopExhaustedError(name, loopHistory);
     }
     return r.text;

package/dist/task/gate-child.js

@@ -88,18 +88,18 @@ export function makeGateChild(deps) {
                     cwd: deps.cwd,
                     ...(sig ? { signal: sig } : {}),
                     tools,
-                    // Run to completion: these passes legitimately read and edit the
-                    // same file many times, and the research-worker guards mislabel
-                    // that as a runaway and kill good work (mx5 TASK_0002).
-                    timeoutMs: 0,
-                    commandTimeoutMs: deps.commandTimeoutMs,
-                    streamInactivityMs: deps.streamInactivityMs,
+                    // The four guard literals that used to sit here — run to
+                    // completion, a per-command watchdog, a stream watchdog, and
+                    // the path rule disabled — are the `gate` row of
+                    // WORKER_PROFILES (workers/worker-profiles.ts), which carries
+                    // the reasoning for each. The two ceilings stay inputs
+                    // because they are user config, not policy.
+                    profile: 'gate',
+                    policyInputs: {
+                        commandTimeoutMs: deps.commandTimeoutMs,
+                        streamInactivityMs: deps.streamInactivityMs
+                    },
                     thinking: deps.thinking,
-                    // Exact-match loop guard only: pathThreshold Infinity disables
-                    // the path-revisit heuristic, so revisiting one file (which IS
-                    // the job) never trips — only a literally-identical call
-                    // repeated past threshold does.
-                    loop: { pathThreshold: Number.POSITIVE_INFINITY },
                     // A discarded attempt is otherwise invisible: the returned
                     // exitCode/text describe the FINAL attempt, so a child that
                     // burned two attempts reads exactly like one that ran clean.

package/dist/task/orchestrator.d.ts

@@ -19,10 +19,9 @@ import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-c
 import { type WidgetState } from './widget.js';
 import { type RunTaskFn } from './gate-deps.js';
 import { type GateDeps } from './task-gates.js';
-import { type PhaseDeps } from './child-runner.js';
+import { type PhaseSeams } from './child-runner.js';
 import { type ThinkingControl } from './implementation-thinking.js';
 import { type RunEnd } from './run-end.js';
-import type { SpawnFn } from '../shared/child-process.js';
 import { type SuperviseOptions } from './implementation-turn.js';
 /**
  * Everything one TaskRunner needs, as one object. The runner is the shared core
@@ -38,25 +37,20 @@ export interface TaskRunnerOptions {
     resumeId?: string;
     /** Deliver the finished spec to the main session. Absent → nothing is sent. */
     sendSpec?: (spec: string) => Promise<void>;
-    /** Test seam: spawn function forwarded into `PhaseDeps.spawn`. Keep for tests
-     *  that drive the Error-triage ladder or a real process. */
-    spawnFn?: SpawnFn;
     /**
-     * Test seam: `PhaseDeps.runChild(name, tools, prompt)`. Present → every phase
-     * child is answered by name, with none of the ladder's guards. Use this when
-     * the child is a premise of the test, not its subject.
-     */
-    runChild?: PhaseDeps['runChild'];
-    /**
-     * Test seam: `PhaseDeps.runWorker(label, input)`. Present → every research
-     * worker is answered BY NAME, so the three Research retry gates and the
-     * fatal/runaway/empty classification are reachable from a runner-driven test
-     * without matching a marker sentence inside the prompt.
+     * Every injectable phase seam, in one field (`PhaseSeams`, child-runner.ts).
+     *
+     * `spawn` drives the Error-triage ladder or a real process. `runChild(name,
+     * tools, prompt)` answers every phase child BY NAME, with none of the
+     * ladder's guards — use it when the child is a premise of the test, not its
+     * subject. `runWorker(label, input)` answers every research worker by name,
+     * so the three Research retry gates are reachable without matching a marker
+     * sentence inside a prompt. The EXTERNAL CONTEXT lookups and the file
+     * inventory each default to the real implementation when absent. `timeoutMs`,
+     * `sleepFor`, `childExtensions` and `logDebug` are seams too, and were
+     * unreachable from here until this became one field.
      */
-    runWorker?: PhaseDeps['runWorker'];
-    /** Test seam: the four EXTERNAL CONTEXT lookups plus the file inventory. Each
-     *  defaults to the real implementation when absent. */
-    lookups?: Pick<PhaseDeps, 'getFileInventory' | 'docsRaw' | 'fetchRaw' | 'npmVersionLookup' | 'docsFocused' | 'fetchFocused' | 'searchFn'>;
+    seams?: PhaseSeams;
     /** Called with the resolved task id once its file exists, before any phase
      *  work. Lets callers record the id (e.g. stamp the /task-auto entry) so an
      *  interrupted run can be resumed instead of restarted. */
@@ -147,7 +141,7 @@ export declare class TaskRunner {
      */
     private _specForDelivery;
 }
-export interface RunSingleTaskOptions extends Pick<TaskRunnerOptions, 'resumeId' | 'spawnFn' | 'runChild' | 'runWorker' | 'lookups' | 'onStart' | 'planContext' | 'fixInstruction'> {
+export interface RunSingleTaskOptions extends Pick<TaskRunnerOptions, 'resumeId' | 'seams' | 'onStart' | 'planContext' | 'fixInstruction'> {
     /** Await the session going idle after the spec is delivered, so the caller
      *  blocks until the agent has implemented it. Default false. */
     waitForImplementation?: boolean;

package/dist/task/orchestrator.js

@@ -126,10 +126,7 @@ export class TaskRunner {
             cwd,
             taskId: '',
             signal: this._abort.signal,
-            spawn: opts.spawnFn,
-            runChild: opts.runChild,
-            runWorker: opts.runWorker,
-            ...opts.lookups,
+            ...opts.seams,
             // Deliberately NOT a ChildStatus (child-status.ts): the phase widget's
             // state is the whole-run WidgetState — task id, phase, label — shared by
             // reference with PhaseContext and written by the phases themselves
@@ -231,7 +228,10 @@ export class TaskRunner {
         const debugLogPath = path.join(tasksDir(cwd), `${id}-debug.log`);
         // Left UNSET at level `off`, so the ~39 `logDebug?.(…)` sites downstream
         // short-circuit before they format a string and the file is never created.
-        this._deps.logDebug = gateDebugWriter((msg) => {
+        // A caller-supplied `logDebug` seam WINS: it is the only way to observe
+        // the ~39 trail decisions from a runner-driven test, and production never
+        // sets one, so the file writer is unaffected.
+        this._deps.logDebug ??= gateDebugWriter((msg) => {
             const line = `${new Date().toISOString()} ${msg}\n`;
             fsp.appendFile(debugLogPath, line).catch(() => {
                 /* ignore */
@@ -480,10 +480,7 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                         release();
                     }
                 },
-                spawnFn: opts.spawnFn,
-                runChild: opts.runChild,
-                runWorker: opts.runWorker,
-                lookups: opts.lookups,
+                seams: opts.seams,
                 onStart: opts.onStart,
                 planContext: opts.planContext,
                 fixInstruction: opts.fixInstruction,
@@ -536,6 +533,12 @@ export const gateRunTask = (c, cwd, t, opts) => runSingleTask(c, cwd, t, {
     onStart: opts?.onStart,
     planContext: opts?.planContext,
     fixInstruction: opts?.fixInstruction
+    // NO `seams` here, deliberately. Threading them would need a field on
+    // `GateParams` and another on `GateDeps`, and nothing — production or
+    // test — would set either: the gate is reached through two orchestrators
+    // that build their params from a task file. An unused field on a seam
+    // roster is the `WorkerOutcome.reason` shape (written twelve times, read
+    // by nothing), so this stays unplumbed until a test actually needs it.
 });
 /**
  * Demote a task file to a resumable state after a gate (or its implementation)

package/dist/task/phases.d.ts

@@ -172,29 +172,6 @@ export declare const SINGLE_READ_EXTENSION_PATH: string;
  * mentions; the rest are unchanged or only lightly trimmed.
  */
 export declare function scopedToolingGoal(refined: string): string;
-/**
- * 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 declare function degradedSectionBody(name: string, reason: string, partial: string): string;
-/**
- * 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 declare function emptySectionBody(name: string): string;
-export declare function isBareNoneAnswer(text: string): boolean;
 export declare function phaseResearch(deps: PhaseDeps, refined: string): Promise<string>;
 export declare function phaseAutoAnswer(deps: PhaseDeps, refined: string, research: string, question: string): Promise<AutoAnswer>;
 export declare function phaseGrill(deps: PhaseDeps, ctx: ExtensionCommandContext, widgetState: WidgetState, refined: string, research: string): Promise<string>;