@mjasnikovs/pi-task 0.2.0

package/dist/task/orchestrator.js

@@ -0,0 +1,387 @@
+/**
+ * pi-task — deterministic spec orchestrator for local models.
+ *
+ * Drives the prompt through five phases — refine → research → grill → compose →
+ * critique — then hands the final spec to the main pi thread via
+ * pi.sendUserMessage so the user can keep working in the main conversation.
+ *
+ * Slash commands:
+ *   /task <prompt>         start a new task
+ *   /task-list             open the task list in an editor dialog
+ *   /task-resume [id]      resume the most recent (or named) non-completed task
+ *   /task-cancel           cancel the running task (soft-terminal — still resumable)
+ *
+ * The orchestrator persists after every phase boundary to
+ * <cwd>/.pi-tasks/TASK_NNNN.md. All user interaction during phases runs through
+ * ctx.ui dialogs; the main pi chat only receives the final spec.
+ */
+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 { startWidget, WIDGET_KEY } from './widget.js';
+import { parseVerifyBlock } from './parsers.js';
+import { formatTimings } from './timings.js';
+// ─── Module-level state ──────────────────────────────────────────────────────
+let activeTask = null;
+/** Set the module-level active task (avoids `this` aliasing in TaskRunner.run). */
+function setActiveTask(runner) {
+    activeTask = runner;
+}
+function clearActiveTask(runner) {
+    if (activeTask === runner) {
+        activeTask = null;
+    }
+}
+// Captured from the factory so command handlers can call pi.sendUserMessage.
+let piApi = null;
+// ─── TaskRunner class ────────────────────────────────────────────────────────
+/** Encapsulates the full lifecycle of a single pi-task run. */
+export class TaskRunner {
+    _ctx;
+    _cwd;
+    _rawPrompt;
+    _resumeId;
+    _sendSpec;
+    _abort = new AbortController();
+    _startedAt;
+    _widgetState;
+    _stopWidget = null;
+    _deps;
+    _pc;
+    /**
+     * Per-phase wall-clock durations collected during the run. Written to the
+     * `## phase timings` section on successful completion so we can spot
+     * regressions and target future speed work. Each top-level entry is a
+     * phase (refine/research/grill/compose/critique); children are optional
+     * sub-step splits the phase chose to record via deps.recordSubStep.
+     */
+    _timings = [];
+    _currentPhaseChildren = null;
+    constructor(ctx, cwd, rawPrompt, resumeId, sendSpec, spawnFn) {
+        this._ctx = ctx;
+        this._cwd = cwd;
+        this._rawPrompt = rawPrompt;
+        this._resumeId = resumeId;
+        this._sendSpec = sendSpec;
+        this._startedAt = Date.now();
+        // We'll populate id/title/phase lazily in run().
+        // Placeholder — real values set in run().
+        this._widgetState = {
+            taskId: '',
+            title: '',
+            phase: 'refine',
+            startedAt: this._startedAt
+        };
+        const parentContextWindow = ctx.model?.contextWindow ?? 0;
+        this._deps = {
+            cwd,
+            taskId: '',
+            signal: this._abort.signal,
+            spawn: spawnFn,
+            onChildOutput: (line) => {
+                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
+                };
+            },
+            recordSubStep: (label, ms) => {
+                if (this._currentPhaseChildren) {
+                    this._currentPhaseChildren.push({ label, ms, children: [] });
+                }
+            }
+        };
+        this._pc = {
+            cwd,
+            id: '',
+            ctx,
+            widgetState: this._widgetState,
+            rawPrompt,
+            refined: '',
+            research: '',
+            qa: '',
+            spec: ''
+        };
+    }
+    get taskId() {
+        return this._widgetState.taskId;
+    }
+    get signal() {
+        return this._abort.signal;
+    }
+    /** Return the current widget state, or null if not started. */
+    status() {
+        return this._widgetState.taskId ? this._widgetState : null;
+    }
+    /** Cancel the running task by aborting the signal. */
+    cancel() {
+        this._abort.abort();
+    }
+    /** Execute the full task lifecycle. */
+    async run() {
+        const cwd = this._cwd;
+        const ctx = this._ctx;
+        // Initialise or resume the TASK file.
+        let id;
+        let title;
+        let resumePhase = 'refine';
+        if (this._resumeId) {
+            id = this._resumeId;
+            const { frontMatter } = await readTaskFile(cwd, id);
+            title = frontMatter.title;
+            resumePhase = frontMatter.phase;
+            await updateTaskFrontMatter(cwd, id, { state: 'in_progress' });
+        }
+        else {
+            id = await allocateTaskId(cwd);
+            title = '(refining…)';
+            const now = new Date().toISOString();
+            const fm = {
+                id,
+                state: 'in_progress',
+                phase: 'refine',
+                created_at: now,
+                updated_at: now,
+                title
+            };
+            await writeTaskFile(cwd, fm, `\n## raw prompt\n\n${this._rawPrompt.trim() || '(none)'}\n`);
+        }
+        // Register as active.
+        this._widgetState.taskId = id;
+        this._widgetState.title = title;
+        this._widgetState.phase = resumePhase;
+        this._widgetState.startedAt = this._startedAt;
+        this._deps.taskId = id;
+        this._pc.id = id;
+        setActiveTask(this);
+        this._stopWidget = startWidget(ctx, () => this.status());
+        const advance = async (phase) => {
+            this._widgetState.phase = phase;
+            this._widgetState.lastLine = undefined;
+            this._widgetState.contextUsage = undefined;
+            await updateTaskFrontMatter(cwd, id, { phase });
+        };
+        try {
+            const resumeIdx = PHASE_INDEX[resumePhase];
+            if (resumeIdx === 0) {
+                const { body } = await readTaskFile(cwd, id);
+                const onDisk = extractSection(body, 'raw prompt');
+                if (onDisk)
+                    this._pc.rawPrompt = onDisk;
+            }
+            for (const phase of PHASES) {
+                const idx = PHASE_INDEX[phase.name];
+                if (idx < resumeIdx) {
+                    this._pc[phase.field] = (await readSection(cwd, id, phase.section)) ?? '';
+                    continue;
+                }
+                await advance(phase.name);
+                const children = [];
+                this._currentPhaseChildren = children;
+                const phaseStart = Date.now();
+                let out;
+                try {
+                    out = await phase.run(this._deps, this._pc);
+                }
+                finally {
+                    this._timings.push({
+                        label: phase.name,
+                        ms: Date.now() - phaseStart,
+                        children
+                    });
+                    this._currentPhaseChildren = null;
+                }
+                await setTaskSection(cwd, id, phase.section, out);
+                this._pc[phase.field] = out;
+                await postCommitPhase(phase, this._pc, out);
+            }
+            // All phases done — hand off the spec.
+            await advance('done');
+            if (parseVerifyBlock(this._pc.spec) === null)
+                throw new Error('no_verify_block');
+            await updateTaskFrontMatter(cwd, id, { state: 'completed', phase: 'done' });
+            this._stopWidget?.();
+            try {
+                ctx.ui.setWidget(WIDGET_KEY, undefined);
+            }
+            catch {
+                /* stale ctx */
+            }
+            await setTaskSection(cwd, id, 'phase timings', formatTimings(this._timings));
+            await setTaskSection(cwd, id, 'handoff', `handoff_at: ${new Date().toISOString()}`);
+            await this._deliverSpec(ctx);
+        }
+        catch (err) {
+            this._stopWidget?.();
+            // Persist whatever timings we collected so failed runs are still
+            // useful for analysis. Best-effort — never mask the original error.
+            if (this._timings.length > 0) {
+                try {
+                    await setTaskSection(cwd, id, 'phase timings', formatTimings(this._timings));
+                }
+                catch {
+                    /* ignore — preserve original failure */
+                }
+            }
+            await handleFailure(err, ctx, cwd, id, this._abort.signal.aborted);
+        }
+        finally {
+            this._stopWidget?.();
+            clearActiveTask(this);
+        }
+    }
+    async _deliverSpec(ctx) {
+        if (this._sendSpec) {
+            await this._sendSpec(this._pc.spec);
+            return;
+        }
+        if (!piApi) {
+            throw new Error('extension not initialised (no ExtensionAPI captured)');
+        }
+        if (ctx.isIdle()) {
+            piApi.sendUserMessage(this._pc.spec);
+        }
+        else {
+            piApi.sendUserMessage(this._pc.spec, { deliverAs: 'followUp' });
+        }
+    }
+}
+// ─── Command handlers ────────────────────────────────────────────────────────
+async function handleTask(args, ctx) {
+    await ctx.waitForIdle();
+    const cwd = ctx.cwd;
+    const raw = args.trim();
+    if (raw.length === 0) {
+        ctx.ui.setEditorText('/task ');
+        ctx.ui.notify('Type your prompt after /task (use @ for file completion).', 'info');
+        return;
+    }
+    const result = await ctx.newSession({
+        withSession: async (newCtx) => {
+            const runner = new TaskRunner(newCtx, cwd, raw, undefined, async (spec) => {
+                await newCtx.sendUserMessage(spec);
+            });
+            await runner.run();
+        }
+    });
+    if (result.cancelled) {
+        ctx.ui.notify('Could not start a fresh session for /task.', 'warning');
+    }
+}
+async function handleTaskList(_args, ctx) {
+    const cwd = ctx.cwd;
+    await ensureTasksDir(cwd);
+    const entries = await fsp.readdir(tasksDir(cwd));
+    const taskFiles = entries.filter((e) => /^TASK_\d+\.md$/.test(e));
+    const rows = [];
+    for (const f of taskFiles) {
+        try {
+            const raw = await fsp.readFile(path.join(tasksDir(cwd), f), 'utf8');
+            const fm = parseFrontMatter(raw);
+            if (!fm)
+                continue;
+            const st = await fsp.stat(path.join(tasksDir(cwd), f));
+            rows.push({ fm, mtime: st.mtimeMs });
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+    rows.sort((a, b) => b.mtime - a.mtime);
+    const lines = [];
+    for (const { fm } of rows) {
+        const idx = PHASE_INDEX[fm.phase];
+        const phasePart = `phase ${Math.min(idx + 1, PHASE_ORDER.length)}/${PHASE_ORDER.length} ${fm.phase}`;
+        const date = fm.updated_at.replace('T', ' ').slice(0, 16);
+        lines.push(`${fm.id}  ${fm.state.padEnd(12)}  ${phasePart.padEnd(24)}  ${date}  "${fm.title}"`);
+    }
+    if (lines.length === 0)
+        lines.push('(no tasks in .pi-tasks/)');
+    lines.push('', 'resume: /task-resume <id>   (eligible: in_progress, pending, cancelled, failed)');
+    await ctx.ui.editor('Tasks', lines.join('\n'));
+}
+async function handleTaskResume(args, ctx) {
+    await ctx.waitForIdle();
+    const cwd = ctx.cwd;
+    let id;
+    if (args.trim().length > 0) {
+        id = normaliseTaskId(args);
+        try {
+            await fsp.access(taskFilePath(cwd, id));
+        }
+        catch {
+            ctx.ui.notify(`${id} not found in .pi-tasks/`, 'error');
+            return;
+        }
+    }
+    else {
+        await ensureTasksDir(cwd);
+        const entries = await fsp.readdir(tasksDir(cwd));
+        const candidates = [];
+        for (const f of entries) {
+            const m = /^(TASK_\d+)\.md$/.exec(f);
+            if (!m)
+                continue;
+            try {
+                const raw = await fsp.readFile(path.join(tasksDir(cwd), f), 'utf8');
+                const fm = parseFrontMatter(raw);
+                if (!fm)
+                    continue;
+                if (!RESUMABLE_STATES.includes(fm.state))
+                    continue;
+                const st = await fsp.stat(path.join(tasksDir(cwd), f));
+                candidates.push({ id: m[1], mtime: st.mtimeMs });
+            }
+            catch {
+                /* skip */
+            }
+        }
+        candidates.sort((a, b) => b.mtime - a.mtime);
+        if (candidates.length === 0) {
+            ctx.ui.notify('No resumable tasks.', 'info');
+            return;
+        }
+        id = candidates[0].id;
+    }
+    const runner = new TaskRunner(ctx, cwd, '', id);
+    await runner.run();
+}
+// eslint-disable-next-line @typescript-eslint/require-await
+async function handleTaskCancel(_args, ctx) {
+    if (!activeTask) {
+        ctx.ui.notify('No task is running.', 'info');
+        return;
+    }
+    activeTask.cancel();
+    ctx.ui.notify(`Cancelling ${activeTask.taskId}…`, 'warning');
+}
+// ─── Entry point ─────────────────────────────────────────────────────────────
+export function registerTask(pi) {
+    piApi = pi;
+    pi.registerCommand('task', {
+        description: 'Start a new task. Usage: /task <prompt>',
+        handler: handleTask
+    });
+    pi.registerCommand('task-list', {
+        description: 'List tasks in this project.',
+        handler: handleTaskList
+    });
+    pi.registerCommand('task-resume', {
+        description: 'Resume a task. Usage: /task-resume [id]',
+        handler: handleTaskResume
+    });
+    pi.registerCommand('task-cancel', {
+        description: 'Cancel the currently running task.',
+        handler: handleTaskCancel
+    });
+}

package/dist/task/parsers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Output parsers for the pi-task pipeline.
+ *
+ * Pure functions that parse raw model output into structured data.
+ */
+export interface VerifyCommand {
+    raw: string;
+}
+export type AutoAnswer = {
+    kind: 'answered';
+    text: string;
+    raw: string;
+} | {
+    kind: 'unknown';
+    suggested?: string;
+    raw: string;
+};
+export declare const GRILL_LINE_RE: RegExp;
+export declare const TITLE_MAX_CHARS = 120;
+export declare function parseVerifyBlock(spec: string): VerifyCommand[] | null;
+export declare function parseGrillQuestions(raw: string): string[];
+export declare function parseAutoAnswer(raw: string): AutoAnswer;
+export declare function parseVerifyToolingOutput(output: string): {
+    verified: string[];
+    rejected: Array<{
+        cmd: string;
+        reason: string;
+    }>;
+};
+export declare function isCritiqueClean(text: string): boolean;
+export declare function validateSpecShape(spec: string): string | null;
+export declare function deriveTitle(refined: string): string;

package/dist/task/parsers.js

@@ -0,0 +1,172 @@
+/**
+ * Output parsers for the pi-task pipeline.
+ *
+ * Pure functions that parse raw model output into structured data.
+ */
+import { MAX_GRILL_QUESTIONS } from './phases.js';
+// ─── Constants ───────────────────────────────────────────────────────────────
+export const GRILL_LINE_RE = /^\s*\d+[.)]\s+(.+)$/;
+export const TITLE_MAX_CHARS = 120;
+// ─── Verify block parser ─────────────────────────────────────────────────────
+export function parseVerifyBlock(spec) {
+    const lines = spec.split('\n');
+    let i = 0;
+    while (i < lines.length && !/^VERIFY:\s*$/.test(lines[i]))
+        i++;
+    if (i >= lines.length)
+        return null;
+    i++;
+    while (i < lines.length && lines[i].trim() === '')
+        i++;
+    if (i >= lines.length)
+        return null;
+    if (!/^```(sh|bash)?\s*$/.test(lines[i]))
+        return null;
+    i++;
+    const cmds = [];
+    while (i < lines.length && !/^```\s*$/.test(lines[i])) {
+        const line = lines[i].trim();
+        if (line.length > 0 && !line.startsWith('#'))
+            cmds.push({ raw: line });
+        i++;
+    }
+    return cmds;
+}
+// ─── Grill questions parser ──────────────────────────────────────────────────
+// The grill-gen prompt instructs the worker to emit the literal token `NONE`
+// when it has zero questions, so the runner's empty-output guard can still
+// distinguish "intentional silence" from a silent child crash.
+export function parseGrillQuestions(raw) {
+    if (/^\s*NONE\s*$/m.test(raw))
+        return [];
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const m = GRILL_LINE_RE.exec(line);
+        if (m)
+            out.push(m[1].trim());
+        if (out.length >= MAX_GRILL_QUESTIONS)
+            break;
+    }
+    return out;
+}
+// ─── Auto-answer parser ──────────────────────────────────────────────────────
+export function parseAutoAnswer(raw) {
+    const lines = raw
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l.length > 0);
+    for (let i = 0; i < lines.length; i++) {
+        const t = lines[i];
+        const a = /^AN[SW]{1,3}E?R:\s*(.+)$/i.exec(t);
+        if (a)
+            return { kind: 'answered', text: a[1].trim(), raw };
+        const u = /^UNKNOWN:\s*(.*)$/i.exec(t);
+        if (u) {
+            const inline = u[1].trim();
+            if (inline.length > 0)
+                return { kind: 'unknown', suggested: inline, raw };
+            const next = lines[i + 1];
+            if (next && next.length > 0)
+                return { kind: 'unknown', suggested: next, raw };
+            return { kind: 'unknown', raw };
+        }
+    }
+    if (lines.length > 0)
+        return { kind: 'unknown', suggested: lines[0], raw };
+    return { kind: 'unknown', raw };
+}
+// ─── Verify tooling output parser ────────────────────────────────────────────
+export function parseVerifyToolingOutput(output) {
+    const verified = [];
+    const rejected = [];
+    let section = null;
+    for (const raw of output.split('\n')) {
+        const line = raw.trim();
+        if (line === 'VERIFIED') {
+            section = 'verified';
+            continue;
+        }
+        if (line === 'REJECTED') {
+            section = 'rejected';
+            continue;
+        }
+        if (!line)
+            continue;
+        // Lines look like: "  <cmd>  <evidence/reason>"
+        const match = line.match(/^(\S.*?)\s{2,}(.+)$/);
+        if (!match)
+            continue;
+        const [, cmd, detail] = match;
+        if (section === 'verified')
+            verified.push(cmd.trim());
+        else if (section === 'rejected')
+            rejected.push({ cmd: cmd.trim(), reason: detail.trim() });
+    }
+    return { verified, rejected };
+}
+// ─── Critique triage parser ──────────────────────────────────────────────────
+// The critique-triage prompt instructs the worker to emit the literal token
+// `CLEAN` on its own line when the compose draft has no substantive defects, so
+// we can skip the expensive full-rewrite pass. Anything else is treated as a
+// defect list that gets fed into the rewrite. Empty output is NOT clean — that
+// would be a silent crash, and treating it as clean would skip review entirely.
+export function isCritiqueClean(text) {
+    const firstLine = text
+        .split('\n')
+        .map(l => l.trim())
+        .find(l => l.length > 0);
+    if (!firstLine)
+        return false;
+    return /^CLEAN[.!]?$/i.test(firstLine);
+}
+// ─── Spec shape validator ────────────────────────────────────────────────────
+export function validateSpecShape(spec) {
+    const trimmed = spec.trim();
+    if (trimmed.length === 0)
+        return 'spec is empty';
+    const firstLine = trimmed.split('\n', 1)[0];
+    if (/^\s*```/.test(firstLine))
+        return 'spec starts with a markdown fence';
+    if (/^\s*cat\s*<<\s*['"]?[A-Za-z_][A-Za-z0-9_]*['"]?/.test(firstLine)) {
+        return 'spec is wrapped in a cat heredoc';
+    }
+    if (!/^GOAL\b/i.test(trimmed))
+        return 'spec does not start with GOAL';
+    for (const section of ['CONSTRAINTS', 'ACCEPTANCE', 'VERIFY']) {
+        if (!new RegExp(`^\\s*${section}\\b`, 'm').test(trimmed)) {
+            return `spec missing required section: ${section}`;
+        }
+    }
+    return null;
+}
+// ─── Title derivation ────────────────────────────────────────────────────────
+export function deriveTitle(refined) {
+    const lines = refined.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = lines[i].trim().replace(/^#+\s+/, '');
+        if (/^GOAL\s*:?\s*$/i.test(stripped)) {
+            for (let j = i + 1; j < lines.length; j++) {
+                const line = lines[j].trim();
+                if (line.length === 0)
+                    continue;
+                const headerCheck = line.replace(/^#+\s+/, '');
+                if (/^(CONSTRAINTS|KNOWN-UNKNOWNS)\s*:?\s*$/i.test(headerCheck))
+                    break;
+                return line.length > TITLE_MAX_CHARS ?
+                    line.slice(0, TITLE_MAX_CHARS - 1) + '…'
+                    : line;
+            }
+            break;
+        }
+    }
+    for (const raw of lines) {
+        let line = raw.trim();
+        if (line.length === 0)
+            continue;
+        line = line.replace(/^#+\s+/, '').replace(/^GOAL\s*:?\s*/i, '');
+        if (line.length === 0)
+            continue;
+        return line.length > TITLE_MAX_CHARS ? line.slice(0, TITLE_MAX_CHARS - 1) + '…' : line;
+    }
+    return '(untitled)';
+}

package/dist/task/phases.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Phase pipeline — the five phase functions (refine, research, grill, compose,
+ * critique) plus the config table that drives the orchestrator loop.
+ */
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import { docsRaw, docsFocused } from '../workers/docs-core.js';
+import { fetchRaw, fetchFocused } from '../workers/fetch-core.js';
+import type { SearchCoreInput, SearchCoreResult } from '../workers/search-core.js';
+import { type PhaseName } from './task-file.js';
+import { type WidgetState } from './widget.js';
+import { type AutoAnswer } from './parsers.js';
+import { type PhaseDeps } from './child-runner.js';
+export { MAX_GRILL_QUESTIONS } from './prompts.js';
+export interface PhaseContext {
+    cwd: string;
+    id: string;
+    ctx: ExtensionCommandContext;
+    widgetState: WidgetState;
+    rawPrompt: string;
+    refined: string;
+    research: string;
+    qa: string;
+    spec: string;
+}
+export type OutputField = 'refined' | 'research' | 'qa' | 'spec';
+export interface PhaseConfig {
+    name: PhaseName;
+    section: string;
+    field: OutputField;
+    run: (deps: PhaseDeps, pc: PhaseContext) => Promise<string>;
+}
+/** Extract the TOOLING section commands from a research output string. */
+export declare function extractToolingCommands(research: string): string[] | null;
+/** Replace the TOOLING section in a research string with a VERIFIED-TOOLING section. */
+export declare function replaceToolingWithVerified(research: string, verifiedCommands: string[]): string;
+export declare const phaseRefine: (deps: PhaseDeps, raw: string) => Promise<string>;
+export declare function phaseVerifyTooling(deps: PhaseDeps, research: string): Promise<string>;
+export interface PhaseResearchDeps {
+    docsRaw?: typeof docsRaw;
+    fetchRaw?: typeof fetchRaw;
+    getFileInventory?: (cwd: string, signal?: AbortSignal) => Promise<string>;
+    searchFn?: (input: SearchCoreInput) => Promise<SearchCoreResult>;
+}
+export declare function phaseResearch(deps: PhaseDeps, refined: string, researchDeps?: PhaseResearchDeps): Promise<string>;
+export interface PhaseAutoAnswerDeps {
+    docsFocused?: typeof docsFocused;
+    fetchFocused?: typeof fetchFocused;
+    searchFn?: (input: SearchCoreInput) => Promise<SearchCoreResult>;
+}
+export declare function phaseAutoAnswer(deps: PhaseDeps, refined: string, research: string, question: string, autoDeps?: PhaseAutoAnswerDeps): Promise<AutoAnswer>;
+export declare function phaseGrill(deps: PhaseDeps, ctx: ExtensionCommandContext, widgetState: WidgetState, refined: string, research: string): Promise<string>;
+export declare function phaseCompose(deps: PhaseDeps, refined: string, research: string, qa: string): Promise<string>;
+export declare function phaseCritique(deps: PhaseDeps, spec: string, refined: string, qa: string): Promise<string>;
+export declare function critiqueWithFallback(d: PhaseDeps, p: PhaseContext): Promise<string>;
+export declare const PHASES: PhaseConfig[];
+export declare function postCommitPhase(phase: PhaseConfig, pc: PhaseContext, out: string): Promise<void>;