@mjasnikovs/pi-task 0.13.6 → 0.13.7

package/dist/shared/child-process.d.ts

@@ -60,6 +60,33 @@ export interface RunChildJsonEventsOptions {
     onFirstByte?: () => void;
 }
 export type RunChildOptions = RunChildTextOptions | RunChildJsonEventsOptions;
+/**
+ * Parses a child's `--mode json` event stream into assistant text plus side
+ * effects (caller callbacks, loop-kill). It holds the cross-chunk line buffer
+ * and the text-assembly state, so event interpretation is independent of the
+ * spawn/kill machinery in runChild — and therefore unit-testable without a real
+ * child: construct one, `feed()` raw lines, assert on `text` / the callbacks /
+ * the onLoopKill signal.
+ */
+export declare class JsonEventSink {
+    private readonly opts;
+    /** Invoked when onToolCall reports a loop hit — runChild kills the child. */
+    private readonly onLoopKill;
+    /** Final assistant text from the agent_end event, if one arrived. */
+    finalText: string;
+    private textDeltaAccum;
+    private buf;
+    constructor(opts: RunChildJsonEventsOptions, 
+    /** Invoked when onToolCall reports a loop hit — runChild kills the child. */
+    onLoopKill: () => void);
+    /** Feed a raw stdout chunk: parse every complete line, buffer the partial tail. */
+    feed(chunk: string): void;
+    /** Flush a trailing event that wasn't newline-terminated (call on close). */
+    flush(): void;
+    /** Extracted assistant text: the agent_end text if present, else the deltas. */
+    get text(): string;
+    private handleEvent;
+}
 export declare function runChild(spawn: SpawnFn, invocation: {
     command: string;
     args: ReadonlyArray<string>;

package/dist/shared/child-process.js

@@ -10,31 +10,162 @@ export const CHILD_BASE_ARGS = [
     '--no-context-files',
     '--no-session'
 ];
+// ─── JSON event-stream sink ──────────────────────────────────────────────────
+/**
+ * Parses a child's `--mode json` event stream into assistant text plus side
+ * effects (caller callbacks, loop-kill). It holds the cross-chunk line buffer
+ * and the text-assembly state, so event interpretation is independent of the
+ * spawn/kill machinery in runChild — and therefore unit-testable without a real
+ * child: construct one, `feed()` raw lines, assert on `text` / the callbacks /
+ * the onLoopKill signal.
+ */
+export class JsonEventSink {
+    opts;
+    onLoopKill;
+    /** Final assistant text from the agent_end event, if one arrived. */
+    finalText = '';
+    textDeltaAccum = '';
+    // json-events lines can split across data chunks; this holds the trailing
+    // partial line between feeds so events spanning a boundary still parse. We
+    // deliberately do NOT accumulate the full raw stream: a long-running child
+    // emits hundreds of MB of events and buffering it would overflow V8's max
+    // string length (≈512MB). We keep only the parsed text.
+    buf = '';
+    constructor(opts, 
+    /** Invoked when onToolCall reports a loop hit — runChild kills the child. */
+    onLoopKill) {
+        this.opts = opts;
+        this.onLoopKill = onLoopKill;
+    }
+    /** Feed a raw stdout chunk: parse every complete line, buffer the partial tail. */
+    feed(chunk) {
+        this.buf += chunk;
+        let nl;
+        while ((nl = this.buf.indexOf('\n')) !== -1) {
+            const line = this.buf.slice(0, nl).trim();
+            this.buf = this.buf.slice(nl + 1);
+            if (line.length === 0)
+                continue;
+            try {
+                const evt = JSON.parse(line);
+                if (evt && typeof evt === 'object')
+                    this.handleEvent(evt);
+            }
+            catch {
+                // Non-JSON line (startup banner, etc.) — ignore.
+            }
+        }
+    }
+    /** Flush a trailing event that wasn't newline-terminated (call on close). */
+    flush() {
+        if (this.buf.trim().length > 0)
+            this.feed('\n');
+        this.buf = '';
+    }
+    /** Extracted assistant text: the agent_end text if present, else the deltas. */
+    get text() {
+        return (this.finalText || this.textDeltaAccum).trim();
+    }
+    handleEvent(evt) {
+        const opts = this.opts;
+        const t = typeof evt.type === 'string' ? evt.type : '';
+        if (t === 'context_usage' && opts.onContextUsage) {
+            const tokens = Number(evt.tokens ?? 0);
+            const contextWindow = Number(evt.contextWindow ?? 0);
+            const percent = Number(evt.percent ?? 0);
+            if (tokens > 0 || contextWindow > 0) {
+                opts.onContextUsage({ tokens, contextWindow, percent });
+            }
+            return;
+        }
+        if (t === 'message_end' && opts.onContextUsage) {
+            const msg = evt.message;
+            if (msg?.role === 'assistant') {
+                const usage = msg.usage;
+                if (usage) {
+                    const tokens = Number(usage.input ?? 0)
+                        + Number(usage.cacheRead ?? 0)
+                        + Number(usage.cacheWrite ?? 0)
+                        + Number(usage.output ?? 0);
+                    if (tokens > 0) {
+                        opts.onContextUsage({ tokens, contextWindow: 0, percent: 0 });
+                    }
+                }
+            }
+            return;
+        }
+        if (t === 'agent_end' && Array.isArray(evt.messages)) {
+            for (let i = evt.messages.length - 1; i >= 0; i--) {
+                const m = evt.messages[i];
+                if (m && m.role === 'assistant' && Array.isArray(m.content)) {
+                    const texts = [];
+                    for (const c of m.content) {
+                        if (c?.type === 'text' && typeof c.text === 'string') {
+                            texts.push(c.text);
+                        }
+                    }
+                    if (texts.length > 0) {
+                        this.finalText = texts.join('');
+                        break;
+                    }
+                }
+            }
+            return;
+        }
+        if (t === 'message_update') {
+            const ame = evt.assistantMessageEvent;
+            const ameType = ame && typeof ame.type === 'string' ? ame.type : '';
+            if (ameType === 'text_start') {
+                this.textDeltaAccum = '';
+                if (opts.onLine)
+                    opts.onLine('writing answer…');
+            }
+            else if (ameType === 'text_delta' && typeof ame.delta === 'string') {
+                this.textDeltaAccum += ame.delta;
+            }
+            else if (ameType === 'thinking_start' && opts.onLine) {
+                opts.onLine('thinking…');
+            }
+            return;
+        }
+        if (t === 'tool_execution_start') {
+            const tn = typeof evt.toolName === 'string' ? evt.toolName : 'tool';
+            if (opts.onLine) {
+                const detail = summarizeToolArgs(tn, evt.args);
+                opts.onLine(detail ? `${tn}: ${detail}` : tn);
+            }
+            if (opts.onToolCall) {
+                const hit = opts.onToolCall({ name: tn, args: evt.args });
+                if (hit)
+                    this.onLoopKill();
+            }
+        }
+    }
+}
 // ─── Unified runChild ────────────────────────────────────────────────────────
 export function runChild(spawn, invocation, cwd, signal, opts) {
     return new Promise(resolve => {
         let stdout = '';
         let stderr = '';
         let aborted = false;
-        const isJsonEvents = opts?.mode === 'json-events';
         const discardStdout = opts?.mode === 'text' && opts.discardStdout === true;
-        // State for json-events mode
-        let finalText = '';
-        let textDeltaAccum = '';
         const proc = spawn(invocation.command, invocation.args, {
             cwd,
             shell: false,
             stdio: ['ignore', 'pipe', 'pipe']
         });
+        // One kill path, shared by user-abort and loop-kill: SIGTERM, then
+        // SIGKILL after a grace period if the child ignored the term.
+        const killProc = () => {
+            aborted = true;
+            proc.kill('SIGTERM');
+            setTimeout(() => {
+                if (!proc.killed)
+                    proc.kill('SIGKILL');
+            }, KILL_GRACE_MS);
+        };
+        const sink = opts?.mode === 'json-events' ? new JsonEventSink(opts, killProc) : null;
         let firstByteFired = false;
-        // json-events lines can split across data chunks; this holds the trailing
-        // partial line between chunks so events spanning a boundary still parse.
-        // In json-events mode we deliberately do NOT accumulate the full raw
-        // stream: a long-running child emits hundreds of MB of events and
-        // `stdout += chunk` would overflow V8's max string length (≈512MB),
-        // crashing the process. We only need the parsed text, so we drop the raw
-        // bytes once drained.
-        let lineBuffer = '';
         proc.stdout?.on('data', (d) => {
             if (!firstByteFired) {
                 firstByteFired = true;
@@ -43,147 +174,28 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             if (discardStdout)
                 return;
             const chunk = d.toString();
-            if (isJsonEvents) {
-                lineBuffer = drainJsonEvents(lineBuffer + chunk, opts);
-            }
-            else {
+            if (sink)
+                sink.feed(chunk);
+            else
                 stdout += chunk;
-            }
         });
         proc.stderr?.on('data', (d) => {
             stderr += d.toString();
         });
         proc.on('close', (code) => {
-            // Flush a final event that wasn't newline-terminated.
-            if (isJsonEvents && lineBuffer.trim().length > 0) {
-                drainJsonEvents(lineBuffer + '\n', opts);
-                lineBuffer = '';
-            }
-            const text = isJsonEvents ? (finalText || textDeltaAccum).trim() : undefined;
+            if (sink)
+                sink.flush();
+            const text = sink ? sink.text : undefined;
             resolve({ stdout, stderr, exitCode: code ?? 0, aborted, text });
         });
         proc.on('error', () => {
             resolve({ stdout, stderr, exitCode: 1, aborted });
         });
         if (signal) {
-            const kill = () => {
-                aborted = true;
-                proc.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!proc.killed)
-                        proc.kill('SIGKILL');
-                }, KILL_GRACE_MS);
-            };
             if (signal.aborted)
-                kill();
+                killProc();
             else
-                signal.addEventListener('abort', kill, { once: true });
-        }
-        // ─── JSON event-stream processing ──────────────────────────────────
-        /**
-         * Parse every complete (newline-terminated) JSON line in `buf` and
-         * return the trailing partial line, which the caller carries into the
-         * next chunk. This avoids both losing events that span a chunk boundary
-         * and buffering the entire stream.
-         */
-        function drainJsonEvents(buf, jsonOpts) {
-            let nl;
-            while ((nl = buf.indexOf('\n')) !== -1) {
-                const line = buf.slice(0, nl).trim();
-                buf = buf.slice(nl + 1);
-                if (line.length === 0)
-                    continue;
-                try {
-                    const evt = JSON.parse(line);
-                    if (evt && typeof evt === 'object') {
-                        handleEvent(evt, jsonOpts);
-                    }
-                }
-                catch {
-                    // Non-JSON line (startup banner, etc.) — ignore.
-                }
-            }
-            return buf;
-        }
-        function handleEvent(evt, jsonOpts) {
-            const t = typeof evt.type === 'string' ? evt.type : '';
-            if (t === 'context_usage' && jsonOpts.onContextUsage) {
-                const tokens = Number(evt.tokens ?? 0);
-                const contextWindow = Number(evt.contextWindow ?? 0);
-                const percent = Number(evt.percent ?? 0);
-                if (tokens > 0 || contextWindow > 0) {
-                    jsonOpts.onContextUsage({ tokens, contextWindow, percent });
-                }
-                return;
-            }
-            if (t === 'message_end' && jsonOpts.onContextUsage) {
-                const msg = evt.message;
-                if (msg?.role === 'assistant') {
-                    const usage = msg.usage;
-                    if (usage) {
-                        const tokens = Number(usage.input ?? 0)
-                            + Number(usage.cacheRead ?? 0)
-                            + Number(usage.cacheWrite ?? 0)
-                            + Number(usage.output ?? 0);
-                        if (tokens > 0) {
-                            jsonOpts.onContextUsage({ tokens, contextWindow: 0, percent: 0 });
-                        }
-                    }
-                }
-                return;
-            }
-            if (t === 'agent_end' && Array.isArray(evt.messages)) {
-                for (let i = evt.messages.length - 1; i >= 0; i--) {
-                    const m = evt.messages[i];
-                    if (m && m.role === 'assistant' && Array.isArray(m.content)) {
-                        const texts = [];
-                        for (const c of m.content) {
-                            if (c?.type === 'text' && typeof c.text === 'string') {
-                                texts.push(c.text);
-                            }
-                        }
-                        if (texts.length > 0) {
-                            finalText = texts.join('');
-                            break;
-                        }
-                    }
-                }
-                return;
-            }
-            if (t === 'message_update') {
-                const ame = evt.assistantMessageEvent;
-                const ameType = ame && typeof ame.type === 'string' ? ame.type : '';
-                if (ameType === 'text_start') {
-                    textDeltaAccum = '';
-                    if (jsonOpts.onLine)
-                        jsonOpts.onLine('writing answer…');
-                }
-                else if (ameType === 'text_delta' && typeof ame.delta === 'string') {
-                    textDeltaAccum += ame.delta;
-                }
-                else if (ameType === 'thinking_start' && jsonOpts.onLine) {
-                    jsonOpts.onLine('thinking…');
-                }
-                return;
-            }
-            if (t === 'tool_execution_start') {
-                const tn = typeof evt.toolName === 'string' ? evt.toolName : 'tool';
-                if (jsonOpts.onLine) {
-                    const detail = summarizeToolArgs(tn, evt.args);
-                    jsonOpts.onLine(detail ? `${tn}: ${detail}` : tn);
-                }
-                if (jsonOpts.onToolCall) {
-                    const hit = jsonOpts.onToolCall({ name: tn, args: evt.args });
-                    if (hit) {
-                        aborted = true;
-                        proc.kill('SIGTERM');
-                        setTimeout(() => {
-                            if (!proc.killed)
-                                proc.kill('SIGKILL');
-                        }, KILL_GRACE_MS);
-                    }
-                }
-            }
+                signal.addEventListener('abort', killProc, { once: true });
         }
     });
 }

package/dist/task/auto-orchestrator.js

@@ -18,6 +18,7 @@ import { runPhaseChild, USER_CANCELLED } from './child-runner.js';
 import { SessionUI, registerBridgeCommand } from '../remote/bridge.js';
 import { getConfig } from '../config/config.js';
 import { startAutoLoader } from './widget.js';
+import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
 // Matches pi's @-file completion token (a path after @, until whitespace).
 const MENTION_RE = /(?:^|\s)@([^\s]+)/g;
 /**
@@ -136,7 +137,7 @@ function defaultDeps(ctx, cwd, signal, title) {
     // output line and context usage, exactly like the single-task phase widget.
     let lastLine;
     let contextUsage;
-    const parentContextWindow = ctx.model?.contextWindow ?? 0;
+    const parentContextWindow = getParentContextWindow(ctx);
     const phaseDeps = {
         cwd,
         taskId: '',
@@ -145,11 +146,7 @@ function defaultDeps(ctx, cwd, signal, title) {
             lastLine = line;
         },
         onContextUsage: snapshot => {
-            const cw = snapshot.contextWindow > 0 ?
-                snapshot.contextWindow
-                : contextUsage?.contextWindow || parentContextWindow;
-            const percent = cw > 0 ? Math.min(100, (snapshot.tokens / cw) * 100) : snapshot.percent;
-            contextUsage = { tokens: snapshot.tokens, contextWindow: cw, percent };
+            contextUsage = resolveContextUsage(snapshot, contextUsage, parentContextWindow);
         }
     };
     return {

package/dist/task/child-runner.js

@@ -10,7 +10,7 @@ import { getPiInvocation } from '../shared/pi-invocation.js';
 import { runChild as runChildUnified, CHILD_BASE_ARGS } from '../shared/child-process.js';
 import { LoopDetector } from './loop-detector.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
-import { readSection, setTaskSection } from './task-file.js';
+import { readSection, setTaskSection } from './task-io.js';
 // ─── Loop detection constants ────────────────────────────────────────────────
 // Defined here (not in phases.ts) to avoid a circular dependency:
 //   phases.ts → child-runner.ts → phases.ts

package/dist/task/context-usage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Context-usage resolution — shared by the single-task widget (TaskRunner) and
+ * the /task-auto planning loader (defaultDeps), which both mirror a child's
+ * context_usage events into a display snapshot with identical math.
+ */
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { ContextSnapshot } from '../shared/child-process.js';
+/** The parent session's context window, or 0 when the model doesn't expose it. */
+export declare function getParentContextWindow(ctx: ExtensionCommandContext): number;
+/**
+ * Fold a raw context_usage snapshot into a display snapshot: prefer the child's
+ * own contextWindow, else the last known one, else the parent session's; then
+ * derive percent against it — falling back to the child's reported percent when
+ * no window is known at all.
+ */
+export declare function resolveContextUsage(snapshot: ContextSnapshot, prev: ContextSnapshot | undefined, parentContextWindow: number): ContextSnapshot;

package/dist/task/context-usage.js

@@ -0,0 +1,22 @@
+/**
+ * Context-usage resolution — shared by the single-task widget (TaskRunner) and
+ * the /task-auto planning loader (defaultDeps), which both mirror a child's
+ * context_usage events into a display snapshot with identical math.
+ */
+/** The parent session's context window, or 0 when the model doesn't expose it. */
+export function getParentContextWindow(ctx) {
+    return (ctx.model?.contextWindow ?? 0);
+}
+/**
+ * Fold a raw context_usage snapshot into a display snapshot: prefer the child's
+ * own contextWindow, else the last known one, else the parent session's; then
+ * derive percent against it — falling back to the child's reported percent when
+ * no window is known at all.
+ */
+export function resolveContextUsage(snapshot, prev, parentContextWindow) {
+    const cw = snapshot.contextWindow > 0 ?
+        snapshot.contextWindow
+        : prev?.contextWindow || parentContextWindow;
+    const percent = cw > 0 ? Math.min(100, (snapshot.tokens / cw) * 100) : snapshot.percent;
+    return { tokens: snapshot.tokens, contextWindow: cw, percent };
+}

package/dist/task/external-context.d.ts

@@ -0,0 +1,27 @@
+/**
+ * External-context enrichment — extract packages / URLs / services from the
+ * refined spec, fan out to docs / fetch / search workers, and assemble the
+ * `EXTERNAL CONTEXT` block the research phase prepends to every worker prompt.
+ *
+ * Split out of phases.ts so the research phase reads as "gather context → run
+ * probes → assemble", and so this fan-out has its own test surface separate
+ * from the four research workers. `enrichment.ts` stays a pure parser; the I/O
+ * lives here.
+ */
+import { docsRaw } from '../workers/docs-core.js';
+import { fetchRaw } from '../workers/fetch-core.js';
+import type { SearchCoreInput, SearchCoreResult } from '../workers/search-core.js';
+import type { PhaseDeps } from './child-runner.js';
+/** Injectable workers so enrichment is testable without spawning real lookups. */
+export interface ExternalContextDeps {
+    docsRaw?: typeof docsRaw;
+    fetchRaw?: typeof fetchRaw;
+    searchFn?: (input: SearchCoreInput) => Promise<SearchCoreResult>;
+}
+type GatherDeps = Pick<PhaseDeps, 'cwd' | 'signal' | 'recordSubStep'>;
+/**
+ * Returns the `EXTERNAL CONTEXT\n…\n\n` block for the refined spec, or `''` when
+ * there is nothing to enrich (no targets, or every lookup failed).
+ */
+export declare function gatherExternalContext(refined: string, deps: GatherDeps, researchDeps?: ExternalContextDeps): Promise<string>;
+export {};

package/dist/task/external-context.js

@@ -0,0 +1,93 @@
+/**
+ * External-context enrichment — extract packages / URLs / services from the
+ * refined spec, fan out to docs / fetch / search workers, and assemble the
+ * `EXTERNAL CONTEXT` block the research phase prepends to every worker prompt.
+ *
+ * Split out of phases.ts so the research phase reads as "gather context → run
+ * probes → assemble", and so this fan-out has its own test surface separate
+ * from the four research workers. `enrichment.ts` stays a pure parser; the I/O
+ * lives here.
+ */
+import { docsRaw } from '../workers/docs-core.js';
+import { fetchRaw } from '../workers/fetch-core.js';
+import { formatNpmVersionSection } from '../workers/npm-version.js';
+import { search as defaultSearch } from '../workers/search-core.js';
+import { extractEnrichTargets } from './enrichment.js';
+import { formatServiceBlock, formatFreshnessSkippedBlock } from './service-blocks.js';
+/**
+ * Returns the `EXTERNAL CONTEXT\n…\n\n` block for the refined spec, or `''` when
+ * there is nothing to enrich (no targets, or every lookup failed).
+ */
+export async function gatherExternalContext(refined, deps, researchDeps = {}) {
+    const docsRawFn = researchDeps.docsRaw ?? docsRaw;
+    const fetchRawFn = researchDeps.fetchRaw ?? fetchRaw;
+    const searchFn = researchDeps.searchFn ?? defaultSearch;
+    const enrichTargets = extractEnrichTargets(refined);
+    if (enrichTargets.packages.length === 0
+        && enrichTargets.urls.length === 0
+        && enrichTargets.services.length === 0) {
+        return '';
+    }
+    const enrichSections = [];
+    const tEnrichStart = Date.now();
+    const [docsResults, fetchResults, serviceResults] = await Promise.all([
+        Promise.all(enrichTargets.packages.map(pkg => docsRawFn({
+            pkg,
+            query: refined.split('\n').find(l => l.trim()) ?? refined,
+            cwd: deps.cwd,
+            signal: deps.signal
+        }).catch(() => null))),
+        Promise.all(enrichTargets.urls.map(url => fetchRawFn({ url, signal: deps.signal }).catch(() => null))),
+        Promise.all(enrichTargets.services.map(s => searchFn({
+            query: `${s.name} ${s.query}`,
+            count: 3,
+            signal: deps.signal
+        }).catch(() => null)))
+    ]);
+    // npm version blocks come from docsRaw's bundled lookup and lead the
+    // section so the model anchors on live version data before reading
+    // the docs body.
+    for (let i = 0; i < enrichTargets.packages.length; i++) {
+        const v = docsResults[i]?.npmVersion;
+        if (v)
+            enrichSections.push(formatNpmVersionSection(v));
+    }
+    for (let i = 0; i < enrichTargets.packages.length; i++) {
+        const r = docsResults[i];
+        if (r?.kind === 'ok' && r.chunks.length > 0) {
+            const body = r.chunks
+                .map(c => c.content)
+                .join('\n\n')
+                .slice(0, 4000);
+            enrichSections.push(`### docs: ${enrichTargets.packages[i]}\n${body}`);
+        }
+    }
+    for (let i = 0; i < enrichTargets.urls.length; i++) {
+        const r = fetchResults[i];
+        if (r) {
+            enrichSections.push(`### url: ${enrichTargets.urls[i]}\n${r.markdown.slice(0, 4000)}`);
+        }
+    }
+    const skipped = [];
+    for (let i = 0; i < enrichTargets.services.length; i++) {
+        const s = enrichTargets.services[i];
+        const r = serviceResults[i];
+        if (r === null)
+            continue;
+        if (r.kind === 'no_key') {
+            skipped.push(s.name);
+            continue;
+        }
+        if (r.kind === 'error')
+            continue;
+        // kind === 'ok'
+        enrichSections.push(formatServiceBlock(s.name, `${s.name} ${s.query}`, r.results));
+    }
+    if (skipped.length > 0) {
+        enrichSections.push(formatFreshnessSkippedBlock(skipped));
+    }
+    deps.recordSubStep?.('enrichment', Date.now() - tEnrichStart);
+    if (enrichSections.length === 0)
+        return '';
+    return `EXTERNAL CONTEXT\n${enrichSections.join('\n\n')}\n\n`;
+}

package/dist/task/failure-classifier.js

@@ -2,7 +2,7 @@
  * Failure classification — map runtime errors to task state transitions,
  * widget flash messages, and user notifications.
  */
-import { updateTaskFrontMatter } from './task-file.js';
+import { updateTaskFrontMatter } from './task-io.js';
 import { flashTerminalWidget } from './widget.js';
 import { LoopExhaustedError, LeakedToolCallError, USER_CANCELLED } from './child-runner.js';
 // ─── Classifier ──────────────────────────────────────────────────────────────

package/dist/task/orchestrator.js

@@ -19,11 +19,14 @@ import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { PHASES, postCommitPhase } from './phases.js';
 import { handleFailure } from './failure-classifier.js';
-import { PHASE_INDEX, PHASE_ORDER, allocateTaskId, ensureTasksDir, normaliseTaskId, parseFrontMatter, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile, extractSection, RESUMABLE_STATES } from './task-file.js';
+import { PHASE_INDEX, PHASE_ORDER, RESUMABLE_STATES } from './task-types.js';
+import { normaliseTaskId, parseFrontMatter, extractSection } from './task-parsers.js';
+import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
 import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
-import { parseVerifyBlock } from './parsers.js';
+import { parseVerifyBlock } from './spec-validation.js';
 import { formatTimings } from './timings.js';
+import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
 // ─── Module-level state ──────────────────────────────────────────────────────
 let activeTask = null;
 /** Set the module-level active task (avoids `this` aliasing in TaskRunner.run). */
@@ -77,7 +80,7 @@ export class TaskRunner {
             phase: 'refine',
             startedAt: this._startedAt
         };
-        const parentContextWindow = ctx.model?.contextWindow ?? 0;
+        const parentContextWindow = getParentContextWindow(ctx);
         this._deps = {
             cwd,
             taskId: '',
@@ -87,16 +90,7 @@ export class TaskRunner {
                 this._widgetState.lastLine = line;
             },
             onContextUsage: snapshot => {
-                const prev = this._widgetState.contextUsage;
-                const cw = snapshot.contextWindow > 0 ?
-                    snapshot.contextWindow
-                    : prev?.contextWindow || parentContextWindow;
-                const percent = cw > 0 ? Math.min(100, (snapshot.tokens / cw) * 100) : snapshot.percent;
-                this._widgetState.contextUsage = {
-                    tokens: snapshot.tokens,
-                    contextWindow: cw,
-                    percent
-                };
+                this._widgetState.contextUsage = resolveContextUsage(snapshot, this._widgetState.contextUsage, parentContextWindow);
             },
             recordSubStep: (label, ms) => {
                 if (this._currentPhaseChildren) {

package/dist/task/parsers.d.ts

@@ -3,9 +3,6 @@
  *
  * Pure functions that parse raw model output into structured data.
  */
-export interface VerifyCommand {
-    raw: string;
-}
 export type AutoAnswer = {
     kind: 'answered';
     text: string;
@@ -23,9 +20,9 @@ export interface ClarifyQuestion {
 }
 export declare const GRILL_LINE_RE: RegExp;
 export declare const SUGGESTED_LINE_RE: RegExp;
-export declare function parseVerifyBlock(spec: string): VerifyCommand[] | null;
 export declare function parseGrillQuestions(raw: string): string[];
 export declare function parseClarifyList(raw: string): ClarifyQuestion[];
+export declare function autoAnswerHasTag(raw: string): boolean;
 export declare function parseAutoAnswer(raw: string): AutoAnswer;
 export declare function parseVerifyToolingOutput(output: string): {
     verified: string[];
@@ -34,15 +31,4 @@ export declare function parseVerifyToolingOutput(output: string): {
         reason: string;
     }>;
 };
-export declare function isCritiqueClean(text: string): boolean;
-/**
- * Drop any preamble the model emitted before the spec's GOAL header. The
- * thinking model sometimes narrates ("Now I have all the context. Here's the
- * rewritten spec:") before GOAL — the prompts forbid it, but the critique
- * validator only checks for a VERIFY block, so it leaked into the delivered
- * spec. We slice from the first line that begins a GOAL section so the spec
- * starts at GOAL. No GOAL line → returned unchanged (validation then flags it).
- */
-export declare function stripSpecPreamble(spec: string): string;
-export declare function validateSpecShape(spec: string): string | null;
 export declare function deriveTitle(refined: string): string;