claude-overnight 0.1.2 → 0.3.2

package/dist/swarm.js

@@ -16,6 +16,7 @@ export class Swarm {
     totalOutputTokens = 0;
     phase = "running";
     aborted = false;
+    cappedOut = false;
     mergeResults = [];
     // Rate limit tracking for auto-concurrency
     rateLimitUtilization = 0;
@@ -29,6 +30,7 @@ export class Swarm {
     cleanedUp = false;
     logFile;
     model;
+    usageCap;
     constructor(config) {
         if (!config.tasks.length) {
             throw new Error("SwarmConfig: tasks array must not be empty");
@@ -49,6 +51,7 @@ export class Swarm {
         }
         this.config = config;
         this.model = config.model;
+        this.usageCap = config.usageCap;
         this.queue = [...config.tasks];
         this.total = config.tasks.length;
     }
@@ -85,18 +88,23 @@ export class Swarm {
         this.activeQueries.forEach((q) => q.close());
         this.activeQueries.clear();
     }
+    /** Monotonic counter so non-TTY consumers can detect log trimming. */
+    logSequence = 0;
     log(agentId, text) {
         const entry = { time: Date.now(), agentId, text };
         this.logs.push(entry);
         this.allLogs.push(entry);
+        this.logSequence++;
         if (this.logs.length > 300)
             this.logs.splice(0, this.logs.length - 150);
     }
     // ── Worker loop with auto-concurrency throttling ──
     async worker() {
         let tasksProcessed = 0;
-        while (this.queue.length > 0 && !this.aborted) {
+        while (this.queue.length > 0 && !this.aborted && !this.cappedOut) {
             await this.throttle();
+            if (this.cappedOut)
+                break;
             const task = this.queue.shift();
             if (!task)
                 break;
@@ -112,14 +120,25 @@ export class Swarm {
         this.log(-1, `Worker finished (${tasksProcessed} tasks)`);
     }
     async throttle() {
+        // Usage cap: stop dispatching when utilization exceeds user's cap
+        const cap = this.config.usageCap;
+        if (cap != null && cap < 1 && this.rateLimitUtilization >= cap) {
+            this.cappedOut = true;
+            this.log(-1, `Usage cap ${Math.round(cap * 100)}% reached (at ${Math.round(this.rateLimitUtilization * 100)}%) — finishing active agents, no new tasks`);
+            return;
+        }
         // Hard block: rate limit rejected — wait until reset
         if (this.rateLimitResetsAt) {
-            const waitMs = this.rateLimitResetsAt - Date.now();
+            const resetTarget = this.rateLimitResetsAt;
+            const waitMs = resetTarget - Date.now();
             if (waitMs > 0) {
                 this.log(-1, `Rate limited, pausing ${Math.ceil(waitMs / 1000)}s`);
                 await sleep(waitMs);
             }
-            this.rateLimitResetsAt = undefined;
+            // Only clear if no newer deadline arrived while we slept
+            if (this.rateLimitResetsAt === resetTarget) {
+                this.rateLimitResetsAt = undefined;
+            }
         }
         // Soft throttle: 0-15s proportional to 75-100% utilization
         else if (this.rateLimitUtilization > 0.75) {
@@ -229,7 +248,10 @@ export class Swarm {
                 break; // Success — exit retry loop
             }
             catch (err) {
-                const canRetry = attempt < maxRetries && isTransientError(err);
+                // If handleMsg already processed a result, don't double-count
+                if (agent.status !== "running")
+                    break;
+                const canRetry = attempt < maxRetries && !this.aborted && isTransientError(err);
                 if (canRetry) {
                     this.log(id, `Transient error: ${String(err.message || err).slice(0, 80)}`);
                     continue;
@@ -295,6 +317,16 @@ export class Swarm {
             this.log(-1, "No changes to merge");
             return;
         }
+        // Remember current branch so we can return to it reliably
+        let originalRef;
+        try {
+            const branch = exec("git rev-parse --abbrev-ref HEAD", this.config.cwd).trim();
+            // Detached HEAD returns "HEAD" — fall back to the commit hash so we can restore it
+            originalRef = branch === "HEAD"
+                ? exec("git rev-parse HEAD", this.config.cwd).trim()
+                : branch;
+        }
+        catch { }
         // Stash dirty working tree before merging
         let stashed = false;
         try {
@@ -381,10 +413,10 @@ export class Swarm {
             }
             const totalFilesChanged = this.mergeResults.reduce((sum, r) => sum + (r.ok ? r.filesChanged : 0), 0);
             this.log(-1, `Merged ${merged.length}/${branches.length} branches, ${totalFilesChanged} files changed${failed.length > 0 ? ` (${failed.length} unresolved)` : ""}`);
-            if (strategy === "branch" && this.mergeBranch) {
-                // Switch back to the original branch
+            if (strategy === "branch" && this.mergeBranch && originalRef) {
+                // Switch back to the original branch (or detached commit)
                 try {
-                    exec("git checkout -", this.config.cwd);
+                    exec(`git checkout "${originalRef}"`, this.config.cwd);
                 }
                 catch { }
             }
@@ -432,9 +464,14 @@ export class Swarm {
         try {
             const list = exec("git worktree list --porcelain", this.config.cwd);
             const stale = [];
+            const tmp = tmpdir();
             for (const line of list.split("\n")) {
-                if (line.startsWith("worktree ") && line.includes("claude-overnight-")) {
-                    stale.push(line.slice("worktree ".length));
+                if (line.startsWith("worktree ")) {
+                    const wpath = line.slice("worktree ".length);
+                    // Only clean worktrees created by us in tmpdir — never touch repo dirs
+                    if (wpath.startsWith(tmp) && wpath.includes("claude-overnight-")) {
+                        stale.push(wpath);
+                    }
                 }
             }
             if (stale.length > 0) {
@@ -447,11 +484,18 @@ export class Swarm {
                 }
                 exec("git worktree prune", this.config.cwd);
             }
-            // Also clean orphaned swarm branches from previous runs
+            // Clean orphaned task branches from previous runs (preserve swarm/run-* user branches)
+            // Only delete branches not actively checked out in a worktree
+            const worktreeBranches = new Set();
+            for (const line of list.split("\n")) {
+                if (line.startsWith("branch refs/heads/")) {
+                    worktreeBranches.add(line.slice("branch refs/heads/".length));
+                }
+            }
             const branches = exec("git branch", this.config.cwd)
                 .split("\n")
                 .map((b) => b.trim().replace(/^\* /, ""))
-                .filter((b) => b.startsWith("swarm/"));
+                .filter((b) => b.startsWith("swarm/task-") && !worktreeBranches.has(b));
             for (const b of branches) {
                 try {
                     exec(`git branch -D "${b}"`, this.config.cwd);
@@ -492,7 +536,6 @@ export class Swarm {
                     time: new Date(l.time).toISOString(), agent: l.agentId, text: l.text,
                 })),
             }, null, 2));
-            process.stderr.write(`Log: ${this.logFile}\n`);
         }
         catch { }
     }
@@ -506,16 +549,13 @@ export class Swarm {
     handleMsg(agent, msg) {
         switch (msg.type) {
             case "assistant": {
+                // Tool calls are counted via stream_event (content_block_start) to avoid
+                // double-counting — the assistant message repeats the same tool_use blocks.
                 const m = msg;
                 if (!m.message?.content)
                     break;
                 for (const block of m.message.content) {
-                    if (block.type === "tool_use") {
-                        agent.currentTool = block.name;
-                        agent.toolCalls++;
-                        this.log(agent.id, block.name);
-                    }
-                    else if (block.type === "text" && block.text) {
+                    if (block.type === "text" && block.text) {
                         const line = block.text.trim().split("\n")[0]?.slice(0, 80);
                         if (line)
                             agent.lastText = line;
@@ -541,15 +581,16 @@ export class Swarm {
                         if (t)
                             agent.lastText = t.slice(0, 80);
                     }
-                }
-                else if (ev.type === "content_block_stop") {
-                    agent.currentTool = undefined;
+                    // Note: content_block_stop is NOT used to clear currentTool — the block
+                    // finishes streaming but the tool hasn't executed yet. Clear it when the
+                    // next content_block_start arrives (above) or on turn end (result handler).
                 }
                 break;
             }
             case "result": {
                 const safeAdd = (v) => typeof v === 'number' && isFinite(v) && v >= 0 ? v : 0;
                 const r = msg;
+                agent.currentTool = undefined;
                 agent.finishedAt = Date.now();
                 const cost = safeAdd(r.total_cost_usd);
                 agent.costUsd = cost;

package/dist/types.d.ts

@@ -11,6 +11,8 @@ export interface Task {
 }
 /** Schema for a JSON task file that defines a batch of work for the swarm. */
 export interface TaskFile {
+    /** High-level objective for multi-wave steering (required when flexiblePlan is true). */
+    objective?: string;
     /** Max number of agents running in parallel. */
     concurrency?: number;
     /** Default working directory for all tasks. */
@@ -23,6 +25,10 @@ export interface TaskFile {
     allowedTools?: string[];
     /** Merge strategy: "yolo" merges into current branch, "branch" creates a new branch. */
     mergeStrategy?: MergeStrategy;
+    /** Stop dispatching new tasks when rate-limit utilization reaches this percentage (0-100). */
+    usageCap?: number;
+    /** Enable adaptive multi-wave planning: after each wave, a steering agent reads the codebase and plans the next wave. Default true in interactive mode. */
+    flexiblePlan?: boolean;
     /** Tasks to execute — either plain prompt strings or objects with per-task overrides. */
     tasks: (string | {
         prompt: string;

package/dist/ui.js

@@ -41,18 +41,36 @@ export function renderFrame(swarm) {
     const cost = swarm.totalCostUsd > 0
         ? chalk.yellow(`$${swarm.totalCostUsd.toFixed(3)}`)
         : "";
-    const rlPct = swarm.rateLimitUtilization;
-    const rlBar = rlPct > 0
-        ? "  " +
-            (rlPct > 0.8
-                ? chalk.red(`RL ${Math.round(rlPct * 100)}%`)
-                : rlPct > 0.5
-                    ? chalk.yellow(`RL ${Math.round(rlPct * 100)}%`)
-                    : chalk.green(`RL ${Math.round(rlPct * 100)}%`))
-        : "";
     out.push(chalk.gray(`  \u2191 ${tokIn} in  \u2193 ${tokOut} out`) +
-        (cost ? `  ${cost}` : "") +
-        rlBar);
+        (cost ? `  ${cost}` : ""));
+    // ── Usage bar ──
+    const rlPct = swarm.rateLimitUtilization;
+    if (rlPct > 0 || swarm.rateLimitResetsAt || swarm.cappedOut) {
+        const barW = Math.min(30, w - 40);
+        const filled = Math.round(rlPct * barW);
+        const capFrac = swarm.usageCap;
+        const capMark = capFrac != null && capFrac < 1 ? Math.round(capFrac * barW) : -1;
+        let barStr = "";
+        for (let i = 0; i < barW; i++) {
+            if (i === capMark)
+                barStr += chalk.yellow("\u2502");
+            else if (i < filled)
+                barStr += rlPct > 0.9 ? chalk.red("\u2588") : rlPct > 0.75 ? chalk.yellow("\u2588") : chalk.blue("\u2588");
+            else
+                barStr += chalk.gray("\u2591");
+        }
+        let label = `${Math.round(rlPct * 100)}% used`;
+        if (swarm.cappedOut) {
+            label = chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% — finishing active`);
+        }
+        else if (swarm.rateLimitResetsAt) {
+            const waitSec = Math.max(0, Math.ceil((swarm.rateLimitResetsAt - Date.now()) / 1000));
+            const mm = Math.floor(waitSec / 60);
+            const ss = waitSec % 60;
+            label = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
+        }
+        out.push(`  ${chalk.dim("Usage")} ${barStr}  ${label}`);
+    }
     out.push("");
     // ── Agent table ──
     const running = swarm.agents.filter((a) => a.status === "running");
@@ -251,7 +269,7 @@ export function renderSummary(swarm) {
     return out.join("\n");
 }
 function startPlainLog(swarm) {
-    let lastLogLen = 0;
+    let lastSeq = swarm.logSequence;
     let lastCompleted = -1;
     const write = (line) => {
         try {
@@ -262,13 +280,18 @@ function startPlainLog(swarm) {
         }
     };
     const interval = setInterval(() => {
-        if (swarm.logs.length > lastLogLen) {
-            for (const entry of swarm.logs.slice(lastLogLen)) {
+        const currentSeq = swarm.logSequence;
+        if (currentSeq > lastSeq) {
+            // Read the most recent (currentSeq - lastSeq) entries from the tail of the log
+            const newCount = currentSeq - lastSeq;
+            const available = swarm.logs.length;
+            const toShow = Math.min(newCount, available);
+            for (const entry of swarm.logs.slice(available - toShow)) {
                 const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
                 const tag = entry.agentId < 0 ? "[sys]" : `[${entry.agentId}]`;
                 write(`${t} ${tag} ${entry.text}`);
             }
-            lastLogLen = swarm.logs.length;
+            lastSeq = currentSeq;
         }
         if (swarm.completed !== lastCompleted) {
             lastCompleted = swarm.completed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "0.1.2",
+  "version": "0.3.2",
   "description": "Fire off Claude agents, come back days later to shipped work. Maximizes every token in your plan.",
   "type": "module",
   "bin": {