claude-overnight 1.25.46 → 1.25.48

package/dist/cli/cli.d.ts

@@ -9,32 +9,11 @@ import { isJWTAuthError } from "../core/auth.js";
 export declare const isAuthError: typeof isJWTAuthError;
 export { isJWTAuthError };
 export declare function fetchModels(timeoutMs?: number): Promise<ModelInfo[]>;
-export declare const PASTE_START = "\u001B[200~";
-export declare const PASTE_END = "\u001B[201~";
 export declare const PASTE_PLACEHOLDER_MAX = 80;
-export type InputSegment = {
-    type: "text";
-    content: string;
-} | {
-    type: "paste";
-    content: string;
-};
-/** Split a raw stdin chunk into typed and pasted segments. */
-export declare function splitPaste(chunk: string): Array<{
-    type: "typed" | "paste";
-    text: string;
-}>;
-export declare function segmentsToString(segs: InputSegment[]): string;
-export declare function renderSegments(segs: InputSegment[]): string;
-export declare function appendCharToSegments(segs: InputSegment[], ch: string): void;
-/** Appends a pasted block. Short single-line pastes inline as text; the rest become placeholders. */
-export declare function appendPasteToSegments(segs: InputSegment[], text: string): void;
-/** Backspace removes one char, or an entire paste block atomically. */
-export declare function backspaceSegments(segs: InputSegment[]): void;
 /**
- * Read a line from the user with bracketed-paste awareness.
- * Pasted multi-line text stays in the buffer as a single block  -- only a typed
- * Enter submits. Falls back to cooked readline when stdin isn't a TTY.
+ * Read a line from the user with bracketed-paste awareness. Pasted multi-line
+ * text stays in the buffer as a single block  -- only a typed Enter submits.
+ * Falls back to cooked readline when stdin isn't a TTY.
  */
 export declare function ask(question: string): Promise<string>;
 export declare function select<T>(label: string, items: {

package/dist/cli/cli.js

@@ -4,6 +4,7 @@ import { resolve } from "path";
 import { createInterface } from "readline";
 import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { parseChunk, setBracketedPaste, deleteWordBackward } from "../ui/raw-input.js";
 // ── CLI flag parsing ──
 export function parseCliFlags(argv) {
     const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget", "merge"]);
@@ -66,69 +67,34 @@ export async function fetchModels(timeoutMs = 10_000) {
         return [];
     }
 }
-// ── Bracketed paste + segment-based input ──
+// ── Interactive primitives ──
 //
-// When the terminal is in bracketed paste mode, pasted content is wrapped with
-// \x1B[200~ ... \x1B[201~ so we can distinguish typed Enter from pasted newlines.
-// Multi-line or long pastes are stored as opaque segments and shown as a compact
-// [Pasted +N lines] placeholder while editing  -- the full text is substituted on submit.
-export const PASTE_START = "\x1B[200~";
-export const PASTE_END = "\x1B[201~";
+// Text entry goes through the shared raw-input parser in `../ui/raw-input.ts`,
+// which enforces the single invariant that used to be duplicated (and buggy)
+// here and in the Ink overlay:
+//   - Typed Enter = a stdin chunk that is exactly "\r", "\n", or "\r\n".
+//   - Anything else with embedded newlines is a paste, not a submit.
+// Multi-line pastes render as a compact `[Pasted +N lines]` placeholder while
+// editing — the full content is substituted on submit.
 export const PASTE_PLACEHOLDER_MAX = 80;
-/** Split a raw stdin chunk into typed and pasted segments. */
-export function splitPaste(chunk) {
-    const out = [];
-    let i = 0;
-    while (i < chunk.length) {
-        const start = chunk.indexOf(PASTE_START, i);
-        if (start === -1) {
-            out.push({ type: "typed", text: chunk.slice(i) });
-            break;
-        }
-        if (start > i)
-            out.push({ type: "typed", text: chunk.slice(i, start) });
-        const bodyStart = start + PASTE_START.length;
-        const end = chunk.indexOf(PASTE_END, bodyStart);
-        if (end === -1) {
-            out.push({ type: "paste", text: chunk.slice(bodyStart) });
-            break;
-        }
-        out.push({ type: "paste", text: chunk.slice(bodyStart, end) });
-        i = end + PASTE_END.length;
-    }
-    return out;
-}
-export function segmentsToString(segs) {
-    return segs.map((s) => s.content).join("");
-}
-export function renderSegments(segs) {
-    return segs.map((s) => {
-        if (s.type === "text")
-            return s.content;
-        const lines = s.content.split("\n").length;
-        return chalk.dim(`[Pasted +${lines} line${lines === 1 ? "" : "s"}]`);
-    }).join("");
-}
-export function appendCharToSegments(segs, ch) {
+function appendTypedChar(segs, ch) {
     const last = segs[segs.length - 1];
     if (last && last.type === "text")
         last.content += ch;
     else
         segs.push({ type: "text", content: ch });
 }
-/** Appends a pasted block. Short single-line pastes inline as text; the rest become placeholders. */
-export function appendPasteToSegments(segs, text) {
+function appendPaste(segs, text) {
     if (!text)
         return;
     const norm = text.replace(/\r\n?/g, "\n");
     if (!norm.includes("\n") && norm.length <= PASTE_PLACEHOLDER_MAX) {
-        appendCharToSegments(segs, norm);
+        appendTypedChar(segs, norm);
         return;
     }
     segs.push({ type: "paste", content: norm });
 }
-/** Backspace removes one char, or an entire paste block atomically. */
-export function backspaceSegments(segs) {
+function backspaceSegs(segs) {
     while (segs.length > 0) {
         const last = segs[segs.length - 1];
         if (last.type === "paste") {
@@ -143,14 +109,22 @@ export function backspaceSegments(segs) {
         return;
     }
 }
+function segsToString(segs) { return segs.map((s) => s.content).join(""); }
+function renderSegs(segs) {
+    return segs.map((s) => {
+        if (s.type === "text")
+            return s.content;
+        const lines = s.content.split("\n").length;
+        return chalk.dim(`[Pasted +${lines} line${lines === 1 ? "" : "s"}]`);
+    }).join("");
+}
 function stripAnsi(s) {
     return s.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
 }
-// ── Interactive primitives ──
 /**
- * Read a line from the user with bracketed-paste awareness.
- * Pasted multi-line text stays in the buffer as a single block  -- only a typed
- * Enter submits. Falls back to cooked readline when stdin isn't a TTY.
+ * Read a line from the user with bracketed-paste awareness. Pasted multi-line
+ * text stays in the buffer as a single block  -- only a typed Enter submits.
+ * Falls back to cooked readline when stdin isn't a TTY.
  */
 export function ask(question) {
     const { stdin, stdout } = process;
@@ -163,28 +137,25 @@ export function ask(question) {
         const tail = question.split("\n").pop() ?? "";
         const tailVisibleLen = stripAnsi(tail).length;
         let prevWrapRows = 0;
-        // Only rewrite the input line (and any wrapped continuation rows). The
-        // question header above is never touched, so redraws can't stack copies
-        // even if the initial write scrolled the viewport.
         const redraw = () => {
             const cols = stdout.columns || 80;
             if (prevWrapRows > 0)
                 stdout.write(`\x1B[${prevWrapRows}A`);
             stdout.write("\r\x1B[J");
-            const rendered = renderSegments(segs);
+            const rendered = renderSegs(segs);
             stdout.write(tail + rendered);
             const visible = tailVisibleLen + stripAnsi(rendered).length;
             prevWrapRows = visible > 0 ? Math.floor((visible - 1) / cols) : 0;
         };
         stdout.write(question);
-        stdout.write("\x1B[?2004h");
+        setBracketedPaste(stdout, true);
         try {
             stdin.setRawMode(true);
         }
         catch { }
         stdin.resume();
         const cleanup = () => {
-            stdout.write("\x1B[?2004l");
+            setBracketedPaste(stdout, false);
             try {
                 stdin.setRawMode(false);
             }
@@ -192,48 +163,44 @@ export function ask(question) {
             stdin.removeListener("data", onData);
             stdin.pause();
         };
+        const submit = () => { stdout.write("\n"); cleanup(); resolve(segsToString(segs).trim()); };
         const onData = (buf) => {
-            const chunk = buf.toString();
-            for (const seg of splitPaste(chunk)) {
-                if (seg.type === "paste") {
-                    appendPasteToSegments(segs, seg.text);
-                    redraw();
-                    continue;
-                }
-                for (let ci = 0; ci < seg.text.length; ci++) {
-                    const ch = seg.text[ci];
-                    if (ch === "\r" || ch === "\n") {
-                        stdout.write("\n");
-                        cleanup();
-                        resolve(segmentsToString(segs).trim());
-                        return;
+            for (const ev of parseChunk(buf.toString())) {
+                switch (ev.type) {
+                    case "char":
+                        appendTypedChar(segs, ev.text);
+                        break;
+                    case "paste":
+                        appendPaste(segs, ev.text);
+                        break;
+                    case "backspace":
+                        backspaceSegs(segs);
+                        break;
+                    case "word-delete": {
+                        const s = segsToString(segs);
+                        const next = deleteWordBackward(s);
+                        segs.length = 0;
+                        if (next)
+                            segs.push({ type: "text", content: next });
+                        break;
                     }
-                    if (ch === "\x03") {
+                    case "clear-line":
+                        segs.length = 0;
+                        break;
+                    case "submit":
+                        submit();
+                        return;
+                    case "cancel":
+                        submit();
+                        return; // lone ESC = submit, preserves old behavior
+                    case "interrupt":
                         cleanup();
                         stdout.write("\n");
                         process.exit(130);
-                    }
-                    if (ch === "\x7F" || ch === "\b") {
-                        backspaceSegments(segs);
-                        redraw();
-                        continue;
-                    }
-                    // ESC submits the current input (same as Enter)
-                    if (ch === "\x1B") {
-                        stdout.write("\n");
-                        cleanup();
-                        resolve(segmentsToString(segs).trim());
-                        return;
-                    }
-                    const code = ch.charCodeAt(0);
-                    if (code < 0x20)
-                        continue; // control chars
-                    if (code >= 0x7F && code < 0xA0)
-                        continue; // DEL + C1 controls
-                    appendCharToSegments(segs, ch);
+                    // tab + nav: ignore during single-line prompts
                 }
-                redraw();
             }
+            redraw();
         };
         stdin.on("data", onData);
     });

package/dist/cli/help.js

@@ -16,6 +16,7 @@ export function printHelp() {
   ${chalk.cyan("Usage")}
     claude-overnight                          ${chalk.dim("interactive mode")}
     claude-overnight tasks.json               ${chalk.dim("task file mode")}
+    claude-overnight plan.md                  ${chalk.dim("plan file mode (.md) — coach + flex")}
     claude-overnight "fix auth" "add tests"   ${chalk.dim("inline tasks")}
 
   ${chalk.cyan("Flags")}
@@ -30,7 +31,8 @@ export function printHelp() {
     --allow-extra-usage    Allow extra/overage usage ${chalk.dim("(default: stop when plan limits hit)")}
     --extra-usage-budget=N Max $ for extra usage ${chalk.dim("(implies --allow-extra-usage)")}
     --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 900s, nudges at timeout, kills at 2×)")}
-    --no-flex              Disable adaptive multi-wave planning ${chalk.dim("(run all tasks in one shot)")}
+    --flex                 Force adaptive multi-wave planning ${chalk.dim("(steering between waves)")}
+    --no-flex              Fixed plan mode ${chalk.dim("(verifier between waves, no re-planning)")}
     --worktrees            Force worktree isolation on ${chalk.dim("(default: auto-detect git repo)")}
     --no-worktrees         Disable worktree isolation ${chalk.dim("(all agents work in real cwd)")}
     --merge=MODE           Merge strategy: yolo or branch ${chalk.dim("(default: yolo)")}

package/dist/core/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.25.46";
+export declare const VERSION = "1.25.48";

package/dist/core/_version.js

@@ -1,2 +1,2 @@
 // Auto-generated by build — do not edit manually.
-export const VERSION = "1.25.46";
+export const VERSION = "1.25.48";

package/dist/index.js

@@ -8,7 +8,7 @@ import { setPlannerEnvResolver } from "./planner/query.js";
 import { setTranscriptRunDir } from "./core/transcripts.js";
 import { pickModel, loadProviders, buildEnvResolver, healthCheckCursorProxy, PROXY_DEFAULT_URL, isCursorProxyProvider, bundledComposerProxyShellCommand, warnMacCursorAgentShellPatchIfNeeded, } from "./providers/index.js";
 import { executeRun } from "./run/run.js";
-import { parseCliFlags, fetchModels, ask, select, selectKey, loadTaskFile, validateConcurrency, isGitRepo, validateGitRepo, showPlan, } from "./cli/cli.js";
+import { parseCliFlags, fetchModels, ask, select, selectKey, loadTaskFile, loadPlanFile, validateConcurrency, isGitRepo, validateGitRepo, showPlan, } from "./cli/cli.js";
 import { loadRunState, findOrphanedDesigns, backfillOrphanedPlans, readPreviousRunKnowledge, createRunDir, updateLatestSymlink, } from "./state/state.js";
 import { runSetupCoach, loadUserSettings, saveUserSettings, COACH_MODEL } from "./planner/coach/coach.js";
 import { editRunSettings, formatSettingsSummary } from "./cli/settings.js";
@@ -63,11 +63,21 @@ async function main() {
     // ── Load tasks ──
     let tasks = [];
     let fileCfg;
+    let planFileContent;
     const jsonFiles = args.filter(a => a.endsWith(".json"));
+    const mdFiles = args.filter(a => a.endsWith(".md"));
     if (jsonFiles.length > 1) {
         console.error(chalk.red(`  Multiple task files provided. Only one .json file is supported.`));
         process.exit(1);
     }
+    if (mdFiles.length > 1) {
+        console.error(chalk.red(`  Multiple plan files provided. Only one .md file is supported.`));
+        process.exit(1);
+    }
+    if (jsonFiles.length && mdFiles.length) {
+        console.error(chalk.red(`  Cannot mix a .json task file with a .md plan file.`));
+        process.exit(1);
+    }
     for (const arg of args) {
         if (arg.endsWith(".json")) {
             if (tasks.length > 0) {
@@ -77,8 +87,13 @@ async function main() {
             fileCfg = loadTaskFile(arg);
             tasks = fileCfg.tasks;
         }
+        else if (arg.endsWith(".md")) {
+            const plan = loadPlanFile(arg);
+            planFileContent = plan.planContent;
+            fileCfg = { tasks: [], objective: plan.objective, flexiblePlan: true };
+        }
         else if (!arg.startsWith("-") && existsSync(resolve(arg))) {
-            console.error(chalk.red(`  "${arg}" looks like a file but doesn't end in .json. Rename it or quote the string.`));
+            console.error(chalk.red(`  "${arg}" looks like a file but doesn't end in .json or .md. Rename it or quote the string.`));
             process.exit(1);
         }
         else {
@@ -341,6 +356,30 @@ async function main() {
         console.log(chalk.dim(`  ╰${"─".repeat(innerLen + 4)}╯`));
     }
     else {
+        // ── Setup coach in confirm-only mode (task/plan file on a TTY) ──
+        let coachResult = null;
+        if (fileCfg?.objective && process.stdin.isTTY
+            && !argv.includes("--no-coach") && !loadUserSettings().skipCoach) {
+            const settings = loadUserSettings();
+            const cModel = settings.coachModel ?? COACH_MODEL;
+            const cProvider = settings.coachProviderId
+                ? loadProviders().find(p => p.id === settings.coachProviderId) : undefined;
+            coachResult = await runSetupCoach(fileCfg.objective, cwd, {
+                providers: loadProviders(), cliFlags, coachModel: cModel, coachProvider: cProvider,
+                planContent: planFileContent, confirmOnly: true,
+            });
+            if (coachResult) {
+                coachedOriginal = fileCfg.objective;
+                coachedAt = Date.now();
+                fileCfg.objective = coachResult.improvedObjective;
+                objective = coachResult.improvedObjective;
+                const rec = coachResult.recommended;
+                if (fileCfg.concurrency == null)
+                    fileCfg.concurrency = rec.concurrency;
+                if (fileCfg.usageCap == null && rec.usageCap != null)
+                    fileCfg.usageCap = Math.round(rec.usageCap * 100);
+            }
+        }
         let models = [];
         if (!cliFlags.model && !fileCfg?.model)
             models = await fetchModels(5_000);
@@ -374,7 +413,7 @@ async function main() {
             }
         }
         concurrency = cliFlags.concurrency ? parseInt(cliFlags.concurrency) : (fileCfg?.concurrency ?? 5);
-        budget = cliFlags.budget ? parseInt(cliFlags.budget) : undefined;
+        budget = cliFlags.budget ? parseInt(cliFlags.budget) : coachResult?.recommended.budget;
         if (budget != null && (isNaN(budget) || budget < 1)) {
             console.error(chalk.red(`  --budget must be a positive integer`));
             process.exit(1);
@@ -442,7 +481,8 @@ async function main() {
         console.log(chalk.dim(`  ${workerModel}  concurrency=${concurrency}  worktrees=${useWorktrees}  merge=${mergeStrategy}${capStr}${extraStr}`));
     }
     // ── Plan phase ──
-    const flex = !argv.includes("--no-flex") && (fileCfg?.flexiblePlan ?? objective != null) && objective != null && (budget ?? 10) > 2;
+    const flexFlag = argv.includes("--flex") ? true : argv.includes("--no-flex") ? false : undefined;
+    const flex = objective != null && (flexFlag ?? ((fileCfg?.flexiblePlan ?? true) && (budget ?? 10) > 2));
     const agentTimeoutMs = cliFlags.timeout ? parseFloat(cliFlags.timeout) * 1000 : undefined;
     let thinkingUsed = 0, thinkingCost = 0, thinkingIn = 0, thinkingOut = 0, thinkingTools = 0;
     let thinkingHistory;

package/dist/planner/verifier.d.ts

@@ -0,0 +1,66 @@
+import type { Task, SteerResult, WaveSummary } from "../core/types.js";
+import { type PlannerLog } from "./query.js";
+export declare const VERIFY_SCHEMA: {
+    type: "json_schema";
+    schema: {
+        type: string;
+        properties: {
+            done: {
+                type: string;
+            };
+            reasoning: {
+                type: string;
+            };
+            statusUpdate: {
+                type: string;
+            };
+            estimatedSessionsRemaining: {
+                type: string;
+            };
+            verifiedCount: {
+                type: string;
+            };
+            retryCount: {
+                type: string;
+            };
+            tasks: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        prompt: {
+                            type: string;
+                        };
+                        model: {
+                            type: string;
+                        };
+                        noWorktree: {
+                            type: string;
+                        };
+                        type: {
+                            type: string;
+                            enum: string[];
+                        };
+                        postcondition: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Verify the previous wave and compose the next fixed batch of pending tasks.
+ *
+ * Unlike `steerWave`, the verifier does not invent new tasks — it:
+ *   1. Runs the project's build/smoke checks.
+ *   2. Fixes shallow regressions in the last wave (edits directly).
+ *   3. Picks the next N pending tasks from the user's fixed plan.
+ *
+ * The model has full tool access so it can actually repair broken commits,
+ * not just report on them.
+ */
+export declare function verifyWave(objective: string, pendingTasks: Task[], lastWave: WaveSummary | undefined, remainingBudget: number, cwd: string, plannerModel: string, concurrency: number, onLog: PlannerLog, transcriptName?: string): Promise<SteerResult>;

package/dist/planner/verifier.js

@@ -0,0 +1,117 @@
+import { runPlannerQuery, attemptJsonParse, postProcess } from "./query.js";
+import { createTurn, beginTurn, endTurn } from "../core/turns.js";
+// Verifier schema — same shape as STEER_SCHEMA plus a `verifiedIds` list so
+// the wave-loop can tell which of the prior wave's tasks actually shipped.
+export const VERIFY_SCHEMA = {
+    type: "json_schema",
+    schema: {
+        type: "object",
+        properties: {
+            done: { type: "boolean" },
+            reasoning: { type: "string" },
+            statusUpdate: { type: "string" },
+            estimatedSessionsRemaining: { type: "number" },
+            verifiedCount: { type: "number" },
+            retryCount: { type: "number" },
+            tasks: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        prompt: { type: "string" },
+                        model: { type: "string" },
+                        noWorktree: { type: "boolean" },
+                        type: { type: "string", enum: ["execute", "explore", "critique", "synthesize", "verify", "user-test", "polish"] },
+                        postcondition: { type: "string" },
+                    },
+                    required: ["prompt"],
+                },
+            },
+        },
+        required: ["done", "tasks", "reasoning", "statusUpdate", "estimatedSessionsRemaining"],
+    },
+};
+function renderLastWave(w) {
+    if (!w)
+        return "(first wave — nothing to verify yet)";
+    const lines = w.tasks.map(t => {
+        const files = t.filesChanged ? ` (${t.filesChanged} files)` : " (0 files)";
+        const err = t.error ? ` — ${t.error}` : "";
+        return `  - [${t.status}] ${t.prompt.slice(0, 160)}${files}${err}`;
+    }).join("\n");
+    return `Wave ${w.wave + 1}:\n${lines}`;
+}
+/**
+ * Verify the previous wave and compose the next fixed batch of pending tasks.
+ *
+ * Unlike `steerWave`, the verifier does not invent new tasks — it:
+ *   1. Runs the project's build/smoke checks.
+ *   2. Fixes shallow regressions in the last wave (edits directly).
+ *   3. Picks the next N pending tasks from the user's fixed plan.
+ *
+ * The model has full tool access so it can actually repair broken commits,
+ * not just report on them.
+ */
+export async function verifyWave(objective, pendingTasks, lastWave, remainingBudget, cwd, plannerModel, concurrency, onLog, transcriptName = "verify") {
+    const pendingList = pendingTasks.length > 0
+        ? pendingTasks.map((t, i) => `  ${i + 1}. ${t.prompt.slice(0, 200)}`).join("\n")
+        : "(none — every task from the original plan has been attempted)";
+    const prompt = `You are the verifier + fix gate between waves of a fixed-plan execution.
+
+Objective: ${objective}
+
+## What just happened
+${renderLastWave(lastWave)}
+
+## Remaining plan (pending tasks, in order)
+${pendingList}
+
+## Your job
+
+1. Run the project's build and smoke checks. Use the tools you have (Bash, Read, Grep, Edit, Write).
+2. For any regression the last wave introduced, make the fix directly. Don't delegate a fix to the next wave if you can do it in two edits.
+3. Compose the next batch of pending tasks to dispatch — pick tasks with non-overlapping file scopes so ${concurrency} can run in parallel.
+4. If the plan is complete AND the build passes AND one verify task has confirmed the app runs, set done=true.
+
+## Output
+
+Respond with ONLY a JSON object (no markdown fences):
+{"done":boolean,"reasoning":"...","statusUpdate":"REQUIRED","estimatedSessionsRemaining":N,"verifiedCount":N,"retryCount":N,"tasks":[{"prompt":"...","type":"execute","postcondition":"..."}]}
+
+Remaining budget: ${remainingBudget} agent sessions. Include retries inside tasks[] (same format) if a pending step needs a second attempt with corrected context.`;
+    onLog("Verifying last wave…", "status");
+    const turn = createTurn("steer", `Verify wave`, `verify-${lastWave?.wave ?? 0}`, plannerModel);
+    beginTurn(turn);
+    const resultText = await runPlannerQuery(prompt, {
+        cwd, model: plannerModel, outputFormat: VERIFY_SCHEMA,
+        transcriptName, turnId: turn.id, maxTurns: 80,
+    }, onLog);
+    const parsed = attemptJsonParse(resultText);
+    if (!parsed) {
+        endTurn(turn, "error");
+        throw new Error(`Could not parse verifier response (${resultText.length} chars): ${resultText.slice(0, 120)}`);
+    }
+    const isDone = parsed.done === true;
+    const statusUpdate = parsed.statusUpdate || undefined;
+    const estRaw = parsed.estimatedSessionsRemaining;
+    const estimatedSessionsRemaining = typeof estRaw === "number" && estRaw >= 0 ? Math.round(estRaw) : undefined;
+    let tasks = (parsed.tasks || []).map((t, i) => ({
+        id: String(i),
+        prompt: typeof t === "string" ? t : t.prompt,
+        ...(t.noWorktree && { noWorktree: true }),
+        ...(t.type && { type: t.type }),
+        ...(typeof t.postcondition === "string" && t.postcondition.trim() && { postcondition: t.postcondition.trim() }),
+    }));
+    tasks = postProcess(tasks, remainingBudget, onLog);
+    endTurn(turn, tasks.length === 0 && !isDone ? "error" : "done");
+    if (isDone) {
+        return {
+            done: true, tasks: [], reasoning: parsed.reasoning || "Plan complete and verified",
+            statusUpdate, estimatedSessionsRemaining: estimatedSessionsRemaining ?? 0,
+        };
+    }
+    return {
+        done: tasks.length === 0, tasks,
+        reasoning: parsed.reasoning || "", statusUpdate, estimatedSessionsRemaining,
+    };
+}

package/dist/run/run.js

@@ -3,6 +3,7 @@ import { join } from "path";
 import { execSync } from "child_process";
 import chalk from "chalk";
 import { steerWave, STEER_SCHEMA } from "../planner/steering.js";
+import { verifyWave } from "../planner/verifier.js";
 import { getTotalPlannerCost, getPlannerRateLimitInfo, runPlannerQuery, setPlannerEnvResolver, attemptJsonParse } from "../planner/query.js";
 import { buildEnvResolver, isCursorProxyProvider } from "../providers/index.js";
 import { RunDisplay } from "../ui/ui.js";
@@ -397,6 +398,33 @@ export async function executeRun(cfg) {
         }
         return steered;
     };
+    // In non-flex mode with an objective, the verifier runs between waves instead of the steerer.
+    const runVerifier = async () => {
+        if (!objective)
+            return false;
+        const plannerCostBefore = getTotalPlannerCost();
+        try {
+            const result = await verifyWave(objective, currentTasks, waveHistory[waveHistory.length - 1], remaining, cwd, plannerModel, concurrency, steeringLog, `verify-wave-${waveNum}`);
+            accCost += getTotalPlannerCost() - plannerCostBefore;
+            syncRunInfo();
+            if (result.statusUpdate)
+                writeStatus(runDir, result.statusUpdate);
+            if (typeof result.estimatedSessionsRemaining === "number")
+                lastEstimate = result.estimatedSessionsRemaining;
+            if (result.done || result.tasks.length === 0) {
+                objectiveComplete = result.done;
+                remaining = 0;
+                return false;
+            }
+            currentTasks = result.tasks;
+            return true;
+        }
+        catch (err) {
+            accCost += getTotalPlannerCost() - plannerCostBefore;
+            display.appendSteeringEvent(`Verifier failed: ${err?.message?.slice(0, 200) || "(no details)"}`);
+            return false;
+        }
+    };
     // Resume: steer immediately if no queued tasks
     if (cfg.resuming && flex && currentTasks.length === 0 && remaining > 0) {
         display.setSteering(rlGetter, buildSteeringContext());
@@ -465,6 +493,7 @@ export async function executeRun(cfg) {
         lastEstimate,
         display,
         runSteering,
+        runVerifier,
         buildSteeringContext,
         rlGetter,
         isStopping: () => stopping,

package/dist/run/wave-loop.d.ts

@@ -46,6 +46,8 @@ export interface WaveLoopCtx {
     lastEstimate: number | undefined;
     display: RunDisplay;
     runSteering: () => Promise<boolean>;
+    /** Verifier invoked between waves in no-flex mode. Mirrors runSteering's contract. */
+    runVerifier?: () => Promise<boolean>;
     buildSteeringContext: () => SteeringContext;
     rlGetter: RLGetter;
     isStopping: () => boolean;