claude-overnight 1.25.33 → 1.25.37

package/dist/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.25.33";
+export declare const VERSION = "1.25.37";

package/dist/_version.js

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

package/dist/index.js

@@ -839,8 +839,10 @@ async function main() {
                 statusLineActive = false;
             }
         };
-        /** Cursor agent cold start + thinking-variant model latency can exceed 20s; API providers stay tight. */
-        const preflightMs = (p) => isCursorProxyProvider(p) ? 60_000 : 20_000;
+        /** Cursor agent cold start + thinking-variant model latency can exceed 20s, and the cursor
+         *  preflight now also runs a write-capability probe (see probeCursorWriteCapability) that
+         *  asks cursor to Bash a marker file — so the total budget must cover auth ping + write turn. */
+        const preflightMs = (p) => isCursorProxyProvider(p) ? 90_000 : 20_000;
         const results = await Promise.all(pending.map(async ([role, p]) => {
             statuses.set(role, "connecting…");
             renderStatus();

package/dist/interactive-panel.d.ts

@@ -1,4 +1,9 @@
 export type PanelMode = "debrief" | "ask" | "custom" | "none";
+export interface DebriefEntry {
+    label: string;
+    text: string;
+    time: number;
+}
 /** Mutable state of the interactive panel. */
 export interface PanelState {
     mode: PanelMode;
@@ -11,12 +16,16 @@ export interface PanelState {
 export declare class InteractivePanel {
     state: PanelState;
     private _bodyLines;
+    /** Accumulated debrief entries — each wave/phase appends one. */
+    private _debriefHistory;
     set(params: {
         mode: PanelMode;
         header: string;
         preview: string;
         body: string;
     }): void;
+    /** Append a debrief entry to the running history. Only meaningful in debrief mode. */
+    appendHistory(label: string, text: string): void;
     /** Close the panel entirely (set mode to "none"). */
     close(): void;
     collapse(): void;

package/dist/interactive-panel.js

@@ -1,5 +1,5 @@
-const DARK_GREEN_BG = "\x1B[48;5;22m";
-const LIGHT_GREEN_FG = "\x1B[38;5;156m";
+const BLACK_BG = "\x1B[48;5;232m";
+const SUBTLE_FG = "\x1B[38;5;108m";
 const BRIGHT_WHITE_FG = "\x1B[38;5;231m";
 const SOFT_GREEN_FG = "\x1B[38;5;114m";
 const RESET = "\x1B[0m";
@@ -15,7 +15,7 @@ function truncate(s, max) {
 }
 /** Wrap a plain (ANSI-free) line in the dark-green bg, padded to width. */
 function bgLine(text, width) {
-    return `${DARK_GREEN_BG}${LIGHT_GREEN_FG}${padTo(text, width)}${RESET}`;
+    return `${BLACK_BG}${SUBTLE_FG}${padTo(text, width)}${RESET}`;
 }
 export class InteractivePanel {
     state = {
@@ -27,6 +27,8 @@ export class InteractivePanel {
         body: "",
     };
     _bodyLines = [];
+    /** Accumulated debrief entries — each wave/phase appends one. */
+    _debriefHistory = [];
     set(params) {
         this.state.mode = params.mode;
         this.state.header = params.header;
@@ -34,6 +36,19 @@ export class InteractivePanel {
         this.state.body = params.body;
         this._bodyLines = params.body.split("\n").filter(l => l.length > 0);
         this.state.scrollOffset = 0;
+        // Clear history when mode changes away from debrief
+        if (params.mode !== "debrief")
+            this._debriefHistory = [];
+    }
+    /** Append a debrief entry to the running history. Only meaningful in debrief mode. */
+    appendHistory(label, text) {
+        if (this.state.mode !== "debrief")
+            return;
+        this._debriefHistory.push({ label, text, time: Date.now() });
+        // Rebuild body from full history so expanded view shows everything
+        const historyBody = this._debriefHistory.map(e => `  ${e.label}\n  ${e.text}`).join("\n\n");
+        this.state.body = historyBody;
+        this._bodyLines = historyBody.split("\n");
     }
     /** Close the panel entirely (set mode to "none"). */
     close() {

package/dist/planner-query.js

@@ -454,9 +454,9 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
 export function postProcess(raw, budget, onLog) {
     let tasks = raw;
     const before = tasks.length;
-    tasks = tasks.filter((t) => t.prompt && t.prompt.trim().split(/\s+/).length >= 3);
+    tasks = tasks.filter((t) => t.prompt && t.prompt.trim().length >= 1);
     if (tasks.length < before)
-        onLog(`Filtered ${before - tasks.length} task(s) with fewer than 3 words`);
+        onLog(`Filtered ${before - tasks.length} task(s) with empty prompt`);
     // Read-only tasks (verify/audit/user-test) shouldn't get a worktree: they
     // don't change files, so they'd just create empty swarm branches that show
     // up as "0 files changed" noise. Run them in the real project directory so

package/dist/providers.js

@@ -1,4 +1,5 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, realpathSync, openSync, statSync, readSync, closeSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, realpathSync, openSync, statSync, readSync, closeSync, unlinkSync } from "fs";
+import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
 import { homedir } from "os";
 import { join, dirname } from "path";
@@ -147,10 +148,10 @@ export function envFor(p) {
         // SDK replaces env for subprocesses — force these so nothing inherits a bad CI / skip flag.
         base.CI = "true";
         base.CURSOR_SKIP_KEYCHAIN = "1";
-        // Bridge mode controls the agent behavior: "plan" enables tool use (Read,
-        // Glob, Grep, Write, Bash), "ask" gives a chat-only assistant. Planner
-        // agents and workers must use "plan" so they actually interact with the codebase.
-        base.CURSOR_BRIDGE_MODE = "plan";
+        // "agent" omits --mode so cursor-agent runs full agentic mode (Read,
+        // Glob, Grep, Write, Bash). Passing --mode plan or ask forces read-only —
+        // Write/Bash tool calls are silently dropped, exit 0, empty stdout.
+        base.CURSOR_BRIDGE_MODE = "agent";
         // Use system Node.js for agent subprocess to avoid macOS segfaults with
         // bundled Node.js. Resolve lazily.
         if (!_cachedAgentNode || !_cachedAgentScript) {
@@ -382,6 +383,10 @@ async function preflightCursorProxyViaHttp(p, timeoutMs, opts) {
     const headers = { "content-type": "application/json" };
     if (key)
         headers["authorization"] = `Bearer ${key}`;
+    // Shared deadline: auth ping + write probe split the total timeout budget.
+    const overallDeadlineAt = Date.now() + timeoutMs;
+    const remaining = () => Math.max(1_000, overallDeadlineAt - Date.now());
+    const authBudget = Math.max(5_000, Math.floor(timeoutMs / 2));
     const controller = new AbortController();
     let elapsed = 0;
     const PROGRESS_INTERVAL_MS = 3_000;
@@ -389,7 +394,7 @@ async function preflightCursorProxyViaHttp(p, timeoutMs, opts) {
         elapsed += PROGRESS_INTERVAL_MS;
         opts?.onProgress?.(`still waiting… (${(elapsed / 1000).toFixed(1)}s)`);
     }, PROGRESS_INTERVAL_MS);
-    const deadline = setTimeout(() => controller.abort(), timeoutMs);
+    const deadline = setTimeout(() => controller.abort(), authBudget);
     try {
         // max_tokens must accommodate thinking tokens for `*-thinking-*` variants —
         // 1 token leaves zero reasoning budget and crashes the cursor-agent subprocess
@@ -410,7 +415,6 @@ async function preflightCursorProxyViaHttp(p, timeoutMs, opts) {
         }
         // Drain body so the connection closes cleanly; we don't care about content.
         await res.text().catch(() => "");
-        return { ok: true };
     }
     catch (err) {
         if (err?.name === "AbortError") {
@@ -422,6 +426,82 @@ async function preflightCursorProxyViaHttp(p, timeoutMs, opts) {
         clearTimeout(deadline);
         clearInterval(progressTimer);
     }
+    // Write-capability probe — catches the --mode plan / ask regression where
+    // the proxy silently swallows Write/Bash tool calls (exit 0, empty body,
+    // no file changes). Ask cursor to write a unique marker file; fail if the
+    // file doesn't appear. Keeps the first wave from silently burning budget.
+    opts?.onProgress?.(`probing write capability…`);
+    const probeErr = await probeCursorWriteCapability(baseURL, key, p.model, remaining(), opts);
+    if (probeErr)
+        return { ok: false, error: probeErr };
+    return { ok: true };
+}
+/**
+ * Ask the proxy to create a unique marker file via its Bash tool; verify the
+ * file appeared on disk. Returns an error string on failure, null on success.
+ *
+ * Failure modes caught:
+ * - `CURSOR_BRIDGE_MODE=plan|ask` silently drops Write/Bash (regression fixed in
+ *   cursor-composer-in-claude 0.9.3; this keeps older proxy versions actionable).
+ * - Workspace is untrusted or agent is otherwise nonfunctional — exit 0 with
+ *   no side effects.
+ */
+async function probeCursorWriteCapability(baseURL, key, model, timeoutMs, opts) {
+    const marker = `co-probe-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const probeFile = join(tmpdir(), `${marker}.txt`);
+    try {
+        unlinkSync(probeFile);
+    }
+    catch { }
+    const prompt = `Run this exact shell command via your Bash tool, then reply with only the word DONE:\n` +
+        `printf 'ok' > ${probeFile}`;
+    const controller = new AbortController();
+    let elapsed = 0;
+    const PROGRESS_INTERVAL_MS = 3_000;
+    const progressTimer = setInterval(() => {
+        elapsed += PROGRESS_INTERVAL_MS;
+        opts?.onProgress?.(`write probe… (${(elapsed / 1000).toFixed(1)}s)`);
+    }, PROGRESS_INTERVAL_MS);
+    const deadline = setTimeout(() => controller.abort(), timeoutMs);
+    const headers = { "content-type": "application/json" };
+    if (key)
+        headers["authorization"] = `Bearer ${key}`;
+    try {
+        const res = await fetch(`${baseURL}/v1/messages`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                messages: [{ role: "user", content: prompt }],
+            }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            return `write probe: HTTP ${res.status}: ${text.slice(0, 200)}`;
+        }
+        await res.text().catch(() => "");
+    }
+    catch (err) {
+        if (err?.name === "AbortError")
+            return `write probe: timeout after ${Math.round(timeoutMs / 1000)}s`;
+        return `write probe: ${String(err?.message || err).slice(0, 200)}`;
+    }
+    finally {
+        clearTimeout(deadline);
+        clearInterval(progressTimer);
+    }
+    if (!existsSync(probeFile)) {
+        return (`write probe: cursor returned without creating the marker file. ` +
+            `Most likely cause: CURSOR_BRIDGE_MODE=plan|ask (silent read-only mode). ` +
+            `Upgrade cursor-composer-in-claude to ≥0.9.3 and set CURSOR_BRIDGE_MODE=agent (or unset).`);
+    }
+    try {
+        unlinkSync(probeFile);
+    }
+    catch { }
+    return null;
 }
 // ── Cursor API Proxy ──
 export const PROXY_DEFAULT_URL = "http://127.0.0.1:8765";
@@ -924,9 +1004,10 @@ async function startProxyProcess(baseUrl, url, port) {
         // the CLI path injects keychain-shim-inject.js via NODE_OPTIONS which no-ops
         // /usr/bin/security calls on macOS (cursor-composer/dist/lib/process.js).
         CURSOR_BRIDGE_USE_ACP: "0",
-        // Default bridge mode: "plan" enables tool use (Read, Glob, Grep, Write, Bash).
-        // "ask" gives a chat-only assistant that doesn't interact with the codebase.
-        CURSOR_BRIDGE_MODE: "plan",
+        // "agent" omits --mode so cursor-agent runs full agentic mode with
+        // Read/Glob/Grep/Write/Bash. --mode plan and --mode ask are both strictly
+        // read-only — Write/Bash calls exit 0 with empty stdout.
+        CURSOR_BRIDGE_MODE: "agent",
         // cursor-composer chat-only mode fakes HOME to a temp dir; on macOS the agent still waits on
         // Keychain (~30s) for `cursor-user` despite CURSOR_API_KEY. Use the real workspace profile.
         CURSOR_BRIDGE_CHAT_ONLY_WORKSPACE: "false",

package/dist/run.js

@@ -185,11 +185,11 @@ export async function executeRun(cfg) {
             waveHistory.length ? `Waves done: ${waveHistory.length}` : "",
             memory.reflections ? `Reflections:\n${cap(memory.reflections, 600)}` : "",
         ].filter(Boolean).join("\n\n");
-        const prompt = `${label}\n\n${ctx}\n\nWrite one short sentence (max 120 chars) summarising progress and what's next. No preamble.`;
+        const prompt = `${label}\n\n${ctx}\n\nWrite one short sentence (max 180 chars) summarising progress and what's next. No preamble.`;
         // Show in-flight feedback so the panel isn't empty while the planner thinks.
         display.setDebrief(`Summarizing ${label.toLowerCase().replace(/\.$/, "")}\u2026`);
         void runPlannerQuery(prompt, { cwd, model: debriefModel, permissionMode }, () => { })
-            .then(text => { display.setDebrief(text.trim().slice(0, 140)); })
+            .then(text => { display.setDebrief(text.trim().slice(0, 210), label); })
             .catch(() => { display.setDebrief(undefined); });
     };
     /** Generate a longer narrative summary at run end. Awaited (not fire-and-forget)
@@ -455,17 +455,50 @@ export async function executeRun(cfg) {
             }
             display.pause();
             console.log(renderSummary(swarm));
-            // Retry execute tasks that returned filesChanged=0. One retry with a nudge;
-            // if still 0, fail loudly so steering re-plans instead of silently dropping.
+            // Retry execute tasks that returned filesChanged=0 OR whose postcondition
+            // shell-check failed after merge. One retry with a nudge that includes the
+            // failure output; if still failing, fail loudly so steering re-plans.
             if (!swarm.aborted && !swarm.cappedOut && remaining > 0) {
-                const zeroWork = swarm.agents.filter(a => a.status === "done" && (!a.task.type || a.task.type === "execute") && (a.filesChanged ?? 0) === 0);
+                const failedBranches = new Set(swarm.mergeResults.filter(r => !r.ok).map(r => r.branch));
+                const postResults = new Map();
+                for (const a of swarm.agents) {
+                    if (a.status !== "done" || !a.task.postcondition)
+                        continue;
+                    if (a.branch && failedBranches.has(a.branch))
+                        continue; // merge-failed: postcondition can't pass on main anyway
+                    try {
+                        const out = execSync(a.task.postcondition, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 30_000 });
+                        postResults.set(a.id, { ok: true, output: out.trim().slice(0, 400) });
+                    }
+                    catch (err) {
+                        const output = ((err.stderr || "") + "\n" + (err.stdout || err.message || "")).trim().slice(0, 400);
+                        postResults.set(a.id, { ok: false, output });
+                    }
+                }
+                const zeroWork = swarm.agents.filter(a => {
+                    if (a.status !== "done" || (a.task.type && a.task.type !== "execute"))
+                        return false;
+                    if ((a.filesChanged ?? 0) === 0)
+                        return true;
+                    const pr = postResults.get(a.id);
+                    return pr && !pr.ok;
+                });
                 if (zeroWork.length > 0) {
-                    display.appendSteeringEvent(`Retry: ${zeroWork.length} execute task(s) with 0 file changes`);
-                    const retryTasks = zeroWork.map(a => ({
-                        id: `${a.task.id}-retry`,
-                        prompt: `${a.task.prompt}\n\nIMPORTANT: your last attempt made no file edits. If the fix truly needs no changes, say 'no-op:' at the start and explain why. Otherwise, make the actual edits.`,
-                        type: "execute",
-                    }));
+                    const noFiles = zeroWork.filter(a => (a.filesChanged ?? 0) === 0).length;
+                    const badPost = zeroWork.length - noFiles;
+                    display.appendSteeringEvent(`Retry: ${zeroWork.length} task(s) (${noFiles} with 0 files, ${badPost} failed postcondition)`);
+                    const retryTasks = zeroWork.map(a => {
+                        const pr = postResults.get(a.id);
+                        const postFailBlock = pr && !pr.ok
+                            ? `\n\nThe postcondition \`${a.task.postcondition}\` failed after your last attempt:\n${pr.output || "(no output)"}\n\nFix what makes the check fail and try again.`
+                            : `\n\nIMPORTANT: your last attempt made no file edits. If the fix truly needs no changes, say 'no-op:' at the start and explain why. Otherwise, make the actual edits.`;
+                        return {
+                            id: `${a.task.id}-retry`,
+                            prompt: `${a.task.prompt}${postFailBlock}`,
+                            type: "execute",
+                            postcondition: a.task.postcondition,
+                        };
+                    });
                     const retrySwarm = new Swarm({
                         tasks: retryTasks, concurrency: Math.min(concurrency, retryTasks.length), cwd, model: workerModel,
                         permissionMode, allowedTools, useWorktrees, mergeStrategy: waveMerge,
@@ -485,10 +518,29 @@ export async function executeRun(cfg) {
                     accIn += retrySwarm.totalInputTokens;
                     accOut += retrySwarm.totalOutputTokens;
                     accTools += retrySwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
-                    // Any retry that still has 0 files → hard fail
-                    const stillZero = retrySwarm.agents.filter(a => a.status === "done" && (a.filesChanged ?? 0) === 0);
+                    // Any retry that still has 0 files OR a still-failing postcondition → hard fail
+                    const retryFailedBranches = new Set(retrySwarm.mergeResults.filter(r => !r.ok).map(r => r.branch));
+                    const stillZero = retrySwarm.agents.filter(a => {
+                        if (a.status !== "done")
+                            return false;
+                        if ((a.filesChanged ?? 0) === 0)
+                            return true;
+                        if (!a.task.postcondition)
+                            return false;
+                        if (a.branch && retryFailedBranches.has(a.branch))
+                            return true;
+                        try {
+                            execSync(a.task.postcondition, { cwd, stdio: "ignore", timeout: 30_000 });
+                            return false;
+                        }
+                        catch {
+                            return true;
+                        }
+                    });
                     for (const a of stillZero) {
-                        display.appendSteeringEvent(`RETRY FAILED: agent ${a.id} still changed 0 files after nudge — task dropped as error`);
+                        const why = (a.filesChanged ?? 0) === 0 ? "still changed 0 files" : "postcondition still failing";
+                        display.appendSteeringEvent(`RETRY FAILED: agent ${a.id} ${why} — task dropped as error`);
+                        a.error = a.error ?? `retry failed: ${why}`;
                         accFailed++;
                         remaining = Math.max(0, remaining - 1);
                     }
@@ -554,9 +606,22 @@ export async function executeRun(cfg) {
             const attemptedPrompts = new Set(swarm.agents.map(a => a.task.prompt));
             const neverStarted = currentTasks.filter(t => !attemptedPrompts.has(t.prompt));
             saveRunState(runDir, buildRunState({ remaining, phase: "steering", currentTasks: neverStarted }));
+            // Overlay merge outcomes: if an agent's branch failed to merge, its changes
+            // did NOT land — tell steering the truth (filesChanged=0, error attached)
+            // so it can't declare victory on work that didn't reach the codebase.
+            const failedMergeBranches = new Set(swarm.mergeResults.filter(r => !r.ok).map(r => r.branch));
             waveHistory.push({
                 wave: waveNum,
-                tasks: swarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, type: a.task.type, filesChanged: a.filesChanged, error: a.error })),
+                tasks: swarm.agents.map(a => {
+                    const mergeFailed = a.branch && failedMergeBranches.has(a.branch);
+                    return {
+                        prompt: a.task.prompt,
+                        status: a.status,
+                        type: a.task.type,
+                        filesChanged: mergeFailed ? 0 : a.filesChanged,
+                        error: mergeFailed ? `merge-failed: branch ${a.branch} did not land` : a.error,
+                    };
+                }),
             });
             // Hook-blocked work: agents that touched files but nothing landed on the
             // branch (pre-commit hooks, gitignore, writes outside worktree). Surface
@@ -574,6 +639,39 @@ export async function executeRun(cfg) {
                 }
                 catch { }
             }
+            // Merge-failed branches: changes never reached the codebase. Regenerate a
+            // pinned section in status.md every wave from live git state — resolved
+            // branches (deleted from git) drop off automatically; still-broken ones
+            // keep shouting at steering until a follow-up wave lands them or discards
+            // them. This is what turns merge-failed from a silent state into a
+            // first-class blocker.
+            try {
+                const unresolved = branches.filter(b => {
+                    if (b.status !== "merge-failed")
+                        return false;
+                    try {
+                        execSync(`git rev-parse --verify "${b.branch}"`, { cwd, stdio: "ignore" });
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    } // branch gone → treat as resolved
+                });
+                const statusPath = join(runDir, "status.md");
+                const existing = existsSync(statusPath) ? readFileSync(statusPath, "utf-8") : "";
+                const marker = "## Unresolved merge failures";
+                const idx = existing.indexOf(marker);
+                const base = idx >= 0 ? existing.slice(0, idx).replace(/\n+$/, "") : existing;
+                let next = base;
+                if (unresolved.length > 0) {
+                    const list = unresolved.map(b => `  - ${b.branch} — ${b.taskPrompt.slice(0, 120)}`).join("\n");
+                    next = `${base}${base ? "\n\n" : ""}${marker}\n${unresolved.length} branch(es) contain unmerged agent work. Resolve or discard before relying on those changes:\n${list}\n`;
+                    display.appendSteeringEvent(`⚠ ${unresolved.length} unresolved merge failure(s) — see status.md`);
+                }
+                if (next !== existing)
+                    writeFileSync(statusPath, next, "utf-8");
+            }
+            catch { }
             // Fire-and-forget debrief after each wave.
             runDebrief(`Wave ${waveNum + 1} just finished.`);
             // After-wave commands: run shell commands in cwd after each wave (e.g. "supabase db push").

package/dist/steering.js

@@ -16,7 +16,7 @@ const STEER_SCHEMA = {
                 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"] } },
+                    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"],
                 },
             },
@@ -103,7 +103,7 @@ Respond with ONLY a JSON object (no markdown fences):
   "statusUpdate": "REQUIRED  -- concise project status: what's built, what works, what's rough, quality level, key gaps. This replaces the previous status.",
   "estimatedSessionsRemaining": 15,
   "tasks": [
-    {"prompt": "task instruction...", "model": "worker"},
+    {"prompt": "task instruction...", "model": "worker", "postcondition": "test -f src/new-file.ts"},
     {"prompt": "quick icon fix, verified by worker next wave...", "model": "fast"},
     {"prompt": "verify the app end-to-end...", "model": "worker", "noWorktree": true}
   ]
@@ -114,6 +114,8 @@ Respond with ONLY a JSON object (no markdown fences):
 The "model" field on each task: use "worker" (${workerModel}) for all tasks. Use "fast" (${fastModel ?? "not set"}) for small, single-file changes that will be checked by the worker in the next wave.
 Set "noWorktree": true for verify/user-test tasks  -- they need the real project directory with env files, dependencies, and local config.
 
+OPTIONAL "postcondition": a single shell one-liner that exits 0 when the task is truly done. The framework runs it after merge; if it fails, the agent's "no-op" claim is rejected and the task is retried with the failure output as context. Use it whenever the task has a concrete, machine-checkable outcome. Examples: \`test -f src/tracking/watchlist-poller.ts && grep -q "runWatchlistPoll" src/tracking/watchlist-poller.ts\`, \`grep -q "watchlistPollerTask" src/scraper/scheduler.ts\`, \`pnpm run build\`, \`diff -q src/public/index.html frontend/dist/index.html\`. Keep it cheap (sub-second, no network). Omit for exploratory/research tasks where there is no crisp check.
+
 If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "estimatedSessionsRemaining": 0, "tasks": []}`;
     onLog("Assessing...", "status");
     onLog(`Reading codebase  -- wave ${history.length + 1}`, "event");
@@ -151,6 +153,7 @@ If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "estimatedSes
         ...(t.model && { model: resolveModel(t.model) }),
         ...(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");

package/dist/swarm.js

@@ -553,10 +553,13 @@ export class Swarm {
                 let resumePrompt = "Continue. Complete the task.";
                 const runOnce = async (isResume) => {
                     const preamble = "Keep files under ~500 lines. If a file would exceed that, split it.\n\n";
+                    const postBlock = task.postcondition
+                        ? `\n\nEXIT CRITERION — after you finish, the framework will run this shell check in cwd and reject a no-op if it fails:\n  $ ${task.postcondition}\nYour work is not done until that command exits 0. Don't claim no-op unless you can prove the check already passes.`
+                        : "";
                     const agentPrompt = isResume ? resumePrompt
                         : this.config.useWorktrees && !task.noWorktree
-                            ? `You are working in an isolated git worktree. Focus only on this task. Do NOT commit your changes  -- the framework handles that.\n\n${preamble}${task.prompt}`
-                            : `${preamble}${task.prompt}`;
+                            ? `You are working in an isolated git worktree. Focus only on this task. Do NOT commit your changes  -- the framework handles that.\n\n${preamble}${task.prompt}${postBlock}`
+                            : `${preamble}${task.prompt}${postBlock}`;
                     const effectiveModel = task.model || this.config.model;
                     const envOverride = this.config.envForModel?.(effectiveModel);
                     const agentQuery = query({

package/dist/types.d.ts

@@ -16,6 +16,8 @@ export interface Task {
     agentCwd?: string;
     /** The kind of work: "execute" modifies files, others are read-only/analysis. Defaults to "execute". */
     type?: string;
+    /** Shell command that must exit 0 for the task to be considered done. Runs in cwd after merge. Failed postconditions trigger the same retry path as filesChanged=0. */
+    postcondition?: string;
 }
 /** Schema for a JSON task file that defines a batch of work for the swarm. */
 export interface TaskFile {

package/dist/ui.d.ts

@@ -84,8 +84,10 @@ export declare class RunDisplay {
     private lastFrame;
     private onSteer?;
     private onAsk?;
-    /** Set or clear the debrief text shown in the interactive panel. */
-    setDebrief(text: string | undefined): void;
+    /** Set or clear the debrief text shown in the interactive panel.
+     *  When a label is provided alongside resolved text, it's appended to
+     *  the running history so expanded view shows all wave debriefs. */
+    setDebrief(text: string | undefined, label?: string): void;
     constructor(runInfo: RunInfo, liveConfig?: LiveConfig, callbacks?: {
         onSteer?: (text: string) => void;
         onAsk?: (text: string) => void;

package/dist/ui.js

@@ -49,10 +49,16 @@ export class RunDisplay {
     lastFrame = "";
     onSteer;
     onAsk;
-    /** Set or clear the debrief text shown in the interactive panel. */
-    setDebrief(text) {
+    /** Set or clear the debrief text shown in the interactive panel.
+     *  When a label is provided alongside resolved text, it's appended to
+     *  the running history so expanded view shows all wave debriefs. */
+    setDebrief(text, label) {
         if (text) {
             this.panel.set({ mode: "debrief", header: "Debrief", preview: text, body: text });
+            // Append to accumulated history when we have the final text (not loading message)
+            if (label && !text.startsWith("Summarizing")) {
+                this.panel.appendHistory(label, text);
+            }
         }
         else if (this.panel.state.mode === "debrief") {
             this.panel.set({ mode: "none", header: "", preview: "", body: "" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.33",
+  "version": "1.25.37",
   "description": "Parallel Claude agents in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Provider-agnostic model catalog (Anthropic, Cursor, OpenAI, Gemini, DeepSeek, Llama, Qwen) with capability-based task scoping.",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.92",
     "chalk": "^5.4.1",
-    "cursor-composer-in-claude": "0.9.1",
+    "cursor-composer-in-claude": "0.9.3",
     "jsonwebtoken": "^9.0.2"
   },
   "devDependencies": {

package/plugins/claude-overnight/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.33",
+  "version": "1.25.37",
   "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs  -- parallel Claude agents in git worktrees with thinking waves, multi-wave steering, and crash-safe resume. Supports Cursor API Proxy, Qwen, OpenRouter.",
   "author": {
     "name": "Francesco Fornace"