@cryer/star-cli 0.3.2 → 0.3.4

package/dist/main.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   AgentLoop,
+  ConfigSchema,
   MAX_IMAGE_DIMENSION,
   SKIP_DIRS,
   TodoStore,
@@ -13,12 +14,15 @@ import {
   collectCommitContext,
   collectWorkingDiff,
   compactMessages,
+  contextWindowTokens,
   createDefaultRegistry,
   createIgnorePredicate,
   defaultAgentTasks,
   defaultTaskManager,
+  diffTreeNames,
   discoverSkills,
   estimateTokens,
+  formatAgentTaskUpdate,
   formatTaskFinished,
   formatTaskList,
   formatTaskStarted,
@@ -39,9 +43,8 @@ import {
   resolveShell,
   resolveSnapshotContent,
   rewindToSnapshot,
-  summarizeMessages,
-  undoTurnSnapshots
-} from "./chunk-BV4PLM6X.js";
+  summarizeMessages
+} from "./chunk-K3R42LOX.js";
 import {
   envFilePath,
   globalConfigPath,
@@ -49,11 +52,20 @@ import {
   sessionsDir,
   starHome,
   userMemoryPath
-} from "./chunk-LADQCYKL.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;
@@ -98,7 +110,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++;
       }
@@ -110,7 +122,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;
@@ -168,7 +180,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) {
@@ -236,6 +256,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",
@@ -261,7 +282,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();
@@ -294,13 +315,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;
@@ -325,11 +351,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)`
     );
@@ -473,11 +501,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;
@@ -485,117 +558,47 @@ 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");
-}
-
-// 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(),
-  apiKey: z.string().optional(),
-  headers: z.record(z.string()).optional()
-});
-var ModelConfigSchema = z.object({
-  name: z.string(),
-  provider: z.string(),
-  model: z.string(),
-  maxTokens: z.number().int().positive().optional(),
-  // Per-model context window; overrides the top-level contextMaxTokens for
-  // compaction and the status bar when set.
-  contextMaxTokens: z.number().int().positive().optional(),
-  // 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()
-});
-var PermissionsConfigSchema = z.object({
-  allow: z.array(z.string()).default([]),
-  deny: z.array(z.string()).default([])
-});
-var HookConfigSchema = z.object({
-  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
-  matcher: z.string().refine(
-    (pattern) => {
-      try {
-        new RegExp(pattern);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    { message: "invalid regular expression" }
-  ).optional(),
-  command: z.string().min(1),
-  timeoutSec: z.number().positive().default(30)
-});
-var ConfigSchema = z.object({
-  defaultModel: z.string().default(""),
-  permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
-  providers: z.array(ProviderConfigSchema).default([]),
-  models: z.array(ModelConfigSchema).default([]),
-  maxSteps: z.number().int().positive().default(50),
-  contextMaxTokens: z.number().int().positive().default(1e5),
-  // Seconds without any stream part before a stalled response is ended
-  // gracefully (some relays never send the terminal chunks). Applies once
-  // streaming has started; the first part gets a longer, fixed allowance.
-  streamIdleTimeoutSec: z.number().positive().default(20),
-  // Seconds to wait for the very first stream part before giving up; slow
-  // thinking-model relays can buffer for minutes before sending anything.
-  streamFirstChunkTimeoutSec: z.number().positive().default(300),
-  // 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.
-  // 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 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
-  // once the estimated cost for the session reaches this amount.
-  sessionBudgetUsd: z.number().positive().optional(),
-  // Terminal bell (REPL only): ring when a turn takes longer than
-  // notifyBellThresholdSec, and when a background task finishes.
-  // STAR_NO_NOTIFY=1 disables without touching the config.
-  notifyBell: z.boolean().default(true),
-  notifyBellThresholdSec: z.number().positive().default(10),
-  permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
-  hooks: z.array(HookConfigSchema).default([])
-});
-function contextWindowTokens(config, modelName) {
-  return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
+  await writeFileAtomic(filePath, upsertTopLevelKeyText(content, "permissionMode", mode));
 }
 
 // src/llm/provider.ts
@@ -674,10 +677,13 @@ function createSseNormalizingFetch(baseFetch = fetch) {
       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: response.headers
+      headers
     });
   };
 }
@@ -715,7 +721,7 @@ 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,
@@ -738,6 +744,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`);
 }
@@ -756,32 +777,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
   }));
 }
 
@@ -802,6 +827,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())}`;
@@ -811,6 +840,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);
@@ -840,6 +872,7 @@ var SessionStore = class _SessionStore {
     } catch {
       debugWarn(`session ${id}: corrupt meta.json, using defaults`);
     }
+    await store.sweepTmpFiles();
     store.initialized = true;
     return store;
   }
@@ -850,16 +883,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;
@@ -868,7 +925,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: "",
@@ -877,16 +935,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();
@@ -895,7 +968,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;
@@ -918,13 +991,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();
@@ -935,7 +1019,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();
@@ -960,6 +1044,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 ?? {};
@@ -969,7 +1059,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);
   }
 };
 
@@ -1026,6 +1116,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);
@@ -1042,20 +1159,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");
 }
@@ -1086,7 +1203,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);
@@ -1102,7 +1221,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
@@ -1178,6 +1298,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 {
@@ -1232,7 +1358,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"];
@@ -1306,7 +1432,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";
@@ -1385,6 +1511,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;
@@ -1397,22 +1530,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 {
@@ -1455,10 +1584,10 @@ async function compactSession(opts) {
     };
   }
   const beforeTokens = estimateTokens(messages);
-  const compacted = compactMessages(messages, config.contextMaxTokens);
+  const compacted = compactMessages(messages, config.contextMaxTokens, { force: true });
   if (!compacted.compacted) {
     return {
-      message: `Nothing to compact: ~${beforeTokens} estimated tokens, below the limit of ${config.contextMaxTokens}.`,
+      message: `Nothing to compact: history is too short to drop a whole turn (~${beforeTokens} estimated tokens).`,
       compacted: false
     };
   }
@@ -1772,7 +1901,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");
@@ -2071,13 +2200,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",
@@ -2349,19 +2487,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:",
@@ -2373,9 +2511,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}`,
@@ -2443,7 +2581,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++) {
@@ -2883,6 +3021,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();
@@ -2998,6 +3150,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";
@@ -3932,18 +4094,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 }) {
@@ -3987,6 +4150,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();
@@ -3994,6 +4168,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: ",
@@ -4005,10 +4180,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)" })
   ] });
 }
@@ -4067,7 +4242,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: [
@@ -4156,17 +4331,6 @@ function ThinkingIndicator({
 
 // src/cli/components/TodoPanel.tsx
 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: "[ ]",
@@ -4356,6 +4520,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) {
@@ -4414,20 +4590,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;
+var SESSION_PREVIEW_MAX = 60;
 var MAX_VISIBLE_QUEUED = 5;
-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;
-}
 function Repl({
   backend,
   model,
@@ -4463,12 +4644,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);
@@ -4477,6 +4660,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);
@@ -4652,14 +4839,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);
     },
@@ -4690,27 +4885,25 @@ 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}` : "";
-      pushMessage(
-        "system",
-        task.status === "running" ? `Background subagent ${task.id} started${label}` : `Background subagent ${task.id} ${task.status}${label}`
-      );
+      pushMessage("system", toTerminalSafe(formatAgentTaskUpdate(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"
         });
       }
@@ -4723,7 +4916,7 @@ function Repl({
       defaultTaskManager.cleanup();
       defaultAgentTasks.cleanup();
     };
-  }, [pushMessage, config]);
+  }, [pushMessage]);
   const interrupt = useCallback(() => {
     abortRef.current?.abort();
     const p = pendingRef.current;
@@ -4762,9 +4955,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]);
@@ -4825,6 +5020,7 @@ function Repl({
           registry: createDefaultRegistry(),
           config,
           cwd,
+          system: SYSTEM_PROMPT,
           sessionStore: sessionStoreRef.current,
           contextMaxTokens: contextWindowTokens(config, name)
         });
@@ -4866,12 +5062,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);
@@ -4897,6 +5096,7 @@ function Repl({
       abortRef.current = controller;
       const turnStartedAt = Date.now();
       streamedRef.current = "";
+      lastCommittedLenRef.current = 0;
       thinkingRef.current = true;
       reasoningRef.current = "";
       turnChunksRef.current = 0;
@@ -4907,22 +5107,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) {
@@ -4991,6 +5194,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);
@@ -5000,6 +5209,9 @@ 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",
@@ -5030,8 +5242,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({
@@ -5214,10 +5427,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.";
         }
@@ -5225,13 +5436,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 ")
             };
           })
         );
@@ -5316,18 +5530,26 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         } catch {
           summaryModel = null;
         }
-        const result = await compactSession({
-          backend: backendRef.current,
-          sessionStore: sessionStoreRef.current,
-          config,
-          model: summaryModel
-        });
-        if (result.compacted && result.messages) {
-          const display = buildDisplayMessages(result.messages);
-          nextIdRef.current = display.length;
-          applyMessages(display);
+        tickerStopRef.current = startTicker((tick) => setSpinnerTick(tick));
+        setActivity("compacting context\u2026");
+        try {
+          const result = await compactSession({
+            backend: backendRef.current,
+            sessionStore: sessionStoreRef.current,
+            config,
+            model: summaryModel
+          });
+          if (result.compacted && result.messages) {
+            const display = buildDisplayMessages(result.messages);
+            nextIdRef.current = display.length;
+            applyMessages(display);
+          }
+          return result.message;
+        } finally {
+          tickerStopRef.current?.();
+          tickerStopRef.current = null;
+          setActivity(null);
         }
-        return result.message;
       },
       exportSession: (arg) => exportSession({
         backend: backendRef.current,
@@ -5344,15 +5566,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
           });
@@ -5360,11 +5583,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--) {
@@ -5374,9 +5596,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) {
@@ -5472,6 +5721,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         `models (${config.models.length}): ${config.models.map((m) => m.name).join(", ") || "(none)"}`,
         `maxSteps: ${config.maxSteps}`,
         `contextMaxTokens: ${config.contextMaxTokens}`,
+        `compactThresholdTokens: ${config.compactThresholdTokens ?? "(context window)"}`,
         `streamIdleTimeoutSec: ${config.streamIdleTimeoutSec}`,
         `streamFirstChunkTimeoutSec: ${config.streamFirstChunkTimeoutSec}`,
         `streamMaxRetries: ${config.streamMaxRetries}`,
@@ -5559,6 +5809,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;
       }
@@ -5741,6 +5995,38 @@ function parseTomlFile(content, filePath) {
 function mergeConfig(base, override) {
   return { ...base, ...override };
 }
+var PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "defaultModel",
+  "models",
+  "maxSteps",
+  "contextMaxTokens",
+  "compactThresholdTokens",
+  "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 };
@@ -5756,22 +6042,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();
@@ -5785,7 +6062,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)) {
@@ -5854,6 +6131,10 @@ 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) {
@@ -5903,8 +6184,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();
@@ -5982,12 +6270,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);
   }
@@ -6011,7 +6304,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;
   }