@cryer/star-cli 0.1.3 → 0.2.1

package/dist/main.js

@@ -1,608 +1,45 @@
 #!/usr/bin/env node
+import {
+  AgentLoop,
+  SKIP_DIRS,
+  TodoStore,
+  WORKING_DIFF_MAX_LINES,
+  bashTool,
+  buildAllowRule,
+  buildCommitPrompt,
+  clearSnapshots,
+  collectCommitContext,
+  collectWorkingDiff,
+  compactMessages,
+  createDefaultRegistry,
+  defaultTaskManager,
+  discoverSkills,
+  estimateTokens,
+  formatTaskFinished,
+  formatTaskList,
+  formatTaskStarted,
+  formatTodos,
+  getGitSummary,
+  globalConfigPath,
+  hydrateSnapshots,
+  isAllowedByRules,
+  isDangerousCommand,
+  isGitRepo,
+  isSensitivePath,
+  listSnapshots,
+  projectConfigPath,
+  reconcileToolCalls,
+  resolveShell,
+  rewindToSnapshot,
+  sessionsDir,
+  starHome,
+  summarizeMessages,
+  undoTurnSnapshots
+} from "./chunk-MJ2O7NWI.js";
 
 // src/main.tsx
 import { Command } from "commander";
 
-// src/agent/loop.ts
-import { tool as aiTool } from "ai";
-
-// src/context/compaction.ts
-import { generateText } from "ai";
-
-// src/context/tokens.ts
-var CHARS_PER_TOKEN = 4;
-var MESSAGE_OVERHEAD = 4;
-function contentCharLength(message) {
-  if (message.role === "tool") {
-    let chars2 = 0;
-    for (const part of message.content) {
-      chars2 += JSON.stringify(part.result ?? null).length;
-    }
-    return chars2;
-  }
-  if (typeof message.content === "string") {
-    return message.content.length;
-  }
-  let chars = 0;
-  for (const part of message.content) {
-    if (part.type === "text" || part.type === "reasoning") {
-      chars += part.text.length;
-    } else if (part.type === "tool-call") {
-      chars += part.toolName.length + JSON.stringify(part.args ?? null).length;
-    }
-  }
-  return chars;
-}
-function estimateMessageTokens(message) {
-  return Math.ceil(contentCharLength(message) / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD;
-}
-function estimateTokens(messages) {
-  return messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
-}
-
-// src/context/compaction.ts
-var MIN_KEPT_MESSAGES = 4;
-function placeholderMessage(droppedCount) {
-  return {
-    role: "user",
-    content: `[context compacted: ${droppedCount} earlier messages dropped]`
-  };
-}
-var SUMMARY_SYSTEM_PROMPT = [
-  "You are summarizing an AI coding agent's conversation for context compaction.",
-  "Write a concise summary that preserves:",
-  "- the user's goals and requests",
-  "- decisions made and their rationale",
-  "- files and code touched (paths, key changes)",
-  "- tool results that matter (errors, key outputs)",
-  "- outstanding TODOs and next steps",
-  "Output only the summary, no preamble."
-].join("\n");
-function serializeMessage(message) {
-  if (typeof message.content === "string") {
-    return `${message.role}: ${message.content}`;
-  }
-  const parts = message.content.map((part) => {
-    if (part.type === "text") return part.text;
-    if (part.type === "tool-call")
-      return `[tool-call ${part.toolName}] ${JSON.stringify(part.args)}`;
-    if (part.type === "tool-result")
-      return `[tool-result ${part.toolName}] ${JSON.stringify(part.result)}`;
-    return `[${part.type}]`;
-  });
-  return `${message.role}: ${parts.join("\n")}`;
-}
-async function summarizeMessages(messages, model) {
-  const transcript = messages.map(serializeMessage).join("\n");
-  const { text } = await generateText({
-    model,
-    system: SUMMARY_SYSTEM_PROMPT,
-    prompt: `Summarize this conversation so far:
-
-${transcript}`
-  });
-  return text.trim();
-}
-function compactMessages(messages, maxTokens) {
-  if (estimateTokens(messages) <= maxTokens) {
-    return { messages, compacted: false, droppedCount: 0 };
-  }
-  const first = messages[0];
-  const hasSystem = first?.role === "system";
-  const head = hasSystem && first ? [first] : [];
-  const rest = hasSystem ? messages.slice(1) : messages.slice();
-  const turns = [];
-  for (const message of rest) {
-    const current = turns[turns.length - 1];
-    if (message.role === "user" || !current) {
-      turns.push([message]);
-    } else {
-      current.push(message);
-    }
-  }
-  let droppedCount = 0;
-  let turnIndex = 0;
-  while (turnIndex < turns.length) {
-    const turn = turns[turnIndex];
-    if (rest.length - droppedCount - turn.length < MIN_KEPT_MESSAGES) {
-      break;
-    }
-    droppedCount += turn.length;
-    turnIndex += 1;
-    const candidate = [...head, placeholderMessage(droppedCount), ...rest.slice(droppedCount)];
-    if (estimateTokens(candidate) <= maxTokens) {
-      break;
-    }
-  }
-  if (droppedCount === 0) {
-    return { messages, compacted: false, droppedCount: 0 };
-  }
-  return {
-    messages: [...head, placeholderMessage(droppedCount), ...rest.slice(droppedCount)],
-    compacted: true,
-    droppedCount
-  };
-}
-
-// src/core/messages.ts
-var MISSING_TOOL_RESULT_TEXT = "tool result missing (session was interrupted)";
-function reconcileToolCalls(messages) {
-  const result = [];
-  let pending = [];
-  const flushPending = () => {
-    for (const call of pending) {
-      result.push({
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: call.toolCallId,
-            toolName: call.toolName,
-            result: MISSING_TOOL_RESULT_TEXT
-          }
-        ]
-      });
-    }
-    pending = [];
-  };
-  for (const message of messages) {
-    if (message.role === "assistant" && Array.isArray(message.content)) {
-      flushPending();
-      pending = message.content.filter((part) => part.type === "tool-call").map((part) => ({ toolCallId: part.toolCallId, toolName: part.toolName }));
-    } else if (message.role === "tool" && Array.isArray(message.content) && pending.length > 0) {
-      const answered = new Set(message.content.map((part) => part.toolCallId));
-      pending = pending.filter((call) => !answered.has(call.toolCallId));
-    } else {
-      flushPending();
-    }
-    result.push(message);
-  }
-  flushPending();
-  return result;
-}
-function retractLastTurn(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "user") {
-      return { messages: messages.slice(0, i), removed: messages.length - i };
-    }
-  }
-  return { messages, removed: 0 };
-}
-
-// src/permissions/gate.ts
-import path from "path";
-
-// src/permissions/allow.ts
-function parseAllowRule(rule) {
-  const match = /^([\w-]+)(?:\((.*)\))?$/.exec(rule.trim());
-  if (!match) return null;
-  return { toolName: match[1], pattern: match[2] };
-}
-function globMatch(pattern, value) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`).test(value);
-}
-function requestTarget(req) {
-  if (typeof req.args !== "object" || req.args === null) return void 0;
-  const args = req.args;
-  const key = req.toolName === "bash" ? "command" : "path";
-  const value = args[key];
-  return typeof value === "string" ? value : void 0;
-}
-function matchAllowRule(rule, req) {
-  if (rule.toolName !== req.toolName) return false;
-  if (rule.pattern === void 0) return true;
-  const target = requestTarget(req);
-  return target !== void 0 && globMatch(rule.pattern, target);
-}
-function isAllowedByRules(rules, req) {
-  return rules.some((raw) => {
-    const rule = parseAllowRule(raw);
-    return rule !== null && matchAllowRule(rule, req);
-  });
-}
-function buildAllowRule(req) {
-  const target = requestTarget(req);
-  return target !== void 0 ? `${req.toolName}(${target})` : req.toolName;
-}
-
-// src/permissions/gate.ts
-var FILE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "read_file"]);
-var DANGEROUS_COMMAND_PATTERNS = [
-  /rm\s+-rf\s+\/(?:\s|$|;|&)/i,
-  /rm\s+-rf\s+~(?:\s|\/|$|;|&)/i,
-  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
-  /\bmkfs\b/i,
-  /dd\s+[^|;]*\bif=/i,
-  />\s*\/dev\/sd[a-z]/i,
-  /\bshutdown\b/i,
-  /\breboot\b/i,
-  /\bpoweroff\b/i
-];
-function isDangerousCommand(command) {
-  return DANGEROUS_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
-}
-function getStringArg(args, key) {
-  if (typeof args === "object" && args !== null) {
-    const value = args[key];
-    if (typeof value === "string") {
-      return value;
-    }
-  }
-  return void 0;
-}
-function normalizeAbsolute(p, cwd) {
-  const abs = path.isAbsolute(p) ? path.normalize(p) : path.resolve(cwd, p);
-  return abs.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
-}
-function isOutsideCwd(p, cwd) {
-  const abs = normalizeAbsolute(p, cwd);
-  const base = normalizeAbsolute(cwd, cwd);
-  return abs !== base && !abs.startsWith(`${base}/`);
-}
-function isSensitivePath(p) {
-  const base = p.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
-  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
-    return false;
-  }
-  return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
-}
-function checkPermission(mode, req, ctx, allowRules = []) {
-  if (mode === "yolo") {
-    return "allow";
-  }
-  const command = getStringArg(req.args, "command");
-  const filePath = getStringArg(req.args, "path");
-  if (req.toolName === "bash" && command !== void 0 && isDangerousCommand(command)) {
-    return "deny";
-  }
-  if (FILE_TOOLS.has(req.toolName) && filePath !== void 0) {
-    if ((req.toolName === "write_file" || req.toolName === "edit_file") && isSensitivePath(filePath)) {
-      return "deny";
-    }
-    if (isOutsideCwd(filePath, ctx.cwd)) {
-      if (mode === "ask" && req.level === "read") {
-        return "ask";
-      }
-      return "deny";
-    }
-  }
-  if (mode === "auto") {
-    return "allow";
-  }
-  if (mode === "readonly") {
-    return req.level === "read" ? "allow" : "deny";
-  }
-  if (mode === "plan") {
-    return req.level === "read" ? "allow" : "deny";
-  }
-  if (isAllowedByRules(allowRules, req)) {
-    return "allow";
-  }
-  return req.level === "read" ? "allow" : "ask";
-}
-
-// src/tools/fs/snapshots.ts
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
-import path2 from "path";
-var MAX_SNAPSHOTS = 50;
-var stack = [];
-var activeTurn = 0;
-function beginTurn() {
-  return ++activeTurn;
-}
-function currentTurnSeq() {
-  return activeTurn;
-}
-async function captureSnapshot(filePath, toolName) {
-  let content = null;
-  let existed = false;
-  try {
-    content = await readFile(filePath, "utf8");
-    existed = true;
-  } catch {
-  }
-  return { path: filePath, existed, content, toolName, timestamp: Date.now(), turn: activeTurn };
-}
-function pushSnapshot(snapshot) {
-  stack.push(snapshot);
-  if (stack.length > MAX_SNAPSHOTS) {
-    stack.splice(0, stack.length - MAX_SNAPSHOTS);
-  }
-}
-async function revert(snapshot) {
-  if (snapshot.existed && snapshot.content !== null) {
-    await mkdir(path2.dirname(snapshot.path), { recursive: true });
-    await writeFile(snapshot.path, snapshot.content, "utf8");
-    return `Restored ${snapshot.path} to its state before ${snapshot.toolName}.`;
-  }
-  await rm(snapshot.path, { force: true });
-  return `Deleted ${snapshot.path} (it did not exist before ${snapshot.toolName}).`;
-}
-async function undoTurnSnapshots(turn) {
-  const matches = [];
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const snapshot = stack[i];
-    if (snapshot && snapshot.turn === turn) {
-      matches.push(snapshot);
-      stack.splice(i, 1);
-    }
-  }
-  const messages = [];
-  for (const snapshot of matches) {
-    messages.push(await revert(snapshot));
-  }
-  return messages;
-}
-
-// src/agent/loop.ts
-var PLAN_MODE_PROMPT = "\n\nYou are currently in PLAN MODE. Research the task using only the read-only tools available to you, then present a concrete, step-by-step implementation plan as your final answer. You must not modify files, run shell commands, or otherwise change the system \u2014 write/exec tools are unavailable in this mode. Do not ask the user to run commands for you; note manual steps in the plan instead. The user will review your plan and approve it before any execution begins.";
-var AgentLoop = class {
-  messages = [];
-  opts;
-  // Seq + user-message index of each turn started via stream(); lets /undo
-  // match a retracted turn to the file snapshots it produced. Cleared when
-  // history is replaced wholesale (resume/compact), because indices no longer
-  // line up — in that case /undo only retracts messages, never wrong files.
-  turnMarkers = [];
-  confirmHandler;
-  constructor(opts) {
-    this.opts = opts;
-    if (opts.system) {
-      this.messages.push({ role: "system", content: opts.system });
-    }
-  }
-  getMessages() {
-    return this.messages;
-  }
-  async loadMessages(messages) {
-    this.messages = reconcileToolCalls(messages);
-    this.turnMarkers = [];
-  }
-  // Drops the final user message and everything after it, and persists the
-  // trimmed history so a later /resume does not bring the turn back.
-  // `turn` is the retracted turn's snapshot seq when it could be verified
-  // against the marker recorded at turn start — undefined means the caller
-  // must not revert any file snapshots.
-  async retractLastTurn() {
-    const result = retractLastTurn([...this.messages]);
-    if (result.removed === 0) return { removed: 0 };
-    const userIndex = result.messages.length;
-    this.messages = result.messages;
-    await this.opts.sessionStore?.replaceMessages([...this.messages]);
-    const last = this.turnMarkers[this.turnMarkers.length - 1];
-    let turn;
-    if (last && last.userIndex === userIndex) {
-      turn = last.seq;
-      this.turnMarkers.pop();
-    }
-    return { removed: result.removed, turn };
-  }
-  async appendContextMessage(text, role = "user") {
-    const message = { role, content: text };
-    this.messages.push(message);
-    await this.persist(message);
-  }
-  async persist(message) {
-    await this.opts.sessionStore?.append(message);
-  }
-  async *stream(input, signal, opts) {
-    this.syncSystemMessage();
-    const userMessage = { role: "user", content: input };
-    this.messages.push(userMessage);
-    this.turnMarkers.push({ seq: beginTurn(), userIndex: this.messages.length - 1 });
-    await this.persist(
-      opts?.persistAs !== void 0 ? { role: "user", content: opts.persistAs } : userMessage
-    );
-    const { config, registry, cwd } = this.opts;
-    const aiTools = this.buildAiTools();
-    for (let step = 0; step < config.maxSteps; step++) {
-      const compacted = compactMessages([...this.messages], config.contextMaxTokens);
-      if (compacted.compacted) {
-        this.messages = await this.applyCompactionSummary(compacted);
-      }
-      let text = "";
-      const toolCalls = [];
-      let failed = false;
-      try {
-        for await (const event of this.streamOnce(aiTools, signal)) {
-          if (event.type === "text-delta") {
-            text += event.text;
-            yield event;
-          } else if (event.type === "reasoning") {
-            yield event;
-          } else if (event.type === "tool-call") {
-            toolCalls.push({ id: event.id, name: event.name, args: event.args });
-            yield event;
-          } else if (event.type === "error") {
-            failed = true;
-            yield event;
-          } else {
-            yield event;
-          }
-        }
-      } catch (error) {
-        if (signal.aborted) return;
-        yield { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
-        return;
-      }
-      if (failed) return;
-      const assistantMessage = {
-        role: "assistant",
-        content: [
-          ...text ? [{ type: "text", text }] : [],
-          ...toolCalls.map((call) => ({
-            type: "tool-call",
-            toolCallId: call.id,
-            toolName: call.name,
-            args: call.args
-          }))
-        ]
-      };
-      this.messages.push(assistantMessage);
-      await this.persist(assistantMessage);
-      if (toolCalls.length === 0) return;
-      const answered = /* @__PURE__ */ new Set();
-      try {
-        for (const call of toolCalls) {
-          if (signal.aborted) break;
-          const result = await this.executeTool(call, signal);
-          const toolMessage = {
-            role: "tool",
-            content: [
-              {
-                type: "tool-result",
-                toolCallId: call.id,
-                toolName: call.name,
-                result: result.content
-              }
-            ]
-          };
-          this.messages.push(toolMessage);
-          await this.persist(toolMessage);
-          answered.add(call.id);
-          yield {
-            type: "tool-result",
-            id: call.id,
-            name: call.name,
-            content: result.content,
-            isError: result.isError
-          };
-        }
-      } finally {
-        for (const call of toolCalls) {
-          if (answered.has(call.id)) continue;
-          const content = signal.aborted ? "Tool execution interrupted by user." : "Tool execution interrupted before a result was produced.";
-          const synthetic = {
-            role: "tool",
-            content: [
-              {
-                type: "tool-result",
-                toolCallId: call.id,
-                toolName: call.name,
-                result: content
-              }
-            ]
-          };
-          this.messages.push(synthetic);
-          await this.persist(synthetic).catch(() => {
-          });
-          yield { type: "tool-result", id: call.id, name: call.name, content, isError: true };
-        }
-      }
-      if (signal.aborted) return;
-    }
-    yield {
-      type: "error",
-      error: new Error(`Max steps (${config.maxSteps}) reached, stopping.`)
-    };
-  }
-  // The permission mode can change at runtime, so the system message is
-  // recomputed at the start of every turn instead of being frozen by the
-  // constructor. Also restores a system message after loadMessages() (resume,
-  // /model switch) replaced the history with one that has none.
-  syncSystemMessage() {
-    const base = this.opts.system;
-    const plan = this.opts.config.permissionMode === "plan";
-    const content = plan ? base ? base + PLAN_MODE_PROMPT : PLAN_MODE_PROMPT.trim() : base ?? null;
-    if (content === null) return;
-    const head = this.messages[0];
-    if (head?.role === "system" && typeof head.content === "string") {
-      if (head.content !== content) head.content = content;
-    } else if (head?.role !== "system") {
-      this.messages.unshift({ role: "system", content });
-    }
-  }
-  async applyCompactionSummary(compacted) {
-    const { config, model } = this.opts;
-    if (config.contextCompaction !== "summary" || !model) {
-      return compacted.messages;
-    }
-    const headCount = compacted.messages[0]?.role === "system" ? 1 : 0;
-    const dropped = this.messages.slice(headCount, headCount + compacted.droppedCount);
-    try {
-      const summary = await summarizeMessages(dropped, model);
-      const messages = compacted.messages.slice();
-      messages[headCount] = {
-        role: "user",
-        content: `[earlier conversation summarized]
-${summary}`
-      };
-      return messages;
-    } catch {
-      return compacted.messages;
-    }
-  }
-  async *streamOnce(aiTools, signal) {
-    const { streamChat } = await import("./stream-Y55NRF2S.js");
-    yield* streamChat({
-      model: this.opts.model,
-      messages: this.messages,
-      tools: aiTools,
-      abortSignal: signal,
-      idleTimeoutMs: this.opts.config.streamIdleTimeoutSec * 1e3
-    });
-  }
-  buildAiTools() {
-    const plan = this.opts.config.permissionMode === "plan";
-    const tools = {};
-    for (const t of this.opts.registry.list()) {
-      if (plan && t.permission !== "read") continue;
-      tools[t.name] = aiTool({
-        description: t.description,
-        parameters: t.parameters
-      });
-    }
-    return tools;
-  }
-  async executeTool(call, signal) {
-    const { registry, config, cwd } = this.opts;
-    const tool = registry.get(call.name);
-    if (!tool) {
-      return { content: `Unknown tool: ${call.name}`, isError: true };
-    }
-    const decision = checkPermission(
-      config.permissionMode,
-      { toolName: call.name, args: call.args, level: tool.permission },
-      { cwd },
-      config.permissions.allow
-    );
-    if (decision === "deny") {
-      return { content: `Permission denied for tool "${call.name}".`, isError: true };
-    }
-    if (decision === "ask") {
-      let approved = false;
-      try {
-        approved = this.confirmHandler ? await this.confirmHandler({
-          toolName: call.name,
-          args: call.args,
-          level: tool.permission
-        }) : false;
-      } catch {
-        approved = false;
-      }
-      if (!approved) {
-        return { content: `User rejected tool "${call.name}".`, isError: true };
-      }
-    }
-    const parsed = tool.parameters.safeParse(call.args);
-    if (!parsed.success) {
-      return { content: `Invalid arguments: ${parsed.error.message}`, isError: true };
-    }
-    try {
-      return await tool.execute(parsed.data, { cwd, abortSignal: signal });
-    } catch (error) {
-      if (signal.aborted) {
-        return { content: "Tool execution aborted.", isError: true };
-      }
-      return {
-        content: `Tool error: ${error instanceof Error ? error.message : String(error)}`,
-        isError: true
-      };
-    }
-  }
-};
-
 // src/cli/format.ts
 function summarizeArgs(args, maxLength = 120) {
   let json;
@@ -666,92 +103,30 @@ function buildDisplayMessages(messages) {
 }
 
 // src/cli/mentions.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import path4 from "path";
-
-// src/tools/fs/util.ts
-import { readdir, stat } from "fs/promises";
-import path3 from "path";
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
-async function walkFiles(root, skipDirs = SKIP_DIRS) {
-  const out = [];
-  async function walk(dir, relBase) {
-    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (!entries) {
-      return;
-    }
-    for (const entry of entries) {
-      const abs = path3.join(dir, entry.name);
-      const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) {
-          await walk(abs, rel);
-        }
-      } else if (entry.isFile()) {
-        try {
-          const st = await stat(abs);
-          out.push({ abs, rel, mtimeMs: st.mtimeMs });
-        } catch {
-        }
-      }
-    }
-  }
-  await walk(root, "");
-  return out;
-}
-var REGEX_SPECIALS = /[.+^${}()|[\]\\]/g;
-function globToRegExp(pattern) {
-  let re = "";
-  let i = 0;
-  while (i < pattern.length) {
-    const c = pattern.charAt(i);
-    if (c === "*") {
-      if (pattern.charAt(i + 1) === "*") {
-        i += 2;
-        if (pattern.charAt(i) === "/") {
-          i += 1;
-          re += "(?:[^/]+/)*";
-        } else {
-          re += ".*";
-        }
-      } else {
-        re += "[^/]*";
-        i += 1;
-      }
-    } else if (c === "?") {
-      re += "[^/]";
-      i += 1;
-    } else {
-      re += c.replace(REGEX_SPECIALS, "\\$&");
-      i += 1;
-    }
-  }
-  return new RegExp(`^${re}$`);
-}
-function matchesGlob(pattern, relPath) {
-  const normalized = pattern.replace(/\\/g, "/");
-  if (!normalized.includes("/")) {
-    const base = relPath.split("/").pop() ?? relPath;
-    return globToRegExp(normalized).test(base);
-  }
-  return globToRegExp(normalized).test(relPath);
-}
-function isSensitivePath2(filePath) {
-  const base = path3.basename(filePath);
-  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
-    return false;
-  }
-  if (base === ".env" || base.startsWith(".env.")) {
-    return true;
-  }
-  if (base === "id_rsa" || base.endsWith(".pem")) {
-    return true;
-  }
-  return false;
-}
-
-// src/cli/mentions.ts
+import { readFile, stat } from "fs/promises";
+import path from "path";
 var MAX_MENTION_BYTES = 100 * 1024;
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function imageMimeType(filePath) {
+  return IMAGE_MIME_TYPES[path.extname(filePath).toLowerCase()] ?? null;
+}
+async function readImageInput(filePath, cwd) {
+  const mimeType = imageMimeType(filePath);
+  if (!mimeType) return null;
+  const abs = path.resolve(cwd, filePath);
+  const st = await stat(abs).catch(() => null);
+  if (!st || !st.isFile() || st.size > MAX_IMAGE_BYTES) return null;
+  const buf = await readFile(abs).catch(() => null);
+  if (!buf) return null;
+  return { path: filePath, mimeType, data: buf.toString("base64") };
+}
 var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\]*|[A-Za-z0-9._\-/\\]+)/g;
 function parseMentions(text) {
   const mentions = [];
@@ -787,18 +162,39 @@ function isBinaryContent(buf) {
 async function resolveMentions(text, cwd) {
   const { cleanText, mentions } = parseMentions(text);
   if (mentions.length === 0) {
-    return { input: text, attached: [], skipped: [] };
+    return { input: text, attached: [], skipped: [], images: [] };
   }
   const blocks = [];
   const attached = [];
   const skipped = [];
+  const images = [];
   for (const mention of mentions) {
-    const abs = path4.resolve(cwd, mention);
-    if (isSensitivePath2(abs)) {
+    const abs = path.resolve(cwd, mention);
+    if (isSensitivePath(abs)) {
       skipped.push({ path: mention, reason: "sensitive file" });
       continue;
     }
-    const st = await stat2(abs).catch(() => null);
+    const mimeType = imageMimeType(mention);
+    if (mimeType) {
+      const st2 = await stat(abs).catch(() => null);
+      if (!st2 || !st2.isFile()) {
+        skipped.push({ path: mention, reason: st2 ? "is a directory" : "file not found" });
+        continue;
+      }
+      if (st2.size > MAX_IMAGE_BYTES) {
+        skipped.push({ path: mention, reason: "image too large" });
+        continue;
+      }
+      const buf2 = await readFile(abs).catch(() => null);
+      if (!buf2) {
+        skipped.push({ path: mention, reason: "unreadable" });
+        continue;
+      }
+      attached.push(mention);
+      images.push({ path: mention, mimeType, data: buf2.toString("base64") });
+      continue;
+    }
+    const st = await stat(abs).catch(() => null);
     if (!st) {
       skipped.push({ path: mention, reason: "file not found" });
       continue;
@@ -811,7 +207,7 @@ async function resolveMentions(text, cwd) {
       skipped.push({ path: mention, reason: `exceeds ${MAX_MENTION_BYTES / 1024}KB limit` });
       continue;
     }
-    const buf = await readFile2(abs).catch(() => null);
+    const buf = await readFile(abs).catch(() => null);
     if (!buf) {
       skipped.push({ path: mention, reason: "unreadable" });
       continue;
@@ -826,7 +222,7 @@ ${buf.toString("utf8")}
 --- end ---`);
   }
   const input = [cleanText, ...blocks].filter((s) => s.length > 0).join("\n\n") || text;
-  return { input, attached, skipped };
+  return { input, attached, skipped, images };
 }
 
 // src/cli/print-json.ts
@@ -873,31 +269,13 @@ var UsageTracker = class {
 };
 
 // src/cli/repl.tsx
-import { Box as Box8, Text as Text8, render, useApp, useInput as useInput4 } from "ink";
-import { useCallback, useEffect, useMemo, useRef as useRef2, useState as useState2 } from "react";
+import { Box as Box9, Text as Text10, render, useApp, useInput as useInput5 } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
 
 // src/config/save.ts
 import fs from "fs";
-import path6 from "path";
+import path2 from "path";
 import { parse, stringify } from "smol-toml";
-
-// src/config/paths.ts
-import os from "os";
-import path5 from "path";
-function starHome() {
-  return process.env.STAR_HOME ?? path5.join(os.homedir(), ".star-cli");
-}
-function globalConfigPath() {
-  return path5.join(starHome(), "config.toml");
-}
-function sessionsDir() {
-  return path5.join(starHome(), "sessions");
-}
-function projectConfigPath(cwd) {
-  return path5.join(cwd, ".star", "config.toml");
-}
-
-// src/config/save.ts
 async function addAllowRule(rule) {
   const filePath = globalConfigPath();
   let raw = {};
@@ -912,7 +290,7 @@ async function addAllowRule(rule) {
   if (allow.includes(rule)) return false;
   permissions.allow = [...allow, rule];
   raw.permissions = permissions;
-  await fs.promises.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
   return true;
 }
@@ -926,10 +304,79 @@ async function savePermissionMode(mode) {
     if (error.code !== "ENOENT") throw error;
   }
   raw.permissionMode = mode;
-  await fs.promises.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
 }
 
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
+  baseURL: z.string(),
+  apiKeyEnv: z.string().optional(),
+  apiKey: z.string().optional(),
+  headers: z.record(z.string()).optional()
+});
+var ModelConfigSchema = z.object({
+  name: z.string(),
+  provider: z.string(),
+  model: z.string(),
+  maxTokens: z.number().int().positive().optional(),
+  // Per-model context window; overrides the top-level contextMaxTokens for
+  // compaction and the status bar when set.
+  contextMaxTokens: z.number().int().positive().optional(),
+  // Cost estimation needs BOTH prices (USD per 1M tokens); with only one set
+  // the model is treated as unpriced.
+  promptPrice: z.number().nonnegative().optional(),
+  completionPrice: z.number().nonnegative().optional()
+});
+var PermissionsConfigSchema = z.object({
+  allow: z.array(z.string()).default([])
+});
+var HookConfigSchema = z.object({
+  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
+  matcher: z.string().refine(
+    (pattern) => {
+      try {
+        new RegExp(pattern);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { message: "invalid regular expression" }
+  ).optional(),
+  command: z.string().min(1),
+  timeoutSec: z.number().positive().default(30)
+});
+var ConfigSchema = z.object({
+  defaultModel: z.string().default(""),
+  permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
+  providers: z.array(ProviderConfigSchema).default([]),
+  models: z.array(ModelConfigSchema).default([]),
+  maxSteps: z.number().int().positive().default(50),
+  contextMaxTokens: z.number().int().positive().default(1e5),
+  // Seconds without any stream part before a stalled response is ended
+  // gracefully (some relays never send the terminal chunks). Applies once
+  // streaming has started; the first part gets a longer, fixed allowance.
+  streamIdleTimeoutSec: z.number().positive().default(20),
+  contextCompaction: z.enum(["summary", "truncate"]).default("summary"),
+  // Optional per-session dollar budget; when set, the REPL stops the session
+  // once the estimated cost for the session reaches this amount.
+  sessionBudgetUsd: z.number().positive().optional(),
+  // Terminal bell (REPL only): ring when a turn takes longer than
+  // notifyBellThresholdSec, and when a background task finishes.
+  // STAR_NO_NOTIFY=1 disables without touching the config.
+  notifyBell: z.boolean().default(true),
+  notifyBellThresholdSec: z.number().positive().default(10),
+  permissions: PermissionsConfigSchema.default({ allow: [] }),
+  hooks: z.array(HookConfigSchema).default([])
+});
+function contextWindowTokens(config, modelName) {
+  return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
+}
+
 // src/llm/provider.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -992,9 +439,69 @@ function createModel(config, modelName) {
   }
 }
 
-// src/session/store.ts
+// src/session/checkpoints.ts
 import fs2 from "fs/promises";
-import path7 from "path";
+import path3 from "path";
+function checkpointsDir(sessionDir) {
+  return path3.join(sessionDir, "checkpoints");
+}
+function indexPath(sessionDir) {
+  return path3.join(checkpointsDir(sessionDir), "index.json");
+}
+function checkpointContentPath(sessionDir, id) {
+  return path3.join(checkpointsDir(sessionDir), `${id}.snapshot`);
+}
+async function listCheckpointRecords(sessionDir) {
+  let raw;
+  try {
+    raw = await fs2.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 fs2.mkdir(checkpointsDir(sessionDir), { recursive: true });
+  if (record.existed && content !== null) {
+    await fs2.writeFile(checkpointContentPath(sessionDir, record.id), content, "utf8");
+  }
+  const records = await listCheckpointRecords(sessionDir);
+  records.push(record);
+  await fs2.writeFile(indexPath(sessionDir), JSON.stringify(records, null, 2));
+}
+async function removeCheckpointRecords(sessionDir, ids) {
+  if (ids.length === 0) return;
+  const drop = new Set(ids);
+  const records = await listCheckpointRecords(sessionDir);
+  const kept = records.filter((record) => !drop.has(record.id));
+  if (kept.length === records.length) return;
+  await fs2.mkdir(checkpointsDir(sessionDir), { recursive: true });
+  await fs2.writeFile(indexPath(sessionDir), JSON.stringify(kept, null, 2));
+  for (const id of ids) {
+    await fs2.rm(checkpointContentPath(sessionDir, id), { force: true });
+  }
+}
+async function loadSessionSnapshots(sessionDir) {
+  const records = await listCheckpointRecords(sessionDir);
+  return records.map((record) => ({
+    ...record,
+    content: null,
+    contentFile: record.existed ? checkpointContentPath(sessionDir, record.id) : void 0
+  }));
+}
+
+// src/session/clear.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+
+// src/session/store.ts
+import fs3 from "fs/promises";
+import path4 from "path";
 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())}`;
@@ -1005,13 +512,9 @@ function debugWarn(message) {
   if (process.env.STAR_DEBUG === "1") process.stderr.write(`[star-cli] ${message}
 `);
 }
-function messageText(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 dayKey(date) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
 }
 var SessionStore = class _SessionStore {
   id;
@@ -1020,13 +523,13 @@ var SessionStore = class _SessionStore {
   initialized = false;
   constructor(id) {
     this.id = id;
-    this.dir = path7.join(sessionsDir(), id);
+    this.dir = path4.join(sessionsDir(), id);
   }
   metaPath() {
-    return path7.join(this.dir, "meta.json");
+    return path4.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path7.join(this.dir, "messages.jsonl");
+    return path4.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
     const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
@@ -1037,7 +540,7 @@ var SessionStore = class _SessionStore {
     const store = new _SessionStore(id);
     let raw;
     try {
-      raw = await fs2.readFile(store.metaPath(), "utf8");
+      raw = await fs3.readFile(store.metaPath(), "utf8");
     } catch {
       return null;
     }
@@ -1053,14 +556,14 @@ var SessionStore = class _SessionStore {
   static async list(cwd) {
     let entries;
     try {
-      entries = await fs2.readdir(sessionsDir());
+      entries = await fs3.readdir(sessionsDir());
     } catch {
       return [];
     }
     const metas = [];
     for (const entry of entries) {
       try {
-        const raw = await fs2.readFile(path7.join(sessionsDir(), entry, "meta.json"), "utf8");
+        const raw = await fs3.readFile(path4.join(sessionsDir(), entry, "meta.json"), "utf8");
         const meta = JSON.parse(raw);
         if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) metas.push(meta);
       } catch {
@@ -1075,7 +578,7 @@ var SessionStore = class _SessionStore {
       this.initialized = true;
       return;
     }
-    await fs2.mkdir(this.dir, { recursive: true });
+    await fs3.mkdir(this.dir, { recursive: true });
     const meta = {
       id: this.id,
       title: "",
@@ -1084,33 +587,30 @@ var SessionStore = class _SessionStore {
       createdAt: pending.createdAt,
       updatedAt: pending.createdAt
     };
-    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
     this.initialized = true;
   }
   async append(message) {
     await this.ensureInitialized();
-    await fs2.appendFile(this.messagesPath(), `${JSON.stringify(message)}
+    await fs3.appendFile(this.messagesPath(), `${JSON.stringify(message)}
 `);
     const meta = await this.meta();
     meta.updatedAt = Date.now();
-    if (!meta.title && message.role === "user") {
-      meta.title = messageText(message).slice(0, 60);
-    }
-    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
   async replaceMessages(messages) {
     await this.ensureInitialized();
     const content = messages.map((message) => JSON.stringify(message)).join("\n");
-    await fs2.writeFile(this.messagesPath(), content ? `${content}
+    await fs3.writeFile(this.messagesPath(), content ? `${content}
 ` : "");
     const meta = await this.meta();
     meta.updatedAt = Date.now();
-    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
   async messages() {
     let raw;
     try {
-      raw = await fs2.readFile(this.messagesPath(), "utf8");
+      raw = await fs3.readFile(this.messagesPath(), "utf8");
     } catch {
       return [];
     }
@@ -1133,7 +633,7 @@ var SessionStore = class _SessionStore {
   async meta() {
     await this.ensureInitialized();
     try {
-      const raw = await fs2.readFile(this.metaPath(), "utf8");
+      const raw = await fs3.readFile(this.metaPath(), "utf8");
       return JSON.parse(raw);
     } catch {
       debugWarn(`session ${this.id}: unreadable meta.json, using defaults`);
@@ -1145,7 +645,17 @@ var SessionStore = class _SessionStore {
     const meta = await this.meta();
     meta.title = title;
     meta.updatedAt = Date.now();
-    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+  }
+  async appendCheckpoint(record, content) {
+    await this.ensureInitialized();
+    await appendCheckpointRecord(this.dir, record, content);
+  }
+  async listCheckpoints() {
+    return listCheckpointRecords(this.dir);
+  }
+  async removeCheckpoints(ids) {
+    await removeCheckpointRecords(this.dir, ids);
   }
   async addUsage(delta) {
     await this.ensureInitialized();
@@ -1161,20 +671,83 @@ var SessionStore = class _SessionStore {
     usage.completionTokens += delta.completionTokens;
     usage.totalTokens += delta.totalTokens;
     meta.usage = usage;
-    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    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 fs3.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
 };
 
-// src/session/resume.ts
-async function resumeSession(id) {
-  const store = await SessionStore.open(id);
-  if (!store) return null;
-  const [meta, loaded] = await Promise.all([store.meta(), store.messages()]);
-  const messages = reconcileToolCalls(loaded);
-  if (messages.length !== loaded.length) {
-    await store.replaceMessages(messages);
+// src/session/clear.ts
+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;
+    }
+    return removed2;
   }
-  return { meta, messages };
+  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;
+  }
+  return removed;
+}
+
+// src/session/list.ts
+import fs5 from "fs/promises";
+import path6 from "path";
+async function countMessages(id) {
+  let raw;
+  try {
+    raw = await fs5.readFile(path6.join(sessionsDir(), id, "messages.jsonl"), "utf8");
+  } catch {
+    return 0;
+  }
+  let count = 0;
+  for (const line of raw.split("\n")) {
+    if (line.trim()) count += 1;
+  }
+  return count;
+}
+async function listSessionEntries(cwd) {
+  const metas = await SessionStore.list(cwd);
+  return Promise.all(
+    metas.map(async (meta) => ({ meta, messageCount: await countMessages(meta.id) }))
+  );
+}
+async function findLatestSession(cwd) {
+  const [latest] = await SessionStore.list(cwd);
+  return latest ?? null;
+}
+function shortSessionId(id) {
+  const dash = id.lastIndexOf("-");
+  return dash === -1 ? id : id.slice(dash + 1);
+}
+async function resolveSessionId(query) {
+  const metas = await SessionStore.list();
+  const exact = metas.find((meta) => meta.id === query);
+  if (exact) return exact.id;
+  const matches = metas.filter(
+    (meta) => shortSessionId(meta.id) === query || meta.id.startsWith(query)
+  );
+  return matches.length === 1 ? matches[0]?.id ?? null : null;
 }
 function relativeTime(timestamp) {
   const diff = Date.now() - timestamp;
@@ -1189,1012 +762,224 @@ function relativeTime(timestamp) {
   if (months < 12) return `${months} \u4E2A\u6708\u524D`;
   return `${Math.floor(months / 12)} \u5E74\u524D`;
 }
-function formatSessionList(metas) {
-  return metas.map((meta) => {
+function formatSessionEntries(entries, options = {}) {
+  return entries.map(({ meta, messageCount }) => {
     const title = meta.title || "(\u65E0\u6807\u9898)";
-    return `${meta.id}  ${title}  (\u66F4\u65B0\u4E8E ${relativeTime(meta.updatedAt)})`;
+    const base = `${shortSessionId(meta.id)}  ${title}  ${messageCount} \u6761\u6D88\u606F  \u66F4\u65B0\u4E8E ${relativeTime(meta.updatedAt)}`;
+    return options.showCwd ? `${base}  [${meta.cwd}]` : base;
   }).join("\n");
 }
 
-// src/tasks/format.ts
-function formatDuration(startedAt, endedAt) {
-  const seconds = Math.max(0, Math.round(((endedAt ?? Date.now()) - startedAt) / 1e3));
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) return `${minutes}m${seconds % 60}s`;
-  return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
-}
-function formatStatus(task) {
-  const duration = formatDuration(task.startedAt, task.endedAt);
-  if (task.status === "running") return `running ${duration}`;
-  const exit = task.exitCode === null || task.exitCode === void 0 ? "" : `, exit ${task.exitCode}`;
-  return `${task.status}${exit} after ${duration}`;
-}
-function formatTaskLine(task) {
-  const label = task.description ? `${task.description} (${task.command})` : task.command;
-  return `${task.id} [${formatStatus(task)}] ${label}`;
-}
-function formatTaskList(tasks) {
-  if (tasks.length === 0) return "No background tasks.";
-  return `Background tasks:
-${tasks.map(formatTaskLine).join("\n")}`;
-}
-function formatTaskStarted(task) {
-  const label = task.description ? `${task.description} (${task.command})` : task.command;
-  return `Background task ${task.id} started: ${label}`;
-}
-function formatTaskFinished(task) {
-  const exit = task.exitCode === null || task.exitCode === void 0 ? "" : ` (exit ${task.exitCode})`;
-  switch (task.status) {
-    case "completed":
-      return `Background task ${task.id} finished${exit}: ${task.command}`;
-    case "failed":
-      return `Background task ${task.id} failed${exit}: ${task.command}`;
-    case "timed_out":
-      return `Background task ${task.id} timed out: ${task.command}`;
-    case "stopped":
-      return `Background task ${task.id} stopped: ${task.command}`;
-    default:
-      return `Background task ${task.id}: ${task.command}`;
+// src/session/resume.ts
+async function resumeSession(id) {
+  const store = await SessionStore.open(id);
+  if (!store) return null;
+  const [meta, loaded] = await Promise.all([store.meta(), store.messages()]);
+  const messages = reconcileToolCalls(loaded);
+  if (messages.length !== loaded.length) {
+    await store.replaceMessages(messages);
   }
+  return { meta, messages };
 }
 
-// src/tasks/manager.ts
-import { spawn as spawn2 } from "child_process";
-import { EventEmitter } from "events";
-
-// src/tools/bash.ts
-import { spawn } from "child_process";
-import { existsSync } from "fs";
-import path8 from "path";
-import { z } from "zod";
-var MAX_OUTPUT = 3e4;
-var DEFAULT_TIMEOUT = 120;
-var MAX_TIMEOUT = 600;
-function findOnPath(exe, exclude) {
-  for (const dir of (process.env.PATH ?? "").split(path8.delimiter)) {
-    if (!dir || exclude?.(dir)) {
-      continue;
-    }
-    const full = path8.join(dir, exe);
-    if (existsSync(full)) {
-      return full;
-    }
-  }
-  return null;
-}
-function resolveShell() {
-  if (process.platform !== "win32") {
-    return { shell: "sh", wrap: (c) => ["-c", c], label: "sh" };
-  }
-  const isWslStub = (dir) => /\\(system32|windowsapps)\\?$/i.test(dir.trim());
-  const fromPath = findOnPath("bash.exe", isWslStub);
-  if (fromPath) {
-    return { shell: fromPath, wrap: (c) => ["-c", c], label: "bash" };
-  }
-  const gitExe = findOnPath("git.exe");
-  if (gitExe) {
-    const sibling = path8.join(path8.dirname(path8.dirname(gitExe)), "bin", "bash.exe");
-    if (existsSync(sibling)) {
-      return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
-    }
-  }
-  for (const candidate of [
-    "C:\\Program Files\\Git\\bin\\bash.exe",
-    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
-    "D:\\Git\\bin\\bash.exe"
-  ]) {
-    if (existsSync(candidate)) {
-      return { shell: candidate, wrap: (c) => ["-c", c], label: "bash" };
-    }
+// src/cli/cost.ts
+function formatDollars(cost) {
+  let s = cost.toFixed(4).replace(/0+$/, "");
+  if (s.endsWith(".")) {
+    s += "00";
+  } else if (s.split(".")[1]?.length === 1) {
+    s += "0";
   }
-  const comspec = process.env.ComSpec ?? "cmd.exe";
-  return { shell: comspec, wrap: (c) => ["/d", "/s", "/c", c], label: "cmd" };
+  return s;
 }
-var schema = z.object({
-  command: z.string().describe("Shell command to execute"),
-  timeout: z.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
-  description: z.string().optional().describe("Short description of what the command does"),
-  run_in_background: z.boolean().optional().describe(
-    "Run the command in the background and return a task id immediately (default false). Use task_output/task_kill to inspect or stop it."
-  )
-});
-function killTree(child) {
-  if (process.platform === "win32" && child.pid) {
-    spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
-      windowsHide: true,
-      stdio: "ignore"
-    }).unref();
-    return;
-  }
-  child.kill("SIGKILL");
-}
-function truncateMiddle(s) {
-  if (s.length <= MAX_OUTPUT) {
-    return s;
-  }
-  const half = Math.floor(MAX_OUTPUT / 2);
-  const head = s.slice(0, half);
-  const tail = s.slice(-half);
-  return `${head}
-... [${s.length - MAX_OUTPUT} characters truncated] ...
-${tail}`;
-}
-var bashTool = {
-  name: "bash",
-  description: "Execute a shell command (Git Bash on Windows when available, otherwise cmd; sh elsewhere). Stdout and stderr are merged. Output is truncated to 30000 characters. Set run_in_background for long-running commands; it returns a task id for task_list/task_output/task_kill.",
-  permission: "exec",
-  parameters: schema,
-  execute(args, ctx) {
-    if (args.run_in_background) {
-      const task = defaultTaskManager.start({
-        command: args.command,
-        description: args.description,
-        cwd: ctx.cwd,
-        timeoutSeconds: args.timeout
-      });
-      return Promise.resolve({
-        content: `Background task started: ${task.id}
-command: ${args.command}
-description: ${args.description ?? "(none)"}`
-      });
-    }
-    const timeoutSeconds = Math.min(args.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
-    const spec = resolveShell();
-    return new Promise((resolve) => {
-      const child = spawn(spec.shell, spec.wrap(args.command), {
-        cwd: ctx.cwd,
-        windowsHide: true
-      });
-      let output = "";
-      let settled = false;
-      const finish = (result) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(timer);
-        ctx.abortSignal?.removeEventListener("abort", onAbort);
-        resolve(result);
-      };
-      const onAbort = () => {
-        killTree(child);
-        finish({ content: `${truncateMiddle(output)}
-Command aborted`, isError: true });
-      };
-      const timer = setTimeout(() => {
-        killTree(child);
-        finish({
-          content: `${truncateMiddle(output)}
-Command timed out after ${timeoutSeconds}s`,
-          isError: true
-        });
-      }, timeoutSeconds * 1e3);
-      child.stdout.on("data", (d) => {
-        output += d.toString("utf8");
-      });
-      child.stderr.on("data", (d) => {
-        output += d.toString("utf8");
-      });
-      child.on("error", (err) => {
-        finish({ content: `Failed to start shell '${spec.label}': ${err.message}`, isError: true });
-      });
-      ctx.abortSignal?.addEventListener("abort", onAbort);
-      child.on("close", (code) => {
-        const trimmed = output.replace(/\s+$/, "");
-        if (code === 0) {
-          finish({ content: truncateMiddle(trimmed) || "(no output)" });
-          return;
-        }
-        const body = truncateMiddle(trimmed);
-        finish({
-          content: `${body}${body ? "\n" : ""}Exit code: ${code ?? "unknown"}`,
-          isError: true
-        });
-      });
-    });
-  }
-};
-
-// src/tasks/manager.ts
-var MAX_TASK_OUTPUT = 1e5;
-var DEFAULT_TASK_TIMEOUT = 3600;
-var TRUNCATED_PREFIX = "[... earlier output truncated ...]\n";
-var TaskManager = class extends EventEmitter {
-  records = /* @__PURE__ */ new Map();
-  seq = 0;
-  start(opts) {
-    const id = `task-${++this.seq}`;
-    const spec = resolveShell();
-    const child = spawn2(spec.shell, spec.wrap(opts.command), {
-      cwd: opts.cwd,
-      windowsHide: true
-    });
-    const rec = {
-      id,
-      command: opts.command,
-      description: opts.description,
-      status: "running",
-      startedAt: Date.now(),
-      output: "",
-      truncated: false,
-      child
-    };
-    this.records.set(id, rec);
-    const append = (d) => {
-      rec.output += d.toString("utf8");
-      if (rec.output.length > MAX_TASK_OUTPUT) {
-        rec.output = rec.output.slice(-MAX_TASK_OUTPUT);
-        rec.truncated = true;
-      }
-    };
-    child.stdout.on("data", append);
-    child.stderr.on("data", append);
-    child.on("error", (err) => {
-      append(Buffer.from(`Failed to start shell '${spec.label}': ${err.message}
-`));
-      if (rec.status === "running") {
-        this.finish(rec, "failed", null);
-      }
-    });
-    child.on("close", (code) => {
-      if (rec.status !== "running") return;
-      this.finish(rec, code === 0 ? "completed" : "failed", code);
-    });
-    const timeoutSeconds = opts.timeoutSeconds ?? DEFAULT_TASK_TIMEOUT;
-    rec.timer = setTimeout(() => this.terminate(rec, "timed_out"), timeoutSeconds * 1e3);
-    rec.timer.unref();
-    this.emitUpdate(rec);
-    return this.snapshot(rec);
-  }
-  get(id) {
-    const rec = this.records.get(id);
-    return rec ? this.snapshot(rec) : void 0;
-  }
-  list() {
-    return [...this.records.values()].map((rec) => this.snapshot(rec));
-  }
-  runningCount() {
-    let count = 0;
-    for (const rec of this.records.values()) {
-      if (rec.status === "running") count += 1;
-    }
-    return count;
-  }
-  kill(id) {
-    const rec = this.records.get(id);
-    if (!rec || rec.status !== "running") return void 0;
-    this.terminate(rec, "stopped");
-    return this.snapshot(rec);
-  }
-  cleanup() {
-    const killed = [];
-    for (const rec of this.records.values()) {
-      if (rec.status === "running") {
-        this.terminate(rec, "stopped");
-        killed.push(this.snapshot(rec));
-      }
-    }
-    return killed;
-  }
-  terminate(rec, status) {
-    killTree(rec.child);
-    this.finish(rec, status, null);
-  }
-  finish(rec, status, exitCode) {
-    if (rec.timer) clearTimeout(rec.timer);
-    rec.status = status;
-    rec.exitCode = exitCode;
-    rec.endedAt = Date.now();
-    this.emitUpdate(rec);
-  }
-  emitUpdate(rec) {
-    this.emit("update", this.snapshot(rec));
-  }
-  snapshot(rec) {
-    return {
-      id: rec.id,
-      command: rec.command,
-      description: rec.description,
-      status: rec.status,
-      startedAt: rec.startedAt,
-      endedAt: rec.endedAt,
-      exitCode: rec.exitCode,
-      output: rec.truncated ? TRUNCATED_PREFIX + rec.output : rec.output
-    };
-  }
-};
-var defaultTaskManager = new TaskManager();
-
-// src/tools/fs/edit.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import path9 from "path";
-import { z as z2 } from "zod";
-var schema2 = z2.object({
-  path: z2.string().describe("File path, absolute or relative to the working directory"),
-  old_string: z2.string().min(1).describe("Exact text to replace"),
-  new_string: z2.string().describe("Replacement text"),
-  replace_all: z2.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
-});
-var editFileTool = {
-  name: "edit_file",
-  description: "Replace an exact string in a file. Fails if old_string is not found or matches multiple locations unless replace_all is set.",
-  permission: "write",
-  parameters: schema2,
-  async execute(args, ctx) {
-    const filePath = path9.resolve(ctx.cwd, args.path);
-    let content;
-    try {
-      content = await readFile3(filePath, "utf8");
-    } catch (err) {
-      return { content: `Failed to read ${args.path}: ${err.message}`, isError: true };
-    }
-    let count = 0;
-    let idx = content.indexOf(args.old_string);
-    while (idx !== -1) {
-      count += 1;
-      idx = content.indexOf(args.old_string, idx + args.old_string.length);
-    }
-    if (count === 0) {
-      return { content: `old_string not found in ${args.path}`, isError: true };
-    }
-    if (count > 1 && !args.replace_all) {
-      return {
-        content: `old_string matches ${count} locations in ${args.path}; provide more surrounding context or set replace_all`,
-        isError: true
-      };
-    }
-    const updated = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
-    try {
-      await writeFile2(filePath, updated, "utf8");
-    } catch (err) {
-      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
-    }
-    pushSnapshot({
-      path: filePath,
-      existed: true,
-      content,
-      toolName: "edit_file",
-      timestamp: Date.now(),
-      turn: currentTurnSeq()
-    });
-    return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
-  }
-};
-
-// src/tools/fs/glob.ts
-import path10 from "path";
-import { z as z3 } from "zod";
-var MAX_RESULTS = 100;
-var schema3 = z3.object({
-  pattern: z3.string().describe(
-    "Glob pattern, e.g. 'src/**/*.ts'. Supports **, * and ?. A bare pattern like '*.ts' matches basenames recursively."
-  ),
-  path: z3.string().optional().describe("Directory to search, defaults to the working directory")
-});
-var globTool = {
-  name: "glob",
-  description: "Find files by glob pattern. Skips node_modules, .git and dist. Returns paths sorted by modification time, newest first, up to 100 results.",
-  permission: "read",
-  parameters: schema3,
-  async execute(args, ctx) {
-    const root = path10.resolve(ctx.cwd, args.path ?? ".");
-    const files = await walkFiles(root);
-    const matched = files.filter((f) => matchesGlob(args.pattern, f.rel)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RESULTS);
-    if (matched.length === 0) {
-      return { content: `No files matched pattern: ${args.pattern}` };
-    }
-    return { content: matched.map((f) => f.rel).join("\n") };
-  }
-};
-
-// src/tools/fs/grep.ts
-import { readFile as readFile4, stat as stat3 } from "fs/promises";
-import path11 from "path";
-import { z as z4 } from "zod";
-var MAX_MATCHES = 250;
-var schema4 = z4.object({
-  pattern: z4.string().describe("Regular expression to search for"),
-  path: z4.string().optional().describe("File or directory to search, defaults to the working directory"),
-  glob: z4.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
-  ignoreCase: z4.boolean().optional().describe("Case-insensitive matching")
-});
-var grepTool = {
-  name: "grep",
-  description: "Search file contents with a regular expression. Outputs 'file:line:content', up to 250 matches. Skips binary files, node_modules and .git.",
-  permission: "read",
-  parameters: schema4,
-  async execute(args, ctx) {
-    let re;
-    try {
-      re = new RegExp(args.pattern, args.ignoreCase ? "i" : "");
-    } catch (err) {
-      return { content: `Invalid regular expression: ${err.message}`, isError: true };
-    }
-    const root = path11.resolve(ctx.cwd, args.path ?? ".");
-    let files;
-    try {
-      const st = await stat3(root);
-      if (st.isFile()) {
-        files = [{ abs: root, rel: path11.basename(root), mtimeMs: st.mtimeMs }];
-      } else {
-        files = await walkFiles(root);
-      }
-    } catch {
-      return { content: `Path not found: ${args.path ?? "."}`, isError: true };
-    }
-    if (args.glob) {
-      const glob = args.glob;
-      files = files.filter((f) => matchesGlob(glob, f.rel));
-    }
-    const out = [];
-    let truncated = false;
-    outer: for (const file of files) {
-      let buf;
-      try {
-        buf = await readFile4(file.abs);
-      } catch {
-        continue;
-      }
-      if (buf.includes(0)) {
-        continue;
-      }
-      const lines = buf.toString("utf8").split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? "";
-        if (re.test(line)) {
-          out.push(`${file.rel}:${i + 1}:${line}`);
-          if (out.length >= MAX_MATCHES) {
-            truncated = true;
-            break outer;
-          }
-        }
-      }
-    }
-    if (out.length === 0) {
-      return { content: `No matches for pattern: ${args.pattern}` };
-    }
-    if (truncated) {
-      out.push(`... (truncated: more than ${MAX_MATCHES} matches)`);
-    }
-    return { content: out.join("\n") };
-  }
-};
-
-// src/tools/fs/read.ts
-import { readFile as readFile5, stat as stat4 } from "fs/promises";
-import path12 from "path";
-import { z as z5 } from "zod";
-var DEFAULT_LIMIT = 2e3;
-var MAX_CHARS = 100 * 1024;
-var schema5 = z5.object({
-  path: z5.string().describe("File path, absolute or relative to the working directory"),
-  offset: z5.number().int().positive().optional().describe("1-based line number to start reading from"),
-  limit: z5.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
-});
-var readFileTool = {
-  name: "read_file",
-  description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default.",
-  permission: "read",
-  parameters: schema5,
-  async execute(args, ctx) {
-    const filePath = path12.resolve(ctx.cwd, args.path);
-    if (isSensitivePath2(filePath)) {
-      return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
-    }
-    const st = await stat4(filePath).catch(() => null);
-    if (!st) {
-      return { content: `File not found: ${args.path}`, isError: true };
-    }
-    if (st.isDirectory()) {
-      return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
-    }
-    const raw = await readFile5(filePath, "utf8");
-    const lines = raw.split("\n");
-    const start = args.offset ?? 1;
-    const limit = args.limit ?? DEFAULT_LIMIT;
-    const end = Math.min(lines.length, start - 1 + limit);
-    const out = [];
-    let size = 0;
-    let truncatedBySize = false;
-    for (let i = start - 1; i < end; i++) {
-      const line = lines[i];
-      if (line === void 0) {
-        break;
-      }
-      const numbered = `${i + 1}	${line}`;
-      if (size + numbered.length > MAX_CHARS) {
-        truncatedBySize = true;
-        break;
-      }
-      out.push(numbered);
-      size += numbered.length;
-    }
-    const lastShown = start - 1 + out.length;
-    if (truncatedBySize) {
-      out.push(
-        `... (truncated: output exceeds 100KB, showing lines ${start}-${lastShown} of ${lines.length})`
-      );
-    } else if (end < lines.length) {
-      out.push(`... (truncated: showing lines ${start}-${end} of ${lines.length})`);
-    }
-    return { content: out.join("\n") };
-  }
-};
-
-// src/tools/fs/write.ts
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import path13 from "path";
-import { z as z6 } from "zod";
-var schema6 = z6.object({
-  path: z6.string().describe("File path, absolute or relative to the working directory"),
-  content: z6.string().describe("Full content to write to the file")
-});
-var writeFileTool = {
-  name: "write_file",
-  description: "Write content to a file, creating parent directories as needed. Overwrites existing files.",
-  permission: "write",
-  parameters: schema6,
-  async execute(args, ctx) {
-    const filePath = path13.resolve(ctx.cwd, args.path);
-    const snapshot = await captureSnapshot(filePath, "write_file");
-    try {
-      await mkdir2(path13.dirname(filePath), { recursive: true });
-      await writeFile3(filePath, args.content, "utf8");
-    } catch (err) {
-      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
-    }
-    pushSnapshot(snapshot);
-    return { content: `Wrote ${Buffer.byteLength(args.content, "utf8")} bytes to ${args.path}` };
-  }
-};
-
-// src/tools/tasks.ts
-import { z as z7 } from "zod";
-var idSchema = z7.object({
-  id: z7.string().describe("Task id, e.g. task-1")
-});
-var taskListTool = {
-  name: "task_list",
-  description: "List background shell tasks with status, runtime, and exit code.",
-  permission: "read",
-  parameters: z7.object({}),
-  execute() {
-    return Promise.resolve({ content: formatTaskList(defaultTaskManager.list()) });
-  }
-};
-var taskOutputTool = {
-  name: "task_output",
-  description: "Read the current output of a background shell task (works while still running).",
-  permission: "read",
-  parameters: idSchema,
-  execute(args) {
-    const task = defaultTaskManager.get(args.id);
-    if (!task) {
-      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
-    }
-    const body = task.output.replace(/\s+$/, "") || "(no output yet)";
-    return Promise.resolve({ content: `${formatTaskLine(task)}
-${body}` });
-  }
-};
-var taskKillTool = {
-  name: "task_kill",
-  description: "Stop a running background shell task (kills the whole process tree).",
-  permission: "exec",
-  parameters: idSchema,
-  execute(args) {
-    const task = defaultTaskManager.get(args.id);
-    if (!task) {
-      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
-    }
-    if (task.status !== "running") {
-      return Promise.resolve({
-        content: `Task ${args.id} is not running (status: ${task.status}).`,
-        isError: true
-      });
-    }
-    defaultTaskManager.kill(args.id);
-    return Promise.resolve({ content: `Task ${args.id} stopped.` });
+function computeCostUsd(usage, model) {
+  if (model?.promptPrice === void 0 || model.completionPrice === void 0) {
+    return null;
   }
-};
-
-// src/tools/todo.ts
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import path14 from "path";
-import { z as z8 } from "zod";
-var todoItemSchema = z8.object({
-  id: z8.number().int(),
-  title: z8.string(),
-  status: z8.enum(["pending", "in_progress", "done"])
-});
-var writeSchema = z8.object({
-  todos: z8.array(todoItemSchema).describe("The full todo list, replacing the current one")
-});
-var readSchema = z8.object({});
-function fileFor(cwd) {
-  return path14.join(cwd, ".star", "todos.json");
+  return (usage.promptTokens * model.promptPrice + usage.completionTokens * model.completionPrice) / 1e6;
 }
-var TodoStore = class {
-  items = /* @__PURE__ */ new Map();
-  list() {
-    return [...this.items.values()];
-  }
-  replace(items) {
-    this.items.clear();
-    for (const item of items) {
-      this.items.set(item.id, item);
-    }
-  }
-  async load(cwd) {
-    let raw;
-    try {
-      raw = await readFile6(fileFor(cwd), "utf8");
-    } catch {
-      return;
-    }
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        this.replace(parsed.filter((it) => todoItemSchema.safeParse(it).success));
+function estimateCost(usage, modelName, model) {
+  const cost = computeCostUsd(usage, model);
+  if (cost === null) {
+    if (model !== void 0) {
+      const missing = [
+        model.promptPrice === void 0 ? "promptPrice" : null,
+        model.completionPrice === void 0 ? "completionPrice" : null
+      ].filter((f) => f !== null);
+      if (missing.length === 1) {
+        return `Estimated cost: unknown (${model.name} is missing ${missing[0]} \u2014 both prices are needed)`;
       }
-    } catch {
     }
+    return `Estimated cost: unknown (no price configured for ${modelName})`;
   }
-  async save(cwd) {
-    await mkdir3(path14.join(cwd, ".star"), { recursive: true });
-    await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
-`);
-  }
-};
-var SYMBOLS = {
-  pending: "[ ]",
-  in_progress: "[~]",
-  done: "[x]"
-};
-function formatTodos(items) {
-  if (items.length === 0) {
-    return "No todos.";
-  }
-  const lines = items.map((it) => `${SYMBOLS[it.status]} ${it.id}. ${it.title}`);
-  const width = Math.max(...lines.map((l) => l.length));
-  return lines.map((line, i) => {
-    const status = items[i]?.status;
-    return status === "pending" ? line : `${line.padEnd(width + 4)}(${status})`;
-  }).join("\n");
-}
-var defaultStore = new TodoStore();
-function createTodoTools(store = defaultStore) {
-  const todoWrite = {
-    name: "todo_write",
-    description: "Replace the current todo list with the given items. Each item has an id, title, and status (pending, in_progress, done).",
-    permission: "read",
-    parameters: writeSchema,
-    async execute(args, ctx) {
-      const parsed = writeSchema.safeParse(args);
-      if (!parsed.success) {
-        return { content: `Invalid todos: ${parsed.error.message}`, isError: true };
-      }
-      await store.load(ctx.cwd);
-      store.replace(parsed.data.todos);
-      await store.save(ctx.cwd);
-      return { content: formatTodos(store.list()) };
-    }
-  };
-  const todoRead = {
-    name: "todo_read",
-    description: "Read the current todo list.",
-    permission: "read",
-    parameters: readSchema,
-    async execute(_args, ctx) {
-      await store.load(ctx.cwd);
-      return { content: formatTodos(store.list()) };
-    }
-  };
-  return [todoWrite, todoRead];
+  return `Estimated cost: $${formatDollars(cost)} (${model?.name} @ $${model?.promptPrice}/M prompt, $${model?.completionPrice}/M completion)`;
 }
 
-// src/tools/web/fetch.ts
-import { z as z9 } from "zod";
-var DEFAULT_MAX_CHARS = 2e4;
-var MAX_BYTES = 2 * 1024 * 1024;
-var TIMEOUT_MS = 3e4;
-var schema7 = z9.object({
-  url: z9.string().describe("The http(s) URL to fetch"),
-  maxChars: z9.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
-});
-function decodeEntities(s) {
-  return s.replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(/&#x([0-9a-fA-F]+);/gi, (_, n) => String.fromCodePoint(Number.parseInt(n, 16))).replace(/&(quot|lt|gt|nbsp);/g, (m) => {
-    switch (m) {
-      case "&quot;":
-        return '"';
-      case "&lt;":
-        return "<";
-      case "&gt;":
-        return ">";
-      case "&nbsp;":
-        return " ";
-      default:
-        return m;
-    }
-  }).replace(/&amp;/g, "&");
-}
-function htmlToText(html) {
-  const noBlocks = html.replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1>/gi, " ");
-  const withBreaks = noBlocks.replace(
-    /<br\s*\/?>|<\/(p|div|li|tr|h[1-6]|section|article|header|footer|blockquote|pre)>/gi,
-    "\n"
-  );
-  const stripped = decodeEntities(withBreaks.replace(/<[^>]+>/g, " "));
-  return stripped.split("\n").map((line) => line.replace(/\s+/g, " ").trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+// src/session/usage.ts
+var USAGE_MAX_DAYS = 14;
+function tokens(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function bucketOf(value) {
+  const record = typeof value === "object" && value !== null ? value : {};
+  const promptTokens = tokens(record.promptTokens);
+  const completionTokens = tokens(record.completionTokens);
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: tokens(record.totalTokens) || promptTokens + completionTokens
+  };
 }
-async function readBody(res, maxChars) {
-  if (!res.body) {
-    return "";
-  }
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let bytes = 0;
-  let text = "";
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      bytes += value.byteLength;
-      text += decoder.decode(value, { stream: true });
-      if (bytes >= MAX_BYTES || text.length >= maxChars * 2) {
-        break;
+function addTo(target, source) {
+  target.promptTokens += source.promptTokens;
+  target.completionTokens += source.completionTokens;
+  target.totalTokens += source.totalTokens;
+}
+function aggregateUsage(metas) {
+  const days = /* @__PURE__ */ new Map();
+  const models = /* @__PURE__ */ new Map();
+  const legacy = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+  let hasLegacy = false;
+  let sessionsWithUsage = 0;
+  let requests = 0;
+  const grand = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+  for (const meta of metas) {
+    const dayBuckets = [];
+    if (meta.usageByDay !== null && typeof meta.usageByDay === "object") {
+      for (const [date, value] of Object.entries(meta.usageByDay)) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
+        dayBuckets.push([date, bucketOf(value)]);
       }
     }
-    text += decoder.decode();
-  } finally {
-    reader.cancel().catch(() => {
-    });
-  }
-  return text;
-}
-function truncate(s, maxChars) {
-  if (s.length <= maxChars) {
-    return s;
-  }
-  return `${s.slice(0, maxChars)}
-[truncated, showing first ${maxChars} of ${s.length} chars]`;
-}
-var webFetchTool = {
-  name: "web_fetch",
-  description: "Fetch a URL over http(s) and return its contents as readable text. HTML pages are converted to plain text (tags, scripts and styles removed). Output is truncated to maxChars (default 20000).",
-  permission: "read",
-  parameters: schema7,
-  async execute(args, ctx) {
-    let url;
-    try {
-      url = new URL(args.url);
-    } catch {
-      return { content: `ERROR: invalid URL: ${args.url}`, isError: true };
-    }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-      return {
-        content: `ERROR: only http(s) URLs are supported, got: ${url.protocol}`,
-        isError: true
+    const daySum = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    for (const [, bucket] of dayBuckets) addTo(daySum, bucket);
+    const hasTotals = meta.usage !== null && typeof meta.usage === "object";
+    const totals = hasTotals ? bucketOf(meta.usage) : daySum;
+    const requestCount = hasTotals && meta.usage ? tokens(meta.usage.requests) : 0;
+    if (!hasTotals && dayBuckets.length === 0) continue;
+    sessionsWithUsage += 1;
+    addTo(grand, totals);
+    requests += requestCount;
+    for (const [date, bucket] of dayBuckets) {
+      const acc = days.get(date) ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+      addTo(acc, bucket);
+      days.set(date, acc);
+    }
+    if (hasTotals) {
+      const rest = {
+        promptTokens: Math.max(0, totals.promptTokens - daySum.promptTokens),
+        completionTokens: Math.max(0, totals.completionTokens - daySum.completionTokens),
+        totalTokens: Math.max(0, totals.totalTokens - daySum.totalTokens)
       };
-    }
-    const maxChars = args.maxChars ?? DEFAULT_MAX_CHARS;
-    const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS);
-    const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
-    let res;
-    try {
-      res = await fetch(url, { signal, redirect: "follow" });
-    } catch (err) {
-      if (ctx.abortSignal?.aborted) {
-        return { content: "ERROR: request aborted", isError: true };
-      }
-      if (timeoutSignal.aborted) {
-        return { content: `ERROR: request timed out after ${TIMEOUT_MS / 1e3}s`, isError: true };
+      if (rest.promptTokens > 0 || rest.completionTokens > 0 || rest.totalTokens > 0) {
+        addTo(legacy, rest);
+        hasLegacy = true;
       }
-      const message = err instanceof Error ? err.message : String(err);
-      return { content: `ERROR: failed to fetch ${args.url}: ${message}`, isError: true };
-    }
-    if (!res.ok) {
-      await res.body?.cancel().catch(() => {
-      });
-      return {
-        content: `ERROR: HTTP ${res.status} ${res.statusText} for ${args.url}`,
-        isError: true
-      };
-    }
-    const [rawType = ""] = (res.headers.get("content-type") ?? "text/plain").split(";");
-    const contentType = rawType.trim().toLowerCase();
-    const isHtml = contentType === "text/html" || contentType === "application/xhtml+xml";
-    const isText = contentType.startsWith("text/") || contentType === "application/json" || contentType === "application/xml" || contentType.endsWith("+json") || contentType.endsWith("+xml");
-    if (!isHtml && !isText) {
-      await res.body?.cancel().catch(() => {
-      });
-      return {
-        content: `ERROR: unsupported content type: ${contentType} (${args.url})`,
-        isError: true
-      };
-    }
-    let body;
-    try {
-      body = await readBody(res, maxChars);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { content: `ERROR: failed to read response body: ${message}`, isError: true };
-    }
-    const text = isHtml ? htmlToText(body) : body;
-    return { content: truncate(text, maxChars) };
-  }
-};
-
-// src/tools/web/search.ts
-import { z as z10 } from "zod";
-var TIMEOUT_MS2 = 15e3;
-var DEFAULT_MAX_RESULTS = 5;
-var MAX_RESULTS_LIMIT = 10;
-var SEARCH_URL = "https://html.duckduckgo.com/html/?q=";
-var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
-var schema8 = z10.object({
-  query: z10.string().min(1).describe("The search query"),
-  maxResults: z10.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
-    `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
-  )
-});
-function stripTags(s) {
-  return decodeEntities(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
-}
-function normalizeUrl(href) {
-  const decoded = decodeEntities(href);
-  const uddg = decoded.match(/[?&]uddg=([^&]+)/);
-  if (uddg?.[1]) {
-    try {
-      return decodeURIComponent(uddg[1]);
-    } catch {
-      return decoded;
-    }
-  }
-  if (decoded.startsWith("//")) {
-    return `https:${decoded}`;
-  }
-  return decoded;
-}
-function parseResults(html) {
-  const results = [];
-  const anchorRe = /<a\b[^>]*\bclass\s*=\s*"[^"]*\bresult__a\b[^"]*"[^>]*>[\s\S]*?<\/a>/gi;
-  const anchors = [...html.matchAll(anchorRe)];
-  for (const [i, anchor] of anchors.entries()) {
-    const full = anchor[0];
-    const hrefMatch = full.match(/href\s*=\s*"([^"]*)"/i);
-    if (!hrefMatch?.[1]) {
-      continue;
-    }
-    const url = normalizeUrl(hrefMatch[1]);
-    const title = stripTags(full.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>\s*$/i, ""));
-    const blockStart = (anchor.index ?? 0) + full.length;
-    const blockEnd = i + 1 < anchors.length ? anchors[i + 1]?.index ?? html.length : html.length;
-    const block = html.slice(blockStart, blockEnd);
-    const snippetMatch = block.match(
-      /<(?:a|div)\b[^>]*\bclass\s*=\s*"[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div)>/i
-    );
-    const snippet = snippetMatch?.[1] ? stripTags(snippetMatch[1]) : "";
-    if (title && url) {
-      results.push({ title, url, snippet });
     }
+    const name = typeof meta.model === "string" && meta.model.trim() ? meta.model : "unknown";
+    const entry = models.get(name) ?? {
+      model: name,
+      sessions: 0,
+      requests: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    entry.sessions += 1;
+    entry.requests += requestCount;
+    addTo(entry, totals);
+    models.set(name, entry);
   }
-  return results;
-}
-var webSearchTool = {
-  name: "web_search",
-  description: "Search the web using DuckDuckGo and return a numbered list of results with title, URL and snippet. No API key required. Use web_fetch to read a result's full page.",
-  permission: "read",
-  parameters: schema8,
-  async execute(args, ctx) {
-    const maxResults = Math.min(args.maxResults ?? DEFAULT_MAX_RESULTS, MAX_RESULTS_LIMIT);
-    const url = `${SEARCH_URL}${encodeURIComponent(args.query)}`;
-    const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS2);
-    const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
-    let res;
-    try {
-      res = await fetch(url, {
-        signal,
-        redirect: "follow",
-        headers: { "user-agent": USER_AGENT, accept: "text/html" }
-      });
-    } catch (err) {
-      if (ctx.abortSignal?.aborted) {
-        return { content: "ERROR: request aborted", isError: true };
-      }
-      const name = err instanceof Error ? err.name : "";
-      if (timeoutSignal.aborted || name === "TimeoutError") {
-        return { content: `ERROR: search timed out after ${TIMEOUT_MS2 / 1e3}s`, isError: true };
-      }
-      const message = err instanceof Error ? err.message : String(err);
-      return { content: `ERROR: search request failed: ${message}`, isError: true };
-    }
-    if (!res.ok) {
-      await res.body?.cancel().catch(() => {
-      });
-      return {
-        content: `ERROR: HTTP ${res.status} ${res.statusText} from DuckDuckGo`,
-        isError: true
-      };
-    }
-    let html;
-    try {
-      html = await res.text();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { content: `ERROR: failed to read search response: ${message}`, isError: true };
-    }
-    const results = parseResults(html).slice(0, maxResults);
-    if (results.length === 0) {
-      return {
-        content: `ERROR: no results found for "${args.query}" (the response may have been blocked or the page layout changed)`,
-        isError: true
-      };
-    }
-    const lines = results.map(
-      (r, i) => `${i + 1}. ${r.title}
-   ${r.url}${r.snippet ? `
-   ${r.snippet}` : ""}`
+  return {
+    sessions: metas.length,
+    sessionsWithUsage,
+    requests,
+    promptTokens: grand.promptTokens,
+    completionTokens: grand.completionTokens,
+    totalTokens: grand.totalTokens,
+    days: [...days.entries()].map(([date, bucket]) => ({ date, ...bucket })).sort((a, b) => a.date.localeCompare(b.date)),
+    legacy: hasLegacy ? legacy : null,
+    models: [...models.values()].sort((a, b) => b.totalTokens - a.totalTokens)
+  };
+}
+async function collectUsageStats() {
+  return aggregateUsage(await SessionStore.list());
+}
+function fmt(n) {
+  return n.toLocaleString("en-US");
+}
+var BAR_WIDTH = 30;
+function formatUsageDashboard(stats, models, options = {}) {
+  if (stats.sessions === 0) return "No sessions found.";
+  const lines = [
+    "Token usage across all sessions",
+    "",
+    `Total: ${stats.sessions} sessions (${stats.sessionsWithUsage} with usage) \xB7 ${fmt(stats.requests)} requests \xB7 ${fmt(stats.promptTokens)} prompt + ${fmt(stats.completionTokens)} completion = ${fmt(stats.totalTokens)} tokens`
+  ];
+  if (stats.sessionsWithUsage === 0) {
+    lines.push("", "No token usage recorded yet.");
+    return lines.join("\n");
+  }
+  const maxDays = options.maxDays ?? USAGE_MAX_DAYS;
+  const recent = stats.days.slice(-maxDays);
+  if (recent.length > 0) {
+    lines.push("");
+    lines.push(
+      stats.days.length > maxDays ? `By day (last ${maxDays} of ${stats.days.length} days with usage):` : "By day:"
     );
-    return { content: lines.join("\n") };
-  }
-};
-
-// src/tools/registry.ts
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  constructor() {
-    for (const tool of [
-      readFileTool,
-      writeFileTool,
-      editFileTool,
-      globTool,
-      grepTool,
-      bashTool,
-      webFetchTool,
-      webSearchTool,
-      taskListTool,
-      taskOutputTool,
-      taskKillTool,
-      ...createTodoTools()
-    ]) {
-      this.register(tool);
+    const maxTotal = Math.max(...recent.map((day) => day.totalTokens));
+    for (const day of recent) {
+      const barLen = maxTotal > 0 ? Math.max(1, Math.round(day.totalTokens / maxTotal * BAR_WIDTH)) : 0;
+      lines.push(`${day.date}  ${fmt(day.totalTokens).padStart(12)}  ${"\u2588".repeat(barLen)}`);
     }
   }
-  register(tool) {
-    this.tools.set(tool.name, tool);
-  }
-  get(name) {
-    return this.tools.get(name);
-  }
-  list() {
-    return [...this.tools.values()];
-  }
-  names() {
-    return [...this.tools.keys()];
+  if (stats.legacy) {
+    lines.push(
+      `Earlier usage without per-day records: ${fmt(stats.legacy.totalTokens)} tokens (${fmt(stats.legacy.promptTokens)} prompt + ${fmt(stats.legacy.completionTokens)} completion)`
+    );
   }
-};
-
-// src/tools/index.ts
-function createDefaultRegistry() {
-  const registry = new ToolRegistry();
-  for (const tool of createTodoTools()) {
-    registry.register(tool);
+  lines.push("", "By model:");
+  const configured = new Map(models.map((m) => [m.name, m]));
+  const rows = stats.models.map((entry) => {
+    const cfg = configured.get(entry.model);
+    const cost = cfg?.promptPrice !== void 0 && cfg.completionPrice !== void 0 ? (entry.promptTokens * cfg.promptPrice + entry.completionTokens * cfg.completionPrice) / 1e6 : null;
+    return { entry, cost };
+  });
+  const header = ["model", "requests", "prompt", "completion", "total", "cost"];
+  const cells = rows.map(({ entry, cost }) => [
+    entry.model,
+    fmt(entry.requests),
+    fmt(entry.promptTokens),
+    fmt(entry.completionTokens),
+    fmt(entry.totalTokens),
+    cost === null ? "\u2014" : `$${formatDollars(cost)}`
+  ]);
+  const widths = header.map(
+    (h, i) => Math.max(h.length, ...cells.map((row) => row[i]?.length ?? 0))
+  );
+  const renderRow = (row) => row.map((cell, i) => i === 0 ? cell.padEnd(widths[0] ?? 0) : cell.padStart(widths[i] ?? 0)).join("  ");
+  lines.push(renderRow(header));
+  for (const row of cells) lines.push(renderRow(row));
+  const pricedCosts = rows.filter((row) => row.cost !== null).map((row) => row.cost);
+  const unpriced = rows.filter((row) => row.cost === null).map((row) => row.entry.model);
+  if (pricedCosts.length > 0) {
+    const total = pricedCosts.reduce((sum, cost) => sum + cost, 0);
+    const note = unpriced.length > 0 ? ` (excludes ${unpriced.join(", ")} \u2014 no price configured)` : "";
+    lines.push("", `Estimated cost: $${formatDollars(total)}${note}`);
+  } else {
+    lines.push("", "Estimated cost: unknown (no per-model pricing configured)");
   }
-  return registry;
+  return lines.join("\n");
 }
 
 // src/version.ts
-import fs3 from "fs";
-import path15 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { fileURLToPath } from "url";
 function readPackageVersion() {
   try {
-    const pkgPath = path15.join(path15.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    const pkg = JSON.parse(fs3.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;
@@ -2205,9 +990,141 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 
+// src/cli/budget.ts
+var BUDGET_WARN_RATIO = 0.8;
+function budgetState(costUsd, budgetUsd) {
+  if (budgetUsd === void 0 || costUsd === null) return "ok";
+  if (costUsd >= budgetUsd) return "exceeded";
+  if (costUsd >= budgetUsd * BUDGET_WARN_RATIO) return "warn";
+  return "ok";
+}
+
+// src/cli/clipboard.ts
+import { execFile } from "child_process";
+import { randomUUID } from "crypto";
+import { readFile as readFile2, unlink } from "fs/promises";
+import os from "os";
+import path8 from "path";
+import { promisify } from "util";
+var CLIPBOARD_TIMEOUT_MS = 5e3;
+var MAX_CLIPBOARD_IMAGE_BYTES = 10 * 1024 * 1024;
+var execFileAsync = promisify(execFile);
+function windowsClipboardImageScript(tempFile) {
+  const escaped = tempFile.replace(/'/g, "''");
+  return [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "$img = [Windows.Forms.Clipboard]::GetImage()",
+    "if ($null -ne $img) {",
+    `  $img.Save('${escaped}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    "  $img.Dispose()",
+    "}"
+  ].join("; ");
+}
+function macOsClipboardImageLines(tempFile) {
+  const posix = tempFile.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return [
+    "set pngData to the clipboard as \xABclass PNGf\xBB",
+    `set theFile to open for access (POSIX file "${posix}") with write permission`,
+    "write pngData to theFile",
+    "close access theFile"
+  ];
+}
+function clipboardImagePlan(platform, tempFile, hasPngpaste) {
+  if (platform === "win32") {
+    return {
+      kind: "temp-file",
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-STA",
+        "-Command",
+        windowsClipboardImageScript(tempFile)
+      ]
+    };
+  }
+  if (platform === "darwin") {
+    if (hasPngpaste) {
+      return { kind: "temp-file", command: "pngpaste", args: [tempFile] };
+    }
+    return {
+      kind: "temp-file",
+      command: "osascript",
+      args: macOsClipboardImageLines(tempFile).flatMap((line) => ["-e", line])
+    };
+  }
+  if (platform === "linux") {
+    return {
+      kind: "stdout",
+      command: "xclip",
+      args: ["-selection", "clipboard", "-t", "image/png", "-o"]
+    };
+  }
+  return null;
+}
+function clipboardCopyCommand(platform) {
+  if (platform === "win32") return { command: "clip.exe", args: [] };
+  if (platform === "darwin") return { command: "pbcopy", args: [] };
+  if (platform === "linux") return { command: "xclip", args: ["-selection", "clipboard"] };
+  return null;
+}
+async function commandExists(command) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  try {
+    await execFileAsync(checker, [command], { timeout: CLIPBOARD_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readClipboardImage() {
+  const tempFile = path8.join(os.tmpdir(), `star-clipboard-${randomUUID()}.png`);
+  const hasPngpaste = process.platform === "darwin" ? await commandExists("pngpaste") : false;
+  const plan = clipboardImagePlan(process.platform, tempFile, hasPngpaste);
+  if (!plan) return null;
+  try {
+    if (plan.kind === "stdout") {
+      const { stdout } = await execFileAsync(plan.command, plan.args, {
+        timeout: CLIPBOARD_TIMEOUT_MS,
+        maxBuffer: MAX_CLIPBOARD_IMAGE_BYTES,
+        encoding: "buffer"
+      });
+      const buf2 = stdout;
+      if (buf2.length === 0) return null;
+      return { path: "clipboard.png", mimeType: "image/png", data: buf2.toString("base64") };
+    }
+    await execFileAsync(plan.command, plan.args, { timeout: CLIPBOARD_TIMEOUT_MS });
+    const buf = await readFile2(tempFile).catch(() => null);
+    if (!buf || buf.length === 0) return null;
+    return { path: "clipboard.png", mimeType: "image/png", data: buf.toString("base64") };
+  } catch {
+    return null;
+  } finally {
+    if (plan.kind === "temp-file") {
+      await unlink(tempFile).catch(() => {
+      });
+    }
+  }
+}
+async function copyText(text) {
+  const plan = clipboardCopyCommand(process.platform);
+  if (!plan) return false;
+  return new Promise((resolve) => {
+    const child = execFile(
+      plan.command,
+      plan.args,
+      { timeout: CLIPBOARD_TIMEOUT_MS },
+      (error) => resolve(error === null)
+    );
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.end(text);
+  });
+}
+
 // src/cli/commands/actions.ts
-import fs4 from "fs/promises";
-import path16 from "path";
+import fs7 from "fs/promises";
+import path9 from "path";
 var MIN_COMPACT_MESSAGES = 4;
 async function compactSession(opts) {
   const { backend, sessionStore, config, model } = opts;
@@ -2268,15 +1185,15 @@ async function exportSession(opts) {
     return "Nothing to export: the session has no messages.";
   }
   const sessionId = sessionStore?.id ?? `unknown-${Date.now()}`;
-  const target = arg ? path16.resolve(cwd, arg) : path16.resolve(cwd, `star-session-${sessionId}.md`);
+  const target = arg ? path9.resolve(cwd, arg) : path9.resolve(cwd, `star-session-${sessionId}.md`);
   const existed = await fileExists(target);
-  await fs4.mkdir(path16.dirname(target), { recursive: true });
-  await fs4.writeFile(target, renderSessionMarkdown(sessionId, messages));
+  await fs7.mkdir(path9.dirname(target), { recursive: true });
+  await fs7.writeFile(target, renderSessionMarkdown(sessionId, messages));
   return existed ? `Exported ${messages.length} messages to ${target} (overwrote existing file).` : `Exported ${messages.length} messages to ${target}.`;
 }
 async function fileExists(target) {
   try {
-    await fs4.access(target);
+    await fs7.access(target);
     return true;
   } catch {
     return false;
@@ -2336,6 +1253,191 @@ function stringifyPart(value) {
   return typeof value === "string" ? value : JSON.stringify(value, null, 2);
 }
 
+// src/cli/diff-preview.ts
+import { readFile as readFile3 } from "fs/promises";
+import path10 from "path";
+var CONTEXT_LINES = 2;
+var MAX_HUNK_LINES = 15;
+var MAX_TOTAL_LINES = 12;
+var NEW_FILE_PREVIEW_LINES = 10;
+var MAX_DP_CELLS = 25e4;
+function diffOps(oldText, newText) {
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start += 1;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA -= 1;
+    endB -= 1;
+  }
+  const prefix = a.slice(0, start).map((text) => ({ kind: "context", text }));
+  const suffix = a.slice(endA).map((text) => ({ kind: "context", text }));
+  const midA = a.slice(start, endA);
+  const midB = b.slice(start, endB);
+  const prefixLen = prefix.length;
+  const ops = [...prefix];
+  if (midA.length * midB.length > MAX_DP_CELLS) {
+    for (const text of midA) ops.push({ kind: "del", text });
+    for (const text of midB) ops.push({ kind: "add", text });
+  } else if (midA.length > 0 || midB.length > 0) {
+    const rows = midA.length + 1;
+    const cols = midB.length + 1;
+    const dp = new Uint32Array(rows * cols);
+    const cell = (r, c) => dp[r * cols + c] ?? 0;
+    for (let i2 = 1; i2 < rows; i2++) {
+      for (let j2 = 1; j2 < cols; j2++) {
+        dp[i2 * cols + j2] = midA[i2 - 1] === midB[j2 - 1] ? cell(i2 - 1, j2 - 1) + 1 : Math.max(cell(i2 - 1, j2), cell(i2, j2 - 1));
+      }
+    }
+    const lineAt = (lines, index) => lines[index] ?? "";
+    const middle = [];
+    let i = midA.length;
+    let j = midB.length;
+    while (i > 0 && j > 0) {
+      if (midA[i - 1] === midB[j - 1]) {
+        middle.push({ kind: "context", text: lineAt(midA, i - 1) });
+        i -= 1;
+        j -= 1;
+      } else if (cell(i, j - 1) >= cell(i - 1, j)) {
+        middle.push({ kind: "add", text: lineAt(midB, j - 1) });
+        j -= 1;
+      } else {
+        middle.push({ kind: "del", text: lineAt(midA, i - 1) });
+        i -= 1;
+      }
+    }
+    while (i > 0) {
+      middle.push({ kind: "del", text: lineAt(midA, i - 1) });
+      i -= 1;
+    }
+    while (j > 0) {
+      middle.push({ kind: "add", text: lineAt(midB, j - 1) });
+      j -= 1;
+    }
+    middle.reverse();
+    ops.push(...middle);
+  }
+  ops.push(...suffix);
+  return ops.length === prefixLen + suffix.length ? [] : ops;
+}
+function hunkRanges(ops) {
+  const changes = [];
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    if (op && op.kind !== "context") changes.push(i);
+  }
+  const ranges = [];
+  let groupStart = 0;
+  for (let k = 1; k <= changes.length; k++) {
+    const cur = changes[k];
+    const prev = changes[k - 1];
+    const first = changes[groupStart];
+    if (prev === void 0 || first === void 0) break;
+    if (cur === void 0 || cur - prev > CONTEXT_LINES * 2 + 1) {
+      ranges.push([
+        Math.max(0, first - CONTEXT_LINES),
+        Math.min(ops.length, prev + CONTEXT_LINES + 1)
+      ]);
+      groupStart = k;
+    }
+  }
+  return ranges;
+}
+function buildDiffLines(oldText, newText) {
+  const ops = diffOps(oldText, newText);
+  if (ops.length === 0) return [];
+  const ranges = hunkRanges(ops);
+  const lines = [];
+  let omitted = 0;
+  for (const [rangeIndex, [start, end]] of ranges.entries()) {
+    if (rangeIndex > 0) lines.push({ kind: "marker", text: "\xB7\xB7\xB7" });
+    const hunk = ops.slice(start, end);
+    let shown = hunk;
+    if (hunk.length > MAX_HUNK_LINES) {
+      const headCount = Math.ceil(MAX_HUNK_LINES / 2);
+      shown = [...hunk.slice(0, headCount), ...hunk.slice(headCount - MAX_HUNK_LINES)];
+    }
+    if (hunk.length > shown.length) {
+      omitted += hunk.length - shown.length;
+    }
+    for (const op of shown) lines.push(op);
+  }
+  if (lines.length > MAX_TOTAL_LINES) {
+    omitted += lines.length - MAX_TOTAL_LINES;
+    lines.length = MAX_TOTAL_LINES;
+  }
+  if (omitted > 0) lines.push({ kind: "marker", text: `... (${omitted} more lines)` });
+  return lines;
+}
+function parseGitDiffLines(diffText) {
+  return diffText.split("\n").map((raw) => {
+    if (raw.startsWith("+") && !raw.startsWith("+++")) {
+      return { kind: "add", text: raw.slice(1) };
+    }
+    if (raw.startsWith("-") && !raw.startsWith("---")) {
+      return { kind: "del", text: raw.slice(1) };
+    }
+    if (raw.startsWith("@@") || raw.startsWith("diff ") || raw.startsWith("index ") || raw.startsWith("#") || raw.startsWith("+++") || raw.startsWith("---")) {
+      return { kind: "marker", text: raw };
+    }
+    return { kind: "context", text: raw.startsWith(" ") ? raw.slice(1) : raw };
+  });
+}
+function getStringArg(args, key) {
+  if (typeof args === "object" && args !== null) {
+    const value = args[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function applyEdit(content, oldString, newString, replaceAll) {
+  let count = 0;
+  let idx = content.indexOf(oldString);
+  while (idx !== -1) {
+    count += 1;
+    idx = content.indexOf(oldString, idx + oldString.length);
+  }
+  if (count === 0) return null;
+  if (count > 1 && !replaceAll) return null;
+  return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+}
+function newFilePreview(content, label) {
+  const all = content.split("\n");
+  const shown = all.slice(0, NEW_FILE_PREVIEW_LINES);
+  const lines = shown.map((text) => ({ kind: "add", text }));
+  if (all.length > shown.length) {
+    lines.push({ kind: "marker", text: `... (${all.length - shown.length} more lines)` });
+  }
+  return { type: "new-file", label, lines };
+}
+async function generateDiffPreview(toolName, args, cwd) {
+  if (toolName !== "edit_file" && toolName !== "write_file") return null;
+  const filePath = getStringArg(args, "path");
+  if (filePath === void 0) return null;
+  const absolute = path10.resolve(cwd, filePath);
+  let existing;
+  try {
+    existing = await readFile3(absolute, "utf8");
+  } catch {
+    existing = null;
+  }
+  if (toolName === "edit_file") {
+    const oldString = getStringArg(args, "old_string");
+    const newString = getStringArg(args, "new_string");
+    if (existing === null || oldString === void 0 || newString === void 0) return null;
+    const replaceAll = typeof args === "object" && args !== null && args.replace_all === true;
+    const updated = applyEdit(existing, oldString, newString, replaceAll);
+    if (updated === null) return null;
+    return { type: "diff", label: filePath, lines: buildDiffLines(existing, updated) };
+  }
+  const content = getStringArg(args, "content");
+  if (content === void 0) return null;
+  if (existing === null) return newFilePreview(content, filePath);
+  return { type: "diff", label: filePath, lines: buildDiffLines(existing, content) };
+}
+
 // src/cli/commands/builtin.ts
 function registerBuiltinCommands(registry) {
   registry.register({
@@ -2359,6 +1461,37 @@ ${lines.join("\n")}`);
       ctx.clearMessages();
     }
   });
+  registry.register({
+    name: "new",
+    description: "Start a new session with a clean context",
+    usage: "/new",
+    async run(_args, ctx) {
+      if (!ctx.newSession) {
+        ctx.addSystemMessage("/new: this context cannot start a new session.");
+        return;
+      }
+      ctx.addSystemMessage(await ctx.newSession());
+    }
+  });
+  registry.register({
+    name: "clear-sessions",
+    description: "Delete stored sessions: this directory by default, every session with --all (the current session is kept)",
+    usage: "/clear-sessions [--all]",
+    async run(args, ctx) {
+      const arg = args.trim();
+      if (arg !== "" && arg !== "--all") {
+        ctx.addSystemMessage(
+          `/clear-sessions: unknown argument "${arg}". Usage: /clear-sessions [--all]`
+        );
+        return;
+      }
+      if (!ctx.clearSessions) {
+        ctx.addSystemMessage("/clear-sessions: this context cannot delete sessions.");
+        return;
+      }
+      ctx.addSystemMessage(await ctx.clearSessions(arg === "--all"));
+    }
+  });
   registry.register({
     name: "exit",
     description: "Exit the application",
@@ -2390,12 +1523,15 @@ ${lines.join("\n")}`);
   registry.register({
     name: "resume",
     description: "List sessions or resume a session by id",
-    usage: "/resume [sessionId]",
+    usage: "/resume [sessionId | --all]",
     async run(args, ctx) {
-      if (!args) {
+      const arg = args.trim();
+      if (arg === "--all") {
+        ctx.addSystemMessage(await ctx.listSessions(true));
+      } else if (!arg) {
         ctx.addSystemMessage(await ctx.listSessions());
       } else {
-        ctx.addSystemMessage(await ctx.resumeSession(args));
+        ctx.addSystemMessage(await ctx.resumeSession(arg));
       }
     }
   });
@@ -2423,6 +1559,14 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage(ctx.showUsage());
     }
   });
+  registry.register({
+    name: "usage",
+    description: "Show token usage aggregated across all sessions",
+    usage: "/usage",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.showGlobalUsage());
+    }
+  });
   registry.register({
     name: "config",
     description: "Show the current configuration",
@@ -2471,6 +1615,14 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage(await ctx.undo());
     }
   });
+  registry.register({
+    name: "rewind",
+    description: "List file-change checkpoints, or rewind to just before one: restore files and retract the conversation",
+    usage: "/rewind [n]",
+    async run(args, ctx) {
+      ctx.addSystemMessage(await ctx.rewind(args.trim()));
+    }
+  });
   registry.register({
     name: "init",
     description: "Generate an AGENTS.md for the current project",
@@ -2487,11 +1639,114 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage(await ctx.runDoctor());
     }
   });
+  registry.register({
+    name: "skills",
+    description: "List available skills (project scope overrides user scope)",
+    usage: "/skills",
+    run(_args, ctx) {
+      const skills = discoverSkills(ctx.cwd ?? process.cwd());
+      if (skills.length === 0) {
+        ctx.addSystemMessage(
+          "No skills found. Add a SKILL.md under .star/skills/<name>/ (project) or ~/.star-cli/skills/<name>/ (user)."
+        );
+        return;
+      }
+      const lines = skills.map((s) => `${s.name} [${s.scope}] \u2014 ${s.description}`);
+      ctx.addSystemMessage(`Available skills:
+${lines.join("\n")}`);
+    }
+  });
+  registry.register({
+    name: "commit",
+    description: "Analyze uncommitted changes and create a git commit (Conventional Commits)",
+    usage: "/commit [instructions]",
+    async run(args, ctx) {
+      const cwd = ctx.cwd ?? process.cwd();
+      if (!isGitRepo(cwd)) {
+        ctx.addSystemMessage("/commit: not a git repository \u2014 nothing to do.");
+        return;
+      }
+      const context = collectCommitContext(cwd);
+      if (!context) {
+        ctx.addSystemMessage("/commit: working tree clean \u2014 nothing to commit.");
+        return;
+      }
+      const prompt = buildCommitPrompt(context, args);
+      if (ctx.submitPrompt) {
+        return ctx.submitPrompt(prompt);
+      }
+      ctx.addSystemMessage("/commit: this context cannot submit prompts to the model.");
+    }
+  });
+  registry.register({
+    name: "copy",
+    description: "Copy the last assistant reply to the clipboard (`all` for the whole conversation)",
+    usage: "/copy [all]",
+    async run(args, ctx) {
+      const arg = args.trim();
+      if (arg !== "" && arg !== "all") {
+        ctx.addSystemMessage(`/copy: unknown argument "${arg}". Usage: /copy [all]`);
+        return;
+      }
+      if (!ctx.conversationText || !ctx.copyToClipboard) {
+        ctx.addSystemMessage("/copy: this context cannot access the clipboard.");
+        return;
+      }
+      const scope = arg === "all" ? "all" : "last";
+      const text = ctx.conversationText(scope);
+      if (!text) {
+        ctx.addSystemMessage(
+          scope === "all" ? "Nothing to copy yet." : "No assistant reply yet \u2014 nothing to copy."
+        );
+        return;
+      }
+      const ok = await ctx.copyToClipboard(text);
+      ctx.addSystemMessage(
+        ok ? `Copied ${text.length} chars to clipboard.` : "Copy failed \u2014 no clipboard command available on this platform."
+      );
+    }
+  });
+  registry.register({
+    name: "diff",
+    description: "Show uncommitted changes (git status + colored diff)",
+    usage: "/diff",
+    run(_args, ctx) {
+      const cwd = ctx.cwd ?? process.cwd();
+      if (!isGitRepo(cwd)) {
+        ctx.addSystemMessage("/diff: not a git repository \u2014 nothing to show.");
+        return;
+      }
+      const result = collectWorkingDiff(cwd);
+      if (!result || result.status === "") {
+        ctx.addSystemMessage("Working tree clean \u2014 no uncommitted changes.");
+        return;
+      }
+      const header = `git status --short:
+${result.status}`;
+      if (result.diff === "") {
+        ctx.addSystemMessage(
+          `${header}
+
+Only untracked files \u2014 no tracked modifications to diff.`
+        );
+        return;
+      }
+      const note = result.truncated ? `diff truncated at ${WORKING_DIFF_MAX_LINES} lines` : void 0;
+      if (ctx.showDiff) {
+        ctx.showDiff(header, parseGitDiffLines(result.diff), note);
+        return;
+      }
+      ctx.addSystemMessage(`${header}
+
+${result.diff}${note ? `
+... (${note})` : ""}`);
+    }
+  });
 }
 
 // src/cli/commands/custom.ts
 import { readFileSync, readdirSync } from "fs";
-import path17 from "path";
+import path11 from "path";
 var NAME_PATTERN = /^[a-z0-9-]+$/;
 var DESCRIPTION_PATTERN = /^<!--\s*description:\s*(.+?)\s*-->\s*$/;
 var DEFAULT_DESCRIPTION = "Custom prompt command";
@@ -2526,14 +1781,14 @@ function scanDir(dir, into) {
     if (!entry.endsWith(".md")) continue;
     const name = entry.slice(0, -".md".length);
     if (!NAME_PATTERN.test(name)) continue;
-    const parsed = parseCommandFile(path17.join(dir, entry), name);
+    const parsed = parseCommandFile(path11.join(dir, entry), name);
     if (parsed) into.set(name, parsed);
   }
 }
 function loadCustomCommands(cwd, home = starHome()) {
   const byName = /* @__PURE__ */ new Map();
-  scanDir(path17.join(home, "commands"), byName);
-  scanDir(path17.join(cwd, ".star", "commands"), byName);
+  scanDir(path11.join(home, "commands"), byName);
+  scanDir(path11.join(cwd, ".star", "commands"), byName);
   return [...byName.values()];
 }
 function registerCustomCommands(registry, cwd, home) {
@@ -2558,8 +1813,8 @@ function registerCustomCommands(registry, cwd, home) {
 }
 
 // src/cli/commands/doctor.ts
-import fs5 from "fs/promises";
-import path18 from "path";
+import fs8 from "fs/promises";
+import path12 from "path";
 var MIN_NODE_MAJOR = 20;
 var REGISTRY_URL = "https://registry.npmjs.org/";
 var REGISTRY_TIMEOUT_MS = 5e3;
@@ -2573,7 +1828,7 @@ function nodeMajor(version) {
 }
 async function pathExists(target) {
   try {
-    await fs5.access(target);
+    await fs8.access(target);
     return true;
   } catch {
     return false;
@@ -2611,7 +1866,7 @@ async function runDoctor(opts) {
       detail: `${spec.label} (${spec.shell})`
     });
   }
-  const configPath = path18.join(home, "config.toml");
+  const configPath = path12.join(home, "config.toml");
   const configExists = await pathExists(configPath);
   checks.push({
     name: "STAR_HOME / config",
@@ -2648,14 +1903,14 @@ async function runDoctor(opts) {
       });
     }
   }
-  const sessions = path18.join(home, "sessions");
+  const sessions = path12.join(home, "sessions");
   let writable = false;
   let writeError = "";
   try {
-    await fs5.mkdir(sessions, { recursive: true });
-    const probe = path18.join(sessions, `.doctor-probe-${process.pid}`);
-    await fs5.writeFile(probe, "ok");
-    await fs5.unlink(probe);
+    await fs8.mkdir(sessions, { recursive: true });
+    const probe = path12.join(sessions, `.doctor-probe-${process.pid}`);
+    await fs8.writeFile(probe, "ok");
+    await fs8.unlink(probe);
     writable = true;
   } catch (error) {
     writeError = error instanceof Error ? error.message : String(error);
@@ -2690,15 +1945,15 @@ function formatDoctorReport(report) {
 }
 
 // src/cli/commands/init-project.ts
-import fs6 from "fs/promises";
-import path19 from "path";
-import { generateText as generateText2 } from "ai";
+import fs9 from "fs/promises";
+import path13 from "path";
+import { generateText } from "ai";
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", "coverage"]);
 var MAX_ENTRIES = 20;
 var README_HEAD_LINES = 5;
 async function fileExists2(target) {
   try {
-    await fs6.access(target);
+    await fs9.access(target);
     return true;
   } catch {
     return false;
@@ -2706,7 +1961,7 @@ async function fileExists2(target) {
 }
 async function readPackageJson(cwd) {
   try {
-    const raw = await fs6.readFile(path19.join(cwd, "package.json"), "utf8");
+    const raw = await fs9.readFile(path13.join(cwd, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return null;
     return parsed;
@@ -2723,10 +1978,10 @@ function stringRecord(value) {
   return out;
 }
 async function detectPackageManager(cwd) {
-  if (await fileExists2(path19.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path19.join(cwd, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path19.join(cwd, "package-lock.json"))) return "npm";
-  if (await fileExists2(path19.join(cwd, "bun.lockb"))) return "bun";
+  if (await fileExists2(path13.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path13.join(cwd, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path13.join(cwd, "package-lock.json"))) return "npm";
+  if (await fileExists2(path13.join(cwd, "bun.lockb"))) return "bun";
   return null;
 }
 function inferCommands(pm, scripts) {
@@ -2741,7 +1996,7 @@ function inferCommands(pm, scripts) {
 }
 async function listEntries(cwd) {
   try {
-    const dirents = await fs6.readdir(cwd, { withFileTypes: true });
+    const dirents = await fs9.readdir(cwd, { withFileTypes: true });
     const entries = [];
     for (const dirent of dirents) {
       if (dirent.isDirectory()) {
@@ -2760,7 +2015,7 @@ async function listEntries(cwd) {
 async function readReadmeHead(cwd) {
   for (const name of ["README.md", "readme.md", "README"]) {
     try {
-      const raw = await fs6.readFile(path19.join(cwd, name), "utf8");
+      const raw = await fs9.readFile(path13.join(cwd, name), "utf8");
       return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, README_HEAD_LINES);
     } catch {
     }
@@ -2773,14 +2028,14 @@ async function scanProject(cwd) {
   const scripts = stringRecord(pkg?.scripts);
   return {
     name: typeof pkg?.name === "string" ? pkg.name : null,
-    dirName: path19.basename(cwd),
+    dirName: path13.basename(cwd),
     packageManager,
     scripts,
     dependencies: Object.keys(stringRecord(pkg?.dependencies)),
     devDependencies: Object.keys(stringRecord(pkg?.devDependencies)),
     commands: inferCommands(packageManager, scripts),
-    hasTsconfig: await fileExists2(path19.join(cwd, "tsconfig.json")),
-    isGitRepo: await fileExists2(path19.join(cwd, ".git")),
+    hasTsconfig: await fileExists2(path13.join(cwd, "tsconfig.json")),
+    isGitRepo: await fileExists2(path13.join(cwd, ".git")),
     readmeHead: await readReadmeHead(cwd),
     entries: await listEntries(cwd)
   };
@@ -2833,7 +2088,7 @@ var INIT_SYSTEM_PROMPT = [
   "Output only the Markdown, no preamble, no code fences."
 ].join("\n");
 async function polishWithModel(facts, model) {
-  const { text } = await generateText2({
+  const { text } = await generateText({
     model,
     system: INIT_SYSTEM_PROMPT,
     prompt: `Project facts:
@@ -2847,7 +2102,7 @@ Write the AGENTS.md.`
 }
 async function initProject(opts) {
   const { cwd, args, model } = opts;
-  const target = path19.join(cwd, "AGENTS.md");
+  const target = path13.join(cwd, "AGENTS.md");
   const force = args.split(/\s+/).includes("force");
   if (!force && await fileExists2(target)) {
     return {
@@ -2881,7 +2136,7 @@ async function initProject(opts) {
     content = renderAgentsMd(facts);
     note = " No model available; used the template \u2014 review and refine manually.";
   }
-  await fs6.writeFile(target, content);
+  await fs9.writeFile(target, content);
   const lines = content.split("\n").length;
   const how = usedLlm ? "generated with model refinement" : "generated from template";
   return {
@@ -2922,6 +2177,44 @@ function parseSlashCommand(input) {
   };
 }
 
+// src/cli/commands/rewind.ts
+import path14 from "path";
+function planRewind(snapshots, id) {
+  const target = snapshots.find((snapshot) => snapshot.id === id);
+  if (!target) return null;
+  const affected = snapshots.filter((snapshot) => snapshot.id >= id);
+  let messageIndex = null;
+  for (const snapshot of affected) {
+    if (snapshot.messageIndex >= 0) {
+      messageIndex = messageIndex === null ? snapshot.messageIndex : Math.min(messageIndex, snapshot.messageIndex);
+    }
+  }
+  return { target, affected, messageIndex };
+}
+function displayPath(filePath, cwd) {
+  const relative = path14.relative(cwd, filePath);
+  return relative !== "" && !relative.startsWith("..") ? relative : filePath;
+}
+function formatTime(timestamp) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const date = new Date(timestamp);
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function formatCheckpointList(snapshots, cwd) {
+  if (snapshots.length === 0) {
+    return "No checkpoints yet \u2014 checkpoints are recorded on every successful write_file/edit_file.";
+  }
+  const lines = snapshots.map((snapshot) => {
+    const label = snapshot.existed ? snapshot.toolName : `${snapshot.toolName} (new file)`;
+    return `#${snapshot.id}  ${formatTime(snapshot.timestamp)}  ${label}  ${displayPath(snapshot.path, cwd)}`;
+  });
+  return [
+    `Checkpoints (${snapshots.length}):`,
+    ...lines,
+    "Use /rewind <n> to restore files and conversation to just before checkpoint n."
+  ].join("\n");
+}
+
 // src/cli/components/ExitPlanPrompt.tsx
 import { Box, Text, useInput } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -2940,7 +2233,7 @@ function ExitPlanPrompt({ onDecision }) {
 
 // src/cli/components/InputBox.tsx
 import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
-import { useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 // src/cli/commands/suggest.ts
 var MAX_SUGGESTIONS = 5;
@@ -2951,36 +2244,116 @@ function filterCommands(input, commands) {
   return commands.filter((cmd) => cmd.name.toLowerCase().startsWith(prefix)).sort((a, b) => a.name.localeCompare(b.name)).slice(0, MAX_SUGGESTIONS);
 }
 
+// src/cli/path-suggest.ts
+import { readdir } from "fs/promises";
+import path15 from "path";
+var MAX_SCAN_ENTRIES = 2e3;
+function extractAtToken(value, cursor) {
+  const before = value.slice(0, cursor);
+  const match = /(?:^|\s)@(\S*)$/.exec(before);
+  if (!match) return null;
+  const token = match[1] ?? "";
+  return { token, start: cursor - token.length - 1, end: cursor };
+}
+async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSuggestions = MAX_SUGGESTIONS) {
+  const normalized = token.replace(/\\/g, "/");
+  const slash = normalized.lastIndexOf("/");
+  const dirPart = slash >= 0 ? normalized.slice(0, slash + 1) : "";
+  const basePrefix = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+  if (dirPart.split("/").some((segment) => SKIP_DIRS.has(segment))) return [];
+  const dirAbs = path15.resolve(cwd, dirPart === "" ? "." : dirPart);
+  const entries = await readdir(dirAbs, { withFileTypes: true }).catch(() => null);
+  if (!entries) return [];
+  const lower = basePrefix.toLowerCase();
+  const matches = [];
+  let scanned = 0;
+  for (const entry of entries) {
+    if (scanned >= maxScanEntries) break;
+    scanned += 1;
+    const isDir = entry.isDirectory();
+    if (!isDir && !entry.isFile()) continue;
+    if (isDir && SKIP_DIRS.has(entry.name)) continue;
+    if (entry.name.startsWith(".") && !basePrefix.startsWith(".")) continue;
+    if (!entry.name.toLowerCase().startsWith(lower)) continue;
+    matches.push({ path: `${dirPart}${entry.name}${isDir ? "/" : ""}`, isDir });
+  }
+  matches.sort((a, b) => a.path.localeCompare(b.path));
+  return matches.slice(0, maxSuggestions);
+}
+
 // src/cli/components/InputBox.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function InputBox({
   isStreaming,
   disabled,
   commands,
+  cwd,
+  refill,
   onSubmit,
   onInterrupt,
-  onExit
+  onExit,
+  onPasteImage
 }) {
   const [value, setValue] = useState("");
   const [cursor, setCursor] = useState(0);
   const [history, setHistory] = useState([]);
   const [highlight, setHighlight] = useState(0);
   const [suggestionsDismissed, setSuggestionsDismissed] = useState(false);
+  const [pathSuggestions, setPathSuggestions] = useState([]);
   const historyIndexRef = useRef(null);
   const draftRef = useRef("");
+  const refillSeqRef = useRef(0);
   const edit = (next, nextCursor) => {
     setValue(next);
     setCursor(Math.max(0, Math.min(nextCursor, next.length)));
     setHighlight(0);
     setSuggestionsDismissed(false);
   };
-  const suggestions = isStreaming || disabled || suggestionsDismissed || !commands ? [] : filterCommands(value, commands);
-  const activeIndex = suggestions.length === 0 ? 0 : Math.min(highlight, suggestions.length - 1);
+  useEffect(() => {
+    if (refill && refill.seq !== refillSeqRef.current) {
+      refillSeqRef.current = refill.seq;
+      edit(refill.text, refill.text.length);
+    }
+  });
+  const suggestionsEnabled = !isStreaming && !disabled && !suggestionsDismissed;
+  const suggestions = suggestionsEnabled && commands ? filterCommands(value, commands) : [];
+  useEffect(() => {
+    if (!suggestionsEnabled || !cwd) {
+      setPathSuggestions([]);
+      return;
+    }
+    const token = extractAtToken(value, cursor);
+    if (!token) {
+      setPathSuggestions([]);
+      return;
+    }
+    let cancelled = false;
+    void suggestPaths(token.token, cwd).then((result) => {
+      if (!cancelled) setPathSuggestions(result);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [value, cursor, cwd, suggestionsEnabled]);
+  const showPathSuggestions = suggestions.length === 0 && pathSuggestions.length > 0;
+  const suggestionCount = suggestions.length > 0 ? suggestions.length : pathSuggestions.length;
+  const activeIndex = suggestionCount === 0 ? 0 : Math.min(highlight, suggestionCount - 1);
   const completeHighlighted = () => {
-    const cmd = suggestions[activeIndex];
-    if (!cmd) return;
-    const text = `/${cmd.name} `;
-    edit(text, text.length);
+    if (suggestions.length > 0) {
+      const cmd = suggestions[activeIndex];
+      if (!cmd) return;
+      const text = `/${cmd.name} `;
+      edit(text, text.length);
+      return;
+    }
+    const sugg = pathSuggestions[activeIndex];
+    const token = extractAtToken(value, cursor);
+    if (!sugg || !token) return;
+    const replacement = `@${sugg.path}${sugg.isDir ? "" : " "}`;
+    edit(
+      value.slice(0, token.start) + replacement + value.slice(token.end),
+      token.start + replacement.length
+    );
   };
   useInput2((input, key) => {
     if (key.ctrl && input === "c") {
@@ -2996,9 +2369,13 @@ function InputBox({
       onExit();
       return;
     }
-    if (isStreaming || disabled) return;
+    if ((key.meta || key.ctrl) && input === "v") {
+      onPasteImage?.();
+      return;
+    }
+    if (disabled) return;
     if (key.escape) {
-      if (suggestions.length > 0) setSuggestionsDismissed(true);
+      if (!isStreaming && suggestionCount > 0) setSuggestionsDismissed(true);
       return;
     }
     if (key.return) {
@@ -3014,13 +2391,13 @@ function InputBox({
     }
     if (key.tab) {
       if (key.shift) return;
-      if (suggestions.length > 0) {
+      if (suggestionCount > 0) {
         completeHighlighted();
         return;
       }
     } else if (key.upArrow) {
-      if (suggestions.length > 0) {
-        setHighlight((prev) => (prev - 1 + suggestions.length) % suggestions.length);
+      if (suggestionCount > 0) {
+        setHighlight((prev) => (prev - 1 + suggestionCount) % suggestionCount);
         return;
       }
       if (history.length === 0) return;
@@ -3034,8 +2411,8 @@ function InputBox({
       edit(entry, entry.length);
       return;
     } else if (key.downArrow) {
-      if (suggestions.length > 0) {
-        setHighlight((prev) => (prev + 1) % suggestions.length);
+      if (suggestionCount > 0) {
+        setHighlight((prev) => (prev + 1) % suggestionCount);
         return;
       }
       if (historyIndexRef.current === null) return;
@@ -3052,7 +2429,7 @@ function InputBox({
       setCursor((prev) => Math.max(0, prev - 1));
       return;
     } else if (key.rightArrow) {
-      if (suggestions.length > 0 && cursor === value.length) {
+      if (suggestionCount > 0 && cursor === value.length) {
         completeHighlighted();
       } else {
         setCursor((prev) => Math.min(value.length, prev + 1));
@@ -3106,14 +2483,47 @@ function InputBox({
         /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: `/${cmd.name}` }),
         /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: ` - ${cmd.description}` })
       ] }, cmd.name)
+    ) }),
+    showPathSuggestions && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: pathSuggestions.map(
+      (sugg, index) => index === activeIndex ? /* @__PURE__ */ jsx2(Text2, { bold: true, inverse: true, children: `@${sugg.path}` }, sugg.path) : /* @__PURE__ */ jsxs2(Text2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: `@${sugg.path}` }),
+        sugg.isDir && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " - directory" })
+      ] }, sugg.path)
     ) })
   ] });
 }
 
 // src/cli/components/MessageList.tsx
-import { Box as Box3, Static, Text as Text3 } from "ink";
+import { Box as Box3, Static, Text as Text4 } from "ink";
 import { memo } from "react";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+
+// src/cli/components/DiffLines.tsx
+import { Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function DiffLineView({ line }) {
+  if (line.kind === "add") return /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+    "+ ",
+    line.text
+  ] });
+  if (line.kind === "del") return /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+    "- ",
+    line.text
+  ] });
+  if (line.kind === "marker") return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: line.text });
+  return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    " ",
+    line.text
+  ] });
+}
+function DiffLines({ lines }) {
+  return /* @__PURE__ */ jsx3(Fragment, { children: lines.map((line, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: diff lines have no stable identity
+    /* @__PURE__ */ jsx3(DiffLineView, { line }, index)
+  )) });
+}
+
+// src/cli/components/MessageList.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var roleStyles = {
   user: { label: "you", color: "cyan" },
   assistant: { label: "star", color: "green" },
@@ -3121,38 +2531,24 @@ var roleStyles = {
   tool: { label: "tool", color: "magenta" }
 };
 var MessageList = memo(function MessageList2({ messages }) {
-  return /* @__PURE__ */ jsx3(Static, { items: messages, children: (message) => {
+  return /* @__PURE__ */ jsx4(Static, { items: messages, children: (message) => {
     const marginBottom = message.tight ? 0 : 1;
     if (message.role === "assistant-cont") {
-      return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginBottom, children: /* @__PURE__ */ jsx3(Text3, { color: "green", children: message.text }) }, message.id);
+      return /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", marginBottom, children: /* @__PURE__ */ jsx4(Text4, { color: "green", children: message.text }) }, message.id);
     }
     const style = roleStyles[message.role];
-    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom, children: [
-      /* @__PURE__ */ jsx3(Text3, { bold: true, color: style.color, children: style.label }),
-      /* @__PURE__ */ jsx3(Text3, { color: style.color, children: message.text }),
-      message.note && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: message.note })
+    return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginBottom, children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: style.color, children: style.label }),
+      /* @__PURE__ */ jsx4(Text4, { color: style.color, children: message.text }),
+      message.diff && /* @__PURE__ */ jsx4(DiffLines, { lines: message.diff }),
+      message.note && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: message.note })
     ] }, message.id);
   } });
 });
 
 // src/cli/components/PermissionPrompt.tsx
-import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function DiffLineView({ line }) {
-  if (line.kind === "add") return /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
-    "+ ",
-    line.text
-  ] });
-  if (line.kind === "del") return /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
-    "- ",
-    line.text
-  ] });
-  if (line.kind === "marker") return /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: line.text });
-  return /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-    " ",
-    line.text
-  ] });
-}
+import { Box as Box4, Text as Text5, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function PermissionPrompt({ request, preview, onDecision }) {
   useInput3((input) => {
     const ch = input.toLowerCase();
@@ -3160,58 +2556,96 @@ function PermissionPrompt({ request, preview, onDecision }) {
     else if (ch === "n") onDecision("no");
     else if (ch === "a") onDecision("always");
   });
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "yellow", children: [
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "yellow", children: [
       "Permission required: ",
       request.toolName,
       " (",
       request.level,
       ")"
     ] }),
-    preview ? /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+    preview ? /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
         preview.type === "new-file" ? "New file: " : "",
         preview.label
       ] }),
-      preview.lines.map((line, index) => (
-        // biome-ignore lint/suspicious/noArrayIndexKey: diff lines have no stable identity
-        /* @__PURE__ */ jsx4(DiffLineView, { line }, index)
-      ))
-    ] }) : /* @__PURE__ */ jsx4(Text4, { children: summarizeArgs(request.args) }),
-    /* @__PURE__ */ jsx4(Text4, { children: "[y] allow [n] deny [a] always (saved to config)" })
+      /* @__PURE__ */ jsx5(DiffLines, { lines: preview.lines })
+    ] }) : /* @__PURE__ */ jsx5(Text5, { children: summarizeArgs(request.args) }),
+    /* @__PURE__ */ jsx5(Text5, { children: "[y] allow [n] deny [a] always (saved to config)" })
+  ] });
+}
+
+// src/cli/components/RewindConfirmPrompt.tsx
+import { Box as Box5, Text as Text6, useInput as useInput4 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function RewindConfirmPrompt({ summary, onDecision }) {
+  useInput4((input, key) => {
+    const ch = input.toLowerCase();
+    if (ch === "y") onDecision("yes");
+    else if (ch === "n" || key.escape) onDecision("no");
+  });
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, color: "yellow", children: "Rewind checkpoints" }),
+    /* @__PURE__ */ jsx6(Text6, { children: summary }),
+    /* @__PURE__ */ jsx6(Text6, { children: "[y] rewind [n] cancel (Esc = n)" })
   ] });
 }
 
 // src/cli/components/StatusBar.tsx
-import { Box as Box5, Text as Text5 } from "ink";
+import { Box as Box6, Text as Text7, useStdout } from "ink";
 import { memo as memo2 } from "react";
-import { jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsxs as jsxs7 } from "react/jsx-runtime";
 var BG_LABEL_MAX = 40;
+var WIDE_COLUMNS = 120;
+function cwdLabel(cwd, wide) {
+  if (wide) return cwd;
+  const base = cwd.replace(/[\\/]+$/, "").split(/[\\/]/).pop();
+  return base && base.length > 0 ? base : cwd;
+}
 var StatusBar = memo2(function StatusBar2({
+  cwd,
   model,
   permissionMode,
-  tokens,
+  tokens: tokens2,
+  gitBranch,
+  contextPercent,
+  sessionCostUsd,
   backgroundTasks = []
 }) {
+  const { stdout } = useStdout();
+  const wide = (stdout?.columns ?? 80) >= WIDE_COLUMNS;
   const joined = backgroundTasks.join(", ");
   const labels = joined.length > BG_LABEL_MAX ? `${joined.slice(0, BG_LABEL_MAX)}\u2026` : joined;
-  return /* @__PURE__ */ jsxs5(Box5, { justifyContent: "space-between", children: [
-    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-      "model: ",
-      model
+  return /* @__PURE__ */ jsxs7(Box6, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      cwdLabel(cwd, wide),
+      gitBranch ? ` [${gitBranch}]` : ""
     ] }),
-    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
       "bg: ",
       backgroundTasks.length,
       " (",
       labels,
       ")"
     ] }),
-    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-      tokens,
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "model: ",
+      model
+    ] }),
+    contextPercent != null && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "ctx: ",
+      contextPercent,
+      "%"
+    ] }),
+    sessionCostUsd != null && sessionCostUsd > 0 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "$",
+      formatDollars(sessionCostUsd)
+    ] }),
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      tokens2,
       " tokens"
     ] }),
-    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
       "mode: ",
       permissionMode
     ] })
@@ -3219,247 +2653,104 @@ var StatusBar = memo2(function StatusBar2({
 });
 
 // src/cli/components/StreamingMessage.tsx
-import { Box as Box6, Text as Text6 } from "ink";
+import { Box as Box7, Text as Text8 } from "ink";
 import { memo as memo3 } from "react";
-import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
 var StreamingMessage = memo3(function StreamingMessage2({
   text,
   continuation
 }) {
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
-    !continuation && /* @__PURE__ */ jsx5(Text6, { bold: true, color: "green", children: "star" }),
-    /* @__PURE__ */ jsx5(Text6, { color: "green", children: text })
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", marginBottom: 1, children: [
+    !continuation && /* @__PURE__ */ jsx7(Text8, { bold: true, color: "green", children: "star" }),
+    /* @__PURE__ */ jsx7(Text8, { color: "green", children: text })
   ] });
 });
-
-// src/cli/components/ThinkingIndicator.tsx
-import { Box as Box7, Text as Text7 } from "ink";
-import { jsxs as jsxs7 } from "react/jsx-runtime";
-var SPINNER_FRAMES = ["-", "\\", "|", "/"];
-var REASONING_TAIL_LENGTH = 200;
-var THOUGHT_SUMMARY_LENGTH = 100;
-function truncateTail(text, max) {
-  const flat = text.replace(/\s+/g, " ").trim();
-  if (flat.length <= max) return flat;
-  return `\u2026${flat.slice(flat.length - max)}`;
-}
-function ThinkingIndicator({
-  reasoning,
-  frame = 0,
-  activity
-}) {
-  const tail = reasoning ? truncateTail(reasoning, REASONING_TAIL_LENGTH) : "";
-  const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-      spinner,
-      " ",
-      activity ?? "star is thinking\u2026"
-    ] }),
-    tail !== "" && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-      " ",
-      tail
-    ] })
-  ] });
-}
-
-// src/cli/components/ToolCallCard.tsx
-function formatToolCard(card) {
-  const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
-  if (card.result === void 0) return header;
-  const preview = previewLines(card.result, 10);
-  return `${header}
-${preview.text}${preview.truncated ? "\n... (truncated)" : ""}`;
-}
-
-// src/cli/cost.ts
-function formatDollars(cost) {
-  let s = cost.toFixed(4).replace(/0+$/, "");
-  if (s.endsWith(".")) {
-    s += "00";
-  } else if (s.split(".")[1]?.length === 1) {
-    s += "0";
-  }
-  return s;
-}
-function estimateCost(usage, modelName, model) {
-  if (model?.promptPrice === void 0 || model.completionPrice === void 0) {
-    return `Estimated cost: unknown (no price configured for ${modelName})`;
-  }
-  const cost = (usage.promptTokens * model.promptPrice + usage.completionTokens * model.completionPrice) / 1e6;
-  return `Estimated cost: $${formatDollars(cost)} (${model.name} @ $${model.promptPrice}/M prompt, $${model.completionPrice}/M completion)`;
-}
-
-// src/cli/diff-preview.ts
-import { readFile as readFile7 } from "fs/promises";
-import path20 from "path";
-var CONTEXT_LINES = 2;
-var MAX_HUNK_LINES = 15;
-var MAX_TOTAL_LINES = 12;
-var NEW_FILE_PREVIEW_LINES = 10;
-var MAX_DP_CELLS = 25e4;
-function diffOps(oldText, newText) {
-  const a = oldText.split("\n");
-  const b = newText.split("\n");
-  let start = 0;
-  while (start < a.length && start < b.length && a[start] === b[start]) start += 1;
-  let endA = a.length;
-  let endB = b.length;
-  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
-    endA -= 1;
-    endB -= 1;
-  }
-  const prefix = a.slice(0, start).map((text) => ({ kind: "context", text }));
-  const suffix = a.slice(endA).map((text) => ({ kind: "context", text }));
-  const midA = a.slice(start, endA);
-  const midB = b.slice(start, endB);
-  const prefixLen = prefix.length;
-  const ops = [...prefix];
-  if (midA.length * midB.length > MAX_DP_CELLS) {
-    for (const text of midA) ops.push({ kind: "del", text });
-    for (const text of midB) ops.push({ kind: "add", text });
-  } else if (midA.length > 0 || midB.length > 0) {
-    const rows = midA.length + 1;
-    const cols = midB.length + 1;
-    const dp = new Uint32Array(rows * cols);
-    const cell = (r, c) => dp[r * cols + c] ?? 0;
-    for (let i2 = 1; i2 < rows; i2++) {
-      for (let j2 = 1; j2 < cols; j2++) {
-        dp[i2 * cols + j2] = midA[i2 - 1] === midB[j2 - 1] ? cell(i2 - 1, j2 - 1) + 1 : Math.max(cell(i2 - 1, j2), cell(i2, j2 - 1));
-      }
-    }
-    const lineAt = (lines, index) => lines[index] ?? "";
-    const middle = [];
-    let i = midA.length;
-    let j = midB.length;
-    while (i > 0 && j > 0) {
-      if (midA[i - 1] === midB[j - 1]) {
-        middle.push({ kind: "context", text: lineAt(midA, i - 1) });
-        i -= 1;
-        j -= 1;
-      } else if (cell(i, j - 1) >= cell(i - 1, j)) {
-        middle.push({ kind: "add", text: lineAt(midB, j - 1) });
-        j -= 1;
-      } else {
-        middle.push({ kind: "del", text: lineAt(midA, i - 1) });
-        i -= 1;
-      }
-    }
-    while (i > 0) {
-      middle.push({ kind: "del", text: lineAt(midA, i - 1) });
-      i -= 1;
-    }
-    while (j > 0) {
-      middle.push({ kind: "add", text: lineAt(midB, j - 1) });
-      j -= 1;
-    }
-    middle.reverse();
-    ops.push(...middle);
-  }
-  ops.push(...suffix);
-  return ops.length === prefixLen + suffix.length ? [] : ops;
+
+// src/cli/components/ThinkingIndicator.tsx
+import { Box as Box8, Text as Text9 } from "ink";
+import { jsxs as jsxs9 } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["-", "\\", "|", "/"];
+var REASONING_TAIL_LENGTH = 200;
+var THOUGHT_SUMMARY_LENGTH = 100;
+function truncateTail(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= max) return flat;
+  return `\u2026${flat.slice(flat.length - max)}`;
 }
-function hunkRanges(ops) {
-  const changes = [];
-  for (let i = 0; i < ops.length; i++) {
-    const op = ops[i];
-    if (op && op.kind !== "context") changes.push(i);
-  }
-  const ranges = [];
-  let groupStart = 0;
-  for (let k = 1; k <= changes.length; k++) {
-    const cur = changes[k];
-    const prev = changes[k - 1];
-    const first = changes[groupStart];
-    if (prev === void 0 || first === void 0) break;
-    if (cur === void 0 || cur - prev > CONTEXT_LINES * 2 + 1) {
-      ranges.push([
-        Math.max(0, first - CONTEXT_LINES),
-        Math.min(ops.length, prev + CONTEXT_LINES + 1)
-      ]);
-      groupStart = k;
-    }
-  }
-  return ranges;
+function ThinkingIndicator({
+  reasoning,
+  frame = 0,
+  activity
+}) {
+  const tail = reasoning ? truncateTail(reasoning, REASONING_TAIL_LENGTH) : "";
+  const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+      spinner,
+      " ",
+      activity ?? "star is thinking\u2026"
+    ] }),
+    tail !== "" && /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+      " ",
+      tail
+    ] })
+  ] });
 }
-function buildDiffLines(oldText, newText) {
-  const ops = diffOps(oldText, newText);
-  if (ops.length === 0) return [];
-  const ranges = hunkRanges(ops);
-  const lines = [];
-  let omitted = 0;
-  for (const [rangeIndex, [start, end]] of ranges.entries()) {
-    if (rangeIndex > 0) lines.push({ kind: "marker", text: "\xB7\xB7\xB7" });
-    const hunk = ops.slice(start, end);
-    let shown = hunk;
-    if (hunk.length > MAX_HUNK_LINES) {
-      const headCount = Math.ceil(MAX_HUNK_LINES / 2);
-      shown = [...hunk.slice(0, headCount), ...hunk.slice(headCount - MAX_HUNK_LINES)];
-    }
-    if (hunk.length > shown.length) {
-      omitted += hunk.length - shown.length;
-    }
-    for (const op of shown) lines.push(op);
-  }
-  if (lines.length > MAX_TOTAL_LINES) {
-    omitted += lines.length - MAX_TOTAL_LINES;
-    lines.length = MAX_TOTAL_LINES;
-  }
-  if (omitted > 0) lines.push({ kind: "marker", text: `... (${omitted} more lines)` });
-  return lines;
+
+// src/cli/components/ToolCallCard.tsx
+function formatToolCard(card) {
+  const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
+  if (card.result === void 0) return header;
+  const preview = previewLines(card.result, 10);
+  return `${header}
+${preview.text}${preview.truncated ? "\n... (truncated)" : ""}`;
 }
-function getStringArg2(args, key) {
-  if (typeof args === "object" && args !== null) {
-    const value = args[key];
-    if (typeof value === "string") return value;
-  }
-  return void 0;
+
+// src/cli/double-esc.ts
+var DOUBLE_ESC_WINDOW_MS = 600;
+function isDoubleEscape(previous, now, windowMs = DOUBLE_ESC_WINDOW_MS) {
+  return previous !== null && now - previous <= windowMs;
 }
-function applyEdit(content, oldString, newString, replaceAll) {
-  let count = 0;
-  let idx = content.indexOf(oldString);
-  while (idx !== -1) {
-    count += 1;
-    idx = content.indexOf(oldString, idx + oldString.length);
-  }
-  if (count === 0) return null;
-  if (count > 1 && !replaceAll) return null;
-  return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+
+// src/cli/notify.ts
+var BELL = "\x07";
+function shouldNotifyBell(input, isTTY) {
+  if (!input.enabled || input.noNotifyEnv || !isTTY) return false;
+  if (input.interrupted) return false;
+  if (input.elapsedMs !== void 0 && input.elapsedMs < input.thresholdSec * 1e3) return false;
+  return true;
 }
-function newFilePreview(content, label) {
-  const all = content.split("\n");
-  const shown = all.slice(0, NEW_FILE_PREVIEW_LINES);
-  const lines = shown.map((text) => ({ kind: "add", text }));
-  if (all.length > shown.length) {
-    lines.push({ kind: "marker", text: `... (${all.length - shown.length} more lines)` });
-  }
-  return { type: "new-file", label, lines };
+function notifyBell(input, deps = {}) {
+  const isTTY = deps.isTTY ?? Boolean(process.stdout.isTTY);
+  if (!shouldNotifyBell(input, isTTY)) return false;
+  (deps.write ?? ((text) => process.stdout.write(text)))(BELL);
+  return true;
 }
-async function generateDiffPreview(toolName, args, cwd) {
-  if (toolName !== "edit_file" && toolName !== "write_file") return null;
-  const filePath = getStringArg2(args, "path");
-  if (filePath === void 0) return null;
-  const absolute = path20.resolve(cwd, filePath);
-  let existing;
-  try {
-    existing = await readFile7(absolute, "utf8");
-  } catch {
-    existing = null;
+
+// src/cli/queue.ts
+var PromptQueue = class {
+  items = [];
+  nextId = 1;
+  enqueue(prompt) {
+    this.items.push({ id: this.nextId++, ...prompt });
+    return this.items.length;
+  }
+  dequeue() {
+    return this.items.shift();
+  }
+  // Empties the queue and returns what was dropped (for the "cleared N" note).
+  clear() {
+    const removed = this.items;
+    this.items = [];
+    return removed;
+  }
+  get size() {
+    return this.items.length;
   }
-  if (toolName === "edit_file") {
-    const oldString = getStringArg2(args, "old_string");
-    const newString = getStringArg2(args, "new_string");
-    if (existing === null || oldString === void 0 || newString === void 0) return null;
-    const replaceAll = typeof args === "object" && args !== null && args.replace_all === true;
-    const updated = applyEdit(existing, oldString, newString, replaceAll);
-    if (updated === null) return null;
-    return { type: "diff", label: filePath, lines: buildDiffLines(existing, updated) };
+  list() {
+    return [...this.items];
   }
-  const content = getStringArg2(args, "content");
-  if (content === void 0) return null;
-  if (existing === null) return newFilePreview(content, filePath);
-  return { type: "diff", label: filePath, lines: buildDiffLines(existing, content) };
-}
+};
 
 // src/cli/shell-bang.ts
 var SHELL_BANG_DISPLAY_MAX_CHARS = 3e3;
@@ -3506,9 +2797,9 @@ function startTicker(onTick, intervalMs = TICK_MS) {
 
 // src/cli/update-check.ts
 var REGISTRY_URL2 = "https://registry.npmjs.org/@cryer%2fstar-cli/latest";
-var TIMEOUT_MS3 = 5e3;
+var TIMEOUT_MS = 5e3;
 async function defaultFetcher2(url) {
-  return fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS3) });
+  return fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS) });
 }
 function isNewerVersion(latest, current) {
   const parse3 = (v) => v.split(".").slice(0, 3).map((part) => Number.parseInt(part, 10));
@@ -3536,7 +2827,7 @@ async function checkForUpdate(currentVersion, fetcher = defaultFetcher2) {
 }
 
 // src/cli/repl.tsx
-import { jsx as jsx6, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs10 } from "react/jsx-runtime";
 var CLEAR_TERMINAL = process.platform === "win32" ? "\x1B[2J\x1B[0f" : "\x1B[2J\x1B[3J\x1B[H";
 function emptyUsage() {
   return { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 };
@@ -3575,6 +2866,7 @@ function Repl({
   const [bgLabels, setBgLabels] = useState2(() => runningTaskLabels());
   const [permissionModeState, setPermissionModeState] = useState2(permissionMode);
   const [planApproval, setPlanApprovalState] = useState2(false);
+  const [pendingRewind, setPendingRewindState] = useState2(null);
   const backendRef = useRef2(backend);
   const nextIdRef = useRef2(initialDisplay.length);
   const abortRef = useRef2(null);
@@ -3588,10 +2880,27 @@ function Repl({
   const alwaysAllowedRef = useRef2(/* @__PURE__ */ new Set());
   const prevModeRef = useRef2(null);
   const planApprovalRef = useRef2(false);
+  const pendingRewindRef = useRef2(null);
   const modelNameRef = useRef2(model);
+  const sessionStoreRef = useRef2(sessionStore);
   const usageRef = useRef2(initialUsage ? { ...initialUsage } : emptyUsage());
   const turnChunksRef = useRef2(0);
   const messagesRef = useRef2(initialDisplay);
+  const [queueItems, setQueueItems] = useState2([]);
+  const queueRef = useRef2(new PromptQueue());
+  const [pendingImages, setPendingImages] = useState2([]);
+  const pendingImagesRef = useRef2([]);
+  const imageSeqRef = useRef2(1);
+  const [inputRefill, setInputRefill] = useState2();
+  const refillSeqRef = useRef2(0);
+  const lastEscRef = useRef2(null);
+  const [gitBranch, setGitBranch] = useState2(null);
+  const [contextPercent, setContextPercent] = useState2(null);
+  const budgetWarnedRef = useRef2(false);
+  const budgetExceededRef = useRef2(false);
+  const runStreamRef = useRef2(
+    null
+  );
   const pushMessage = useCallback(
     (role, text, note, tight) => {
       setMessages((prev) => {
@@ -3632,6 +2941,42 @@ function Repl({
     planApprovalRef.current = v;
     setPlanApprovalState(v);
   }, []);
+  const setPendingRewind = useCallback((p) => {
+    pendingRewindRef.current = p;
+    setPendingRewindState(p);
+  }, []);
+  const stageClipboardImage = useCallback((img) => {
+    pendingImagesRef.current = [
+      ...pendingImagesRef.current,
+      { id: imageSeqRef.current++, image: img }
+    ];
+    setPendingImages(pendingImagesRef.current);
+  }, []);
+  const clearPendingImages = useCallback(() => {
+    pendingImagesRef.current = [];
+    setPendingImages([]);
+  }, []);
+  const sessionCostUsd = useCallback(
+    () => computeCostUsd(
+      usageRef.current,
+      config.models.find((m) => m.name === modelNameRef.current)
+    ),
+    [config]
+  );
+  const handlePasteImage = useCallback(() => {
+    void readClipboardImage().then((img) => {
+      if (img) stageClipboardImage(img);
+    });
+  }, [stageClipboardImage]);
+  const handleRewindDecision = useCallback(
+    (decision) => {
+      const p = pendingRewindRef.current;
+      if (!p) return;
+      setPendingRewind(null);
+      p.resolve(decision === "yes");
+    },
+    [setPendingRewind]
+  );
   const applySessionMode = useCallback(
     (mode) => {
       if (mode === config.permissionMode) return;
@@ -3656,10 +3001,11 @@ function Repl({
           setPendingPermission({ request: req, preview, resolve });
         });
       };
+      target.onHookWarning = (message) => pushMessage("system", message);
     },
-    [setPendingPermission, cwd]
+    [setPendingPermission, cwd, pushMessage]
   );
-  useEffect(() => {
+  useEffect2(() => {
     attachConfirmHandler(backendRef.current);
     return () => {
       tickerStopRef.current?.();
@@ -3667,26 +3013,33 @@ function Repl({
       pendingRef.current?.resolve(false);
     };
   }, [attachConfirmHandler]);
-  useEffect(() => {
+  useEffect2(() => {
     if (process.env.STAR_NO_UPDATE_CHECK === "1") return;
     void checkForUpdate(VERSION).then((message) => {
       if (message) pushMessage("system", message);
     });
   }, [pushMessage]);
-  useEffect(() => {
+  useEffect2(() => {
     const onUpdate = (task) => {
       setBgLabels(runningTaskLabels());
       pushMessage(
         "system",
         task.status === "running" ? formatTaskStarted(task) : formatTaskFinished(task)
       );
+      if (task.status !== "running") {
+        notifyBell({
+          enabled: config.notifyBell,
+          thresholdSec: config.notifyBellThresholdSec,
+          noNotifyEnv: process.env.STAR_NO_NOTIFY === "1"
+        });
+      }
     };
     defaultTaskManager.on("update", onUpdate);
     return () => {
       defaultTaskManager.off("update", onUpdate);
       defaultTaskManager.cleanup();
     };
-  }, [pushMessage]);
+  }, [pushMessage, config]);
   const interrupt = useCallback(() => {
     abortRef.current?.abort();
     const p = pendingRef.current;
@@ -3694,7 +3047,34 @@ function Repl({
       setPendingPermission(null);
       p.resolve(false);
     }
-  }, [setPendingPermission]);
+    const cleared = queueRef.current.clear();
+    if (cleared.length > 0) {
+      setQueueItems([]);
+      pushMessage("system", `cleared ${cleared.length} queued message(s)`);
+    }
+  }, [setPendingPermission, pushMessage]);
+  const editLastMessage = useCallback(async () => {
+    const current = backendRef.current;
+    if (typeof current.retractLastTurn !== "function") return;
+    const visible = messagesRef.current;
+    let cut = -1;
+    let text = "";
+    for (let i = visible.length - 1; i >= 0; i--) {
+      const msg = visible[i];
+      if (msg?.role === "user") {
+        cut = i;
+        text = msg.text;
+        break;
+      }
+    }
+    if (cut < 0) return;
+    const { removed } = await current.retractLastTurn();
+    if (removed === 0) return;
+    redrawMessages(visible.slice(0, cut));
+    refillSeqRef.current += 1;
+    setInputRefill({ text, seq: refillSeqRef.current });
+    pushMessage("system", "last message restored for editing");
+  }, [pushMessage, redrawMessages]);
   const handleExit = useCallback(() => {
     const killed = defaultTaskManager.cleanup();
     if (killed.length > 0) {
@@ -3705,10 +3085,27 @@ function Repl({
     }
     exit();
   }, [exit, pushMessage]);
-  useInput4((_input, key) => {
-    if (key.escape) interrupt();
+  useInput5((_input, key) => {
+    if (key.escape) {
+      const busy = abortRef.current !== null || pendingRef.current !== null || planApprovalRef.current || pendingRewindRef.current !== null;
+      if (busy) {
+        lastEscRef.current = null;
+        interrupt();
+        return;
+      }
+      const now = Date.now();
+      if (isDoubleEscape(lastEscRef.current, now)) {
+        lastEscRef.current = null;
+        void editLastMessage();
+      } else {
+        lastEscRef.current = now;
+      }
+      return;
+    }
+    lastEscRef.current = null;
     if (key.shift && key.tab) {
-      if (abortRef.current || pendingRef.current || planApprovalRef.current) return;
+      if (abortRef.current || pendingRef.current || planApprovalRef.current || pendingRewindRef.current)
+        return;
       const current = config.permissionMode;
       const index = SESSION_MODE_CYCLE.indexOf(current);
       const next = SESSION_MODE_CYCLE[(index + 1) % SESSION_MODE_CYCLE.length] ?? "ask";
@@ -3745,7 +3142,8 @@ function Repl({
           registry: createDefaultRegistry(),
           config,
           cwd,
-          sessionStore
+          sessionStore: sessionStoreRef.current,
+          contextMaxTokens: contextWindowTokens(config, name)
         });
         const prev = backendRef.current;
         if (prev instanceof AgentLoop) {
@@ -3760,7 +3158,7 @@ function Repl({
         return `Failed to switch model: ${error instanceof Error ? error.message : String(error)}`;
       }
     },
-    [config, cwd, sessionStore, attachConfirmHandler]
+    [config, cwd, attachConfirmHandler]
   );
   const resume = useCallback(
     async (id) => {
@@ -3768,33 +3166,43 @@ function Repl({
       if (!(current instanceof AgentLoop)) {
         return "Current backend does not support resuming sessions.";
       }
-      const resumed = await resumeSession(id);
+      const resolvedId = await resolveSessionId(id);
+      if (!resolvedId) {
+        return `Session not found: ${id}`;
+      }
+      const resumed = await resumeSession(resolvedId);
       if (!resumed) {
         return `Session not found: ${id}`;
       }
       await current.loadMessages(resumed.messages);
+      const store = await SessionStore.open(resolvedId);
+      if (store) {
+        hydrateSnapshots(await loadSessionSnapshots(store.dir));
+      }
       const display = buildDisplayMessages(resumed.messages);
       nextIdRef.current = display.length;
       applyMessages(display);
       usageRef.current = resumed.meta.usage ? { ...resumed.meta.usage } : emptyUsage();
       setUsageVersion((v) => v + 1);
-      return `Resumed session ${id} (${resumed.messages.length} messages).`;
+      return `Resumed session ${resolvedId} (${resumed.messages.length} messages).`;
     },
     [applyMessages]
   );
   const runStream = useCallback(
-    async (input) => {
+    async (input, extraImages = []) => {
       const resolved = await resolveMentions(input, cwd);
+      const images = [...resolved.images, ...extraImages];
       pushMessage(
         "user",
         input,
-        resolved.attached.length > 0 ? `attached: ${resolved.attached.join(", ")}` : void 0
+        resolved.attached.length + extraImages.length > 0 ? `attached: ${[...resolved.attached, ...extraImages.map((img) => img.path)].join(", ")}` : void 0
       );
       for (const skip of resolved.skipped) {
         pushMessage("system", `Skipped @${skip.path}: ${skip.reason}`);
       }
       const controller = new AbortController();
       abortRef.current = controller;
+      const turnStartedAt = Date.now();
       streamedRef.current = "";
       thinkingRef.current = true;
       reasoningRef.current = "";
@@ -3831,9 +3239,13 @@ function Repl({
         }
       });
       try {
-        for await (const event of backendRef.current.stream(resolved.input, controller.signal, {
-          persistAs: input
-        })) {
+        for await (const event of backendRef.current.stream(
+          images.length > 0 ? { text: resolved.input, images } : resolved.input,
+          controller.signal,
+          {
+            persistAs: extraImages.length > 0 ? `${input}${" [clipboard image]".repeat(extraImages.length)}` : input
+          }
+        )) {
           if (event.type === "text-delta") {
             if (thinkingRef.current) {
               thinkingRef.current = false;
@@ -3883,7 +3295,7 @@ function Repl({
               usage.completionTokens += event.usage.completionTokens;
               usage.totalTokens += event.usage.totalTokens;
               setUsageVersion((v) => v + 1);
-              sessionStore?.addUsage(event.usage).catch(() => {
+              sessionStoreRef.current?.addUsage(event.usage).catch(() => {
               });
             }
           } else if (event.type === "error") {
@@ -3913,6 +3325,13 @@ function Repl({
         streamedRef.current = "";
         setStreamingText(null);
         const interrupted = controller.signal.aborted;
+        notifyBell({
+          enabled: config.notifyBell,
+          thresholdSec: config.notifyBellThresholdSec,
+          noNotifyEnv: process.env.STAR_NO_NOTIFY === "1",
+          interrupted,
+          elapsedMs: Date.now() - turnStartedAt
+        });
         if (finalText.length > 0) {
           pushAssistantChunk(`${finalText}${interrupted ? " [interrupted]" : ""}`, false);
         } else if (interrupted && turnChunksRef.current > 0) {
@@ -3931,6 +3350,37 @@ function Repl({
         if (!interrupted && config.permissionMode === "plan") {
           setPlanApproval(true);
         }
+        const cost = sessionCostUsd();
+        const budget = config.sessionBudgetUsd;
+        const status = budgetState(cost, budget);
+        if (status === "warn" && !budgetWarnedRef.current) {
+          budgetWarnedRef.current = true;
+          pushMessage(
+            "system",
+            `Session cost $${formatDollars(cost ?? 0)} has passed 80% of the $${formatDollars(budget ?? 0)} session budget (sessionBudgetUsd).`
+          );
+        }
+        if (status === "exceeded" && !budgetExceededRef.current) {
+          budgetExceededRef.current = true;
+          pushMessage(
+            "system",
+            `Session budget exceeded: $${formatDollars(cost ?? 0)} of $${formatDollars(budget ?? 0)} (sessionBudgetUsd). New prompts are blocked \u2014 raise sessionBudgetUsd in the config or start a /new session.`
+          );
+        }
+        const nextPrompt = queueRef.current.dequeue();
+        if (nextPrompt) {
+          if (status === "exceeded") {
+            const dropped = queueRef.current.clear().length + 1;
+            setQueueItems([]);
+            pushMessage(
+              "system",
+              `Dropped ${dropped} queued message(s) \u2014 session budget exceeded.`
+            );
+          } else {
+            setQueueItems(queueRef.current.list());
+            void runStreamRef.current?.(nextPrompt.text, nextPrompt.images);
+          }
+        }
       }
     },
     [
@@ -3938,11 +3388,14 @@ function Repl({
       pushAssistantChunk,
       setPendingPermission,
       setPlanApproval,
-      sessionStore,
       cwd,
-      config
+      config,
+      sessionCostUsd
     ]
   );
+  useEffect2(() => {
+    runStreamRef.current = runStream;
+  }, [runStream]);
   const handlePlanDecision = useCallback(
     (decision) => {
       setPlanApproval(false);
@@ -3956,10 +3409,39 @@ function Repl({
   );
   const registry = useMemo(() => {
     const ctx = {
+      cwd,
       addSystemMessage: (text) => pushMessage("system", text),
+      showDiff: (text, lines, note) => {
+        setMessages((prev) => {
+          const next = [
+            ...prev,
+            { id: nextIdRef.current++, role: "system", text, note, diff: lines }
+          ];
+          messagesRef.current = next;
+          return next;
+        });
+      },
       clearMessages: () => {
         redrawMessages([]);
       },
+      conversationText: (scope) => {
+        const current = backendRef.current;
+        if (!(current instanceof AgentLoop)) return null;
+        const messages2 = current.getMessages();
+        if (scope === "all") {
+          const parts = messages2.filter((m) => m.role === "user" || m.role === "assistant").map((m) => coreMessageText(m)).filter((text) => text.length > 0);
+          return parts.length > 0 ? parts.join("\n\n") : null;
+        }
+        for (let i = messages2.length - 1; i >= 0; i--) {
+          const message = messages2[i];
+          if (message?.role === "assistant") {
+            const text = coreMessageText(message);
+            if (text) return text;
+          }
+        }
+        return null;
+      },
+      copyToClipboard: (text) => copyText(text),
       exit: () => handleExit(),
       listModels: () => {
         const models = listModels(config);
@@ -3971,11 +3453,42 @@ function Repl({
 ${lines.join("\n")}`;
       },
       switchModel,
-      listSessions: async () => {
-        const metas = await SessionStore.list(cwd);
-        return metas.length === 0 ? "No sessions found for this directory." : formatSessionList(metas);
+      listSessions: async (all) => {
+        const entries = await listSessionEntries(all ? void 0 : cwd);
+        if (entries.length === 0) {
+          return all ? "No sessions found." : "No sessions found for this directory.";
+        }
+        return formatSessionEntries(entries, { showCwd: all });
       },
       resumeSession: resume,
+      newSession: async () => {
+        const current = backendRef.current;
+        if (!(current instanceof AgentLoop)) {
+          return "Current backend does not support starting a new session.";
+        }
+        const store = await SessionStore.create(cwd, modelNameRef.current);
+        current.setSessionStore(store);
+        sessionStoreRef.current = store;
+        const [first] = current.getMessages();
+        await current.loadMessages(first?.role === "system" ? [first] : []);
+        clearSnapshots();
+        redrawMessages([]);
+        usageRef.current = emptyUsage();
+        budgetWarnedRef.current = false;
+        budgetExceededRef.current = false;
+        setUsageVersion((v) => v + 1);
+        return `Started a new session (${store.id}) with a clean context.`;
+      },
+      clearSessions: async (all) => {
+        const currentId = sessionStoreRef.current?.id;
+        const removed = await clearSessions(all ? void 0 : cwd, currentId);
+        if (removed === 0) {
+          return all ? "No stored sessions to delete." : "No stored sessions for this directory.";
+        }
+        const scope = all ? "across all directories" : "for this directory";
+        const kept = currentId ? " The current session is still active." : "";
+        return `Deleted ${removed} session(s) ${scope}.${kept}`;
+      },
       showTodos: async () => {
         const store = new TodoStore();
         await store.load(cwd);
@@ -3987,6 +3500,7 @@ ${lines.join("\n")}`;
         return `${formatUsage(usageRef.current)}
 ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
       },
+      showGlobalUsage: async () => formatUsageDashboard(await collectUsageStats(), config.models),
       compactContext: async () => {
         let summaryModel = null;
         try {
@@ -3996,7 +3510,7 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         }
         const result = await compactSession({
           backend: backendRef.current,
-          sessionStore,
+          sessionStore: sessionStoreRef.current,
           config,
           model: summaryModel
         });
@@ -4007,7 +3521,12 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         }
         return result.message;
       },
-      exportSession: (arg) => exportSession({ backend: backendRef.current, sessionStore, cwd, arg }),
+      exportSession: (arg) => exportSession({
+        backend: backendRef.current,
+        sessionStore: sessionStoreRef.current,
+        cwd,
+        arg
+      }),
       undo: async () => {
         const current = backendRef.current;
         if (!(current instanceof AgentLoop)) {
@@ -4031,6 +3550,48 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
           "\n"
         );
       },
+      rewind: async (args) => {
+        if (!args) {
+          return formatCheckpointList(listSnapshots(), cwd);
+        }
+        const id = Number.parseInt(args, 10);
+        if (!Number.isFinite(id) || String(id) !== args) {
+          return `Usage: /rewind <n> \u2014 "${args}" is not a checkpoint number.`;
+        }
+        const plan = planRewind(listSnapshots(), id);
+        if (!plan) {
+          return `Checkpoint #${id} not found (it may already have been rewound). /rewind lists the current checkpoints.`;
+        }
+        const current = backendRef.current;
+        const messageCount = plan.messageIndex !== null && current instanceof AgentLoop ? current.countRetraction(plan.messageIndex) : 0;
+        const confirmed = await new Promise((resolve) => {
+          setPendingRewind({
+            summary: `Rewind to just before checkpoint #${id} (${plan.target.toolName} ${plan.target.path}):
+${plan.affected.length} file change(s) will be reverted, ${messageCount} message(s) retracted.`,
+            resolve
+          });
+        });
+        if (!confirmed) {
+          return "Rewind cancelled.";
+        }
+        const result = await rewindToSnapshot(id);
+        if (!result) {
+          return `Checkpoint #${id} is no longer available.`;
+        }
+        let retracted = 0;
+        if (result.messageIndex !== null && current instanceof AgentLoop) {
+          retracted = await current.retractFromIndex(result.messageIndex);
+          if (retracted > 0) {
+            const display = buildDisplayMessages([...current.getMessages()]);
+            nextIdRef.current = display.length;
+            redrawMessages(display);
+          }
+        }
+        return [
+          ...result.reverted,
+          `Rewound to before checkpoint #${id}: ${result.reverted.length} file change(s) reverted, ${retracted} message(s) retracted.`
+        ].join("\n");
+      },
       permissionMode: async (args) => {
         const current = config.permissionMode;
         if (!args) {
@@ -4084,7 +3645,8 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         `maxSteps: ${config.maxSteps}`,
         `contextMaxTokens: ${config.contextMaxTokens}`,
         `streamIdleTimeoutSec: ${config.streamIdleTimeoutSec}`,
-        `permissions.allow (${config.permissions.allow.length}): ${config.permissions.allow.join(", ") || "(none)"}`
+        `permissions.allow (${config.permissions.allow.length}): ${config.permissions.allow.join(", ") || "(none)"}`,
+        `hooks (${config.hooks.length}): ${config.hooks.map((h) => h.event).join(", ") || "(none)"}`
       ].join("\n")
     };
     const reg = new CommandRegistry();
@@ -4098,11 +3660,11 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
     cwd,
     switchModel,
     resume,
-    sessionStore,
     runStream,
     applyMessages,
     redrawMessages,
-    applySessionMode
+    applySessionMode,
+    setPendingRewind
   ]);
   const runShellBang = useCallback(
     async (raw) => {
@@ -4143,6 +3705,11 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
   const handleSubmit = useCallback(
     (text) => {
       if (text.startsWith("!")) {
+        if (abortRef.current) {
+          queueRef.current.enqueue({ text, images: [] });
+          setQueueItems(queueRef.current.list());
+          return;
+        }
         void runShellBang(text.slice(1));
         return;
       }
@@ -4157,17 +3724,44 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         void command.run(parsed.args, registry.ctx);
         return;
       }
-      void runStream(text);
+      const budget = config.sessionBudgetUsd;
+      if (budgetState(sessionCostUsd(), budget) === "exceeded") {
+        pushMessage(
+          "system",
+          `Session budget of $${formatDollars(budget ?? 0)} (sessionBudgetUsd) is exceeded \u2014 prompts are blocked. Slash commands still work; raise sessionBudgetUsd in the config or start a /new session.`
+        );
+        return;
+      }
+      const images = pendingImagesRef.current.map((staged) => staged.image);
+      if (images.length > 0) clearPendingImages();
+      if (abortRef.current) {
+        queueRef.current.enqueue({ text, images });
+        setQueueItems(queueRef.current.list());
+        return;
+      }
+      void runStream(text, images);
     },
-    [registry, pushMessage, runStream, runShellBang]
+    [registry, pushMessage, runStream, runShellBang, config, clearPendingImages, sessionCostUsd]
   );
   const commandHints = useMemo(
     () => registry.list().map((cmd) => ({ name: cmd.name, description: cmd.description })),
     [registry]
   );
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx6(MessageList, { messages }, `messages-${epoch}`),
-    (thinking || activity !== null) && /* @__PURE__ */ jsx6(
+  useEffect2(() => {
+    setGitBranch(getGitSummary(cwd)?.branch ?? null);
+    const current = backendRef.current;
+    if (current instanceof AgentLoop) {
+      const window_ = contextWindowTokens(config, modelNameRef.current);
+      const pct = estimateTokens([...current.getMessages()]) / window_ * 100;
+      setContextPercent(pct < 10 ? Math.round(pct * 10) / 10 : Math.round(pct));
+    } else {
+      setContextPercent(null);
+    }
+  }, [cwd, config, isStreaming, epoch]);
+  const sessionCost = sessionCostUsd();
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(MessageList, { messages }, `messages-${epoch}`),
+    (thinking || activity !== null) && /* @__PURE__ */ jsx8(
       ThinkingIndicator,
       {
         reasoning: thinkingText,
@@ -4175,9 +3769,9 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         activity: activity ?? void 0
       }
     ),
-    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx6(Text8, { dimColor: true, children: thoughtSummary }),
-    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx6(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
-    pending && /* @__PURE__ */ jsx6(
+    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx8(Text10, { dimColor: true, children: thoughtSummary }),
+    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx8(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
+    pending && /* @__PURE__ */ jsx8(
       PermissionPrompt,
       {
         request: pending.request,
@@ -4185,24 +3779,41 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         onDecision: handleDecision
       }
     ),
-    planApproval && /* @__PURE__ */ jsx6(ExitPlanPrompt, { onDecision: handlePlanDecision }),
-    /* @__PURE__ */ jsx6(
+    planApproval && /* @__PURE__ */ jsx8(ExitPlanPrompt, { onDecision: handlePlanDecision }),
+    pendingRewind && /* @__PURE__ */ jsx8(RewindConfirmPrompt, { summary: pendingRewind.summary, onDecision: handleRewindDecision }),
+    queueItems.map((item) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      "queued: ",
+      item.text.length > 80 ? `${item.text.slice(0, 80)}\u2026` : item.text
+    ] }, item.id)),
+    pendingImages.map((staged) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      "[image attached: ",
+      staged.image.path,
+      "]"
+    ] }, staged.id)),
+    /* @__PURE__ */ jsx8(
       InputBox,
       {
         isStreaming,
-        disabled: pending !== null || planApproval,
+        disabled: pending !== null || planApproval || pendingRewind !== null,
         commands: commandHints,
+        cwd,
+        refill: inputRefill,
         onSubmit: handleSubmit,
         onInterrupt: interrupt,
-        onExit: handleExit
+        onExit: handleExit,
+        onPasteImage: handlePasteImage
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx8(
       StatusBar,
       {
+        cwd,
         model: modelName,
         permissionMode: permissionModeState,
         tokens: usageRef.current.totalTokens,
+        gitBranch,
+        contextPercent,
+        sessionCostUsd: sessionCost,
         backgroundTasks: bgLabels
       }
     )
@@ -4213,7 +3824,7 @@ function renderRepl(backend, opts) {
     defaultTaskManager.cleanup();
   });
   return render(
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx8(
       Repl,
       {
         backend,
@@ -4230,46 +3841,8 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs7 from "fs";
+import fs10 from "fs";
 import { parse as parse2 } from "smol-toml";
-
-// src/config/schema.ts
-import { z as z11 } from "zod";
-var ProviderConfigSchema = z11.object({
-  name: z11.string(),
-  protocol: z11.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
-  baseURL: z11.string(),
-  apiKeyEnv: z11.string().optional(),
-  apiKey: z11.string().optional(),
-  headers: z11.record(z11.string()).optional()
-});
-var ModelConfigSchema = z11.object({
-  name: z11.string(),
-  provider: z11.string(),
-  model: z11.string(),
-  maxTokens: z11.number().int().positive().optional(),
-  promptPrice: z11.number().nonnegative().optional(),
-  completionPrice: z11.number().nonnegative().optional()
-});
-var PermissionsConfigSchema = z11.object({
-  allow: z11.array(z11.string()).default([])
-});
-var ConfigSchema = z11.object({
-  defaultModel: z11.string().default(""),
-  permissionMode: z11.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
-  providers: z11.array(ProviderConfigSchema).default([]),
-  models: z11.array(ModelConfigSchema).default([]),
-  maxSteps: z11.number().int().positive().default(50),
-  contextMaxTokens: z11.number().int().positive().default(1e5),
-  // Seconds without any stream part before a stalled response is ended
-  // gracefully (some relays never send the terminal chunks). Applies once
-  // streaming has started; the first part gets a longer, fixed allowance.
-  streamIdleTimeoutSec: z11.number().positive().default(20),
-  contextCompaction: z11.enum(["summary", "truncate"]).default("summary"),
-  permissions: PermissionsConfigSchema.default({ allow: [] })
-});
-
-// src/config/loader.ts
 var PartialConfigSchema = ConfigSchema.partial();
 function parseTomlFile(content, filePath) {
   let raw;
@@ -4296,8 +3869,8 @@ function applyOverrides(config, overrides) {
   return merged;
 }
 function readTomlFileSync(filePath) {
-  if (!fs7.existsSync(filePath)) return {};
-  const content = fs7.readFileSync(filePath, "utf8");
+  if (!fs10.existsSync(filePath)) return {};
+  const content = fs10.readFileSync(filePath, "utf8");
   return parseTomlFile(content, filePath);
 }
 function loadConfigSync(cwd, overrides) {
@@ -4321,12 +3894,36 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     config,
     cwd,
     system: SYSTEM_PROMPT,
-    sessionStore
+    sessionStore,
+    contextMaxTokens: contextWindowTokens(config, modelName)
   });
 }
-async function printMode(loop, prompt, cwd, json) {
+async function printMode(loop, prompt, cwd, json, imagePaths) {
+  const flagImages = [];
+  for (const imagePath of imagePaths) {
+    if (!imageMimeType(imagePath)) {
+      process.stderr.write(
+        `[error] unsupported image type: ${imagePath} (supported: png, jpg, jpeg, gif, webp)
+`
+      );
+      return 1;
+    }
+    const image = await readImageInput(imagePath, cwd);
+    if (!image) {
+      process.stderr.write(
+        `[error] cannot read image: ${imagePath} (missing, unreadable, or larger than ${MAX_IMAGE_BYTES / (1024 * 1024)}MB)
+`
+      );
+      return 1;
+    }
+    flagImages.push(image);
+  }
   const controller = new AbortController();
   process.on("SIGINT", () => controller.abort());
+  loop.onHookWarning = (message) => {
+    process.stderr.write(`[hook] ${message}
+`);
+  };
   const resolved = await resolveMentions(prompt, cwd);
   if (resolved.attached.length > 0) {
     process.stderr.write(`[attached] ${resolved.attached.join(", ")}
@@ -4336,10 +3933,12 @@ async function printMode(loop, prompt, cwd, json) {
     process.stderr.write(`[skipped] @${skip.path}: ${skip.reason}
 `);
   }
+  const images = [...flagImages, ...resolved.images];
+  const input = images.length > 0 ? { text: resolved.input, images } : resolved.input;
   const usage = new UsageTracker();
   let exitCode = 0;
   try {
-    for await (const event of loop.stream(resolved.input, controller.signal, {
+    for await (const event of loop.stream(input, controller.signal, {
       persistAs: prompt
     })) {
       if (json) {
@@ -4405,7 +4004,15 @@ async function printMode(loop, prompt, cwd, json) {
   return exitCode;
 }
 var program = new Command();
-program.name("star").description("Star CLI \u2014 an AI agent command-line interface").version(VERSION).option("-m, --model <model>", "model to use").option("--permission-mode <mode>", "permission mode: ask | auto | readonly | yolo | plan").option("-p, --print <prompt>", "non-interactive print mode").option("--json", "output NDJSON events on stdout (print mode only)").option("-r, --resume <sessionId>", "resume a previous session").action(async (opts) => {
+program.name("star").description("Star CLI \u2014 an AI agent command-line interface").version(VERSION).option("-m, --model <model>", "model to use").option("--permission-mode <mode>", "permission mode: ask | auto | readonly | yolo | plan").option("-p, --print <prompt>", "non-interactive print mode").option("--json", "output NDJSON events on stdout (print mode only)").option(
+  "--image <path>",
+  "attach an image file (png/jpg/jpeg/gif/webp, max 5MB); repeatable",
+  (value, previous) => [...previous, value],
+  []
+).option("-r, --resume [sessionId]", "resume a previous session (lists sessions when no id given)").option("-c, --continue", "continue the most recent session for the current directory").option(
+  "--clear-sessions [scope]",
+  "delete stored sessions for the current directory ('all' deletes every session) and exit"
+).action(async (opts) => {
   const cwd = process.cwd();
   if (opts.json && opts.print === void 0) {
     console.error(
@@ -4413,6 +4020,32 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
     );
     process.exit(1);
   }
+  if (opts.resume !== void 0 && opts.continue) {
+    console.error("Options --resume and --continue are mutually exclusive: pick one.");
+    process.exit(1);
+  }
+  if (opts.resume === true) {
+    const entries = await listSessionEntries(cwd);
+    if (entries.length === 0) {
+      console.error("No sessions found for this directory.");
+    } else {
+      console.log(formatSessionEntries(entries));
+    }
+    process.exit(0);
+  }
+  if (opts.clearSessions !== void 0) {
+    const scope = opts.clearSessions;
+    if (scope !== true && scope !== "all") {
+      console.error(`Invalid scope: ${scope}. Use --clear-sessions or --clear-sessions all.`);
+      process.exit(1);
+    }
+    const all = scope === "all";
+    const removed = await clearSessions(all ? void 0 : cwd);
+    console.log(
+      all ? `Deleted ${removed} session(s) across all directories.` : `Deleted ${removed} session(s) for this directory.`
+    );
+    process.exit(0);
+  }
   let config;
   try {
     config = loadConfigSync(cwd, { model: opts.model, permissionMode: opts.permissionMode });
@@ -4429,13 +4062,28 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
   }
   let sessionStore = null;
   let resumed = null;
-  if (opts.resume) {
-    resumed = await resumeSession(opts.resume);
-    if (!resumed) {
+  let resumeId = null;
+  if (typeof opts.resume === "string") {
+    resumeId = await resolveSessionId(opts.resume);
+    if (!resumeId) {
       console.error(`Session not found: ${opts.resume}`);
       process.exit(1);
     }
-    sessionStore = await SessionStore.open(opts.resume);
+  } else if (opts.continue) {
+    const latest = await findLatestSession(cwd);
+    if (latest) {
+      resumeId = latest.id;
+    } else {
+      process.stderr.write("No previous session for this directory \u2014 starting a new session.\n");
+    }
+  }
+  if (resumeId) {
+    resumed = await resumeSession(resumeId);
+    if (!resumed) {
+      console.error(`Session not found: ${resumeId}`);
+      process.exit(1);
+    }
+    sessionStore = await SessionStore.open(resumeId);
   } else if (!opts.print) {
     sessionStore = await SessionStore.create(cwd, modelName);
   }
@@ -4448,9 +4096,18 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
   }
   if (resumed) {
     await loop.loadMessages(resumed.messages);
+    if (sessionStore) {
+      hydrateSnapshots(await loadSessionSnapshots(sessionStore.dir));
+    }
   }
   if (opts.print) {
-    process.exitCode = await printMode(loop, opts.print, cwd, Boolean(opts.json));
+    process.exitCode = await printMode(
+      loop,
+      opts.print,
+      cwd,
+      Boolean(opts.json),
+      opts.image ?? []
+    );
     return;
   }
   renderRepl(loop, {