@cryer/star-cli 0.3.8 → 0.3.10

package/dist/{chunk-IYWYSFSF.js → chunk-PDFC7QVW.js}

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
+import {
+  coreMessageText,
+  pruneTreeReposExcept,
+  removeTreeRepo
+} from "./chunk-IJGUW4PM.js";
 import {
   SKIP_DIRS,
   createIgnorePredicate,
   downsampleImageIfNeeded,
-  envFilePath,
   isSensitivePath,
-  pruneTreeReposExcept,
-  removeTreeRepo,
   sessionsDir
-} from "./chunk-OHLA2DP7.js";
+} from "./chunk-A5PXPWHB.js";
 
 // src/cli/cost.ts
 function formatDollars(cost) {
@@ -52,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;
@@ -297,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++;
     }
@@ -528,96 +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/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");
@@ -625,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}
 `);
@@ -664,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())}`;
@@ -682,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;
   }
@@ -699,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;
     }
@@ -716,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;
@@ -748,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`
@@ -811,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,
@@ -832,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) {
@@ -855,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`
@@ -881,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);
@@ -891,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`);
         }
       };
@@ -931,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 {
@@ -998,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;
@@ -1064,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);
@@ -1077,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);
@@ -1135,6 +1257,55 @@ 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.
+When you add a feature or change behavior, write the unit tests that cover it in the same change, matching the project's test framework, layout, and naming; if the project has no test setup at all, say so instead of silently skipping tests.
+Never consider the task finished until you have verified the result yourself: run the project's full verification \u2014 the whole test suite, not only the tests you touched, plus the type check, build, or lint the project defines \u2014 and if verification fails or reveals gaps, keep fixing until everything passes; a change that breaks other tests is not done.
+Before the final verification, sweep your own changes for leftovers: debug prints, commented-out code, half-finished edits.
+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.
+When you report completion, state the evidence: which checks you ran and that they passed \u2014 never claim success you did not observe.
+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";
@@ -1153,61 +1324,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,
@@ -1216,18 +1340,13 @@ export {
   formatElapsedSeconds,
   splitCommittableLines,
   formatStreamError,
-  coreMessageText,
   buildDisplayMessages,
   MAX_IMAGE_BYTES,
   imageMimeType,
   readImageInput,
   resolveMentions,
-  SYSTEM_PROMPT,
-  loadEnvFile,
-  upsertEnvContent,
   loadSessionSnapshots,
   SessionStore,
-  clearSessions,
   listSessionEntries,
   findLatestSession,
   sessionPreview,
@@ -1235,6 +1354,8 @@ export {
   resolveSessionId,
   relativeTime,
   formatSessionEntries,
+  SYSTEM_PROMPT,
+  clearSessions,
   VERSION
 };
-//# sourceMappingURL=chunk-IYWYSFSF.js.map
+//# sourceMappingURL=chunk-PDFC7QVW.js.map