@cryer/star-cli 0.3.7 → 0.3.9

package/dist/{chunk-4X25DNTF.js → chunk-VJFWTXWN.js}

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
+import {
+  coreMessageText,
+  pruneTreeReposExcept,
+  removeTreeRepo
+} from "./chunk-56ZIA57D.js";
 import {
   SKIP_DIRS,
   createIgnorePredicate,
   downsampleImageIfNeeded,
-  envFilePath,
   isSensitivePath,
-  pruneTreeReposExcept,
-  removeTreeRepo,
-  sessionsDir,
-  wrapFetchWithActivity
-} from "./chunk-OOOW7FC4.js";
+  sessionsDir
+} from "./chunk-A5PXPWHB.js";
 
 // src/cli/cost.ts
 function formatDollars(cost) {
@@ -53,6 +54,70 @@ function estimateCost(usage, modelName, model) {
   return `Estimated cost: $${formatDollars(cost)} (${model?.name} @ $${model?.promptPrice}/M prompt, $${model?.completionPrice}/M completion${cachePrice})`;
 }
 
+// src/cli/icons.ts
+var EMOJI_TERM_PROGRAMS = /* @__PURE__ */ new Set([
+  "vscode",
+  "WezTerm",
+  "iTerm.app",
+  "Apple_Terminal",
+  "ghostty",
+  "kitty",
+  "Hyper",
+  "WarpTerminal"
+]);
+function resolveIconMode(env = process.env) {
+  const override = env.STAR_ICONS;
+  if (override === "emoji" || override === "plain") return override;
+  if (env.WT_SESSION) return "emoji";
+  if (EMOJI_TERM_PROGRAMS.has(env.TERM_PROGRAM ?? "")) return "emoji";
+  const term = env.TERM ?? "";
+  if (term.includes("kitty") || term.includes("alacritty")) return "emoji";
+  return "plain";
+}
+var EMOJI_TOOL_ICONS = {
+  bash: "\u{1F4BB}",
+  read_file: "\u{1F4C4}",
+  write_file: "\u{1F4DD}",
+  edit_file: "\u270F\uFE0F",
+  glob: "\u{1F4C2}",
+  grep: "\u{1F50D}",
+  web_search: "\u{1F50E}",
+  web_fetch: "\u{1F310}",
+  todo_write: "\u{1F4CB}",
+  todo_read: "\u{1F4CB}",
+  task_list: "\u{1F9F5}",
+  task_output: "\u{1F9F5}",
+  task_kill: "\u{1F6D1}",
+  subagent: "\u{1F916}",
+  skill: "\u2728",
+  remember: "\u{1F9E0}"
+};
+var PLAIN_TOOL_ICONS = {
+  bash: "$",
+  read_file: "\u2261",
+  write_file: "+",
+  edit_file: "\u270E",
+  glob: "*",
+  grep: "/",
+  web_search: "?",
+  web_fetch: "\u21D3",
+  todo_write: "\u2023",
+  todo_read: "\u2023",
+  task_list: "\xB6",
+  task_output: "\xB6",
+  task_kill: "\xD7",
+  subagent: "\u25C9",
+  skill: "\u2727",
+  remember: "\u203B"
+};
+var iconMode = resolveIconMode();
+function toolIcon(name) {
+  const map = iconMode === "emoji" ? EMOJI_TOOL_ICONS : PLAIN_TOOL_ICONS;
+  return map[name] ?? (iconMode === "emoji" ? "\u{1F527}" : "\u25B8");
+}
+var thinkingIcon = iconMode === "emoji" ? "\u{1F4AD}" : "\u2727";
+var folderIcon = iconMode === "emoji" ? "\u{1F4C1} " : "";
+
 // src/cli/terminal-text.ts
 var UNSAFE_CHARS = /[\x00-\x09\x0b-\x1f\x7f]/;
 var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f]/g;
@@ -298,25 +363,48 @@ function formatStreamError(error) {
   }
   return error.message;
 }
-function coreMessageText(message) {
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
-  }
-  return "";
-}
 function buildDisplayMessages(messages) {
   const display = [];
   let collapsed = 0;
   for (const message of messages) {
     if (message.role === "user" || message.role === "assistant") {
-      const text = coreMessageText(message);
-      if (text) {
+      const content = message.content;
+      if (!Array.isArray(content)) {
+        const text = coreMessageText(message);
+        if (text) {
+          display.push({ id: display.length, role: message.role, text: toTerminalSafe(text) });
+        } else {
+          collapsed++;
+        }
+        continue;
+      }
+      let textParts = [];
+      let represented = false;
+      const flushText = () => {
+        const text = textParts.join(" ");
+        textParts = [];
+        if (!text) return;
+        represented = true;
         display.push({ id: display.length, role: message.role, text: toTerminalSafe(text) });
-      } else {
-        collapsed++;
+      };
+      for (const part of content) {
+        if (part.type === "text" && "text" in part) {
+          textParts.push(part.text);
+        } else if (part.type === "tool-call") {
+          flushText();
+          represented = true;
+          display.push({
+            id: display.length,
+            role: "tool",
+            text: toTerminalSafe(
+              `${toolIcon(part.toolName)} ${part.toolName} ${summarizeArgs(part.args)}`
+            ),
+            dim: true
+          });
+        }
       }
+      flushText();
+      if (!represented) collapsed++;
     } else if (message.role === "tool") {
       collapsed++;
     }
@@ -529,292 +617,15 @@ ${buf.toString("utf8")}
   return { input, attached, skipped, images };
 }
 
-// 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/llm/registry.ts
-function listModels(config) {
-  return config.models;
-}
-function resolveModelConfig(config, modelName) {
-  const name = modelName ?? config.defaultModel;
-  const model = config.models.find((m) => m.name === name);
-  if (!model) {
-    const available = config.models.map((m) => m.name).join(", ") || "(none)";
-    throw new Error(`Model "${name}" not found. Available models: ${available}`);
-  }
-  return model;
-}
-
-// src/llm/provider.ts
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-
-// src/llm/sse-normalize.ts
-function splitJsonPrefix(text) {
-  if (!text.startsWith("{")) return null;
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (ch === '"') inString = true;
-    else if (ch === "{") depth += 1;
-    else if (ch === "}") {
-      depth -= 1;
-      if (depth === 0) return [text.slice(0, i + 1), text.slice(i + 1).trimStart()];
-    }
-  }
-  return null;
-}
-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 emitPayload = (payload, controller) => {
-      let rest = payload;
-      for (; ; ) {
-        const split = splitJsonPrefix(rest);
-        if (!split) {
-          pending = rest;
-          return;
-        }
-        const [json, tail] = split;
-        if (tail === "") {
-          pending = json;
-          return;
-        }
-        controller.enqueue(`data: ${json}
-
-`);
-        if (tail.startsWith("data:")) {
-          rest = tail.slice(5).replace(/^ /, "");
-          continue;
-        }
-        if (tail.startsWith("{")) {
-          rest = tail;
-          continue;
-        }
-        controller.enqueue(`${tail}
-`);
-        return;
-      }
-    };
-    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);
-        emitPayload(line.slice(5).replace(/^ /, ""), controller);
-        return;
-      }
-      if (line.startsWith("{") && pending !== null) {
-        flushPending(controller);
-        emitPayload(line, controller);
-        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;
-  const apiKey = fromEnv ?? provider.apiKey;
-  if (!apiKey) {
-    const hint = provider.apiKeyEnv ? `set ${provider.apiKeyEnv} or configure apiKey` : "configure apiKey";
-    throw new Error(`Missing API key for provider "${provider.name}": ${hint}`);
-  }
-  return apiKey;
-}
-function createModel(config, modelName) {
-  const modelConfig = resolveModelConfig(config, modelName);
-  const provider = config.providers.find((p) => p.name === modelConfig.provider);
-  if (!provider) {
-    const available = config.providers.map((p) => p.name).join(", ") || "(none)";
-    throw new Error(
-      `Provider "${modelConfig.provider}" for model "${modelConfig.name}" not found. Available providers: ${available}`
-    );
-  }
-  const apiKey = resolveApiKey(provider);
-  const trackedFetch = wrapFetchWithActivity();
-  switch (provider.protocol) {
-    case "anthropic":
-      return createAnthropic({
-        baseURL: provider.baseURL,
-        apiKey,
-        headers: provider.headers,
-        fetch: trackedFetch
-      })(modelConfig.model);
-    case "openai-compatible":
-      return createOpenAICompatible({
-        name: provider.name,
-        baseURL: provider.baseURL,
-        apiKey,
-        headers: provider.headers,
-        fetch: trackedFetch
-      })(modelConfig.model, {}, { includeUsage: true });
-    case "openai-responses":
-      return createOpenAI({
-        baseURL: provider.baseURL,
-        apiKey,
-        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(trackedFetch)
-      }).responses(modelConfig.model);
-  }
-}
-function reasoningEffortMetadata(config, modelName) {
-  const modelConfig = resolveModelConfig(config, modelName);
-  if (!modelConfig.reasoningEffort) return void 0;
-  const provider = config.providers.find((p) => p.name === modelConfig.provider);
-  if (!provider || provider.protocol === "anthropic") return void 0;
-  const key = provider.protocol === "openai-responses" ? "openai" : provider.name;
-  return { [key]: { reasoningEffort: modelConfig.reasoningEffort } };
-}
-
 // src/session/checkpoints.ts
-import fs from "fs/promises";
-import path2 from "path";
-function checkpointsDir(sessionDir) {
-  return path2.join(sessionDir, "checkpoints");
-}
-function indexPath(sessionDir) {
-  return path2.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 path2.join(checkpointsDir(sessionDir), `${id}.snapshot`);
-}
-async function listCheckpointRecords(sessionDir) {
-  let raw;
-  try {
-    raw = await fs.readFile(indexPath(sessionDir), "utf8");
-  } catch {
-    return [];
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-async function appendCheckpointRecord(sessionDir, record, content) {
-  await enqueueIndexWrite(sessionDir, async () => {
-    await fs.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
-    if (record.existed && content !== null) {
-      await fs.writeFile(checkpointContentPath(sessionDir, record.id), content, "utf8");
-    }
-    const records = await listCheckpointRecords(sessionDir);
-    records.push(record);
-    await fs.writeFile(indexPath(sessionDir), JSON.stringify(records, null, 2));
-  });
-}
-async function removeCheckpointRecords(sessionDir, ids) {
-  if (ids.length === 0) return;
-  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 fs.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
-    await fs.writeFile(indexPath(sessionDir), JSON.stringify(kept, null, 2));
-    for (const id of ids) {
-      await fs.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 && !record.contentTooLarge ? checkpointContentPath(sessionDir, record.id) : void 0
-  }));
-}
-
-// src/session/store.ts
 import fs2 from "fs/promises";
 import path3 from "path";
+
+// src/session/store.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import fs from "fs/promises";
+import path2 from "path";
 import { StringDecoder } from "string_decoder";
 function generateId(now) {
   const pad = (n) => String(n).padStart(2, "0");
@@ -822,6 +633,24 @@ function generateId(now) {
   const suffix = Math.random().toString(16).slice(2, 8).padEnd(6, "0");
   return `${stamp}-${suffix}`;
 }
+var ID_COLLISION_MAX_ATTEMPTS = 5;
+function generateUniqueId() {
+  let id = generateId(/* @__PURE__ */ new Date());
+  for (let attempt = 1; existsSync(path2.join(sessionsDir(), id)); attempt++) {
+    if (attempt >= ID_COLLISION_MAX_ATTEMPTS) {
+      const stamp = id.slice(0, id.lastIndexOf("-"));
+      return `${stamp}-${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+    }
+    id = generateId(/* @__PURE__ */ new Date());
+  }
+  return id;
+}
+function normalizeCwdForCompare(cwd, platform = process.platform) {
+  if (platform !== "win32") return cwd;
+  const resolved = path2.win32.resolve(cwd);
+  const trimmed = resolved.replace(/[\\/]+$/, "");
+  return (trimmed === "" ? resolved : trimmed).toLowerCase();
+}
 function debugWarn(message) {
   if (process.env.STAR_DEBUG === "1") process.stderr.write(`[star-cli] ${message}
 `);
@@ -861,6 +690,23 @@ function isFallbackMeta(meta) {
 }
 var META_FLUSH_INTERVAL_MS = 2e3;
 var MESSAGES_READ_CHUNK_BYTES = 64 * 1024;
+var STAR_META_KEY = "__starMeta";
+function serializeMessage(star) {
+  if (!star.meta) return JSON.stringify(star.message);
+  return JSON.stringify({ ...star.message, [STAR_META_KEY]: star.meta });
+}
+function parseMessageLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed !== null && typeof parsed === "object" && STAR_META_KEY in parsed) {
+      const { [STAR_META_KEY]: meta, ...message } = parsed;
+      return { message, meta };
+    }
+    return { message: parsed };
+  } catch {
+    return null;
+  }
+}
 function dayKey(date) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
@@ -879,16 +725,16 @@ var SessionStore = class _SessionStore {
   metaDirty = false;
   constructor(id) {
     this.id = id;
-    this.dir = path3.join(sessionsDir(), id);
+    this.dir = path2.join(sessionsDir(), id);
   }
   metaPath() {
-    return path3.join(this.dir, "meta.json");
+    return path2.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path3.join(this.dir, "messages.jsonl");
+    return path2.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
-    const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
+    const store = new _SessionStore(generateUniqueId());
     store.pendingMeta = { cwd, model, createdAt: Date.now() };
     return store;
   }
@@ -896,7 +742,7 @@ var SessionStore = class _SessionStore {
     const store = new _SessionStore(id);
     let raw;
     try {
-      raw = await fs2.readFile(store.metaPath(), "utf8");
+      raw = await fs.readFile(store.metaPath(), "utf8");
     } catch {
       return null;
     }
@@ -913,16 +759,19 @@ var SessionStore = class _SessionStore {
   static async list(cwd) {
     let entries;
     try {
-      entries = await fs2.readdir(sessionsDir());
+      entries = await fs.readdir(sessionsDir());
     } catch {
       return [];
     }
+    const wanted = cwd === void 0 ? void 0 : normalizeCwdForCompare(cwd);
     const metas = await Promise.all(
       entries.map(async (entry) => {
         try {
-          const raw = await fs2.readFile(path3.join(sessionsDir(), entry, "meta.json"), "utf8");
+          const raw = await fs.readFile(path2.join(sessionsDir(), entry, "meta.json"), "utf8");
           const meta = JSON.parse(raw);
-          if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) return meta;
+          if (meta.id === entry && (wanted === void 0 || normalizeCwdForCompare(meta.cwd) === wanted)) {
+            return meta;
+          }
         } catch {
         }
         return null;
@@ -945,11 +794,11 @@ var SessionStore = class _SessionStore {
     const run = this.metaWriteQueue.then(async () => {
       try {
         await withTransientFsRetry(async () => {
-          await fs2.writeFile(tmp, JSON.stringify(meta, null, 2));
-          await fs2.rename(tmp, this.metaPath());
+          await fs.writeFile(tmp, JSON.stringify(meta, null, 2));
+          await fs.rename(tmp, this.metaPath());
         });
       } catch (error) {
-        await fs2.unlink(tmp).catch(() => {
+        await fs.unlink(tmp).catch(() => {
         });
         debugWarn(
           `session ${this.id}: meta write failed (${error.code ?? String(error)}), skipping`
@@ -1008,7 +857,7 @@ var SessionStore = class _SessionStore {
       this.initialized = true;
       return;
     }
-    await fs2.mkdir(this.dir, { recursive: true, mode: 448 });
+    await fs.mkdir(this.dir, { recursive: true, mode: 448 });
     await this.sweepTmpFiles();
     const meta = {
       id: this.id,
@@ -1029,22 +878,22 @@ var SessionStore = class _SessionStore {
   async sweepTmpFiles() {
     let entries;
     try {
-      entries = await fs2.readdir(this.dir);
+      entries = await fs.readdir(this.dir);
     } catch {
       return;
     }
     await Promise.all(
       entries.filter(
         (entry) => entry.startsWith("meta.json.tmp-") || entry.startsWith("messages.jsonl.tmp-")
-      ).map((entry) => fs2.unlink(path3.join(this.dir, entry)).catch(() => {
+      ).map((entry) => fs.unlink(path2.join(this.dir, entry)).catch(() => {
       }))
     );
   }
-  async append(message) {
+  async append(message, meta) {
     await this.ensureInitialized();
     try {
       await withTransientFsRetry(
-        () => fs2.appendFile(this.messagesPath(), `${JSON.stringify(message)}
+        () => fs.appendFile(this.messagesPath(), `${serializeMessage({ message, meta })}
 `)
       );
     } catch (error) {
@@ -1052,22 +901,22 @@ var SessionStore = class _SessionStore {
         `session ${this.id}: message append failed (${error.code ?? String(error)}), message kept in memory only`
       );
     }
-    const meta = await this.meta();
-    meta.updatedAt = Date.now();
+    const sessionMeta = await this.meta();
+    sessionMeta.updatedAt = Date.now();
     this.markMetaDirty();
   }
   async replaceMessages(messages) {
     await this.ensureInitialized();
-    const content = messages.map((message) => JSON.stringify(message)).join("\n");
+    const content = messages.map(serializeMessage).join("\n");
     const tmp = `${this.messagesPath()}.tmp-${process.pid}-${this.messagesTmpSeq++}`;
     try {
       await withTransientFsRetry(async () => {
-        await fs2.writeFile(tmp, content ? `${content}
+        await fs.writeFile(tmp, content ? `${content}
 ` : "");
-        await fs2.rename(tmp, this.messagesPath());
+        await fs.rename(tmp, this.messagesPath());
       });
     } catch (error) {
-      await fs2.unlink(tmp).catch(() => {
+      await fs.unlink(tmp).catch(() => {
       });
       warn(
         `session ${this.id}: history rewrite failed (${error.code ?? String(error)}), kept the previous messages.jsonl`
@@ -1078,9 +927,12 @@ var SessionStore = class _SessionStore {
     await this.flushMetaNow();
   }
   async messages() {
+    return (await this.starMessages()).map((star) => star.message);
+  }
+  async starMessages() {
     let handle = null;
     try {
-      handle = await fs2.open(this.messagesPath(), "r");
+      handle = await fs.open(this.messagesPath(), "r");
       const messages = [];
       const decoder = new StringDecoder("utf8");
       const buffer = Buffer.alloc(MESSAGES_READ_CHUNK_BYTES);
@@ -1088,9 +940,10 @@ var SessionStore = class _SessionStore {
       const pushLine = (line) => {
         const trimmed = line.trim();
         if (!trimmed) return;
-        try {
-          messages.push(JSON.parse(trimmed));
-        } catch {
+        const parsed = parseMessageLine(trimmed);
+        if (parsed) {
+          messages.push(parsed);
+        } else {
           debugWarn(`session ${this.id}: skipping corrupt messages.jsonl line`);
         }
       };
@@ -1128,7 +981,7 @@ var SessionStore = class _SessionStore {
     await this.ensureInitialized();
     if (this.cachedMeta) return this.cachedMeta;
     try {
-      const raw = await fs2.readFile(this.metaPath(), "utf8");
+      const raw = await fs.readFile(this.metaPath(), "utf8");
       this.cachedMeta = JSON.parse(raw);
       return this.cachedMeta;
     } catch {
@@ -1195,48 +1048,107 @@ var SessionStore = class _SessionStore {
   }
 };
 
-// src/session/clear.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-async function clearSessions(cwd, excludeId) {
-  if (cwd !== void 0) {
-    const metas = await SessionStore.list(cwd);
-    let removed2 = 0;
-    for (const meta of metas) {
-      if (meta.id === excludeId) continue;
-      await fs3.rm(path4.join(sessionsDir(), meta.id), { recursive: true, force: true });
-      removed2 += 1;
-    }
-    if ((await SessionStore.list(cwd)).length === 0) {
-      await removeTreeRepo(cwd);
+// src/session/checkpoints.ts
+function checkpointsDir(sessionDir) {
+  return path3.join(sessionDir, "checkpoints");
+}
+function indexPath(sessionDir) {
+  return path3.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);
+  const tail = run.then(
+    () => {
+    },
+    () => {
     }
-    return removed2;
+  );
+  indexWriteQueues.set(sessionDir, tail);
+  void tail.then(() => {
+    if (indexWriteQueues.get(sessionDir) === tail) indexWriteQueues.delete(sessionDir);
+  });
+  return run;
+}
+var indexTmpSeq = 0;
+async function writeIndex(sessionDir, records) {
+  const target = indexPath(sessionDir);
+  const tmp = `${target}.tmp-${process.pid}-${indexTmpSeq++}`;
+  try {
+    await withTransientFsRetry(async () => {
+      await fs2.writeFile(tmp, JSON.stringify(records, null, 2));
+      await fs2.rename(tmp, target);
+    });
+  } catch (error) {
+    await fs2.unlink(tmp).catch(() => {
+    });
+    throw error;
   }
-  let entries;
+}
+function checkpointContentPath(sessionDir, id) {
+  return path3.join(checkpointsDir(sessionDir), `${id}.snapshot`);
+}
+async function listCheckpointRecords(sessionDir) {
+  let raw;
   try {
-    entries = await fs3.readdir(sessionsDir());
+    raw = await fs2.readFile(indexPath(sessionDir), "utf8");
   } catch {
-    return 0;
+    return [];
   }
-  let removed = 0;
-  for (const entry of entries) {
-    if (entry === excludeId) continue;
-    await fs3.rm(path4.join(sessionsDir(), entry), { recursive: true, force: true });
-    removed += 1;
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    process.stderr.write(
+      `[star-cli] checkpoints index unreadable for session ${path3.basename(sessionDir)}, ignoring it
+`
+    );
+    return [];
   }
-  const survivors = await SessionStore.list();
-  await pruneTreeReposExcept(survivors.map((meta) => meta.cwd));
-  return removed;
+}
+async function appendCheckpointRecord(sessionDir, record, content) {
+  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 writeIndex(sessionDir, records);
+  });
+}
+async function removeCheckpointRecords(sessionDir, ids) {
+  if (ids.length === 0) return;
+  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 writeIndex(sessionDir, kept);
+    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 && !record.contentTooLarge ? checkpointContentPath(sessionDir, record.id) : void 0
+  }));
 }
 
 // src/session/list.ts
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs3 from "fs/promises";
+import path4 from "path";
 var COUNT_CHUNK_BYTES = 64 * 1024;
 async function countMessages(id) {
   let handle = null;
   try {
-    handle = await fs4.open(path5.join(sessionsDir(), id, "messages.jsonl"), "r");
+    handle = await fs3.open(path4.join(sessionsDir(), id, "messages.jsonl"), "r");
     const buffer = Buffer.alloc(COUNT_CHUNK_BYTES);
     let count = 0;
     let lineHasContent = false;
@@ -1261,11 +1173,24 @@ async function countMessages(id) {
     });
   }
 }
+var LIST_COUNT_CONCURRENCY = 8;
 async function listSessionEntries(cwd) {
   const metas = await SessionStore.list(cwd);
-  return Promise.all(
-    metas.map(async (meta) => ({ meta, messageCount: await countMessages(meta.id) }))
+  const entries = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < metas.length) {
+      const index = next;
+      next += 1;
+      const meta = metas[index];
+      if (!meta) continue;
+      entries[index] = { meta, messageCount: await countMessages(meta.id) };
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(LIST_COUNT_CONCURRENCY, metas.length) }, () => worker())
   );
+  return entries;
 }
 async function findLatestSession(cwd) {
   const [latest] = await SessionStore.list(cwd);
@@ -1274,7 +1199,7 @@ async function findLatestSession(cwd) {
 async function sessionPreview(id, maxBytes = 4096) {
   let handle = null;
   try {
-    handle = await fs4.open(path5.join(sessionsDir(), id, "messages.jsonl"), "r");
+    handle = await fs3.open(path4.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);
@@ -1332,6 +1257,52 @@ function formatSessionEntries(entries, options = {}) {
   }).join("\n");
 }
 
+// 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/session/clear.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+async function clearSessions(cwd, excludeId) {
+  if (cwd !== void 0) {
+    const metas = await SessionStore.list(cwd);
+    let removed2 = 0;
+    for (const meta of metas) {
+      if (meta.id === excludeId) continue;
+      await fs4.rm(path5.join(sessionsDir(), meta.id), { recursive: true, force: true });
+      removed2 += 1;
+    }
+    if ((await SessionStore.list(cwd)).length === 0) {
+      await removeTreeRepo(cwd);
+    }
+    return removed2;
+  }
+  let entries;
+  try {
+    entries = await fs4.readdir(sessionsDir());
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  for (const entry of entries) {
+    if (entry === excludeId) continue;
+    await fs4.rm(path5.join(sessionsDir(), entry), { recursive: true, force: true });
+    removed += 1;
+  }
+  const survivors = await SessionStore.list();
+  await pruneTreeReposExcept(survivors.map((meta) => meta.cwd));
+  return removed;
+}
+
 // src/version.ts
 import fs5 from "fs";
 import path6 from "path";
@@ -1350,61 +1321,14 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 
-// src/config/env.ts
-import fs6 from "fs";
-var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function parseEnvContent(content) {
-  const vars = {};
-  for (const rawLine of content.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const eq = line.indexOf("=");
-    if (eq <= 0) continue;
-    const key = line.slice(0, eq).trim();
-    if (!ENV_KEY_PATTERN.test(key)) continue;
-    let value = line.slice(eq + 1).trim();
-    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-    vars[key] = value;
-  }
-  return vars;
-}
-function loadEnvFile(filePath = envFilePath()) {
-  let content;
-  try {
-    content = fs6.readFileSync(filePath, "utf8");
-  } catch {
-    return;
-  }
-  for (const [key, value] of Object.entries(parseEnvContent(content))) {
-    if (process.env[key] === void 0) {
-      process.env[key] = value;
-    }
-  }
-}
-function upsertEnvContent(content, key, value) {
-  const entry = `${key}=${value.replace(/[\r\n]/g, "")}`;
-  const pattern = new RegExp(`^\\s*${key}\\s*=`);
-  const lines = content.split("\n");
-  while (lines.length > 0 && (lines[lines.length - 1] ?? "").trim() === "") lines.pop();
-  for (let i = 0; i < lines.length; i++) {
-    if (pattern.test(lines[i] ?? "")) {
-      lines[i] = entry;
-      return `${lines.join("\n")}
-`;
-    }
-  }
-  lines.push(entry);
-  return `${lines.join("\n")}
-`;
-}
-
 export {
   formatDollars,
   formatTokens,
   computeCostUsd,
   estimateCost,
+  toolIcon,
+  thinkingIcon,
+  folderIcon,
   renderMarkdown,
   toTerminalSafe,
   summarizeArgs,
@@ -1413,22 +1337,13 @@ export {
   formatElapsedSeconds,
   splitCommittableLines,
   formatStreamError,
-  coreMessageText,
   buildDisplayMessages,
   MAX_IMAGE_BYTES,
   imageMimeType,
   readImageInput,
   resolveMentions,
-  SYSTEM_PROMPT,
-  loadEnvFile,
-  upsertEnvContent,
-  listModels,
-  resolveModelConfig,
-  createModel,
-  reasoningEffortMetadata,
   loadSessionSnapshots,
   SessionStore,
-  clearSessions,
   listSessionEntries,
   findLatestSession,
   sessionPreview,
@@ -1436,6 +1351,8 @@ export {
   resolveSessionId,
   relativeTime,
   formatSessionEntries,
+  SYSTEM_PROMPT,
+  clearSessions,
   VERSION
 };
-//# sourceMappingURL=chunk-4X25DNTF.js.map
+//# sourceMappingURL=chunk-VJFWTXWN.js.map