claude-overnight 1.10.0 → 1.11.0

package/dist/cli.js

@@ -6,8 +6,8 @@ import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 // ── CLI flag parsing ──
 export function parseCliFlags(argv) {
-    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget"]);
-    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex", "--allow-extra-usage"]);
+    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget", "merge", "perm"]);
+    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex", "--allow-extra-usage", "--worktrees", "--no-worktrees", "--yolo"]);
     const flags = {};
     const positional = [];
     for (let i = 0; i < argv.length; i++) {

package/dist/index.js

@@ -42,6 +42,11 @@ async function main() {
     --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)")}
+    --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)")}
+    --perm=MODE            Permission mode: auto, bypassPermissions, default ${chalk.dim("(default: auto)")}
+    --yolo                 Shorthand for --perm=bypassPermissions --no-worktrees
 
   ${chalk.cyan("Defaults")} ${chalk.dim("(non-interactive)")}
     model: first available    concurrency: 5    worktrees: auto    merge: yolo    perms: auto
@@ -251,6 +256,9 @@ async function main() {
     let usageCap;
     let allowExtraUsage = false;
     let extraUsageBudget;
+    let permissionMode = "auto";
+    let useWorktrees = false;
+    let mergeStrategy = "yolo";
     if (resuming) {
         workerModel = resumeState.workerModel;
         plannerModel = resumeState.plannerModel;
@@ -260,6 +268,9 @@ async function main() {
         usageCap = resumeState.usageCap;
         allowExtraUsage = resumeState.allowExtraUsage ?? false;
         extraUsageBudget = resumeState.extraUsageBudget;
+        permissionMode = resumeState.permissionMode;
+        useWorktrees = resumeState.useWorktrees;
+        mergeStrategy = resumeState.mergeStrategy;
     }
     else if (!nonInteractive) {
         while (true) {
@@ -279,6 +290,17 @@ async function main() {
             console.error(chalk.red(`  Budget must be a positive number`));
             process.exit(1);
         }
+        // ③ Max concurrency (skip if --concurrency set)
+        if (cliFlags.concurrency) {
+            concurrency = parseInt(cliFlags.concurrency);
+        }
+        else {
+            const defaultC = Math.min(5, budget);
+            const concAns = await ask(`\n  ${chalk.cyan("③")} ${chalk.dim("Max concurrency")} ${chalk.dim("[")}${chalk.white(String(defaultC))}${chalk.dim("]:")} `);
+            concurrency = parseInt(concAns) || defaultC;
+            if (concurrency < 1)
+                concurrency = 1;
+        }
         let modelFrame = 0;
         const modelSpinner = setInterval(() => {
             process.stdout.write(`\x1B[2K\r  ${chalk.cyan(BRAILLE[modelFrame++ % BRAILLE.length])} ${chalk.dim("loading models...")}`);
@@ -293,19 +315,19 @@ async function main() {
         }
         plannerModel = models[0]?.value || "claude-sonnet-4-6";
         if (models.length > 0) {
-            workerModel = await select(`${chalk.cyan("③")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })));
+            workerModel = await select(`${chalk.cyan("④")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })));
         }
         else {
-            const ans = await ask(`  ${chalk.cyan("③")} ${chalk.dim("Worker model [claude-sonnet-4-6]:")} `);
+            const ans = await ask(`  ${chalk.cyan("④")} ${chalk.dim("Worker model [claude-sonnet-4-6]:")} `);
             workerModel = ans || "claude-sonnet-4-6";
         }
-        usageCap = await select(`${chalk.cyan("④")} Usage cap:`, [
+        usageCap = await select(`${chalk.cyan("⑤")} Usage cap:`, [
             { name: "Unlimited", value: undefined, hint: "full capacity, wait through rate limits" },
             { name: "90%", value: 0.9, hint: "leave 10% for other work" },
             { name: "75%", value: 0.75, hint: "conservative, plenty of headroom" },
             { name: "50%", value: 0.5, hint: "use half, keep the rest" },
         ]);
-        const extraChoice = await select(`${chalk.cyan("⑤")} Allow extra usage ${chalk.dim("(billed separately)")}:`, [
+        const extraChoice = await select(`${chalk.cyan("⑥")} Allow extra usage ${chalk.dim("(billed separately)")}:`, [
             { name: "No", value: "no", hint: "stop when plan limits are reached" },
             { name: "Yes, with $ limit", value: "budget", hint: "set a spending cap" },
             { name: "Yes, unlimited", value: "unlimited", hint: "keep going no matter what" },
@@ -319,7 +341,44 @@ async function main() {
         }
         else if (extraChoice === "unlimited")
             allowExtraUsage = true;
-        concurrency = Math.min(5, budget);
+        // ⑦ Permission mode (skip if --yolo or --perm set)
+        const cliYolo = argv.includes("--yolo");
+        if (cliFlags.perm) {
+            permissionMode = cliFlags.perm;
+        }
+        else if (cliYolo) {
+            permissionMode = "bypassPermissions";
+        }
+        else {
+            permissionMode = await select(`${chalk.cyan("⑦")} Permissions:`, [
+                { name: "Auto", value: "auto", hint: "accept low-risk, reject high-risk" },
+                { name: "Bypass all", value: "bypassPermissions", hint: "agents can run anything (yolo)" },
+                { name: "Prompt each", value: "default", hint: "ask for every dangerous op" },
+            ]);
+        }
+        // ⑧ Worktrees + merge (skip if --yolo, --worktrees, --no-worktrees, or --merge set)
+        const gitRepo = isGitRepo(cwd);
+        if (cliYolo || argv.includes("--no-worktrees")) {
+            useWorktrees = false;
+            mergeStrategy = cliFlags.merge || "yolo";
+        }
+        else if (argv.includes("--worktrees")) {
+            useWorktrees = true;
+            mergeStrategy = cliFlags.merge || "yolo";
+        }
+        else if (gitRepo) {
+            const wtChoice = await select(`${chalk.cyan("⑧")} Git isolation:`, [
+                { name: "Worktrees + yolo merge", value: "wt-yolo", hint: "isolate agents, merge into current branch" },
+                { name: "Worktrees + new branch", value: "wt-branch", hint: "isolate agents, merge into a new branch" },
+                { name: "No worktrees", value: "no-wt", hint: "all agents share the working directory" },
+            ]);
+            useWorktrees = wtChoice !== "no-wt";
+            mergeStrategy = wtChoice === "wt-branch" ? "branch" : "yolo";
+        }
+        else {
+            useWorktrees = false;
+            mergeStrategy = "yolo";
+        }
         const parts = [];
         if (workerModel !== plannerModel)
             parts.push(`${detectModelTier(workerModel)} → ${detectModelTier(plannerModel)}`);
@@ -331,6 +390,12 @@ async function main() {
         if (usageCap != null)
             parts.push(`cap ${Math.round(usageCap * 100)}%`);
         parts.push(allowExtraUsage ? (extraUsageBudget ? `extra $${extraUsageBudget}` : "extra ∞") : "no extra");
+        if (permissionMode !== "auto")
+            parts.push(permissionMode === "bypassPermissions" ? "yolo" : "prompt");
+        if (useWorktrees)
+            parts.push(mergeStrategy === "branch" ? "wt→branch" : "wt→yolo");
+        else
+            parts.push("no wt");
         if (completedRuns.length > 0)
             parts.push(`${completedRuns.length} prior`);
         const inner = parts.join(chalk.dim(" · "));
@@ -375,11 +440,28 @@ async function main() {
         }
     }
     validateConcurrency(concurrency);
-    const permissionMode = resuming ? resumeState.permissionMode : (fileCfg?.permissionMode ?? "auto");
-    const useWorktrees = resuming ? resumeState.useWorktrees : (fileCfg?.useWorktrees ?? isGitRepo(cwd));
+    // Resolve permissionMode, useWorktrees, mergeStrategy for non-interactive + non-resume
+    if (!resuming && nonInteractive) {
+        const yolo = argv.includes("--yolo");
+        permissionMode = cliFlags.perm ? cliFlags.perm
+            : yolo ? "bypassPermissions"
+                : (fileCfg?.permissionMode ?? "auto");
+        if (!["auto", "bypassPermissions", "default"].includes(permissionMode)) {
+            console.error(chalk.red(`  --perm must be auto, bypassPermissions, or default (got ${permissionMode})`));
+            process.exit(1);
+        }
+        useWorktrees = argv.includes("--no-worktrees") || yolo ? false
+            : argv.includes("--worktrees") ? true
+                : (fileCfg?.useWorktrees ?? isGitRepo(cwd));
+        mergeStrategy = cliFlags.merge ? cliFlags.merge
+            : (fileCfg?.mergeStrategy ?? "yolo");
+        if (!["yolo", "branch"].includes(mergeStrategy)) {
+            console.error(chalk.red(`  --merge must be yolo or branch (got ${mergeStrategy})`));
+            process.exit(1);
+        }
+    }
     if (useWorktrees)
         validateGitRepo(cwd);
-    const mergeStrategy = resuming ? resumeState.mergeStrategy : (fileCfg?.mergeStrategy ?? "yolo");
     if (nonInteractive) {
         const capStr = usageCap != null ? `  cap=${Math.round(usageCap * 100)}%` : "";
         const extraStr = allowExtraUsage ? (extraUsageBudget ? `  extra=$${extraUsageBudget}` : "  extra=∞") : "  extra=off";
@@ -416,7 +498,7 @@ async function main() {
                     for (let i = 0; i < themes.length; i++)
                         console.log(chalk.dim(`  ${String(i + 1).padStart(3)}.`) + ` ${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: "q", desc: "uit" }]);
+                    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") {
                         reviewing = false;
                         break;
@@ -435,6 +517,28 @@ async function main() {
                         }
                         planRestore();
                     }
+                    else if (action === "c") {
+                        const question = await ask(`\n  ${chalk.bold("Ask about the themes:")}\n  ${chalk.cyan(">")} `);
+                        if (!question)
+                            continue;
+                        process.stdout.write("\x1B[?25l");
+                        try {
+                            let answer = "";
+                            for await (const msg of query({
+                                prompt: `You're planning work for: "${objective}"\n\nThemes identified:\n${themes.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n\nUser question: ${question}`,
+                                options: { cwd, model: plannerModel, permissionMode, persistSession: false },
+                            })) {
+                                if (msg.type === "result" && msg.subtype === "success")
+                                    answer = msg.result || "";
+                            }
+                            planRestore();
+                            if (answer)
+                                console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
+                        }
+                        catch {
+                            planRestore();
+                        }
+                    }
                     else {
                         console.log(chalk.dim("\n  Aborted.\n"));
                         process.exit(0);

package/dist/render.js

@@ -183,7 +183,8 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
     if (showHotkeys) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
-        out.push(chalk.dim("  [b] budget  [t] threshold  [s] steer  [?] ask  [q] stop") + chip);
+        const fixChip = swarm.failed > 0 && swarm.active > 0 ? chalk.yellow("  [f] fix") : "";
+        out.push(chalk.dim("  [b] budget  [t] threshold  [s] steer  [?] ask  [q] stop") + fixChip + chip);
     }
     out.push("");
     return out.join("\n");

package/dist/swarm.d.ts

@@ -59,6 +59,8 @@ export declare class Swarm {
     get pending(): number;
     run(): Promise<void>;
     abort(): void;
+    /** Re-queue all errored agents' tasks for retry within this wave. */
+    requeueFailed(): number;
     logSequence: number;
     log(agentId: number, text: string): void;
     cleanup(): void;

package/dist/swarm.js

@@ -110,6 +110,21 @@ export class Swarm {
         this.activeQueries.forEach(q => q.close());
         this.activeQueries.clear();
     }
+    /** Re-queue all errored agents' tasks for retry within this wave. */
+    requeueFailed() {
+        const errored = this.agents.filter(a => a.status === "error");
+        if (errored.length === 0)
+            return 0;
+        for (const a of errored) {
+            this.queue.push(a.task);
+            a.status = "pending";
+            a.error = undefined;
+            a.finishedAt = undefined;
+        }
+        this.failed -= errored.length;
+        this.log(-1, `Re-queued ${errored.length} failed task(s)`);
+        return errored.length;
+    }
     logSequence = 0;
     log(agentId, text) {
         const entry = { time: Date.now(), agentId, text };
@@ -201,21 +216,39 @@ export class Swarm {
         this.agents.push(agent);
         let agentCwd = task.cwd || this.config.cwd;
         if (this.config.useWorktrees && this.worktreeBase && !task.noWorktree) {
-            try {
-                const branch = `swarm/task-${id}`;
-                const dir = join(this.worktreeBase, `agent-${id}`);
-                gitExec(`git worktree add -b "${branch}" "${dir}" HEAD`, this.config.cwd);
+            const branch = `swarm/task-${id}`;
+            const dir = join(this.worktreeBase, `agent-${id}`);
+            let worktreeOk = false;
+            for (let wt = 0; wt < 2 && !worktreeOk; wt++) {
+                try {
+                    gitExec(`git worktree add -b "${branch}" "${dir}" HEAD`, this.config.cwd);
+                    worktreeOk = true;
+                }
+                catch (e) {
+                    if (wt === 0) {
+                        this.log(id, `Worktree failed, cleaning up: ${e.message?.slice(0, 50)}`);
+                        try {
+                            gitExec(`git branch -D "${branch}"`, this.config.cwd);
+                        }
+                        catch { }
+                        try {
+                            rmSync(dir, { recursive: true, force: true });
+                        }
+                        catch { }
+                        try {
+                            gitExec("git worktree prune", this.config.cwd);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            if (worktreeOk) {
                 agentCwd = dir;
                 agent.branch = branch;
                 this.log(id, `Worktree: ${branch}`);
             }
-            catch (e) {
-                this.log(id, `Worktree failed: ${e.message?.slice(0, 60)}`);
-                agent.status = "error";
-                agent.error = "worktree creation failed";
-                agent.finishedAt = Date.now();
-                this.failed++;
-                return;
+            else {
+                this.log(id, `Worktree failed after retry — running without isolation`);
             }
         }
         this.log(id, `Starting: ${task.prompt.slice(0, 60)}`);

package/dist/ui.js

@@ -266,6 +266,9 @@ export class RunDisplay {
                     this.inputBuf = "";
                 }
             }
+            else if ((s === "f" || s === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
+                this.swarm.requeueFailed();
+            }
             else if ((s === "s" || s === "S") && this.onSteer) {
                 this.inputMode = "steer";
                 this.inputBuf = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Run 10, 100, or 1000 Claude agents overnight. Parallel autonomous AI coding with thinking waves, iterative quality steering, crash recovery, and rate limit handling. Built on the Claude Agent SDK.",
   "type": "module",
   "bin": {