@cryer/star-cli 0.3.12 → 0.3.14

package/dist/{chunk-2GAUAYCU.js → chunk-NRLGGA7L.js}

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 import {
+  computeCostUsd,
   coreMessageText,
   pruneTreeReposExcept,
   removeTreeRepo
-} from "./chunk-MYHD3SZB.js";
+} from "./chunk-CECMCDZG.js";
 import {
   SKIP_DIRS,
   createIgnorePredicate,
   downsampleImageIfNeeded,
   isSensitivePath,
   sessionsDir
-} from "./chunk-LSYGHLRU.js";
+} from "./chunk-2ISBRSBA.js";
 
 // src/cli/cost.ts
 function formatDollars(cost) {
@@ -35,14 +36,6 @@ function formatTokensCompact(n) {
   const scaled = thousands ? n / 1e3 : n / 1e6;
   return `${scaled.toFixed(1).replace(/\.0$/, "")}${thousands ? "K" : "M"}`;
 }
-function computeCostUsd(usage, model) {
-  if (model?.promptPrice === void 0 || model.completionPrice === void 0) {
-    return null;
-  }
-  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);
   if (cost === null) {
@@ -133,6 +126,58 @@ function toTerminalSafe(text) {
   if (!UNSAFE_CHARS.test(text)) return text;
   return text.replace(TABS, "  ").replace(CONTROL_CHARS, "");
 }
+var WIDE_RANGES = [
+  [4352, 4447],
+  // Hangul Jamo
+  [11904, 42191],
+  // CJK radicals … Yi syllables
+  [43360, 43388],
+  // Hangul Jamo Extended-B
+  [44032, 55203],
+  // Hangul syllables
+  [63744, 64255],
+  // CJK compatibility ideographs
+  [65040, 65049],
+  // vertical forms
+  [65072, 65106],
+  // CJK compatibility forms
+  [65108, 65126],
+  // small form variants
+  [65128, 65131],
+  [65280, 65376],
+  // fullwidth forms
+  [65504, 65510],
+  // fullwidth signs
+  [127744, 128591],
+  // emoji
+  [129280, 129535],
+  // supplemental emoji
+  [131072, 262141]
+  // CJK extension planes
+];
+function isWideChar(ch) {
+  const cp = ch.codePointAt(0) ?? 0;
+  return WIDE_RANGES.some(([lo, hi]) => cp >= lo && cp <= hi);
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const ch of text) width += isWideChar(ch) ? 2 : 1;
+  return width;
+}
+function truncateToWidth(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  if (displayWidth(text) <= maxWidth) return text;
+  const limit = Math.max(0, maxWidth - 1);
+  let width = 0;
+  let out = "";
+  for (const ch of text) {
+    const w = isWideChar(ch) ? 2 : 1;
+    if (width + w > limit) break;
+    out += ch;
+    width += w;
+  }
+  return `${out}\u2026`;
+}
 
 // src/cli/markdown.ts
 var ESC = "\x1B[";
@@ -640,15 +685,153 @@ ${buf.toString("utf8")}
 }
 
 // src/session/checkpoints.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// src/session/store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync } from "fs";
 import fs2 from "fs/promises";
 import path3 from "path";
+import { StringDecoder } from "string_decoder";
 
-// src/session/store.ts
+// src/session/lock.ts
 import { randomUUID } from "crypto";
-import { existsSync } from "fs";
 import fs from "fs/promises";
 import path2 from "path";
-import { StringDecoder } from "string_decoder";
+var LOCK_FILENAME = ".lock";
+var RECLAIM_FILENAME = ".lock.reclaim";
+var MALFORMED_LOCK_GRACE_MS = 5e3;
+var RECLAIM_STALE_MS = 3e4;
+var SessionLockedError = class extends Error {
+  constructor(sessionId) {
+    super(`Session is already open in another process: ${sessionId}`);
+    this.sessionId = sessionId;
+    this.name = "SessionLockedError";
+  }
+  sessionId;
+  code = "SESSION_LOCKED";
+};
+function lockPath(sessionDir) {
+  return path2.join(sessionDir, LOCK_FILENAME);
+}
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function readLockRecord(file) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(file, "utf8"));
+    if (typeof parsed.pid !== "number" || typeof parsed.token !== "string" || typeof parsed.createdAt !== "number") {
+      return null;
+    }
+    return { pid: parsed.pid, token: parsed.token, createdAt: parsed.createdAt };
+  } catch {
+    return null;
+  }
+}
+async function malformedLockIsStale(file) {
+  try {
+    const stat2 = await fs.stat(file);
+    return Date.now() - stat2.mtimeMs >= MALFORMED_LOCK_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
+async function reclaimStaleLock(sessionDir, expected) {
+  const guard = path2.join(sessionDir, RECLAIM_FILENAME);
+  let guardHandle;
+  try {
+    guardHandle = await fs.open(guard, "wx", 384);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    try {
+      const stat2 = await fs.stat(guard);
+      if (Date.now() - stat2.mtimeMs < RECLAIM_STALE_MS) return false;
+      await fs.unlink(guard);
+    } catch {
+      return false;
+    }
+    return false;
+  }
+  const quarantine = `${lockPath(sessionDir)}.stale-${process.pid}-${randomUUID()}`;
+  try {
+    const file = lockPath(sessionDir);
+    const current = await readLockRecord(file);
+    if (expected) {
+      if (current?.token !== expected.token || processIsAlive(current.pid)) return false;
+    } else {
+      if (current) {
+        if (processIsAlive(current.pid)) return false;
+      } else if (!await malformedLockIsStale(file)) {
+        return false;
+      }
+    }
+    await fs.rename(file, quarantine);
+    await fs.unlink(quarantine).catch(() => {
+    });
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return true;
+    throw error;
+  } finally {
+    await guardHandle.close().catch(() => {
+    });
+    await fs.unlink(guard).catch(() => {
+    });
+  }
+}
+async function acquireSessionLock(sessionDir, sessionId) {
+  await fs.mkdir(sessionDir, { recursive: true, mode: 448 });
+  const file = lockPath(sessionDir);
+  const record = { pid: process.pid, token: randomUUID(), createdAt: Date.now() };
+  for (let attempt = 0; attempt < 20; attempt++) {
+    let handle;
+    try {
+      handle = await fs.open(file, "wx", 384);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const existing = await readLockRecord(file);
+      if (existing ? processIsAlive(existing.pid) : !await malformedLockIsStale(file)) {
+        throw new SessionLockedError(sessionId);
+      }
+      if (!await reclaimStaleLock(sessionDir, existing)) {
+        const current = await readLockRecord(file);
+        if (current && processIsAlive(current.pid)) throw new SessionLockedError(sessionId);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      continue;
+    }
+    try {
+      await handle.writeFile(JSON.stringify(record), "utf8");
+      await handle.close();
+      return {
+        release: async () => {
+          if ((await readLockRecord(file))?.token === record.token) {
+            await fs.unlink(file).catch((error) => {
+              if (error.code !== "ENOENT") throw error;
+            });
+          }
+        }
+      };
+    } catch (error) {
+      await handle.close().catch(() => {
+      });
+      await fs.unlink(file).catch(() => {
+      });
+      throw error;
+    }
+  }
+  throw new SessionLockedError(sessionId);
+}
+
+// src/session/store.ts
 function generateId(now) {
   const pad = (n) => String(n).padStart(2, "0");
   const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
@@ -658,10 +841,10 @@ function generateId(now) {
 var ID_COLLISION_MAX_ATTEMPTS = 5;
 function generateUniqueId() {
   let id = generateId(/* @__PURE__ */ new Date());
-  for (let attempt = 1; existsSync(path2.join(sessionsDir(), id)); attempt++) {
+  for (let attempt = 1; existsSync(path3.join(sessionsDir(), id)); attempt++) {
     if (attempt >= ID_COLLISION_MAX_ATTEMPTS) {
       const stamp = id.slice(0, id.lastIndexOf("-"));
-      return `${stamp}-${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+      return `${stamp}-${randomUUID2().replaceAll("-", "").slice(0, 12)}`;
     }
     id = generateId(/* @__PURE__ */ new Date());
   }
@@ -669,7 +852,7 @@ function generateUniqueId() {
 }
 function normalizeCwdForCompare(cwd, platform = process.platform) {
   if (platform !== "win32") return cwd;
-  const resolved = path2.win32.resolve(cwd);
+  const resolved = path3.win32.resolve(cwd);
   const trimmed = resolved.replace(/[\\/]+$/, "");
   return (trimmed === "" ? resolved : trimmed).toLowerCase();
 }
@@ -738,33 +921,48 @@ var SessionStore = class _SessionStore {
   dir;
   pendingMeta = null;
   initialized = false;
+  initialization = null;
   cachedMeta = null;
-  metaTmpSeq = 0;
-  messagesTmpSeq = 0;
+  lock = null;
+  closing = false;
+  closed = false;
+  messageHistory = null;
+  degraded = false;
+  messageWriteQueue = Promise.resolve();
   metaWriteQueue = Promise.resolve();
   metaLastFlushAt = 0;
   metaFlushTimer = null;
   metaDirty = false;
   constructor(id) {
     this.id = id;
-    this.dir = path2.join(sessionsDir(), id);
+    this.dir = path3.join(sessionsDir(), id);
   }
   metaPath() {
-    return path2.join(this.dir, "meta.json");
+    return path3.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path2.join(this.dir, "messages.jsonl");
+    return path3.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
-    const store = new _SessionStore(generateUniqueId());
-    store.pendingMeta = { cwd, model, createdAt: Date.now() };
-    return store;
+    for (let attempt = 0; attempt < ID_COLLISION_MAX_ATTEMPTS; attempt++) {
+      const store = new _SessionStore(generateUniqueId());
+      try {
+        store.lock = await acquireSessionLock(store.dir, store.id);
+      } catch (error) {
+        if (error instanceof SessionLockedError) continue;
+        throw error;
+      }
+      store.pendingMeta = { cwd, model, createdAt: Date.now() };
+      store.messageHistory = [];
+      return store;
+    }
+    throw new Error("Could not allocate an exclusive session id");
   }
   static async open(id) {
     const store = new _SessionStore(id);
     let raw;
     try {
-      raw = await fs.readFile(store.metaPath(), "utf8");
+      raw = await fs2.readFile(store.metaPath(), "utf8");
     } catch {
       return null;
     }
@@ -774,32 +972,44 @@ var SessionStore = class _SessionStore {
     } catch {
       debugWarn(`session ${id}: corrupt meta.json, using defaults`);
     }
-    await store.sweepTmpFiles();
-    store.initialized = true;
-    return store;
+    store.lock = await acquireSessionLock(store.dir, id);
+    try {
+      await store.sweepTmpFiles();
+      store.initialized = true;
+      return store;
+    } catch (error) {
+      await store.lock.release();
+      throw error;
+    }
   }
   static async list(cwd) {
     let entries;
     try {
-      entries = await fs.readdir(sessionsDir());
+      entries = await fs2.readdir(sessionsDir());
     } catch {
       return [];
     }
     const wanted = cwd === void 0 ? void 0 : normalizeCwdForCompare(cwd);
-    const metas = await Promise.all(
-      entries.map(async (entry) => {
+    const metas = [];
+    let next = 0;
+    const worker = async () => {
+      while (next < entries.length) {
+        const index = next;
+        next += 1;
+        const entry = entries[index];
+        if (!entry) continue;
         try {
-          const raw = await fs.readFile(path2.join(sessionsDir(), entry, "meta.json"), "utf8");
+          const raw = await fs2.readFile(path3.join(sessionsDir(), entry, "meta.json"), "utf8");
           const meta = JSON.parse(raw);
           if (meta.id === entry && (wanted === void 0 || normalizeCwdForCompare(meta.cwd) === wanted)) {
-            return meta;
+            metas[index] = meta;
           }
         } catch {
         }
-        return null;
-      })
-    );
-    return metas.filter((meta) => meta !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(8, entries.length) }, () => worker()));
+    return metas.filter((meta) => meta !== null && meta !== void 0).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
@@ -812,15 +1022,15 @@ var SessionStore = class _SessionStore {
   // agent turn over a stale updatedAt would be the wrong trade.
   writeMeta(meta) {
     if (isFallbackMeta(meta)) return Promise.resolve();
-    const tmp = `${this.metaPath()}.tmp-${process.pid}-${this.metaTmpSeq++}`;
+    const tmp = `${this.metaPath()}.tmp-${process.pid}-${randomUUID2()}`;
     const run = this.metaWriteQueue.then(async () => {
       try {
         await withTransientFsRetry(async () => {
-          await fs.writeFile(tmp, JSON.stringify(meta, null, 2));
-          await fs.rename(tmp, this.metaPath());
+          await fs2.writeFile(tmp, JSON.stringify(meta, null, 2));
+          await fs2.rename(tmp, this.metaPath());
         });
       } catch (error) {
-        await fs.unlink(tmp).catch(() => {
+        await fs2.unlink(tmp).catch(() => {
         });
         debugWarn(
           `session ${this.id}: meta write failed (${error.code ?? String(error)}), skipping`
@@ -831,10 +1041,6 @@ var SessionStore = class _SessionStore {
     });
     return run;
   }
-  // Debounced flush for append-driven updatedAt bumps. The trailing timer is
-  // unref'd so a pending flush never keeps the process alive; close() flushes
-  // synchronously on a clean exit, and a hard exit simply drops the trailing
-  // bump — meta is bookkeeping.
   markMetaDirty() {
     this.metaDirty = true;
     if (this.metaFlushTimer) return;
@@ -853,9 +1059,6 @@ var SessionStore = class _SessionStore {
     if (!this.metaDirty) return;
     await this.flushMetaNow();
   }
-  // Immediate flush for substantive meta changes; cancels a pending debounced
-  // flush, which the write makes redundant either way (it serializes the live
-  // cached meta).
   async flushMetaNow() {
     if (this.metaFlushTimer) {
       clearTimeout(this.metaFlushTimer);
@@ -865,96 +1068,172 @@ var SessionStore = class _SessionStore {
     this.metaLastFlushAt = Date.now();
     if (this.cachedMeta) await this.writeMeta(this.cachedMeta);
   }
-  // Flushes a pending debounced meta write and waits for in-flight writes to
-  // settle; call when the store is dropped so a clean exit keeps the trailing
-  // updatedAt bump.
   async close() {
-    await this.flushMetaIfDirty();
-    await this.metaWriteQueue;
+    if (this.closed || this.closing) return;
+    this.closing = true;
+    try {
+      await this.messageWriteQueue;
+      await this.flushMetaIfDirty();
+      await this.metaWriteQueue;
+    } finally {
+      if (this.metaFlushTimer) clearTimeout(this.metaFlushTimer);
+      this.metaFlushTimer = null;
+      this.closed = true;
+      this.closing = false;
+      const lock = this.lock;
+      this.lock = null;
+      await lock?.release();
+    }
+  }
+  assertCanWrite() {
+    if (this.closed || this.closing || !this.lock) {
+      throw new Error(`Session store is closed: ${this.id}`);
+    }
   }
   async ensureInitialized() {
     if (this.initialized) return;
-    const pending = this.pendingMeta;
-    if (!pending) {
+    if (this.initialization) return this.initialization;
+    this.initialization = (async () => {
+      const pending = this.pendingMeta;
+      if (!pending) {
+        this.initialized = true;
+        return;
+      }
+      await this.sweepTmpFiles();
+      const meta = {
+        id: this.id,
+        title: "",
+        model: pending.model,
+        cwd: pending.cwd,
+        createdAt: pending.createdAt,
+        updatedAt: pending.createdAt
+      };
+      await this.writeMeta(meta);
+      this.cachedMeta = meta;
+      this.metaLastFlushAt = Date.now();
       this.initialized = true;
-      return;
+    })();
+    try {
+      await this.initialization;
+    } catch (error) {
+      this.initialization = null;
+      throw error;
     }
-    await fs.mkdir(this.dir, { recursive: true, mode: 448 });
-    await this.sweepTmpFiles();
-    const meta = {
-      id: this.id,
-      title: "",
-      model: pending.model,
-      cwd: pending.cwd,
-      createdAt: pending.createdAt,
-      updatedAt: pending.createdAt
-    };
-    await this.writeMeta(meta);
-    this.cachedMeta = meta;
-    this.metaLastFlushAt = Date.now();
-    this.initialized = true;
   }
-  // Removes tmp orphans left behind by crashed atomic writes (both meta.json
-  // and messages.jsonl write tmp file + rename); best-effort, the directory
-  // may not even exist yet.
   async sweepTmpFiles() {
     let entries;
     try {
-      entries = await fs.readdir(this.dir);
+      entries = await fs2.readdir(this.dir);
     } catch {
       return;
     }
     await Promise.all(
-      entries.filter(
-        (entry) => entry.startsWith("meta.json.tmp-") || entry.startsWith("messages.jsonl.tmp-")
-      ).map((entry) => fs.unlink(path2.join(this.dir, entry)).catch(() => {
-      }))
+      entries.map(async (entry) => {
+        const match = /^(?:meta\.json|messages\.jsonl)\.tmp-(\d+)-/.exec(entry);
+        if (!match) return;
+        const pid = Number(match[1]);
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch (error) {
+          if (error.code === "EPERM") return;
+        }
+        await fs2.unlink(path3.join(this.dir, entry)).catch(() => {
+        });
+      })
     );
   }
-  async append(message, meta) {
-    await this.ensureInitialized();
-    try {
-      await withTransientFsRetry(
-        () => fs.appendFile(this.messagesPath(), `${serializeMessage({ message, meta })}
-`)
-      );
-    } catch (error) {
-      warn(
-        `session ${this.id}: message append failed (${error.code ?? String(error)}), message kept in memory only`
-      );
-    }
-    const sessionMeta = await this.meta();
-    sessionMeta.updatedAt = Date.now();
-    this.markMetaDirty();
+  enqueueMessageWrite(operation) {
+    const run = this.messageWriteQueue.then(operation);
+    this.messageWriteQueue = run.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return run;
   }
-  async replaceMessages(messages) {
+  get persistenceDegraded() {
+    return this.degraded;
+  }
+  async ensureMessageHistory() {
+    if (!this.messageHistory) this.messageHistory = await this.readStarMessages(true);
+    return this.messageHistory;
+  }
+  async rewriteMessages(messages) {
     await this.ensureInitialized();
+    this.messageHistory = [...messages];
     const content = messages.map(serializeMessage).join("\n");
-    const tmp = `${this.messagesPath()}.tmp-${process.pid}-${this.messagesTmpSeq++}`;
+    const tmp = `${this.messagesPath()}.tmp-${process.pid}-${randomUUID2()}`;
     try {
       await withTransientFsRetry(async () => {
-        await fs.writeFile(tmp, content ? `${content}
+        await fs2.writeFile(tmp, content ? `${content}
 ` : "");
-        await fs.rename(tmp, this.messagesPath());
+        await fs2.rename(tmp, this.messagesPath());
       });
     } catch (error) {
-      await fs.unlink(tmp).catch(() => {
+      await fs2.unlink(tmp).catch(() => {
       });
+      this.degraded = true;
       warn(
         `session ${this.id}: history rewrite failed (${error.code ?? String(error)}), kept the previous messages.jsonl`
       );
+      return false;
     }
+    this.degraded = false;
     const meta = await this.meta();
     meta.updatedAt = Date.now();
     await this.flushMetaNow();
+    return true;
+  }
+  async append(message, meta) {
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(async () => {
+      await this.ensureInitialized();
+      const history = await this.ensureMessageHistory();
+      const star = { message, meta };
+      if (this.degraded) return this.rewriteMessages([...history, star]);
+      try {
+        await withTransientFsRetry(
+          () => fs2.appendFile(this.messagesPath(), `${serializeMessage(star)}
+`)
+        );
+      } catch (error) {
+        this.messageHistory = [...history, star];
+        this.degraded = true;
+        warn(
+          `session ${this.id}: message append failed (${error.code ?? String(error)}), full history rewrite required`
+        );
+        return false;
+      }
+      history.push(star);
+      const sessionMeta = await this.meta();
+      sessionMeta.updatedAt = Date.now();
+      this.markMetaDirty();
+      return true;
+    });
+  }
+  async replaceMessages(messages) {
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(() => this.rewriteMessages(messages));
+  }
+  async recoverMessages() {
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(async () => {
+      if (!this.degraded) return true;
+      return this.rewriteMessages(await this.ensureMessageHistory());
+    });
   }
   async messages() {
     return (await this.starMessages()).map((star) => star.message);
   }
   async starMessages() {
+    return this.readStarMessages(false);
+  }
+  async readStarMessages(strict) {
     let handle = null;
     try {
-      handle = await fs.open(this.messagesPath(), "r");
+      handle = await fs2.open(this.messagesPath(), "r");
       const messages = [];
       const decoder = new StringDecoder("utf8");
       const buffer = Buffer.alloc(MESSAGES_READ_CHUNK_BYTES);
@@ -979,7 +1258,8 @@ var SessionStore = class _SessionStore {
       }
       pushLine(tail + decoder.end());
       return messages;
-    } catch {
+    } catch (error) {
+      if (strict && error.code !== "ENOENT") throw error;
       return [];
     } finally {
       await handle?.close().catch(() => {
@@ -1003,7 +1283,7 @@ var SessionStore = class _SessionStore {
     await this.ensureInitialized();
     if (this.cachedMeta) return this.cachedMeta;
     try {
-      const raw = await fs.readFile(this.metaPath(), "utf8");
+      const raw = await fs2.readFile(this.metaPath(), "utf8");
       this.cachedMeta = JSON.parse(raw);
       return this.cachedMeta;
     } catch {
@@ -1012,70 +1292,102 @@ var SessionStore = class _SessionStore {
     }
   }
   async setTitle(title) {
-    await this.ensureInitialized();
-    const meta = await this.meta();
-    meta.title = title;
-    meta.updatedAt = Date.now();
-    await this.flushMetaNow();
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(async () => {
+      await this.ensureInitialized();
+      const meta = await this.meta();
+      meta.title = title;
+      meta.updatedAt = Date.now();
+      await this.flushMetaNow();
+    });
   }
   // /model swaps the live loop mid-session; keep the recorded model in sync
   // or the session list and /usage attribute the whole session to whichever
   // model happened to be active at creation.
   async setModel(model) {
-    await this.ensureInitialized();
-    const meta = await this.meta();
-    meta.model = model;
-    meta.updatedAt = Date.now();
-    await this.flushMetaNow();
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(async () => {
+      await this.ensureInitialized();
+      const meta = await this.meta();
+      meta.model = model;
+      meta.updatedAt = Date.now();
+      await this.flushMetaNow();
+    });
   }
   async appendCheckpoint(record, content) {
-    await this.ensureInitialized();
-    await appendCheckpointRecord(this.dir, record, content);
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(async () => {
+      await this.ensureInitialized();
+      await appendCheckpointRecord(this.dir, record, content);
+    });
   }
   async listCheckpoints() {
     return listCheckpointRecords(this.dir);
   }
   async removeCheckpoints(ids) {
-    await removeCheckpointRecords(this.dir, ids);
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(() => removeCheckpointRecords(this.dir, ids));
   }
-  async addUsage(delta) {
-    await this.ensureInitialized();
-    const meta = await this.meta();
-    const usage = meta.usage ?? {
-      requests: 0,
-      promptTokens: 0,
-      completionTokens: 0,
-      totalTokens: 0
-    };
-    usage.requests += 1;
-    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 ?? {};
-    const bucket = byDay[day] ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
-    bucket.promptTokens += delta.promptTokens;
-    bucket.completionTokens += delta.completionTokens;
-    bucket.totalTokens += delta.totalTokens;
-    byDay[day] = bucket;
-    meta.usageByDay = byDay;
-    await this.flushMetaNow();
+  async addUsage(delta, attribution) {
+    this.assertCanWrite();
+    return this.enqueueMessageWrite(async () => {
+      await this.ensureInitialized();
+      const meta = await this.meta();
+      const apply = (usage2) => {
+        usage2.requests += 1;
+        usage2.promptTokens += delta.promptTokens;
+        usage2.completionTokens += delta.completionTokens;
+        usage2.totalTokens += delta.totalTokens;
+        if (delta.cachedPromptTokens) {
+          usage2.cachedPromptTokens = (usage2.cachedPromptTokens ?? 0) + delta.cachedPromptTokens;
+        }
+        if (delta.cacheReadInputTokens) {
+          usage2.cacheReadInputTokens = (usage2.cacheReadInputTokens ?? 0) + delta.cacheReadInputTokens;
+        }
+        if (attribution) {
+          if (attribution.costUsd === null) usage2.costUnknown = true;
+          else usage2.costUsd = (usage2.costUsd ?? 0) + attribution.costUsd;
+        }
+      };
+      const usage = meta.usage ?? {
+        requests: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0
+      };
+      apply(usage);
+      meta.usage = usage;
+      if (attribution) {
+        const byModel = meta.usageByModel ?? {};
+        const modelUsage = byModel[attribution.modelName] ?? {
+          requests: 0,
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0
+        };
+        apply(modelUsage);
+        byModel[attribution.modelName] = modelUsage;
+        meta.usageByModel = byModel;
+      }
+      const day = dayKey(/* @__PURE__ */ new Date());
+      const byDay = meta.usageByDay ?? {};
+      const bucket = byDay[day] ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+      bucket.promptTokens += delta.promptTokens;
+      bucket.completionTokens += delta.completionTokens;
+      bucket.totalTokens += delta.totalTokens;
+      byDay[day] = bucket;
+      meta.usageByDay = byDay;
+      await this.flushMetaNow();
+    });
   }
 };
 
 // src/session/checkpoints.ts
 function checkpointsDir(sessionDir) {
-  return path3.join(sessionDir, "checkpoints");
+  return path4.join(sessionDir, "checkpoints");
 }
 function indexPath(sessionDir) {
-  return path3.join(checkpointsDir(sessionDir), "index.json");
+  return path4.join(checkpointsDir(sessionDir), "index.json");
 }
 var indexWriteQueues = /* @__PURE__ */ new Map();
 function enqueueIndexWrite(sessionDir, op) {
@@ -1093,28 +1405,27 @@ function enqueueIndexWrite(sessionDir, op) {
   });
   return run;
 }
-var indexTmpSeq = 0;
 async function writeIndex(sessionDir, records) {
   const target = indexPath(sessionDir);
-  const tmp = `${target}.tmp-${process.pid}-${indexTmpSeq++}`;
+  const tmp = `${target}.tmp-${process.pid}-${randomUUID3()}`;
   try {
     await withTransientFsRetry(async () => {
-      await fs2.writeFile(tmp, JSON.stringify(records, null, 2));
-      await fs2.rename(tmp, target);
+      await fs3.writeFile(tmp, JSON.stringify(records, null, 2));
+      await fs3.rename(tmp, target);
     });
   } catch (error) {
-    await fs2.unlink(tmp).catch(() => {
+    await fs3.unlink(tmp).catch(() => {
     });
     throw error;
   }
 }
 function checkpointContentPath(sessionDir, id) {
-  return path3.join(checkpointsDir(sessionDir), `${id}.snapshot`);
+  return path4.join(checkpointsDir(sessionDir), `${id}.snapshot`);
 }
 async function listCheckpointRecords(sessionDir) {
   let raw;
   try {
-    raw = await fs2.readFile(indexPath(sessionDir), "utf8");
+    raw = await fs3.readFile(indexPath(sessionDir), "utf8");
   } catch {
     return [];
   }
@@ -1123,7 +1434,7 @@ async function listCheckpointRecords(sessionDir) {
     return Array.isArray(parsed) ? parsed : [];
   } catch {
     process.stderr.write(
-      `[star-cli] checkpoints index unreadable for session ${path3.basename(sessionDir)}, ignoring it
+      `[star-cli] checkpoints index unreadable for session ${path4.basename(sessionDir)}, ignoring it
 `
     );
     return [];
@@ -1131,9 +1442,20 @@ async function listCheckpointRecords(sessionDir) {
 }
 async function appendCheckpointRecord(sessionDir, record, content) {
   await enqueueIndexWrite(sessionDir, async () => {
-    await fs2.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
+    await fs3.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
     if (record.existed && content !== null) {
-      await fs2.writeFile(checkpointContentPath(sessionDir, record.id), content, "utf8");
+      const target = checkpointContentPath(sessionDir, record.id);
+      const tmp = `${target}.tmp-${process.pid}-${randomUUID3()}`;
+      try {
+        await withTransientFsRetry(async () => {
+          await fs3.writeFile(tmp, content, "utf8");
+          await fs3.rename(tmp, target);
+        });
+      } catch (error) {
+        await fs3.unlink(tmp).catch(() => {
+        });
+        throw error;
+      }
     }
     const records = await listCheckpointRecords(sessionDir);
     records.push(record);
@@ -1147,10 +1469,10 @@ async function removeCheckpointRecords(sessionDir, 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 fs3.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
     await writeIndex(sessionDir, kept);
     for (const id of ids) {
-      await fs2.rm(checkpointContentPath(sessionDir, id), { force: true });
+      await fs3.rm(checkpointContentPath(sessionDir, id), { force: true });
     }
   });
 }
@@ -1164,13 +1486,13 @@ async function loadSessionSnapshots(sessionDir) {
 }
 
 // src/session/list.ts
-import fs3 from "fs/promises";
-import path4 from "path";
+import fs4 from "fs/promises";
+import path5 from "path";
 var COUNT_CHUNK_BYTES = 64 * 1024;
 async function countMessages(id) {
   let handle = null;
   try {
-    handle = await fs3.open(path4.join(sessionsDir(), id, "messages.jsonl"), "r");
+    handle = await fs4.open(path5.join(sessionsDir(), id, "messages.jsonl"), "r");
     const buffer = Buffer.alloc(COUNT_CHUNK_BYTES);
     let count = 0;
     let lineHasContent = false;
@@ -1221,7 +1543,7 @@ async function findLatestSession(cwd) {
 async function sessionPreview(id, maxBytes = 4096) {
   let handle = null;
   try {
-    handle = await fs3.open(path4.join(sessionsDir(), id, "messages.jsonl"), "r");
+    handle = await fs4.open(path5.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);
@@ -1295,11 +1617,22 @@ When you report completion, state the evidence: which checks you ran and that th
 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";
+import fs5 from "fs/promises";
+import path6 from "path";
+async function removeIfUnlocked(id) {
+  const dir = path6.join(sessionsDir(), id);
+  const lock = await acquireSessionLock(dir, id).catch((error) => {
+    if (error instanceof SessionLockedError) return null;
+    throw error;
+  });
+  if (!lock) return false;
+  await lock.release();
+  await fs5.rm(dir, { recursive: true, force: true });
+  return true;
+}
 async function deleteSession(id) {
   const meta = (await SessionStore.list()).find((m) => m.id === id);
-  await fs4.rm(path5.join(sessionsDir(), id), { recursive: true, force: true });
+  if (!await removeIfUnlocked(id)) return;
   if (meta && (await SessionStore.list(meta.cwd)).length === 0) {
     await removeTreeRepo(meta.cwd);
   }
@@ -1310,8 +1643,7 @@ async function clearSessions(cwd, excludeId) {
     let removed2 = 0;
     for (const meta of metas) {
       if (meta.id === excludeId) continue;
-      await fs4.rm(path5.join(sessionsDir(), meta.id), { recursive: true, force: true });
-      removed2 += 1;
+      if (await removeIfUnlocked(meta.id)) removed2 += 1;
     }
     if ((await SessionStore.list(cwd)).length === 0) {
       await removeTreeRepo(cwd);
@@ -1320,15 +1652,14 @@ async function clearSessions(cwd, excludeId) {
   }
   let entries;
   try {
-    entries = await fs4.readdir(sessionsDir());
+    entries = await fs5.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;
+    if (await removeIfUnlocked(entry)) removed += 1;
   }
   const survivors = await SessionStore.list();
   await pruneTreeReposExcept(survivors.map((meta) => meta.cwd));
@@ -1336,13 +1667,13 @@ async function clearSessions(cwd, excludeId) {
 }
 
 // src/version.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { fileURLToPath } from "url";
 function readPackageVersion() {
   try {
-    const pkgPath = path6.join(path6.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path7.join(path7.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
     if (typeof pkg === "object" && pkg !== null) {
       const version = pkg.version;
       if (typeof version === "string") return version;
@@ -1357,7 +1688,6 @@ export {
   formatDollars,
   formatTokens,
   formatTokensCompact,
-  computeCostUsd,
   estimateCost,
   resolveIconMode,
   toolIcon,
@@ -1365,6 +1695,8 @@ export {
   folderIcon,
   renderMarkdown,
   toTerminalSafe,
+  displayWidth,
+  truncateToWidth,
   summarizeArgs,
   previewLines,
   formatByteCount,
@@ -1390,4 +1722,4 @@ export {
   clearSessions,
   VERSION
 };
-//# sourceMappingURL=chunk-2GAUAYCU.js.map
+//# sourceMappingURL=chunk-NRLGGA7L.js.map