claude-overnight 1.59.0 → 1.60.1

package/dist/bin/evolve-subcommands.d.ts

@@ -0,0 +1,3 @@
+export declare function runDiff(runIdA: string | undefined, runIdB: string | undefined): Promise<void>;
+export declare function runDownload(runIdArg?: string, ...rest: string[]): Promise<void>;
+export declare function runPromote(runIdArg?: string, ...rest: string[]): Promise<void>;

package/dist/bin/evolve-subcommands.js

@@ -0,0 +1,252 @@
+export async function runDiff(runIdA, runIdB) {
+    if (!runIdA || !runIdB) {
+        console.error("usage: claude-overnight-evolve diff <runIdA> <runIdB>");
+        process.exit(2);
+    }
+    const { loadRun } = await import("../prompt-evolution/persistence.js");
+    const a = loadRun(runIdA);
+    const b = loadRun(runIdB);
+    const collect = (run) => {
+        const out = new Map();
+        for (const rec of run.matrix) {
+            // Keep the latest-generation row per variantId so diff compares final state.
+            const existing = out.get(rec.variantId);
+            if (!existing || rec.generation > existing.generation) {
+                out.set(rec.variantId, { generation: rec.generation, variantId: rec.variantId, gmean: rec.gmean });
+            }
+        }
+        return out;
+    };
+    const rowsA = collect(a);
+    const rowsB = collect(b);
+    const ids = new Set([...rowsA.keys(), ...rowsB.keys()]);
+    console.log(`# Diff: ${runIdA} → ${runIdB}`);
+    console.log("");
+    console.log(`|  Variant  |  A gmean  |  B gmean  |   Δ   |  note  |`);
+    console.log(`|-----------|-----------|-----------|-------|--------|`);
+    const sorted = [...ids].sort();
+    for (const id of sorted) {
+        const ra = rowsA.get(id);
+        const rb = rowsB.get(id);
+        const ga = ra ? (ra.gmean * 100).toFixed(1) : "—";
+        const gb = rb ? (rb.gmean * 100).toFixed(1) : "—";
+        const delta = ra && rb ? ((rb.gmean - ra.gmean) * 100).toFixed(1) : "—";
+        const note = !ra ? "new in B" : !rb ? "missing in B" : ra.gmean < rb.gmean ? "↑" : ra.gmean > rb.gmean ? "↓" : "=";
+        console.log(`| ${id.padEnd(10)}| ${ga.padStart(9)} | ${gb.padStart(9)} | ${delta.padStart(5)} | ${note} |`);
+    }
+}
+export async function runDownload(runIdArg, ...rest) {
+    if (!runIdArg) {
+        console.error("usage: claude-overnight-evolve download <runId> --base-url <url> [--token <token>] [--project <id>]");
+        process.exit(2);
+    }
+    const runId = runIdArg;
+    let baseUrl;
+    let token;
+    let projectId;
+    let watch = false;
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--base-url" && rest[i + 1]) {
+            baseUrl = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--token" && rest[i + 1]) {
+            token = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--project" && rest[i + 1]) {
+            projectId = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--watch") {
+            watch = true;
+        }
+    }
+    if (!baseUrl) {
+        console.error("--base-url is required (e.g. https://fornace.net or http://localhost:8787)");
+        process.exit(2);
+    }
+    const authHeaders = {};
+    if (token)
+        authHeaders.Authorization = `Bearer ${token}`;
+    const prefix = projectId
+        ? `${baseUrl.replace(/\/$/, "")}/api/projects/${projectId}/prompt-evolution/${runId}`
+        : `${baseUrl.replace(/\/$/, "")}/runs/${runId}`;
+    let remoteMeta = null;
+    let metaBody = null;
+    while (true) {
+        const metaRes = await fetch(prefix, { headers: authHeaders });
+        if (!metaRes.ok) {
+            console.error(`Failed to fetch run metadata: HTTP ${metaRes.status}`);
+            process.exit(1);
+        }
+        metaBody = (await metaRes.json());
+        remoteMeta = typeof metaBody.meta === "object" && metaBody.meta
+            ? metaBody.meta
+            : metaBody;
+        const status = remoteMeta.status;
+        if (watch && (status === "running" || status === "queued" || status === "pending" || !status)) {
+            process.stdout.write(`\r[${new Date().toLocaleTimeString()}] Run ${runId} is ${status || "running"}... waiting... `);
+            await new Promise(r => setTimeout(r, 10000));
+        }
+        else {
+            if (watch)
+                console.log(`\nRun finished with status: ${status}`);
+            break;
+        }
+    }
+    const { runDir } = await import("../prompt-evolution/persistence.js");
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    const { dirname, join } = await import("node:path");
+    const localDir = runDir(runId);
+    mkdirSync(localDir, { recursive: true });
+    mkdirSync(join(localDir, "prompts"), { recursive: true });
+    const meta = {
+        runId,
+        promptPath: (remoteMeta.promptPath ?? remoteMeta.prompt ?? ""),
+        target: (remoteMeta.target ?? "claude-overnight"),
+        evalModel: (remoteMeta.evalModel ?? ""),
+        mutateModel: (remoteMeta.mutateModel ?? remoteMeta.evalModel ?? ""),
+        generations: (remoteMeta.generations ?? 10),
+        populationCap: (remoteMeta.populationCap ?? remoteMeta.population ?? 8),
+        startedAt: (remoteMeta.startedAt ?? remoteMeta.queuedAt ?? new Date().toISOString()),
+        status: (remoteMeta.status ?? "done"),
+        caseNames: [],
+    };
+    writeFileSync(join(localDir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+    const inlineReport = typeof metaBody.report === "string" ? metaBody.report : metaBody.report_md;
+    if (typeof inlineReport === "string") {
+        writeFileSync(join(localDir, "report.md"), inlineReport);
+        console.log("  ✓ report.md (inline)");
+    }
+    const listRes = await fetch(`${prefix}/files`, { headers: authHeaders });
+    let files = [];
+    if (listRes.ok) {
+        const listBody = (await listRes.json());
+        files = listBody.files ?? [];
+    }
+    else {
+        console.log(`  ⚠ File listing not available (HTTP ${listRes.status}); trying known files...`);
+        files = ["report.md", "best.md", "matrix.jsonl", "learning.jsonl"];
+    }
+    for (const file of files) {
+        const fileRes = await fetch(`${prefix}/files/${encodeURIComponent(file)}`, { headers: authHeaders });
+        if (!fileRes.ok) {
+            console.error(`  ⚠ ${file}: HTTP ${fileRes.status}`);
+            continue;
+        }
+        const data = Buffer.from(await fileRes.arrayBuffer());
+        const localPath = join(localDir, file);
+        mkdirSync(dirname(localPath), { recursive: true });
+        writeFileSync(localPath, data);
+        console.log(`  ✓ ${file}`);
+    }
+    const matrixPath = join(localDir, "matrix.jsonl");
+    const { existsSync, readFileSync } = await import("node:fs");
+    if (existsSync(matrixPath)) {
+        const variantIds = new Set();
+        for (const line of readFileSync(matrixPath, "utf-8").trim().split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const row = JSON.parse(line);
+                if (row.variantId)
+                    variantIds.add(row.variantId);
+            }
+            catch { /* ignore */ }
+        }
+        for (const vid of variantIds) {
+            const safeId = vid.replace(/[^a-zA-Z0-9_-]/g, "_");
+            const promptFile = `prompts/${safeId}.md`;
+            if (existsSync(join(localDir, promptFile)))
+                continue;
+            const fileRes = await fetch(`${prefix}/files/${encodeURIComponent(promptFile)}`, { headers: authHeaders });
+            if (!fileRes.ok)
+                continue;
+            const data = Buffer.from(await fileRes.arrayBuffer());
+            mkdirSync(dirname(join(localDir, promptFile)), { recursive: true });
+            writeFileSync(join(localDir, promptFile), data);
+            console.log(`  ✓ ${promptFile} (from matrix)`);
+        }
+    }
+    console.log(`\nDownloaded to ${localDir}`);
+}
+export async function runPromote(runIdArg, ...rest) {
+    if (!runIdArg) {
+        console.error("usage: claude-overnight-evolve promote <runId> [--variant <id>] [--into <block>]");
+        process.exit(2);
+    }
+    const runId = runIdArg;
+    let variantId;
+    let intoBlock;
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--variant" && rest[i + 1]) {
+            variantId = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--into" && rest[i + 1]) {
+            intoBlock = rest[i + 1];
+            i++;
+        }
+    }
+    const { loadRun, runDir } = await import("../prompt-evolution/persistence.js");
+    const { PROMPTS_ROOT } = await import("../prompts/load.js");
+    const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const run = loadRun(runId);
+    const promptPath = run.meta.promptPath;
+    let sourceVariant = variantId;
+    if (!sourceVariant) {
+        const bestMatch = run.bestMd.match(/variantId\s*\|\s*`([^`]+)`/);
+        sourceVariant = bestMatch ? bestMatch[1] : undefined;
+        if (!sourceVariant) {
+            const rows = run.matrix;
+            if (rows.length)
+                sourceVariant = [...rows].sort((a, b) => b.gmean - a.gmean)[0].variantId;
+        }
+    }
+    if (!sourceVariant) {
+        console.error("Could not determine best variant for run. Use --variant <id>.");
+        process.exit(2);
+    }
+    const safeId = sourceVariant.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const variantFile = join(runDir(runId), "prompts", `${safeId}.md`);
+    if (!existsSync(variantFile)) {
+        console.error(`Variant file not found: ${variantFile}`);
+        process.exit(2);
+    }
+    const variantText = readFileSync(variantFile, "utf-8").replace(/^<!--\s*generation=[\s\S]*?-->\n\n?/, "");
+    const namedVariants = ["tight", "standard", "large", "wrap", "amend", "wave", "run", "file", "all", "postfailed", "nofiles"];
+    const targetBlock = intoBlock ?? (namedVariants.includes(sourceVariant.toLowerCase()) ? sourceVariant : undefined);
+    if (!targetBlock) {
+        console.error(`Variant "${sourceVariant}" is not a named seed variant. Use --into <block> to specify which marker block to overwrite.`);
+        process.exit(2);
+    }
+    const promptFile = join(PROMPTS_ROOT, promptPath + ".md");
+    if (!existsSync(promptFile)) {
+        console.error(`Prompt file not found: ${promptFile}`);
+        process.exit(2);
+    }
+    const newText = replaceVariantBlock(readFileSync(promptFile, "utf-8"), targetBlock, variantText);
+    writeFileSync(promptFile, newText);
+    console.log(`Promoted ${sourceVariant} → ${promptPath} (<!-- ${targetBlock.toUpperCase()} -->)`);
+    console.log(`  file: ${promptFile}`);
+}
+function replaceVariantBlock(fileText, blockName, newText) {
+    const separator = "\n<!-- @@@ -->\n";
+    const sections = fileText.split(separator);
+    const markerRegex = new RegExp(`<!--\\s*(?:[─\\-]+\\s*)?${blockName.toUpperCase()}\\s*-->`, "i");
+    let found = false;
+    const newSections = sections.map((section) => {
+        const lines = section.split("\n");
+        const markerIndex = lines.findIndex((line) => markerRegex.test(line));
+        if (markerIndex === -1)
+            return section;
+        found = true;
+        const before = lines.slice(0, markerIndex + 1);
+        return [...before, "", newText.trim(), ""].join("\n").trimEnd() + "\n";
+    });
+    if (!found)
+        throw new Error(`Variant block "${blockName.toUpperCase()}" not found in prompt file`);
+    return newSections.join(separator);
+}

package/dist/bin/evolve.js

@@ -19,6 +19,7 @@ import { evolvePrompt } from "../prompt-evolution/index.js";
 import { PLAN_CASES } from "../prompt-evolution/fixtures/plan-cases.js";
 import { harvestRealCases } from "../prompt-evolution/fixtures/harvest.js";
 import { generateCases } from "../prompt-evolution/fixtures/generate.js";
+import { runDiff, runDownload, runPromote } from "./evolve-subcommands.js";
 import { scenariosToCases, PLANNING_SCENARIOS, REVIEW_SCENARIOS, SUPERVISION_SCENARIOS, STUCK_SCENARIOS, hydrateCases, extractPrompt, } from "../prompt-evolution/adapters/mcp-browser.js";
 function help() {
     process.stdout.write(`Usage: claude-overnight-evolve [options]
@@ -57,6 +58,19 @@ Options:
   --gen-model <model>     Model used by the case generator (default: eval-model)
 
 Subcommands:
+  claude-overnight-evolve download <runId> --base-url <url> [--token <token>]
+                          [--project <id>] [--watch]
+                          Pull a remote run (fornace or self-host) into the local
+                          ~/.claude-overnight/prompt-evolution/<runId>/ directory
+                          so you can audit, diff, or promote it offline. Use
+                          --project for fornace; omit for self-host. If --watch
+                          is set, it will poll until the run finishes before downloading.
+  claude-overnight-evolve promote <runId> [--variant <id>] [--into <block>]
+                          Write a run's winning variant back into the source
+                          prompt file's <!-- BLOCK --> marker. If --variant is
+                          omitted, uses the run's best variant. If the variant is
+                          a seed (tight/standard/large) --into defaults to its
+                          name; evo-* or default variants require --into.
   claude-overnight-evolve diff <runIdA> <runIdB>
                           Print a per-variant diff of two persisted runs
   --base-url <url>        API base URL override
@@ -208,6 +222,16 @@ function parseArgs() {
     return opts;
 }
 async function main() {
+    // Subcommand: download a remote run for local audit/promote.
+    if (process.argv[2] === "download") {
+        await runDownload(process.argv[3], ...process.argv.slice(4));
+        return;
+    }
+    // Subcommand: promote a run variant back into the source prompt file.
+    if (process.argv[2] === "promote") {
+        await runPromote(process.argv[3], ...process.argv.slice(4));
+        return;
+    }
     // Subcommand: diff two persisted runs.
     if (process.argv[2] === "diff") {
         await runDiff(process.argv[3], process.argv[4]);
@@ -357,43 +381,6 @@ async function evolveOne(opts) {
     console.log(result.bestVariant.text);
     return result;
 }
-async function runDiff(runIdA, runIdB) {
-    if (!runIdA || !runIdB) {
-        console.error("usage: claude-overnight-evolve diff <runIdA> <runIdB>");
-        process.exit(2);
-    }
-    const { loadRun } = await import("../prompt-evolution/persistence.js");
-    const a = loadRun(runIdA);
-    const b = loadRun(runIdB);
-    const collect = (run) => {
-        const out = new Map();
-        for (const rec of run.matrix) {
-            // Keep the latest-generation row per variantId so diff compares final state.
-            const existing = out.get(rec.variantId);
-            if (!existing || rec.generation > existing.generation) {
-                out.set(rec.variantId, { generation: rec.generation, variantId: rec.variantId, gmean: rec.gmean });
-            }
-        }
-        return out;
-    };
-    const rowsA = collect(a);
-    const rowsB = collect(b);
-    const ids = new Set([...rowsA.keys(), ...rowsB.keys()]);
-    console.log(`# Diff: ${runIdA} → ${runIdB}`);
-    console.log("");
-    console.log(`|  Variant  |  A gmean  |  B gmean  |   Δ   |  note  |`);
-    console.log(`|-----------|-----------|-----------|-------|--------|`);
-    const sorted = [...ids].sort();
-    for (const id of sorted) {
-        const ra = rowsA.get(id);
-        const rb = rowsB.get(id);
-        const ga = ra ? (ra.gmean * 100).toFixed(1) : "—";
-        const gb = rb ? (rb.gmean * 100).toFixed(1) : "—";
-        const delta = ra && rb ? ((rb.gmean - ra.gmean) * 100).toFixed(1) : "—";
-        const note = !ra ? "new in B" : !rb ? "missing in B" : ra.gmean < rb.gmean ? "↑" : ra.gmean > rb.gmean ? "↓" : "=";
-        console.log(`| ${id.padEnd(10)}| ${ga.padStart(9)} | ${gb.padStart(9)} | ${delta.padStart(5)} | ${note} |`);
-    }
-}
 main().catch((err) => {
     console.error(err);
     process.exit(1);

package/dist/core/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.59.0";
+export declare const VERSION = "1.60.0";

package/dist/core/_version.js

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

package/dist/prompt-evolution/llm-judge.js

@@ -43,11 +43,10 @@ export async function judgeOutput(rawOutput, c, opts) {
     const headers = {
         "Content-Type": "application/json",
         "Authorization": `Bearer ${authToken}`,
+        "User-Agent": "Claude-Code/0.1.0",
     };
     if (isAnthropic)
         headers["anthropic-version"] = "2023-06-01";
-    if (isKimi)
-        headers["User-Agent"] = "Kilo-Code/1.0";
     const res = await fetch(endpoint, {
         method: "POST",
         headers,

package/dist/prompt-evolution/mutator.js

@@ -15,19 +15,36 @@ export async function mutate(request, opts) {
     const baseUrl = (opts.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\/$/, "");
     const authToken = opts.authToken ?? process.env.ANTHROPIC_AUTH_TOKEN ?? process.env.ANTHROPIC_API_KEY ?? "";
     const isKimi = /kimi\.com/i.test(baseUrl);
-    const body = JSON.stringify({
-        model: opts.model,
-        max_tokens: opts.maxTokens ?? 4096,
-        messages: [{ role: "user", content: prompt }],
-    });
+    let body;
+    if (baseUrl.includes("generativelanguage")) {
+        body = JSON.stringify({
+            model: opts.model,
+            max_completion_tokens: opts.maxTokens ?? 4096,
+            messages: [{ role: "user", content: prompt }],
+        });
+    }
+    else {
+        body = JSON.stringify({
+            model: opts.model,
+            max_tokens: opts.maxTokens ?? 4096,
+            messages: [{ role: "user", content: prompt }],
+        });
+    }
     const headers = {
         "Content-Type": "application/json",
         "Authorization": `Bearer ${authToken}`,
         "anthropic-version": "2023-06-01",
+        "User-Agent": "Claude-Code/0.1.0",
     };
-    if (isKimi)
-        headers["User-Agent"] = "Kilo-Code/1.0";
-    const res = await fetch(`${baseUrl}/v1/messages`, {
+    let endpoint = `${baseUrl}/v1/messages`;
+    if (baseUrl.includes("generativelanguage")) {
+        endpoint = `${baseUrl}/v1/chat/completions`;
+    }
+    else if (!/^https?:\/\/(api\.)?anthropic\.com/i.test(baseUrl) && !baseUrl.includes("/v1/messages")) {
+        // A lot of OpenAI compatible endpoints use `/v1/chat/completions` natively
+        endpoint = `${baseUrl}/v1/chat/completions`;
+    }
+    const res = await fetch(endpoint, {
         method: "POST",
         headers,
         body,
@@ -38,7 +55,15 @@ export async function mutate(request, opts) {
         throw new Error(`Mutator HTTP ${res.status}: ${text.slice(0, 200)}`);
     }
     const data = await res.json();
-    const raw = data.content?.map((c) => c.text ?? "").join("") ?? "";
+    let raw = "";
+    if (endpoint.includes("chat/completions")) {
+        const chatData = data;
+        raw = chatData.choices?.[0]?.message?.content ?? "";
+    }
+    else {
+        const msgData = data;
+        raw = msgData.content?.map((c) => c.text ?? "").join("") ?? "";
+    }
     return parseMutantOutput(raw, request);
 }
 function buildMutatorPrompt(req) {

package/dist/prompt-evolution/transport.js

@@ -8,8 +8,7 @@
  * Supports both Anthropic-native and OpenAI-compatible endpoints so we can
  * run the same eval against Haiku, Kimi, and OpenRouter without a rewrite.
  */
-import { VERSION } from "../core/_version.js";
-const USER_AGENT = `claude-overnight-evolve/${VERSION}`;
+const USER_AGENT = `Claude-Code/0.1.0`;
 export async function defaultCallModel(userText, systemText, opts) {
     const baseUrl = (opts.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\/$/, "");
     const authToken = opts.authToken ?? process.env.ANTHROPIC_AUTH_TOKEN ?? process.env.ANTHROPIC_API_KEY ?? "";
@@ -44,16 +43,21 @@ export async function defaultCallModel(userText, systemText, opts) {
         if (systemText)
             messages.push({ role: "system", content: systemText });
         messages.push({ role: "user", content: userText });
-        // Platform.moonshot.ai marks max_tokens deprecated in favor of
-        // max_completion_tokens. Kimi's coding endpoint still accepts max_tokens.
-        // Sending both is safe — OpenAI, Moonshot, DeepSeek, and Kimi all tolerate
-        // the extra field, and we're future-proof against the deprecation.
-        body = JSON.stringify({
+        const payload = {
             model: opts.model,
-            max_tokens: maxOut,
-            max_completion_tokens: maxOut,
             messages,
-        });
+        };
+        // Platform.moonshot.ai marks max_tokens deprecated in favor of max_completion_tokens.
+        // Kimi's coding endpoint accepts max_tokens.
+        // Gemini's OpenAI wrapper strictly rejects having BOTH set.
+        if (baseUrl.includes("generativelanguage")) {
+            payload.max_completion_tokens = maxOut;
+        }
+        else {
+            payload.max_tokens = maxOut;
+            payload.max_completion_tokens = maxOut;
+        }
+        body = JSON.stringify(payload);
     }
     const res = await fetch(endpoint, {
         method: "POST",

package/dist/prompts/load.d.ts

@@ -1,3 +1,4 @@
+export declare const PROMPTS_ROOT: string;
 export type PromptVars = Record<string, string | number | boolean | undefined | null>;
 export interface RenderOpts {
     variant?: string;

package/dist/prompts/load.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 // Resolve <pkg>/prompts whether running from dist/ (installed) or src/ (dev).
-const PROMPTS_ROOT = (() => {
+export const PROMPTS_ROOT = (() => {
     const here = dirname(fileURLToPath(import.meta.url));
     for (const depth of [2, 3, 4]) {
         const candidate = join(here, ...Array(depth).fill(".."), "prompts");

package/dist/ui/input.js

@@ -169,19 +169,35 @@ export function InputLayer({ store, callbacks, onToast }) {
         const lc = s.liveConfig;
         if (key.rightArrow || key.downArrow) {
             callbacks.cycleAgent(1);
+            const nextId = store.get().selectedAgentId;
+            if (nextId != null && s.viewMode.startsWith("stream:agent-")) {
+                store.patch({ viewMode: `stream:agent-${nextId}` });
+            }
             return;
         }
         if (key.upArrow) {
             callbacks.cycleAgent(-1);
+            const nextId = store.get().selectedAgentId;
+            if (nextId != null && s.viewMode.startsWith("stream:agent-")) {
+                store.patch({ viewMode: `stream:agent-${nextId}` });
+            }
             return;
         }
         if (key.leftArrow) {
             callbacks.clearSelectedAgent();
+            if (s.viewMode.startsWith("stream:agent-"))
+                store.patch({ viewMode: "events" });
             return;
         }
         if (key.escape) {
             if (s.selectedAgentId != null) {
                 callbacks.clearSelectedAgent();
+                if (s.viewMode.startsWith("stream:agent-"))
+                    store.patch({ viewMode: "events" });
+                return;
+            }
+            if (s.viewMode !== "events") {
+                store.patch({ viewMode: "events" });
                 return;
             }
             if (s.ask && !s.ask.streaming) {
@@ -202,10 +218,18 @@ export function InputLayer({ store, callbacks, onToast }) {
                 callbacks.openAskTempFile();
             return;
         }
+        if (key.tab) {
+            const modes = ["stream:planner", "stream:steerer", "stream:verifier"];
+            const current = s.viewMode;
+            const idx = modes.indexOf(current);
+            const next = modes[(idx + 1) % modes.length];
+            store.patch({ viewMode: next });
+            return;
+        }
         if (!raw || raw.length !== 1)
             return;
         const code = raw.charCodeAt(0);
-        if (code < 0x20 || code > 0x7E)
+        if (code !== 9 && (code < 0x20 || code > 0x7E))
             return;
         if (key.ctrl || key.meta)
             return;
@@ -273,8 +297,11 @@ export function InputLayer({ store, callbacks, onToast }) {
         if (/^[0-9]$/.test(raw) && swarm) {
             const n = parseInt(raw, 10);
             const running = swarm.agents.filter(a => a.status === "running");
-            if (n < running.length)
-                callbacks.selectAgent(running[n].id);
+            if (n < running.length) {
+                const id = running[n].id;
+                callbacks.selectAgent(id);
+                store.patch({ viewMode: `stream:agent-${id}` });
+            }
         }
     }, { isActive: !textEntry });
     if (state.input.mode === "none")

package/dist/ui/ui.js

@@ -8,7 +8,7 @@ import { UiStore, makeInitialState } from "./store.js";
 import { App } from "./shell.js";
 const MAX_STEERING_EVENTS = 60;
 const MAX_ASK_LINES = 40;
-const MAX_DEBRIEF_HISTORY = 20;
+const MAX_DEBRIEF_HISTORY = 50;
 function askDisplayCap() {
     return Math.max(3, Math.min(MAX_ASK_LINES, (process.stdout.rows || 40) - 20));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.59.0",
+  "version": "1.60.1",
   "description": "Overnight parallel coding agents in git worktrees, with a self-curating skill memory that improves while the run is going. Mix Claude Opus as planner, Kimi 2.6 or Cursor composer-2 as cheap fast worker, Gemini or Qwen for bulk implementation. Multi-wave autonomous loop that plans, executes, reviews, and steers itself until the objective is met. Crash-safe resume, rate-limit aware, usage cap preserves headroom for your interactive Claude Code.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "test": "node --test dist/__tests__/*.test.js",
     "matrix:cursor-proxy": "node scripts/cursor-proxy-keychain-matrix.mjs",
     "evolve": "node dist/bin/evolve.js",
+    "evolve:favorite": "node dist/bin/evolve.js --prompt 10_planning/10-3_plan --eval-model gemini-3.1-flash-lite-preview --mutate-model gemini-3.1-pro-preview --generations 10 --population 8 --plateau 3 --reps 3",
     "prepublishOnly": "node scripts/sync-plugin-version.js"
   },
   "dependencies": {

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

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.59.0",
+  "version": "1.60.1",
   "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs: overnight parallel coding agents in git worktrees with a self-curating skill memory, multi-wave steering, three-layer review, and crash-safe resume. Mix Opus planner with Kimi 2.6, Cursor composer-2, Gemini, Qwen, or any Anthropic-compatible worker.",
   "author": {
     "name": "Francesco Fornace"

package/prompts/10_planning/10-3_plan.md

@@ -30,23 +30,20 @@ Respond with ONLY a JSON object (no markdown fences):
 <!-- @@@ -->
 
 <!-- STANDARD -->
+<!-- LARGE -->
 
-You are a task coordinator for a parallel agent system with {{budget}} agent sessions available.
+You are a task coordinator for a parallel agent system. Analyze this codebase and break the following objective into independent tasks.
 
 Objective: {{objective}}
 
 {{contextConstraintNote}}
 
-Do NOT over-specify. Give each agent a MISSION, not step-by-step instructions. Let agents make their own decisions about implementation details.
-
 Requirements:
 - Target exactly ~{{budget}} tasks
-- Each task should be a substantial piece of work
 - Each task MUST be independent  -- no task depends on another
-- Tasks that run concurrently must touch DIFFERENT files/areas to avoid merge conflicts
-- Give agents scope and autonomy: "Design and implement X" not "In file Y, add function Z"
-- Include research/exploration tasks, design tasks, implementation tasks, testing tasks, and polish tasks
-- Think in terms of workstreams: architecture, features, tests, docs, UX, performance, etc.{{#if concurrency}}
+- Each task should target specific files/areas to avoid merge conflicts
+- Be specific: mention exact file paths, function names, what to change
+- Keep tasks focused: one concrete change per task{{#if concurrency}}
 - {{concurrency}} agents run in parallel  -- tasks that run concurrently must touch DIFFERENT files to avoid merge conflicts{{/if}}{{#if flexNote}}
 
 {{flexNote}}{{/if}}
@@ -54,8 +51,8 @@ Requirements:
 Respond with ONLY a JSON object (no markdown fences):
 {
   "tasks": [
-    { "prompt": "Design and implement the complete user favorites system: database schema, API routes, client hooks, and error handling. Research existing patterns in the codebase first." },
-    { "prompt": "Audit all existing API routes for consistency, error handling, and input validation. Fix any issues found." }
+    { "prompt": "In src/foo.ts, refactor the bar() function to..." },
+    { "prompt": "Add unit tests for the baz module in test/baz.test.ts..." }
   ]
 }