claude-overnight 1.25.45 → 1.25.46

package/dist/cli/cli.d.ts

@@ -61,6 +61,11 @@ export interface FileArgs {
     usageCap?: number;
     flexiblePlan?: boolean;
 }
+/** Load a markdown plan file. Extracts the first H1 as objective and returns the full body as planContent. */
+export declare function loadPlanFile(file: string): {
+    objective: string;
+    planContent: string;
+};
 export declare function loadTaskFile(file: string): FileArgs;
 export declare function validateConcurrency(value: unknown): asserts value is number;
 export declare function isGitRepo(cwd: string): boolean;

package/dist/cli/cli.js

@@ -7,7 +7,7 @@ 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", "merge"]);
-    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex", "--allow-extra-usage", "--worktrees", "--no-worktrees", "--yolo"]);
+    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--flex", "--no-flex", "--allow-extra-usage", "--worktrees", "--no-worktrees", "--yolo"]);
     const flags = {};
     const positional = [];
     for (let i = 0; i < argv.length; i++) {
@@ -334,6 +334,23 @@ export async function selectKey(label, options) {
 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;

package/dist/core/_version.d.ts

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

package/dist/core/_version.js

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

package/dist/core/jwt-signer.js

@@ -59,27 +59,29 @@ export function verifyToken(token, providerId) {
  */
 export function verifyTokenWithResult(token, options = {}) {
     const { providerId, model, baseURL } = options;
-    // Unsafely decode the token to extract the `sub` claim so we can derive
-    // the correct signing key. This does NOT verify the signature yet.
-    const raw = jwt.decode(token);
-    if (!raw || typeof raw !== "object") {
+    const header = jwt.decode(token, { complete: true });
+    if (!header || typeof header === "string") {
         return { valid: false, reason: "invalid_signature" };
     }
-    const sub = raw.sub;
-    if (typeof sub !== "string" || !sub) {
+    const loose = header.payload;
+    const subForKey = loose.sub;
+    if (!subForKey || typeof subForKey !== "string") {
+        return { valid: false, reason: "invalid_signature" };
+    }
+    let key;
+    try {
+        key = deriveKey(subForKey);
+    }
+    catch {
         return { valid: false, reason: "invalid_signature" };
     }
-    const key = deriveKey(sub);
     try {
         const decoded = jwt.verify(token, key, {
             algorithms: ["HS256"],
-            // Let jwt.verify check expiration for us
         });
-        // Reject tokens from older versions
         if (decoded.ver !== TOKEN_VERSION) {
             return { valid: false, reason: "wrong_version" };
         }
-        // Validate claims if expected values are provided
         if (providerId && decoded.sub !== providerId) {
             return { valid: false, reason: "claim_mismatch" };
         }

package/dist/core/rate-limiter.d.ts

@@ -8,6 +8,12 @@ export interface RateLimiterConfig {
     windowMs: number;
     minIntervalMs?: number;
 }
+export interface AcquireOptions {
+    /** When true, skip sliding-window / min-interval waits (caller still records after the request). */
+    skipWhen?: () => boolean;
+    /** Invoked once when `skipWhen()` returned true and the throttle was bypassed. */
+    onBypass?: () => void;
+}
 export declare class RateLimiter {
     private readonly maxRequests;
     private readonly windowMs;
@@ -18,6 +24,8 @@ export declare class RateLimiter {
     record(): void;
     get currentCount(): number;
     canRequest(): boolean;
+    /** Wait until a request slot is available. Optional `skipWhen` bypasses the throttle entirely. */
+    acquire(options?: AcquireOptions): Promise<number>;
     waitIfNeeded(): Promise<number>;
     waitMs(): number;
     reset(): void;
@@ -29,6 +37,8 @@ export declare class RateLimiter {
 }
 /** Shared rate limiter for SDK query calls — enforced globally across all workers. */
 export declare const sdkQueryRateLimiter: RateLimiter;
+/** Acquire SDK query slot. Skips the SDK sliding-window limiter when `CURSOR_PROXY_URL` is set (proxy has its own limiters). */
+export declare function acquireSdkQueryRateLimit(): Promise<number>;
 /** Shared rate limiter for Cursor proxy direct fetches — enforced globally. */
 export declare const cursorProxyRateLimiter: RateLimiter;
 /** Shared rate limiter for direct API endpoint calls — guards against rapid

package/dist/core/rate-limiter.js

@@ -38,12 +38,20 @@ export class RateLimiter {
         return this.timestamps.length < this.maxRequests
             && (Date.now() - this.lastRequestAt) >= this.minIntervalMs;
     }
-    async waitIfNeeded() {
+    /** Wait until a request slot is available. Optional `skipWhen` bypasses the throttle entirely. */
+    async acquire(options) {
+        if (options?.skipWhen?.()) {
+            options.onBypass?.();
+            return 0;
+        }
         const waited = this.waitMs();
         if (waited > 0)
             await new Promise(r => setTimeout(r, waited));
         return waited;
     }
+    async waitIfNeeded() {
+        return this.acquire();
+    }
     waitMs() {
         this.evict();
         const volumeWait = this.timestamps.length >= this.maxRequests
@@ -86,6 +94,15 @@ const _cursorProxyLimiter = new RateLimiter({ maxRequests: 4, windowMs: 10_000 }
 const _apiEndpointLimiter = new RateLimiter({ maxRequests: 6, windowMs: 15_000, minIntervalMs: 1_000 });
 /** Shared rate limiter for SDK query calls — enforced globally across all workers. */
 export const sdkQueryRateLimiter = _sdkQueryLimiter;
+/** Acquire SDK query slot. Skips the SDK sliding-window limiter when `CURSOR_PROXY_URL` is set (proxy has its own limiters). */
+export async function acquireSdkQueryRateLimit() {
+    return _sdkQueryLimiter.acquire({
+        skipWhen: () => !!process.env.CURSOR_PROXY_URL,
+        onBypass: () => {
+            console.log("[rate-limiter] Skipping SDK rate limit (Cursor proxy has its own limiter)");
+        },
+    });
+}
 /** Shared rate limiter for Cursor proxy direct fetches — enforced globally. */
 export const cursorProxyRateLimiter = _cursorProxyLimiter;
 /** Shared rate limiter for direct API endpoint calls — guards against rapid

package/dist/core/token-cache.js

@@ -21,7 +21,7 @@ export function getCachedToken(providerId) {
     const entry = tokenCache.get(providerId);
     if (!entry)
         return null;
-    if (isRevoked(entry.sessionId)) {
+    if (isSessionRevoked(entry.sessionId)) {
         tokenCache.delete(providerId);
         return null;
     }
@@ -51,7 +51,7 @@ export function tryRefreshCachedToken(providerId, refresher) {
     const entry = tokenCache.get(providerId);
     if (!entry)
         return null;
-    if (isRevoked(entry.sessionId)) {
+    if (isSessionRevoked(entry.sessionId)) {
         tokenCache.delete(providerId);
         return null;
     }
@@ -99,11 +99,6 @@ export function clearRevocations() {
 export function getRevocationCount() {
     return revokedSessions.size;
 }
-/** Check if a session ID has been revoked, pruning expired entries first. */
-function isRevoked(sessionId) {
-    pruneRevocations();
-    return revokedSessions.has(sessionId);
-}
 /** Remove expired revocation entries and enforce max size. */
 function pruneRevocations() {
     if (revokedSessions.size === 0)

package/dist/core/token-manager.js

@@ -65,10 +65,9 @@ export function refreshToken(oldToken, providerId) {
  */
 export function verifyBearerToken(token, providerId) {
     const result = verifyTokenWithResult(token, { providerId });
-    if (!result.valid)
+    if (!result.valid || !result.payload)
         return result;
-    // Reject if the session was explicitly revoked (check token's jti, not cache)
-    if (result.payload && isSessionRevoked(result.payload.jti)) {
+    if (isSessionRevoked(result.payload.jti)) {
         return { valid: false, reason: "revoked" };
     }
     return result;
@@ -100,11 +99,15 @@ function tryPeekAndRevoke(providerId) {
  * reducing false positives from unrelated 401/403 responses.
  */
 export function isJWTAuthError(err) {
-    const msg = err instanceof Error ? err.message
-        : (err !== null && typeof err === "object" && "message" in err && typeof err.message === "string")
+    const msg = err instanceof Error
+        ? err.message
+        : err && typeof err === "object" && "message" in err && typeof err.message === "string"
             ? err.message
             : String(err);
     const lower = msg.toLowerCase();
+    if (lower.includes("bearer") && lower.includes("token") && lower.includes("invalid")) {
+        return true;
+    }
     // JWT-specific indicators (high confidence)
     const jwtIndicators = [
         "token expired", "invalid_token", "jwt", "signature",

package/dist/core/types.d.ts

@@ -88,6 +88,8 @@ export interface AgentState {
     peakContextTokens?: number;
     /** Resolved model this agent is running (task override or swarm default). */
     model?: string;
+    /** Unix timestamp (ms) of the last assistant stream content (text, tool deltas, etc.). Used to detect SDK streams that yield no content. */
+    lastContentTimestamp?: number;
 }
 /** A timestamped log line from an agent's execution. */
 export interface LogEntry {
@@ -173,8 +175,13 @@ export interface WaveSummary {
         status: string;
         type?: string;
         filesChanged?: number;
+        toolCalls?: number;
         error?: string;
     }[];
+    /** Sum of `toolCalls` across all agents in this wave (diagnostics). */
+    totalToolCalls?: number;
+    /** Non-heal tasks landed 0 files but agents invoked tools — possible worktree/merge bug. */
+    suspectedInfraFailure?: boolean;
 }
 /** Result from the steering function. */
 export interface SteerResult {

package/dist/planner/coach/coach.d.ts

@@ -11,5 +11,9 @@ export interface CoachContext {
     log?: PlannerLog;
     coachModel?: string;
     coachProvider?: ProviderConfig;
+    /** Full markdown plan content (e.g. from a .md plan file). Overrides URL fetching. */
+    planContent?: string;
+    /** When true, show only accept/skip and do not persist user settings. */
+    confirmOnly?: boolean;
 }
 export declare function runSetupCoach(rawObjective: string, cwd: string, ctx: CoachContext): Promise<CoachResult | null>;

package/dist/planner/coach/coach.js

@@ -47,13 +47,15 @@ export async function runSetupCoach(rawObjective, cwd, ctx) {
     const facts = collectRepoFacts(cwd);
     if (facts.srcFileCount > 1_000_000)
         return null;
-    const urls = rawObjective.match(URL_REGEX) ?? [];
-    let planContent = null;
-    if (urls.length > 0) {
-        const results = await Promise.all(urls.map(u => fetchUrlContent(u, 4_000)));
-        const fetched = results.filter(Boolean);
-        if (fetched.length > 0) {
-            planContent = fetched.map((c, i) => `[URL ${i + 1}: ${urls[i]}]\n${c}`).join("\n\n---\n\n");
+    let planContent = ctx.planContent ?? null;
+    if (!planContent) {
+        const urls = rawObjective.match(URL_REGEX) ?? [];
+        if (urls.length > 0) {
+            const results = await Promise.all(urls.map(u => fetchUrlContent(u, 4_000)));
+            const fetched = results.filter(Boolean);
+            if (fetched.length > 0) {
+                planContent = fetched.map((c, i) => `[URL ${i + 1}: ${urls[i]}]\n${c}`).join("\n\n---\n\n");
+            }
         }
     }
     const userMessage = renderRepoFacts(facts, rawObjective, ctx.providers, ctx.cliFlags, planContent);
@@ -120,14 +122,20 @@ export async function runSetupCoach(rawObjective, cwd, ctx) {
         return null;
     }
     renderCoachBlock(result, elapsedMs, model);
-    const choice = await selectKey("", [
-        { key: "y", desc: " accept" },
-        { key: "e", desc: "dit objective" },
-        { key: "s", desc: "kip coach" },
-        { key: "x", desc: " skip coach forever" },
-    ]);
+    const choice = ctx.confirmOnly
+        ? await selectKey("", [
+            { key: "y", desc: " accept" },
+            { key: "s", desc: "kip" },
+        ])
+        : await selectKey("", [
+            { key: "y", desc: " accept" },
+            { key: "e", desc: "dit objective" },
+            { key: "s", desc: "kip coach" },
+            { key: "x", desc: " skip coach forever" },
+        ]);
     if (choice === "y") {
-        saveUserSettings({ ...loadUserSettings(), lastCoachedAt: Date.now() });
+        if (!ctx.confirmOnly)
+            saveUserSettings({ ...loadUserSettings(), lastCoachedAt: Date.now() });
         return result;
     }
     if (choice === "e") {

package/dist/planner/query.js

@@ -3,7 +3,7 @@ import { NudgeError, extractToolTarget, sumUsageTokens } from "../core/types.js"
 import { writeTranscriptEvent } from "../core/transcripts.js";
 import { getTurn, updateTurn } from "../core/turns.js";
 import { isRateLimitError, throttlePlanner, addPlannerCost, recordPeakContext, resetPlannerRateLimit, setContextTokens, applyRateLimitEvent, getPlannerRateLimitInfo, } from "./throttle.js";
-import { cursorProxyRateLimiter, sdkQueryRateLimiter, apiEndpointLimiter } from "../core/rate-limiter.js";
+import { cursorProxyRateLimiter, sdkQueryRateLimiter, apiEndpointLimiter, acquireSdkQueryRateLimit } from "../core/rate-limiter.js";
 export { getTotalPlannerCost, getPeakPlannerContext, getPlannerRateLimitInfo, } from "./throttle.js";
 export { attemptJsonParse, extractTaskJson } from "./json.js";
 export { postProcess } from "./postprocess.js";
@@ -126,7 +126,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
             promptBytes: prompt.length,
         });
     }
-    await rl.waitIfNeeded();
+    await acquireSdkQueryRateLimit();
     const pq = query({
         prompt,
         options: {

package/dist/providers/index.js

@@ -11,7 +11,7 @@ import { DEFAULT_MODEL } from "../core/models.js";
 import { isCursorProxyProvider, resolveCursorAgentToken, cachedAgentPaths, } from "./cursor-env.js";
 import { preflightCursorProxyViaHttp } from "./cursor-proxy.js";
 import { pickCursorModel } from "./cursor-picker.js";
-import { sdkQueryRateLimiter } from "../core/rate-limiter.js";
+import { sdkQueryRateLimiter, acquireSdkQueryRateLimit } from "../core/rate-limiter.js";
 // Re-export Cursor utilities so callers can keep a single import point.
 export { PROXY_DEFAULT_URL, isCursorProxyProvider, bundledComposerProxyShellCommand, readCursorProxyLogTail, warnMacCursorAgentShellPatchIfNeeded, hasCursorAgentToken, getCursorAgentToken, } from "./cursor-env.js";
 export { healthCheckCursorProxy, ensureCursorProxyRunning } from "./cursor-proxy.js";
@@ -243,7 +243,7 @@ export async function preflightProvider(p, cwd, timeoutMs = 20_000, opts) {
     let pq;
     const rl = sdkQueryRateLimiter;
     try {
-        await rl.waitIfNeeded();
+        await acquireSdkQueryRateLimit();
         pq = query({
             prompt: "Reply with exactly the word ok and nothing else.",
             options: {

package/dist/run/circuit-breaker-state.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Autonomous circuit breaker: halt after consecutive waves where no non-heal
+ * task landed merged file changes *and* no agent used tools (true idle).
+ *
+ * If agents used tools but files stayed at 0, treat as possible worktree/merge
+ * infrastructure issue — do not advance the halt streak.
+ */
+export declare function updateCircuitBreakerStreak(args: {
+    waveNum: number;
+    prevStreak: number;
+    nonHealFiles: number;
+    totalToolCallsAllAgents: number;
+}): {
+    streak: number;
+    shouldHalt: boolean;
+};

package/dist/run/circuit-breaker-state.js

@@ -0,0 +1,18 @@
+/**
+ * Autonomous circuit breaker: halt after consecutive waves where no non-heal
+ * task landed merged file changes *and* no agent used tools (true idle).
+ *
+ * If agents used tools but files stayed at 0, treat as possible worktree/merge
+ * infrastructure issue — do not advance the halt streak.
+ */
+export function updateCircuitBreakerStreak(args) {
+    const { waveNum, prevStreak, nonHealFiles, totalToolCallsAllAgents } = args;
+    if (waveNum <= 0 || nonHealFiles > 0) {
+        return { streak: 0, shouldHalt: false };
+    }
+    if (totalToolCallsAllAgents > 0) {
+        return { streak: 0, shouldHalt: false };
+    }
+    const streak = prevStreak + 1;
+    return { streak, shouldHalt: streak >= 2 };
+}

package/dist/run/wave-loop.js

@@ -15,6 +15,7 @@ import { getModelCapability } from "../core/models.js";
 import { isJWTAuthError } from "../core/auth.js";
 import { saveRunState, saveWaveSession, } from "../state/state.js";
 import { throttleBeforeWave } from "./throttle.js";
+import { updateCircuitBreakerStreak } from "./circuit-breaker-state.js";
 import { checkProjectHealth } from "./health.js";
 import { runPostWaveReview } from "./review.js";
 import { promptBudgetExtension } from "./budget.js";
@@ -159,18 +160,27 @@ export async function runWaveLoop(host, ctx) {
                 host.currentTasks = neverStarted;
             // ── Overlay merge outcomes into wave history ──
             const failedMergeBranches = new Set(swarm.mergeResults.filter(r => !r.ok).map(r => r.branch));
+            const 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,
+                    toolCalls: a.toolCalls,
+                    error: mergeFailed ? `merge-failed: branch ${a.branch} did not land` : a.error,
+                };
+            });
+            const nonHealTasks = tasks.filter(t => t.type !== "heal");
+            const nonHealFiles = nonHealTasks.reduce((sum, t) => sum + (t.filesChanged ?? 0), 0);
+            const nonHealToolCalls = nonHealTasks.reduce((sum, t) => sum + (t.toolCalls ?? 0), 0);
+            const totalToolCalls = swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+            const suspectedInfraFailure = host.waveNum > 0 && nonHealFiles === 0 && nonHealToolCalls > 0;
             host.waveHistory.push({
                 wave: host.waveNum,
-                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,
-                    };
-                }),
+                tasks,
+                totalToolCalls,
+                suspectedInfraFailure,
             });
             // ── Heal fail streak ──
             const lastWave = host.waveHistory[host.waveHistory.length - 1];
@@ -182,21 +192,26 @@ export async function runWaveLoop(host, ctx) {
                 healFailStreak = 0;
             }
             // ── Circuit breaker ──
-            const nonHealFiles = lastWave?.tasks.filter(t => t.type !== "heal").reduce((sum, t) => sum + (t.filesChanged ?? 0), 0) ?? 0;
-            if (nonHealFiles === 0 && host.waveNum > 0) {
-                zeroFileWaves++;
-                if (zeroFileWaves >= 2) {
-                    ctx.display.appendSteeringEvent(`Circuit breaker: 2 consecutive waves produced no merged changes — halting to prevent budget drain`);
-                    ctx.display.stop();
-                    saveRunState(ctx.runDir, buildRunState(host, "stopped", []));
-                    ctx.display.stop();
-                    console.log(chalk.red(`\n  Circuit breaker: 2 consecutive waves produced no merged changes.`));
-                    console.log(chalk.red(`  Halting to prevent budget drain. Run preserved at ${ctx.runDir}.`));
-                    process.exit(3);
-                }
+            const { streak: nextZeroFileWaves, shouldHalt: circuitHalt } = updateCircuitBreakerStreak({
+                waveNum: host.waveNum,
+                prevStreak: zeroFileWaves,
+                nonHealFiles,
+                totalToolCallsAllAgents: totalToolCalls,
+            });
+            if (host.waveNum > 0 && nonHealFiles === 0 && nonHealToolCalls > 0) {
+                const msg = "[circuit-breaker] Agents completed with tool calls but 0 files landed — possible worktree/merge bug, NOT a stuck agent. Continuing run.";
+                console.warn(chalk.yellow(`\n  ${msg}`));
+                ctx.display.appendSteeringEvent(msg);
             }
-            else {
-                zeroFileWaves = 0;
+            zeroFileWaves = nextZeroFileWaves;
+            if (circuitHalt) {
+                ctx.display.appendSteeringEvent(`Circuit breaker: 2 consecutive waves produced no merged changes — halting to prevent budget drain`);
+                ctx.display.stop();
+                saveRunState(ctx.runDir, buildRunState(host, "stopped", []));
+                ctx.display.stop();
+                console.log(chalk.red(`\n  Circuit breaker: 2 consecutive waves produced no merged changes.`));
+                console.log(chalk.red(`  Halting to prevent budget drain. Run preserved at ${ctx.runDir}.`));
+                process.exit(3);
             }
             // ── Hook-blocked work ──
             const hookBlocked = swarm.agents.filter(a => swarm.logs.some(l => l.agentId === a.id && l.text.includes("did NOT land")));

package/dist/swarm/agent-run.js

@@ -13,10 +13,10 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import { NudgeError } from "../core/types.js";
 import { gitExec, autoCommit } from "./merge.js";
 import { createTurn, beginTurn, endTurn, updateTurn } from "../core/turns.js";
-import { SIMPLIFY_PROMPT, withCursorWorkspaceHeader } from "./config.js";
-import { AgentTimeoutError, isRateLimitError, isTransientError, sleep } from "./errors.js";
-import { handleMsg } from "./message-handler.js";
-import { sdkQueryRateLimiter } from "../core/rate-limiter.js";
+import { SIMPLIFY_PROMPT, withCursorWorkspaceHeader, getAgentTimeout } from "./config.js";
+import { AgentTimeoutError, StreamStalledError, isRateLimitError, isTransientError, sleep } from "./errors.js";
+import { handleMsg, checkStreamHealth, NO_CONTENT_TIMEOUT_MS } from "./message-handler.js";
+import { sdkQueryRateLimiter, acquireSdkQueryRateLimit } from "../core/rate-limiter.js";
 export async function runAgent(host, task) {
     // Guard: if pause was triggered between dispatch and here, re-queue immediately.
     // The worker already shifted this task, so unshift puts it back for resume.
@@ -87,7 +87,7 @@ export async function runAgent(host, task) {
     const isResumed = !!task.resumeSessionId;
     host.log(id, isResumed ? `Resuming: ${task.prompt.slice(0, 60)}` : `Starting: ${task.prompt.slice(0, 60)}`);
     const maxRetries = host.config.maxRetries ?? 2;
-    const inactivityMs = host.config.agentTimeoutMs ?? 15 * 60 * 1000;
+    const inactivityMs = host.config.agentTimeoutMs ?? getAgentTimeout();
     const rl = sdkQueryRateLimiter;
     // Hoisted so the catch block can read the session captured during the turn
     // when routing a pause-interrupt through the requeue path.
@@ -115,7 +115,7 @@ export async function runAgent(host, task) {
                 // Read host.model (live — setModel updates it between waves), not host.config.model (frozen at construction).
                 const effectiveModel = task.model || host.model;
                 const envOverride = withCursorWorkspaceHeader(host.config.envForModel?.(effectiveModel), agentCwd);
-                await rl.waitIfNeeded();
+                await acquireSdkQueryRateLimit();
                 const agentQuery = query({
                     prompt: agentPrompt,
                     options: {
@@ -129,19 +129,29 @@ export async function runAgent(host, task) {
                 const timeoutMs = isResume ? inactivityMs * 2 : inactivityMs;
                 let sessionId;
                 let lastActivity = Date.now();
+                agent.lastContentTimestamp = Date.now();
                 let timer;
                 const watchdog = new Promise((_, reject) => {
                     const check = () => {
+                        const lastContent = agent.lastContentTimestamp;
+                        if (lastContent != null && !checkStreamHealth(lastContent, NO_CONTENT_TIMEOUT_MS)) {
+                            const elapsed = Date.now() - lastContent;
+                            agentQuery.interrupt().catch(() => agentQuery.close());
+                            reject(new StreamStalledError(elapsed, NO_CONTENT_TIMEOUT_MS));
+                            return;
+                        }
                         const silent = Date.now() - lastActivity;
                         if (silent >= timeoutMs) {
                             agentQuery.interrupt().catch(() => agentQuery.close());
                             reject(isResume ? new AgentTimeoutError(silent) : new NudgeError(sessionId, silent));
                         }
                         else {
-                            timer = setTimeout(check, Math.min(30_000, timeoutMs - silent + 1000));
+                            const gap = lastContent != null ? Date.now() - lastContent : 0;
+                            const untilNoContent = lastContent != null ? Math.max(250, NO_CONTENT_TIMEOUT_MS - gap + 50) : Number.POSITIVE_INFINITY;
+                            timer = setTimeout(check, Math.min(30_000, timeoutMs - silent + 1000, 5_000, untilNoContent));
                         }
                     };
-                    timer = setTimeout(check, timeoutMs);
+                    timer = setTimeout(check, Math.min(5_000, timeoutMs));
                 });
                 host.activeQueries.add(agentQuery);
                 // Guard: if pause was triggered between runAgent check and here, close the query
@@ -403,7 +413,7 @@ Respond with JSON: {"keep": true/false, "reason": "brief explanation"}`;
         const rl = sdkQueryRateLimiter;
         let eq;
         try {
-            await rl.waitIfNeeded();
+            await acquireSdkQueryRateLimit();
             eq = query({
                 prompt,
                 options: {

package/dist/swarm/config.d.ts

@@ -29,3 +29,10 @@ export declare const SIMPLIFY_PROMPT = "You just finished your task. Review and
  * all worktree paths) so the header value passes the safety check.
  */
 export declare function withCursorWorkspaceHeader(env: Record<string, string> | undefined, cwd: string): Record<string, string> | undefined;
+/** Default per-agent inactivity watchdog (see `agent-run` race with SDK `query`). */
+export declare const DEFAULT_AGENT_TIMEOUT_MS: number;
+/**
+ * Per-agent watchdog timeout in ms. Override with `AGENT_TIMEOUT_MS` (integer).
+ * Explicit `SwarmConfig.agentTimeoutMs` still wins at call sites that pass it.
+ */
+export declare function getAgentTimeout(): number;

package/dist/swarm/config.js

@@ -33,3 +33,18 @@ export function withCursorWorkspaceHeader(env, cwd) {
             : hdr,
     };
 }
+/** Default per-agent inactivity watchdog (see `agent-run` race with SDK `query`). */
+export const DEFAULT_AGENT_TIMEOUT_MS = 15 * 60 * 1000;
+/**
+ * Per-agent watchdog timeout in ms. Override with `AGENT_TIMEOUT_MS` (integer).
+ * Explicit `SwarmConfig.agentTimeoutMs` still wins at call sites that pass it.
+ */
+export function getAgentTimeout() {
+    const raw = process.env.AGENT_TIMEOUT_MS;
+    if (raw == null || raw.trim() === "")
+        return DEFAULT_AGENT_TIMEOUT_MS;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return DEFAULT_AGENT_TIMEOUT_MS;
+    return n;
+}

package/dist/swarm/errors.d.ts

@@ -1,6 +1,13 @@
 export declare class AgentTimeoutError extends Error {
     constructor(silentMs: number);
 }
+/** Thrown when the SDK query stream stops emitting assistant content for too long while still open. */
+export declare class StreamStalledError extends Error {
+    readonly elapsed: number;
+    readonly timeoutMs: number;
+    constructor(elapsed: number, timeoutMs: number);
+}
+export declare function isStreamStalledError(err: unknown): err is StreamStalledError;
 export declare function isRateLimitError(err: unknown): boolean;
 export declare function isTransientError(err: unknown): boolean;
 export declare function sleep(ms: number): Promise<void>;

package/dist/swarm/errors.js

@@ -7,6 +7,20 @@ export class AgentTimeoutError extends Error {
         this.name = "AgentTimeoutError";
     }
 }
+/** Thrown when the SDK query stream stops emitting assistant content for too long while still open. */
+export class StreamStalledError extends Error {
+    elapsed;
+    timeoutMs;
+    constructor(elapsed, timeoutMs) {
+        super(`Stream stalled: no content for ${timeoutMs}ms (last gap ${Math.round(elapsed)}ms)`);
+        this.elapsed = elapsed;
+        this.timeoutMs = timeoutMs;
+        this.name = "StreamStalledError";
+    }
+}
+export function isStreamStalledError(err) {
+    return err instanceof StreamStalledError;
+}
 export function isRateLimitError(err) {
     const status = err?.status ?? err?.statusCode;
     if (status === 429)
@@ -20,7 +34,7 @@ export function isRateLimitError(err) {
     return false;
 }
 export function isTransientError(err) {
-    if (err instanceof AgentTimeoutError)
+    if (err instanceof AgentTimeoutError || err instanceof StreamStalledError)
         return false;
     const msg = String(err?.message || err).toLowerCase();
     const status = err?.status ?? err?.statusCode;

package/dist/swarm/message-handler.d.ts

@@ -1,5 +1,9 @@
 import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { AgentState, AITurn, RateLimitWindow } from "../core/types.js";
+/** Default: no assistant content for this long means the SDK stream is stuck. */
+export declare const NO_CONTENT_TIMEOUT_MS = 15000;
+/** @returns false if no stream content has arrived within {@link timeoutMs} of {@link lastContentTimestamp}. */
+export declare function checkStreamHealth(lastContentTimestamp: number, timeoutMs: number): boolean;
 /** Per-agent pending tool_use block while we wait for the delta stream to
  *  finish materializing the real `input`. */
 export interface PendingTool {

package/dist/swarm/message-handler.js

@@ -11,6 +11,15 @@
 import { RATE_LIMIT_WINDOW_SHORT, extractToolTarget, sumUsageTokens } from "../core/types.js";
 import { getModelCapability } from "../core/models.js";
 import { updateTurn } from "../core/turns.js";
+/** Default: no assistant content for this long means the SDK stream is stuck. */
+export const NO_CONTENT_TIMEOUT_MS = 15_000;
+/** @returns false if no stream content has arrived within {@link timeoutMs} of {@link lastContentTimestamp}. */
+export function checkStreamHealth(lastContentTimestamp, timeoutMs) {
+    return Date.now() - lastContentTimestamp <= timeoutMs;
+}
+function markStreamContent(agent) {
+    agent.lastContentTimestamp = Date.now();
+}
 /** Log a tool invocation with a short target extracted from its input. */
 export function logToolUse(host, agent, name, input) {
     const target = extractToolTarget(input);
@@ -49,6 +58,10 @@ export function handleMsg(host, agent, msg) {
             if (!m.message?.content)
                 break;
             for (const block of m.message.content) {
+                const bt = block.type;
+                if (bt === "text" || bt === "tool_use" || bt === "thinking" || bt === "redacted_thinking") {
+                    markStreamContent(agent);
+                }
                 if (block.type === "text" && block.text) {
                     const line = block.text.trim().split("\n")[0]?.slice(0, 80);
                     if (line)
@@ -63,6 +76,7 @@ export function handleMsg(host, agent, msg) {
             if (ev.type === "content_block_start") {
                 const cb = ev.content_block;
                 if (cb?.type === "tool_use") {
+                    markStreamContent(agent);
                     agent.currentTool = cb.name;
                     agent.toolCalls++;
                     const input = (cb.input ?? {});
@@ -72,13 +86,18 @@ export function handleMsg(host, agent, msg) {
                         logToolUse(host, agent, cb.name, input);
                 }
                 else if (cb?.type === "thinking" || cb?.type === "redacted_thinking") {
+                    markStreamContent(agent);
                     agent.lastText = "thinking…";
                 }
+                else if (cb?.type === "text") {
+                    markStreamContent(agent);
+                }
             }
             else if (ev.type === "content_block_delta") {
                 const delta = ev.delta;
                 const pending = host.pendingTools.get(agent);
                 if (delta?.type === "input_json_delta" && pending && typeof delta.partial_json === "string") {
+                    markStreamContent(agent);
                     pending.buf += delta.partial_json;
                     break;
                 }
@@ -87,6 +106,7 @@ export function handleMsg(host, agent, msg) {
                     : delta?.type === "thinking_delta" ? delta.thinking
                         : undefined;
                 if (typeof raw === "string") {
+                    markStreamContent(agent);
                     const t = raw.trim();
                     if (t)
                         agent.lastText = t.slice(-80);

package/dist/swarm/swarm.js

@@ -5,6 +5,7 @@ import chalk from "chalk";
 import { RATE_LIMIT_WINDOW_SHORT } from "../core/types.js";
 import { gitExec, mergeAllBranches, warnDirtyTree, cleanStaleWorktrees, writeSwarmLog } from "./merge.js";
 import { ensureCursorProxyRunning, PROXY_DEFAULT_URL } from "../providers/index.js";
+import { getAgentTimeout } from "./config.js";
 import { sleep } from "./errors.js";
 import { runAgent as runAgentImpl, buildErroredBranchEvaluator } from "./agent-run.js";
 export class Swarm {
@@ -315,6 +316,8 @@ export class Swarm {
                 const task = this.queue.shift();
                 if (!task)
                     break;
+                const watchdogMs = this.config.agentTimeoutMs ?? getAgentTimeout();
+                this.log(-1, `[swarm] Agent watchdog timeout: ${Math.round(watchdogMs / 1000)}s`);
                 try {
                     await this.runAgent(task);
                 }

package/dist/ui/footer.js

@@ -27,8 +27,10 @@ function layoutActions(rendered, pendingChip, termW) {
 }
 export function Footer({ state, toast }) {
     const inOverlay = state.input.mode;
+    // When an input overlay is active the InputPrompt box renders its own hint
+    // line, so the footer stays quiet — just a spacer to keep the layout stable.
     if (inOverlay !== "none") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsx(Text, { children: chalk.dim("  Enter submit \u00b7 Esc cancel") })] }));
+        return _jsx(Text, { children: " " });
     }
     const actions = deriveFooter(state);
     const pending = state.runInfo.pendingSteer ?? 0;

package/dist/ui/header.js

@@ -1,9 +1,18 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text, Box } from "ink";
 import chalk from "chalk";
-import { fmtDur, fmtTokens } from "./primitives.js";
+import { fmtDur, fmtTokens, visibleLen } from "./primitives.js";
 import { UsageBars, SteeringBars } from "./bars.js";
-const HEADER_BAR_W = 30;
+function terminalWidth() { return Math.max((process.stdout.columns ?? 80) || 80, 60); }
+// Scales with terminal width so narrow panes get a short bar and wide ones
+// don't waste the right half of the screen.
+function headerBarWidth(termW) {
+    if (termW < 90)
+        return 16;
+    if (termW < 120)
+        return 24;
+    return 30;
+}
 function runPhaseLabel(swarm) {
     const allDone = swarm.agents.length > 0 && swarm.agents.every(a => a.status !== "running");
     const doneTag = allDone && !swarm.aborted ? chalk.green("COMPLETE") : "";
@@ -16,6 +25,9 @@ function runPhaseLabel(swarm) {
     return [phaseLabel, doneTag, pausedTag, stallTag, stoppingTag].filter(Boolean).join(" ");
 }
 export function Header({ phase, runInfo, swarm, rlGetter, selectedAgentId }) {
+    const termW = terminalWidth();
+    const barW = headerBarWidth(termW);
+    const narrow = termW < 90;
     const model = runInfo.model ?? swarm?.model;
     const modelTag = model ? chalk.dim(` [${model}]`) : "";
     let phaseTag = "";
@@ -42,24 +54,38 @@ export function Header({ phase, runInfo, swarm, rlGetter, selectedAgentId }) {
         barPct = runInfo.sessionsBudget > 0 ? sessionsUsed / runInfo.sessionsBudget : 0;
         barLabel = `${sessionsUsed}/${runInfo.sessionsBudget}`;
     }
-    const filled = Math.round(barPct * HEADER_BAR_W);
-    const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(HEADER_BAR_W - filled));
+    const filled = Math.round(barPct * barW);
+    const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(barW - filled));
     const working = Math.max(0, active - blocked);
     const stuck = blocked > 0 && working === 0;
     const activeChip = active > 0
         ? (stuck ? chalk.yellow(`${active} blocked`) : chalk.cyan(`${working} active`) + (blocked > 0 ? chalk.yellow(` (${blocked} blocked)`) : ""))
         : "";
-    const topLine = `  ${chalk.bold.white("CLAUDE OVERNIGHT")}${modelTag}${phaseTag ? " " + phaseTag : ""}  ${bar}  ${barLabel}  ` +
-        (activeChip ? activeChip + "  " : "") +
-        (queued > 0 ? chalk.gray(`${queued} queued`) + "  " : "") +
-        chalk.gray(`\u23F1 ${fmtDur(Date.now() - runInfo.startedAt)}`);
+    const elapsed = chalk.gray(`\u23F1 ${fmtDur(Date.now() - runInfo.startedAt)}`);
+    const queuedChip = queued > 0 ? chalk.gray(`${queued} queued`) : "";
+    // Top line: brand · phase · bar · counters · elapsed. Narrow terminals drop
+    // the brand and model so the live indicators stay on one row.
+    const brand = narrow ? "" : chalk.bold.white("CLAUDE OVERNIGHT") + modelTag;
+    const progress = barLabel ? bar + "  " + barLabel : bar;
+    const topParts = [
+        brand,
+        phaseTag,
+        progress,
+        activeChip,
+        queuedChip,
+        elapsed,
+    ].filter(Boolean);
+    const topLine = "  " + topParts.join("  ");
     const tokIn = fmtTokens(totalIn);
     const tokOut = fmtTokens(totalOut);
     const costStr = totalCost > 0 ? chalk.yellow(`$${totalCost.toFixed(2)}`) : "";
-    const waveLabel = runInfo.waveNum >= 0 ? `wave ${runInfo.waveNum + 1} \u00b7 ` : "";
-    const sessionStr = chalk.dim(`  ${waveLabel}`) +
-        chalk.white(`${sessionsUsed}/${runInfo.sessionsBudget}`) +
+    const waveLabel = runInfo.waveNum >= 0 ? `wave ${runInfo.waveNum + 1}` : "";
+    const tokens = chalk.gray(`\u2191 ${tokIn} in  \u2193 ${tokOut} out`);
+    const sessions = chalk.white(`${sessionsUsed}/${runInfo.sessionsBudget}`) +
         chalk.dim(` sessions \u00b7 ${runInfo.remaining} left`);
-    const bottomLine = chalk.gray(`  \u2191 ${tokIn} in  \u2193 ${tokOut} out`) + (costStr ? `  ${costStr}` : "") + sessionStr;
+    const bottomLeftParts = [tokens, costStr].filter(Boolean).join("  ");
+    const bottomRightParts = [waveLabel ? chalk.dim(waveLabel) : "", sessions].filter(Boolean).join(chalk.dim(" \u00b7 "));
+    const gap = Math.max(2, termW - visibleLen(bottomLeftParts) - visibleLen(bottomRightParts) - 4);
+    const bottomLine = "  " + bottomLeftParts + " ".repeat(gap) + bottomRightParts;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsx(Text, { children: topLine }), _jsx(Text, { children: bottomLine }), phase === "run" && swarm ? _jsx(UsageBars, { swarm: swarm, selectedAgentId: selectedAgentId }) : null, phase === "steering" && rlGetter ? _jsx(SteeringBars, { rl: rlGetter() }) : null, _jsx(Text, { children: " " })] }));
 }

package/dist/ui/input.d.ts

@@ -1,6 +1,13 @@
 import React from "react";
 import type { UiStore, HostCallbacks } from "./store.js";
 export declare const MAX_INPUT_LEN = 600;
+export declare const CONTROL_CHAR_RE: RegExp;
+/** Strip control characters from typed raw input so escape flushes, newlines,
+ *  and C1 bytes never end up in the user's buffer. Exported for tests. */
+export declare function sanitizeTyped(raw: string): string;
+/** Delete the previous word including any trailing whitespace, readline-style.
+ *  Bound to Ctrl+W and Opt/Cmd+Backspace. Exported for tests. */
+export declare function deleteWordBackward(s: string): string;
 interface Props {
     store: UiStore;
     callbacks: HostCallbacks;

package/dist/ui/input.js

@@ -9,11 +9,34 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Text-entry overlays (steer, ask, settings) are *not* separate phases — they
 // capture typed chars, show a minimal hint in the footer (handled by
 // footer.tsx), and dispatch on Enter/Esc.
+//
+// Text-entry input hygiene: terminals send a zoo of escape/control sequences
+// for navigation keys (arrows, cmd+arrow → ctrl+a/e on macOS, option+letter,
+// pageup/pgdn, home/end, lone ESC flushes). We explicitly swallow all of them
+// instead of letting them fall through to the "typed char" branch, which used
+// to corrupt the buffer or dismiss the overlay and discard unfinished text.
 import { useState, useSyncExternalStore } from "react";
 import { Text, Box, useInput } from "ink";
 import chalk from "chalk";
+import { visibleLen, wrap } from "./primitives.js";
 import { SETTINGS_FIELDS, SETTINGS_LABELS, NUMERIC_SETTINGS_FIELDS, applySettingEdit, readSettingValue, } from "./settings.js";
 export const MAX_INPUT_LEN = 600;
+// Any printable char is kept verbatim; everything else is filtered out before
+// touching the buffer. Matches: ASCII C0 controls (0x00-0x1F), DEL (0x7F), C1
+// controls (0x80-0x9F), and lone ESC (already handled by `key.escape`).
+export const CONTROL_CHAR_RE = /[\x00-\x1f\x7f-\x9f]/g;
+/** Strip control characters from typed raw input so escape flushes, newlines,
+ *  and C1 bytes never end up in the user's buffer. Exported for tests. */
+export function sanitizeTyped(raw) {
+    return raw.replace(CONTROL_CHAR_RE, "");
+}
+/** Delete the previous word including any trailing whitespace, readline-style.
+ *  Bound to Ctrl+W and Opt/Cmd+Backspace. Exported for tests. */
+export function deleteWordBackward(s) {
+    const trimmed = s.replace(/\s+$/, "");
+    const idx = trimmed.search(/\S+$/);
+    return idx < 0 ? "" : trimmed.slice(0, idx);
+}
 export function InputLayer({ store, callbacks, onToast }) {
     const [buffer, setBuffer] = useState("");
     const [settingsField, setSettingsField] = useState(0);
@@ -24,7 +47,14 @@ export function InputLayer({ store, callbacks, onToast }) {
         const lc = state.liveConfig;
         // ── Text-entry modes ──
         if (mode !== "none") {
-            // Esc bails
+            // Navigation keys must NEVER touch the buffer or dismiss the overlay.
+            // (Bug: cmd+arrow on macOS Terminal sends ctrl+a/ctrl+e which used to
+            // leak through and append "a"/"e"; arrows on some terminals flushed
+            // partial ESC sequences that dropped the user's unfinished text.)
+            if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow ||
+                key.pageUp || key.pageDown || key.home || key.end)
+                return;
+            // Esc bails (loses the buffer — always intentional).
             if (key.escape) {
                 setBuffer("");
                 setSettingsField(0);
@@ -59,25 +89,53 @@ export function InputLayer({ store, callbacks, onToast }) {
                 store.patch({ input: { mode: "none", buffer: "", settingsField: 0 } });
                 return;
             }
-            if (key.tab && mode === "settings") {
-                const field = SETTINGS_FIELDS[settingsField % SETTINGS_FIELDS.length];
-                if (field === "pause" && swarm && lc) {
-                    const next = !swarm.paused;
-                    swarm.setPaused(next);
-                    lc.paused = next;
-                    lc.dirty = true;
-                    callbacks.settingsTick();
+            // Word-delete: option/alt + backspace — expected on macOS.
+            if ((key.meta || key.ctrl) && (key.backspace || key.delete)) {
+                const next = deleteWordBackward(buffer);
+                setBuffer(next);
+                store.patch({ input: { ...state.input, buffer: next } });
+                return;
+            }
+            // Swallow modifier combos so they can't leak as stray letters.
+            // (cmd+→ on macOS Terminal = \x05 = ctrl+e → input handler sees raw='e';
+            // without this guard we used to append 'e'.)
+            if (key.ctrl || key.meta) {
+                if (mode !== "settings" && key.ctrl && raw === "u") {
+                    // ctrl+U: clear the whole line — standard readline behavior.
+                    setBuffer("");
+                    store.patch({ input: { ...state.input, buffer: "" } });
+                    return;
                 }
-                const next = settingsField + 1;
-                setBuffer("");
-                if (next >= SETTINGS_FIELDS.length) {
-                    setSettingsField(0);
-                    store.patch({ input: { mode: "none", buffer: "", settingsField: 0 } });
+                if (key.ctrl && raw === "w") {
+                    const next = deleteWordBackward(buffer);
+                    setBuffer(next);
+                    store.patch({ input: { ...state.input, buffer: next } });
+                    return;
                 }
-                else {
-                    setSettingsField(next);
-                    store.patch({ input: { mode: "settings", buffer: "", settingsField: next } });
+                return;
+            }
+            if (key.tab) {
+                if (mode === "settings") {
+                    const field = SETTINGS_FIELDS[settingsField % SETTINGS_FIELDS.length];
+                    if (field === "pause" && swarm && lc) {
+                        const next = !swarm.paused;
+                        swarm.setPaused(next);
+                        lc.paused = next;
+                        lc.dirty = true;
+                        callbacks.settingsTick();
+                    }
+                    const next = settingsField + 1;
+                    setBuffer("");
+                    if (next >= SETTINGS_FIELDS.length) {
+                        setSettingsField(0);
+                        store.patch({ input: { mode: "none", buffer: "", settingsField: 0 } });
+                    }
+                    else {
+                        setSettingsField(next);
+                        store.patch({ input: { mode: "settings", buffer: "", settingsField: next } });
+                    }
                 }
+                // Tab in steer/ask modes is a no-op, not a submit or a "tab character".
                 return;
             }
             if (key.backspace || key.delete) {
@@ -86,9 +144,11 @@ export function InputLayer({ store, callbacks, onToast }) {
                 store.patch({ input: { ...state.input, buffer: next } });
                 return;
             }
-            // Typed char(s) — raw is the string for this event
+            // Typed printable char(s) — raw is the string for this event. Strip any
+            // control chars (lone ESC flushes, \n linefeeds parseKeypress labels as
+            // 'enter', partial ESC [ sequences) before touching the buffer.
             if (raw && raw.length > 0) {
-                let text = raw;
+                let text = sanitizeTyped(raw);
                 if (mode === "settings") {
                     const field = SETTINGS_FIELDS[settingsField % SETTINGS_FIELDS.length];
                     if (NUMERIC_SETTINGS_FIELDS.has(field))
@@ -149,6 +209,10 @@ export function InputLayer({ store, callbacks, onToast }) {
         const code = raw.charCodeAt(0);
         if (code < 0x20 || code > 0x7E)
             return;
+        // Any ctrl/meta combo (that isn't one of the specific hotkeys above) is
+        // nav-adjacent on most terminals; ignore instead of matching "c"/"i" etc.
+        if (key.ctrl || key.meta)
+            return;
         const toast = (msg) => onToast(msg);
         switch (raw.toLowerCase()) {
             case "?":
@@ -225,22 +289,58 @@ export function InputLayer({ store, callbacks, onToast }) {
     const state = useSyncExternalStore(store.subscribe, store.get, store.get);
     if (state.input.mode === "none")
         return null;
-    // Caret pulses with the 1 Hz tick — visible on even ticks, hidden on odd.
-    const caret = state.tick % 2 === 0 ? chalk.cyan("\u2588") : " ";
-    return _jsx(InputPrompt, { mode: state.input.mode, buffer: buffer, settingsField: settingsField, state: state, caret: caret });
+    const caretOn = state.tick % 2 === 0;
+    return (_jsx(InputPrompt, { mode: state.input.mode, buffer: buffer, settingsField: settingsField, state: state, caretOn: caretOn }));
 }
-function InputPrompt({ mode, buffer, settingsField, state, caret, }) {
+function terminalWidth() { return Math.max((process.stdout.columns ?? 80) || 80, 60); }
+function InputPrompt({ mode, buffer, settingsField, state, caretOn }) {
+    const termW = terminalWidth();
+    const boxW = Math.min(Math.max(44, termW - 6), 120);
+    const innerW = boxW - 6;
+    const accent = mode === "settings" ? chalk.yellow : mode === "steer" ? chalk.cyan : chalk.magenta;
+    const borderColor = mode === "settings" ? "yellow" : mode === "steer" ? "cyan" : "magenta";
+    const title = mode === "steer" ? "Steer next wave"
+        : mode === "ask" ? "Ask the planner"
+            : "Settings";
+    let subtitle;
+    let hint;
+    let currentLine = null;
+    let filteredBuffer = buffer;
     if (mode === "settings") {
         const total = SETTINGS_FIELDS.length;
         const field = SETTINGS_FIELDS[settingsField % total];
-        const label = SETTINGS_LABELS[field];
+        subtitle = SETTINGS_LABELS[field];
         const current = readSettingValue(field, state.liveConfig, state.swarm);
-        const hint = field === "pause"
-            ? chalk.dim(` (Enter toggle, Tab skip, Esc exit)`)
-            : chalk.dim(` [${settingsField + 1}/${total}]  Tab next \u00b7 Esc exit \u00b7 current: ${chalk.white(current)}`);
-        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["  ", chalk.cyan("\u25C6"), " ", chalk.bold(label), hint] }), _jsxs(Text, { children: ["  ", buffer, caret] })] }));
+        currentLine = chalk.dim(`current: ${chalk.white(current)}`);
+        hint = field === "pause"
+            ? chalk.dim(`Enter toggle \u00b7 Tab skip \u00b7 Esc exit`)
+            : chalk.dim(`[${settingsField + 1}/${total}]  Enter save \u00b7 Tab skip \u00b7 Esc exit`);
+    }
+    else {
+        subtitle = mode === "steer"
+            ? "queued as the next wave's seed"
+            : "planner answers inline — you keep working";
+        const action = mode === "steer" ? "queue" : "send";
+        hint = chalk.dim(`Enter ${action} \u00b7 Esc cancel \u00b7 Ctrl+U clear \u00b7 Ctrl+W del word`);
     }
-    const title = mode === "steer" ? "Inject next wave" : "Ask the planner";
-    const action = mode === "steer" ? "queue" : "send";
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["  ", chalk.cyan(">"), " ", chalk.bold(title), " ", chalk.dim(`(Enter to ${action}, Esc to cancel)`)] }), _jsxs(Text, { children: ["  ", buffer, caret] })] }));
+    // Word-wrap the buffer so long entries don't blow past the box edge.
+    const bufferLines = filteredBuffer.length === 0
+        ? [""]
+        : wrap(filteredBuffer, Math.max(20, innerW));
+    const caret = caretOn ? accent("\u2588") : " ";
+    const lastIdx = bufferLines.length - 1;
+    // Char counter — dims normally, warns at 80%, red at 95%.
+    const pct = buffer.length / MAX_INPUT_LEN;
+    const counter = buffer.length === 0 ? "" :
+        pct >= 0.95 ? chalk.red(`${buffer.length}/${MAX_INPUT_LEN}`)
+            : pct >= 0.8 ? chalk.yellow(`${buffer.length}/${MAX_INPUT_LEN}`)
+                : chalk.dim(`${buffer.length}/${MAX_INPUT_LEN}`);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, borderStyle: "round", borderColor: borderColor, width: boxW, children: [_jsxs(Text, { children: [" ", accent("\u25C6"), " ", chalk.bold.white(title), "  ", chalk.dim(subtitle)] }), currentLine ? _jsxs(Text, { children: [" ", currentLine] }) : null, bufferLines.map((ln, i) => {
+                const showCaret = i === lastIdx;
+                const pad = Math.max(0, innerW - visibleLen(ln));
+                const counterSuffix = showCaret && counter
+                    ? "  " + counter
+                    : "";
+                return (_jsxs(Text, { children: [" ", accent("\u203A "), ln, showCaret ? caret : " ", " ".repeat(pad), counterSuffix] }, i));
+            }), _jsxs(Text, { children: [" ", hint] })] }));
 }

package/dist/ui/overlay.js

@@ -3,40 +3,52 @@ import { Text, Box } from "ink";
 import chalk from "chalk";
 import { wrap } from "./primitives.js";
 function terminalWidth() { return Math.max((process.stdout.columns ?? 80) || 80, 60); }
+const ASK_BODY_LINES = 8;
+const DEBRIEF_BODY_LINES = 6;
 export function Overlay({ ask, debrief }) {
     if (!ask && !debrief)
         return null;
     const w = terminalWidth();
-    const maxW = Math.min(Math.max(40, w - 6), 120);
+    const boxW = Math.min(Math.max(44, w - 6), 120);
+    const innerW = boxW - 4;
     if (ask) {
-        const title = ask.streaming ? chalk.cyan("Ask (streaming\u2026)") : ask.error ? chalk.red("Ask (error)") : chalk.bold.white("Ask");
-        const qLines = wrap(ask.question, maxW - 6);
+        const title = ask.streaming ? chalk.cyan("Ask") + chalk.dim(" (streaming\u2026)")
+            : ask.error ? chalk.red("Ask") + chalk.dim(" (error)")
+                : chalk.bold.white("Ask");
+        const qLines = wrap(ask.question, innerW - 4);
         const bodyLines = [];
+        let hiddenExtra = 0;
         if (ask.error) {
-            for (const wl of wrap(`Error: ${ask.error}`, maxW - 4))
+            for (const wl of wrap(`Error: ${ask.error}`, innerW - 2))
                 bodyLines.push(chalk.red(wl));
         }
         else if (ask.answer) {
-            for (const ln of ask.answer.split("\n").slice(0, 8)) {
-                for (const wl of wrap(ln, maxW - 4))
+            const rawLines = ask.answer.split("\n");
+            const visible = rawLines.slice(0, ASK_BODY_LINES);
+            hiddenExtra = Math.max(0, rawLines.length - visible.length);
+            for (const ln of visible) {
+                for (const wl of wrap(ln, innerW - 2))
                     bodyLines.push(wl);
             }
         }
         else if (ask.streaming) {
             bodyLines.push(chalk.dim("\u2026"));
         }
-        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, borderStyle: "round", borderColor: "cyan", width: maxW, children: [_jsxs(Text, { children: [" ", title] }), qLines.map((ql, i) => (_jsxs(Text, { children: [" ", i === 0 ? chalk.dim("Q:") + " " : "   ", ql] }, `q${i}`))), bodyLines.map((l, i) => _jsxs(Text, { children: [" ", l] }, i))] }));
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, borderStyle: "round", borderColor: "cyan", width: boxW, children: [_jsxs(Text, { children: [" ", title] }), qLines.map((ql, i) => (_jsxs(Text, { children: [" ", i === 0 ? chalk.dim("Q:") + " " : "   ", ql] }, `q${i}`))), bodyLines.map((l, i) => _jsxs(Text, { children: [" ", l] }, i)), hiddenExtra > 0 ? _jsxs(Text, { children: [" ", chalk.dim(`\u2026 + ${hiddenExtra} more line${hiddenExtra === 1 ? "" : "s"} \u00b7 press Enter to open`)] }) : null] }));
     }
     if (debrief) {
         const title = debrief.label
             ? `${chalk.bold.white("Debrief")} ${chalk.dim("\u00b7")} ${chalk.white(debrief.label)}`
             : chalk.bold.white("Debrief");
         const lines = [];
-        for (const ln of debrief.text.split("\n").slice(0, 6)) {
-            for (const wl of wrap(ln, maxW - 4))
+        const rawLines = debrief.text.split("\n");
+        const visible = rawLines.slice(0, DEBRIEF_BODY_LINES);
+        const hiddenExtra = Math.max(0, rawLines.length - visible.length);
+        for (const ln of visible) {
+            for (const wl of wrap(ln, innerW - 2))
                 lines.push(wl);
         }
-        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, borderStyle: "round", borderColor: "green", width: maxW, children: [_jsxs(Text, { children: [" ", title] }), lines.map((l, i) => _jsxs(Text, { children: [" ", l] }, i))] }));
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, borderStyle: "round", borderColor: "green", width: boxW, children: [_jsxs(Text, { children: [" ", title] }), lines.map((l, i) => _jsxs(Text, { children: [" ", l] }, i)), hiddenExtra > 0 ? _jsxs(Text, { children: [" ", chalk.dim(`\u2026 + ${hiddenExtra} more line${hiddenExtra === 1 ? "" : "s"}`)] }) : null] }));
     }
     return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.45",
+  "version": "1.25.46",
   "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": {

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

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.45",
+  "version": "1.25.46",
   "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"