@cryer/star-cli 0.3.0 → 0.3.2

package/dist/main.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   AgentLoop,
+  MAX_IMAGE_DIMENSION,
   SKIP_DIRS,
   TodoStore,
   WORKING_DIFF_MAX_LINES,
@@ -23,25 +24,32 @@ import {
   formatTaskStarted,
   formatTodos,
   getGitSummary,
-  globalConfigPath,
   hydrateSnapshots,
   isAllowedByRules,
   isDangerousCommand,
   isGitRepo,
   isSensitivePath,
   listSnapshots,
+  listTurnSnapshots,
   loadTodos,
   parseTodoArgs,
-  projectConfigPath,
+  probeImageDimensions,
   reconcileToolCalls,
+  resetTodos,
   resolveShell,
+  resolveSnapshotContent,
   rewindToSnapshot,
+  summarizeMessages,
+  undoTurnSnapshots
+} from "./chunk-BV4PLM6X.js";
+import {
+  envFilePath,
+  globalConfigPath,
+  projectConfigPath,
   sessionsDir,
   starHome,
-  summarizeMessages,
-  undoTurnSnapshots,
   userMemoryPath
-} from "./chunk-DZWTIMJ2.js";
+} from "./chunk-LADQCYKL.js";
 
 // src/main.tsx
 import { Command } from "commander";
@@ -109,10 +117,125 @@ function buildDisplayMessages(messages) {
 }
 
 // src/cli/mentions.ts
-import { readFile, stat } from "fs/promises";
+import { readFile as readFile2, readdir, stat } from "fs/promises";
+import path2 from "path";
+
+// src/cli/image.ts
+import { execFile } from "child_process";
+import { randomUUID } from "crypto";
+import { readFile, unlink, writeFile } from "fs/promises";
+import os from "os";
 import path from "path";
+import { promisify } from "util";
+var RESIZE_TIMEOUT_MS = 1e4;
+var execFileAsync = promisify(execFile);
+function windowsResizeScript(inputFile, outputFile, maxDimension) {
+  const input = inputFile.replace(/'/g, "''");
+  const output = outputFile.replace(/'/g, "''");
+  return [
+    "Add-Type -AssemblyName System.Drawing",
+    `$img = [System.Drawing.Image]::FromFile('${input}')`,
+    `$scale = [Math]::Min(1.0, ${maxDimension} / [Math]::Max($img.Width, $img.Height))`,
+    "$w = [int][Math]::Max(1, [Math]::Round($img.Width * $scale))",
+    "$h = [int][Math]::Max(1, [Math]::Round($img.Height * $scale))",
+    "$bmp = New-Object System.Drawing.Bitmap($w, $h)",
+    "$g = [System.Drawing.Graphics]::FromImage($bmp)",
+    "$g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic",
+    "$g.DrawImage($img, 0, 0, $w, $h)",
+    `$bmp.Save('${output}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    "$g.Dispose(); $bmp.Dispose(); $img.Dispose()"
+  ].join("; ");
+}
+function resizeImagePlan(platform, inputFile, outputFile, maxDimension, tools = {}) {
+  if (platform === "win32") {
+    return {
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        windowsResizeScript(inputFile, outputFile, maxDimension)
+      ]
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      command: "sips",
+      args: ["-Z", String(maxDimension), inputFile, "--out", outputFile]
+    };
+  }
+  if (platform === "linux") {
+    if (tools.hasConvert) {
+      return {
+        command: "convert",
+        args: [inputFile, "-resize", `${maxDimension}x${maxDimension}>`, outputFile]
+      };
+    }
+    if (tools.hasFfmpeg) {
+      return {
+        command: "ffmpeg",
+        args: [
+          "-y",
+          "-i",
+          inputFile,
+          "-vf",
+          `scale='if(gt(iw,ih),min(iw,${maxDimension}),-1)':'if(gt(iw,ih),-1,min(ih,${maxDimension}))'`,
+          outputFile
+        ]
+      };
+    }
+    return null;
+  }
+  return null;
+}
+async function commandExists(command) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  try {
+    await execFileAsync(checker, [command], { timeout: RESIZE_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function downsampleImageIfNeeded(image) {
+  const buf = Buffer.from(image.data, "base64");
+  const dims = probeImageDimensions(buf);
+  if (!dims || Math.max(dims.width, dims.height) <= MAX_IMAGE_DIMENSION) {
+    return { image, oversized: false, resized: false };
+  }
+  const inputFile = path.join(os.tmpdir(), `star-image-${randomUUID()}.src`);
+  const outputFile = path.join(os.tmpdir(), `star-image-${randomUUID()}.png`);
+  try {
+    const [hasConvert, hasFfmpeg] = process.platform === "linux" ? await Promise.all([commandExists("convert"), commandExists("ffmpeg")]) : [false, false];
+    const plan = resizeImagePlan(process.platform, inputFile, outputFile, MAX_IMAGE_DIMENSION, {
+      hasConvert,
+      hasFfmpeg
+    });
+    if (!plan) return { image, oversized: true, resized: false };
+    await writeFile(inputFile, buf);
+    await execFileAsync(plan.command, plan.args, { timeout: RESIZE_TIMEOUT_MS });
+    const out = await readFile(outputFile).catch(() => null);
+    if (!out || out.length === 0) return { image, oversized: true, resized: false };
+    return {
+      image: { path: image.path, mimeType: "image/png", data: out.toString("base64") },
+      oversized: true,
+      resized: true
+    };
+  } catch {
+    return { image, oversized: true, resized: false };
+  } finally {
+    await unlink(inputFile).catch(() => {
+    });
+    await unlink(outputFile).catch(() => {
+    });
+  }
+}
+
+// src/cli/mentions.ts
 var MAX_MENTION_BYTES = 100 * 1024;
 var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var MAX_DIR_MENTION_ENTRIES = 200;
+var MAX_DIR_MENTION_DEPTH = 10;
 var IMAGE_MIME_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -121,17 +244,22 @@ var IMAGE_MIME_TYPES = {
   ".webp": "image/webp"
 };
 function imageMimeType(filePath) {
-  return IMAGE_MIME_TYPES[path.extname(filePath).toLowerCase()] ?? null;
+  return IMAGE_MIME_TYPES[path2.extname(filePath).toLowerCase()] ?? null;
 }
 async function readImageInput(filePath, cwd) {
   const mimeType = imageMimeType(filePath);
   if (!mimeType) return null;
-  const abs = path.resolve(cwd, filePath);
+  const abs = path2.resolve(cwd, filePath);
   const st = await stat(abs).catch(() => null);
   if (!st || !st.isFile() || st.size > MAX_IMAGE_BYTES) return null;
-  const buf = await readFile(abs).catch(() => null);
+  const buf = await readFile2(abs).catch(() => null);
   if (!buf) return null;
-  return { path: filePath, mimeType, data: buf.toString("base64") };
+  const result = await downsampleImageIfNeeded({
+    path: filePath,
+    mimeType,
+    data: buf.toString("base64")
+  });
+  return result.image;
 }
 var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\]*|[A-Za-z0-9._\-/\\]+)/g;
 function parseMentions(text) {
@@ -165,6 +293,51 @@ function isBinaryContent(buf) {
   const probe = buf.subarray(0, 8e3);
   return probe.includes(0);
 }
+async function listDirEntries(dir, prefix, depth, state, ignore) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  const visible = entries.filter((entry) => entry.isDirectory() || entry.isFile()).filter((entry) => !isSensitivePath(entry.name)).filter((entry) => !ignore?.(path2.join(dir, entry.name), entry.isDirectory())).sort((a, b) => {
+    const dirDiff = Number(b.isDirectory()) - Number(a.isDirectory());
+    return dirDiff !== 0 ? dirDiff : a.name.localeCompare(b.name);
+  });
+  for (let i = 0; i < visible.length; i++) {
+    const entry = visible[i];
+    if (!entry) continue;
+    state.total += 1;
+    const last = i === visible.length - 1;
+    const isDir = entry.isDirectory();
+    if (state.shown < MAX_DIR_MENTION_ENTRIES) {
+      state.shown += 1;
+      state.lines.push(`${prefix}${last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${entry.name}${isDir ? "/" : ""}`);
+      if (isDir && depth < MAX_DIR_MENTION_DEPTH) {
+        await listDirEntries(
+          path2.join(dir, entry.name),
+          `${prefix}${last ? "    " : "\u2502   "}`,
+          depth + 1,
+          state,
+          ignore
+        );
+      }
+    } else if (isDir && depth < MAX_DIR_MENTION_DEPTH) {
+      await listDirEntries(path2.join(dir, entry.name), prefix, depth + 1, state, ignore);
+    }
+  }
+}
+async function directoryBlock(abs, mention, ignore) {
+  const display = `${mention.replace(/\\/g, "/").replace(/\/+$/, "")}/`;
+  const state = { lines: [`${display}`], shown: 0, total: 0 };
+  const probe = await readdir(abs).catch(() => null);
+  if (!probe) return null;
+  await listDirEntries(abs, "", 1, state, ignore);
+  if (state.total > state.shown) {
+    state.lines.push(
+      `... (truncated, ${state.total - state.shown} more entries \u2014 use glob/grep tools or mention a subdirectory to see more)`
+    );
+  }
+  return `--- @${display} (directory) ---
+${state.lines.join("\n")}
+--- end ---`;
+}
 async function resolveMentions(text, cwd) {
   const { cleanText, mentions } = parseMentions(text);
   if (mentions.length === 0) {
@@ -174,8 +347,9 @@ async function resolveMentions(text, cwd) {
   const attached = [];
   const skipped = [];
   const images = [];
+  let ignore;
   for (const mention of mentions) {
-    const abs = path.resolve(cwd, mention);
+    const abs = path2.resolve(cwd, mention);
     if (isSensitivePath(abs)) {
       skipped.push({ path: mention, reason: "sensitive file" });
       continue;
@@ -191,13 +365,18 @@ async function resolveMentions(text, cwd) {
         skipped.push({ path: mention, reason: "image too large" });
         continue;
       }
-      const buf2 = await readFile(abs).catch(() => null);
+      const buf2 = await readFile2(abs).catch(() => null);
       if (!buf2) {
         skipped.push({ path: mention, reason: "unreadable" });
         continue;
       }
+      const result = await downsampleImageIfNeeded({
+        path: mention,
+        mimeType,
+        data: buf2.toString("base64")
+      });
       attached.push(mention);
-      images.push({ path: mention, mimeType, data: buf2.toString("base64") });
+      images.push(result.image);
       continue;
     }
     const st = await stat(abs).catch(() => null);
@@ -206,14 +385,23 @@ async function resolveMentions(text, cwd) {
       continue;
     }
     if (st.isDirectory()) {
-      skipped.push({ path: mention, reason: "is a directory" });
+      if (ignore === void 0) {
+        ignore = createIgnorePredicate(cwd) ?? null;
+      }
+      const block = await directoryBlock(abs, mention, ignore ?? void 0);
+      if (!block) {
+        skipped.push({ path: mention, reason: "unreadable" });
+        continue;
+      }
+      attached.push(mention);
+      blocks.push(block);
       continue;
     }
     if (st.size > MAX_MENTION_BYTES) {
       skipped.push({ path: mention, reason: `exceeds ${MAX_MENTION_BYTES / 1024}KB limit` });
       continue;
     }
-    const buf = await readFile(abs).catch(() => null);
+    const buf = await readFile2(abs).catch(() => null);
     if (!buf) {
       skipped.push({ path: mention, reason: "unreadable" });
       continue;
@@ -275,12 +463,12 @@ var UsageTracker = class {
 };
 
 // src/cli/repl.tsx
-import { Box as Box11, Text as Text12, render, useApp, useInput as useInput6 } from "ink";
-import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef3, useState as useState3 } from "react";
+import { Box as Box13, Text as Text14, render, useApp, useInput as useInput8 } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef5, useState as useState5 } from "react";
 
 // src/config/save.ts
 import fs from "fs";
-import path2 from "path";
+import path3 from "path";
 import { parse, stringify } from "smol-toml";
 async function addAllowRule(rule) {
   return addPermissionRule("allow", rule);
@@ -299,7 +487,7 @@ async function addPermissionRule(kind, rule) {
   if (rules.includes(rule)) return false;
   permissions[kind] = [...rules, rule];
   raw.permissions = permissions;
-  await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
+  await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
   return true;
 }
@@ -313,7 +501,7 @@ async function savePermissionMode(mode) {
     if (error.code !== "ENOENT") throw error;
   }
   raw.permissionMode = mode;
-  await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
+  await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
 }
 
@@ -321,6 +509,10 @@ async function savePermissionMode(mode) {
 import { z } from "zod";
 var ProviderConfigSchema = z.object({
   name: z.string(),
+  // openai-responses talks to the Responses API (/responses) instead of chat
+  // completions — the wire format codex uses, and the native API of
+  // reasoning-model relays that otherwise hide reasoning behind empty chat
+  // completions. streamChat sends strictSchemas:false + store:false with it.
   protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
   baseURL: z.string(),
   apiKeyEnv: z.string().optional(),
@@ -377,13 +569,18 @@ var ConfigSchema = z.object({
   // Extra attempts per model request when a stream fails transiently
   // (network error, 429/5xx, idle watchdog cutoff) or comes back empty, so a
   // relay hiccup does not silently end a half-finished turn. 0 disables.
-  // Retries after a timeout/empty failure scale both stream timeouts up
-  // (attempt number ×, capped at 3x) since the relay is likely overloaded.
+  // The wait between attempts honors Retry-After headers and otherwise backs
+  // off exponentially with jitter (llm/retry.ts); retries after a
+  // timeout/empty failure also scale both stream timeouts up (attempt number
+  // ×, capped at 3x) since the relay is likely overloaded.
   streamMaxRetries: z.number().int().min(0).default(3),
-  // How many times a turn may be nudged to continue when the model ends it
-  // with a text-only reply that announces pending work ("我将…", "I will…")
-  // instead of tool calls — a common premature-stop failure of weaker
-  // agentic models. Never fires in plan mode. 0 disables.
+  // How many consecutive unproductive replies may be nudged before the turn
+  // is handed back: a text-only reply that announces pending work ("我将…",
+  // "I will…") or answers a nudge with more words, or an empty reply that
+  // survived the stream retry budget (steered with a nudge — a changed
+  // request — since identical resends already failed). Tool calls reset the
+  // count, so a productive task keeps going; exhaustion surfaces a notice
+  // instead of stopping silently. Never fires in plan mode. 0 disables.
   maxAutoContinues: z.number().int().min(0).default(2),
   contextCompaction: z.enum(["summary", "truncate"]).default("summary"),
   // Optional per-session dollar budget; when set, the REPL stops the session
@@ -420,6 +617,71 @@ function resolveModelConfig(config, modelName) {
   return model;
 }
 
+// src/llm/sse-normalize.ts
+var SseNormalizeTransform = class extends TransformStream {
+  constructor() {
+    let buffer = "";
+    let pending = null;
+    const flushPending = (controller) => {
+      if (pending === null) return;
+      controller.enqueue(`data: ${pending}
+
+`);
+      pending = null;
+    };
+    const handleLine = (raw, controller) => {
+      const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+      if (line === "") {
+        flushPending(controller);
+        return;
+      }
+      if (line.startsWith("data:")) {
+        flushPending(controller);
+        pending = line.slice(5).replace(/^ /, "");
+        return;
+      }
+      if (line.startsWith("{") && pending !== null) {
+        flushPending(controller);
+        pending = line;
+        return;
+      }
+      flushPending(controller);
+      controller.enqueue(`${line}
+`);
+    };
+    super({
+      transform(chunk, controller) {
+        buffer += chunk;
+        let index = buffer.indexOf("\n");
+        while (index !== -1) {
+          handleLine(buffer.slice(0, index), controller);
+          buffer = buffer.slice(index + 1);
+          index = buffer.indexOf("\n");
+        }
+      },
+      flush(controller) {
+        if (buffer.length > 0) handleLine(buffer, controller);
+        flushPending(controller);
+      }
+    });
+  }
+};
+function createSseNormalizingFetch(baseFetch = fetch) {
+  return async (input, init) => {
+    const response = await baseFetch(input, init);
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!response.body || !contentType.includes("text/event-stream")) {
+      return response;
+    }
+    const body = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new SseNormalizeTransform()).pipeThrough(new TextEncoderStream());
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+}
+
 // src/llm/provider.ts
 function resolveApiKey(provider) {
   const fromEnv = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : void 0;
@@ -458,22 +720,26 @@ function createModel(config, modelName) {
       return createOpenAI({
         baseURL: provider.baseURL,
         apiKey,
-        headers: provider.headers
+        headers: provider.headers,
+        // Relays fronting the Responses API sometimes batch several JSON
+        // events into one SSE data payload, which the SDK's parser cannot
+        // read; normalize the wire format back to one event per data line.
+        fetch: createSseNormalizingFetch()
       }).responses(modelConfig.model);
   }
 }
 
 // src/session/checkpoints.ts
 import fs2 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 function checkpointsDir(sessionDir) {
-  return path3.join(sessionDir, "checkpoints");
+  return path4.join(sessionDir, "checkpoints");
 }
 function indexPath(sessionDir) {
-  return path3.join(checkpointsDir(sessionDir), "index.json");
+  return path4.join(checkpointsDir(sessionDir), "index.json");
 }
 function checkpointContentPath(sessionDir, id) {
-  return path3.join(checkpointsDir(sessionDir), `${id}.snapshot`);
+  return path4.join(checkpointsDir(sessionDir), `${id}.snapshot`);
 }
 async function listCheckpointRecords(sessionDir) {
   let raw;
@@ -521,11 +787,11 @@ async function loadSessionSnapshots(sessionDir) {
 
 // src/session/clear.ts
 import fs4 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 
 // src/session/store.ts
 import fs3 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 function generateId(now) {
   const pad = (n) => String(n).padStart(2, "0");
   const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
@@ -547,13 +813,13 @@ var SessionStore = class _SessionStore {
   initialized = false;
   constructor(id) {
     this.id = id;
-    this.dir = path4.join(sessionsDir(), id);
+    this.dir = path5.join(sessionsDir(), id);
   }
   metaPath() {
-    return path4.join(this.dir, "meta.json");
+    return path5.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path4.join(this.dir, "messages.jsonl");
+    return path5.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
     const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
@@ -587,7 +853,7 @@ var SessionStore = class _SessionStore {
     const metas = [];
     for (const entry of entries) {
       try {
-        const raw = await fs3.readFile(path4.join(sessionsDir(), entry, "meta.json"), "utf8");
+        const raw = await fs3.readFile(path5.join(sessionsDir(), entry, "meta.json"), "utf8");
         const meta = JSON.parse(raw);
         if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) metas.push(meta);
       } catch {
@@ -714,7 +980,7 @@ async function clearSessions(cwd, excludeId) {
     let removed2 = 0;
     for (const meta of metas) {
       if (meta.id === excludeId) continue;
-      await fs4.rm(path5.join(sessionsDir(), meta.id), { recursive: true, force: true });
+      await fs4.rm(path6.join(sessionsDir(), meta.id), { recursive: true, force: true });
       removed2 += 1;
     }
     return removed2;
@@ -728,7 +994,7 @@ async function clearSessions(cwd, excludeId) {
   let removed = 0;
   for (const entry of entries) {
     if (entry === excludeId) continue;
-    await fs4.rm(path5.join(sessionsDir(), entry), { recursive: true, force: true });
+    await fs4.rm(path6.join(sessionsDir(), entry), { recursive: true, force: true });
     removed += 1;
   }
   return removed;
@@ -736,11 +1002,11 @@ async function clearSessions(cwd, excludeId) {
 
 // src/session/list.ts
 import fs5 from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 async function countMessages(id) {
   let raw;
   try {
-    raw = await fs5.readFile(path6.join(sessionsDir(), id, "messages.jsonl"), "utf8");
+    raw = await fs5.readFile(path7.join(sessionsDir(), id, "messages.jsonl"), "utf8");
   } catch {
     return 0;
   }
@@ -998,11 +1264,11 @@ function formatUsageDashboard(stats, models, options = {}) {
 
 // src/version.ts
 import fs6 from "fs";
-import path7 from "path";
+import path8 from "path";
 import { fileURLToPath } from "url";
 function readPackageVersion() {
   try {
-    const pkgPath = path7.join(path7.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkgPath = path8.join(path8.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
     if (typeof pkg === "object" && pkg !== null) {
       const version = pkg.version;
@@ -1023,16 +1289,30 @@ function budgetState(costUsd, budgetUsd) {
   return "ok";
 }
 
+// src/cli/cache-stats.ts
+function cacheUsageReported(usage) {
+  return usage.cachedPromptTokens != null || usage.cacheReadInputTokens != null;
+}
+function addToCacheTotals(totals, usage) {
+  totals.cachedTokens += (usage.cachedPromptTokens ?? 0) + (usage.cacheReadInputTokens ?? 0);
+  totals.promptTokens += usage.promptTokens + (usage.cacheReadInputTokens ?? 0);
+}
+function cacheHitPercent(totals) {
+  if (totals.promptTokens <= 0) return null;
+  const rate = totals.cachedTokens / totals.promptTokens;
+  return Math.round(Math.min(1, Math.max(0, rate)) * 100);
+}
+
 // src/cli/clipboard.ts
-import { execFile } from "child_process";
-import { randomUUID } from "crypto";
-import { readFile as readFile2, unlink } from "fs/promises";
-import os from "os";
-import path8 from "path";
-import { promisify } from "util";
+import { execFile as execFile2 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile3, unlink as unlink2 } from "fs/promises";
+import os2 from "os";
+import path9 from "path";
+import { promisify as promisify2 } from "util";
 var CLIPBOARD_TIMEOUT_MS = 5e3;
 var MAX_CLIPBOARD_IMAGE_BYTES = 10 * 1024 * 1024;
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify2(execFile2);
 function windowsClipboardImageScript(tempFile) {
   const escaped = tempFile.replace(/'/g, "''");
   return [
@@ -1092,40 +1372,52 @@ function clipboardCopyCommand(platform) {
   if (platform === "linux") return { command: "xclip", args: ["-selection", "clipboard"] };
   return null;
 }
-async function commandExists(command) {
+async function commandExists2(command) {
   const checker = process.platform === "win32" ? "where" : "which";
   try {
-    await execFileAsync(checker, [command], { timeout: CLIPBOARD_TIMEOUT_MS });
+    await execFileAsync2(checker, [command], { timeout: CLIPBOARD_TIMEOUT_MS });
     return true;
   } catch {
     return false;
   }
 }
+async function finalizeClipboardImage(image) {
+  const result = await downsampleImageIfNeeded(image);
+  return { image: result.image, oversized: result.oversized && !result.resized };
+}
 async function readClipboardImage() {
-  const tempFile = path8.join(os.tmpdir(), `star-clipboard-${randomUUID()}.png`);
-  const hasPngpaste = process.platform === "darwin" ? await commandExists("pngpaste") : false;
+  const tempFile = path9.join(os2.tmpdir(), `star-clipboard-${randomUUID2()}.png`);
+  const hasPngpaste = process.platform === "darwin" ? await commandExists2("pngpaste") : false;
   const plan = clipboardImagePlan(process.platform, tempFile, hasPngpaste);
   if (!plan) return null;
   try {
     if (plan.kind === "stdout") {
-      const { stdout } = await execFileAsync(plan.command, plan.args, {
+      const { stdout } = await execFileAsync2(plan.command, plan.args, {
         timeout: CLIPBOARD_TIMEOUT_MS,
         maxBuffer: MAX_CLIPBOARD_IMAGE_BYTES,
         encoding: "buffer"
       });
       const buf2 = stdout;
       if (buf2.length === 0) return null;
-      return { path: "clipboard.png", mimeType: "image/png", data: buf2.toString("base64") };
+      return finalizeClipboardImage({
+        path: "clipboard.png",
+        mimeType: "image/png",
+        data: buf2.toString("base64")
+      });
     }
-    await execFileAsync(plan.command, plan.args, { timeout: CLIPBOARD_TIMEOUT_MS });
-    const buf = await readFile2(tempFile).catch(() => null);
+    await execFileAsync2(plan.command, plan.args, { timeout: CLIPBOARD_TIMEOUT_MS });
+    const buf = await readFile3(tempFile).catch(() => null);
     if (!buf || buf.length === 0) return null;
-    return { path: "clipboard.png", mimeType: "image/png", data: buf.toString("base64") };
+    return finalizeClipboardImage({
+      path: "clipboard.png",
+      mimeType: "image/png",
+      data: buf.toString("base64")
+    });
   } catch {
     return null;
   } finally {
     if (plan.kind === "temp-file") {
-      await unlink(tempFile).catch(() => {
+      await unlink2(tempFile).catch(() => {
       });
     }
   }
@@ -1134,7 +1426,7 @@ async function copyText(text) {
   const plan = clipboardCopyCommand(process.platform);
   if (!plan) return false;
   return new Promise((resolve) => {
-    const child = execFile(
+    const child = execFile2(
       plan.command,
       plan.args,
       { timeout: CLIPBOARD_TIMEOUT_MS },
@@ -1148,7 +1440,7 @@ async function copyText(text) {
 
 // src/cli/commands/actions.ts
 import fs7 from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 var MIN_COMPACT_MESSAGES = 4;
 async function compactSession(opts) {
   const { backend, sessionStore, config, model } = opts;
@@ -1209,9 +1501,9 @@ async function exportSession(opts) {
     return "Nothing to export: the session has no messages.";
   }
   const sessionId = sessionStore?.id ?? `unknown-${Date.now()}`;
-  const target = arg ? path9.resolve(cwd, arg) : path9.resolve(cwd, `star-session-${sessionId}.md`);
+  const target = arg ? path10.resolve(cwd, arg) : path10.resolve(cwd, `star-session-${sessionId}.md`);
   const existed = await fileExists(target);
-  await fs7.mkdir(path9.dirname(target), { recursive: true });
+  await fs7.mkdir(path10.dirname(target), { recursive: true });
   await fs7.writeFile(target, renderSessionMarkdown(sessionId, messages));
   return existed ? `Exported ${messages.length} messages to ${target} (overwrote existing file).` : `Exported ${messages.length} messages to ${target}.`;
 }
@@ -1333,8 +1625,8 @@ function formatSearchResults(hits, query) {
 }
 
 // src/cli/diff-preview.ts
-import { readFile as readFile3 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile4 } from "fs/promises";
+import path11 from "path";
 var CONTEXT_LINES = 2;
 var MAX_HUNK_LINES = 15;
 var MAX_TOTAL_LINES = 12;
@@ -1495,10 +1787,10 @@ async function generateDiffPreview(toolName, args, cwd) {
   if (toolName !== "edit_file" && toolName !== "write_file") return null;
   const filePath = getStringArg(args, "path");
   if (filePath === void 0) return null;
-  const absolute = path10.resolve(cwd, filePath);
+  const absolute = path11.resolve(cwd, filePath);
   let existing;
   try {
-    existing = await readFile3(absolute, "utf8");
+    existing = await readFile4(absolute, "utf8");
   } catch {
     existing = null;
   }
@@ -1795,6 +2087,19 @@ ${content}`);
       ctx.addSystemMessage(await ctx.rewind(args.trim()));
     }
   });
+  register({
+    name: "connect",
+    description: "Interactive wizard: add an LLM provider + model, store the key safely, and save to config",
+    usage: "/connect",
+    category: "Settings",
+    async run(_args, ctx) {
+      if (!ctx.connect) {
+        ctx.addSystemMessage("/connect: this context cannot run the interactive wizard.");
+        return;
+      }
+      ctx.addSystemMessage(await ctx.connect());
+    }
+  });
   register({
     name: "init",
     description: "Generate an AGENTS.md for the current project",
@@ -1922,9 +2227,260 @@ ${result.diff}${note ? `
   });
 }
 
+// src/cli/commands/connect.ts
+import { spawn } from "child_process";
+import fs9 from "fs";
+import path12 from "path";
+
+// src/config/env.ts
+import fs8 from "fs";
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseEnvContent(content) {
+  const vars = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!ENV_KEY_PATTERN.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function loadEnvFile(filePath = envFilePath()) {
+  let content;
+  try {
+    content = fs8.readFileSync(filePath, "utf8");
+  } catch {
+    return;
+  }
+  for (const [key, value] of Object.entries(parseEnvContent(content))) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+function upsertEnvContent(content, key, value) {
+  const entry = `${key}=${value.replace(/[\r\n]/g, "")}`;
+  const pattern = new RegExp(`^\\s*${key}\\s*=`);
+  const lines = content.split("\n");
+  while (lines.length > 0 && (lines[lines.length - 1] ?? "").trim() === "") lines.pop();
+  for (let i = 0; i < lines.length; i++) {
+    if (pattern.test(lines[i] ?? "")) {
+      lines[i] = entry;
+      return `${lines.join("\n")}
+`;
+    }
+  }
+  lines.push(entry);
+  return `${lines.join("\n")}
+`;
+}
+
+// src/cli/commands/connect.ts
+var PROVIDER_PRESETS = [
+  {
+    key: "openai",
+    label: "OpenAI",
+    baseURL: "https://api.openai.com/v1",
+    protocol: "openai-compatible",
+    modelHint: "gpt-4o"
+  },
+  {
+    key: "anthropic",
+    label: "Anthropic",
+    baseURL: "https://api.anthropic.com",
+    protocol: "anthropic",
+    modelHint: "claude-sonnet-4-5"
+  },
+  {
+    key: "moonshot",
+    label: "Kimi (Moonshot)",
+    baseURL: "https://api.moonshot.cn/v1",
+    protocol: "openai-compatible",
+    modelHint: "kimi-k2-0905-preview"
+  },
+  {
+    key: "deepseek",
+    label: "DeepSeek",
+    baseURL: "https://api.deepseek.com/v1",
+    protocol: "openai-compatible",
+    modelHint: "deepseek-chat"
+  }
+];
+var PROTOCOLS = ["openai-compatible", "anthropic", "openai-responses"];
+var PROTOCOL_DESCRIPTIONS = {
+  "openai-compatible": "POST /chat/completions \u2014 most providers",
+  anthropic: "Anthropic Messages API",
+  "openai-responses": "OpenAI Responses API (endpoints exposing only /responses)"
+};
+var CONNECT_DEFAULT_CONTEXT_TOKENS = 128e3;
+function deriveProviderName(baseURL) {
+  let host = baseURL;
+  try {
+    host = new URL(baseURL).hostname;
+  } catch {
+    host = baseURL.replace(/^[a-z]+:\/\//i, "").split(/[/:?#]/)[0] ?? baseURL;
+  }
+  const labels = host.toLowerCase().split(".");
+  const skip = /* @__PURE__ */ new Set(["www", "api"]);
+  const meaningful = labels.filter((label) => label !== "" && !skip.has(label));
+  const raw = meaningful[0] ?? "provider";
+  const slug = raw.replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "provider";
+}
+function dedupeName(base, taken) {
+  const names = new Set(taken);
+  if (!names.has(base)) return base;
+  for (let i = 2; ; i++) {
+    const candidate = `${base}-${i}`;
+    if (!names.has(candidate)) return candidate;
+  }
+}
+function apiKeyEnvFor(providerName) {
+  return `STAR_API_KEY_${providerName.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+}
+function maskApiKey(key) {
+  if (key.length <= 8) return "\u2022\u2022\u2022\u2022\u2022\u2022";
+  return `${key.slice(0, 3)}\u2026${key.slice(-4)}`;
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function buildProviderTomlBlock(provider) {
+  return [
+    "[[providers]]",
+    `name = ${tomlString(provider.name)}`,
+    "# wire format: openai-compatible | anthropic | openai-responses",
+    `protocol = ${tomlString(provider.protocol)}`,
+    `baseURL = ${tomlString(provider.baseURL)}`,
+    "# environment variable holding the API key; the key itself lives in",
+    "# ~/.star-cli/.env (written by /connect), never in this file",
+    `apiKeyEnv = ${tomlString(provider.apiKeyEnv ?? "")}`,
+    "# inline key instead of apiKeyEnv (not recommended):",
+    '# apiKey = "sk-..."',
+    "# extra HTTP headers sent to the provider:",
+    '# headers = { "X-Title" = "star-cli" }',
+    "",
+    ""
+  ].join("\n");
+}
+function buildModelTomlBlock(model) {
+  return [
+    "[[models]]",
+    `name = ${tomlString(model.name)}`,
+    `provider = ${tomlString(model.provider)}`,
+    `model = ${tomlString(model.model)}`,
+    "# per-model context window in tokens \u2014 overrides the top-level",
+    "# contextMaxTokens for compaction and the ctx % in the status bar",
+    `contextMaxTokens = ${model.contextMaxTokens ?? CONNECT_DEFAULT_CONTEXT_TOKENS}`,
+    "# pricing in USD per 1M tokens \u2014 set your provider's rates; BOTH",
+    "# promptPrice and completionPrice are required together for the $",
+    "# estimates in /cost and /usage (0 prices a token at $0)",
+    `promptPrice = ${model.promptPrice ?? 0}`,
+    `completionPrice = ${model.completionPrice ?? 0}`,
+    "# cap on generated tokens per reply:",
+    "# maxTokens = 8192",
+    "",
+    ""
+  ].join("\n");
+}
+function saveConnection(answers, configPath = globalConfigPath(), envPath = envFilePath()) {
+  const provider = {
+    name: answers.providerName,
+    protocol: answers.protocol,
+    baseURL: answers.baseURL,
+    apiKeyEnv: answers.apiKeyEnv
+  };
+  const model = {
+    name: answers.modelName,
+    provider: answers.providerName,
+    model: answers.modelId,
+    contextMaxTokens: CONNECT_DEFAULT_CONTEXT_TOKENS,
+    promptPrice: 0,
+    completionPrice: 0
+  };
+  fs9.mkdirSync(path12.dirname(envPath), { recursive: true });
+  let envContent = "";
+  try {
+    envContent = fs9.readFileSync(envPath, "utf8");
+  } catch {
+    envContent = "";
+  }
+  fs9.writeFileSync(
+    envPath,
+    upsertEnvContent(envContent, provider.apiKeyEnv ?? "", answers.apiKey),
+    {
+      encoding: "utf8",
+      mode: 384
+    }
+  );
+  try {
+    fs9.chmodSync(envPath, 384);
+  } catch {
+  }
+  if (provider.apiKeyEnv) {
+    process.env[provider.apiKeyEnv] = answers.apiKey;
+  }
+  fs9.mkdirSync(path12.dirname(configPath), { recursive: true });
+  let existing = "";
+  try {
+    existing = fs9.readFileSync(configPath, "utf8");
+  } catch {
+    existing = "";
+  }
+  const separator = existing === "" ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+  fs9.writeFileSync(
+    configPath,
+    existing + separator + buildProviderTomlBlock(provider) + buildModelTomlBlock(model),
+    "utf8"
+  );
+  return { provider, model, configPath, envPath };
+}
+function setDefaultModelInToml(content, modelName) {
+  const line = `defaultModel = ${tomlString(modelName)}`;
+  const lines = content.split("\n");
+  let inTopLevel = true;
+  for (let i = 0; i < lines.length; i++) {
+    const current = lines[i] ?? "";
+    if (/^\s*\[/.test(current)) inTopLevel = false;
+    if (inTopLevel && /^\s*defaultModel\s*=/.test(current)) {
+      lines[i] = line;
+      return lines.join("\n");
+    }
+  }
+  return `${line}
+${content}`;
+}
+function saveDefaultModel(modelName, configPath = globalConfigPath()) {
+  let content = "";
+  try {
+    content = fs9.readFileSync(configPath, "utf8");
+  } catch {
+    content = "";
+  }
+  fs9.mkdirSync(path12.dirname(configPath), { recursive: true });
+  fs9.writeFileSync(configPath, setDefaultModelInToml(content, modelName), "utf8");
+}
+function openConfigFile(filePath) {
+  const [command, args] = process.platform === "win32" ? ["cmd", ["/c", "start", "", filePath]] : process.platform === "darwin" ? ["open", [filePath]] : ["xdg-open", [filePath]];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
 // src/cli/commands/custom.ts
 import { readFileSync as readFileSync2, readdirSync } from "fs";
-import path11 from "path";
+import path13 from "path";
 var NAME_PATTERN = /^[a-z0-9-]+$/;
 var DESCRIPTION_PATTERN = /^<!--\s*description:\s*(.+?)\s*-->\s*$/;
 var DEFAULT_DESCRIPTION = "Custom prompt command";
@@ -1959,14 +2515,14 @@ function scanDir(dir, into) {
     if (!entry.endsWith(".md")) continue;
     const name = entry.slice(0, -".md".length);
     if (!NAME_PATTERN.test(name)) continue;
-    const parsed = parseCommandFile(path11.join(dir, entry), name);
+    const parsed = parseCommandFile(path13.join(dir, entry), name);
     if (parsed) into.set(name, parsed);
   }
 }
 function loadCustomCommands(cwd, home = starHome()) {
   const byName = /* @__PURE__ */ new Map();
-  scanDir(path11.join(home, "commands"), byName);
-  scanDir(path11.join(cwd, ".star", "commands"), byName);
+  scanDir(path13.join(home, "commands"), byName);
+  scanDir(path13.join(cwd, ".star", "commands"), byName);
   return [...byName.values()];
 }
 function registerCustomCommands(registry, cwd, home) {
@@ -1992,8 +2548,8 @@ function registerCustomCommands(registry, cwd, home) {
 }
 
 // src/cli/commands/doctor.ts
-import fs8 from "fs/promises";
-import path12 from "path";
+import fs10 from "fs/promises";
+import path14 from "path";
 var MIN_NODE_MAJOR = 20;
 var REGISTRY_URL = "https://registry.npmjs.org/";
 var REGISTRY_TIMEOUT_MS = 5e3;
@@ -2007,7 +2563,7 @@ function nodeMajor(version) {
 }
 async function pathExists(target) {
   try {
-    await fs8.access(target);
+    await fs10.access(target);
     return true;
   } catch {
     return false;
@@ -2045,7 +2601,7 @@ async function runDoctor(opts) {
       detail: `${spec.label} (${spec.shell})`
     });
   }
-  const configPath = path12.join(home, "config.toml");
+  const configPath = path14.join(home, "config.toml");
   const configExists = await pathExists(configPath);
   checks.push({
     name: "STAR_HOME / config",
@@ -2082,14 +2638,14 @@ async function runDoctor(opts) {
       });
     }
   }
-  const sessions = path12.join(home, "sessions");
+  const sessions = path14.join(home, "sessions");
   let writable = false;
   let writeError = "";
   try {
-    await fs8.mkdir(sessions, { recursive: true });
-    const probe = path12.join(sessions, `.doctor-probe-${process.pid}`);
-    await fs8.writeFile(probe, "ok");
-    await fs8.unlink(probe);
+    await fs10.mkdir(sessions, { recursive: true });
+    const probe = path14.join(sessions, `.doctor-probe-${process.pid}`);
+    await fs10.writeFile(probe, "ok");
+    await fs10.unlink(probe);
     writable = true;
   } catch (error) {
     writeError = error instanceof Error ? error.message : String(error);
@@ -2124,15 +2680,15 @@ function formatDoctorReport(report) {
 }
 
 // src/cli/commands/init-project.ts
-import fs9 from "fs/promises";
-import path13 from "path";
+import fs11 from "fs/promises";
+import path15 from "path";
 import { generateText } from "ai";
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", "coverage"]);
 var MAX_ENTRIES = 20;
 var README_HEAD_LINES = 5;
 async function fileExists2(target) {
   try {
-    await fs9.access(target);
+    await fs11.access(target);
     return true;
   } catch {
     return false;
@@ -2140,7 +2696,7 @@ async function fileExists2(target) {
 }
 async function readPackageJson(cwd) {
   try {
-    const raw = await fs9.readFile(path13.join(cwd, "package.json"), "utf8");
+    const raw = await fs11.readFile(path15.join(cwd, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return null;
     return parsed;
@@ -2157,10 +2713,10 @@ function stringRecord(value) {
   return out;
 }
 async function detectPackageManager(cwd) {
-  if (await fileExists2(path13.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path13.join(cwd, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path13.join(cwd, "package-lock.json"))) return "npm";
-  if (await fileExists2(path13.join(cwd, "bun.lockb"))) return "bun";
+  if (await fileExists2(path15.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path15.join(cwd, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path15.join(cwd, "package-lock.json"))) return "npm";
+  if (await fileExists2(path15.join(cwd, "bun.lockb"))) return "bun";
   return null;
 }
 function inferCommands(pm, scripts) {
@@ -2175,7 +2731,7 @@ function inferCommands(pm, scripts) {
 }
 async function listEntries(cwd) {
   try {
-    const dirents = await fs9.readdir(cwd, { withFileTypes: true });
+    const dirents = await fs11.readdir(cwd, { withFileTypes: true });
     const entries = [];
     for (const dirent of dirents) {
       if (dirent.isDirectory()) {
@@ -2194,7 +2750,7 @@ async function listEntries(cwd) {
 async function readReadmeHead(cwd) {
   for (const name of ["README.md", "readme.md", "README"]) {
     try {
-      const raw = await fs9.readFile(path13.join(cwd, name), "utf8");
+      const raw = await fs11.readFile(path15.join(cwd, name), "utf8");
       return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, README_HEAD_LINES);
     } catch {
     }
@@ -2207,14 +2763,14 @@ async function scanProject(cwd) {
   const scripts = stringRecord(pkg?.scripts);
   return {
     name: typeof pkg?.name === "string" ? pkg.name : null,
-    dirName: path13.basename(cwd),
+    dirName: path15.basename(cwd),
     packageManager,
     scripts,
     dependencies: Object.keys(stringRecord(pkg?.dependencies)),
     devDependencies: Object.keys(stringRecord(pkg?.devDependencies)),
     commands: inferCommands(packageManager, scripts),
-    hasTsconfig: await fileExists2(path13.join(cwd, "tsconfig.json")),
-    isGitRepo: await fileExists2(path13.join(cwd, ".git")),
+    hasTsconfig: await fileExists2(path15.join(cwd, "tsconfig.json")),
+    isGitRepo: await fileExists2(path15.join(cwd, ".git")),
     readmeHead: await readReadmeHead(cwd),
     entries: await listEntries(cwd)
   };
@@ -2281,7 +2837,7 @@ Write the AGENTS.md.`
 }
 async function initProject(opts) {
   const { cwd, args, model } = opts;
-  const target = path13.join(cwd, "AGENTS.md");
+  const target = path15.join(cwd, "AGENTS.md");
   const force = args.split(/\s+/).includes("force");
   if (!force && await fileExists2(target)) {
     return {
@@ -2315,7 +2871,7 @@ async function initProject(opts) {
     content = renderAgentsMd(facts);
     note = " No model available; used the template \u2014 review and refine manually.";
   }
-  await fs9.writeFile(target, content);
+  await fs11.writeFile(target, content);
   const lines = content.split("\n").length;
   const how = usedLlm ? "generated with model refinement" : "generated from template";
   return {
@@ -2357,7 +2913,7 @@ function parseSlashCommand(input) {
 }
 
 // src/cli/commands/rewind.ts
-import path14 from "path";
+import path16 from "path";
 function planRewind(snapshots, id) {
   const target = snapshots.find((snapshot) => snapshot.id === id);
   if (!target) return null;
@@ -2371,7 +2927,7 @@ function planRewind(snapshots, id) {
   return { target, affected, messageIndex };
 }
 function displayPath(filePath, cwd) {
-  const relative = path14.relative(cwd, filePath);
+  const relative = path16.relative(cwd, filePath);
   return relative !== "" && !relative.startsWith("..") ? relative : filePath;
 }
 function formatTime(timestamp) {
@@ -2421,29 +2977,110 @@ function didYouMeanSuffix(names) {
   return ` Did you mean: ${listed.join(", ")}?`;
 }
 
-// src/cli/components/ExitPlanPrompt.tsx
+// src/cli/commands/undo.ts
+import { readFile as readFile5 } from "fs/promises";
+import path17 from "path";
+function displayPath2(filePath, cwd) {
+  const relative = path17.relative(cwd, filePath);
+  return relative !== "" && !relative.startsWith("..") ? relative : filePath;
+}
+async function buildUndoDiffs(snapshots, cwd) {
+  const diffs = [];
+  for (const snapshot of snapshots) {
+    let current = "";
+    try {
+      current = await readFile5(snapshot.path, "utf8");
+    } catch {
+    }
+    const before = snapshot.existed ? await resolveSnapshotContent(snapshot) : "";
+    const lines = before === null ? [{ kind: "marker", text: "(snapshot content unavailable)" }] : buildDiffLines(current, before);
+    diffs.push({ label: displayPath2(snapshot.path, cwd), lines });
+  }
+  return diffs;
+}
+
+// src/cli/components/ConnectWizard.tsx
+import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
+import { useRef as useRef4, useState as useState4 } from "react";
+
+// src/cli/components/SelectPrompt.tsx
 import { Box, Text, useInput } from "ink";
+import { useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-function ExitPlanPrompt({ onDecision }) {
+var SELECT_PROMPT_MAX_VISIBLE = 9;
+function SelectPrompt({ title, options, onSelect, onCancel }) {
+  const [index, setIndex] = useState(0);
+  const indexRef = useRef(0);
+  const move = (delta) => {
+    indexRef.current = Math.max(0, Math.min(indexRef.current + delta, options.length - 1));
+    setIndex(indexRef.current);
+  };
   useInput((input, key) => {
-    const ch = input.toLowerCase();
-    if (ch === "y") onDecision("yes");
-    else if (ch === "n" || key.escape) onDecision("no");
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      const option = options[indexRef.current];
+      if (option) onSelect(option.value);
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      move(1);
+    } else if (key.upArrow || input === "k") {
+      move(-1);
+    }
   });
+  const maxStart = Math.max(0, options.length - SELECT_PROMPT_MAX_VISIBLE);
+  const start = Math.min(Math.max(0, index - Math.floor(SELECT_PROMPT_MAX_VISIBLE / 2)), maxStart);
+  const visible = options.slice(start, start + SELECT_PROMPT_MAX_VISIBLE);
+  const above = start;
+  const below = options.length - start - visible.length;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Plan ready (plan mode)" }),
-    /* @__PURE__ */ jsx(Text, { children: "The plan above was produced without making any changes." }),
-    /* @__PURE__ */ jsx(Text, { children: "[y] approve and execute [n] keep refining (Esc = n)" })
-  ] });
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: title }),
+    above > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "\u2026 ",
+      above,
+      " more above"
+    ] }),
+    visible.map((option, i) => {
+      const active = start + i === index;
+      return /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsxs(Text, { bold: active, inverse: active, children: [
+          active ? "\u276F " : "  ",
+          option.label
+        ] }),
+        option.hint && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " (",
+          option.hint,
+          ")"
+        ] }),
+        option.description && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " \u2014 ",
+          option.description
+        ] })
+      ] }, option.value);
+    }),
+    below > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "\u2026 ",
+      below,
+      " more below"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[\u2191/\u2193 or j/k] move [Enter] select [Esc] cancel" })
+  ] });
 }
 
+// src/cli/components/TextField.tsx
+import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
+import { useRef as useRef3, useState as useState3 } from "react";
+
 // src/cli/components/InputBox.tsx
-import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
-import { useEffect, useRef, useState } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput2, useStdout } from "ink";
+import { useEffect, useRef as useRef2, useState as useState2 } from "react";
 
 // src/cli/path-suggest.ts
-import { readdir } from "fs/promises";
-import path15 from "path";
+import { readdir as readdir2 } from "fs/promises";
+import path18 from "path";
 var MAX_SCAN_ENTRIES = 2e3;
 function extractAtToken(value, cursor) {
   const before = value.slice(0, cursor);
@@ -2458,8 +3095,8 @@ async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSu
   const dirPart = slash >= 0 ? normalized.slice(0, slash + 1) : "";
   const basePrefix = slash >= 0 ? normalized.slice(slash + 1) : normalized;
   if (dirPart.split("/").some((segment) => SKIP_DIRS.has(segment))) return [];
-  const dirAbs = path15.resolve(cwd, dirPart === "" ? "." : dirPart);
-  const entries = await readdir(dirAbs, { withFileTypes: true }).catch(() => null);
+  const dirAbs = path18.resolve(cwd, dirPart === "" ? "." : dirPart);
+  const entries = await readdir2(dirAbs, { withFileTypes: true }).catch(() => null);
   if (!entries) return [];
   const ignore = createIgnorePredicate(cwd);
   const lower = basePrefix.toLowerCase();
@@ -2473,7 +3110,7 @@ async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSu
     if (isDir && SKIP_DIRS.has(entry.name)) continue;
     if (entry.name.startsWith(".") && !basePrefix.startsWith(".")) continue;
     if (!entry.name.toLowerCase().startsWith(lower)) continue;
-    if (ignore?.(path15.join(dirAbs, entry.name), isDir)) continue;
+    if (ignore?.(path18.join(dirAbs, entry.name), isDir)) continue;
     matches.push({ path: `${dirPart}${entry.name}${isDir ? "/" : ""}`, isDir });
   }
   matches.sort((a, b) => a.path.localeCompare(b.path));
@@ -2482,6 +3119,95 @@ async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSu
 
 // src/cli/components/InputBox.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function moveCursorLines(value, cursor, delta) {
+  const lineStart = value.lastIndexOf("\n", cursor - 1) + 1;
+  const col = cursor - lineStart;
+  if (delta === -1) {
+    if (lineStart === 0) return null;
+    const prevEnd = lineStart - 1;
+    const prevStart = value.lastIndexOf("\n", prevEnd - 1) + 1;
+    return prevStart + Math.min(col, prevEnd - prevStart);
+  }
+  const lineEndIndex = value.indexOf("\n", cursor);
+  if (lineEndIndex === -1) return null;
+  const nextStart = lineEndIndex + 1;
+  const nextEndIndex = value.indexOf("\n", nextStart);
+  const nextEnd = nextEndIndex === -1 ? value.length : nextEndIndex;
+  return nextStart + Math.min(col, nextEnd - nextStart);
+}
+function findHistoryMatch(history, query, from, step) {
+  const needle = query.toLowerCase();
+  for (let i = from; i >= 0 && i < history.length; i += step) {
+    if ((history[i] ?? "").toLowerCase().includes(needle)) return i;
+  }
+  return null;
+}
+var PASTE_COLLAPSE_MIN_LINES = 10;
+var PASTE_COLLAPSE_MIN_CHARS = 500;
+var PASTE_MERGE_WINDOW_MS = 100;
+var PASTE_MERGE_MIN_CHARS = 32;
+var PASTE_DELIM = "\u200B";
+var PASTE_TOKEN_RE = /\u200B\[pasted #(\d+): \d+ lines?\]\u200B/g;
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+var PARTIAL_BRACKET_RE = /\u001B(?:\[(?:2(?:0(?:[01])?)?)?)?$/;
+function feedBracketedPaste(state, raw) {
+  let stream = state.pending + raw;
+  state.pending = "";
+  if (stream.startsWith("[200~") || stream.startsWith("[201~")) {
+    stream = `\x1B${stream}`;
+  }
+  const segments = [];
+  let buffer = state.buffer;
+  let bracketed = state.active;
+  let i = 0;
+  const pushText = (text) => {
+    const cleaned = text.replaceAll("\x1B", "");
+    if (cleaned.length > 0) segments.push({ type: "text", text: cleaned });
+  };
+  const holdPartial = (tail) => {
+    const partial = PARTIAL_BRACKET_RE.exec(tail);
+    if (!partial) return tail;
+    state.pending = partial[0];
+    return tail.slice(0, tail.length - partial[0].length);
+  };
+  while (i < stream.length) {
+    if (bracketed) {
+      const idx = stream.indexOf(BRACKETED_PASTE_END, i);
+      if (idx === -1) {
+        buffer += holdPartial(stream.slice(i));
+        i = stream.length;
+      } else {
+        buffer += stream.slice(i, idx);
+        segments.push({ type: "paste", text: buffer });
+        buffer = "";
+        bracketed = false;
+        i = idx + BRACKETED_PASTE_END.length;
+      }
+    } else {
+      const idx = stream.indexOf(BRACKETED_PASTE_START, i);
+      if (idx === -1) {
+        pushText(holdPartial(stream.slice(i)));
+        i = stream.length;
+      } else {
+        pushText(stream.slice(i, idx));
+        buffer = "";
+        bracketed = true;
+        i = idx + BRACKETED_PASTE_START.length;
+      }
+    }
+  }
+  state.active = bracketed;
+  state.buffer = buffer;
+  return segments.length === 0 ? null : segments;
+}
+function pasteToken(id, lineCount) {
+  const label = `[pasted #${id}: ${lineCount} ${lineCount === 1 ? "line" : "lines"}]`;
+  return `${PASTE_DELIM}${label}${PASTE_DELIM}`;
+}
+function stylePasteTokens(segment) {
+  return segment.replace(PASTE_TOKEN_RE, (match) => `\x1B[2m${match}\x1B[22m`);
+}
 function InputBox({
   isStreaming,
   disabled,
@@ -2494,28 +3220,126 @@ function InputBox({
   onExit,
   onPasteImage
 }) {
-  const [value, setValue] = useState("");
-  const [cursor, setCursor] = useState(0);
-  const [history, setHistory] = useState(() => initialHistory ?? []);
-  const [highlight, setHighlight] = useState(0);
-  const [suggestionsDismissed, setSuggestionsDismissed] = useState(false);
-  const [pathSuggestions, setPathSuggestions] = useState([]);
-  const historyIndexRef = useRef(null);
-  const draftRef = useRef("");
-  const refillSeqRef = useRef(0);
+  const [value, setValue] = useState2("");
+  const [cursor, setCursor] = useState2(0);
+  const [history, setHistory] = useState2(() => initialHistory ?? []);
+  const [highlight, setHighlight] = useState2(0);
+  const [suggestionsDismissed, setSuggestionsDismissed] = useState2(false);
+  const [pathSuggestions, setPathSuggestions] = useState2([]);
+  const historyIndexRef = useRef2(null);
+  const draftRef = useRef2("");
+  const refillSeqRef = useRef2(0);
+  const [search, setSearch] = useState2(null);
+  const searchSavedRef = useRef2(null);
+  const pastesRef = useRef2(/* @__PURE__ */ new Map());
+  const pasteSeqRef = useRef2(0);
+  const bracketRef = useRef2({ active: false, buffer: "", pending: "" });
+  const lastPasteRef = useRef2(
+    null
+  );
+  const valueRef = useRef2(value);
+  const cursorRef = useRef2(cursor);
+  useEffect(() => {
+    valueRef.current = value;
+    cursorRef.current = cursor;
+  });
+  const { stdout } = useStdout();
+  useEffect(() => {
+    if (!stdout?.isTTY) return;
+    stdout.write("\x1B[?2004h");
+    return () => {
+      stdout.write("\x1B[?2004l");
+    };
+  }, [stdout]);
+  const expandPastes = (raw) => raw.replace(PASTE_TOKEN_RE, (match, id) => pastesRef.current.get(Number(id)) ?? match);
+  const clearPastes = () => {
+    pastesRef.current.clear();
+    pasteSeqRef.current = 0;
+    lastPasteRef.current = null;
+    const bracket = bracketRef.current;
+    bracket.active = false;
+    bracket.buffer = "";
+    bracket.pending = "";
+  };
   const edit = (next, nextCursor) => {
+    const idx = historyIndexRef.current;
+    if (idx !== null && next !== history[idx]) historyIndexRef.current = null;
+    const clamped = Math.max(0, Math.min(nextCursor, next.length));
+    valueRef.current = next;
+    cursorRef.current = clamped;
     setValue(next);
-    setCursor(Math.max(0, Math.min(nextCursor, next.length)));
+    setCursor(clamped);
     setHighlight(0);
     setSuggestionsDismissed(false);
   };
+  const normalizeNewlines = (text) => text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const collapseOrInsert = (text) => {
+    const currentValue = valueRef.current;
+    const currentCursor = cursorRef.current;
+    const lineCount = text.split("\n").length;
+    if (lineCount >= PASTE_COLLAPSE_MIN_LINES || text.length >= PASTE_COLLAPSE_MIN_CHARS) {
+      const id = ++pasteSeqRef.current;
+      pastesRef.current.set(id, text);
+      const token = pasteToken(id, lineCount);
+      const nextCursor = currentCursor + token.length;
+      edit(
+        currentValue.slice(0, currentCursor) + token + currentValue.slice(currentCursor),
+        nextCursor
+      );
+      lastPasteRef.current = { id, token, cursor: nextCursor, time: Date.now() };
+      return;
+    }
+    edit(
+      currentValue.slice(0, currentCursor) + text + currentValue.slice(currentCursor),
+      currentCursor + text.length
+    );
+  };
+  const insertPlainText = (rawText) => {
+    const text = normalizeNewlines(rawText);
+    const currentValue = valueRef.current;
+    const currentCursor = cursorRef.current;
+    const last = lastPasteRef.current;
+    if (last && Date.now() - last.time <= PASTE_MERGE_WINDOW_MS && currentCursor === last.cursor && currentValue.endsWith(last.token, currentCursor) && (text.includes("\n") || text.length >= PASTE_MERGE_MIN_CHARS)) {
+      const merged = (pastesRef.current.get(last.id) ?? "") + text;
+      pastesRef.current.set(last.id, merged);
+      const token = pasteToken(last.id, merged.split("\n").length);
+      const start = currentCursor - last.token.length;
+      const nextCursor = start + token.length;
+      edit(currentValue.slice(0, start) + token + currentValue.slice(currentCursor), nextCursor);
+      lastPasteRef.current = { id: last.id, token, cursor: nextCursor, time: Date.now() };
+      return;
+    }
+    collapseOrInsert(text);
+  };
+  const flushBracketPaste = () => {
+    const bracket = bracketRef.current;
+    const content = bracket.buffer;
+    bracket.active = false;
+    bracket.buffer = "";
+    bracket.pending = "";
+    if (content.length > 0) collapseOrInsert(normalizeNewlines(content));
+  };
+  const applyPasteSegments = (segments) => {
+    if (search) {
+      const query = search.query + normalizeNewlines(segments.map((seg) => seg.text).join(""));
+      setSearch({ query, match: findHistoryMatch(history, query, history.length - 1, -1) });
+      return;
+    }
+    for (const seg of segments) {
+      if (seg.type === "paste") {
+        collapseOrInsert(normalizeNewlines(seg.text));
+      } else {
+        insertPlainText(seg.text);
+      }
+    }
+  };
   useEffect(() => {
     if (refill && refill.seq !== refillSeqRef.current) {
       refillSeqRef.current = refill.seq;
       edit(refill.text, refill.text.length);
     }
   });
-  const suggestionsEnabled = !isStreaming && !disabled && !suggestionsDismissed;
+  const suggestionsEnabled = !isStreaming && !disabled && !suggestionsDismissed && !search;
   const suggestions = suggestionsEnabled && commands ? filterCommands(value, commands) : [];
   useEffect(() => {
     if (!suggestionsEnabled || !cwd) {
@@ -2556,11 +3380,87 @@ function InputBox({
     );
   };
   useInput2((input, key) => {
+    if (!disabled) {
+      const bracket = bracketRef.current;
+      const feedable = input.length > 0 && !key.ctrl && !key.meta;
+      if (bracket.active && (!feedable || input === "\r")) {
+        flushBracketPaste();
+        if (feedable) return;
+      }
+      if (feedable) {
+        const segments = feedBracketedPaste(bracket, input);
+        if (segments === null) return;
+        const only = segments.length === 1 ? segments[0] : void 0;
+        if (!only || only.type !== "text" || only.text !== input) {
+          applyPasteSegments(segments);
+          return;
+        }
+      } else {
+        bracket.pending = "";
+      }
+    }
+    if (key.ctrl && input === "r") {
+      if (isStreaming || disabled) return;
+      if (search) {
+        const from = (search.match ?? history.length) - 1;
+        const older = findHistoryMatch(history, search.query, from, -1);
+        if (older !== null) setSearch({ ...search, match: older });
+      } else {
+        searchSavedRef.current = { value, cursor };
+        setSearch({ query: "", match: history.length > 0 ? history.length - 1 : null });
+      }
+      return;
+    }
+    if (search) {
+      const exitSearch = (accept) => {
+        const saved = searchSavedRef.current;
+        setSearch(null);
+        searchSavedRef.current = null;
+        const match = accept && search.match !== null ? history[search.match] : void 0;
+        if (match !== void 0) {
+          edit(match, match.length);
+        } else if (saved) {
+          edit(saved.value, saved.cursor);
+        }
+      };
+      if (key.escape || key.ctrl && (input === "c" || input === "g")) {
+        exitSearch(false);
+        return;
+      }
+      if (key.return) {
+        exitSearch(true);
+        return;
+      }
+      const requery = (query) => setSearch({ query, match: findHistoryMatch(history, query, history.length - 1, -1) });
+      if (key.backspace || key.delete) {
+        requery(search.query.slice(0, -1));
+        return;
+      }
+      if (key.upArrow) {
+        const from = (search.match ?? history.length) - 1;
+        const older = findHistoryMatch(history, search.query, from, -1);
+        if (older !== null) setSearch({ ...search, match: older });
+        return;
+      }
+      if (key.downArrow) {
+        if (search.match !== null) {
+          const newer = findHistoryMatch(history, search.query, search.match + 1, 1);
+          if (newer !== null) setSearch({ ...search, match: newer });
+        }
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        const text = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        requery(search.query + text);
+      }
+      return;
+    }
     if (key.ctrl && input === "c") {
       if (isStreaming || disabled) {
         onInterrupt();
       } else {
         edit("", 0);
+        clearPastes();
         historyIndexRef.current = null;
       }
       return;
@@ -2579,27 +3479,28 @@ function InputBox({
       return;
     }
     if (key.return) {
-      if (key.shift) {
-        edit(`${value.slice(0, cursor)}
-${value.slice(cursor)}`, cursor + 1);
-        return;
-      }
-      if (value[cursor - 1] === "\\") {
-        edit(`${value.slice(0, cursor - 1)}
-${value.slice(cursor)}`, cursor);
+      const currentValue = valueRef.current;
+      const currentCursor = cursorRef.current;
+      if (currentValue[currentCursor - 1] === "\\") {
+        edit(
+          `${currentValue.slice(0, currentCursor - 1)}
+${currentValue.slice(currentCursor)}`,
+          currentCursor
+        );
         return;
       }
-      const text = value.trim();
+      const text = expandPastes(currentValue).trim();
       if (text.length > 0) {
-        setHistory((prev) => [...prev, text]);
+        if (!text.startsWith("/")) setHistory((prev) => [...prev, text]);
         onSubmit(text);
       }
       edit("", 0);
+      clearPastes();
       historyIndexRef.current = null;
       draftRef.current = "";
       return;
     }
-    if (input === "\n" || input === "\r" || /^\[13;\d+u$/.test(input)) {
+    if (input === "\n" || input === "\r") {
       edit(`${value.slice(0, cursor)}
 ${value.slice(cursor)}`, cursor + 1);
       return;
@@ -2611,34 +3512,47 @@ ${value.slice(cursor)}`, cursor + 1);
         return;
       }
     } else if (key.upArrow) {
+      if (historyIndexRef.current !== null) {
+        if (historyIndexRef.current > 0) {
+          historyIndexRef.current -= 1;
+          const entry2 = history[historyIndexRef.current] ?? "";
+          edit(entry2, entry2.length);
+        }
+        return;
+      }
       if (suggestionCount > 0) {
         setHighlight((prev) => (prev - 1 + suggestionCount) % suggestionCount);
         return;
       }
-      if (history.length === 0) return;
-      if (historyIndexRef.current === null) {
-        draftRef.current = value;
-        historyIndexRef.current = history.length - 1;
-      } else if (historyIndexRef.current > 0) {
-        historyIndexRef.current -= 1;
+      const moved = moveCursorLines(value, cursor, -1);
+      if (moved !== null) {
+        setCursor(moved);
+        return;
       }
+      if (history.length === 0) return;
+      draftRef.current = value;
+      historyIndexRef.current = history.length - 1;
       const entry = history[historyIndexRef.current] ?? "";
       edit(entry, entry.length);
       return;
     } else if (key.downArrow) {
+      if (historyIndexRef.current !== null) {
+        if (historyIndexRef.current < history.length - 1) {
+          historyIndexRef.current += 1;
+          const entry = history[historyIndexRef.current] ?? "";
+          edit(entry, entry.length);
+        } else {
+          historyIndexRef.current = null;
+          edit(draftRef.current, draftRef.current.length);
+        }
+        return;
+      }
       if (suggestionCount > 0) {
         setHighlight((prev) => (prev + 1) % suggestionCount);
         return;
       }
-      if (historyIndexRef.current === null) return;
-      if (historyIndexRef.current < history.length - 1) {
-        historyIndexRef.current += 1;
-        const entry = history[historyIndexRef.current] ?? "";
-        edit(entry, entry.length);
-      } else {
-        historyIndexRef.current = null;
-        edit(draftRef.current, draftRef.current.length);
-      }
+      const moved = moveCursorLines(value, cursor, 1);
+      if (moved !== null) setCursor(moved);
       return;
     } else if (key.leftArrow) {
       setCursor((prev) => Math.max(0, prev - 1));
@@ -2676,20 +3590,29 @@ ${value.slice(cursor)}`, cursor + 1);
     }
     if (key.backspace || key.delete) {
       if (cursor === 0) return;
-      edit(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+      let remove = 1;
+      for (const match of value.matchAll(PASTE_TOKEN_RE)) {
+        if (match.index + match[0].length === cursor) {
+          remove = match[0].length;
+          const id = Number(match[1]);
+          pastesRef.current.delete(id);
+          if (lastPasteRef.current?.id === id) lastPasteRef.current = null;
+          break;
+        }
+      }
+      edit(value.slice(0, cursor - remove) + value.slice(cursor), cursor - remove);
       return;
     }
     if (input && !key.ctrl && !key.meta) {
-      const text = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-      edit(value.slice(0, cursor) + text + value.slice(cursor), cursor + text.length);
+      insertPlainText(input);
     }
   });
   const before = value.slice(0, cursor);
   const at = value[cursor];
   const after = value.slice(cursor + 1);
-  const cursorChar = at === "\n" || at === void 0 ? " " : at;
-  const tail = (at === "\n" ? "\n" : "") + after;
-  const styled = `\x1B[36m> \x1B[39m${before}\x1B[7m${cursorChar}\x1B[27m${tail}`;
+  const cursorChar = at === "\n" || at === void 0 || at === PASTE_DELIM ? " " : at;
+  const tail = (at === "\n" ? "\n" : "") + stylePasteTokens(after);
+  const styled = search ? `\x1B[36m(reverse-search) \x1B[39m'${search.query}': ${search.match === null ? "\x1B[2mno match\x1B[22m\x1B[7m \x1B[27m" : `${history[search.match]}\x1B[7m \x1B[27m`}` : `\x1B[36m> \x1B[39m${stylePasteTokens(before)}\x1B[7m${cursorChar}\x1B[27m${tail}`;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { children: styled }) }),
     suggestions.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: suggestions.map((cmd, index) => {
@@ -2708,175 +3631,422 @@ ${value.slice(cursor)}`, cursor + 1);
   ] });
 }
 
+// src/cli/components/TextField.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var MASK_CAP = 24;
+function TextField({
+  label,
+  initialValue = "",
+  masked = false,
+  placeholder,
+  onSubmit,
+  onCancel
+}) {
+  const [value, setValue] = useState3(initialValue);
+  const valueRef = useRef3(initialValue);
+  const bracketRef = useRef3({ active: false, buffer: "", pending: "" });
+  const flushBracket = () => {
+    const bracket = bracketRef.current;
+    const content = bracket.buffer.replace(/[\r\n]+/g, "");
+    bracket.active = false;
+    bracket.buffer = "";
+    bracket.pending = "";
+    if (content.length > 0) {
+      valueRef.current += content;
+      setValue(valueRef.current);
+    }
+  };
+  useInput3((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      flushBracket();
+      onSubmit(valueRef.current.trim());
+      return;
+    }
+    if (key.backspace || key.delete) {
+      flushBracket();
+      valueRef.current = valueRef.current.slice(0, -1);
+      setValue(valueRef.current);
+      return;
+    }
+    if (key.ctrl || key.meta || !input) return;
+    const segments = feedBracketedPaste(bracketRef.current, input);
+    if (segments === null) return;
+    const text = segments.map((segment) => segment.text).join("").replace(/[\r\n]+/g, "");
+    if (text.length === 0) return;
+    valueRef.current += text;
+    setValue(valueRef.current);
+  });
+  const echo = masked ? "\u2022".repeat(Math.min(value.length, MASK_CAP)) : value;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      label,
+      " ",
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: echo }),
+      value === "" && placeholder ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: placeholder }) : null
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "[Enter] confirm [Esc] cancel" })
+  ] });
+}
+
+// src/cli/components/ConnectWizard.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function YN({ question, onAnswer }) {
+  useInput4((input, key) => {
+    const ch = input.toLowerCase();
+    if (ch === "y") onAnswer(true);
+    else if (ch === "n" || key.escape) onAnswer(false);
+  });
+  return /* @__PURE__ */ jsxs4(Text4, { children: [
+    question,
+    " ",
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "[y] yes [n] no" })
+  ] });
+}
+function ConnectWizard({
+  existingProviderNames,
+  existingModelNames,
+  onSave,
+  onSetDefault,
+  onOpenConfig,
+  onFinish,
+  onCancel
+}) {
+  const [step, setStep] = useState4("provider");
+  const [preset, setPreset] = useState4(null);
+  const [protocol, setProtocol] = useState4("openai-compatible");
+  const [baseURL, setBaseURL] = useState4("");
+  const [apiKey, setApiKey] = useState4("");
+  const [modelId, setModelId] = useState4("");
+  const [answers, setAnswers] = useState4(null);
+  const [error, setError] = useState4(null);
+  const [busy, setBusy] = useState4(false);
+  const [notes, setNotes] = useState4([]);
+  const busyRef = useRef4(false);
+  const notesRef = useRef4([]);
+  const pushNote = (note) => {
+    notesRef.current = [...notesRef.current, note];
+    setNotes(notesRef.current);
+  };
+  const providerOptions = [
+    ...PROVIDER_PRESETS.map((p) => ({ value: p.key, label: p.label, description: p.baseURL })),
+    {
+      value: "custom",
+      label: "Custom",
+      description: "any OpenAI/Anthropic-compatible endpoint"
+    }
+  ];
+  const handleProviderSelect = (value) => {
+    const found = PROVIDER_PRESETS.find((p) => p.key === value) ?? null;
+    setPreset(found);
+    if (found) {
+      setProtocol(found.protocol);
+      setBaseURL(found.baseURL);
+      setStep("baseUrl");
+    } else {
+      setStep("protocol");
+    }
+  };
+  const handleProtocolSelect = (value) => {
+    setProtocol(value);
+    setStep("baseUrl");
+  };
+  const submitBaseURL = (value) => {
+    if (!value) {
+      setError("baseURL is required");
+      return;
+    }
+    setError(null);
+    setBaseURL(value);
+    setStep("apiKey");
+  };
+  const submitApiKey = (value) => {
+    if (!value) {
+      setError("API key is required");
+      return;
+    }
+    setError(null);
+    setApiKey(value);
+    setStep("model");
+  };
+  const submitModel = (value) => {
+    if (!value) {
+      setError("model id is required");
+      return;
+    }
+    setError(null);
+    setModelId(value);
+    const providerName = dedupeName(deriveProviderName(baseURL), existingProviderNames);
+    setAnswers({
+      providerName,
+      protocol,
+      baseURL,
+      apiKeyEnv: apiKeyEnvFor(providerName),
+      apiKey,
+      modelName: dedupeName(value, existingModelNames),
+      modelId: value
+    });
+    setStep("confirm");
+  };
+  const handleConfirm = async (yes) => {
+    if (!yes) {
+      onCancel();
+      return;
+    }
+    if (busyRef.current || !answers) return;
+    busyRef.current = true;
+    setBusy(true);
+    try {
+      pushNote(await onSave(answers));
+    } catch (saveError) {
+      busyRef.current = false;
+      setBusy(false);
+      setError(
+        `Save failed: ${saveError instanceof Error ? saveError.message : String(saveError)}`
+      );
+      return;
+    }
+    busyRef.current = false;
+    setBusy(false);
+    setStep("setDefault");
+  };
+  const handleSetDefault = async (yes) => {
+    if (busyRef.current || !answers) return;
+    busyRef.current = true;
+    setBusy(true);
+    try {
+      pushNote(yes ? await onSetDefault(answers.modelName) : "Default model unchanged.");
+    } catch (setDefaultError) {
+      pushNote(
+        `Could not set the default model: ${setDefaultError instanceof Error ? setDefaultError.message : String(setDefaultError)}`
+      );
+    }
+    busyRef.current = false;
+    setBusy(false);
+    setStep("openFile");
+  };
+  const handleOpenFile = (yes) => {
+    if (yes) pushNote(onOpenConfig());
+    onFinish(notesRef.current.join("\n"));
+  };
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Connect a provider" }),
+    notes.map((note, index) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: notes are append-only
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: note }, index)
+    )),
+    step === "provider" && /* @__PURE__ */ jsx4(
+      SelectPrompt,
+      {
+        title: "Which provider?",
+        options: providerOptions,
+        onSelect: handleProviderSelect,
+        onCancel
+      }
+    ),
+    step === "protocol" && /* @__PURE__ */ jsx4(
+      SelectPrompt,
+      {
+        title: "API format (protocol)?",
+        options: PROTOCOLS.map((p) => ({
+          value: p,
+          label: p,
+          description: PROTOCOL_DESCRIPTIONS[p]
+        })),
+        onSelect: handleProtocolSelect,
+        onCancel
+      }
+    ),
+    step === "baseUrl" && /* @__PURE__ */ jsx4(
+      TextField,
+      {
+        label: "baseURL:",
+        initialValue: preset?.baseURL ?? "",
+        placeholder: "https://api.example.com/v1",
+        onSubmit: submitBaseURL,
+        onCancel
+      }
+    ),
+    step === "apiKey" && /* @__PURE__ */ jsx4(
+      TextField,
+      {
+        label: "API key:",
+        masked: true,
+        placeholder: "paste your key (hidden)",
+        onSubmit: submitApiKey,
+        onCancel
+      }
+    ),
+    step === "model" && /* @__PURE__ */ jsx4(
+      TextField,
+      {
+        label: "Model id:",
+        placeholder: preset?.modelHint ?? "e.g. gpt-4o",
+        onSubmit: submitModel,
+        onCancel
+      }
+    ),
+    step === "confirm" && answers && /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { children: `  provider:  ${answers.providerName} (${answers.protocol})` }),
+      /* @__PURE__ */ jsx4(Text4, { children: `  baseURL:   ${answers.baseURL}` }),
+      /* @__PURE__ */ jsx4(Text4, { children: `  API key:   ${maskApiKey(answers.apiKey)} \u2192 ${answers.apiKeyEnv} (stored in ~/.star-cli/.env)` }),
+      /* @__PURE__ */ jsx4(Text4, { children: `  model:     ${answers.modelName} \u2192 ${answers.modelId}` }),
+      busy ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Saving\u2026" }) : /* @__PURE__ */ jsx4(YN, { question: "Save this provider and model?", onAnswer: handleConfirm })
+    ] }),
+    step === "setDefault" && (busy ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Saving\u2026" }) : /* @__PURE__ */ jsx4(
+      YN,
+      {
+        question: `Set "${answers?.modelName}" as the default model and switch to it?`,
+        onAnswer: handleSetDefault
+      }
+    )),
+    step === "openFile" && /* @__PURE__ */ jsx4(YN, { question: "Open the config file now?", onAnswer: handleOpenFile }),
+    error && /* @__PURE__ */ jsx4(Text4, { color: "red", children: error })
+  ] });
+}
+
+// src/cli/components/ExitPlanPrompt.tsx
+import { Box as Box5, Text as Text5, useInput as useInput5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ExitPlanPrompt({ onDecision }) {
+  useInput5((input, key) => {
+    const ch = input.toLowerCase();
+    if (ch === "y") onDecision("yes");
+    else if (ch === "n" || key.escape) onDecision("no");
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "Plan ready (plan mode)" }),
+    /* @__PURE__ */ jsx5(Text5, { children: "The plan above was produced without making any changes." }),
+    /* @__PURE__ */ jsx5(Text5, { children: "[y] approve and execute [n] keep refining (Esc = n)" })
+  ] });
+}
+
 // src/cli/components/MessageList.tsx
-import { Box as Box3, Static, Text as Text4 } from "ink";
+import { Box as Box6, Static, Text as Text7 } from "ink";
 import { memo } from "react";
 
 // src/cli/components/DiffLines.tsx
-import { Text as Text3 } from "ink";
-import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Text as Text6 } from "ink";
+import { Fragment, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function DiffLineView({ line }) {
-  if (line.kind === "add") return /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+  if (line.kind === "add") return /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
     "+ ",
     line.text
   ] });
-  if (line.kind === "del") return /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+  if (line.kind === "del") return /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
     "- ",
     line.text
   ] });
-  if (line.kind === "marker") return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: line.text });
-  return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+  if (line.kind === "marker") return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: line.text });
+  return /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
     " ",
     line.text
   ] });
 }
 function DiffLines({ lines }) {
-  return /* @__PURE__ */ jsx3(Fragment, { children: lines.map((line, index) => (
+  return /* @__PURE__ */ jsx6(Fragment, { children: lines.map((line, index) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: diff lines have no stable identity
-    /* @__PURE__ */ jsx3(DiffLineView, { line }, index)
+    /* @__PURE__ */ jsx6(DiffLineView, { line }, index)
   )) });
 }
 
 // src/cli/components/MessageList.tsx
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 var roleStyles = {
   user: { label: "you", color: "cyan" },
   assistant: { label: "star", color: "green" },
   system: { label: "system", color: "yellow" },
   tool: { label: "tool", color: "magenta" }
 };
+var interruptedMarker = (text) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: text.length > 0 ? " [interrupted]" : "[interrupted]" });
 var MessageList = memo(function MessageList2({ messages }) {
-  return /* @__PURE__ */ jsx4(Static, { items: messages, children: (message) => {
+  return /* @__PURE__ */ jsx7(Static, { items: messages, children: (message) => {
     const marginBottom = message.tight ? 0 : 1;
     if (message.role === "assistant-cont") {
-      return /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", marginBottom, children: /* @__PURE__ */ jsx4(Text4, { color: "green", children: message.text }) }, message.id);
+      return /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", marginBottom, children: /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+        message.text,
+        message.interrupted && interruptedMarker(message.text)
+      ] }) }, message.id);
     }
     const style = roleStyles[message.role];
-    return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginBottom, children: [
-      /* @__PURE__ */ jsx4(Text4, { bold: true, color: style.color, children: style.label }),
-      /* @__PURE__ */ jsx4(Text4, { color: style.color, children: message.text }),
-      message.diff && /* @__PURE__ */ jsx4(DiffLines, { lines: message.diff }),
-      message.note && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: message.note })
+    return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", marginBottom, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: style.color, children: style.label }),
+      /* @__PURE__ */ jsxs7(Text7, { color: style.color, children: [
+        message.text,
+        message.interrupted && interruptedMarker(message.text)
+      ] }),
+      message.diff && /* @__PURE__ */ jsx7(DiffLines, { lines: message.diff }),
+      message.note && /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: message.note })
     ] }, message.id);
   } });
 });
 
 // src/cli/components/PermissionPrompt.tsx
-import { Box as Box4, Text as Text5, useInput as useInput3 } from "ink";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text8, useInput as useInput6 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 function PermissionPrompt({ request, preview, onDecision }) {
-  useInput3((input) => {
+  useInput6((input) => {
     const ch = input.toLowerCase();
     if (ch === "y") onDecision("yes");
     else if (ch === "n") onDecision("no");
     else if (ch === "a") onDecision("always");
   });
-  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "yellow", children: [
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs8(Text8, { bold: true, color: "yellow", children: [
       "Permission required: ",
       request.toolName,
       " (",
       request.level,
       ")"
     ] }),
-    preview ? /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+    preview ? /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
         preview.type === "new-file" ? "New file: " : "",
         preview.label
       ] }),
-      /* @__PURE__ */ jsx5(DiffLines, { lines: preview.lines })
-    ] }) : /* @__PURE__ */ jsx5(Text5, { children: summarizeArgs(request.args) }),
-    /* @__PURE__ */ jsx5(Text5, { children: "[y] allow [n] deny [a] always (saved to config)" })
+      /* @__PURE__ */ jsx8(DiffLines, { lines: preview.lines })
+    ] }) : /* @__PURE__ */ jsx8(Text8, { children: summarizeArgs(request.args) }),
+    /* @__PURE__ */ jsx8(Text8, { children: "[y] allow [n] deny [a] always (saved to config)" })
   ] });
 }
 
 // src/cli/components/RewindConfirmPrompt.tsx
-import { Box as Box5, Text as Text6, useInput as useInput4 } from "ink";
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
-function RewindConfirmPrompt({ summary, onDecision }) {
-  useInput4((input, key) => {
+import { Box as Box8, Text as Text9, useInput as useInput7 } from "ink";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function RewindConfirmPrompt({
+  summary,
+  title = "Rewind checkpoints",
+  confirmLabel = "rewind",
+  diffs,
+  onDecision
+}) {
+  useInput7((input, key) => {
     const ch = input.toLowerCase();
     if (ch === "y") onDecision("yes");
     else if (ch === "n" || key.escape) onDecision("no");
   });
-  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx6(Text6, { bold: true, color: "yellow", children: "Rewind checkpoints" }),
-    /* @__PURE__ */ jsx6(Text6, { children: summary }),
-    /* @__PURE__ */ jsx6(Text6, { children: "[y] rewind [n] cancel (Esc = n)" })
-  ] });
-}
-
-// src/cli/components/SelectPrompt.tsx
-import { Box as Box6, Text as Text7, useInput as useInput5 } from "ink";
-import { useRef as useRef2, useState as useState2 } from "react";
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-var SELECT_PROMPT_MAX_VISIBLE = 9;
-function SelectPrompt({ title, options, onSelect, onCancel }) {
-  const [index, setIndex] = useState2(0);
-  const indexRef = useRef2(0);
-  const move = (delta) => {
-    indexRef.current = Math.max(0, Math.min(indexRef.current + delta, options.length - 1));
-    setIndex(indexRef.current);
-  };
-  useInput5((input, key) => {
-    if (key.escape) {
-      onCancel();
-      return;
-    }
-    if (key.return) {
-      const option = options[indexRef.current];
-      if (option) onSelect(option.value);
-      return;
-    }
-    if (key.downArrow || input === "j") {
-      move(1);
-    } else if (key.upArrow || input === "k") {
-      move(-1);
-    }
-  });
-  const maxStart = Math.max(0, options.length - SELECT_PROMPT_MAX_VISIBLE);
-  const start = Math.min(Math.max(0, index - Math.floor(SELECT_PROMPT_MAX_VISIBLE / 2)), maxStart);
-  const visible = options.slice(start, start + SELECT_PROMPT_MAX_VISIBLE);
-  const above = start;
-  const below = options.length - start - visible.length;
-  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
-    /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: title }),
-    above > 0 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-      "\u2026 ",
-      above,
-      " more above"
-    ] }),
-    visible.map((option, i) => {
-      const active = start + i === index;
-      return /* @__PURE__ */ jsxs7(Text7, { children: [
-        /* @__PURE__ */ jsxs7(Text7, { bold: active, inverse: active, children: [
-          active ? "\u276F " : "  ",
-          option.label
-        ] }),
-        option.hint && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-          " (",
-          option.hint,
-          ")"
-        ] }),
-        option.description && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-          " \u2014 ",
-          option.description
-        ] })
-      ] }, option.value);
-    }),
-    below > 0 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-      "\u2026 ",
-      below,
-      " more below"
-    ] }),
-    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "[\u2191/\u2193 or j/k] move [Enter] select [Esc] cancel" })
+  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx9(Text9, { bold: true, color: "yellow", children: title }),
+    /* @__PURE__ */ jsx9(Text9, { children: summary }),
+    diffs?.map((diff) => /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: diff.label }),
+      /* @__PURE__ */ jsx9(DiffLines, { lines: diff.lines })
+    ] }, diff.label)),
+    /* @__PURE__ */ jsxs9(Text9, { children: [
+      "[y] ",
+      confirmLabel,
+      " [n] cancel (Esc = n)"
+    ] })
   ] });
 }
 
 // src/cli/components/StatusBar.tsx
-import { Box as Box7, Text as Text8, useStdout } from "ink";
+import { Box as Box9, Text as Text10, useStdout as useStdout2 } from "ink";
 import { memo as memo2 } from "react";
-import { jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsxs as jsxs10 } from "react/jsx-runtime";
 var BG_LABEL_MAX = 40;
 var WIDE_COLUMNS = 120;
 function cwdLabel(cwd, wide) {
@@ -2891,43 +4061,48 @@ var StatusBar = memo2(function StatusBar2({
   tokens: tokens2,
   gitBranch,
   contextPercent,
+  cachePercent,
   sessionCostUsd,
   backgroundTasks = []
 }) {
-  const { stdout } = useStdout();
+  const { stdout } = useStdout2();
   const wide = (stdout?.columns ?? 80) >= WIDE_COLUMNS;
   const joined = backgroundTasks.join(", ");
   const labels = joined.length > BG_LABEL_MAX ? `${joined.slice(0, BG_LABEL_MAX)}\u2026` : joined;
-  return /* @__PURE__ */ jsxs8(Box7, { justifyContent: "space-between", children: [
-    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs10(Box9, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       cwdLabel(cwd, wide),
       gitBranch ? ` [${gitBranch}]` : ""
     ] }),
-    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs10(Text10, { color: "yellow", children: [
       "bg: ",
       backgroundTasks.length,
       " (",
       labels,
       ")"
     ] }),
-    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       "model: ",
       model
     ] }),
-    contextPercent != null && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+    contextPercent != null && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       "ctx: ",
       contextPercent,
       "%"
     ] }),
-    sessionCostUsd != null && sessionCostUsd > 0 && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      "cache: ",
+      cachePercent != null ? `${cachePercent}%` : "Not provided"
+    ] }),
+    sessionCostUsd != null && sessionCostUsd > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       "$",
       formatDollars(sessionCostUsd)
     ] }),
-    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       tokens2,
       " tokens"
     ] }),
-    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       "mode: ",
       permissionMode
     ] })
@@ -2935,22 +4110,22 @@ var StatusBar = memo2(function StatusBar2({
 });
 
 // src/cli/components/StreamingMessage.tsx
-import { Box as Box8, Text as Text9 } from "ink";
+import { Box as Box10, Text as Text11 } from "ink";
 import { memo as memo3 } from "react";
-import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs11 } from "react/jsx-runtime";
 var StreamingMessage = memo3(function StreamingMessage2({
   text,
   continuation
 }) {
-  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", marginBottom: 1, children: [
-    !continuation && /* @__PURE__ */ jsx8(Text9, { bold: true, color: "green", children: "star" }),
-    /* @__PURE__ */ jsx8(Text9, { color: "green", children: text })
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", marginBottom: 1, children: [
+    !continuation && /* @__PURE__ */ jsx10(Text11, { bold: true, color: "green", children: "star" }),
+    /* @__PURE__ */ jsx10(Text11, { color: "green", children: text })
   ] });
 });
 
 // src/cli/components/ThinkingIndicator.tsx
-import { Box as Box9, Text as Text10 } from "ink";
-import { jsxs as jsxs10 } from "react/jsx-runtime";
+import { Box as Box11, Text as Text12 } from "ink";
+import { jsxs as jsxs12 } from "react/jsx-runtime";
 var SPINNER_FRAMES = ["-", "\\", "|", "/"];
 var REASONING_TAIL_LENGTH = 200;
 var THOUGHT_SUMMARY_LENGTH = 100;
@@ -2966,13 +4141,13 @@ function ThinkingIndicator({
 }) {
   const tail = reasoning ? truncateTail(reasoning, REASONING_TAIL_LENGTH) : "";
   const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
       spinner,
       " ",
       activity ?? "star is thinking\u2026"
     ] }),
-    tail !== "" && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+    tail !== "" && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
       " ",
       tail
     ] })
@@ -2980,35 +4155,71 @@ function ThinkingIndicator({
 }
 
 // src/cli/components/TodoPanel.tsx
-import { Box as Box10, Text as Text11 } from "ink";
-import { jsx as jsx9, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Box as Box12, Text as Text13 } from "ink";
+
+// src/cli/terminal-text.ts
+var UNSAFE_CHARS = /[\x00-\x09\x0b-\x1f\x7f]/;
+var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f]/g;
+var TABS = /\t/g;
+function toTerminalSafe(text) {
+  if (!UNSAFE_CHARS.test(text)) return text;
+  return text.replace(TABS, "  ").replace(CONTROL_CHARS, "");
+}
+
+// src/cli/components/TodoPanel.tsx
+import { jsxs as jsxs13 } from "react/jsx-runtime";
 var SYMBOLS = {
   pending: "[ ]",
   in_progress: "[~]",
   done: "[x]"
 };
+var MAX_VISIBLE_TODOS = 10;
+function visibleTodoWindow(todos, max = MAX_VISIBLE_TODOS) {
+  if (todos.length <= max) return { items: [...todos], hiddenBefore: 0, hiddenAfter: 0 };
+  const active = todos.findIndex((todo) => todo.status === "in_progress");
+  const start = active > 0 ? Math.min(active, todos.length - max) : 0;
+  const items = todos.slice(start, start + max);
+  return {
+    items,
+    hiddenBefore: start,
+    hiddenAfter: todos.length - start - items.length
+  };
+}
 function TodoPanel({ todos }) {
   if (todos.length === 0) return null;
-  return /* @__PURE__ */ jsx9(Box10, { flexDirection: "column", children: todos.map((todo) => /* @__PURE__ */ jsxs11(
-    Text11,
-    {
-      dimColor: todo.status === "done",
-      color: todo.status === "in_progress" ? "cyan" : void 0,
-      children: [
-        SYMBOLS[todo.status],
-        " ",
-        todo.title
-      ]
-    },
-    todo.id
-  )) });
+  const { items, hiddenBefore, hiddenAfter } = visibleTodoWindow(todos);
+  return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+    hiddenBefore > 0 && /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      " \u2026 ",
+      hiddenBefore,
+      " more above"
+    ] }),
+    items.map((todo) => /* @__PURE__ */ jsxs13(
+      Text13,
+      {
+        dimColor: todo.status === "done",
+        color: todo.status === "in_progress" ? "cyan" : void 0,
+        children: [
+          SYMBOLS[todo.status],
+          " ",
+          toTerminalSafe(todo.title)
+        ]
+      },
+      todo.id
+    )),
+    hiddenAfter > 0 && /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      " \u2026 ",
+      hiddenAfter,
+      " more"
+    ] })
+  ] });
 }
 
 // src/cli/components/ToolCallCard.tsx
 function formatToolCard(card) {
   const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
   if (card.result === void 0) return header;
-  const preview = previewLines(card.result, 10);
+  const preview = previewLines(toTerminalSafe(card.result), 10);
   return `${header}
 ${preview.text}${preview.truncated ? "\n... (truncated)" : ""}`;
 }
@@ -3020,28 +4231,44 @@ function isDoubleEscape(previous, now, windowMs = DOUBLE_ESC_WINDOW_MS) {
 }
 
 // src/cli/history.ts
-import fs10 from "fs";
-import path16 from "path";
-var DEFAULT_LIMIT = 500;
-var MAX_FILE_LINES = 1e3;
-var TRIM_TO_LINES = 500;
+import fs12 from "fs";
+import path19 from "path";
+var HISTORY_LIMIT = 50;
+var JUNK_ENTRY_PATTERN = /^(.)\1{19,}$/;
 function historyPath() {
-  return path16.join(starHome(), "history");
+  return path19.join(starHome(), "history");
 }
 function readLines(file) {
-  const raw = fs10.readFileSync(file, "utf8");
+  const raw = fs12.readFileSync(file, "utf8");
   return raw.split("\n").map((line) => line.replace(/\r$/, "")).filter((line) => line.trim().length > 0);
 }
-function loadHistory(limit = DEFAULT_LIMIT) {
+function writeHistory(file, lines) {
+  fs12.mkdirSync(path19.dirname(file), { recursive: true });
+  fs12.writeFileSync(file, `${lines.join("\n")}
+`);
+}
+function isJunkHistoryEntry(line) {
+  return JUNK_ENTRY_PATTERN.test(line);
+}
+function isSkippableEntry(line) {
+  return isJunkHistoryEntry(line) || line.startsWith("/");
+}
+function loadHistory(limit = HISTORY_LIMIT) {
   try {
-    return readLines(historyPath()).slice(-limit);
+    const file = historyPath();
+    const lines = readLines(file);
+    const clean = lines.filter((line) => !isSkippableEntry(line));
+    if (clean.length !== lines.length || clean.length > HISTORY_LIMIT) {
+      writeHistory(file, clean.slice(-HISTORY_LIMIT));
+    }
+    return clean.slice(-limit);
   } catch {
     return [];
   }
 }
 function appendHistory(entry) {
   const line = entry.replace(/[\r\n]+/g, " ").trim();
-  if (line.length === 0) return;
+  if (line.length === 0 || isSkippableEntry(line)) return;
   try {
     const file = historyPath();
     let existing = [];
@@ -3050,15 +4277,12 @@ function appendHistory(entry) {
     } catch {
     }
     if (existing[existing.length - 1] === line) return;
-    if (existing.length >= MAX_FILE_LINES) {
-      const kept = [...existing.slice(-(TRIM_TO_LINES - 1)), line];
-      fs10.mkdirSync(path16.dirname(file), { recursive: true });
-      fs10.writeFileSync(file, `${kept.join("\n")}
-`);
+    if (existing.length >= HISTORY_LIMIT) {
+      writeHistory(file, [...existing.slice(-(HISTORY_LIMIT - 1)), line]);
       return;
     }
-    fs10.mkdirSync(path16.dirname(file), { recursive: true });
-    fs10.appendFileSync(file, `${line}
+    fs12.mkdirSync(path19.dirname(file), { recursive: true });
+    fs12.appendFileSync(file, `${line}
 `);
   } catch {
   }
@@ -3179,7 +4403,7 @@ async function checkForUpdate(currentVersion, fetcher = defaultFetcher2) {
 }
 
 // src/cli/repl.tsx
-import { jsx as jsx10, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs14 } from "react/jsx-runtime";
 var CLEAR_TERMINAL = process.platform === "win32" ? "\x1B[2J\x1B[0f" : "\x1B[2J\x1B[3J\x1B[H";
 function emptyUsage() {
   return { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 };
@@ -3194,6 +4418,7 @@ function formatUsage(usage) {
   return `API usage this session: ${usage.requests} requests, ${usage.promptTokens} prompt + ${usage.completionTokens} completion = ${usage.totalTokens} tokens`;
 }
 var SESSION_PICKER_CAP = 20;
+var MAX_VISIBLE_QUEUED = 5;
 async function sessionPreview(id) {
   const store = await SessionStore.open(id);
   if (!store) return null;
@@ -3214,65 +4439,67 @@ function Repl({
   initialUsage
 }) {
   const { exit } = useApp();
-  const [initialDisplay] = useState3(() => buildDisplayMessages(initialMessages ?? []));
-  const [messages, setMessages] = useState3(initialDisplay);
-  const [epoch, setEpoch] = useState3(0);
-  const [streamingText, setStreamingText] = useState3(null);
-  const [isStreaming, setIsStreaming] = useState3(false);
-  const [thinking, setThinking] = useState3(false);
-  const [thinkingText, setThinkingText] = useState3("");
-  const [thoughtSummary, setThoughtSummary] = useState3(null);
-  const [, setUsageVersion] = useState3(0);
-  const [modelName, setModelName] = useState3(model);
-  const [pending, setPending] = useState3(null);
-  const [spinnerTick, setSpinnerTick] = useState3(0);
-  const [activity, setActivity] = useState3(null);
-  const [bgLabels, setBgLabels] = useState3(() => runningTaskLabels());
-  const [todos, setTodos] = useState3([]);
-  const [permissionModeState, setPermissionModeState] = useState3(permissionMode);
-  const [planApproval, setPlanApprovalState] = useState3(false);
-  const [pendingRewind, setPendingRewindState] = useState3(null);
-  const [picker, setPickerState] = useState3(null);
-  const backendRef = useRef3(backend);
-  const nextIdRef = useRef3(initialDisplay.length);
-  const abortRef = useRef3(null);
-  const streamedRef = useRef3("");
-  const thinkingRef = useRef3(false);
-  const reasoningRef = useRef3("");
-  const tickerStopRef = useRef3(null);
-  const flushedRef = useRef3({ streamed: "", reasoning: "" });
-  const toolCardsRef = useRef3(/* @__PURE__ */ new Map());
-  const pendingRef = useRef3(null);
-  const alwaysAllowedRef = useRef3(/* @__PURE__ */ new Set());
-  const prevModeRef = useRef3(null);
-  const planApprovalRef = useRef3(false);
-  const pendingRewindRef = useRef3(null);
-  const pickerRef = useRef3(null);
-  const modelNameRef = useRef3(model);
-  const sessionStoreRef = useRef3(sessionStore);
-  const usageRef = useRef3(initialUsage ? { ...initialUsage } : emptyUsage());
-  const turnChunksRef = useRef3(0);
-  const messagesRef = useRef3(initialDisplay);
-  const [queueItems, setQueueItems] = useState3([]);
-  const queueRef = useRef3(new PromptQueue());
-  const [pendingImages, setPendingImages] = useState3([]);
-  const pendingImagesRef = useRef3([]);
-  const imageSeqRef = useRef3(1);
-  const [inputRefill, setInputRefill] = useState3();
-  const refillSeqRef = useRef3(0);
-  const lastEscRef = useRef3(null);
-  const [gitBranch, setGitBranch] = useState3(null);
-  const [contextPercent, setContextPercent] = useState3(null);
-  const [initialHistory] = useState3(() => loadHistory());
-  const budgetWarnedRef = useRef3(false);
-  const budgetExceededRef = useRef3(false);
-  const runStreamRef = useRef3(
+  const [initialDisplay] = useState5(() => buildDisplayMessages(initialMessages ?? []));
+  const [messages, setMessages] = useState5(initialDisplay);
+  const [epoch, setEpoch] = useState5(0);
+  const [streamingText, setStreamingText] = useState5(null);
+  const [isStreaming, setIsStreaming] = useState5(false);
+  const [thinking, setThinking] = useState5(false);
+  const [thinkingText, setThinkingText] = useState5("");
+  const [thoughtSummary, setThoughtSummary] = useState5(null);
+  const [, setUsageVersion] = useState5(0);
+  const [modelName, setModelName] = useState5(model);
+  const [pending, setPending] = useState5(null);
+  const [spinnerTick, setSpinnerTick] = useState5(0);
+  const [activity, setActivity] = useState5(null);
+  const [bgLabels, setBgLabels] = useState5(() => runningTaskLabels());
+  const [todos, setTodos] = useState5([]);
+  const [permissionModeState, setPermissionModeState] = useState5(permissionMode);
+  const [planApproval, setPlanApprovalState] = useState5(false);
+  const [pendingRewind, setPendingRewindState] = useState5(null);
+  const [picker, setPickerState] = useState5(null);
+  const [pendingConnect, setPendingConnectState] = useState5(null);
+  const backendRef = useRef5(backend);
+  const nextIdRef = useRef5(initialDisplay.length);
+  const abortRef = useRef5(null);
+  const streamedRef = useRef5("");
+  const thinkingRef = useRef5(false);
+  const reasoningRef = useRef5("");
+  const tickerStopRef = useRef5(null);
+  const flushedRef = useRef5({ streamed: "", reasoning: "" });
+  const toolCardsRef = useRef5(/* @__PURE__ */ new Map());
+  const pendingRef = useRef5(null);
+  const alwaysAllowedRef = useRef5(/* @__PURE__ */ new Set());
+  const prevModeRef = useRef5(null);
+  const planApprovalRef = useRef5(false);
+  const pendingRewindRef = useRef5(null);
+  const pickerRef = useRef5(null);
+  const pendingConnectRef = useRef5(null);
+  const modelNameRef = useRef5(model);
+  const sessionStoreRef = useRef5(sessionStore);
+  const usageRef = useRef5(initialUsage ? { ...initialUsage } : emptyUsage());
+  const turnChunksRef = useRef5(0);
+  const messagesRef = useRef5(initialDisplay);
+  const [queueItems, setQueueItems] = useState5([]);
+  const queueRef = useRef5(new PromptQueue());
+  const [pendingImages, setPendingImages] = useState5([]);
+  const pendingImagesRef = useRef5([]);
+  const imageSeqRef = useRef5(1);
+  const [inputRefill, setInputRefill] = useState5();
+  const refillSeqRef = useRef5(0);
+  const lastEscRef = useRef5(null);
+  const [gitBranch, setGitBranch] = useState5(null);
+  const [contextPercent, setContextPercent] = useState5(null);
+  const [initialHistory] = useState5(() => loadHistory());
+  const budgetWarnedRef = useRef5(false);
+  const budgetExceededRef = useRef5(false);
+  const runStreamRef = useRef5(
     null
   );
   const pushMessage = useCallback(
-    (role, text, note, tight) => {
+    (role, text, note, tight, interrupted) => {
       setMessages((prev) => {
-        const next = [...prev, { id: nextIdRef.current++, role, text, note, tight }];
+        const next = [...prev, { id: nextIdRef.current++, role, text, note, tight, interrupted }];
         messagesRef.current = next;
         return next;
       });
@@ -3294,10 +4521,10 @@ function Repl({
     [applyMessages]
   );
   const pushAssistantChunk = useCallback(
-    (text, tight) => {
+    (text, tight, interrupted = false) => {
       const role = turnChunksRef.current === 0 ? "assistant" : "assistant-cont";
       turnChunksRef.current += 1;
-      pushMessage(role, text, void 0, tight);
+      pushMessage(role, text, void 0, tight, interrupted);
     },
     [pushMessage]
   );
@@ -3317,6 +4544,10 @@ function Repl({
     pickerRef.current = p;
     setPickerState(p);
   }, []);
+  const setPendingConnect = useCallback((p) => {
+    pendingConnectRef.current = p;
+    setPendingConnectState(p);
+  }, []);
   const showPicker = useCallback(
     (title, options) => {
       if (pickerRef.current) return Promise.resolve(null);
@@ -3360,10 +4591,17 @@ function Repl({
     [config]
   );
   const handlePasteImage = useCallback(() => {
-    void readClipboardImage().then((img) => {
-      if (img) stageClipboardImage(img);
+    void readClipboardImage().then((result) => {
+      if (!result) return;
+      if (result.oversized) {
+        pushMessage(
+          "system",
+          `Image exceeds ${MAX_IMAGE_DIMENSION}px on its longest side and could not be resized automatically; the model may reject it.`
+        );
+      }
+      stageClipboardImage(result.image);
     });
-  }, [stageClipboardImage]);
+  }, [stageClipboardImage, pushMessage]);
   const handleRewindDecision = useCallback(
     (decision) => {
       const p = pendingRewindRef.current;
@@ -3373,6 +4611,32 @@ function Repl({
     },
     [setPendingRewind]
   );
+  const handleConnectSave = useCallback(
+    async (answers) => {
+      const result = saveConnection(answers);
+      config.providers.push(result.provider);
+      config.models.push(result.model);
+      return `Saved provider "${result.provider.name}" and model "${result.model.name}" to ${result.configPath}; the key is stored as ${result.provider.apiKeyEnv} in ${result.envPath}.`;
+    },
+    [config]
+  );
+  const handleConnectOpenConfig = useCallback(() => {
+    const file = globalConfigPath();
+    openConfigFile(file);
+    return `Opening ${file} with the system default app (open it manually if nothing showed up).`;
+  }, []);
+  const finishConnect = useCallback(
+    (message) => {
+      const p = pendingConnectRef.current;
+      if (!p) return;
+      setPendingConnect(null);
+      p.resolve(message);
+    },
+    [setPendingConnect]
+  );
+  const cancelConnect = useCallback(() => {
+    finishConnect("Connect cancelled \u2014 nothing was saved.");
+  }, [finishConnect]);
   const applySessionMode = useCallback(
     (mode) => {
       if (mode === config.permissionMode) return;
@@ -3415,10 +4679,12 @@ function Repl({
       if (message) pushMessage("system", message);
     });
   }, [pushMessage]);
+  const resumedAtStart = initialMessages !== void 0;
   useEffect2(() => {
+    if (!resumedAtStart) return;
     loadTodos(cwd).then(setTodos).catch(() => {
     });
-  }, [cwd]);
+  }, [cwd, resumedAtStart]);
   useEffect2(() => {
     const onUpdate = (task) => {
       setBgLabels(runningTaskLabels());
@@ -3502,9 +4768,9 @@ function Repl({
     }
     exit();
   }, [exit, pushMessage]);
-  useInput6((_input, key) => {
+  useInput8((_input, key) => {
     if (key.escape) {
-      const busy = abortRef.current !== null || pendingRef.current !== null || planApprovalRef.current || pendingRewindRef.current !== null || pickerRef.current !== null;
+      const busy = abortRef.current !== null || pendingRef.current !== null || planApprovalRef.current || pendingRewindRef.current !== null || pendingConnectRef.current !== null || pickerRef.current !== null;
       if (busy) {
         lastEscRef.current = null;
         interrupt();
@@ -3521,7 +4787,7 @@ function Repl({
     }
     lastEscRef.current = null;
     if (key.shift && key.tab) {
-      if (abortRef.current || pendingRef.current || planApprovalRef.current || pendingRewindRef.current || pickerRef.current)
+      if (abortRef.current || pendingRef.current || planApprovalRef.current || pendingRewindRef.current || pendingConnectRef.current || pickerRef.current)
         return;
       const current = config.permissionMode;
       const index = SESSION_MODE_CYCLE.indexOf(current);
@@ -3577,6 +4843,15 @@ function Repl({
     },
     [config, cwd, attachConfirmHandler]
   );
+  const handleConnectSetDefault = useCallback(
+    async (modelName2) => {
+      saveDefaultModel(modelName2);
+      config.defaultModel = modelName2;
+      const switched = await switchModel(modelName2);
+      return `Default model set to "${modelName2}" (saved to config). ${switched}`;
+    },
+    [config, switchModel]
+  );
   const resume = useCallback(
     async (id) => {
       const current = backendRef.current;
@@ -3592,6 +4867,7 @@ function Repl({
         return `Session not found: ${id}`;
       }
       await current.loadMessages(resumed.messages);
+      setTodos(await loadTodos(cwd));
       const store = await SessionStore.open(resolvedId);
       if (store) {
         hydrateSnapshots(await loadSessionSnapshots(store.dir));
@@ -3603,7 +4879,7 @@ function Repl({
       setUsageVersion((v) => v + 1);
       return `Resumed session ${resolvedId} (${resumed.messages.length} messages).`;
     },
-    [applyMessages]
+    [applyMessages, cwd]
   );
   const runStream = useCallback(
     async (input, extraImages = []) => {
@@ -3673,9 +4949,9 @@ function Repl({
                 );
               }
             }
-            streamedRef.current += event.text;
+            streamedRef.current += toTerminalSafe(event.text);
           } else if (event.type === "reasoning") {
-            reasoningRef.current += event.text;
+            reasoningRef.current += toTerminalSafe(event.text);
           } else if (event.type === "tool-call") {
             commitStreamed(true);
             toolCardsRef.current.set(event.id, {
@@ -3715,14 +4991,19 @@ function Repl({
               usage.promptTokens += event.usage.promptTokens;
               usage.completionTokens += event.usage.completionTokens;
               usage.totalTokens += event.usage.totalTokens;
+              if (cacheUsageReported(event.usage)) {
+                if (!usage.cache) usage.cache = { cachedTokens: 0, promptTokens: 0 };
+                addToCacheTotals(usage.cache, event.usage);
+              }
               setUsageVersion((v) => v + 1);
               sessionStoreRef.current?.addUsage(event.usage).catch(() => {
               });
             }
           } else if (event.type === "retry") {
+            const wait = event.delayMs !== void 0 && event.delayMs >= 1e3 ? ` in ${Math.round(event.delayMs / 1e3)}s` : "";
             pushMessage(
               "system",
-              `Request failed, retrying (${event.attempt}/${event.maxAttempts}): ${event.reason}`
+              `Request failed, retrying (${event.attempt}/${event.maxAttempts})${wait}: ${event.reason}`
             );
           } else if (event.type === "notice") {
             pushMessage("system", event.message);
@@ -3761,9 +5042,9 @@ function Repl({
           elapsedMs: Date.now() - turnStartedAt
         });
         if (finalText.length > 0) {
-          pushAssistantChunk(`${finalText}${interrupted ? " [interrupted]" : ""}`, false);
+          pushAssistantChunk(finalText, false, interrupted);
         } else if (interrupted && turnChunksRef.current > 0) {
-          pushAssistantChunk("[interrupted]", false);
+          pushAssistantChunk("", false, true);
         }
         for (const card of toolCardsRef.current.values()) {
           pushMessage("tool", formatToolCard(card));
@@ -3992,12 +5273,20 @@ ${lines.join("\n")}`;
         await current.loadMessages(first?.role === "system" ? [first] : []);
         clearSnapshots();
         redrawMessages([]);
+        resetTodos();
+        setTodos([]);
         usageRef.current = emptyUsage();
         budgetWarnedRef.current = false;
         budgetExceededRef.current = false;
         setUsageVersion((v) => v + 1);
         return `Started a new session (${store.id}) with a clean context.`;
       },
+      connect: async () => {
+        if (pendingConnectRef.current) return "The connect wizard is already open.";
+        return new Promise((resolve) => {
+          setPendingConnect({ resolve });
+        });
+      },
       clearSessions: async (all) => {
         const currentId = sessionStoreRef.current?.id;
         const removed = await clearSessions(all ? void 0 : cwd, currentId);
@@ -4051,6 +5340,26 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         if (!(current instanceof AgentLoop)) {
           return "Nothing to undo.";
         }
+        const preview = current.previewLastTurnRetraction();
+        if (preview.removed === 0) {
+          return "Nothing to undo (no conversation turn to retract).";
+        }
+        const diffs = await buildUndoDiffs(
+          preview.turn !== void 0 ? listTurnSnapshots(preview.turn) : [],
+          cwd
+        );
+        const confirmed = await new Promise((resolve) => {
+          setPendingRewind({
+            title: "Undo last turn",
+            confirmLabel: "undo",
+            summary: `${preview.removed} message(s) will be retracted, ${diffs.length} file change(s) reverted.`,
+            diffs,
+            resolve
+          });
+        });
+        if (!confirmed) {
+          return "Undo cancelled.";
+        }
         const { removed, turn } = await current.retractLastTurn();
         if (removed === 0) {
           return "Nothing to undo (no conversation turn to retract).";
@@ -4187,6 +5496,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     redrawMessages,
     applySessionMode,
     setPendingRewind,
+    setPendingConnect,
     showPicker
   ]);
   const runShellBang = useCallback(
@@ -4291,9 +5601,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     }
   }, [cwd, config, isStreaming, epoch]);
   const sessionCost = sessionCostUsd();
-  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx10(MessageList, { messages }, `messages-${epoch}`),
-    (thinking || activity !== null) && /* @__PURE__ */ jsx10(
+  return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(MessageList, { messages }, `messages-${epoch}`),
+    (thinking || activity !== null) && /* @__PURE__ */ jsx11(
       ThinkingIndicator,
       {
         reasoning: thinkingText,
@@ -4301,9 +5611,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         activity: activity ?? void 0
       }
     ),
-    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx10(Text12, { dimColor: true, children: thoughtSummary }),
-    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx10(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
-    pending && /* @__PURE__ */ jsx10(
+    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx11(Text14, { dimColor: true, children: thoughtSummary }),
+    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx11(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
+    pending && /* @__PURE__ */ jsx11(
       PermissionPrompt,
       {
         request: pending.request,
@@ -4311,9 +5621,18 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onDecision: handleDecision
       }
     ),
-    planApproval && /* @__PURE__ */ jsx10(ExitPlanPrompt, { onDecision: handlePlanDecision }),
-    pendingRewind && /* @__PURE__ */ jsx10(RewindConfirmPrompt, { summary: pendingRewind.summary, onDecision: handleRewindDecision }),
-    picker && /* @__PURE__ */ jsx10(
+    planApproval && /* @__PURE__ */ jsx11(ExitPlanPrompt, { onDecision: handlePlanDecision }),
+    pendingRewind && /* @__PURE__ */ jsx11(
+      RewindConfirmPrompt,
+      {
+        summary: pendingRewind.summary,
+        title: pendingRewind.title,
+        confirmLabel: pendingRewind.confirmLabel,
+        diffs: pendingRewind.diffs,
+        onDecision: handleRewindDecision
+      }
+    ),
+    picker && /* @__PURE__ */ jsx11(
       SelectPrompt,
       {
         title: picker.title,
@@ -4322,21 +5641,38 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onCancel: handlePickerCancel
       }
     ),
-    queueItems.map((item) => /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+    pendingConnect && /* @__PURE__ */ jsx11(
+      ConnectWizard,
+      {
+        existingProviderNames: config.providers.map((p) => p.name),
+        existingModelNames: config.models.map((m) => m.name),
+        onSave: handleConnectSave,
+        onSetDefault: handleConnectSetDefault,
+        onOpenConfig: handleConnectOpenConfig,
+        onFinish: finishConnect,
+        onCancel: cancelConnect
+      }
+    ),
+    queueItems.slice(0, MAX_VISIBLE_QUEUED).map((item) => /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
       "queued: ",
       item.text.length > 80 ? `${item.text.slice(0, 80)}\u2026` : item.text
     ] }, item.id)),
-    pendingImages.map((staged) => /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+    queueItems.length > MAX_VISIBLE_QUEUED && /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+      "\u2026 ",
+      queueItems.length - MAX_VISIBLE_QUEUED,
+      " more queued"
+    ] }),
+    pendingImages.map((staged) => /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
       "[image attached: ",
       staged.image.path,
       "]"
     ] }, staged.id)),
-    /* @__PURE__ */ jsx10(TodoPanel, { todos }),
-    /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx11(TodoPanel, { todos }),
+    /* @__PURE__ */ jsx11(
       InputBox,
       {
         isStreaming,
-        disabled: pending !== null || planApproval || pendingRewind !== null || picker !== null,
+        disabled: pending !== null || planApproval || pendingRewind !== null || pendingConnect !== null || picker !== null,
         commands: commandHints,
         cwd,
         refill: inputRefill,
@@ -4347,7 +5683,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onPasteImage: handlePasteImage
       }
     ),
-    /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx11(
       StatusBar,
       {
         cwd,
@@ -4356,6 +5692,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         tokens: usageRef.current.totalTokens,
         gitBranch,
         contextPercent,
+        cachePercent: usageRef.current.cache ? cacheHitPercent(usageRef.current.cache) : null,
         sessionCostUsd: sessionCost,
         backgroundTasks: bgLabels
       }
@@ -4367,7 +5704,7 @@ function renderRepl(backend, opts) {
     defaultTaskManager.cleanup();
   });
   return render(
-    /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx11(
       Repl,
       {
         backend,
@@ -4384,7 +5721,7 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs11 from "fs";
+import fs13 from "fs";
 import { parse as parse2 } from "smol-toml";
 var PartialConfigSchema = ConfigSchema.partial();
 function parseTomlFile(content, filePath) {
@@ -4412,11 +5749,12 @@ function applyOverrides(config, overrides) {
   return merged;
 }
 function readTomlFileSync(filePath) {
-  if (!fs11.existsSync(filePath)) return {};
-  const content = fs11.readFileSync(filePath, "utf8");
+  if (!fs13.existsSync(filePath)) return {};
+  const content = fs13.readFileSync(filePath, "utf8");
   return parseTomlFile(content, filePath);
 }
 function loadConfigSync(cwd, overrides) {
+  loadEnvFile();
   const global = readTomlFileSync(globalConfigPath());
   const project = readTomlFileSync(projectConfigPath(cwd));
   const merged = applyOverrides(mergeConfig(global, project), overrides);
@@ -4517,14 +5855,17 @@ async function printMode(loop, prompt, cwd, json, imagePaths) {
         case "finish":
           usage.add(event.usage);
           break;
-        case "retry":
-          if (!json)
+        case "retry": {
+          if (!json) {
+            const wait = event.delayMs !== void 0 && event.delayMs >= 1e3 ? ` in ${Math.round(event.delayMs / 1e3)}s` : "";
             process.stderr.write(
               `
-[retry ${event.attempt}/${event.maxAttempts}] ${event.reason}
+[retry ${event.attempt}/${event.maxAttempts}${wait}] ${event.reason}
 `
             );
+          }
           break;
+        }
         case "notice":
           if (!json) process.stderr.write(`
 [notice] ${event.message}
@@ -4659,6 +6000,7 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
   }
   if (resumed) {
     await loop.loadMessages(resumed.messages);
+    await loadTodos(cwd);
     if (sessionStore) {
       hydrateSnapshots(await loadSessionSnapshots(sessionStore.dir));
     }