@cryer/star-cli 0.1.0 → 0.1.2

package/dist/main.js

@@ -124,8 +124,89 @@ function compactMessages(messages, maxTokens) {
   };
 }
 
+// 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,
@@ -138,6 +219,9 @@ var DANGEROUS_COMMAND_PATTERNS = [
   /\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];
@@ -163,10 +247,13 @@ function isSensitivePath(p) {
   }
   return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
 }
-function checkPermission(mode, req, ctx) {
+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 && DANGEROUS_COMMAND_PATTERNS.some((pattern) => pattern.test(command))) {
+  if (req.toolName === "bash" && command !== void 0 && isDangerousCommand(command)) {
     return "deny";
   }
   if (FILE_TOOLS.has(req.toolName) && filePath !== void 0) {
@@ -186,13 +273,78 @@ function checkPermission(mode, req, ctx) {
   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;
@@ -204,15 +356,44 @@ var AgentLoop = class {
     return this.messages;
   }
   async loadMessages(messages) {
-    this.messages = 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) {
+  async *stream(input, signal, opts) {
+    this.syncSystemMessage();
     const userMessage = { role: "user", content: input };
     this.messages.push(userMessage);
-    await this.persist(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++) {
@@ -228,6 +409,8 @@ var AgentLoop = class {
           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;
@@ -239,6 +422,7 @@ var AgentLoop = class {
           }
         }
       } catch (error) {
+        if (signal.aborted) return;
         yield { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
         return;
       }
@@ -258,35 +442,77 @@ var AgentLoop = class {
       this.messages.push(assistantMessage);
       await this.persist(assistantMessage);
       if (toolCalls.length === 0) return;
-      for (const call of toolCalls) {
-        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);
-        yield {
-          type: "tool-result",
-          id: call.id,
-          name: call.name,
-          content: result.content,
-          isError: result.isError
-        };
+      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) {
@@ -308,17 +534,20 @@ ${summary}`
     }
   }
   async *streamOnce(aiTools, signal) {
-    const { streamChat } = await import("./stream-FJQZGETE.js");
+    const { streamChat } = await import("./stream-Y55NRF2S.js");
     yield* streamChat({
       model: this.opts.model,
       messages: this.messages,
       tools: aiTools,
-      abortSignal: signal
+      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
@@ -335,17 +564,23 @@ ${summary}`
     const decision = checkPermission(
       config.permissionMode,
       { toolName: call.name, args: call.args, level: tool.permission },
-      { cwd }
+      { cwd },
+      config.permissions.allow
     );
     if (decision === "deny") {
       return { content: `Permission denied for tool "${call.name}".`, isError: true };
     }
     if (decision === "ask") {
-      const approved = this.confirmHandler ? await this.confirmHandler({
-        toolName: call.name,
-        args: call.args,
-        level: tool.permission
-      }) : false;
+      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 };
       }
@@ -368,100 +603,36 @@ ${summary}`
   }
 };
 
-// src/cli/repl.tsx
-import { Box as Box7, render, useApp, useInput as useInput3 } from "ink";
-import { useCallback, useEffect, useMemo, useRef as useRef2, useState as useState2 } from "react";
-
-// src/llm/provider.ts
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-
-// src/llm/registry.ts
-function listModels(config) {
-  return config.models;
-}
-function resolveModelConfig(config, modelName) {
-  const name = modelName ?? config.defaultModel;
-  const model = config.models.find((m) => m.name === name);
-  if (!model) {
-    const available = config.models.map((m) => m.name).join(", ") || "(none)";
-    throw new Error(`Model "${name}" not found. Available models: ${available}`);
-  }
-  return model;
-}
-
-// src/llm/provider.ts
-function resolveApiKey(provider) {
-  const fromEnv = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : void 0;
-  const apiKey = fromEnv ?? provider.apiKey;
-  if (!apiKey) {
-    const hint = provider.apiKeyEnv ? `set ${provider.apiKeyEnv} or configure apiKey` : "configure apiKey";
-    throw new Error(`Missing API key for provider "${provider.name}": ${hint}`);
-  }
-  return apiKey;
-}
-function createModel(config, modelName) {
-  const modelConfig = resolveModelConfig(config, modelName);
-  const provider = config.providers.find((p) => p.name === modelConfig.provider);
-  if (!provider) {
-    const available = config.providers.map((p) => p.name).join(", ") || "(none)";
-    throw new Error(
-      `Provider "${modelConfig.provider}" for model "${modelConfig.name}" not found. Available providers: ${available}`
-    );
-  }
-  const apiKey = resolveApiKey(provider);
-  switch (provider.protocol) {
-    case "anthropic":
-      return createAnthropic({
-        baseURL: provider.baseURL,
-        apiKey,
-        headers: provider.headers
-      })(modelConfig.model);
-    case "openai-compatible":
-      return createOpenAICompatible({
-        name: provider.name,
-        baseURL: provider.baseURL,
-        apiKey,
-        headers: provider.headers
-      })(modelConfig.model);
-    case "openai-responses":
-      return createOpenAI({
-        baseURL: provider.baseURL,
-        apiKey,
-        headers: provider.headers
-      }).responses(modelConfig.model);
+// src/cli/format.ts
+function summarizeArgs(args, maxLength = 120) {
+  let json;
+  try {
+    json = JSON.stringify(args) ?? String(args);
+  } catch {
+    json = String(args);
   }
+  return json.length > maxLength ? `${json.slice(0, maxLength)}...` : json;
 }
-
-// src/session/store.ts
-import fs from "fs/promises";
-import path3 from "path";
-
-// src/config/paths.ts
-import os from "os";
-import path2 from "path";
-function starHome() {
-  return process.env.STAR_HOME ?? path2.join(os.homedir(), ".star-cli");
-}
-function globalConfigPath() {
-  return path2.join(starHome(), "config.toml");
-}
-function sessionsDir() {
-  return path2.join(starHome(), "sessions");
+function previewLines(text, maxLines = 10) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return { text, truncated: false };
+  return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
 }
-function projectConfigPath(cwd) {
-  return path2.join(cwd, ".star", "config.toml");
+function splitCommittableLines(text, minCompleteLines) {
+  const lastNewline = text.lastIndexOf("\n");
+  if (lastNewline < 0) return null;
+  const complete = text.slice(0, lastNewline);
+  const completeLines = complete.split("\n").length;
+  if (completeLines < minCompleteLines) return null;
+  return { committed: complete, rest: text.slice(lastNewline + 1) };
 }
-
-// src/session/store.ts
-function generateId(now) {
-  const pad = (n) => String(n).padStart(2, "0");
-  const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
-  const suffix = Math.random().toString(16).slice(2, 8).padEnd(6, "0");
-  return `${stamp}-${suffix}`;
+function formatStreamError(error) {
+  if (error.message.includes("Unexpected end of JSON input")) {
+    return `${error.message} (response stream was truncated \u2014 try again)`;
+  }
+  return error.message;
 }
-function messageText(message) {
+function coreMessageText(message) {
   const content = message.content;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -469,90 +640,477 @@ function messageText(message) {
   }
   return "";
 }
-var SessionStore = class _SessionStore {
-  id;
-  dir;
-  pendingMeta = null;
-  initialized = false;
-  constructor(id) {
-    this.id = id;
-    this.dir = path3.join(sessionsDir(), id);
-  }
-  metaPath() {
-    return path3.join(this.dir, "meta.json");
-  }
-  messagesPath() {
-    return path3.join(this.dir, "messages.jsonl");
-  }
-  static async create(cwd, model) {
-    const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
-    store.pendingMeta = { cwd, model, createdAt: Date.now() };
-    return store;
-  }
-  static async open(id) {
-    const store = new _SessionStore(id);
-    try {
-      const raw = await fs.readFile(store.metaPath(), "utf8");
-      const meta = JSON.parse(raw);
-      if (meta.id !== id) return null;
-      store.initialized = true;
-      return store;
-    } catch {
-      return null;
+function buildDisplayMessages(messages) {
+  const display = [];
+  let collapsed = 0;
+  for (const message of messages) {
+    if (message.role === "user" || message.role === "assistant") {
+      const text = coreMessageText(message);
+      if (text) {
+        display.push({ id: display.length, role: message.role, text });
+      } else {
+        collapsed++;
+      }
+    } else if (message.role === "tool") {
+      collapsed++;
     }
   }
-  static async list(cwd) {
-    let entries;
-    try {
-      entries = await fs.readdir(sessionsDir());
-    } catch {
-      return [];
+  if (collapsed > 0) {
+    display.push({
+      id: display.length,
+      role: "system",
+      text: `\u5DF2\u6062\u590D ${collapsed} \u6761\u5386\u53F2\u6D88\u606F`
+    });
+  }
+  return display;
+}
+
+// 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;
     }
-    const metas = [];
     for (const entry of entries) {
-      try {
-        const raw = await fs.readFile(path3.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 {
+      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 {
+        }
       }
     }
-    return metas.sort((a, b) => b.updatedAt - a.updatedAt);
   }
-  async ensureInitialized() {
-    if (this.initialized) return;
-    const pending = this.pendingMeta;
-    if (!pending) {
-      this.initialized = true;
-      return;
-    }
-    await fs.mkdir(this.dir, { recursive: true });
-    const meta = {
-      id: this.id,
-      title: "",
-      model: pending.model,
-      cwd: pending.cwd,
+  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
+var MAX_MENTION_BYTES = 100 * 1024;
+var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\]*|[A-Za-z0-9._\-/\\]+)/g;
+function parseMentions(text) {
+  const mentions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ranges = [];
+  for (const match of text.matchAll(MENTION_RE)) {
+    const mention = match[1];
+    const full = match[0];
+    if (mention === void 0 || full === void 0) continue;
+    ranges.push([match.index, match.index + full.length]);
+    if (!seen.has(mention)) {
+      seen.add(mention);
+      mentions.push(mention);
+    }
+  }
+  if (ranges.length === 0) {
+    return { cleanText: text, mentions };
+  }
+  let clean = "";
+  let last = 0;
+  for (const [start, end] of ranges) {
+    clean += text.slice(last, start);
+    last = end;
+  }
+  clean += text.slice(last);
+  const cleanText = clean.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return { cleanText, mentions };
+}
+function isBinaryContent(buf) {
+  const probe = buf.subarray(0, 8e3);
+  return probe.includes(0);
+}
+async function resolveMentions(text, cwd) {
+  const { cleanText, mentions } = parseMentions(text);
+  if (mentions.length === 0) {
+    return { input: text, attached: [], skipped: [] };
+  }
+  const blocks = [];
+  const attached = [];
+  const skipped = [];
+  for (const mention of mentions) {
+    const abs = path4.resolve(cwd, mention);
+    if (isSensitivePath2(abs)) {
+      skipped.push({ path: mention, reason: "sensitive file" });
+      continue;
+    }
+    const st = await stat2(abs).catch(() => null);
+    if (!st) {
+      skipped.push({ path: mention, reason: "file not found" });
+      continue;
+    }
+    if (st.isDirectory()) {
+      skipped.push({ path: mention, reason: "is a directory" });
+      continue;
+    }
+    if (st.size > MAX_MENTION_BYTES) {
+      skipped.push({ path: mention, reason: `exceeds ${MAX_MENTION_BYTES / 1024}KB limit` });
+      continue;
+    }
+    const buf = await readFile2(abs).catch(() => null);
+    if (!buf) {
+      skipped.push({ path: mention, reason: "unreadable" });
+      continue;
+    }
+    if (isBinaryContent(buf)) {
+      skipped.push({ path: mention, reason: "binary file" });
+      continue;
+    }
+    attached.push(mention);
+    blocks.push(`--- @${mention} ---
+${buf.toString("utf8")}
+--- end ---`);
+  }
+  const input = [cleanText, ...blocks].filter((s) => s.length > 0).join("\n\n") || text;
+  return { input, attached, skipped };
+}
+
+// src/cli/print-json.ts
+function eventToJsonLine(event) {
+  switch (event.type) {
+    case "finish":
+      return null;
+    case "error":
+      return JSON.stringify({ type: "error", error: { message: event.error.message } });
+    default:
+      return JSON.stringify(event);
+  }
+}
+var UsageTracker = class {
+  requests = 0;
+  promptTokens = 0;
+  completionTokens = 0;
+  totalTokens = 0;
+  add(usage) {
+    if (!usage) return;
+    this.requests += 1;
+    this.promptTokens += usage.promptTokens;
+    this.completionTokens += usage.completionTokens;
+    this.totalTokens += usage.totalTokens;
+  }
+  get totals() {
+    return {
+      requests: this.requests,
+      promptTokens: this.promptTokens,
+      completionTokens: this.completionTokens,
+      totalTokens: this.totalTokens
+    };
+  }
+  toJsonLine() {
+    if (this.requests === 0) return null;
+    return JSON.stringify({
+      type: "usage",
+      requests: this.requests,
+      promptTokens: this.promptTokens,
+      completionTokens: this.completionTokens,
+      totalTokens: this.totalTokens
+    });
+  }
+};
+
+// 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";
+
+// src/config/save.ts
+import fs from "fs";
+import path6 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 = {};
+  try {
+    const content = await fs.promises.readFile(filePath, "utf8");
+    raw = parse(content);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const permissions = typeof raw.permissions === "object" && raw.permissions !== null ? raw.permissions : {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  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.writeFile(filePath, stringify(raw), "utf8");
+  return true;
+}
+async function savePermissionMode(mode) {
+  const filePath = globalConfigPath();
+  let raw = {};
+  try {
+    const content = await fs.promises.readFile(filePath, "utf8");
+    raw = parse(content);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  raw.permissionMode = mode;
+  await fs.promises.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, stringify(raw), "utf8");
+}
+
+// src/llm/provider.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+// src/llm/registry.ts
+function listModels(config) {
+  return config.models;
+}
+function resolveModelConfig(config, modelName) {
+  const name = modelName ?? config.defaultModel;
+  const model = config.models.find((m) => m.name === name);
+  if (!model) {
+    const available = config.models.map((m) => m.name).join(", ") || "(none)";
+    throw new Error(`Model "${name}" not found. Available models: ${available}`);
+  }
+  return model;
+}
+
+// src/llm/provider.ts
+function resolveApiKey(provider) {
+  const fromEnv = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : void 0;
+  const apiKey = fromEnv ?? provider.apiKey;
+  if (!apiKey) {
+    const hint = provider.apiKeyEnv ? `set ${provider.apiKeyEnv} or configure apiKey` : "configure apiKey";
+    throw new Error(`Missing API key for provider "${provider.name}": ${hint}`);
+  }
+  return apiKey;
+}
+function createModel(config, modelName) {
+  const modelConfig = resolveModelConfig(config, modelName);
+  const provider = config.providers.find((p) => p.name === modelConfig.provider);
+  if (!provider) {
+    const available = config.providers.map((p) => p.name).join(", ") || "(none)";
+    throw new Error(
+      `Provider "${modelConfig.provider}" for model "${modelConfig.name}" not found. Available providers: ${available}`
+    );
+  }
+  const apiKey = resolveApiKey(provider);
+  switch (provider.protocol) {
+    case "anthropic":
+      return createAnthropic({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers
+      })(modelConfig.model);
+    case "openai-compatible":
+      return createOpenAICompatible({
+        name: provider.name,
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers
+      })(modelConfig.model);
+    case "openai-responses":
+      return createOpenAI({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers
+      }).responses(modelConfig.model);
+  }
+}
+
+// src/session/store.ts
+import fs2 from "fs/promises";
+import path7 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())}`;
+  const suffix = Math.random().toString(16).slice(2, 8).padEnd(6, "0");
+  return `${stamp}-${suffix}`;
+}
+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 "";
+}
+var SessionStore = class _SessionStore {
+  id;
+  dir;
+  pendingMeta = null;
+  initialized = false;
+  constructor(id) {
+    this.id = id;
+    this.dir = path7.join(sessionsDir(), id);
+  }
+  metaPath() {
+    return path7.join(this.dir, "meta.json");
+  }
+  messagesPath() {
+    return path7.join(this.dir, "messages.jsonl");
+  }
+  static async create(cwd, model) {
+    const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
+    store.pendingMeta = { cwd, model, createdAt: Date.now() };
+    return store;
+  }
+  static async open(id) {
+    const store = new _SessionStore(id);
+    let raw;
+    try {
+      raw = await fs2.readFile(store.metaPath(), "utf8");
+    } catch {
+      return null;
+    }
+    try {
+      const meta = JSON.parse(raw);
+      if (meta.id !== id) return null;
+    } catch {
+      debugWarn(`session ${id}: corrupt meta.json, using defaults`);
+    }
+    store.initialized = true;
+    return store;
+  }
+  static async list(cwd) {
+    let entries;
+    try {
+      entries = await fs2.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 meta = JSON.parse(raw);
+        if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) metas.push(meta);
+      } catch {
+      }
+    }
+    return metas.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    const pending = this.pendingMeta;
+    if (!pending) {
+      this.initialized = true;
+      return;
+    }
+    await fs2.mkdir(this.dir, { recursive: true });
+    const meta = {
+      id: this.id,
+      title: "",
+      model: pending.model,
+      cwd: pending.cwd,
       createdAt: pending.createdAt,
       updatedAt: pending.createdAt
     };
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
     this.initialized = true;
   }
   async append(message) {
     await this.ensureInitialized();
-    await fs.appendFile(this.messagesPath(), `${JSON.stringify(message)}
+    await fs2.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 fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.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}
+` : "");
+    const meta = await this.meta();
+    meta.updatedAt = Date.now();
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
   async messages() {
     let raw;
     try {
-      raw = await fs.readFile(this.messagesPath(), "utf8");
+      raw = await fs2.readFile(this.messagesPath(), "utf8");
     } catch {
       return [];
     }
@@ -563,21 +1121,31 @@ var SessionStore = class _SessionStore {
       try {
         messages.push(JSON.parse(trimmed));
       } catch {
+        debugWarn(`session ${this.id}: skipping corrupt messages.jsonl line`);
       }
     }
     return messages;
   }
+  fallbackMeta() {
+    const now = Date.now();
+    return { id: this.id, title: "", model: "", cwd: "", createdAt: now, updatedAt: now };
+  }
   async meta() {
     await this.ensureInitialized();
-    const raw = await fs.readFile(this.metaPath(), "utf8");
-    return JSON.parse(raw);
+    try {
+      const raw = await fs2.readFile(this.metaPath(), "utf8");
+      return JSON.parse(raw);
+    } catch {
+      debugWarn(`session ${this.id}: unreadable meta.json, using defaults`);
+      return this.fallbackMeta();
+    }
   }
   async setTitle(title) {
     await this.ensureInitialized();
     const meta = await this.meta();
     meta.title = title;
     meta.updatedAt = Date.now();
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
   async addUsage(delta) {
     await this.ensureInitialized();
@@ -593,7 +1161,7 @@ var SessionStore = class _SessionStore {
     usage.completionTokens += delta.completionTokens;
     usage.totalTokens += delta.totalTokens;
     meta.usage = usage;
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
 };
 
@@ -601,7 +1169,11 @@ var SessionStore = class _SessionStore {
 async function resumeSession(id) {
   const store = await SessionStore.open(id);
   if (!store) return null;
-  const [meta, messages] = await Promise.all([store.meta(), store.messages()]);
+  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 };
 }
 function relativeTime(timestamp) {
@@ -624,20 +1196,67 @@ function formatSessionList(metas) {
   }).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/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 path4 from "path";
+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(path4.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path8.delimiter)) {
     if (!dir || exclude?.(dir)) {
       continue;
     }
-    const full = path4.join(dir, exe);
+    const full = path8.join(dir, exe);
     if (existsSync(full)) {
       return full;
     }
@@ -655,7 +1274,7 @@ function resolveShell() {
   }
   const gitExe = findOnPath("git.exe");
   if (gitExe) {
-    const sibling = path4.join(path4.dirname(path4.dirname(gitExe)), "bin", "bash.exe");
+    const sibling = path8.join(path8.dirname(path8.dirname(gitExe)), "bin", "bash.exe");
     if (existsSync(sibling)) {
       return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
     }
@@ -675,7 +1294,10 @@ function resolveShell() {
 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")
+  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) {
@@ -700,10 +1322,23 @@ ${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.",
+  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) => {
@@ -761,9 +1396,119 @@ Command timed out after ${timeoutSeconds}s`,
   }
 };
 
+// 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, writeFile } from "fs/promises";
-import path5 from "path";
+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"),
@@ -777,120 +1522,49 @@ var editFileTool = {
   permission: "write",
   parameters: schema2,
   async execute(args, ctx) {
-    const filePath = path5.resolve(ctx.cwd, args.path);
+    const filePath = path9.resolve(ctx.cwd, args.path);
     let content;
     try {
-      content = await readFile(filePath, "utf8");
+      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);
-    await writeFile(filePath, updated, "utf8");
-    return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
-  }
-};
-
-// src/tools/fs/glob.ts
-import path7 from "path";
-import { z as z3 } from "zod";
-
-// src/tools/fs/util.ts
-import { readdir, stat } from "fs/promises";
-import path6 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 = path6.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;
+    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" : ""}` };
   }
-  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 = path6.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/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(
@@ -904,7 +1578,7 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path7.resolve(ctx.cwd, args.path ?? ".");
+    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) {
@@ -915,8 +1589,8 @@ var globTool = {
 };
 
 // src/tools/fs/grep.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import path8 from "path";
+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({
@@ -937,12 +1611,12 @@ var grepTool = {
     } catch (err) {
       return { content: `Invalid regular expression: ${err.message}`, isError: true };
     }
-    const root = path8.resolve(ctx.cwd, args.path ?? ".");
+    const root = path11.resolve(ctx.cwd, args.path ?? ".");
     let files;
     try {
-      const st = await stat2(root);
+      const st = await stat3(root);
       if (st.isFile()) {
-        files = [{ abs: root, rel: path8.basename(root), mtimeMs: st.mtimeMs }];
+        files = [{ abs: root, rel: path11.basename(root), mtimeMs: st.mtimeMs }];
       } else {
         files = await walkFiles(root);
       }
@@ -958,7 +1632,7 @@ var grepTool = {
     outer: for (const file of files) {
       let buf;
       try {
-        buf = await readFile2(file.abs);
+        buf = await readFile4(file.abs);
       } catch {
         continue;
       }
@@ -988,8 +1662,8 @@ var grepTool = {
 };
 
 // src/tools/fs/read.ts
-import { readFile as readFile3, stat as stat3 } from "fs/promises";
-import path9 from "path";
+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;
@@ -1004,18 +1678,18 @@ var readFileTool = {
   permission: "read",
   parameters: schema5,
   async execute(args, ctx) {
-    const filePath = path9.resolve(ctx.cwd, args.path);
+    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 stat3(filePath).catch(() => null);
+    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 readFile3(filePath, "utf8");
+    const raw = await readFile5(filePath, "utf8");
     const lines = raw.split("\n");
     const start = args.offset ?? 1;
     const limit = args.limit ?? DEFAULT_LIMIT;
@@ -1049,8 +1723,8 @@ var readFileTool = {
 };
 
 // src/tools/fs/write.ts
-import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import path10 from "path";
+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"),
@@ -1062,32 +1736,84 @@ var writeFileTool = {
   permission: "write",
   parameters: schema6,
   async execute(args, ctx) {
-    const filePath = path10.resolve(ctx.cwd, args.path);
+    const filePath = path13.resolve(ctx.cwd, args.path);
+    const snapshot = await captureSnapshot(filePath, "write_file");
     try {
-      await mkdir(path10.dirname(filePath), { recursive: true });
-      await writeFile2(filePath, args.content, "utf8");
+      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/todo.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import path11 from "path";
+// src/tools/tasks.ts
 import { z as z7 } from "zod";
-var todoItemSchema = z7.object({
-  id: z7.number().int(),
-  title: z7.string(),
-  status: z7.enum(["pending", "in_progress", "done"])
+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.` });
+  }
+};
+
+// 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 = z7.object({
-  todos: z7.array(todoItemSchema).describe("The full todo list, replacing the current one")
+var writeSchema = z8.object({
+  todos: z8.array(todoItemSchema).describe("The full todo list, replacing the current one")
 });
-var readSchema = z7.object({});
+var readSchema = z8.object({});
 function fileFor(cwd) {
-  return path11.join(cwd, ".star", "todos.json");
+  return path14.join(cwd, ".star", "todos.json");
 }
 var TodoStore = class {
   items = /* @__PURE__ */ new Map();
@@ -1103,7 +1829,7 @@ var TodoStore = class {
   async load(cwd) {
     let raw;
     try {
-      raw = await readFile4(fileFor(cwd), "utf8");
+      raw = await readFile6(fileFor(cwd), "utf8");
     } catch {
       return;
     }
@@ -1116,8 +1842,8 @@ var TodoStore = class {
     }
   }
   async save(cwd) {
-    await mkdir2(path11.join(cwd, ".star"), { recursive: true });
-    await writeFile3(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
+    await mkdir3(path14.join(cwd, ".star"), { recursive: true });
+    await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
 `);
   }
 };
@@ -1169,13 +1895,13 @@ function createTodoTools(store = defaultStore) {
 }
 
 // src/tools/web/fetch.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var DEFAULT_MAX_CHARS = 2e4;
 var MAX_BYTES = 2 * 1024 * 1024;
 var TIMEOUT_MS = 3e4;
-var schema7 = z8.object({
-  url: z8.string().describe("The http(s) URL to fetch"),
-  maxChars: z8.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
+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) => {
@@ -1302,6 +2028,121 @@ var webFetchTool = {
   }
 };
 
+// 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 });
+    }
+  }
+  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 { content: lines.join("\n") };
+  }
+};
+
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
@@ -1314,6 +2155,10 @@ var ToolRegistry = class {
       grepTool,
       bashTool,
       webFetchTool,
+      webSearchTool,
+      taskListTool,
+      taskOutputTool,
+      taskKillTool,
       ...createTodoTools()
     ]) {
       this.register(tool);
@@ -1342,6 +2187,155 @@ function createDefaultRegistry() {
   return registry;
 }
 
+// src/version.ts
+import fs3 from "fs";
+import path15 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"));
+    if (typeof pkg === "object" && pkg !== null) {
+      const version = pkg.version;
+      if (typeof version === "string") return version;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var VERSION = readPackageVersion();
+
+// src/cli/commands/actions.ts
+import fs4 from "fs/promises";
+import path16 from "path";
+var MIN_COMPACT_MESSAGES = 4;
+async function compactSession(opts) {
+  const { backend, sessionStore, config, model } = opts;
+  if (!(backend instanceof AgentLoop)) {
+    return { message: "Current backend does not support compaction.", compacted: false };
+  }
+  const messages = [...backend.getMessages()];
+  if (messages.length < MIN_COMPACT_MESSAGES) {
+    return {
+      message: `Nothing to compact: history has only ${messages.length} message(s).`,
+      compacted: false
+    };
+  }
+  const beforeTokens = estimateTokens(messages);
+  const compacted = compactMessages(messages, config.contextMaxTokens);
+  if (!compacted.compacted) {
+    return {
+      message: `Nothing to compact: ~${beforeTokens} estimated tokens, below the limit of ${config.contextMaxTokens}.`,
+      compacted: false
+    };
+  }
+  const next = await applyCompactionSummary(messages, compacted, config, model);
+  await backend.loadMessages(next);
+  await sessionStore?.replaceMessages(next);
+  const afterTokens = estimateTokens(next);
+  return {
+    message: `Compacted context: ${messages.length} -> ${next.length} messages (~${beforeTokens} -> ~${afterTokens} estimated tokens).`,
+    compacted: true,
+    messages: next
+  };
+}
+async function applyCompactionSummary(original, compacted, config, model) {
+  if (config.contextCompaction !== "summary" || !model) {
+    return compacted.messages;
+  }
+  const headCount = compacted.messages[0]?.role === "system" ? 1 : 0;
+  const dropped = original.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 function exportSession(opts) {
+  const { backend, sessionStore, cwd, arg } = opts;
+  if (!(backend instanceof AgentLoop)) {
+    return "Current backend does not support exporting sessions.";
+  }
+  const messages = [...backend.getMessages()];
+  if (messages.length === 0) {
+    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 existed = await fileExists(target);
+  await fs4.mkdir(path16.dirname(target), { recursive: true });
+  await fs4.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);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function renderSessionMarkdown(sessionId, messages, exportedAt = /* @__PURE__ */ new Date()) {
+  const lines = [
+    `# Star CLI Session ${sessionId}`,
+    "",
+    `_Exported at ${exportedAt.toISOString()}_`,
+    ""
+  ];
+  for (const message of messages) {
+    lines.push(`## ${roleHeading(message.role)}`, "");
+    lines.push(...renderContent(message), "");
+  }
+  return lines.join("\n");
+}
+function roleHeading(role) {
+  return role.charAt(0).toUpperCase() + role.slice(1);
+}
+function renderContent(message) {
+  const content = message.content;
+  if (typeof content === "string") return [content];
+  const lines = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      lines.push(part.text, "");
+    } else if (part.type === "tool-call") {
+      lines.push(
+        `**Tool call: ${part.toolName}**`,
+        "",
+        "```json",
+        JSON.stringify(part.args, null, 2),
+        "```",
+        ""
+      );
+    } else if (part.type === "tool-result") {
+      lines.push(
+        `**Tool result: ${part.toolName}**`,
+        "",
+        "```",
+        stringifyPart(part.result),
+        "```",
+        ""
+      );
+    } else if (part.type === "reasoning") {
+      lines.push(part.text, "");
+    } else {
+      lines.push(`[${part.type}]`, "");
+    }
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function stringifyPart(value) {
+  return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+
 // src/cli/commands/builtin.ts
 function registerBuiltinCommands(registry) {
   registry.register({
@@ -1405,30 +2399,498 @@ ${lines.join("\n")}`);
       }
     }
   });
-  registry.register({
-    name: "todo",
-    description: "Show the current todo list",
-    usage: "/todo",
-    async run(_args, ctx) {
-      ctx.addSystemMessage(await ctx.showTodos());
+  registry.register({
+    name: "todo",
+    description: "Show the current todo list",
+    usage: "/todo",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.showTodos());
+    }
+  });
+  registry.register({
+    name: "tasks",
+    description: "List background shell tasks",
+    usage: "/tasks",
+    run(_args, ctx) {
+      ctx.addSystemMessage(ctx.listTasks());
+    }
+  });
+  registry.register({
+    name: "cost",
+    description: "Show API token usage for this session",
+    usage: "/cost",
+    run(_args, ctx) {
+      ctx.addSystemMessage(ctx.showUsage());
+    }
+  });
+  registry.register({
+    name: "config",
+    description: "Show the current configuration",
+    usage: "/config",
+    run(_args, ctx) {
+      ctx.addSystemMessage(ctx.describeConfig());
+    }
+  });
+  registry.register({
+    name: "compact",
+    description: "Compact the conversation history to free up context",
+    usage: "/compact",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.compactContext());
+    }
+  });
+  registry.register({
+    name: "export",
+    description: "Export the current session to a Markdown file",
+    usage: "/export [path]",
+    async run(args, ctx) {
+      ctx.addSystemMessage(await ctx.exportSession(args));
+    }
+  });
+  registry.register({
+    name: "permission",
+    description: "Show or set the global permission mode (ask | auto | readonly | yolo)",
+    usage: "/permission [ask|auto|readonly|yolo]",
+    async run(args, ctx) {
+      ctx.addSystemMessage(await ctx.permissionMode(args.trim()));
+    }
+  });
+  registry.register({
+    name: "plan",
+    description: "Toggle plan mode: read-only research, then approve the plan before executing",
+    usage: "/plan",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.planMode());
+    }
+  });
+  registry.register({
+    name: "undo",
+    description: "Undo the last conversation turn: revert its file changes (write_file/edit_file) and retract its messages",
+    usage: "/undo",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.undo());
+    }
+  });
+  registry.register({
+    name: "init",
+    description: "Generate an AGENTS.md for the current project",
+    usage: "/init [force]",
+    async run(args, ctx) {
+      ctx.addSystemMessage(await ctx.initProject(args));
+    }
+  });
+  registry.register({
+    name: "doctor",
+    description: "Run environment and configuration checks",
+    usage: "/doctor",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.runDoctor());
+    }
+  });
+}
+
+// src/cli/commands/custom.ts
+import { readFileSync, readdirSync } from "fs";
+import path17 from "path";
+var NAME_PATTERN = /^[a-z0-9-]+$/;
+var DESCRIPTION_PATTERN = /^<!--\s*description:\s*(.+?)\s*-->\s*$/;
+var DEFAULT_DESCRIPTION = "Custom prompt command";
+function parseCommandFile(filePath, name) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = raw.split(/\r?\n/);
+  let description = DEFAULT_DESCRIPTION;
+  const first = lines[0] ?? "";
+  const match = first.match(DESCRIPTION_PATTERN);
+  if (match) {
+    description = match[1] ?? DEFAULT_DESCRIPTION;
+    lines.shift();
+    if (lines[0] !== void 0 && lines[0].trim() === "") lines.shift();
+  }
+  const template = lines.join("\n").trim();
+  if (!template) return null;
+  return { name, description, template, source: filePath };
+}
+function scanDir(dir, into) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries.sort()) {
+    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);
+    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);
+  return [...byName.values()];
+}
+function registerCustomCommands(registry, cwd, home) {
+  const registered = [];
+  for (const command of loadCustomCommands(cwd, home)) {
+    if (registry.get(command.name)) continue;
+    registry.register({
+      name: command.name,
+      description: command.description,
+      usage: `/${command.name} [args]`,
+      run(args, ctx) {
+        const prompt = command.template.split("$ARGUMENTS").join(args);
+        if (ctx.submitPrompt) {
+          return ctx.submitPrompt(prompt);
+        }
+        ctx.addSystemMessage(`/${command.name}: this context cannot submit prompts to the model.`);
+      }
+    });
+    registered.push(command);
+  }
+  return registered;
+}
+
+// src/cli/commands/doctor.ts
+import fs5 from "fs/promises";
+import path18 from "path";
+var MIN_NODE_MAJOR = 20;
+var REGISTRY_URL = "https://registry.npmjs.org/";
+var REGISTRY_TIMEOUT_MS = 5e3;
+async function defaultFetcher(url, timeoutMs) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+  return res.ok;
+}
+function nodeMajor(version) {
+  const match = /^v?(\d+)/.exec(version);
+  return match ? Number.parseInt(match[1] ?? "", 10) : null;
+}
+async function pathExists(target) {
+  try {
+    await fs5.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveApiKeyConfigured(config, providerName, env) {
+  const provider = config.providers.find((p) => p.name === providerName);
+  if (!provider) return null;
+  const fromEnv = provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0;
+  return Boolean(fromEnv ?? provider.apiKey);
+}
+async function runDoctor(opts) {
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? starHome();
+  const checks = [];
+  const version = opts.nodeVersion ?? process.version;
+  const major = nodeMajor(version);
+  const nodeOk = major !== null && major >= MIN_NODE_MAJOR;
+  checks.push({
+    name: "Node.js version",
+    ok: nodeOk,
+    detail: nodeOk ? `${version} (>= ${MIN_NODE_MAJOR} required)` : `${version} \u2014 Node.js >= ${MIN_NODE_MAJOR} is required`
+  });
+  if (opts.shellLabel !== void 0 || opts.shellPath !== void 0) {
+    checks.push({
+      name: "Shell for bash tool",
+      ok: true,
+      detail: `${opts.shellLabel ?? "unknown"}${opts.shellPath ? ` (${opts.shellPath})` : ""}`
+    });
+  } else {
+    const spec = resolveShell();
+    checks.push({
+      name: "Shell for bash tool",
+      ok: true,
+      detail: `${spec.label} (${spec.shell})`
+    });
+  }
+  const configPath = path18.join(home, "config.toml");
+  const configExists = await pathExists(configPath);
+  checks.push({
+    name: "STAR_HOME / config",
+    ok: configExists,
+    detail: configExists ? `STAR_HOME=${home}, config.toml found at ${configPath}` : `STAR_HOME=${home}, config.toml missing at ${configPath}`
+  });
+  const defaultModel = opts.config.defaultModel;
+  if (!defaultModel) {
+    checks.push({
+      name: "Default model",
+      ok: false,
+      detail: "no defaultModel configured"
+    });
+  } else {
+    const modelConfig = opts.config.models.find((m) => m.name === defaultModel);
+    if (!modelConfig) {
+      checks.push({
+        name: "Default model",
+        ok: false,
+        detail: `model "${defaultModel}" not found in configured models`
+      });
+    } else {
+      const provider = opts.config.providers.find((p) => p.name === modelConfig.provider);
+      checks.push({
+        name: "Default model",
+        ok: provider !== void 0,
+        detail: provider ? `${modelConfig.name} (${provider.name}/${modelConfig.model}, ${provider.baseURL})` : `provider "${modelConfig.provider}" for model "${modelConfig.name}" not found`
+      });
+      const keyConfigured = resolveApiKeyConfigured(opts.config, modelConfig.provider, env);
+      checks.push({
+        name: "Provider API key",
+        ok: keyConfigured === true,
+        detail: keyConfigured === null ? `provider "${modelConfig.provider}" not found` : keyConfigured ? `apiKey resolved for provider "${modelConfig.provider}"` : `apiKey missing for provider "${modelConfig.provider}"${provider?.apiKeyEnv ? ` (set ${provider.apiKeyEnv} or configure apiKey)` : ""}`
+      });
     }
+  }
+  const sessions = path18.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);
+    writable = true;
+  } catch (error) {
+    writeError = error instanceof Error ? error.message : String(error);
+  }
+  checks.push({
+    name: "Sessions directory writable",
+    ok: writable,
+    detail: writable ? `${sessions} is writable` : `${sessions} not writable: ${writeError}`
   });
-  registry.register({
-    name: "cost",
-    description: "Show API token usage for this session",
-    usage: "/cost",
-    run(_args, ctx) {
-      ctx.addSystemMessage(ctx.showUsage());
-    }
+  const fetcher = opts.fetcher ?? defaultFetcher;
+  let registryOk = false;
+  try {
+    registryOk = await fetcher(REGISTRY_URL, REGISTRY_TIMEOUT_MS);
+  } catch {
+    registryOk = false;
+  }
+  checks.push({
+    name: "npm registry connectivity",
+    ok: registryOk,
+    detail: registryOk ? `${REGISTRY_URL} reachable` : `${REGISTRY_URL} unreachable (optional \u2014 only affects update checks)`,
+    optional: true
   });
-  registry.register({
-    name: "config",
-    description: "Show the current configuration",
-    usage: "/config",
-    run(_args, ctx) {
-      ctx.addSystemMessage(ctx.describeConfig());
+  const passed = checks.filter((c) => c.ok).length;
+  return { checks, passed, failed: checks.length - passed };
+}
+function formatDoctorReport(report) {
+  const lines = report.checks.map(
+    (check) => `${check.ok ? "\u2713" : "\u2717"} ${check.name}: ${check.detail}`
+  );
+  lines.push("", `${report.passed} passed, ${report.failed} failed`);
+  return lines.join("\n");
+}
+
+// src/cli/commands/init-project.ts
+import fs6 from "fs/promises";
+import path19 from "path";
+import { generateText as generateText2 } 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);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readPackageJson(cwd) {
+  try {
+    const raw = await fs6.readFile(path19.join(cwd, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function stringRecord(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const out = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (typeof val === "string") out[key] = val;
+  }
+  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";
+  return null;
+}
+function inferCommands(pm, scripts) {
+  const runner = pm ?? "npm";
+  const pick = (script) => script in scripts ? `${runner} ${script}` : null;
+  return {
+    test: pick("test"),
+    build: pick("build"),
+    lint: pick("lint"),
+    typecheck: pick("typecheck")
+  };
+}
+async function listEntries(cwd) {
+  try {
+    const dirents = await fs6.readdir(cwd, { withFileTypes: true });
+    const entries = [];
+    for (const dirent of dirents) {
+      if (dirent.isDirectory()) {
+        if (IGNORED_DIRS.has(dirent.name)) continue;
+        entries.push(`${dirent.name}/`);
+      } else if (!dirent.name.startsWith(".")) {
+        entries.push(dirent.name);
+      }
+      if (entries.length >= MAX_ENTRIES) break;
+    }
+    return entries.sort();
+  } catch {
+    return [];
+  }
+}
+async function readReadmeHead(cwd) {
+  for (const name of ["README.md", "readme.md", "README"]) {
+    try {
+      const raw = await fs6.readFile(path19.join(cwd, name), "utf8");
+      return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, README_HEAD_LINES);
+    } catch {
     }
+  }
+  return [];
+}
+async function scanProject(cwd) {
+  const pkg = await readPackageJson(cwd);
+  const packageManager = await detectPackageManager(cwd);
+  const scripts = stringRecord(pkg?.scripts);
+  return {
+    name: typeof pkg?.name === "string" ? pkg.name : null,
+    dirName: path19.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")),
+    readmeHead: await readReadmeHead(cwd),
+    entries: await listEntries(cwd)
+  };
+}
+function renderAgentsMd(facts) {
+  const title = facts.name ?? facts.dirName;
+  const lines = [
+    "# AGENTS.md",
+    "",
+    "Guidance for AI agents working in this repository.",
+    "",
+    "## Project",
+    "",
+    facts.readmeHead.length > 0 ? facts.readmeHead.join(" ") : `${title}`,
+    ""
+  ];
+  const commandLines = [];
+  const push = (label, command) => {
+    if (command) commandLines.push(`- \`${command}\` \u2014 ${label}`);
+  };
+  push("run tests", facts.commands.test);
+  push("build", facts.commands.build);
+  push("lint", facts.commands.lint);
+  push("typecheck", facts.commands.typecheck);
+  if (commandLines.length > 0) {
+    lines.push("## Commands", "", ...commandLines, "");
+  }
+  lines.push("## Layout", "");
+  for (const entry of facts.entries) {
+    lines.push(`- \`${entry}\``);
+  }
+  lines.push("", "## Conventions", "");
+  const conventions = [];
+  if (facts.hasTsconfig) conventions.push("TypeScript project (tsconfig.json present).");
+  if (facts.packageManager) conventions.push(`Use ${facts.packageManager} as the package manager.`);
+  if (facts.isGitRepo) conventions.push("Git repository.");
+  if (facts.dependencies.length > 0) {
+    conventions.push(`Key dependencies: ${facts.dependencies.slice(0, 10).join(", ")}.`);
+  }
+  if (conventions.length === 0) conventions.push("No conventions detected yet \u2014 fill this in.");
+  for (const item of conventions) lines.push(`- ${item}`);
+  lines.push("");
+  return lines.join("\n");
+}
+var INIT_SYSTEM_PROMPT = [
+  "You are writing an AGENTS.md file that guides AI coding agents working in a repository.",
+  "You are given scanned project facts as JSON.",
+  "Produce a concise Markdown document with sections: Project, Commands, Layout, Conventions.",
+  "Keep commands exactly as given in the facts. Do not invent tools, scripts, or directories.",
+  "Output only the Markdown, no preamble, no code fences."
+].join("\n");
+async function polishWithModel(facts, model) {
+  const { text } = await generateText2({
+    model,
+    system: INIT_SYSTEM_PROMPT,
+    prompt: `Project facts:
+
+${JSON.stringify(facts, null, 2)}
+
+Write the AGENTS.md.`
   });
+  const trimmed = text.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+async function initProject(opts) {
+  const { cwd, args, model } = opts;
+  const target = path19.join(cwd, "AGENTS.md");
+  const force = args.split(/\s+/).includes("force");
+  if (!force && await fileExists2(target)) {
+    return {
+      message: `AGENTS.md already exists at ${target}. Use /init force to overwrite it.`,
+      written: false,
+      path: target,
+      lines: 0,
+      usedLlm: false
+    };
+  }
+  const facts = await scanProject(cwd);
+  let usedLlm = false;
+  let content;
+  let note = "";
+  if (model) {
+    try {
+      const polished = await polishWithModel(facts, model);
+      if (polished) {
+        content = polished.endsWith("\n") ? polished : `${polished}
+`;
+        usedLlm = true;
+      } else {
+        content = renderAgentsMd(facts);
+        note = " Model returned an empty draft; used the template instead \u2014 review and refine manually.";
+      }
+    } catch {
+      content = renderAgentsMd(facts);
+      note = " Model refinement failed; used the template instead \u2014 review and refine manually.";
+    }
+  } else {
+    content = renderAgentsMd(facts);
+    note = " No model available; used the template \u2014 review and refine manually.";
+  }
+  await fs6.writeFile(target, content);
+  const lines = content.split("\n").length;
+  const how = usedLlm ? "generated with model refinement" : "generated from template";
+  return {
+    message: `Wrote ${target} (${lines} lines, ${how}).${note}`,
+    written: true,
+    path: target,
+    lines,
+    usedLlm
+  };
 }
 
 // src/cli/commands/registry.ts
@@ -1460,21 +2922,67 @@ function parseSlashCommand(input) {
   };
 }
 
-// src/cli/components/InputBox.tsx
+// src/cli/components/ExitPlanPrompt.tsx
 import { Box, Text, useInput } from "ink";
-import { useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
+function ExitPlanPrompt({ onDecision }) {
+  useInput((input, key) => {
+    const ch = input.toLowerCase();
+    if (ch === "y") onDecision("yes");
+    else if (ch === "n" || key.escape) onDecision("no");
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Plan ready (plan mode)" }),
+    /* @__PURE__ */ jsx(Text, { children: "The plan above was produced without making any changes." }),
+    /* @__PURE__ */ jsx(Text, { children: "[y] approve and execute [n] keep refining (Esc = n)" })
+  ] });
+}
+
+// src/cli/components/InputBox.tsx
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import { useRef, useState } from "react";
+
+// src/cli/commands/suggest.ts
+var MAX_SUGGESTIONS = 5;
+function filterCommands(input, commands) {
+  if (!input.startsWith("/")) return [];
+  if (/\s/.test(input)) return [];
+  const prefix = input.slice(1).toLowerCase();
+  return commands.filter((cmd) => cmd.name.toLowerCase().startsWith(prefix)).sort((a, b) => a.name.localeCompare(b.name)).slice(0, MAX_SUGGESTIONS);
+}
+
+// src/cli/components/InputBox.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function InputBox({
+  isStreaming,
+  disabled,
+  commands,
+  onSubmit,
+  onInterrupt,
+  onExit
+}) {
   const [value, setValue] = useState("");
   const [cursor, setCursor] = useState(0);
   const [history, setHistory] = useState([]);
+  const [highlight, setHighlight] = useState(0);
+  const [suggestionsDismissed, setSuggestionsDismissed] = useState(false);
   const historyIndexRef = useRef(null);
   const draftRef = useRef("");
   const edit = (next, nextCursor) => {
     setValue(next);
     setCursor(Math.max(0, Math.min(nextCursor, next.length)));
+    setHighlight(0);
+    setSuggestionsDismissed(false);
   };
-  useInput((input, key) => {
+  const suggestions = isStreaming || disabled || suggestionsDismissed || !commands ? [] : filterCommands(value, commands);
+  const activeIndex = suggestions.length === 0 ? 0 : Math.min(highlight, suggestions.length - 1);
+  const completeHighlighted = () => {
+    const cmd = suggestions[activeIndex];
+    if (!cmd) return;
+    const text = `/${cmd.name} `;
+    edit(text, text.length);
+  };
+  useInput2((input, key) => {
     if (key.ctrl && input === "c") {
       if (isStreaming || disabled) {
         onInterrupt();
@@ -1489,6 +2997,10 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
       return;
     }
     if (isStreaming || disabled) return;
+    if (key.escape) {
+      if (suggestions.length > 0) setSuggestionsDismissed(true);
+      return;
+    }
     if (key.return) {
       const text = value.trim();
       if (text.length > 0) {
@@ -1500,7 +3012,17 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
       draftRef.current = "";
       return;
     }
-    if (key.upArrow) {
+    if (key.tab) {
+      if (key.shift) return;
+      if (suggestions.length > 0) {
+        completeHighlighted();
+        return;
+      }
+    } else if (key.upArrow) {
+      if (suggestions.length > 0) {
+        setHighlight((prev) => (prev - 1 + suggestions.length) % suggestions.length);
+        return;
+      }
       if (history.length === 0) return;
       if (historyIndexRef.current === null) {
         draftRef.current = value;
@@ -1511,8 +3033,11 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
       const entry = history[historyIndexRef.current] ?? "";
       edit(entry, entry.length);
       return;
-    }
-    if (key.downArrow) {
+    } else if (key.downArrow) {
+      if (suggestions.length > 0) {
+        setHighlight((prev) => (prev + 1) % suggestions.length);
+        return;
+      }
       if (historyIndexRef.current === null) return;
       if (historyIndexRef.current < history.length - 1) {
         historyIndexRef.current += 1;
@@ -1523,13 +3048,15 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
         edit(draftRef.current, draftRef.current.length);
       }
       return;
-    }
-    if (key.leftArrow) {
+    } else if (key.leftArrow) {
       setCursor((prev) => Math.max(0, prev - 1));
       return;
-    }
-    if (key.rightArrow) {
-      setCursor((prev) => Math.min(value.length, prev + 1));
+    } else if (key.rightArrow) {
+      if (suggestions.length > 0 && cursor === value.length) {
+        completeHighlighted();
+      } else {
+        setCursor((prev) => Math.min(value.length, prev + 1));
+      }
       return;
     }
     if (key.ctrl && input === "a") {
@@ -1567,169 +3094,457 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
   const before = value.slice(0, cursor);
   const at = value[cursor] ?? " ";
   const after = value.slice(cursor + 1);
-  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
-    /* @__PURE__ */ jsx(Text, { color: "cyan", children: "> " }),
-    /* @__PURE__ */ jsx(Text, { children: before }),
-    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
-    /* @__PURE__ */ jsx(Text, { children: after })
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box2, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "> " }),
+      /* @__PURE__ */ jsx2(Text2, { children: before }),
+      /* @__PURE__ */ jsx2(Text2, { inverse: true, children: at }),
+      /* @__PURE__ */ jsx2(Text2, { children: after })
+    ] }),
+    suggestions.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: suggestions.map(
+      (cmd, index) => index === activeIndex ? /* @__PURE__ */ jsx2(Text2, { bold: true, inverse: true, children: `/${cmd.name} - ${cmd.description}` }, cmd.name) : /* @__PURE__ */ jsxs2(Text2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: `/${cmd.name}` }),
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: ` - ${cmd.description}` })
+      ] }, cmd.name)
+    ) })
   ] });
 }
 
 // src/cli/components/MessageList.tsx
-import { Box as Box2, Static, Text as Text2 } from "ink";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Box as Box3, Static, Text as Text3 } from "ink";
+import { memo } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var roleStyles = {
   user: { label: "you", color: "cyan" },
   assistant: { label: "star", color: "green" },
   system: { label: "system", color: "yellow" },
   tool: { label: "tool", color: "magenta" }
 };
-function MessageList({ messages }) {
-  return /* @__PURE__ */ jsx2(Static, { items: messages, children: (message) => {
+var MessageList = memo(function MessageList2({ messages }) {
+  return /* @__PURE__ */ jsx3(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);
+    }
     const style = roleStyles[message.role];
-    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx2(Text2, { bold: true, color: style.color, children: style.label }),
-      /* @__PURE__ */ jsx2(Text2, { color: style.color, children: message.text })
+    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 })
     ] }, message.id);
   } });
-}
+});
 
 // src/cli/components/PermissionPrompt.tsx
-import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
-
-// src/cli/format.ts
-function summarizeArgs(args, maxLength = 120) {
-  let json;
-  try {
-    json = JSON.stringify(args) ?? String(args);
-  } catch {
-    json = String(args);
-  }
-  return json.length > maxLength ? `${json.slice(0, maxLength)}...` : json;
-}
-function previewLines(text, maxLines = 10) {
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) return { text, truncated: false };
-  return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
-}
-function coreMessageText(message) {
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
-  }
-  return "";
-}
-function buildDisplayMessages(messages) {
-  const display = [];
-  let collapsed = 0;
-  for (const message of messages) {
-    if (message.role === "user" || message.role === "assistant") {
-      const text = coreMessageText(message);
-      if (text) {
-        display.push({ id: display.length, role: message.role, text });
-      } else {
-        collapsed++;
-      }
-    } else if (message.role === "tool") {
-      collapsed++;
-    }
-  }
-  if (collapsed > 0) {
-    display.push({
-      id: display.length,
-      role: "system",
-      text: `\u5DF2\u6062\u590D ${collapsed} \u6761\u5386\u53F2\u6D88\u606F`
-    });
-  }
-  return display;
+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
+  ] });
 }
-
-// src/cli/components/PermissionPrompt.tsx
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-function PermissionPrompt({ request, onDecision }) {
-  useInput2((input) => {
+function PermissionPrompt({ request, preview, onDecision }) {
+  useInput3((input) => {
     const ch = input.toLowerCase();
     if (ch === "y") onDecision("yes");
     else if (ch === "n") onDecision("no");
     else if (ch === "a") onDecision("always");
   });
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs3(Text3, { bold: true, color: "yellow", children: [
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "yellow", children: [
       "Permission required: ",
       request.toolName,
       " (",
       request.level,
       ")"
     ] }),
-    /* @__PURE__ */ jsx3(Text3, { children: summarizeArgs(request.args) }),
-    /* @__PURE__ */ jsx3(Text3, { children: "[y] allow [n] deny [a] always" })
+    preview ? /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { 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)" })
+  ] });
+}
+
+// src/cli/components/StatusBar.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { memo as memo2 } from "react";
+import { jsxs as jsxs5 } from "react/jsx-runtime";
+var BG_LABEL_MAX = 40;
+var StatusBar = memo2(function StatusBar2({
+  model,
+  permissionMode,
+  tokens,
+  backgroundTasks = []
+}) {
+  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
+    ] }),
+    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+      "bg: ",
+      backgroundTasks.length,
+      " (",
+      labels,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      tokens,
+      " tokens"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "mode: ",
+      permissionMode
+    ] })
+  ] });
+});
+
+// src/cli/components/StreamingMessage.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { memo as memo3 } from "react";
+import { jsx as jsx5, jsxs as jsxs6 } 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 })
+  ] });
+});
+
+// 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/StatusBar.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import { jsxs as jsxs4 } from "react/jsx-runtime";
-function StatusBar({ model, permissionMode, tokens }) {
-  return /* @__PURE__ */ jsxs4(Box4, { justifyContent: "space-between", children: [
-    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-      "model: ",
-      model
-    ] }),
-    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-      tokens,
-      " tokens"
-    ] }),
-    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-      "mode: ",
-      permissionMode
-    ] })
-  ] });
+// 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;
+}
+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 getStringArg2(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 = 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;
+  }
+  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) };
+  }
+  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;
+function truncateShellOutput(output, max = SHELL_BANG_DISPLAY_MAX_CHARS) {
+  if (output.length <= max) return output;
+  const half = Math.floor(max / 2);
+  return `${output.slice(0, half)}
+... [${output.length - max} characters truncated] ...
+${output.slice(-half)}`;
+}
+function buildShellContextMessage(command, output) {
+  return `The user ran \`!${command}\` directly in the shell (no permission prompt). Output:
+${output}`;
+}
+async function executeShellBang(raw, cwd, signal) {
+  const command = raw.trim();
+  if (!command) return { ok: false, reason: "empty" };
+  if (isDangerousCommand(command)) return { ok: false, reason: "dangerous" };
+  const result = await bashTool.execute({ command }, { cwd, abortSignal: signal });
+  const output = truncateShellOutput(result.content);
+  return {
+    ok: true,
+    command,
+    output,
+    isError: result.isError ?? false,
+    contextMessage: buildShellContextMessage(command, output)
+  };
 }
 
-// src/cli/components/StreamingMessage.tsx
-import { Box as Box5, Text as Text5 } from "ink";
-import { jsx as jsx4, jsxs as jsxs5 } from "react/jsx-runtime";
-function StreamingMessage({ text }) {
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx4(Text5, { bold: true, color: "green", children: "star" }),
-    /* @__PURE__ */ jsx4(Text5, { color: "green", children: text })
-  ] });
+// src/cli/ticker.ts
+var TICK_MS = 100;
+function nextFlush(prev, next) {
+  if (prev.streamed === next.streamed && prev.reasoning === next.reasoning) return null;
+  return next;
+}
+function startTicker(onTick, intervalMs = TICK_MS) {
+  let tick = 0;
+  const timer = setInterval(() => {
+    tick += 1;
+    onTick(tick);
+  }, intervalMs);
+  return () => clearInterval(timer);
 }
 
-// src/cli/components/ToolCallCard.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
-function ToolCallCard({ card }) {
-  const color = card.isError ? "red" : "magenta";
-  const preview = card.result !== void 0 ? previewLines(card.result, 10) : null;
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs6(Text6, { bold: true, color, children: [
-      "tool: ",
-      card.name,
-      card.isError ? " (error)" : ""
-    ] }),
-    /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: card.argsSummary }),
-    preview && /* @__PURE__ */ jsxs6(Text6, { color, children: [
-      preview.text,
-      preview.truncated ? "\n... (truncated)" : ""
-    ] })
-  ] });
+// src/cli/update-check.ts
+var REGISTRY_URL2 = "https://registry.npmjs.org/@cryer%2fstar-cli/latest";
+var TIMEOUT_MS3 = 5e3;
+async function defaultFetcher2(url) {
+  return fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS3) });
 }
-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 isNewerVersion(latest, current) {
+  const parse3 = (v) => v.split(".").slice(0, 3).map((part) => Number.parseInt(part, 10));
+  const a = parse3(latest);
+  const b = parse3(current);
+  for (let i = 0; i < 3; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (Number.isNaN(x) || Number.isNaN(y)) return false;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+async function checkForUpdate(currentVersion, fetcher = defaultFetcher2) {
+  try {
+    const res = await fetcher(REGISTRY_URL2);
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latest = typeof data === "object" && data !== null ? data.version : null;
+    if (typeof latest !== "string" || !isNewerVersion(latest, currentVersion)) return null;
+    return `New version available: ${currentVersion} -> ${latest} \u2014 run: npm i -g @cryer/star-cli`;
+  } catch {
+    return null;
+  }
 }
 
 // src/cli/repl.tsx
-import { jsx as jsx6, jsxs as jsxs7 } from "react/jsx-runtime";
-var FLUSH_INTERVAL_MS = 30;
+import { jsx as jsx6, jsxs as jsxs8 } 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 };
 }
+function runningTaskLabels() {
+  return defaultTaskManager.list().filter((t) => t.status === "running").map((t) => t.description ?? t.command);
+}
+var SESSION_MODE_CYCLE = ["ask", "auto", "readonly", "plan"];
 function formatUsage(usage) {
   return `API usage this session: ${usage.requests} requests, ${usage.promptTokens} prompt + ${usage.completionTokens} completion = ${usage.totalTokens} tokens`;
 }
@@ -1749,48 +3564,129 @@ function Repl({
   const [epoch, setEpoch] = useState2(0);
   const [streamingText, setStreamingText] = useState2(null);
   const [isStreaming, setIsStreaming] = useState2(false);
-  const [usageVersion, setUsageVersion] = useState2(0);
+  const [thinking, setThinking] = useState2(false);
+  const [thinkingText, setThinkingText] = useState2("");
+  const [thoughtSummary, setThoughtSummary] = useState2(null);
+  const [, setUsageVersion] = useState2(0);
   const [modelName, setModelName] = useState2(model);
   const [pending, setPending] = useState2(null);
-  const [cardsVersion, setCardsVersion] = useState2(0);
+  const [spinnerTick, setSpinnerTick] = useState2(0);
+  const [activity, setActivity] = useState2(null);
+  const [bgLabels, setBgLabels] = useState2(() => runningTaskLabels());
+  const [permissionModeState, setPermissionModeState] = useState2(permissionMode);
+  const [planApproval, setPlanApprovalState] = useState2(false);
   const backendRef = useRef2(backend);
   const nextIdRef = useRef2(initialDisplay.length);
   const abortRef = useRef2(null);
   const streamedRef = useRef2("");
-  const flushTimerRef = useRef2(null);
+  const thinkingRef = useRef2(false);
+  const reasoningRef = useRef2("");
+  const tickerStopRef = useRef2(null);
+  const flushedRef = useRef2({ streamed: "", reasoning: "" });
   const toolCardsRef = useRef2(/* @__PURE__ */ new Map());
   const pendingRef = useRef2(null);
   const alwaysAllowedRef = useRef2(/* @__PURE__ */ new Set());
+  const prevModeRef = useRef2(null);
+  const planApprovalRef = useRef2(false);
   const modelNameRef = useRef2(model);
   const usageRef = useRef2(initialUsage ? { ...initialUsage } : emptyUsage());
-  const pushMessage = useCallback((role, text) => {
-    setMessages((prev) => [...prev, { id: nextIdRef.current++, role, text }]);
+  const turnChunksRef = useRef2(0);
+  const messagesRef = useRef2(initialDisplay);
+  const pushMessage = useCallback(
+    (role, text, note, tight) => {
+      setMessages((prev) => {
+        const next = [...prev, { id: nextIdRef.current++, role, text, note, tight }];
+        messagesRef.current = next;
+        return next;
+      });
+    },
+    []
+  );
+  const applyMessages = useCallback((next) => {
+    messagesRef.current = next;
+    setMessages(next);
+    setEpoch((e) => e + 1);
   }, []);
+  const redrawMessages = useCallback(
+    (next) => {
+      if (process.stdout.isTTY) {
+        process.stdout.write(CLEAR_TERMINAL);
+      }
+      applyMessages(next);
+    },
+    [applyMessages]
+  );
+  const pushAssistantChunk = useCallback(
+    (text, tight) => {
+      const role = turnChunksRef.current === 0 ? "assistant" : "assistant-cont";
+      turnChunksRef.current += 1;
+      pushMessage(role, text, void 0, tight);
+    },
+    [pushMessage]
+  );
   const setPendingPermission = useCallback((p) => {
     pendingRef.current = p;
     setPending(p);
   }, []);
+  const setPlanApproval = useCallback((v) => {
+    planApprovalRef.current = v;
+    setPlanApprovalState(v);
+  }, []);
+  const applySessionMode = useCallback(
+    (mode) => {
+      if (mode === config.permissionMode) return;
+      if (mode === "plan") {
+        prevModeRef.current = config.permissionMode;
+      } else if (config.permissionMode === "plan") {
+        prevModeRef.current = null;
+      }
+      config.permissionMode = mode;
+      setPermissionModeState(mode);
+    },
+    [config]
+  );
   const attachConfirmHandler = useCallback(
     (target) => {
-      target.confirmHandler = (req) => {
-        if (alwaysAllowedRef.current.has(req.toolName)) {
-          return Promise.resolve(true);
+      target.confirmHandler = async (req) => {
+        if (isAllowedByRules([...alwaysAllowedRef.current], req)) {
+          return true;
         }
+        const preview = await generateDiffPreview(req.toolName, req.args, cwd).catch(() => null);
         return new Promise((resolve) => {
-          setPendingPermission({ request: req, resolve });
+          setPendingPermission({ request: req, preview, resolve });
         });
       };
     },
-    [setPendingPermission]
+    [setPendingPermission, cwd]
   );
   useEffect(() => {
     attachConfirmHandler(backendRef.current);
     return () => {
-      if (flushTimerRef.current !== null) clearInterval(flushTimerRef.current);
+      tickerStopRef.current?.();
       abortRef.current?.abort();
       pendingRef.current?.resolve(false);
     };
   }, [attachConfirmHandler]);
+  useEffect(() => {
+    if (process.env.STAR_NO_UPDATE_CHECK === "1") return;
+    void checkForUpdate(VERSION).then((message) => {
+      if (message) pushMessage("system", message);
+    });
+  }, [pushMessage]);
+  useEffect(() => {
+    const onUpdate = (task) => {
+      setBgLabels(runningTaskLabels());
+      pushMessage(
+        "system",
+        task.status === "running" ? formatTaskStarted(task) : formatTaskFinished(task)
+      );
+    };
+    defaultTaskManager.on("update", onUpdate);
+    return () => {
+      defaultTaskManager.off("update", onUpdate);
+      defaultTaskManager.cleanup();
+    };
+  }, [pushMessage]);
   const interrupt = useCallback(() => {
     abortRef.current?.abort();
     const p = pendingRef.current;
@@ -1799,20 +3695,46 @@ function Repl({
       p.resolve(false);
     }
   }, [setPendingPermission]);
-  useInput3((_input, key) => {
+  const handleExit = useCallback(() => {
+    const killed = defaultTaskManager.cleanup();
+    if (killed.length > 0) {
+      pushMessage(
+        "system",
+        `Stopped ${killed.length} background task(s): ${killed.map((t) => t.id).join(", ")}`
+      );
+    }
+    exit();
+  }, [exit, pushMessage]);
+  useInput4((_input, key) => {
     if (key.escape) interrupt();
+    if (key.shift && key.tab) {
+      if (abortRef.current || pendingRef.current || planApprovalRef.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";
+      applySessionMode(next);
+    }
   });
   const handleDecision = useCallback(
     (decision) => {
       const p = pendingRef.current;
       if (!p) return;
       if (decision === "always") {
-        alwaysAllowedRef.current.add(p.request.toolName);
+        const rule = buildAllowRule(p.request);
+        alwaysAllowedRef.current.add(rule);
+        void addAllowRule(rule).then((added) => {
+          pushMessage(
+            "system",
+            added ? `Always allow ${rule} \u2014 saved to config` : `Always allow ${rule} (already in config)`
+          );
+        }).catch(() => {
+          pushMessage("system", `Always allow ${rule} for this session (failed to save)`);
+        });
       }
       setPendingPermission(null);
       p.resolve(decision !== "no");
     },
-    [setPendingPermission]
+    [setPendingPermission, pushMessage]
   );
   const switchModel = useCallback(
     async (name) => {
@@ -1840,95 +3762,119 @@ function Repl({
     },
     [config, cwd, sessionStore, attachConfirmHandler]
   );
-  const resume = useCallback(async (id) => {
-    const current = backendRef.current;
-    if (!(current instanceof AgentLoop)) {
-      return "Current backend does not support resuming sessions.";
-    }
-    const resumed = await resumeSession(id);
-    if (!resumed) {
-      return `Session not found: ${id}`;
-    }
-    await current.loadMessages(resumed.messages);
-    const display = buildDisplayMessages(resumed.messages);
-    nextIdRef.current = display.length;
-    setMessages(display);
-    setEpoch((e) => e + 1);
-    usageRef.current = resumed.meta.usage ? { ...resumed.meta.usage } : emptyUsage();
-    setUsageVersion((v) => v + 1);
-    return `Resumed session ${id} (${resumed.messages.length} messages).`;
-  }, []);
-  const registry = useMemo(() => {
-    const ctx = {
-      addSystemMessage: (text) => pushMessage("system", text),
-      clearMessages: () => {
-        setMessages([]);
-        setEpoch((e) => e + 1);
-      },
-      exit: () => exit(),
-      listModels: () => {
-        const models = listModels(config);
-        if (models.length === 0) return "No models configured.";
-        const lines = models.map(
-          (m) => `${m.name === modelNameRef.current ? "*" : " "} ${m.name} (${m.provider}/${m.model})`
-        );
-        return `Models (* = current):
-${lines.join("\n")}`;
-      },
-      switchModel,
-      listSessions: async () => {
-        const metas = await SessionStore.list(cwd);
-        return metas.length === 0 ? "No sessions found for this directory." : formatSessionList(metas);
-      },
-      resumeSession: resume,
-      showTodos: async () => {
-        const store = new TodoStore();
-        await store.load(cwd);
-        return formatTodos(store.list());
-      },
-      showUsage: () => formatUsage(usageRef.current),
-      describeConfig: () => [
-        `defaultModel: ${config.defaultModel || "(none)"}`,
-        `permissionMode: ${config.permissionMode}`,
-        `providers (${config.providers.length}): ${config.providers.map((p) => p.name).join(", ") || "(none)"}`,
-        `models (${config.models.length}): ${config.models.map((m) => m.name).join(", ") || "(none)"}`,
-        `maxSteps: ${config.maxSteps}`,
-        `contextMaxTokens: ${config.contextMaxTokens}`
-      ].join("\n")
-    };
-    const reg = new CommandRegistry();
-    registerBuiltinCommands(reg);
-    return Object.assign(reg, { ctx });
-  }, [pushMessage, exit, config, cwd, switchModel, resume]);
+  const resume = useCallback(
+    async (id) => {
+      const current = backendRef.current;
+      if (!(current instanceof AgentLoop)) {
+        return "Current backend does not support resuming sessions.";
+      }
+      const resumed = await resumeSession(id);
+      if (!resumed) {
+        return `Session not found: ${id}`;
+      }
+      await current.loadMessages(resumed.messages);
+      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).`;
+    },
+    [applyMessages]
+  );
   const runStream = useCallback(
     async (input) => {
-      pushMessage("user", input);
+      const resolved = await resolveMentions(input, cwd);
+      pushMessage(
+        "user",
+        input,
+        resolved.attached.length > 0 ? `attached: ${resolved.attached.join(", ")}` : void 0
+      );
+      for (const skip of resolved.skipped) {
+        pushMessage("system", `Skipped @${skip.path}: ${skip.reason}`);
+      }
       const controller = new AbortController();
       abortRef.current = controller;
       streamedRef.current = "";
+      thinkingRef.current = true;
+      reasoningRef.current = "";
+      turnChunksRef.current = 0;
+      setThinking(true);
+      setThinkingText("");
+      setThoughtSummary(null);
       setStreamingText("");
       setIsStreaming(true);
-      flushTimerRef.current = setInterval(() => {
-        setStreamingText(streamedRef.current);
-      }, FLUSH_INTERVAL_MS);
+      flushedRef.current = { streamed: "", reasoning: "" };
+      const commitStreamed = (tight) => {
+        if (streamedRef.current.length === 0) return;
+        pushAssistantChunk(streamedRef.current, tight);
+        streamedRef.current = "";
+        flushedRef.current = { ...flushedRef.current, streamed: "" };
+        setStreamingText("");
+      };
+      tickerStopRef.current = startTicker((tick) => {
+        setSpinnerTick(tick);
+        const split = splitCommittableLines(streamedRef.current, 8);
+        if (split) {
+          pushAssistantChunk(split.committed, true);
+          streamedRef.current = split.rest;
+          flushedRef.current = { ...flushedRef.current, streamed: "" };
+        }
+        const next = {
+          streamed: streamedRef.current,
+          reasoning: reasoningRef.current
+        };
+        if (nextFlush(flushedRef.current, next) !== null) {
+          flushedRef.current = next;
+          setStreamingText(next.streamed);
+          setThinkingText(next.reasoning);
+        }
+      });
       try {
-        for await (const event of backendRef.current.stream(input, controller.signal)) {
+        for await (const event of backendRef.current.stream(resolved.input, controller.signal, {
+          persistAs: input
+        })) {
           if (event.type === "text-delta") {
+            if (thinkingRef.current) {
+              thinkingRef.current = false;
+              setThinking(false);
+              if (reasoningRef.current.length > 0) {
+                setThoughtSummary(
+                  `thought: ${truncateTail(reasoningRef.current, THOUGHT_SUMMARY_LENGTH)}`
+                );
+              }
+            }
             streamedRef.current += event.text;
+          } else if (event.type === "reasoning") {
+            reasoningRef.current += event.text;
           } else if (event.type === "tool-call") {
+            commitStreamed(true);
             toolCardsRef.current.set(event.id, {
               id: event.id,
               name: event.name,
               argsSummary: summarizeArgs(event.args)
             });
-            setCardsVersion((v) => v + 1);
+            setActivity(`running ${event.name}: ${summarizeArgs(event.args, 60)}`);
           } else if (event.type === "tool-result") {
-            const card = toolCardsRef.current.get(event.id);
-            if (card) {
-              card.result = event.content;
-              card.isError = event.isError ?? false;
-              setCardsVersion((v) => v + 1);
-            }
+            const card = toolCardsRef.current.get(event.id) ?? {
+              id: event.id,
+              name: event.name,
+              argsSummary: ""
+            };
+            toolCardsRef.current.delete(event.id);
+            pushMessage(
+              "tool",
+              formatToolCard({
+                ...card,
+                result: event.content,
+                isError: event.isError ?? false
+              })
+            );
+            setActivity(null);
+            thinkingRef.current = true;
+            reasoningRef.current = "";
+            setThinking(true);
+            setThinkingText("");
           } else if (event.type === "finish") {
             if (event.usage) {
               const usage = usageRef.current;
@@ -1941,45 +3887,265 @@ ${lines.join("\n")}`;
               });
             }
           } else if (event.type === "error") {
-            pushMessage("system", `Error: ${event.error.message}`);
+            pushMessage("system", `Error: ${formatStreamError(event.error)}`);
           }
         }
       } catch (error) {
-        if (!(error instanceof DOMException && error.name === "AbortError")) {
-          pushMessage("system", `Error: ${error instanceof Error ? error.message : String(error)}`);
+        const aborted = controller.signal.aborted || error instanceof DOMException && error.name === "AbortError";
+        if (!aborted) {
+          pushMessage(
+            "system",
+            `Error: ${error instanceof Error ? formatStreamError(error) : String(error)}`
+          );
         }
       } finally {
-        if (flushTimerRef.current !== null) {
-          clearInterval(flushTimerRef.current);
-          flushTimerRef.current = null;
-        }
+        tickerStopRef.current?.();
+        tickerStopRef.current = null;
         abortRef.current = null;
         setIsStreaming(false);
+        thinkingRef.current = false;
+        reasoningRef.current = "";
+        setThinking(false);
+        setThinkingText("");
+        setThoughtSummary(null);
+        setActivity(null);
         const finalText = streamedRef.current;
         streamedRef.current = "";
         setStreamingText(null);
+        const interrupted = controller.signal.aborted;
         if (finalText.length > 0) {
-          pushMessage(
-            "assistant",
-            controller.signal.aborted ? `${finalText} [interrupted]` : finalText
-          );
+          pushAssistantChunk(`${finalText}${interrupted ? " [interrupted]" : ""}`, false);
+        } else if (interrupted && turnChunksRef.current > 0) {
+          pushAssistantChunk("[interrupted]", false);
         }
         for (const card of toolCardsRef.current.values()) {
           pushMessage("tool", formatToolCard(card));
         }
         toolCardsRef.current.clear();
-        setCardsVersion((v) => v + 1);
+        turnChunksRef.current = 0;
         const p = pendingRef.current;
         if (p) {
           setPendingPermission(null);
           p.resolve(false);
         }
+        if (!interrupted && config.permissionMode === "plan") {
+          setPlanApproval(true);
+        }
+      }
+    },
+    [
+      pushMessage,
+      pushAssistantChunk,
+      setPendingPermission,
+      setPlanApproval,
+      sessionStore,
+      cwd,
+      config
+    ]
+  );
+  const handlePlanDecision = useCallback(
+    (decision) => {
+      setPlanApproval(false);
+      if (decision === "no") return;
+      const restore = prevModeRef.current ?? "ask";
+      applySessionMode(restore);
+      pushMessage("system", `Plan approved \u2014 permission mode restored to ${restore}.`);
+      void runStream("The plan above is approved. Proceed with the implementation.");
+    },
+    [applySessionMode, pushMessage, runStream, setPlanApproval]
+  );
+  const registry = useMemo(() => {
+    const ctx = {
+      addSystemMessage: (text) => pushMessage("system", text),
+      clearMessages: () => {
+        redrawMessages([]);
+      },
+      exit: () => handleExit(),
+      listModels: () => {
+        const models = listModels(config);
+        if (models.length === 0) return "No models configured.";
+        const lines = models.map(
+          (m) => `${m.name === modelNameRef.current ? "*" : " "} ${m.name} (${m.provider}/${m.model})`
+        );
+        return `Models (* = current):
+${lines.join("\n")}`;
+      },
+      switchModel,
+      listSessions: async () => {
+        const metas = await SessionStore.list(cwd);
+        return metas.length === 0 ? "No sessions found for this directory." : formatSessionList(metas);
+      },
+      resumeSession: resume,
+      showTodos: async () => {
+        const store = new TodoStore();
+        await store.load(cwd);
+        return formatTodos(store.list());
+      },
+      listTasks: () => formatTaskList(defaultTaskManager.list()),
+      showUsage: () => {
+        const modelConfig = config.models.find((m) => m.name === modelNameRef.current);
+        return `${formatUsage(usageRef.current)}
+${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
+      },
+      compactContext: async () => {
+        let summaryModel = null;
+        try {
+          summaryModel = createModel(config, modelNameRef.current);
+        } catch {
+          summaryModel = null;
+        }
+        const result = await compactSession({
+          backend: backendRef.current,
+          sessionStore,
+          config,
+          model: summaryModel
+        });
+        if (result.compacted && result.messages) {
+          const display = buildDisplayMessages(result.messages);
+          nextIdRef.current = display.length;
+          applyMessages(display);
+        }
+        return result.message;
+      },
+      exportSession: (arg) => exportSession({ backend: backendRef.current, sessionStore, cwd, arg }),
+      undo: async () => {
+        const current = backendRef.current;
+        if (!(current instanceof AgentLoop)) {
+          return "Nothing to undo.";
+        }
+        const { removed, turn } = await current.retractLastTurn();
+        if (removed === 0) {
+          return "Nothing to undo (no conversation turn to retract).";
+        }
+        const reverted = turn !== void 0 ? await undoTurnSnapshots(turn) : [];
+        const visible = messagesRef.current;
+        let cut = -1;
+        for (let i = visible.length - 1; i >= 0; i--) {
+          if (visible[i]?.role === "user") {
+            cut = i;
+            break;
+          }
+        }
+        redrawMessages(cut >= 0 ? visible.slice(0, cut) : visible);
+        return [...reverted, `Retracted the last conversation turn (${removed} messages).`].join(
+          "\n"
+        );
+      },
+      permissionMode: async (args) => {
+        const current = config.permissionMode;
+        if (!args) {
+          const mark = (m) => m === current ? "*" : " ";
+          return [
+            "Permission modes (* = current):",
+            `${mark("ask")} ask      \u2014 reads allowed; writes/exec ask for confirmation`,
+            `${mark("auto")} auto     \u2014 everything allowed except hard-denied dangerous commands/paths`,
+            `${mark("readonly")} readonly \u2014 read-only; all writes/exec denied`,
+            `${mark("yolo")} yolo     \u2014 allow everything, never ask (disables ALL safety checks)`
+          ].join("\n");
+        }
+        const mode = args.toLowerCase();
+        if (!["ask", "auto", "readonly", "yolo"].includes(mode)) {
+          return `Unknown permission mode: ${args} (expected ask | auto | readonly | yolo)`;
+        }
+        config.permissionMode = mode;
+        prevModeRef.current = null;
+        setPermissionModeState(mode);
+        await savePermissionMode(mode);
+        return mode === "yolo" ? "Permission mode set to yolo \u2014 ALL safety checks disabled, tools run without asking. Saved to config." : `Permission mode set to ${mode}. Saved to config.`;
+      },
+      planMode: async () => {
+        if (config.permissionMode === "plan") {
+          const restore = prevModeRef.current ?? "ask";
+          applySessionMode(restore);
+          return `Exited plan mode \u2014 permission mode back to ${restore} (this session only).`;
+        }
+        applySessionMode("plan");
+        return "Entered plan mode: the agent researches with read-only tools and presents a plan for approval before anything is executed. /plan again to exit.";
+      },
+      initProject: async (args) => {
+        let model2 = null;
+        try {
+          model2 = createModel(config, modelNameRef.current);
+        } catch {
+          model2 = null;
+        }
+        const result = await initProject({ cwd, args, model: model2 });
+        return result.message;
+      },
+      runDoctor: async () => formatDoctorReport(await runDoctor({ cwd, config })),
+      submitPrompt: async (text) => {
+        await runStream(text);
+      },
+      describeConfig: () => [
+        `defaultModel: ${config.defaultModel || "(none)"}`,
+        `permissionMode: ${config.permissionMode}`,
+        `providers (${config.providers.length}): ${config.providers.map((p) => p.name).join(", ") || "(none)"}`,
+        `models (${config.models.length}): ${config.models.map((m) => m.name).join(", ") || "(none)"}`,
+        `maxSteps: ${config.maxSteps}`,
+        `contextMaxTokens: ${config.contextMaxTokens}`,
+        `streamIdleTimeoutSec: ${config.streamIdleTimeoutSec}`,
+        `permissions.allow (${config.permissions.allow.length}): ${config.permissions.allow.join(", ") || "(none)"}`
+      ].join("\n")
+    };
+    const reg = new CommandRegistry();
+    registerBuiltinCommands(reg);
+    registerCustomCommands(reg, cwd);
+    return Object.assign(reg, { ctx });
+  }, [
+    pushMessage,
+    handleExit,
+    config,
+    cwd,
+    switchModel,
+    resume,
+    sessionStore,
+    runStream,
+    applyMessages,
+    redrawMessages,
+    applySessionMode
+  ]);
+  const runShellBang = useCallback(
+    async (raw) => {
+      pushMessage("user", `!${raw.trim()}`);
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        const outcome = await executeShellBang(raw, cwd, controller.signal);
+        if (!outcome.ok) {
+          pushMessage(
+            "system",
+            outcome.reason === "dangerous" ? `Refused to run dangerous command: ${raw.trim()}` : "Usage: !<command>"
+          );
+          return;
+        }
+        pushMessage(
+          "tool",
+          formatToolCard({
+            id: `bang-${nextIdRef.current}`,
+            name: "bash",
+            argsSummary: outcome.command,
+            result: outcome.output,
+            isError: outcome.isError
+          })
+        );
+        const current = backendRef.current;
+        if (current instanceof AgentLoop) {
+          await current.appendContextMessage(outcome.contextMessage);
+        }
+      } finally {
+        if (abortRef.current === controller) {
+          abortRef.current = null;
+        }
       }
     },
-    [pushMessage, setPendingPermission, sessionStore]
+    [cwd, pushMessage]
   );
   const handleSubmit = useCallback(
     (text) => {
+      if (text.startsWith("!")) {
+        void runShellBang(text.slice(1));
+        return;
+      }
       if (text.startsWith("/")) {
         const parsed = parseSlashCommand(text);
         if (!parsed) return;
@@ -1993,36 +4159,59 @@ ${lines.join("\n")}`;
       }
       void runStream(text);
     },
-    [registry, pushMessage, runStream]
+    [registry, pushMessage, runStream, runShellBang]
   );
-  const cards = [...toolCardsRef.current.values()];
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx6(MessageList, { messages }, epoch),
-    cards.length > 0 && /* @__PURE__ */ jsx6(Box7, { flexDirection: "column", children: cards.map((card) => /* @__PURE__ */ jsx6(ToolCallCard, { card }, card.id)) }, cardsVersion),
-    streamingText !== null && /* @__PURE__ */ jsx6(StreamingMessage, { text: streamingText }),
-    pending && /* @__PURE__ */ jsx6(PermissionPrompt, { request: pending.request, onDecision: handleDecision }),
+  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(
+      ThinkingIndicator,
+      {
+        reasoning: thinkingText,
+        frame: spinnerTick,
+        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(
+      PermissionPrompt,
+      {
+        request: pending.request,
+        preview: pending.preview,
+        onDecision: handleDecision
+      }
+    ),
+    planApproval && /* @__PURE__ */ jsx6(ExitPlanPrompt, { onDecision: handlePlanDecision }),
     /* @__PURE__ */ jsx6(
       InputBox,
       {
         isStreaming,
-        disabled: pending !== null,
+        disabled: pending !== null || planApproval,
+        commands: commandHints,
         onSubmit: handleSubmit,
         onInterrupt: interrupt,
-        onExit: exit
+        onExit: handleExit
       }
     ),
     /* @__PURE__ */ jsx6(
       StatusBar,
       {
         model: modelName,
-        permissionMode,
-        tokens: usageRef.current.totalTokens
-      },
-      usageVersion
+        permissionMode: permissionModeState,
+        tokens: usageRef.current.totalTokens,
+        backgroundTasks: bgLabels
+      }
     )
   ] });
 }
 function renderRepl(backend, opts) {
+  process.on("exit", () => {
+    defaultTaskManager.cleanup();
+  });
   return render(
     /* @__PURE__ */ jsx6(
       Repl,
@@ -2041,33 +4230,43 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs2 from "fs";
-import { parse } from "smol-toml";
+import fs7 from "fs";
+import { parse as parse2 } from "smol-toml";
 
 // src/config/schema.ts
-import { z as z9 } from "zod";
-var ProviderConfigSchema = z9.object({
-  name: z9.string(),
-  protocol: z9.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
-  baseURL: z9.string(),
-  apiKeyEnv: z9.string().optional(),
-  apiKey: z9.string().optional(),
-  headers: z9.record(z9.string()).optional()
+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 ModelConfigSchema = z9.object({
-  name: z9.string(),
-  provider: z9.string(),
-  model: z9.string(),
-  maxTokens: z9.number().int().positive().optional()
+var PermissionsConfigSchema = z11.object({
+  allow: z11.array(z11.string()).default([])
 });
-var ConfigSchema = z9.object({
-  defaultModel: z9.string().default(""),
-  permissionMode: z9.enum(["auto", "ask", "readonly"]).default("ask"),
-  providers: z9.array(ProviderConfigSchema).default([]),
-  models: z9.array(ModelConfigSchema).default([]),
-  maxSteps: z9.number().int().positive().default(50),
-  contextMaxTokens: z9.number().int().positive().default(1e5),
-  contextCompaction: z9.enum(["summary", "truncate"]).default("summary")
+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
@@ -2075,7 +4274,7 @@ var PartialConfigSchema = ConfigSchema.partial();
 function parseTomlFile(content, filePath) {
   let raw;
   try {
-    raw = parse(content);
+    raw = parse2(content);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to parse TOML in ${filePath}: ${message}`);
@@ -2097,8 +4296,8 @@ function applyOverrides(config, overrides) {
   return merged;
 }
 function readTomlFileSync(filePath) {
-  if (!fs2.existsSync(filePath)) return {};
-  const content = fs2.readFileSync(filePath, "utf8");
+  if (!fs7.existsSync(filePath)) return {};
+  const content = fs7.readFileSync(filePath, "utf8");
   return parseTomlFile(content, filePath);
 }
 function loadConfigSync(cwd, overrides) {
@@ -2125,59 +4324,95 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     sessionStore
   });
 }
-async function printMode(loop, prompt) {
+async function printMode(loop, prompt, cwd, json) {
   const controller = new AbortController();
   process.on("SIGINT", () => controller.abort());
-  let requests = 0;
-  let promptTokens = 0;
-  let completionTokens = 0;
-  let totalTokens = 0;
+  const resolved = await resolveMentions(prompt, cwd);
+  if (resolved.attached.length > 0) {
+    process.stderr.write(`[attached] ${resolved.attached.join(", ")}
+`);
+  }
+  for (const skip of resolved.skipped) {
+    process.stderr.write(`[skipped] @${skip.path}: ${skip.reason}
+`);
+  }
+  const usage = new UsageTracker();
   let exitCode = 0;
-  for await (const event of loop.stream(prompt, controller.signal)) {
-    switch (event.type) {
-      case "text-delta":
-        process.stdout.write(event.text);
-        break;
-      case "tool-call":
-        process.stderr.write(`
+  try {
+    for await (const event of loop.stream(resolved.input, controller.signal, {
+      persistAs: prompt
+    })) {
+      if (json) {
+        const line = eventToJsonLine(event);
+        if (line) process.stdout.write(`${line}
+`);
+      }
+      switch (event.type) {
+        case "text-delta":
+          if (!json) process.stdout.write(event.text);
+          break;
+        case "reasoning":
+          break;
+        case "tool-call":
+          if (!json) process.stderr.write(`
 [tool] ${event.name} ${JSON.stringify(event.args)}
 `);
-        break;
-      case "tool-result": {
-        const preview = event.content.length > 500 ? `${event.content.slice(0, 500)}... (truncated)` : event.content;
-        process.stderr.write(`[result] ${event.isError ? "ERROR: " : ""}${preview}
+          break;
+        case "tool-result": {
+          if (!json) {
+            const preview = event.content.length > 500 ? `${event.content.slice(0, 500)}... (truncated)` : event.content;
+            process.stderr.write(`[result] ${event.isError ? "ERROR: " : ""}${preview}
 `);
-        break;
-      }
-      case "finish":
-        if (event.usage) {
-          requests += 1;
-          promptTokens += event.usage.promptTokens;
-          completionTokens += event.usage.completionTokens;
-          totalTokens += event.usage.totalTokens;
+          }
+          break;
         }
-        break;
-      case "error":
-        process.stderr.write(`
-[error] ${event.error.message}
+        case "finish":
+          usage.add(event.usage);
+          break;
+        case "error":
+          if (!json) process.stderr.write(`
+[error] ${formatStreamError(event.error)}
 `);
-        exitCode = 1;
-        break;
+          exitCode = 1;
+          break;
+      }
+      if (exitCode !== 0) break;
+    }
+  } catch (error) {
+    if (!(error instanceof DOMException && error.name === "AbortError")) {
+      const message = error instanceof Error ? formatStreamError(error) : String(error);
+      process.stderr.write(`
+[error] ${message}
+`);
+      exitCode = 1;
     }
-    if (exitCode !== 0) break;
   }
-  if (requests > 0) {
-    process.stderr.write(
-      `[usage] ${requests} requests, ${promptTokens} prompt + ${completionTokens} completion = ${totalTokens} tokens
+  const usageLine = usage.toJsonLine();
+  if (usageLine) {
+    if (json) {
+      process.stdout.write(`${usageLine}
+`);
+    } else {
+      const t = usage.totals;
+      process.stderr.write(
+        `[usage] ${t.requests} requests, ${t.promptTokens} prompt + ${t.completionTokens} completion = ${t.totalTokens} tokens
 `
-    );
+      );
+    }
   }
-  process.stdout.write("\n");
+  if (!json) process.stdout.write("\n");
+  defaultTaskManager.cleanup();
   return exitCode;
 }
 var program = new Command();
-program.name("star").description("Star CLI \u2014 an AI agent command-line interface").version("0.1.0").option("-m, --model <model>", "model to use").option("--permission-mode <mode>", "permission mode: auto | ask | readonly").option("-p, --print <prompt>", "non-interactive print mode").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("-r, --resume <sessionId>", "resume a previous session").action(async (opts) => {
   const cwd = process.cwd();
+  if (opts.json && opts.print === void 0) {
+    console.error(
+      '--json requires print mode: use star -p "..." --json (the interactive REPL does not support JSON output).'
+    );
+    process.exit(1);
+  }
   let config;
   try {
     config = loadConfigSync(cwd, { model: opts.model, permissionMode: opts.permissionMode });
@@ -2215,7 +4450,7 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
     await loop.loadMessages(resumed.messages);
   }
   if (opts.print) {
-    process.exitCode = await printMode(loop, opts.print);
+    process.exitCode = await printMode(loop, opts.print, cwd, Boolean(opts.json));
     return;
   }
   renderRepl(loop, {