@cryer/star-cli 0.3.1 → 0.3.3

package/dist/main.js

@@ -17,15 +17,14 @@ import {
   createIgnorePredicate,
   defaultAgentTasks,
   defaultTaskManager,
+  diffTreeNames,
   discoverSkills,
-  envFilePath,
   estimateTokens,
   formatTaskFinished,
   formatTaskList,
   formatTaskStarted,
   formatTodos,
   getGitSummary,
-  globalConfigPath,
   hydrateSnapshots,
   isAllowedByRules,
   isDangerousCommand,
@@ -36,22 +35,34 @@ import {
   loadTodos,
   parseTodoArgs,
   probeImageDimensions,
-  projectConfigPath,
   reconcileToolCalls,
   resetTodos,
   resolveShell,
   resolveSnapshotContent,
   rewindToSnapshot,
+  summarizeMessages
+} from "./chunk-3L6QKJM4.js";
+import {
+  envFilePath,
+  globalConfigPath,
+  projectConfigPath,
   sessionsDir,
   starHome,
-  summarizeMessages,
-  undoTurnSnapshots,
   userMemoryPath
-} from "./chunk-K4SIXWCI.js";
+} from "./chunk-B6P4VUBE.js";
 
 // src/main.tsx
 import { Command } from "commander";
 
+// 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/format.ts
 function summarizeArgs(args, maxLength = 120) {
   let json;
@@ -96,7 +107,7 @@ function buildDisplayMessages(messages) {
     if (message.role === "user" || message.role === "assistant") {
       const text = coreMessageText(message);
       if (text) {
-        display.push({ id: display.length, role: message.role, text });
+        display.push({ id: display.length, role: message.role, text: toTerminalSafe(text) });
       } else {
         collapsed++;
       }
@@ -108,7 +119,7 @@ function buildDisplayMessages(messages) {
     display.push({
       id: display.length,
       role: "system",
-      text: `\u5DF2\u6062\u590D ${collapsed} \u6761\u5386\u53F2\u6D88\u606F`
+      text: `Restored ${collapsed} history message(s) not shown here.`
     });
   }
   return display;
@@ -166,7 +177,15 @@ function resizeImagePlan(platform, inputFile, outputFile, maxDimension, tools =
     if (tools.hasConvert) {
       return {
         command: "convert",
-        args: [inputFile, "-resize", `${maxDimension}x${maxDimension}>`, outputFile]
+        // -auto-orient keeps EXIF-rotated photos upright after the resize
+        // strips their orientation metadata.
+        args: [
+          inputFile,
+          "-auto-orient",
+          "-resize",
+          `${maxDimension}x${maxDimension}>`,
+          outputFile
+        ]
       };
     }
     if (tools.hasFfmpeg) {
@@ -234,6 +253,7 @@ 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 MAX_DIR_MENTION_TOTAL = 5e3;
 var IMAGE_MIME_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -259,7 +279,7 @@ async function readImageInput(filePath, cwd) {
   });
   return result.image;
 }
-var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\]*|[A-Za-z0-9._\-/\\]+)/g;
+var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\\u2e80-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]*|[A-Za-z0-9._\-/\\\u2e80-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]+)/g;
 function parseMentions(text) {
   const mentions = [];
   const seen = /* @__PURE__ */ new Set();
@@ -292,13 +312,18 @@ function isBinaryContent(buf) {
   return probe.includes(0);
 }
 async function listDirEntries(dir, prefix, depth, state, ignore) {
+  if (state.capped) return;
   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 visible = entries.filter((entry) => entry.isDirectory() || entry.isFile()).filter((entry) => !(entry.isDirectory() && SKIP_DIRS.has(entry.name))).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++) {
+    if (state.total >= MAX_DIR_MENTION_TOTAL) {
+      state.capped = true;
+      return;
+    }
     const entry = visible[i];
     if (!entry) continue;
     state.total += 1;
@@ -323,11 +348,13 @@ async function listDirEntries(dir, prefix, depth, state, ignore) {
 }
 async function directoryBlock(abs, mention, ignore) {
   const display = `${mention.replace(/\\/g, "/").replace(/\/+$/, "")}/`;
-  const state = { lines: [`${display}`], shown: 0, total: 0 };
+  const state = { lines: [`${display}`], shown: 0, total: 0, capped: false };
   const probe = await readdir(abs).catch(() => null);
   if (!probe) return null;
   await listDirEntries(abs, "", 1, state, ignore);
-  if (state.total > state.shown) {
+  if (state.capped) {
+    state.lines.push("... (truncated, many more entries)");
+  } else 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)`
     );
@@ -471,11 +498,56 @@ import { parse, stringify } from "smol-toml";
 async function addAllowRule(rule) {
   return addPermissionRule("allow", rule);
 }
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+async function writeFileAtomic(filePath, content) {
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  await fs.promises.writeFile(tmpPath, content, "utf8");
+  await fs.promises.rename(tmpPath, filePath);
+}
+function upsertPermissionRuleText(content, kind, rules, hadPermissionsTable) {
+  const newLine = `${kind} = [${rules.map(tomlString).join(", ")}]`;
+  const lines = content.split("\n");
+  let sectionStart = -1;
+  let sectionEnd = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!/^\s*\[/.test(line)) continue;
+    if (sectionStart === -1) {
+      if (/^\s*\[\s*permissions\s*\]\s*(?:#.*)?$/.test(line)) sectionStart = i;
+    } else {
+      sectionEnd = i;
+      break;
+    }
+  }
+  if (sectionStart === -1) {
+    if (hadPermissionsTable) return null;
+    const separator = content === "" ? "" : content.endsWith("\n") ? "\n" : "\n\n";
+    return `${content}${separator}[permissions]
+${newLine}
+`;
+  }
+  const inlineArray = new RegExp(`^(\\s*)${kind}\\s*=\\s*\\[.*\\](\\s*(?:#.*)?)$`);
+  const anyKey = new RegExp(`^\\s*${kind}\\s*=`);
+  for (let i = sectionStart + 1; i < sectionEnd; i++) {
+    const line = lines[i] ?? "";
+    const match = inlineArray.exec(line);
+    if (match) {
+      lines[i] = `${match[1]}${newLine}${match[2]}`;
+      return lines.join("\n");
+    }
+    if (anyKey.test(line)) return null;
+  }
+  lines.splice(sectionStart + 1, 0, newLine);
+  return lines.join("\n");
+}
 async function addPermissionRule(kind, rule) {
   const filePath = globalConfigPath();
+  let content = "";
   let raw = {};
   try {
-    const content = await fs.promises.readFile(filePath, "utf8");
+    content = await fs.promises.readFile(filePath, "utf8");
     raw = parse(content);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -483,30 +555,57 @@ async function addPermissionRule(kind, rule) {
   const permissions = typeof raw.permissions === "object" && raw.permissions !== null ? raw.permissions : {};
   const rules = Array.isArray(permissions[kind]) ? permissions[kind] : [];
   if (rules.includes(rule)) return false;
-  permissions[kind] = [...rules, rule];
-  raw.permissions = permissions;
+  const nextRules = [...rules, rule];
   await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
-  await fs.promises.writeFile(filePath, stringify(raw), "utf8");
+  const updated = upsertPermissionRuleText(content, kind, nextRules, raw.permissions !== void 0);
+  if (updated !== null) {
+    await writeFileAtomic(filePath, updated);
+    return true;
+  }
+  permissions[kind] = nextRules;
+  raw.permissions = permissions;
+  await writeFileAtomic(filePath, stringify(raw));
   return true;
 }
+function upsertTopLevelKeyText(content, key, value) {
+  const newLine = `${key} = ${tomlString(value)}`;
+  if (content.trim() === "") return `${newLine}
+`;
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex((line) => /^\s*\[/.test(line));
+  const end = firstTable === -1 ? lines.length : firstTable;
+  const keyLine = new RegExp(`^\\s*${key}\\s*=`);
+  for (let i = 0; i < end; i++) {
+    const line = lines[i] ?? "";
+    if (keyLine.test(line)) {
+      const comment = /\s+#.*$/.exec(line);
+      lines[i] = `${newLine}${comment?.[0] ?? ""}`;
+      return lines.join("\n");
+    }
+  }
+  lines.splice(end, 0, newLine);
+  return lines.join("\n");
+}
 async function savePermissionMode(mode) {
   const filePath = globalConfigPath();
-  let raw = {};
+  let content = "";
   try {
-    const content = await fs.promises.readFile(filePath, "utf8");
-    raw = parse(content);
+    content = await fs.promises.readFile(filePath, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  raw.permissionMode = mode;
   await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
-  await fs.promises.writeFile(filePath, stringify(raw), "utf8");
+  await writeFileAtomic(filePath, upsertTopLevelKeyText(content, "permissionMode", mode));
 }
 
 // src/config/schema.ts
 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(),
@@ -524,7 +623,11 @@ var ModelConfigSchema = z.object({
   // Cost estimation needs BOTH prices (USD per 1M tokens); with only one set
   // the model is treated as unpriced.
   promptPrice: z.number().nonnegative().optional(),
-  completionPrice: z.number().nonnegative().optional()
+  completionPrice: z.number().nonnegative().optional(),
+  // Optional price (USD per 1M tokens) for cache-read prompt tokens. When
+  // unset, OpenAI-style cached tokens bill at promptPrice and Anthropic-style
+  // cache reads are not billed — set this for accurate cache pricing.
+  cacheReadPrice: z.number().nonnegative().optional()
 });
 var PermissionsConfigSchema = z.object({
   allow: z.array(z.string()).default([]),
@@ -563,14 +666,16 @@ 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 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 the
-  // model finished deliberately (steered with a nudge after one identical
-  // resend instead of burning the stream retry budget). Tool calls reset the
+  // "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),
@@ -584,7 +689,17 @@ var ConfigSchema = z.object({
   notifyBell: z.boolean().default(true),
   notifyBellThresholdSec: z.number().positive().default(10),
   permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
-  hooks: z.array(HookConfigSchema).default([])
+  hooks: z.array(HookConfigSchema).default([]),
+  // Consecutive identical tool calls (same tool + same arguments) allowed
+  // before the loop refuses to execute the repeat and tells the model to
+  // change approach — a guard against agents stuck retrying a failing call
+  // (opencode's doom_loop). 0 disables.
+  doomLoopThreshold: z.number().int().min(0).default(3),
+  // Track the whole working tree with an internal git repo (outside the
+  // user's .git) at every turn boundary, so /undo and /redo can restore
+  // changes made by ANY tool (bash included), not just write_file/edit_file.
+  // Falls back silently to per-file snapshots when git is unavailable.
+  gitSnapshots: z.boolean().default(true)
 });
 function contextWindowTokens(config, modelName) {
   return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
@@ -609,6 +724,74 @@ 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());
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+
 // src/llm/provider.ts
 function resolveApiKey(provider) {
   const fromEnv = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : void 0;
@@ -642,12 +825,16 @@ function createModel(config, modelName) {
         baseURL: provider.baseURL,
         apiKey,
         headers: provider.headers
-      })(modelConfig.model);
+      })(modelConfig.model, {}, { includeUsage: true });
     case "openai-responses":
       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);
   }
 }
@@ -661,6 +848,21 @@ function checkpointsDir(sessionDir) {
 function indexPath(sessionDir) {
   return path4.join(checkpointsDir(sessionDir), "index.json");
 }
+var indexWriteQueues = /* @__PURE__ */ new Map();
+function enqueueIndexWrite(sessionDir, op) {
+  const queued = indexWriteQueues.get(sessionDir) ?? Promise.resolve();
+  const run = queued.then(op);
+  indexWriteQueues.set(
+    sessionDir,
+    run.then(
+      () => {
+      },
+      () => {
+      }
+    )
+  );
+  return run;
+}
 function checkpointContentPath(sessionDir, id) {
   return path4.join(checkpointsDir(sessionDir), `${id}.snapshot`);
 }
@@ -679,32 +881,36 @@ async function listCheckpointRecords(sessionDir) {
   }
 }
 async function appendCheckpointRecord(sessionDir, record, content) {
-  await fs2.mkdir(checkpointsDir(sessionDir), { recursive: true });
-  if (record.existed && content !== null) {
-    await fs2.writeFile(checkpointContentPath(sessionDir, record.id), content, "utf8");
-  }
-  const records = await listCheckpointRecords(sessionDir);
-  records.push(record);
-  await fs2.writeFile(indexPath(sessionDir), JSON.stringify(records, null, 2));
+  await enqueueIndexWrite(sessionDir, async () => {
+    await fs2.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
+    if (record.existed && content !== null) {
+      await fs2.writeFile(checkpointContentPath(sessionDir, record.id), content, "utf8");
+    }
+    const records = await listCheckpointRecords(sessionDir);
+    records.push(record);
+    await fs2.writeFile(indexPath(sessionDir), JSON.stringify(records, null, 2));
+  });
 }
 async function removeCheckpointRecords(sessionDir, ids) {
   if (ids.length === 0) return;
-  const drop = new Set(ids);
-  const records = await listCheckpointRecords(sessionDir);
-  const kept = records.filter((record) => !drop.has(record.id));
-  if (kept.length === records.length) return;
-  await fs2.mkdir(checkpointsDir(sessionDir), { recursive: true });
-  await fs2.writeFile(indexPath(sessionDir), JSON.stringify(kept, null, 2));
-  for (const id of ids) {
-    await fs2.rm(checkpointContentPath(sessionDir, id), { force: true });
-  }
+  await enqueueIndexWrite(sessionDir, async () => {
+    const drop = new Set(ids);
+    const records = await listCheckpointRecords(sessionDir);
+    const kept = records.filter((record) => !drop.has(record.id));
+    if (kept.length === records.length) return;
+    await fs2.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
+    await fs2.writeFile(indexPath(sessionDir), JSON.stringify(kept, null, 2));
+    for (const id of ids) {
+      await fs2.rm(checkpointContentPath(sessionDir, id), { force: true });
+    }
+  });
 }
 async function loadSessionSnapshots(sessionDir) {
   const records = await listCheckpointRecords(sessionDir);
   return records.map((record) => ({
     ...record,
     content: null,
-    contentFile: record.existed ? checkpointContentPath(sessionDir, record.id) : void 0
+    contentFile: record.existed && !record.contentTooLarge ? checkpointContentPath(sessionDir, record.id) : void 0
   }));
 }
 
@@ -725,6 +931,10 @@ function debugWarn(message) {
   if (process.env.STAR_DEBUG === "1") process.stderr.write(`[star-cli] ${message}
 `);
 }
+var FALLBACK_META = /* @__PURE__ */ Symbol("star.fallbackMeta");
+function isFallbackMeta(meta) {
+  return meta[FALLBACK_META] === true;
+}
 function dayKey(date) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
@@ -734,6 +944,9 @@ var SessionStore = class _SessionStore {
   dir;
   pendingMeta = null;
   initialized = false;
+  cachedMeta = null;
+  metaTmpSeq = 0;
+  metaWriteQueue = Promise.resolve();
   constructor(id) {
     this.id = id;
     this.dir = path5.join(sessionsDir(), id);
@@ -763,6 +976,7 @@ var SessionStore = class _SessionStore {
     } catch {
       debugWarn(`session ${id}: corrupt meta.json, using defaults`);
     }
+    await store.sweepTmpFiles();
     store.initialized = true;
     return store;
   }
@@ -773,16 +987,40 @@ var SessionStore = class _SessionStore {
     } catch {
       return [];
     }
-    const metas = [];
-    for (const entry of entries) {
+    const metas = await Promise.all(
+      entries.map(async (entry) => {
+        try {
+          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)) return meta;
+        } catch {
+        }
+        return null;
+      })
+    );
+    return metas.filter((meta) => meta !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  // Meta writes are serialized per instance and land atomically (tmp file +
+  // rename) over a cached in-memory meta: the fire-and-forget title/usage
+  // writers race the loop's own appends, and a truncated read once turned
+  // fallbackMeta's empty defaults into a persisted wipe of model/cwd/usage.
+  // A branded fallback meta is never written back for the same reason.
+  writeMeta(meta) {
+    if (isFallbackMeta(meta)) return Promise.resolve();
+    const tmp = `${this.metaPath()}.tmp-${process.pid}-${this.metaTmpSeq++}`;
+    const run = this.metaWriteQueue.then(async () => {
       try {
-        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 {
+        await fs3.writeFile(tmp, JSON.stringify(meta, null, 2));
+        await fs3.rename(tmp, this.metaPath());
+      } catch (error) {
+        await fs3.unlink(tmp).catch(() => {
+        });
+        throw error;
       }
-    }
-    return metas.sort((a, b) => b.updatedAt - a.updatedAt);
+    });
+    this.metaWriteQueue = run.catch(() => {
+    });
+    return run;
   }
   async ensureInitialized() {
     if (this.initialized) return;
@@ -791,7 +1029,8 @@ var SessionStore = class _SessionStore {
       this.initialized = true;
       return;
     }
-    await fs3.mkdir(this.dir, { recursive: true });
+    await fs3.mkdir(this.dir, { recursive: true, mode: 448 });
+    await this.sweepTmpFiles();
     const meta = {
       id: this.id,
       title: "",
@@ -800,16 +1039,31 @@ var SessionStore = class _SessionStore {
       createdAt: pending.createdAt,
       updatedAt: pending.createdAt
     };
-    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await this.writeMeta(meta);
+    this.cachedMeta = meta;
     this.initialized = true;
   }
+  // Removes meta.json.tmp-* orphans left behind by a crashed meta write
+  // (tmp file + rename); best-effort, the directory may not even exist yet.
+  async sweepTmpFiles() {
+    let entries;
+    try {
+      entries = await fs3.readdir(this.dir);
+    } catch {
+      return;
+    }
+    await Promise.all(
+      entries.filter((entry) => entry.startsWith("meta.json.tmp-")).map((entry) => fs3.unlink(path5.join(this.dir, entry)).catch(() => {
+      }))
+    );
+  }
   async append(message) {
     await this.ensureInitialized();
     await fs3.appendFile(this.messagesPath(), `${JSON.stringify(message)}
 `);
     const meta = await this.meta();
     meta.updatedAt = Date.now();
-    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await this.writeMeta(meta);
   }
   async replaceMessages(messages) {
     await this.ensureInitialized();
@@ -818,7 +1072,7 @@ var SessionStore = class _SessionStore {
 ` : "");
     const meta = await this.meta();
     meta.updatedAt = Date.now();
-    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await this.writeMeta(meta);
   }
   async messages() {
     let raw;
@@ -841,13 +1095,24 @@ var SessionStore = class _SessionStore {
   }
   fallbackMeta() {
     const now = Date.now();
-    return { id: this.id, title: "", model: "", cwd: "", createdAt: now, updatedAt: now };
+    const meta = {
+      id: this.id,
+      title: "",
+      model: "",
+      cwd: "",
+      createdAt: now,
+      updatedAt: now
+    };
+    Object.defineProperty(meta, FALLBACK_META, { value: true, enumerable: false });
+    return meta;
   }
   async meta() {
     await this.ensureInitialized();
+    if (this.cachedMeta) return this.cachedMeta;
     try {
       const raw = await fs3.readFile(this.metaPath(), "utf8");
-      return JSON.parse(raw);
+      this.cachedMeta = JSON.parse(raw);
+      return this.cachedMeta;
     } catch {
       debugWarn(`session ${this.id}: unreadable meta.json, using defaults`);
       return this.fallbackMeta();
@@ -858,7 +1123,7 @@ var SessionStore = class _SessionStore {
     const meta = await this.meta();
     meta.title = title;
     meta.updatedAt = Date.now();
-    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await this.writeMeta(meta);
   }
   async appendCheckpoint(record, content) {
     await this.ensureInitialized();
@@ -883,6 +1148,12 @@ var SessionStore = class _SessionStore {
     usage.promptTokens += delta.promptTokens;
     usage.completionTokens += delta.completionTokens;
     usage.totalTokens += delta.totalTokens;
+    if (delta.cachedPromptTokens) {
+      usage.cachedPromptTokens = (usage.cachedPromptTokens ?? 0) + delta.cachedPromptTokens;
+    }
+    if (delta.cacheReadInputTokens) {
+      usage.cacheReadInputTokens = (usage.cacheReadInputTokens ?? 0) + delta.cacheReadInputTokens;
+    }
     meta.usage = usage;
     const day = dayKey(/* @__PURE__ */ new Date());
     const byDay = meta.usageByDay ?? {};
@@ -892,7 +1163,7 @@ var SessionStore = class _SessionStore {
     bucket.totalTokens += delta.totalTokens;
     byDay[day] = bucket;
     meta.usageByDay = byDay;
-    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await this.writeMeta(meta);
   }
 };
 
@@ -949,6 +1220,33 @@ async function findLatestSession(cwd) {
   const [latest] = await SessionStore.list(cwd);
   return latest ?? null;
 }
+async function sessionPreview(id, maxBytes = 4096) {
+  let handle = null;
+  try {
+    handle = await fs5.open(path7.join(sessionsDir(), id, "messages.jsonl"), "r");
+    const buffer = Buffer.alloc(maxBytes);
+    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+    const head = buffer.toString("utf8", 0, bytesRead);
+    for (const line of head.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const message = JSON.parse(trimmed);
+        if (message.role !== "user") continue;
+        const text = typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.type === "text" ? part.text : "").join(" ");
+        const collapsed = text.replace(/\s+/g, " ").trim();
+        if (collapsed) return collapsed;
+      } catch {
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
 function shortSessionId(id) {
   const dash = id.lastIndexOf("-");
   return dash === -1 ? id : id.slice(dash + 1);
@@ -965,20 +1263,20 @@ async function resolveSessionId(query) {
 function relativeTime(timestamp) {
   const diff = Date.now() - timestamp;
   const minutes = Math.floor(diff / 6e4);
-  if (minutes < 1) return "\u521A\u521A";
-  if (minutes < 60) return `${minutes} \u5206\u949F\u524D`;
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
   const hours = Math.floor(minutes / 60);
-  if (hours < 24) return `${hours} \u5C0F\u65F6\u524D`;
+  if (hours < 24) return `${hours}h ago`;
   const days = Math.floor(hours / 24);
-  if (days < 30) return `${days} \u5929\u524D`;
+  if (days < 30) return `${days}d ago`;
   const months = Math.floor(days / 30);
-  if (months < 12) return `${months} \u4E2A\u6708\u524D`;
-  return `${Math.floor(months / 12)} \u5E74\u524D`;
+  if (months < 12) return `${months}mo ago`;
+  return `${Math.floor(months / 12)}y ago`;
 }
 function formatSessionEntries(entries, options = {}) {
   return entries.map(({ meta, messageCount }) => {
-    const title = meta.title || "(\u65E0\u6807\u9898)";
-    const base = `${shortSessionId(meta.id)}  ${title}  ${messageCount} \u6761\u6D88\u606F  \u66F4\u65B0\u4E8E ${relativeTime(meta.updatedAt)}`;
+    const title = meta.title || "(untitled)";
+    const base = `${shortSessionId(meta.id)}  ${title}  ${messageCount} messages  updated ${relativeTime(meta.updatedAt)}`;
     return options.showCwd ? `${base}  [${meta.cwd}]` : base;
   }).join("\n");
 }
@@ -1009,7 +1307,9 @@ function computeCostUsd(usage, model) {
   if (model?.promptPrice === void 0 || model.completionPrice === void 0) {
     return null;
   }
-  return (usage.promptTokens * model.promptPrice + usage.completionTokens * model.completionPrice) / 1e6;
+  const cached = Math.min(Math.max(usage.cachedPromptTokens ?? 0, 0), usage.promptTokens);
+  const promptUsd = (usage.promptTokens - cached) * model.promptPrice + cached * (model.cacheReadPrice ?? model.promptPrice) + (usage.cacheReadInputTokens ?? 0) * (model.cacheReadPrice ?? 0);
+  return (promptUsd + usage.completionTokens * model.completionPrice) / 1e6;
 }
 function estimateCost(usage, modelName, model) {
   const cost = computeCostUsd(usage, model);
@@ -1025,7 +1325,8 @@ function estimateCost(usage, modelName, model) {
     }
     return `Estimated cost: unknown (no price configured for ${modelName})`;
   }
-  return `Estimated cost: $${formatDollars(cost)} (${model?.name} @ $${model?.promptPrice}/M prompt, $${model?.completionPrice}/M completion)`;
+  const cachePrice = model?.cacheReadPrice !== void 0 ? `, $${model.cacheReadPrice}/M cache read` : "";
+  return `Estimated cost: $${formatDollars(cost)} (${model?.name} @ $${model?.promptPrice}/M prompt, $${model?.completionPrice}/M completion${cachePrice})`;
 }
 
 // src/session/usage.ts
@@ -1101,6 +1402,12 @@ function aggregateUsage(metas) {
     entry.sessions += 1;
     entry.requests += requestCount;
     addTo(entry, totals);
+    if (hasTotals && meta.usage) {
+      const cached = tokens(meta.usage.cachedPromptTokens);
+      const cacheRead = tokens(meta.usage.cacheReadInputTokens);
+      if (cached > 0) entry.cachedPromptTokens = (entry.cachedPromptTokens ?? 0) + cached;
+      if (cacheRead > 0) entry.cacheReadInputTokens = (entry.cacheReadInputTokens ?? 0) + cacheRead;
+    }
     models.set(name, entry);
   }
   return {
@@ -1155,7 +1462,7 @@ function formatUsageDashboard(stats, models, options = {}) {
   const configured = new Map(models.map((m) => [m.name, m]));
   const rows = stats.models.map((entry) => {
     const cfg = configured.get(entry.model);
-    const cost = cfg?.promptPrice !== void 0 && cfg.completionPrice !== void 0 ? (entry.promptTokens * cfg.promptPrice + entry.completionTokens * cfg.completionPrice) / 1e6 : null;
+    const cost = computeCostUsd(entry, cfg);
     return { entry, cost };
   });
   const header = ["model", "requests", "prompt", "completion", "total", "cost"];
@@ -1229,7 +1536,7 @@ function cacheHitPercent(totals) {
 // src/cli/clipboard.ts
 import { execFile as execFile2 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile3, unlink as unlink2 } from "fs/promises";
+import { readFile as readFile3, stat as stat2, unlink as unlink2 } from "fs/promises";
 import os2 from "os";
 import path9 from "path";
 import { promisify as promisify2 } from "util";
@@ -1308,6 +1615,13 @@ async function finalizeClipboardImage(image) {
   const result = await downsampleImageIfNeeded(image);
   return { image: result.image, oversized: result.oversized && !result.resized };
 }
+async function readClipboardTempFile(tempFile) {
+  const st = await stat2(tempFile).catch(() => null);
+  if (!st || st.size === 0 || st.size > MAX_CLIPBOARD_IMAGE_BYTES) return null;
+  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") };
+}
 async function readClipboardImage() {
   const tempFile = path9.join(os2.tmpdir(), `star-clipboard-${randomUUID2()}.png`);
   const hasPngpaste = process.platform === "darwin" ? await commandExists2("pngpaste") : false;
@@ -1320,22 +1634,18 @@ async function readClipboardImage() {
         maxBuffer: MAX_CLIPBOARD_IMAGE_BYTES,
         encoding: "buffer"
       });
-      const buf2 = stdout;
-      if (buf2.length === 0) return null;
+      const buf = stdout;
+      if (buf.length === 0) return null;
       return finalizeClipboardImage({
         path: "clipboard.png",
         mimeType: "image/png",
-        data: buf2.toString("base64")
+        data: buf.toString("base64")
       });
     }
     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 finalizeClipboardImage({
-      path: "clipboard.png",
-      mimeType: "image/png",
-      data: buf.toString("base64")
-    });
+    const image = await readClipboardTempFile(tempFile);
+    if (!image) return null;
+    return finalizeClipboardImage(image);
   } catch {
     return null;
   } finally {
@@ -1695,7 +2005,7 @@ function applyEdit(content, oldString, newString, replaceAll) {
   }
   if (count === 0) return null;
   if (count > 1 && !replaceAll) return null;
-  return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+  return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, () => newString);
 }
 function newFilePreview(content, label) {
   const all = content.split("\n");
@@ -1994,13 +2304,22 @@ ${content}`);
   });
   register({
     name: "undo",
-    description: "Undo the last conversation turn: revert its file changes (write_file/edit_file) and retract its messages",
+    description: "Undo the last conversation turn: revert its file changes (any tool, bash included, when git snapshots are on) and retract its messages",
     usage: "/undo",
     category: "Changes",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.undo());
     }
   });
+  register({
+    name: "redo",
+    description: "Redo the last git-snapshot undo: restore the working tree to its pre-undo state",
+    usage: "/redo",
+    category: "Changes",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.redo());
+    }
+  });
   register({
     name: "rewind",
     description: "List file-change checkpoints, or rewind to just before one: restore files and retract the conversation",
@@ -2272,19 +2591,19 @@ 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) {
+function tomlString2(value) {
   return JSON.stringify(value);
 }
 function buildProviderTomlBlock(provider) {
   return [
     "[[providers]]",
-    `name = ${tomlString(provider.name)}`,
+    `name = ${tomlString2(provider.name)}`,
     "# wire format: openai-compatible | anthropic | openai-responses",
-    `protocol = ${tomlString(provider.protocol)}`,
-    `baseURL = ${tomlString(provider.baseURL)}`,
+    `protocol = ${tomlString2(provider.protocol)}`,
+    `baseURL = ${tomlString2(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 ?? "")}`,
+    `apiKeyEnv = ${tomlString2(provider.apiKeyEnv ?? "")}`,
     "# inline key instead of apiKeyEnv (not recommended):",
     '# apiKey = "sk-..."',
     "# extra HTTP headers sent to the provider:",
@@ -2296,9 +2615,9 @@ function buildProviderTomlBlock(provider) {
 function buildModelTomlBlock(model) {
   return [
     "[[models]]",
-    `name = ${tomlString(model.name)}`,
-    `provider = ${tomlString(model.provider)}`,
-    `model = ${tomlString(model.model)}`,
+    `name = ${tomlString2(model.name)}`,
+    `provider = ${tomlString2(model.provider)}`,
+    `model = ${tomlString2(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}`,
@@ -2366,7 +2685,7 @@ function saveConnection(answers, configPath = globalConfigPath(), envPath = envF
   return { provider, model, configPath, envPath };
 }
 function setDefaultModelInToml(content, modelName) {
-  const line = `defaultModel = ${tomlString(modelName)}`;
+  const line = `defaultModel = ${tomlString2(modelName)}`;
   const lines = content.split("\n");
   let inTopLevel = true;
   for (let i = 0; i < lines.length; i++) {
@@ -2806,6 +3125,20 @@ async function initProject(opts) {
   };
 }
 
+// src/cli/commands/redo.ts
+function formatRedoSummary(entry) {
+  const label = entry.label !== "" ? ` of "${entry.label}"` : "";
+  return `Restore the working tree to its state before the undo${label} (tree ${entry.tree.slice(0, 8)}). Conversation messages are not restored.`;
+}
+function formatRedoResult(result) {
+  if (!result.ok) {
+    return `Redo failed \u2014 git could not restore the snapshot (tree ${result.tree.slice(0, 8)}). The redo entry was kept; try again or check that git is working.`;
+  }
+  const files = result.files === null ? "unknown number of" : `${result.files}`;
+  const label = result.label !== "" ? ` \u2014 "${result.label}"` : "";
+  return `Redone: restored ${files} file(s) to the pre-undo state (tree ${result.tree.slice(0, 8)})${label}.`;
+}
+
 // src/cli/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -2921,6 +3254,16 @@ async function buildUndoDiffs(snapshots, cwd) {
   }
   return diffs;
 }
+async function buildUndoTreeDiffs(cwd, tree) {
+  const names = await diffTreeNames(cwd, tree);
+  if (!names || names.length === 0) return [];
+  return [
+    {
+      label: "Working-tree files restoring the turn's start will touch:",
+      lines: names.map((name) => ({ kind: "marker", text: name }))
+    }
+  ];
+}
 
 // src/cli/components/ConnectWizard.tsx
 import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
@@ -3855,18 +4198,19 @@ import { memo } from "react";
 import { Text as Text6 } from "ink";
 import { Fragment, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function DiffLineView({ line }) {
+  const text = toTerminalSafe(line.text);
   if (line.kind === "add") return /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
     "+ ",
-    line.text
+    text
   ] });
   if (line.kind === "del") return /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
     "- ",
-    line.text
+    text
   ] });
-  if (line.kind === "marker") return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: line.text });
+  if (line.kind === "marker") return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: text });
   return /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
     " ",
-    line.text
+    text
   ] });
 }
 function DiffLines({ lines }) {
@@ -3910,6 +4254,17 @@ var MessageList = memo(function MessageList2({ messages }) {
 // src/cli/components/PermissionPrompt.tsx
 import { Box as Box7, Text as Text8, useInput as useInput6 } from "ink";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var BASH_COMMAND_MAX = 1e3;
+function middleTruncate(text, max) {
+  if (text.length <= max) return text;
+  const half = Math.floor((max - 1) / 2);
+  return `${text.slice(0, half)}\u2026${text.slice(text.length - half)}`;
+}
+function bashCommand(args) {
+  if (typeof args !== "object" || args === null) return null;
+  const command = args.command;
+  return typeof command === "string" ? command : null;
+}
 function PermissionPrompt({ request, preview, onDecision }) {
   useInput6((input) => {
     const ch = input.toLowerCase();
@@ -3917,6 +4272,7 @@ function PermissionPrompt({ request, preview, onDecision }) {
     else if (ch === "n") onDecision("no");
     else if (ch === "a") onDecision("always");
   });
+  const command = request.toolName === "bash" ? bashCommand(request.args) : null;
   return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
     /* @__PURE__ */ jsxs8(Text8, { bold: true, color: "yellow", children: [
       "Permission required: ",
@@ -3928,10 +4284,10 @@ function PermissionPrompt({ request, preview, onDecision }) {
     preview ? /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
         preview.type === "new-file" ? "New file: " : "",
-        preview.label
+        toTerminalSafe(preview.label)
       ] }),
       /* @__PURE__ */ jsx8(DiffLines, { lines: preview.lines })
-    ] }) : /* @__PURE__ */ jsx8(Text8, { children: summarizeArgs(request.args) }),
+    ] }) : command !== null ? /* @__PURE__ */ jsx8(Text8, { children: toTerminalSafe(middleTruncate(command, BASH_COMMAND_MAX)) }) : /* @__PURE__ */ jsx8(Text8, { children: toTerminalSafe(summarizeArgs(request.args)) }),
     /* @__PURE__ */ jsx8(Text8, { children: "[y] allow [n] deny [a] always (saved to config)" })
   ] });
 }
@@ -3990,7 +4346,7 @@ var StatusBar = memo2(function StatusBar2({
 }) {
   const { stdout } = useStdout2();
   const wide = (stdout?.columns ?? 80) >= WIDE_COLUMNS;
-  const joined = backgroundTasks.join(", ");
+  const joined = backgroundTasks.map((label) => toTerminalSafe(label)).join(", ");
   const labels = joined.length > BG_LABEL_MAX ? `${joined.slice(0, BG_LABEL_MAX)}\u2026` : joined;
   return /* @__PURE__ */ jsxs10(Box9, { justifyContent: "space-between", children: [
     /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
@@ -4079,34 +4435,59 @@ function ThinkingIndicator({
 
 // src/cli/components/TodoPanel.tsx
 import { Box as Box12, Text as Text13 } from "ink";
-import { jsx as jsx11, jsxs as jsxs13 } from "react/jsx-runtime";
+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__ */ jsx11(Box12, { flexDirection: "column", children: todos.map((todo) => /* @__PURE__ */ jsxs13(
-    Text13,
-    {
-      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)" : ""}`;
 }
@@ -4243,6 +4624,18 @@ async function executeShellBang(raw, cwd, signal) {
   };
 }
 
+// src/cli/system-prompt.ts
+var SYSTEM_PROMPT = `You are Star CLI, an AI coding agent running in the user's terminal.
+You help with software engineering tasks: reading, writing and editing code, running shell commands, and managing todos.
+Be concise and direct. Use tools when they help accomplish the task.
+For any task with two or more steps, start by creating a todo list with todo_write and keep it updated as you progress; only mark an item completed after you have verified its result.
+The working directory is the user's project root; never touch files outside it without explicit instruction.
+For conversion, batch-processing, or other scriptable tasks, write a script file into the working directory and run it instead of pasting long inline code into the shell; once the script's output is verified, delete the script unless the user asked to keep it.
+When a tool call or command fails, read the error output, work out the cause, and try again with a corrected or alternative approach \u2014 never repeat an identical failing call without changing something.
+Never consider the task finished until you have verified the result yourself: run the tests, the build, or a check command that proves the output is correct, and if verification fails or reveals gaps, keep fixing until it passes.
+Do not end your turn while the task is still incomplete; keep going until it is done or you are genuinely blocked, and if you are blocked, state exactly what is missing.
+Never end a reply by announcing what you will do next \u2014 either do it now with tool calls, or do not mention it. Narrating future actions is not progress.`;
+
 // src/cli/ticker.ts
 var TICK_MS = 100;
 function nextFlush(prev, next) {
@@ -4290,7 +4683,7 @@ async function checkForUpdate(currentVersion, fetcher = defaultFetcher2) {
 }
 
 // src/cli/repl.tsx
-import { jsx as jsx12, jsxs as jsxs14 } 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 };
@@ -4301,19 +4694,25 @@ function runningTaskLabels() {
   return [...shells, ...agents];
 }
 var SESSION_MODE_CYCLE = ["ask", "auto", "readonly", "plan"];
+var BUSY_BLOCKED_COMMANDS = /* @__PURE__ */ new Set([
+  "new",
+  "resume",
+  "undo",
+  "redo",
+  "rewind",
+  "compact",
+  "fork",
+  "clear-sessions",
+  "model",
+  "connect",
+  "memory"
+]);
 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;
-async function sessionPreview(id) {
-  const store = await SessionStore.open(id);
-  if (!store) return null;
-  const first = (await store.messages()).find((m) => m.role === "user");
-  if (!first) return null;
-  const text = coreMessageText(first).replace(/\s+/g, " ").trim();
-  if (!text) return null;
-  return text.length > 60 ? `${text.slice(0, 60)}\u2026` : text;
-}
+var SESSION_PREVIEW_MAX = 60;
+var MAX_VISIBLE_QUEUED = 5;
 function Repl({
   backend,
   model,
@@ -4349,12 +4748,14 @@ function Repl({
   const nextIdRef = useRef5(initialDisplay.length);
   const abortRef = useRef5(null);
   const streamedRef = useRef5("");
+  const lastCommittedLenRef = useRef5(0);
   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 permissionChainRef = useRef5(Promise.resolve());
   const alwaysAllowedRef = useRef5(/* @__PURE__ */ new Set());
   const prevModeRef = useRef5(null);
   const planApprovalRef = useRef5(false);
@@ -4363,6 +4764,10 @@ function Repl({
   const pendingConnectRef = useRef5(null);
   const modelNameRef = useRef5(model);
   const sessionStoreRef = useRef5(sessionStore);
+  const configRef = useRef5(config);
+  useEffect2(() => {
+    configRef.current = config;
+  }, [config]);
   const usageRef = useRef5(initialUsage ? { ...initialUsage } : emptyUsage());
   const turnChunksRef = useRef5(0);
   const messagesRef = useRef5(initialDisplay);
@@ -4538,14 +4943,22 @@ function Repl({
   );
   const attachConfirmHandler = useCallback(
     (target) => {
-      target.confirmHandler = async (req) => {
+      target.confirmHandler = (req) => {
         if (isAllowedByRules([...alwaysAllowedRef.current], req)) {
-          return true;
+          return Promise.resolve(true);
         }
-        const preview = await generateDiffPreview(req.toolName, req.args, cwd).catch(() => null);
-        return new Promise((resolve) => {
-          setPendingPermission({ request: req, preview, resolve });
-        });
+        const ask = async () => {
+          const preview = await generateDiffPreview(req.toolName, req.args, cwd).catch(() => null);
+          return new Promise((resolve) => {
+            setPendingPermission({ request: req, preview, resolve });
+          });
+        };
+        const decision = permissionChainRef.current.then(ask);
+        permissionChainRef.current = decision.then(
+          () => void 0,
+          () => void 0
+        );
+        return decision;
       };
       target.onHookWarning = (message) => pushMessage("system", message);
     },
@@ -4576,27 +4989,29 @@ function Repl({
       setBgLabels(runningTaskLabels());
       pushMessage(
         "system",
-        task.status === "running" ? formatTaskStarted(task) : formatTaskFinished(task)
+        toTerminalSafe(
+          task.status === "running" ? formatTaskStarted(task) : formatTaskFinished(task)
+        )
       );
       if (task.status !== "running") {
         notifyBell({
-          enabled: config.notifyBell,
-          thresholdSec: config.notifyBellThresholdSec,
+          enabled: configRef.current.notifyBell,
+          thresholdSec: configRef.current.notifyBellThresholdSec,
           noNotifyEnv: process.env.STAR_NO_NOTIFY === "1"
         });
       }
     };
     const onAgentUpdate = (task) => {
       setBgLabels(runningTaskLabels());
-      const label = task.description ? `: ${task.description}` : "";
+      const label = task.description ? `: ${toTerminalSafe(task.description)}` : "";
       pushMessage(
         "system",
         task.status === "running" ? `Background subagent ${task.id} started${label}` : `Background subagent ${task.id} ${task.status}${label}`
       );
       if (task.status !== "running") {
         notifyBell({
-          enabled: config.notifyBell,
-          thresholdSec: config.notifyBellThresholdSec,
+          enabled: configRef.current.notifyBell,
+          thresholdSec: configRef.current.notifyBellThresholdSec,
           noNotifyEnv: process.env.STAR_NO_NOTIFY === "1"
         });
       }
@@ -4609,7 +5024,7 @@ function Repl({
       defaultTaskManager.cleanup();
       defaultAgentTasks.cleanup();
     };
-  }, [pushMessage, config]);
+  }, [pushMessage]);
   const interrupt = useCallback(() => {
     abortRef.current?.abort();
     const p = pendingRef.current;
@@ -4648,9 +5063,11 @@ function Repl({
   const handleExit = useCallback(() => {
     const killed = defaultTaskManager.cleanup();
     const killedAgents = defaultAgentTasks.cleanup();
-    const stopped = [...killed.map((t) => t.id), ...killedAgents.map((t) => t.id)];
-    if (stopped.length > 0) {
-      pushMessage("system", `Stopped ${stopped.length} background task(s): ${stopped.join(", ")}`);
+    const stopped = killed.length + killedAgents.length;
+    if (stopped > 0) {
+      pushMessage("system", `${stopped} background task(s) still running; reports will be lost.`);
+      setTimeout(exit, 50);
+      return;
     }
     exit();
   }, [exit, pushMessage]);
@@ -4711,6 +5128,7 @@ function Repl({
           registry: createDefaultRegistry(),
           config,
           cwd,
+          system: SYSTEM_PROMPT,
           sessionStore: sessionStoreRef.current,
           contextMaxTokens: contextWindowTokens(config, name)
         });
@@ -4752,12 +5170,15 @@ function Repl({
       if (!resumed) {
         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));
+      if (!store) {
+        return `Session not found: ${id}`;
       }
+      await current.loadMessages(resumed.messages);
+      current.setSessionStore(store);
+      sessionStoreRef.current = store;
+      setTodos(await loadTodos(cwd));
+      hydrateSnapshots(await loadSessionSnapshots(store.dir));
       const display = buildDisplayMessages(resumed.messages);
       nextIdRef.current = display.length;
       applyMessages(display);
@@ -4783,6 +5204,7 @@ function Repl({
       abortRef.current = controller;
       const turnStartedAt = Date.now();
       streamedRef.current = "";
+      lastCommittedLenRef.current = 0;
       thinkingRef.current = true;
       reasoningRef.current = "";
       turnChunksRef.current = 0;
@@ -4793,22 +5215,25 @@ function Repl({
       setIsStreaming(true);
       flushedRef.current = { streamed: "", reasoning: "" };
       const commitStreamed = (tight) => {
-        if (streamedRef.current.length === 0) return;
-        pushAssistantChunk(streamedRef.current, tight);
+        const uncommitted = streamedRef.current.slice(lastCommittedLenRef.current);
+        if (uncommitted.length > 0) {
+          pushAssistantChunk(uncommitted, tight);
+        }
         streamedRef.current = "";
+        lastCommittedLenRef.current = 0;
         flushedRef.current = { ...flushedRef.current, streamed: "" };
         setStreamingText("");
       };
       tickerStopRef.current = startTicker((tick) => {
         setSpinnerTick(tick);
-        const split = splitCommittableLines(streamedRef.current, 8);
+        const uncommitted = streamedRef.current.slice(lastCommittedLenRef.current);
+        const split = splitCommittableLines(uncommitted, 8);
         if (split) {
           pushAssistantChunk(split.committed, true);
-          streamedRef.current = split.rest;
-          flushedRef.current = { ...flushedRef.current, streamed: "" };
+          lastCommittedLenRef.current += split.committed.length + 1;
         }
         const next = {
-          streamed: streamedRef.current,
+          streamed: streamedRef.current.slice(lastCommittedLenRef.current),
           reasoning: reasoningRef.current
         };
         if (nextFlush(flushedRef.current, next) !== null) {
@@ -4835,9 +5260,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, {
@@ -4877,6 +5302,12 @@ function Repl({
               usage.promptTokens += event.usage.promptTokens;
               usage.completionTokens += event.usage.completionTokens;
               usage.totalTokens += event.usage.totalTokens;
+              if (event.usage.cachedPromptTokens) {
+                usage.cachedPromptTokens = (usage.cachedPromptTokens ?? 0) + event.usage.cachedPromptTokens;
+              }
+              if (event.usage.cacheReadInputTokens) {
+                usage.cacheReadInputTokens = (usage.cacheReadInputTokens ?? 0) + event.usage.cacheReadInputTokens;
+              }
               if (cacheUsageReported(event.usage)) {
                 if (!usage.cache) usage.cache = { cachedTokens: 0, promptTokens: 0 };
                 addToCacheTotals(usage.cache, event.usage);
@@ -4886,9 +5317,13 @@ function Repl({
               });
             }
           } else if (event.type === "retry") {
+            streamedRef.current = streamedRef.current.slice(0, lastCommittedLenRef.current);
+            flushedRef.current = { ...flushedRef.current, streamed: "" };
+            setStreamingText("");
+            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);
@@ -4915,8 +5350,9 @@ function Repl({
         setThinkingText("");
         setThoughtSummary(null);
         setActivity(null);
-        const finalText = streamedRef.current;
+        const finalText = streamedRef.current.slice(lastCommittedLenRef.current);
         streamedRef.current = "";
+        lastCommittedLenRef.current = 0;
         setStreamingText(null);
         const interrupted = controller.signal.aborted;
         notifyBell({
@@ -5099,10 +5535,8 @@ ${lines.join("\n")}`;
         return ctx.permissionMode(picked);
       },
       pickSession: async (all) => {
-        const entries = (await listSessionEntries(all ? void 0 : cwd)).slice(
-          0,
-          SESSION_PICKER_CAP
-        );
+        const currentId = sessionStoreRef.current?.id;
+        const entries = (await listSessionEntries(all ? void 0 : cwd)).filter((entry) => entry.meta.id !== currentId).slice(0, SESSION_PICKER_CAP);
         if (entries.length === 0) {
           return all ? "No sessions found." : "No sessions found for this directory.";
         }
@@ -5110,13 +5544,16 @@ ${lines.join("\n")}`;
           entries.map(async ({ meta, messageCount }) => {
             const parts = [`${messageCount} messages \xB7 ${relativeTime(meta.updatedAt)}`];
             const preview = await sessionPreview(meta.id);
-            if (preview) parts.push(preview);
+            if (preview) {
+              parts.push(
+                preview.length > SESSION_PREVIEW_MAX ? `${preview.slice(0, SESSION_PREVIEW_MAX)}\u2026` : preview
+              );
+            }
             if (all) parts.push(`[${meta.cwd}]`);
             return {
               value: meta.id,
               label: meta.title || shortSessionId(meta.id),
-              description: parts.join(" \xB7 "),
-              hint: meta.id === sessionStoreRef.current?.id ? "current" : void 0
+              description: parts.join(" \xB7 ")
             };
           })
         );
@@ -5229,15 +5666,16 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         if (preview.removed === 0) {
           return "Nothing to undo (no conversation turn to retract).";
         }
-        const diffs = await buildUndoDiffs(
+        const diffs = preview.tree ? await buildUndoTreeDiffs(cwd, preview.tree) : await buildUndoDiffs(
           preview.turn !== void 0 ? listTurnSnapshots(preview.turn) : [],
           cwd
         );
+        const summary = preview.tree ? `${preview.removed} message(s) will be retracted, and the working tree restored to the turn's start (git snapshot \u2014 covers changes from any tool, bash included).` : `${preview.removed} message(s) will be retracted, ${diffs.length} file change(s) reverted.`;
         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.`,
+            summary,
             diffs,
             resolve
           });
@@ -5245,11 +5683,10 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         if (!confirmed) {
           return "Undo cancelled.";
         }
-        const { removed, turn } = await current.retractLastTurn();
-        if (removed === 0) {
+        const outcome = await current.undoLastTurn();
+        if (outcome.removed === 0) {
           return "Nothing to undo (no conversation turn to retract).";
         }
-        const reverted = turn !== void 0 ? await undoTurnSnapshots(turn) : [];
         const visible = messagesRef.current;
         let cut = -1;
         for (let i = visible.length - 1; i >= 0; i--) {
@@ -5259,9 +5696,36 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
           }
         }
         redrawMessages(cut >= 0 ? visible.slice(0, cut) : visible);
-        return [...reverted, `Retracted the last conversation turn (${removed} messages).`].join(
-          "\n"
-        );
+        return [
+          ...outcome.reverted,
+          `Retracted the last conversation turn (${outcome.removed} messages).`
+        ].join("\n");
+      },
+      redo: async () => {
+        const current = backendRef.current;
+        if (!(current instanceof AgentLoop)) {
+          return "Nothing to redo.";
+        }
+        const entry = current.peekRedo();
+        if (!entry) {
+          return "Nothing to redo.";
+        }
+        const confirmed = await new Promise((resolve) => {
+          setPendingRewind({
+            title: "Redo last undo",
+            confirmLabel: "redo",
+            summary: formatRedoSummary(entry),
+            resolve
+          });
+        });
+        if (!confirmed) {
+          return "Redo cancelled.";
+        }
+        const result = await current.redoLastUndo();
+        if (!result) {
+          return "Nothing to redo.";
+        }
+        return formatRedoResult(result);
       },
       rewind: async (args) => {
         if (!args) {
@@ -5444,6 +5908,10 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
           );
           return;
         }
+        if (abortRef.current && BUSY_BLOCKED_COMMANDS.has(parsed.name)) {
+          pushMessage("system", "Busy \u2014 wait for the turn to finish or press Esc to interrupt it.");
+          return;
+        }
         void command.run(parsed.args, registry.ctx);
         return;
       }
@@ -5487,8 +5955,8 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
   }, [cwd, config, isStreaming, epoch]);
   const sessionCost = sessionCostUsd();
   return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx12(MessageList, { messages }, `messages-${epoch}`),
-    (thinking || activity !== null) && /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsx11(MessageList, { messages }, `messages-${epoch}`),
+    (thinking || activity !== null) && /* @__PURE__ */ jsx11(
       ThinkingIndicator,
       {
         reasoning: thinkingText,
@@ -5496,9 +5964,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         activity: activity ?? void 0
       }
     ),
-    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx12(Text14, { dimColor: true, children: thoughtSummary }),
-    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx12(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
-    pending && /* @__PURE__ */ jsx12(
+    !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,
@@ -5506,8 +5974,8 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onDecision: handleDecision
       }
     ),
-    planApproval && /* @__PURE__ */ jsx12(ExitPlanPrompt, { onDecision: handlePlanDecision }),
-    pendingRewind && /* @__PURE__ */ jsx12(
+    planApproval && /* @__PURE__ */ jsx11(ExitPlanPrompt, { onDecision: handlePlanDecision }),
+    pendingRewind && /* @__PURE__ */ jsx11(
       RewindConfirmPrompt,
       {
         summary: pendingRewind.summary,
@@ -5517,7 +5985,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onDecision: handleRewindDecision
       }
     ),
-    picker && /* @__PURE__ */ jsx12(
+    picker && /* @__PURE__ */ jsx11(
       SelectPrompt,
       {
         title: picker.title,
@@ -5526,7 +5994,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onCancel: handlePickerCancel
       }
     ),
-    pendingConnect && /* @__PURE__ */ jsx12(
+    pendingConnect && /* @__PURE__ */ jsx11(
       ConnectWizard,
       {
         existingProviderNames: config.providers.map((p) => p.name),
@@ -5538,17 +6006,22 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onCancel: cancelConnect
       }
     ),
-    queueItems.map((item) => /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+    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)),
+    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__ */ jsx12(TodoPanel, { todos }),
-    /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsx11(TodoPanel, { todos }),
+    /* @__PURE__ */ jsx11(
       InputBox,
       {
         isStreaming,
@@ -5563,7 +6036,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onPasteImage: handlePasteImage
       }
     ),
-    /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsx11(
       StatusBar,
       {
         cwd,
@@ -5584,7 +6057,7 @@ function renderRepl(backend, opts) {
     defaultTaskManager.cleanup();
   });
   return render(
-    /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsx11(
       Repl,
       {
         backend,
@@ -5621,6 +6094,37 @@ function parseTomlFile(content, filePath) {
 function mergeConfig(base, override) {
   return { ...base, ...override };
 }
+var PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "defaultModel",
+  "models",
+  "maxSteps",
+  "contextMaxTokens",
+  "streamIdleTimeoutSec",
+  "streamFirstChunkTimeoutSec",
+  "streamMaxRetries",
+  "maxAutoContinues",
+  "contextCompaction",
+  "sessionBudgetUsd",
+  "notifyBell",
+  "notifyBellThresholdSec",
+  "doomLoopThreshold",
+  "gitSnapshots"
+]);
+function sanitizeProjectConfig(project, filePath) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(project)) {
+    if (value === void 0) continue;
+    if (PROJECT_ALLOWED_KEYS.has(key)) {
+      sanitized[key] = value;
+    } else {
+      process.stderr.write(
+        `[star] ignoring "${key}" in ${filePath}: project config cannot set this key
+`
+      );
+    }
+  }
+  return sanitized;
+}
 function applyOverrides(config, overrides) {
   if (!overrides) return config;
   const merged = { ...config };
@@ -5636,22 +6140,13 @@ function readTomlFileSync(filePath) {
 function loadConfigSync(cwd, overrides) {
   loadEnvFile();
   const global = readTomlFileSync(globalConfigPath());
-  const project = readTomlFileSync(projectConfigPath(cwd));
+  const projectPath = projectConfigPath(cwd);
+  const project = sanitizeProjectConfig(readTomlFileSync(projectPath), projectPath);
   const merged = applyOverrides(mergeConfig(global, project), overrides);
   return ConfigSchema.parse(merged);
 }
 
 // src/main.tsx
-var SYSTEM_PROMPT = `You are Star CLI, an AI coding agent running in the user's terminal.
-You help with software engineering tasks: reading, writing and editing code, running shell commands, and managing todos.
-Be concise and direct. Use tools when they help accomplish the task.
-For any task with two or more steps, start by creating a todo list with todo_write and keep it updated as you progress; only mark an item completed after you have verified its result.
-The working directory is the user's project root; never touch files outside it without explicit instruction.
-For conversion, batch-processing, or other scriptable tasks, write a script file into the working directory and run it instead of pasting long inline code into the shell; once the script's output is verified, delete the script unless the user asked to keep it.
-When a tool call or command fails, read the error output, work out the cause, and try again with a corrected or alternative approach \u2014 never repeat an identical failing call without changing something.
-Never consider the task finished until you have verified the result yourself: run the tests, the build, or a check command that proves the output is correct, and if verification fails or reveals gaps, keep fixing until it passes.
-Do not end your turn while the task is still incomplete; keep going until it is done or you are genuinely blocked, and if you are blocked, state exactly what is missing.
-Never end a reply by announcing what you will do next \u2014 either do it now with tool calls, or do not mention it. Narrating future actions is not progress.`;
 async function createLoop(config, modelName, cwd, sessionStore) {
   const model = createModel(config, modelName);
   const registry = createDefaultRegistry();
@@ -5665,7 +6160,7 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     contextMaxTokens: contextWindowTokens(config, modelName)
   });
 }
-async function printMode(loop, prompt, cwd, json, imagePaths) {
+async function printMode(loop, prompt, cwd, json, imagePaths, sessionStore) {
   const flagImages = [];
   for (const imagePath of imagePaths) {
     if (!imageMimeType(imagePath)) {
@@ -5734,15 +6229,22 @@ async function printMode(loop, prompt, cwd, json, imagePaths) {
         }
         case "finish":
           usage.add(event.usage);
+          if (event.usage) {
+            sessionStore?.addUsage(event.usage).catch(() => {
+            });
+          }
           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}
@@ -5780,8 +6282,15 @@ async function printMode(loop, prompt, cwd, json, imagePaths) {
     }
   }
   if (!json) process.stdout.write("\n");
-  defaultTaskManager.cleanup();
-  defaultAgentTasks.cleanup();
+  const killedShells = defaultTaskManager.cleanup();
+  const killedAgents = defaultAgentTasks.cleanup();
+  const stopped = killedShells.length + killedAgents.length;
+  if (stopped > 0) {
+    process.stderr.write(
+      `[info] ${stopped} background task(s) were still running and have been stopped.
+`
+    );
+  }
   return exitCode;
 }
 var program = new Command();
@@ -5859,12 +6368,17 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
     }
   }
   if (resumeId) {
-    resumed = await resumeSession(resumeId);
-    if (!resumed) {
+    sessionStore = await SessionStore.open(resumeId);
+    if (!sessionStore) {
       console.error(`Session not found: ${resumeId}`);
       process.exit(1);
     }
-    sessionStore = await SessionStore.open(resumeId);
+    const [meta, loaded] = await Promise.all([sessionStore.meta(), sessionStore.messages()]);
+    const messages = reconcileToolCalls(loaded);
+    if (messages.length !== loaded.length) {
+      await sessionStore.replaceMessages(messages);
+    }
+    resumed = { meta, messages };
   } else if (!opts.print) {
     sessionStore = await SessionStore.create(cwd, modelName);
   }
@@ -5888,7 +6402,8 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
       opts.print,
       cwd,
       Boolean(opts.json),
-      opts.image ?? []
+      opts.image ?? [],
+      sessionStore
     );
     return;
   }