claude-overnight 1.60.2 → 1.60.3

package/dist/cli/files.js

@@ -0,0 +1,94 @@
+// Task-file / plan-file loading. Pure: throws on bad input, no stdio.
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { validateConcurrency } from "./argv.js";
+const KNOWN_TASK_FILE_KEYS = new Set([
+    "tasks", "objective", "concurrency", "cwd", "model", "allowedTools",
+    "beforeWave", "afterWave", "afterRun", "worktrees", "mergeStrategy",
+    "usageCap", "flexiblePlan",
+]);
+/** Load a markdown plan file. Extracts the first H1 as objective and returns the full body as planContent. */
+export function loadPlanFile(file) {
+    const path = resolve(file);
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        throw new Error(`Cannot read plan file: ${path}`);
+    }
+    const body = raw.trim();
+    if (!body)
+        throw new Error(`Plan file is empty: ${path}`);
+    const h1 = body.match(/^#\s+(.+)$/m);
+    const objective = (h1?.[1] ?? body.split("\n").find(l => l.trim())).trim();
+    return { objective, planContent: body };
+}
+export function loadTaskFile(file) {
+    const path = resolve(file);
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        throw new Error(`Cannot read task file: ${path}`);
+    }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Task file is not valid JSON: ${path}`);
+    }
+    const parsed = Array.isArray(json) ? { tasks: json } : json;
+    if (!Array.isArray(json) && typeof json === "object" && json !== null) {
+        const unknown = Object.keys(json).filter((k) => !KNOWN_TASK_FILE_KEYS.has(k));
+        if (unknown.length > 0) {
+            throw new Error(`Unknown key${unknown.length > 1 ? "s" : ""} in task file: ${unknown.join(", ")}. Allowed: ${[...KNOWN_TASK_FILE_KEYS].join(", ")}`);
+        }
+    }
+    if (!Array.isArray(parsed.tasks))
+        throw new Error(`Task file must contain a "tasks" array (got ${typeof parsed.tasks})`);
+    const tasks = [];
+    for (let i = 0; i < parsed.tasks.length; i++) {
+        const t = parsed.tasks[i];
+        const id = String(tasks.length);
+        if (typeof t === "string") {
+            if (!t.trim())
+                throw new Error(`Task ${i} is an empty string`);
+            tasks.push({ id, prompt: t });
+        }
+        else if (typeof t === "object" && t !== null) {
+            if (typeof t.prompt !== "string" || !t.prompt.trim())
+                throw new Error(`Task ${i} is missing a "prompt" string`);
+            tasks.push({ id, prompt: t.prompt, cwd: t.cwd ? resolve(t.cwd) : undefined, model: t.model });
+        }
+        else {
+            throw new Error(`Task ${i} must be a string or object with a "prompt" field (got ${typeof t})`);
+        }
+    }
+    if (parsed.concurrency !== undefined)
+        validateConcurrency(parsed.concurrency);
+    const usageCap = parsed.usageCap;
+    if (usageCap != null && (typeof usageCap !== "number" || usageCap < 0 || usageCap > 100)) {
+        throw new Error(`usageCap must be a number between 0 and 100 (got ${JSON.stringify(usageCap)})`);
+    }
+    if (parsed.flexiblePlan && typeof parsed.objective !== "string") {
+        throw new Error(`flexiblePlan requires an "objective" string in the task file`);
+    }
+    return {
+        tasks,
+        objective: typeof parsed.objective === "string" ? parsed.objective : undefined,
+        concurrency: parsed.concurrency,
+        model: parsed.model,
+        cwd: parsed.cwd ? resolve(parsed.cwd) : undefined,
+        allowedTools: parsed.allowedTools,
+        beforeWave: parsed.beforeWave,
+        afterWave: parsed.afterWave,
+        afterRun: parsed.afterRun,
+        useWorktrees: parsed.worktrees,
+        mergeStrategy: parsed.mergeStrategy,
+        usageCap,
+        flexiblePlan: parsed.flexiblePlan,
+    };
+}

package/dist/cli/help.js

@@ -1,12 +1,12 @@
-import { readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
 import { VERSION } from "../core/_version.js";
+import { readJsonOrNull } from "../core/fs-helpers.js";
 export function printVersion() {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"));
-    console.log(`claude-overnight v${pkg.version}`);
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = readJsonOrNull(join(here, "..", "..", "package.json"));
+    console.log(`claude-overnight v${pkg?.version ?? VERSION}`);
 }
 export function printHelp() {
     console.log(`

package/dist/cli/plan-phase.js

@@ -1,5 +1,5 @@
-import { readFileSync, readdirSync, mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
+import { mkdirSync, writeFileSync } from "fs";
+import { readMdEntries } from "../core/fs-helpers.js";
 import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Swarm } from "../swarm/swarm.js";
@@ -9,7 +9,10 @@ import { renderSummary } from "../ui/summary.js";
 import { isCursorProxyProvider } from "../providers/index.js";
 import { readMdDir, saveRunState } from "../state/state.js";
 import { computeRepoFingerprint } from "../skills/scribe.js";
-import { selectKey, ask, showPlan, makeProgressLog, isJWTAuthError } from "./cli.js";
+import { selectKey, ask } from "./prompts.js";
+import { showPlan, makeProgressLog, numberedLine } from "./display.js";
+import { isJWTAuthError } from "./cli.js";
+import { tasksJsonPath, themesMdPath } from "./run-paths.js";
 import { renderPrompt } from "../prompts/load.js";
 export async function runPlanPhase(input) {
     const { objective, noTTY, flex, budget, concurrency, cwd, plannerModel, workerModel, fastModel, plannerProvider, workerProvider, fastProvider, usageCap, allowExtraUsage, extraUsageBudget, useWorktrees, mergeStrategy, agentTimeoutMs, runDir, designDir, previousKnowledge, envForModel, coachedOriginal, coachedAt, } = input;
@@ -58,7 +61,7 @@ export async function runPlanPhase(input) {
             // readable record (and a future resume can skip identifyThemes).
             const saveThemesMd = (list) => {
                 try {
-                    writeFileSync(join(runDir, "themes.md"), `# Themes\n\n**Objective:** ${objective}\n\n${list.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n`, "utf-8");
+                    writeFileSync(themesMdPath(runDir), `# Themes\n\n**Objective:** ${objective}\n\n${list.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n`, "utf-8");
                 }
                 catch { }
             };
@@ -69,7 +72,7 @@ export async function runPlanPhase(input) {
             let reviewing = true;
             while (reviewing) {
                 for (let i = 0; i < themes.length; i++)
-                    console.log(chalk.dim(`  ${String(i + 1).padStart(3)}.`) + ` ${themes[i]}`);
+                    console.log(numberedLine(i, themes[i]));
                 console.log(chalk.dim(`\n  ${thinkingCount} thinking agents → orchestrate → ${(budget ?? 10) - thinkingCount} execution sessions\n`));
                 const action = await selectKey(`${chalk.white(`${themes.length} themes`)} ${chalk.dim(`· ${thinkingCount} thinking · ${concurrency} concurrent`)}`, [{ key: "r", desc: "un" }, { key: "e", desc: "dit" }, { key: "c", desc: "hat" }, { key: "q", desc: "uit" }]);
                 if (action === "r") {
@@ -128,17 +131,13 @@ export async function runPlanPhase(input) {
             }
             process.stdout.write("\x1B[?25l");
             mkdirSync(designDir, { recursive: true });
-            const existingDesigns = readMdDir(designDir);
-            if (existingDesigns) {
-                const designFiles = readdirSync(designDir).filter(f => f.endsWith(".md")).sort();
-                console.log(chalk.green(`\n  ✓ Reusing ${designFiles.length} design docs`) + chalk.dim(` (from prior attempt)`));
-                for (const f of designFiles) {
-                    try {
-                        const firstLine = readFileSync(join(designDir, f), "utf-8").split("\n")[0].replace(/^#+\s*/, "").trim();
-                        if (firstLine)
-                            console.log(chalk.dim(`    ${firstLine.slice(0, 80)}`));
-                    }
-                    catch { }
+            const priorDesigns = readMdEntries(designDir);
+            if (priorDesigns.length > 0) {
+                console.log(chalk.green(`\n  ✓ Reusing ${priorDesigns.length} design docs`) + chalk.dim(` (from prior attempt)`));
+                for (const { body } of priorDesigns) {
+                    const firstLine = body.split("\n")[0].replace(/^#+\s*/, "").trim();
+                    if (firstLine)
+                        console.log(chalk.dim(`    ${firstLine.slice(0, 80)}`));
                 }
                 console.log("");
             }
@@ -213,7 +212,7 @@ export async function runPlanPhase(input) {
                 }
             }
             const designs = readMdDir(designDir);
-            const taskFile = join(runDir, "tasks.json");
+            const taskFile = tasksJsonPath(runDir);
             if (designs) {
                 const orchBudget = Math.min(50, Math.max(concurrency, Math.ceil(((budget ?? 10) - thinkingUsed) * 0.5)));
                 const flexNote = renderPrompt("_shared/flex-note", { vars: { remainingBudget: (budget ?? 10) - thinkingUsed } });

package/dist/cli/prompts.d.ts

@@ -0,0 +1,16 @@
+export declare const PASTE_PLACEHOLDER_MAX = 80;
+/**
+ * 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: {
+    name: string;
+    value: T;
+    hint?: string;
+}[], defaultIdx?: number): Promise<T>;
+export declare function selectKey(label: string, options: {
+    key: string;
+    desc: string;
+}[]): Promise<string>;

package/dist/cli/prompts.js

@@ -0,0 +1,226 @@
+// Interactive terminal primitives: ask, select, selectKey.
+//
+// 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.
+import { createInterface } from "readline";
+import chalk from "chalk";
+import { parseChunk, setBracketedPaste, deleteWordBackward } from "../ui/raw-input.js";
+export const PASTE_PLACEHOLDER_MAX = 80;
+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 });
+}
+function appendPaste(segs, text) {
+    if (!text)
+        return;
+    const norm = text.replace(/\r\n?/g, "\n");
+    if (!norm.includes("\n") && norm.length <= PASTE_PLACEHOLDER_MAX) {
+        appendTypedChar(segs, norm);
+        return;
+    }
+    segs.push({ type: "paste", content: norm });
+}
+function backspaceSegs(segs) {
+    while (segs.length > 0) {
+        const last = segs[segs.length - 1];
+        if (last.type === "paste") {
+            segs.pop();
+            return;
+        }
+        if (last.content.length > 1) {
+            last.content = last.content.slice(0, -1);
+            return;
+        }
+        segs.pop();
+        return;
+    }
+}
+const segsToString = (segs) => 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("");
+}
+const stripAnsi = (s) => s.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+/**
+ * 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;
+    if (!stdin.isTTY) {
+        const rl = createInterface({ input: stdin, output: stdout });
+        return new Promise((res) => rl.question(question, (a) => { rl.close(); res(a.trim()); }));
+    }
+    return new Promise((resolve) => {
+        const segs = [];
+        const tail = question.split("\n").pop() ?? "";
+        const tailVisibleLen = stripAnsi(tail).length;
+        let prevWrapRows = 0;
+        const redraw = () => {
+            const cols = stdout.columns || 80;
+            if (prevWrapRows > 0)
+                stdout.write(`\x1B[${prevWrapRows}A`);
+            stdout.write("\r\x1B[J");
+            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);
+        setBracketedPaste(stdout, true);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch { }
+        stdin.resume();
+        const cleanup = () => {
+            setBracketedPaste(stdout, false);
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { }
+            stdin.removeListener("data", onData);
+            stdin.pause();
+        };
+        const submit = () => { stdout.write("\n"); cleanup(); resolve(segsToString(segs).trim()); };
+        const onData = (buf) => {
+            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 next = deleteWordBackward(segsToString(segs));
+                        segs.length = 0;
+                        if (next)
+                            segs.push({ type: "text", content: next });
+                        break;
+                    }
+                    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);
+                    // tab + nav: ignore during single-line prompts
+                }
+            }
+            redraw();
+        };
+        stdin.on("data", onData);
+    });
+}
+export async function select(label, items, defaultIdx = 0) {
+    const { stdin, stdout } = process;
+    let idx = defaultIdx;
+    const draw = (first = false) => {
+        if (!first)
+            stdout.write(`\x1B[${items.length}A`);
+        for (let i = 0; i < items.length; i++) {
+            const sel = i === idx;
+            const radio = sel ? chalk.cyan("  ● ") : chalk.dim("  ○ ");
+            const name = sel ? chalk.white(items[i].name) : chalk.dim(items[i].name);
+            const hint = items[i].hint ? chalk.dim(` · ${items[i].hint}`) : "";
+            stdout.write(`\x1B[2K${radio}${name}${hint}\n`);
+        }
+    };
+    stdout.write(`\n  ${chalk.bold(label)}\n`);
+    draw(true);
+    return new Promise((resolve) => {
+        stdin.setRawMode(true);
+        stdin.resume();
+        const done = (val) => {
+            stdin.setRawMode(false);
+            stdin.removeListener("data", handler);
+            stdin.pause();
+            resolve(val);
+        };
+        const handler = (buf) => {
+            const s = buf.toString();
+            // Arrow keys: \x1B[A = up, \x1B[B = down. Ignore other escape sequences.
+            if (s === "\x1B[A") {
+                idx = (idx - 1 + items.length) % items.length;
+                draw();
+                return;
+            }
+            if (s === "\x1B[B") {
+                idx = (idx + 1) % items.length;
+                draw();
+                return;
+            }
+            if (s[0] === "\x1B")
+                return;
+            if (s === "\r")
+                done(items[idx].value);
+            else if (s === "\x03") {
+                stdin.setRawMode(false);
+                process.exit(0);
+            }
+            else if (/^[1-9]$/.test(s)) {
+                const n = parseInt(s) - 1;
+                if (n < items.length) {
+                    idx = n;
+                    draw();
+                    done(items[idx].value);
+                }
+            }
+        };
+        stdin.on("data", handler);
+    });
+}
+export async function selectKey(label, options) {
+    const { stdin, stdout } = process;
+    const keys = options.map((o) => o.key.toLowerCase());
+    const optStr = options.map((o) => `${chalk.cyan.bold(o.key.toUpperCase())}${chalk.dim(o.desc)}`).join(chalk.dim("  │  "));
+    stdout.write(`\n  ${label}\n  ${optStr}\n  `);
+    return new Promise((resolve) => {
+        stdin.setRawMode(true);
+        stdin.resume();
+        const finish = (val) => {
+            stdin.setRawMode(false);
+            stdin.removeListener("data", handler);
+            stdin.pause();
+            resolve(val);
+        };
+        const handler = (buf) => {
+            const s = buf.toString().toLowerCase();
+            if (s[0] === "\x1B")
+                return;
+            if (s === "\x03") {
+                stdin.setRawMode(false);
+                process.exit(0);
+            }
+            if (s === "\r")
+                return finish(keys[0]);
+            if (s.length === 1 && keys.includes(s))
+                finish(s);
+        };
+        stdin.on("data", handler);
+    });
+}

package/dist/cli/resume.js

@@ -1,22 +1,22 @@
-import { readFileSync } from "fs";
-import { join } from "path";
 import chalk from "chalk";
-import { formatContextWindow } from "../core/models.js";
+import { readFileOrEmpty, readJsonOrNull } from "../core/fs-helpers.js";
 import { saveRunState, findIncompleteRuns, showRunHistory, formatTimeAgo, autoMergeBranches, readMdDir, } from "../state/state.js";
 import { orchestrate, salvageFromFile } from "../planner/planner.js";
 import { setTranscriptRunDir } from "../core/transcripts.js";
-import { wrap } from "../ui/primitives.js";
-import { makeProgressLog, selectKey } from "./cli.js";
-import { editRunSettings } from "./settings.js";
+import { wrap, terminalWidth } from "../ui/primitives.js";
+import { selectKey } from "./prompts.js";
+import { makeProgressLog } from "./display.js";
+import { editRunSettings, printRunSettings } from "./settings.js";
+import { tasksJsonPath, designsDir, statusMdPath } from "./run-paths.js";
 import { renderPrompt } from "../prompts/load.js";
 export function countTasksInFile(path) {
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf-8"));
-        return Array.isArray(parsed?.tasks) ? parsed.tasks.length : 0;
-    }
-    catch {
-        return 0;
-    }
+    const parsed = readJsonOrNull(path);
+    return parsed && Array.isArray(parsed.tasks) ? parsed.tasks.length : 0;
+}
+/** Read the first line / preview of a run's status.md. Returns "" if missing. */
+function readStatusPreview(runDir, maxLen, firstLineOnly = false) {
+    const raw = readFileOrEmpty(statusMdPath(runDir)).trim();
+    return (firstLineOnly ? raw.split("\n")[0] : raw).slice(0, maxLen);
 }
 export async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir) {
     // ── Apply CLI flag overrides first ──
@@ -56,29 +56,8 @@ export async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir
         return;
     }
     // ── Interactive review ──
-    const fmtSummary = () => {
-        const remaining = Math.max(1, state.remaining);
-        const capStr = state.usageCap != null ? `${Math.round(state.usageCap * 100)}%` : "unlimited";
-        const extraStr = state.allowExtraUsage
-            ? (state.extraUsageBudget ? `$${state.extraUsageBudget}` : "unlimited")
-            : "off";
-        const modelLine = (label, m) => m ? `  ${chalk.dim(label.padEnd(11))}${chalk.white(m)} ${chalk.dim(`(${formatContextWindow(m)} context)`)}` : null;
-        console.log();
-        console.log(`  ${chalk.dim("Resume settings")}`);
-        console.log(`  ${chalk.dim("─".repeat(40))}`);
-        const lines = [
-            modelLine("planner", state.plannerModel),
-            modelLine("worker", state.workerModel),
-            modelLine("fast", state.fastModel),
-        ].filter(Boolean);
-        for (const l of lines)
-            console.log(l);
-        console.log(`  ${chalk.dim("remaining  ")}${chalk.white(String(remaining))} ${chalk.dim("sessions")}`);
-        console.log(`  ${chalk.dim("concur     ")}${chalk.white(String(state.concurrency))}`);
-        console.log(`  ${chalk.dim("usage cap  ")}${chalk.white(capStr)}`);
-        console.log(`  ${chalk.dim("extra      ")}${chalk.white(extraStr)}`);
-    };
-    fmtSummary();
+    const showSummary = () => printRunSettings(state, { header: "Resume settings", remaining: state.remaining });
+    showSummary();
     const action = await selectKey("", [
         { key: "r", desc: "esume" },
         { key: "e", desc: "dit" },
@@ -110,7 +89,7 @@ export async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir
     }
     catch { }
     console.log(chalk.green("\n  ✓ Settings updated"));
-    fmtSummary();
+    showSummary();
     console.log();
 }
 export async function detectResume(input) {
@@ -151,15 +130,10 @@ export async function detectResume(input) {
                 const failed = prev.branches.filter(b => b.status === "failed" || b.status === "merge-failed").length;
                 const obj = prev.objective?.slice(0, 50) || "";
                 const ago = formatTimeAgo(prev.startedAt);
-                let lastStatus = "";
-                try {
-                    lastStatus = readFileSync(join(run.dir, "status.md"), "utf-8").trim().slice(0, 200);
-                }
-                catch { }
-                const planTaskCount = prev.phase === "planning" ? countTasksInFile(join(run.dir, "tasks.json")) : 0;
+                const lastStatus = readStatusPreview(run.dir, 200);
+                const planTaskCount = prev.phase === "planning" ? countTasksInFile(tasksJsonPath(run.dir)) : 0;
                 console.log(chalk.yellow(`\n  ⚠ Unfinished run`) + chalk.dim(` · ${ago}`));
-                const termW = Math.max(process.stdout.columns ?? 80, 60);
-                const statusMaxW = Math.min(termW - 8, 80);
+                const statusMaxW = Math.min(terminalWidth() - 8, 80);
                 const leftover = prev.currentTasks?.length ?? 0;
                 const leftoverNote = prev.phase === "stopped" && leftover > 0
                     ? ` · ${leftover} leftover task${leftover === 1 ? "" : "s"} preserved`
@@ -209,22 +183,17 @@ export async function detectResume(input) {
                     const ago = formatTimeAgo(s.startedAt);
                     const obj = s.objective?.slice(0, 50) || "";
                     const merged = s.branches.filter(b => b.status === "merged").length;
-                    let lastStatus = "";
-                    try {
-                        lastStatus = readFileSync(join(shown[i].dir, "status.md"), "utf-8").trim().split("\n")[0].slice(0, 120);
-                    }
-                    catch { }
+                    const lastStatus = readStatusPreview(shown[i].dir, 120, true);
                     console.log(chalk.cyan(`  ${i + 1}`) + `  ${obj}${obj.length >= 50 ? "…" : ""}`);
                     if (s.phase === "planning") {
-                        const n = countTasksInFile(join(shown[i].dir, "tasks.json"));
+                        const n = countTasksInFile(tasksJsonPath(shown[i].dir));
                         console.log(chalk.dim(`     plan ready · ${n} tasks · budget ${s.budget} · ${ago} · not yet executing`));
                     }
                     else {
                         console.log(chalk.dim(`     ${s.accCompleted}/${s.budget} · $${s.accCost.toFixed(2)} · ${ago} · ${s.phase} at wave ${s.waveNum + 1}${merged ? ` · ${merged} merged` : ""}`));
                     }
                     if (lastStatus) {
-                        const termW = Math.max(process.stdout.columns ?? 80, 60);
-                        for (const wl of wrap(lastStatus, termW - 6))
+                        for (const wl of wrap(lastStatus, terminalWidth() - 6))
                             console.log(chalk.dim(`     ${wl}`));
                     }
                     console.log("");
@@ -257,7 +226,7 @@ export async function detectResume(input) {
             // already persisted the leftover work — resume executes those directly.
             // Otherwise fall back to tasks.json (planning-phase + legacy stopped runs).
             if (resumeState.currentTasks.length === 0) {
-                const loaded = salvageFromFile(join(resumeRunDir, "tasks.json"), resumeState.budget, () => { }, "resume");
+                const loaded = salvageFromFile(tasksJsonPath(resumeRunDir), resumeState.budget, () => { }, "resume");
                 if (loaded) {
                     resumeState.currentTasks = loaded;
                     const label = resumeState.phase === "planning" ? "Resuming plan" : `Resuming ${resumeState.phase} run`;
@@ -267,7 +236,7 @@ export async function detectResume(input) {
                     // No tasks.json  -- the thinking wave got killed before orchestrate ran.
                     // If design docs survived, re-orchestrate from them (salvages the
                     // thinking spend instead of throwing it away).
-                    const designs = readMdDir(join(resumeRunDir, "designs"));
+                    const designs = readMdDir(designsDir(resumeRunDir));
                     if (!designs || !resumeState.objective) {
                         // Planning died before producing anything — re-run planning from
                         // scratch while keeping all saved settings (model, budget, etc.).
@@ -284,7 +253,7 @@ export async function detectResume(input) {
                         // land alongside the prior run's planning trail.
                         setTranscriptRunDir(resumeRunDir);
                         try {
-                            const orchTasks = await orchestrate(resumeState.objective, designs, cwd, resumeState.plannerModel, resumeState.workerModel, orchBudget, resumeState.concurrency, makeProgressLog(), flexNote, join(resumeRunDir, "tasks.json"), "orchestrate-resume");
+                            const orchTasks = await orchestrate(resumeState.objective, designs, cwd, resumeState.plannerModel, resumeState.workerModel, orchBudget, resumeState.concurrency, makeProgressLog(), flexNote, tasksJsonPath(resumeRunDir), "orchestrate-resume");
                             resumeState.currentTasks = orchTasks;
                             process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${orchTasks.length} tasks`)}\n`);
                         }

package/dist/cli/run-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const tasksJsonPath: (runDir: string) => string;
+export declare const designsDir: (runDir: string) => string;
+export declare const themesMdPath: (runDir: string) => string;
+export declare const statusMdPath: (runDir: string) => string;

package/dist/cli/run-paths.js

@@ -0,0 +1,8 @@
+// Filesystem layout of a single run dir. Keeps the on-disk schema in one
+// place so resume.ts and plan-phase.ts don't bake "tasks.json" / "designs"
+// strings independently.
+import { join } from "path";
+export const tasksJsonPath = (runDir) => join(runDir, "tasks.json");
+export const designsDir = (runDir) => join(runDir, "designs");
+export const themesMdPath = (runDir) => join(runDir, "themes.md");
+export const statusMdPath = (runDir) => join(runDir, "status.md");

package/dist/cli/settings.d.ts

@@ -15,6 +15,13 @@ interface EditSettingsOptions {
 }
 /** Interactively edit all mutable run settings. Mutates `options.current` in place. */
 export declare function editRunSettings(options: EditSettingsOptions): Promise<MutableRunSettings>;
+/** Print the planner/worker/fast/concur/usage/extra block.
+ *  When `header` is set, the block gets a "Resume settings" / ─── header.
+ *  When `remaining` is set, a `remaining N sessions` line is inserted before concur. */
+export declare function printRunSettings(s: MutableRunSettings, opts?: {
+    header?: string;
+    remaining?: number;
+}): void;
 /** Format a MutableRunSettings as a compact summary line for the terminal. */
 export declare function formatSettingsSummary(s: MutableRunSettings): string;
 export {};

package/dist/cli/settings.js

@@ -1,6 +1,8 @@
 import chalk from "chalk";
 import { modelDisplayName, formatContextWindow } from "../core/models.js";
-import { fetchModels, ask, select, BRAILLE } from "./cli.js";
+import { ask, select } from "./prompts.js";
+import { BRAILLE } from "./display.js";
+import { fetchModels } from "./cli.js";
 import { pickModel } from "../providers/index.js";
 /** Interactively edit all mutable run settings. Mutates `options.current` in place. */
 export async function editRunSettings(options) {
@@ -76,22 +78,36 @@ export async function editRunSettings(options) {
         s.allowExtraUsage = false;
         s.extraUsageBudget = undefined;
     }
-    const modelLine = (label, m) => m ? `${chalk.dim(label.padEnd(11))}${chalk.white(m)} ${chalk.dim(`(${formatContextWindow(m)} context)`)}` : null;
+    printRunSettings(s);
+    return s;
+}
+/** Print the planner/worker/fast/concur/usage/extra block.
+ *  When `header` is set, the block gets a "Resume settings" / ─── header.
+ *  When `remaining` is set, a `remaining N sessions` line is inserted before concur. */
+export function printRunSettings(s, opts = {}) {
+    const modelLine = (label, m) => m ? `  ${chalk.dim(label.padEnd(11))}${chalk.white(m)} ${chalk.dim(`(${formatContextWindow(m)} context)`)}` : null;
     const lines = [
         modelLine("planner", s.plannerModel),
         modelLine("worker", s.workerModel),
         modelLine("fast", s.fastModel),
     ].filter(Boolean);
+    const capStr = s.usageCap != null ? `${Math.round(s.usageCap * 100)}%` : "unlimited";
+    const extraStr = s.allowExtraUsage ? (s.extraUsageBudget ? `$${s.extraUsageBudget}` : "unlimited") : "off";
     console.log();
+    if (opts.header) {
+        console.log(`  ${chalk.dim(opts.header)}`);
+        console.log(`  ${chalk.dim("─".repeat(40))}`);
+    }
     for (const l of lines)
         console.log(l);
-    const capStr = s.usageCap != null ? `${Math.round(s.usageCap * 100)}%` : "unlimited";
-    const extraStr = s.allowExtraUsage ? (s.extraUsageBudget ? `$${s.extraUsageBudget}` : "unlimited") : "off";
+    if (opts.remaining != null) {
+        console.log(`  ${chalk.dim("remaining  ")}${chalk.white(String(Math.max(1, opts.remaining)))} ${chalk.dim("sessions")}`);
+    }
     console.log(`  ${chalk.dim("concur     ")}${chalk.white(String(s.concurrency))}`);
     console.log(`  ${chalk.dim("usage cap  ")}${chalk.white(capStr)}`);
     console.log(`  ${chalk.dim("extra      ")}${chalk.white(extraStr)}`);
-    console.log();
-    return s;
+    if (!opts.header)
+        console.log();
 }
 /** Format a MutableRunSettings as a compact summary line for the terminal. */
 export function formatSettingsSummary(s) {