@cryer/star-cli 0.1.1 → 0.1.2

package/dist/main.js

@@ -124,6 +124,51 @@ 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";
 
@@ -174,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];
@@ -200,9 +248,12 @@ function isSensitivePath(p) {
   return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
 }
 function checkPermission(mode, req, ctx, allowRules = []) {
+  if (mode === "yolo") {
+    return "allow";
+  }
   const command = getStringArg(req.args, "command");
   const filePath = getStringArg(req.args, "path");
-  if (req.toolName === "bash" && command !== void 0 && 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) {
@@ -222,16 +273,78 @@ function checkPermission(mode, req, ctx, allowRules = []) {
   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;
@@ -243,14 +356,41 @@ 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, opts) {
+    this.syncSystemMessage();
     const userMessage = { role: "user", content: input };
     this.messages.push(userMessage);
+    this.turnMarkers.push({ seq: beginTurn(), userIndex: this.messages.length - 1 });
     await this.persist(
       opts?.persistAs !== void 0 ? { role: "user", content: opts.persistAs } : userMessage
     );
@@ -269,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;
@@ -280,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;
       }
@@ -299,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) {
@@ -349,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
@@ -383,11 +571,16 @@ ${summary}`
       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 };
       }
@@ -410,13 +603,75 @@ ${summary}`
   }
 };
 
+// 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 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) };
+}
+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 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;
+}
+
 // src/cli/mentions.ts
-import { readFile, stat as stat2 } from "fs/promises";
-import path3 from "path";
+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 path2 from "path";
+import path3 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
 async function walkFiles(root, skipDirs = SKIP_DIRS) {
   const out = [];
@@ -426,7 +681,7 @@ async function walkFiles(root, skipDirs = SKIP_DIRS) {
       return;
     }
     for (const entry of entries) {
-      const abs = path2.join(dir, entry.name);
+      const abs = path3.join(dir, entry.name);
       const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
@@ -482,7 +737,7 @@ function matchesGlob(pattern, relPath) {
   return globToRegExp(normalized).test(relPath);
 }
 function isSensitivePath2(filePath) {
-  const base = path2.basename(filePath);
+  const base = path3.basename(filePath);
   if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
     return false;
   }
@@ -538,7 +793,7 @@ async function resolveMentions(text, cwd) {
   const attached = [];
   const skipped = [];
   for (const mention of mentions) {
-    const abs = path3.resolve(cwd, mention);
+    const abs = path4.resolve(cwd, mention);
     if (isSensitivePath2(abs)) {
       skipped.push({ path: mention, reason: "sensitive file" });
       continue;
@@ -556,7 +811,7 @@ async function resolveMentions(text, cwd) {
       skipped.push({ path: mention, reason: `exceeds ${MAX_MENTION_BYTES / 1024}KB limit` });
       continue;
     }
-    const buf = await readFile(abs).catch(() => null);
+    const buf = await readFile2(abs).catch(() => null);
     if (!buf) {
       skipped.push({ path: mention, reason: "unreadable" });
       continue;
@@ -574,29 +829,72 @@ ${buf.toString("utf8")}
   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 Box7, render, useApp, useInput as useInput3 } from "ink";
+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 path5 from "path";
+import path6 from "path";
 import { parse, stringify } from "smol-toml";
 
 // src/config/paths.ts
 import os from "os";
-import path4 from "path";
+import path5 from "path";
 function starHome() {
-  return process.env.STAR_HOME ?? path4.join(os.homedir(), ".star-cli");
+  return process.env.STAR_HOME ?? path5.join(os.homedir(), ".star-cli");
 }
 function globalConfigPath() {
-  return path4.join(starHome(), "config.toml");
+  return path5.join(starHome(), "config.toml");
 }
 function sessionsDir() {
-  return path4.join(starHome(), "sessions");
+  return path5.join(starHome(), "sessions");
 }
 function projectConfigPath(cwd) {
-  return path4.join(cwd, ".star", "config.toml");
+  return path5.join(cwd, ".star", "config.toml");
 }
 
 // src/config/save.ts
@@ -614,10 +912,23 @@ async function addAllowRule(rule) {
   if (allow.includes(rule)) return false;
   permissions.allow = [...allow, rule];
   raw.permissions = permissions;
-  await fs.promises.mkdir(path5.dirname(filePath), { recursive: true });
+  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";
@@ -683,13 +994,17 @@ function createModel(config, modelName) {
 
 // src/session/store.ts
 import fs2 from "fs/promises";
-import path6 from "path";
+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;
@@ -705,13 +1020,13 @@ var SessionStore = class _SessionStore {
   initialized = false;
   constructor(id) {
     this.id = id;
-    this.dir = path6.join(sessionsDir(), id);
+    this.dir = path7.join(sessionsDir(), id);
   }
   metaPath() {
-    return path6.join(this.dir, "meta.json");
+    return path7.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path6.join(this.dir, "messages.jsonl");
+    return path7.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
     const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
@@ -720,15 +1035,20 @@ var SessionStore = class _SessionStore {
   }
   static async open(id) {
     const store = new _SessionStore(id);
+    let raw;
+    try {
+      raw = await fs2.readFile(store.metaPath(), "utf8");
+    } catch {
+      return null;
+    }
     try {
-      const raw = await fs2.readFile(store.metaPath(), "utf8");
       const meta = JSON.parse(raw);
       if (meta.id !== id) return null;
-      store.initialized = true;
-      return store;
     } catch {
-      return null;
+      debugWarn(`session ${id}: corrupt meta.json, using defaults`);
     }
+    store.initialized = true;
+    return store;
   }
   static async list(cwd) {
     let entries;
@@ -740,7 +1060,7 @@ var SessionStore = class _SessionStore {
     const metas = [];
     for (const entry of entries) {
       try {
-        const raw = await fs2.readFile(path6.join(sessionsDir(), entry, "meta.json"), "utf8");
+        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 {
@@ -801,14 +1121,24 @@ 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 fs2.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();
@@ -839,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) {
@@ -862,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 path7 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(path7.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path8.delimiter)) {
     if (!dir || exclude?.(dir)) {
       continue;
     }
-    const full = path7.join(dir, exe);
+    const full = path8.join(dir, exe);
     if (existsSync(full)) {
       return full;
     }
@@ -893,7 +1274,7 @@ function resolveShell() {
   }
   const gitExe = findOnPath("git.exe");
   if (gitExe) {
-    const sibling = path7.join(path7.dirname(path7.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" };
     }
@@ -913,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) {
@@ -938,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) => {
@@ -999,47 +1396,120 @@ Command timed out after ${timeoutSeconds}s`,
   }
 };
 
-// src/tools/fs/edit.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import path9 from "path";
-import { z as z2 } from "zod";
-
-// src/tools/fs/snapshots.ts
-import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
-import path8 from "path";
-var MAX_SNAPSHOTS = 50;
-var stack = [];
-async function captureSnapshot(filePath, toolName) {
-  let content = null;
-  let existed = false;
-  try {
-    content = await readFile2(filePath, "utf8");
-    existed = true;
-  } catch {
+// 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);
   }
-  return { path: filePath, existed, content, toolName, timestamp: Date.now() };
-}
-function pushSnapshot(snapshot) {
-  stack.push(snapshot);
-  if (stack.length > MAX_SNAPSHOTS) {
-    stack.splice(0, stack.length - MAX_SNAPSHOTS);
+  get(id) {
+    const rec = this.records.get(id);
+    return rec ? this.snapshot(rec) : void 0;
   }
-}
-async function undoLastSnapshot() {
-  const snapshot = stack.pop();
-  if (!snapshot) {
-    return "Nothing to undo.";
+  list() {
+    return [...this.records.values()].map((rec) => this.snapshot(rec));
   }
-  if (snapshot.existed && snapshot.content !== null) {
-    await mkdir(path8.dirname(snapshot.path), { recursive: true });
-    await writeFile(snapshot.path, snapshot.content, "utf8");
-    return `Restored ${snapshot.path} to its state before ${snapshot.toolName}.`;
+  runningCount() {
+    let count = 0;
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") count += 1;
+    }
+    return count;
   }
-  await rm(snapshot.path, { force: true });
-  return `Deleted ${snapshot.path} (it did not exist before ${snapshot.toolName}).`;
-}
+  kill(id) {
+    const rec = this.records.get(id);
+    if (!rec || rec.status !== "running") return void 0;
+    this.terminate(rec, "stopped");
+    return this.snapshot(rec);
+  }
+  cleanup() {
+    const killed = [];
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") {
+        this.terminate(rec, "stopped");
+        killed.push(this.snapshot(rec));
+      }
+    }
+    return killed;
+  }
+  terminate(rec, status) {
+    killTree(rec.child);
+    this.finish(rec, status, null);
+  }
+  finish(rec, status, exitCode) {
+    if (rec.timer) clearTimeout(rec.timer);
+    rec.status = status;
+    rec.exitCode = exitCode;
+    rec.endedAt = Date.now();
+    this.emitUpdate(rec);
+  }
+  emitUpdate(rec) {
+    this.emit("update", this.snapshot(rec));
+  }
+  snapshot(rec) {
+    return {
+      id: rec.id,
+      command: rec.command,
+      description: rec.description,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      endedAt: rec.endedAt,
+      exitCode: rec.exitCode,
+      output: rec.truncated ? TRUNCATED_PREFIX + rec.output : rec.output
+    };
+  }
+};
+var defaultTaskManager = new TaskManager();
 
 // src/tools/fs/edit.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
+import { z as z2 } from "zod";
 var schema2 = z2.object({
   path: z2.string().describe("File path, absolute or relative to the working directory"),
   old_string: z2.string().min(1).describe("Exact text to replace"),
@@ -1085,7 +1555,8 @@ var editFileTool = {
       existed: true,
       content,
       toolName: "edit_file",
-      timestamp: Date.now()
+      timestamp: Date.now(),
+      turn: currentTurnSeq()
     });
     return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
   }
@@ -1278,19 +1749,69 @@ var writeFileTool = {
   }
 };
 
+// src/tools/tasks.ts
+import { z as z7 } from "zod";
+var idSchema = z7.object({
+  id: z7.string().describe("Task id, e.g. task-1")
+});
+var taskListTool = {
+  name: "task_list",
+  description: "List background shell tasks with status, runtime, and exit code.",
+  permission: "read",
+  parameters: z7.object({}),
+  execute() {
+    return Promise.resolve({ content: formatTaskList(defaultTaskManager.list()) });
+  }
+};
+var taskOutputTool = {
+  name: "task_output",
+  description: "Read the current output of a background shell task (works while still running).",
+  permission: "read",
+  parameters: idSchema,
+  execute(args) {
+    const task = defaultTaskManager.get(args.id);
+    if (!task) {
+      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+    }
+    const body = task.output.replace(/\s+$/, "") || "(no output yet)";
+    return Promise.resolve({ content: `${formatTaskLine(task)}
+${body}` });
+  }
+};
+var taskKillTool = {
+  name: "task_kill",
+  description: "Stop a running background shell task (kills the whole process tree).",
+  permission: "exec",
+  parameters: idSchema,
+  execute(args) {
+    const task = defaultTaskManager.get(args.id);
+    if (!task) {
+      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+    }
+    if (task.status !== "running") {
+      return Promise.resolve({
+        content: `Task ${args.id} is not running (status: ${task.status}).`,
+        isError: true
+      });
+    }
+    defaultTaskManager.kill(args.id);
+    return Promise.resolve({ content: `Task ${args.id} stopped.` });
+  }
+};
+
 // src/tools/todo.ts
 import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 import path14 from "path";
-import { z as z7 } from "zod";
-var todoItemSchema = z7.object({
-  id: z7.number().int(),
-  title: z7.string(),
-  status: z7.enum(["pending", "in_progress", "done"])
+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 path14.join(cwd, ".star", "todos.json");
 }
@@ -1374,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) => {
@@ -1508,15 +2029,15 @@ var webFetchTool = {
 };
 
 // src/tools/web/search.ts
-import { z as z9 } from "zod";
+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 = z9.object({
-  query: z9.string().min(1).describe("The search query"),
-  maxResults: z9.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+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})`
   )
 });
@@ -1635,6 +2156,9 @@ var ToolRegistry = class {
       bashTool,
       webFetchTool,
       webSearchTool,
+      taskListTool,
+      taskOutputTool,
+      taskKillTool,
       ...createTodoTools()
     ]) {
       this.register(tool);
@@ -1663,9 +2187,27 @@ function createDefaultRegistry() {
   return registry;
 }
 
-// src/cli/commands/actions.ts
-import fs3 from "fs/promises";
+// 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;
@@ -1726,15 +2268,15 @@ async function exportSession(opts) {
     return "Nothing to export: the session has no messages.";
   }
   const sessionId = sessionStore?.id ?? `unknown-${Date.now()}`;
-  const target = arg ? path15.resolve(cwd, arg) : path15.resolve(cwd, `star-session-${sessionId}.md`);
+  const target = arg ? path16.resolve(cwd, arg) : path16.resolve(cwd, `star-session-${sessionId}.md`);
   const existed = await fileExists(target);
-  await fs3.mkdir(path15.dirname(target), { recursive: true });
-  await fs3.writeFile(target, renderSessionMarkdown(sessionId, messages));
+  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 fs3.access(target);
+    await fs4.access(target);
     return true;
   } catch {
     return false;
@@ -1865,6 +2407,14 @@ ${lines.join("\n")}`);
       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",
@@ -1897,14 +2447,450 @@ ${lines.join("\n")}`);
       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: "Revert the last file change made by write_file or edit_file",
+    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}`
+  });
+  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
+  });
+  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
@@ -1936,8 +2922,24 @@ function parseSlashCommand(input) {
   };
 }
 
-// src/cli/components/InputBox.tsx
+// src/cli/components/ExitPlanPrompt.tsx
 import { Box, Text, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+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
@@ -1950,7 +2952,7 @@ function filterCommands(input, commands) {
 }
 
 // src/cli/components/InputBox.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function InputBox({
   isStreaming,
   disabled,
@@ -1980,7 +2982,7 @@ function InputBox({
     const text = `/${cmd.name} `;
     edit(text, text.length);
   };
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (key.ctrl && input === "c") {
       if (isStreaming || disabled) {
         onInterrupt();
@@ -2011,6 +3013,7 @@ function InputBox({
       return;
     }
     if (key.tab) {
+      if (key.shift) return;
       if (suggestions.length > 0) {
         completeHighlighted();
         return;
@@ -2091,164 +3094,176 @@ function InputBox({
   const before = value.slice(0, cursor);
   const at = value[cursor] ?? " ";
   const after = value.slice(cursor + 1);
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__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__ */ jsx(Box, { flexDirection: "column", paddingLeft: 2, children: suggestions.map(
-      (cmd, index) => index === activeIndex ? /* @__PURE__ */ jsx(Text, { bold: true, inverse: true, children: `/${cmd.name} - ${cmd.description}` }, cmd.name) : /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "cyan", children: `/${cmd.name}` }),
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` - ${cmd.description}` })
+    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 }),
-      message.note && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: message.note })
+    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 (saved to config)" })
+    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 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: [
+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
     ] }),
-    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+      "bg: ",
+      backgroundTasks.length,
+      " (",
+      labels,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
       tokens,
       " tokens"
     ] }),
-    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
       "mode: ",
       permissionMode
     ] })
   ] });
-}
+});
 
 // 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/components/ToolCallCard.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";
-function ToolCallCard({ card }) {
-  const color = card.isError ? "red" : "magenta";
-  const preview = card.result !== void 0 ? previewLines(card.result, 10) : null;
+var StreamingMessage = memo3(function StreamingMessage2({
+  text,
+  continuation
+}) {
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs6(Text6, { bold: true, color, children: [
-      "tool: ",
-      card.name,
-      card.isError ? " (error)" : ""
+    !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"
     ] }),
-    /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: card.argsSummary }),
-    preview && /* @__PURE__ */ jsxs6(Text6, { color, children: [
-      preview.text,
-      preview.truncated ? "\n... (truncated)" : ""
+    tail !== "" && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      " ",
+      tail
     ] })
   ] });
 }
+
+// src/cli/components/ToolCallCard.tsx
 function formatToolCard(card) {
   const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
   if (card.result === void 0) return header;
@@ -2257,73 +3272,421 @@ function formatToolCard(card) {
 ${preview.text}${preview.truncated ? "\n... (truncated)" : ""}`;
 }
 
-// src/cli/repl.tsx
-import { jsx as jsx6, jsxs as jsxs7 } from "react/jsx-runtime";
-var FLUSH_INTERVAL_MS = 30;
-function emptyUsage() {
-  return { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+// 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 formatUsage(usage) {
-  return `API usage this session: ${usage.requests} requests, ${usage.promptTokens} prompt + ${usage.completionTokens} completion = ${usage.totalTokens} tokens`;
+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)`;
 }
-function Repl({
-  backend,
-  model,
-  permissionMode,
-  config,
-  cwd,
-  sessionStore,
-  initialMessages,
-  initialUsage
-}) {
-  const { exit } = useApp();
+
+// 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/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/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 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 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`;
+}
+function Repl({
+  backend,
+  model,
+  permissionMode,
+  config,
+  cwd,
+  sessionStore,
+  initialMessages,
+  initialUsage
+}) {
+  const { exit } = useApp();
   const [initialDisplay] = useState2(() => buildDisplayMessages(initialMessages ?? []));
   const [messages, setMessages] = useState2(initialDisplay);
   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, note) => {
-    setMessages((prev) => [...prev, { id: nextIdRef.current++, role, text, note }]);
+  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) => {
+      target.confirmHandler = async (req) => {
         if (isAllowedByRules([...alwaysAllowedRef.current], req)) {
-          return Promise.resolve(true);
+          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;
@@ -2332,8 +3695,25 @@ 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) => {
@@ -2382,32 +3762,205 @@ 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 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) => {
+      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);
+      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(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)
+            });
+            setActivity(`running ${event.name}: ${summarizeArgs(event.args, 60)}`);
+          } else if (event.type === "tool-result") {
+            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;
+              usage.requests += 1;
+              usage.promptTokens += event.usage.promptTokens;
+              usage.completionTokens += event.usage.completionTokens;
+              usage.totalTokens += event.usage.totalTokens;
+              setUsageVersion((v) => v + 1);
+              sessionStore?.addUsage(event.usage).catch(() => {
+              });
+            }
+          } else if (event.type === "error") {
+            pushMessage("system", `Error: ${formatStreamError(event.error)}`);
+          }
+        }
+      } catch (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 {
+        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) {
+          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();
+        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: () => {
-        setMessages([]);
-        setEpoch((e) => e + 1);
+        redrawMessages([]);
       },
-      exit: () => exit(),
+      exit: () => handleExit(),
       listModels: () => {
         const models = listModels(config);
         if (models.length === 0) return "No models configured.";
@@ -2428,7 +3981,12 @@ ${lines.join("\n")}`;
         await store.load(cwd);
         return formatTodos(store.list());
       },
-      showUsage: () => formatUsage(usageRef.current),
+      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 {
@@ -2445,13 +4003,79 @@ ${lines.join("\n")}`;
         if (result.compacted && result.messages) {
           const display = buildDisplayMessages(result.messages);
           nextIdRef.current = display.length;
-          setMessages(display);
-          setEpoch((e) => e + 1);
+          applyMessages(display);
         }
         return result.message;
       },
       exportSession: (arg) => exportSession({ backend: backendRef.current, sessionStore, cwd, arg }),
-      undo: () => undoLastSnapshot(),
+      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}`,
@@ -2459,103 +4083,69 @@ ${lines.join("\n")}`;
         `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, exit, config, cwd, switchModel, resume, sessionStore]);
-  const runStream = useCallback(
-    async (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}`);
-      }
+  }, [
+    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;
-      streamedRef.current = "";
-      setStreamingText("");
-      setIsStreaming(true);
-      flushTimerRef.current = setInterval(() => {
-        setStreamingText(streamedRef.current);
-      }, FLUSH_INTERVAL_MS);
       try {
-        for await (const event of backendRef.current.stream(resolved.input, controller.signal, {
-          persistAs: input
-        })) {
-          if (event.type === "text-delta") {
-            streamedRef.current += event.text;
-          } else if (event.type === "tool-call") {
-            toolCardsRef.current.set(event.id, {
-              id: event.id,
-              name: event.name,
-              argsSummary: summarizeArgs(event.args)
-            });
-            setCardsVersion((v) => v + 1);
-          } 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);
-            }
-          } else if (event.type === "finish") {
-            if (event.usage) {
-              const usage = usageRef.current;
-              usage.requests += 1;
-              usage.promptTokens += event.usage.promptTokens;
-              usage.completionTokens += event.usage.completionTokens;
-              usage.totalTokens += event.usage.totalTokens;
-              setUsageVersion((v) => v + 1);
-              sessionStore?.addUsage(event.usage).catch(() => {
-              });
-            }
-          } else if (event.type === "error") {
-            pushMessage("system", `Error: ${event.error.message}`);
-          }
-        }
-      } catch (error) {
-        if (!(error instanceof DOMException && error.name === "AbortError")) {
-          pushMessage("system", `Error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      } finally {
-        if (flushTimerRef.current !== null) {
-          clearInterval(flushTimerRef.current);
-          flushTimerRef.current = null;
-        }
-        abortRef.current = null;
-        setIsStreaming(false);
-        const finalText = streamedRef.current;
-        streamedRef.current = "";
-        setStreamingText(null);
-        if (finalText.length > 0) {
+        const outcome = await executeShellBang(raw, cwd, controller.signal);
+        if (!outcome.ok) {
           pushMessage(
-            "assistant",
-            controller.signal.aborted ? `${finalText} [interrupted]` : finalText
+            "system",
+            outcome.reason === "dangerous" ? `Refused to run dangerous command: ${raw.trim()}` : "Usage: !<command>"
           );
+          return;
         }
-        for (const card of toolCardsRef.current.values()) {
-          pushMessage("tool", formatToolCard(card));
+        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);
         }
-        toolCardsRef.current.clear();
-        setCardsVersion((v) => v + 1);
-        const p = pendingRef.current;
-        if (p) {
-          setPendingPermission(null);
-          p.resolve(false);
+      } finally {
+        if (abortRef.current === controller) {
+          abortRef.current = null;
         }
       }
     },
-    [pushMessage, setPendingPermission, sessionStore, cwd]
+    [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;
@@ -2569,41 +4159,59 @@ ${lines.join("\n")}`;
       }
       void runStream(text);
     },
-    [registry, pushMessage, runStream]
+    [registry, pushMessage, runStream, runShellBang]
   );
   const commandHints = useMemo(
     () => registry.list().map((cmd) => ({ name: cmd.name, description: cmd.description })),
     [registry]
   );
-  const cards = [...toolCardsRef.current.values()];
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx6(MessageList, { messages }, `messages-${epoch}`),
-    cards.length > 0 && /* @__PURE__ */ jsx6(Box7, { flexDirection: "column", children: cards.map((card) => /* @__PURE__ */ jsx6(ToolCallCard, { card }, card.id)) }, `cards-${cardsVersion}`),
-    streamingText !== null && /* @__PURE__ */ jsx6(StreamingMessage, { text: streamingText }),
-    pending && /* @__PURE__ */ jsx6(PermissionPrompt, { request: pending.request, onDecision: handleDecision }),
+    (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
-      },
-      `status-${usageVersion}`
+        permissionMode: permissionModeState,
+        tokens: usageRef.current.totalTokens,
+        backgroundTasks: bgLabels
+      }
     )
   ] });
 }
 function renderRepl(backend, opts) {
+  process.on("exit", () => {
+    defaultTaskManager.cleanup();
+  });
   return render(
     /* @__PURE__ */ jsx6(
       Repl,
@@ -2622,36 +4230,42 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs4 from "fs";
+import fs7 from "fs";
 import { parse as parse2 } from "smol-toml";
 
 // src/config/schema.ts
-import { z as z10 } from "zod";
-var ProviderConfigSchema = z10.object({
-  name: z10.string(),
-  protocol: z10.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
-  baseURL: z10.string(),
-  apiKeyEnv: z10.string().optional(),
-  apiKey: z10.string().optional(),
-  headers: z10.record(z10.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 = z10.object({
-  name: z10.string(),
-  provider: z10.string(),
-  model: z10.string(),
-  maxTokens: z10.number().int().positive().optional()
+var ModelConfigSchema = z11.object({
+  name: z11.string(),
+  provider: z11.string(),
+  model: z11.string(),
+  maxTokens: z11.number().int().positive().optional(),
+  promptPrice: z11.number().nonnegative().optional(),
+  completionPrice: z11.number().nonnegative().optional()
 });
-var PermissionsConfigSchema = z10.object({
-  allow: z10.array(z10.string()).default([])
+var PermissionsConfigSchema = z11.object({
+  allow: z11.array(z11.string()).default([])
 });
-var ConfigSchema = z10.object({
-  defaultModel: z10.string().default(""),
-  permissionMode: z10.enum(["auto", "ask", "readonly"]).default("ask"),
-  providers: z10.array(ProviderConfigSchema).default([]),
-  models: z10.array(ModelConfigSchema).default([]),
-  maxSteps: z10.number().int().positive().default(50),
-  contextMaxTokens: z10.number().int().positive().default(1e5),
-  contextCompaction: z10.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: [] })
 });
 
@@ -2682,8 +4296,8 @@ function applyOverrides(config, overrides) {
   return merged;
 }
 function readTomlFileSync(filePath) {
-  if (!fs4.existsSync(filePath)) return {};
-  const content = fs4.readFileSync(filePath, "utf8");
+  if (!fs7.existsSync(filePath)) return {};
+  const content = fs7.readFileSync(filePath, "utf8");
   return parseTomlFile(content, filePath);
 }
 function loadConfigSync(cwd, overrides) {
@@ -2710,7 +4324,7 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     sessionStore
   });
 }
-async function printMode(loop, prompt, cwd) {
+async function printMode(loop, prompt, cwd, json) {
   const controller = new AbortController();
   process.on("SIGINT", () => controller.abort());
   const resolved = await resolveMentions(prompt, cwd);
@@ -2722,58 +4336,83 @@ async function printMode(loop, prompt, cwd) {
     process.stderr.write(`[skipped] @${skip.path}: ${skip.reason}
 `);
   }
-  let requests = 0;
-  let promptTokens = 0;
-  let completionTokens = 0;
-  let totalTokens = 0;
+  const usage = new UsageTracker();
   let exitCode = 0;
-  for await (const event of loop.stream(resolved.input, controller.signal, {
-    persistAs: prompt
-  })) {
-    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 });
@@ -2811,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, cwd);
+    process.exitCode = await printMode(loop, opts.print, cwd, Boolean(opts.json));
     return;
   }
   renderRepl(loop, {