@cryer/star-cli 0.3.4 → 0.3.6

package/dist/main.js

@@ -44,7 +44,7 @@ import {
   resolveSnapshotContent,
   rewindToSnapshot,
   summarizeMessages
-} from "./chunk-K3R42LOX.js";
+} from "./chunk-I6FDXAWX.js";
 import {
   envFilePath,
   globalConfigPath,
@@ -57,6 +57,198 @@ import {
 // src/main.tsx
 import { Command } from "commander";
 
+// src/cli/markdown.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+function styled(open, text, base) {
+  const reopen = base ? `${ESC}${base}m` : "";
+  return `${ESC}${open}m${text}${RESET}${reopen}`;
+}
+var bold = (t, b) => styled("1", t, b);
+var dim = (t, b) => styled("2", t, b);
+var italic = (t, b) => styled("3", t, b);
+var underline = (t, b) => styled("4", t, b);
+var strike = (t, b) => styled("9", t, b);
+var yellow = (t, b) => styled("33", t, b);
+var cyanBold = (t, b) => styled("1;36", t, b);
+function cellWidth(text) {
+  let width = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp >= 768 && cp <= 879 || cp === 8205 || cp >= 65024 && cp <= 65039) {
+      continue;
+    }
+    if (cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 40959 || cp >= 40960 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 126976 && cp <= 129791 || cp >= 131072 && cp <= 262141) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+var IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g;
+var LINK_RE = /\[([^\]]+)\]\(([^)\s]+)\)/g;
+var BOLD_RE = /\*\*([^*\n]+)\*\*|__([^_\n]+)__/g;
+var STRIKE_RE = /~~([^~\n]+)~~/g;
+var STAR_ITALIC_RE = /\*([^*\n]+)\*/g;
+var UNDERSCORE_ITALIC_RE = /(^|[^\w])_([^_\n]+)_(?=[^\w]|$)/g;
+function renderInline(text, base = "") {
+  return text.split(/`([^`\n]+)`/).map((segment, index) => {
+    if (index % 2 === 1) return yellow(segment, base);
+    return segment.replace(IMAGE_RE, (_m, alt) => dim(`[image: ${alt}]`, base)).replace(
+      LINK_RE,
+      (_m, label, url) => `${underline(label, base)}${dim(` (${url})`, base)}`
+    ).replace(BOLD_RE, (_m, star, under) => bold(star ?? under, base)).replace(STRIKE_RE, (_m, t) => strike(t, base)).replace(STAR_ITALIC_RE, (_m, t) => italic(t, base)).replace(UNDERSCORE_ITALIC_RE, (_m, pre, t) => pre + italic(t, base));
+  }).join("");
+}
+var HEADING_RE = /^#{1,6}\s+(.*)$/;
+var HR_RE = /^\s{0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
+var QUOTE_RE = /^\s{0,3}>\s?(.*)$/;
+var FENCE_RE = /^\s{0,3}(```+|~~~+)/;
+var TABLE_SEPARATOR_CELL_RE = /^:?-{3,}:?$/;
+function isTableSeparator(line) {
+  const cells = splitTableRow(line);
+  return cells !== null && cells.length > 0 && cells.every((cell) => TABLE_SEPARATOR_CELL_RE.test(cell.trim()));
+}
+function splitTableRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) return null;
+  const stripped = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  return stripped.split("|").map((cell) => cell.trim());
+}
+var MIN_COLUMN_WIDTH = 4;
+function wrapCell(text, width) {
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  for (const ch of text) {
+    const w = cellWidth(ch);
+    if (currentWidth > 0 && currentWidth + w > width) {
+      const lastSpace = current.lastIndexOf(" ");
+      if (lastSpace > 0 && ch !== " ") {
+        lines.push(current.slice(0, lastSpace));
+        current = current.slice(lastSpace + 1) + ch;
+      } else {
+        lines.push(current);
+        current = ch === " " ? "" : ch;
+      }
+      currentWidth = cellWidth(current);
+    } else {
+      current += ch;
+      currentWidth += w;
+    }
+  }
+  if (current.length > 0 || lines.length === 0) lines.push(current);
+  return lines;
+}
+function renderTable(lines, base, maxWidth) {
+  const rows = [];
+  for (const line of lines) {
+    const cells = splitTableRow(line);
+    if (cells) rows.push(cells);
+  }
+  if (rows.length < 2) return lines;
+  const columnCount = Math.max(...rows.map((row) => row.length));
+  const widths = Array.from(
+    { length: columnCount },
+    (_, column) => Math.max(1, ...rows.map((row) => cellWidth(row[column] ?? "")))
+  );
+  const totalWidth = () => 2 + widths.reduce((sum, width) => sum + width, 0) + 3 * (columnCount - 1);
+  while (totalWidth() > maxWidth) {
+    const widest = widths.indexOf(Math.max(...widths));
+    if (widths[widest] === void 0 || widths[widest] <= MIN_COLUMN_WIDTH) break;
+    widths[widest] -= 1;
+  }
+  const joiner = ` ${dim("\u2502", base)} `;
+  const formatRow = (row, style) => {
+    const wrapped = widths.map((width, column) => wrapCell(row[column] ?? "", width));
+    const height = Math.max(...wrapped.map((cell) => cell.length));
+    const out = [];
+    for (let line = 0; line < height; line++) {
+      out.push(
+        `  ${widths.map((width, column) => {
+          const raw = wrapped[column]?.[line] ?? "";
+          return style(raw) + " ".repeat(Math.max(0, width - cellWidth(raw)));
+        }).join(joiner).trimEnd()}`
+      );
+    }
+    return out;
+  };
+  const separator = dim(`  ${widths.map((width) => "\u2500".repeat(width)).join("\u2500\u253C\u2500")}`, base);
+  const [header, , ...body] = rows;
+  return [
+    ...formatRow(header, (cell) => bold(cell, base)),
+    separator,
+    ...body.flatMap((row, index) => {
+      const lines2 = formatRow(row, (cell) => renderInline(cell, base));
+      return index < body.length - 1 ? [...lines2, separator] : lines2;
+    })
+  ];
+}
+function committableLineCount(lines) {
+  let inFence = false;
+  let safe = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (FENCE_RE.test(line)) inFence = !inFence;
+    const isPipe = line.includes("|");
+    const nextIsPipe = i + 1 >= lines.length || (lines[i + 1] ?? "").includes("|");
+    if (!inFence && !(isPipe && nextIsPipe)) safe = i + 1;
+  }
+  return safe;
+}
+function renderMarkdown(text, base = "", maxWidth = 80) {
+  const lines = text.split("\n");
+  const out = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (inFence) {
+      if (FENCE_RE.test(line)) {
+        inFence = false;
+      } else {
+        out.push(`${dim("  \u258E", base)}${line}`);
+      }
+      continue;
+    }
+    const fence = FENCE_RE.exec(line);
+    if (fence) {
+      inFence = true;
+      const lang = line.trim().slice(fence[1]?.length ?? 0).trim();
+      if (lang) out.push(dim(`  \u258E ${lang}`, base));
+      continue;
+    }
+    const heading = HEADING_RE.exec(line);
+    if (heading) {
+      out.push(cyanBold(heading[1] ?? "", base));
+      continue;
+    }
+    if (HR_RE.test(line)) {
+      out.push(dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500", base));
+      continue;
+    }
+    const quote = QUOTE_RE.exec(line);
+    if (quote) {
+      out.push(`${dim("  \u258E", base)}${italic(renderInline(quote[1] ?? "", base), base)}`);
+      continue;
+    }
+    const headerCells = splitTableRow(line);
+    if (headerCells && i + 1 < lines.length && isTableSeparator(lines[i + 1] ?? "")) {
+      const block = [line];
+      let j = i + 1;
+      while (j < lines.length && splitTableRow(lines[j] ?? "") !== null) {
+        block.push(lines[j] ?? "");
+        j += 1;
+      }
+      out.push(...renderTable(block, base, maxWidth));
+      i = j - 1;
+      continue;
+    }
+    out.push(renderInline(line, base));
+  }
+  return out.join("\n");
+}
+
 // src/cli/terminal-text.ts
 var UNSAFE_CHARS = /[\x00-\x09\x0b-\x1f\x7f]/;
 var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f]/g;
@@ -85,9 +277,11 @@ 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) };
+  const lines = complete.split("\n");
+  const count = committableLineCount(lines);
+  if (count < minCompleteLines) return null;
+  const committed = lines.slice(0, count).join("\n");
+  return { committed, rest: text.slice(committed.length + 1) };
 }
 function formatStreamError(error) {
   if (error.message.includes("Unexpected end of JSON input")) {
@@ -491,8 +685,8 @@ var UsageTracker = class {
 };
 
 // src/cli/repl.tsx
-import { Box as Box13, Text as Text14, render, useApp, useInput as useInput8 } from "ink";
-import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef5, useState as useState5 } from "react";
+import { Box as Box13, Text as Text14, render, useApp } from "ink";
+import { useCallback, useEffect as useEffect3, useMemo, useRef as useRef6, useState as useState5 } from "react";
 
 // src/config/save.ts
 import fs from "fs";
@@ -600,6 +794,75 @@ async function savePermissionMode(mode) {
   await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
   await writeFileAtomic(filePath, upsertTopLevelKeyText(content, "permissionMode", mode));
 }
+function unquoteTomlString(raw) {
+  if (raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function setReasoningEffortInToml(content, modelName, effort) {
+  const lines = content.split("\n");
+  const header = /^\s*\[\[\s*models\s*\]\]\s*(?:#.*)?$/;
+  const anyHeader = /^\s*\[/;
+  const nameLine = /^\s*name\s*=\s*("(?:[^"\\]|\\.)*"|'[^']*')/;
+  for (let start = 0; start < lines.length; start++) {
+    if (!header.test(lines[start] ?? "")) continue;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+      if (anyHeader.test(lines[i] ?? "")) {
+        end = i;
+        break;
+      }
+    }
+    let nameIndex = -1;
+    for (let i = start + 1; i < end; i++) {
+      const match = nameLine.exec(lines[i] ?? "");
+      if (match?.[1] && unquoteTomlString(match[1]) === modelName) {
+        nameIndex = i;
+        break;
+      }
+    }
+    if (nameIndex === -1) continue;
+    const keyLine = /^\s*reasoningEffort\s*=/;
+    for (let i = start + 1; i < end; i++) {
+      if (!keyLine.test(lines[i] ?? "")) continue;
+      if (effort === void 0) {
+        lines.splice(i, 1);
+      } else {
+        const comment = /\s+#.*$/.exec(lines[i] ?? "");
+        lines[i] = `reasoningEffort = ${tomlString(effort)}${comment?.[0] ?? ""}`;
+      }
+      return lines.join("\n");
+    }
+    if (effort === void 0) return content;
+    let insertAt = nameIndex + 1;
+    for (let i = start + 1; i < end; i++) {
+      if (/^\s*model\s*=/.test(lines[i] ?? "")) {
+        insertAt = i + 1;
+        break;
+      }
+    }
+    lines.splice(insertAt, 0, `reasoningEffort = ${tomlString(effort)}`);
+    return lines.join("\n");
+  }
+  return null;
+}
+async function saveReasoningEffort(modelName, effort) {
+  const filePath = globalConfigPath();
+  let content = "";
+  try {
+    content = await fs.promises.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const updated = setReasoningEffortInToml(content, modelName, effort);
+  if (updated === null) return false;
+  await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
+  await writeFileAtomic(filePath, updated);
+  return true;
+}
 
 // src/llm/provider.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
@@ -734,6 +997,14 @@ function createModel(config, modelName) {
       }).responses(modelConfig.model);
   }
 }
+function reasoningEffortMetadata(config, modelName) {
+  const modelConfig = resolveModelConfig(config, modelName);
+  if (!modelConfig.reasoningEffort) return void 0;
+  const provider = config.providers.find((p) => p.name === modelConfig.provider);
+  if (!provider || provider.protocol === "anthropic") return void 0;
+  const key = provider.protocol === "openai-responses" ? "openai" : provider.name;
+  return { [key]: { reasoningEffort: modelConfig.reasoningEffort } };
+}
 
 // src/session/checkpoints.ts
 import fs2 from "fs/promises";
@@ -827,6 +1098,12 @@ function debugWarn(message) {
   if (process.env.STAR_DEBUG === "1") process.stderr.write(`[star-cli] ${message}
 `);
 }
+var META_WRITE_MAX_ATTEMPTS = 5;
+var META_WRITE_RETRY_DELAY_MS = 25;
+function isTransientFsError(error) {
+  const code = error.code;
+  return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
 var FALLBACK_META = /* @__PURE__ */ Symbol("star.fallbackMeta");
 function isFallbackMeta(meta) {
   return meta[FALLBACK_META] === true;
@@ -901,17 +1178,33 @@ var SessionStore = class _SessionStore {
   // writers race the loop's own appends, and a truncated read once turned
   // fallbackMeta's empty defaults into a persisted wipe of model/cwd/usage.
   // A branded fallback meta is never written back for the same reason.
+  // A write that still fails after retries is dropped rather than thrown:
+  // meta.json is bookkeeping the cached meta rebuilds on the next write,
+  // while the conversation itself lives in messages.jsonl — killing the
+  // agent turn over a stale updatedAt would be the wrong trade.
   writeMeta(meta) {
     if (isFallbackMeta(meta)) return Promise.resolve();
     const tmp = `${this.metaPath()}.tmp-${process.pid}-${this.metaTmpSeq++}`;
     const run = this.metaWriteQueue.then(async () => {
-      try {
-        await fs3.writeFile(tmp, JSON.stringify(meta, null, 2));
-        await fs3.rename(tmp, this.metaPath());
-      } catch (error) {
-        await fs3.unlink(tmp).catch(() => {
-        });
-        throw error;
+      for (let attempt = 0; attempt < META_WRITE_MAX_ATTEMPTS; attempt++) {
+        try {
+          await fs3.writeFile(tmp, JSON.stringify(meta, null, 2));
+          await fs3.rename(tmp, this.metaPath());
+          return;
+        } catch (error) {
+          if (isTransientFsError(error) && attempt + 1 < META_WRITE_MAX_ATTEMPTS) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, META_WRITE_RETRY_DELAY_MS * (attempt + 1))
+            );
+            continue;
+          }
+          await fs3.unlink(tmp).catch(() => {
+          });
+          debugWarn(
+            `session ${this.id}: meta write failed (${error.code ?? String(error)}), skipping`
+          );
+          return;
+        }
       }
     });
     this.metaWriteQueue = run.catch(() => {
@@ -3162,17 +3455,295 @@ async function buildUndoTreeDiffs(cwd, tree) {
 }
 
 // src/cli/components/ConnectWizard.tsx
-import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
-import { useRef as useRef4, useState as useState4 } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import { useRef as useRef5, useState as useState4 } from "react";
+
+// src/cli/use-input.ts
+import { useStdin } from "ink";
+import { useEffect, useRef } from "react";
+
+// src/cli/keypress.ts
+var metaKeyCodeRe = /^(?:\u001B)([a-zA-Z0-9])$/;
+var fnKeyRe = /^(?:\u001B+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+var keyName = {
+  OP: "f1",
+  OQ: "f2",
+  OR: "f3",
+  OS: "f4",
+  "[11~": "f1",
+  "[12~": "f2",
+  "[13~": "f3",
+  "[14~": "f4",
+  "[[A": "f1",
+  "[[B": "f2",
+  "[[C": "f3",
+  "[[D": "f4",
+  "[[E": "f5",
+  "[15~": "f5",
+  "[17~": "f6",
+  "[18~": "f7",
+  "[19~": "f8",
+  "[20~": "f9",
+  "[21~": "f10",
+  "[23~": "f11",
+  "[24~": "f12",
+  "[A": "up",
+  "[B": "down",
+  "[C": "right",
+  "[D": "left",
+  "[E": "clear",
+  "[F": "end",
+  "[H": "home",
+  OA: "up",
+  OB: "down",
+  OC: "right",
+  OD: "left",
+  OE: "clear",
+  OF: "end",
+  OH: "home",
+  "[1~": "home",
+  "[2~": "insert",
+  "[3~": "delete",
+  "[4~": "end",
+  "[5~": "pageup",
+  "[6~": "pagedown",
+  "[[5~": "pageup",
+  "[[6~": "pagedown",
+  "[7~": "home",
+  "[8~": "end",
+  "[a": "up",
+  "[b": "down",
+  "[c": "right",
+  "[d": "left",
+  "[e": "clear",
+  "[2$": "insert",
+  "[3$": "delete",
+  "[5$": "pageup",
+  "[6$": "pagedown",
+  "[7$": "home",
+  "[8$": "end",
+  Oa: "up",
+  Ob: "down",
+  Oc: "right",
+  Od: "left",
+  Oe: "clear",
+  "[2^": "insert",
+  "[3^": "delete",
+  "[5^": "pageup",
+  "[6^": "pagedown",
+  "[7^": "home",
+  "[8^": "end",
+  "[Z": "tab"
+};
+var nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
+var shiftKeyCodes = /* @__PURE__ */ new Set([
+  "[a",
+  "[b",
+  "[c",
+  "[d",
+  "[e",
+  "[2$",
+  "[3$",
+  "[5$",
+  "[6$",
+  "[7$",
+  "[8$",
+  "[Z"
+]);
+var ctrlKeyCodes = /* @__PURE__ */ new Set([
+  "Oa",
+  "Ob",
+  "Oc",
+  "Od",
+  "Oe",
+  "[2^",
+  "[3^",
+  "[5^",
+  "[6^",
+  "[7^",
+  "[8^"
+]);
+function parseKeypress(s) {
+  const key = {
+    name: void 0,
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    sequence: s
+  };
+  if (s === "\r") {
+    key.name = "return";
+  } else if (s === "\n") {
+    key.name = "enter";
+  } else if (s === "	") {
+    key.name = "tab";
+  } else if (s === "\b" || s === "\x1B\b") {
+    key.name = "backspace";
+    key.meta = s.charAt(0) === "\x1B";
+  } else if (s === "\x7F" || s === "\x1B\x7F") {
+    key.name = "delete";
+    key.meta = s.charAt(0) === "\x1B";
+  } else if (s === "\x1B" || s === "\x1B\x1B") {
+    key.name = "escape";
+    key.meta = s.length === 2;
+  } else if (s === " " || s === "\x1B ") {
+    key.name = "space";
+    key.meta = s.length === 2;
+  } else if (s.length === 1 && s <= "") {
+    key.name = String.fromCharCode(s.charCodeAt(0) + "a".charCodeAt(0) - 1);
+    key.ctrl = true;
+  } else if (s.length === 1 && s >= "0" && s <= "9") {
+    key.name = "number";
+  } else if (s.length === 1 && s >= "a" && s <= "z") {
+    key.name = s;
+  } else if (s.length === 1 && s >= "A" && s <= "Z") {
+    key.name = s.toLowerCase();
+    key.shift = true;
+  }
+  const metaMatch = key.name === void 0 ? metaKeyCodeRe.exec(s) : null;
+  const fnMatch = key.name === void 0 && metaMatch === null ? fnKeyRe.exec(s) : null;
+  if (metaMatch) {
+    key.meta = true;
+    key.shift = /^[A-Z]$/.test(metaMatch[1] ?? "");
+  } else if (fnMatch) {
+    const segs = [...s];
+    if (segs[0] === "\x1B" && segs[1] === "\x1B") {
+      key.option = true;
+    }
+    const code = [fnMatch[1], fnMatch[2], fnMatch[4], fnMatch[6]].filter(Boolean).join("");
+    const modifier = Number(fnMatch[3] || fnMatch[5] || 1) - 1;
+    key.ctrl = !!(modifier & 4);
+    key.meta = !!(modifier & 10);
+    key.shift = !!(modifier & 1);
+    key.code = code;
+    key.name = keyName[code];
+    key.shift = shiftKeyCodes.has(code) || key.shift;
+    key.ctrl = ctrlKeyCodes.has(code) || key.ctrl;
+  }
+  return key;
+}
+function splitKeypresses(chunk) {
+  const units = [];
+  let i = 0;
+  const csiLength = (start) => {
+    let j = start;
+    while (j < chunk.length) {
+      const code = chunk.charCodeAt(j);
+      j += 1;
+      if (code >= 64 && code <= 126) break;
+    }
+    return j;
+  };
+  while (i < chunk.length) {
+    if (chunk[i] !== "\x1B") {
+      const next2 = chunk.indexOf("\x1B", i);
+      const end = next2 === -1 ? chunk.length : next2;
+      units.push(chunk.slice(i, end));
+      i = end;
+      continue;
+    }
+    const next = chunk[i + 1];
+    if (next === void 0) {
+      units.push("\x1B");
+      i += 1;
+    } else if (next === "[") {
+      const end = csiLength(i + 2);
+      units.push(chunk.slice(i, end));
+      i = end;
+    } else if (next === "O") {
+      const end = Math.min(i + 3, chunk.length);
+      units.push(chunk.slice(i, end));
+      i = end;
+    } else if (next === "\x1B" && (chunk[i + 2] === "[" || chunk[i + 2] === "O")) {
+      const end = chunk[i + 2] === "[" ? csiLength(i + 3) : Math.min(i + 4, chunk.length);
+      units.push(chunk.slice(i, end));
+      i = end;
+    } else if (next === "\x1B") {
+      units.push("\x1B");
+      i += 1;
+    } else {
+      units.push(chunk.slice(i, i + 2));
+      i += 2;
+    }
+  }
+  return units;
+}
+var INCOMPLETE_TAIL_RE = /\u001B(?:\[(?:[0-9;?]*)?|O|\u001B(?:\[(?:[0-9;?]*)?|O))$/;
+function splitTrailingIncomplete(chunk) {
+  const match = INCOMPLETE_TAIL_RE.exec(chunk);
+  if (!match) return { head: chunk, tail: "" };
+  return { head: chunk.slice(0, chunk.length - match[0].length), tail: match[0] };
+}
+function toInputKey(unit) {
+  const keypress = parseKeypress(unit);
+  const key = {
+    upArrow: keypress.name === "up",
+    downArrow: keypress.name === "down",
+    leftArrow: keypress.name === "left",
+    rightArrow: keypress.name === "right",
+    pageDown: keypress.name === "pagedown",
+    pageUp: keypress.name === "pageup",
+    return: keypress.name === "return",
+    escape: keypress.name === "escape",
+    ctrl: keypress.ctrl,
+    shift: keypress.shift,
+    tab: keypress.name === "tab",
+    backspace: keypress.name === "backspace",
+    delete: keypress.name === "delete",
+    meta: keypress.meta || keypress.name === "escape" || keypress.option
+  };
+  let input = keypress.ctrl ? keypress.name ?? "" : keypress.sequence;
+  if (nonAlphanumericKeys.includes(keypress.name ?? "")) {
+    input = "";
+  }
+  if (input.startsWith("\x1B")) {
+    input = input.slice(1);
+  }
+  if (input.length === 1 && /[A-Z]/.test(input)) {
+    key.shift = true;
+  }
+  return { input, key };
+}
+
+// src/cli/use-input.ts
+function useInput(inputHandler, options = {}) {
+  const { setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = useStdin();
+  const pendingRef = useRef("");
+  useEffect(() => {
+    if (options.isActive === false) return;
+    setRawMode(true);
+    return () => {
+      setRawMode(false);
+    };
+  }, [options.isActive, setRawMode]);
+  useEffect(() => {
+    if (options.isActive === false) return;
+    const handleData = (data) => {
+      const { head, tail } = splitTrailingIncomplete(pendingRef.current + data);
+      pendingRef.current = tail;
+      for (const unit of splitKeypresses(head)) {
+        const { input, key } = toInputKey(unit);
+        if (!(input === "c" && key.ctrl) || !internal_exitOnCtrlC) {
+          inputHandler(input, key);
+        }
+      }
+    };
+    internal_eventEmitter?.on("input", handleData);
+    return () => {
+      internal_eventEmitter?.removeListener("input", handleData);
+    };
+  }, [options.isActive, internal_exitOnCtrlC, internal_eventEmitter, inputHandler]);
+}
 
 // src/cli/components/SelectPrompt.tsx
-import { Box, Text, useInput } from "ink";
-import { useRef, useState } from "react";
+import { Box, Text } from "ink";
+import { useRef as useRef2, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 var SELECT_PROMPT_MAX_VISIBLE = 9;
 function SelectPrompt({ title, options, onSelect, onCancel }) {
   const [index, setIndex] = useState(0);
-  const indexRef = useRef(0);
+  const indexRef = useRef2(0);
   const move = (delta) => {
     indexRef.current = Math.max(0, Math.min(indexRef.current + delta, options.length - 1));
     setIndex(indexRef.current);
@@ -3233,12 +3804,12 @@ function SelectPrompt({ title, options, onSelect, onCancel }) {
 }
 
 // src/cli/components/TextField.tsx
-import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
-import { useRef as useRef3, useState as useState3 } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { useRef as useRef4, useState as useState3 } from "react";
 
 // src/cli/components/InputBox.tsx
-import { Box as Box2, Text as Text2, useInput as useInput2, useStdout } from "ink";
-import { useEffect, useRef as useRef2, useState as useState2 } from "react";
+import { Box as Box2, Text as Text2, useStdout } from "ink";
+import { useEffect as useEffect2, useRef as useRef3, useState as useState2 } from "react";
 
 // src/cli/path-suggest.ts
 import { readdir as readdir2 } from "fs/promises";
@@ -3388,25 +3959,25 @@ function InputBox({
   const [highlight, setHighlight] = useState2(0);
   const [suggestionsDismissed, setSuggestionsDismissed] = useState2(false);
   const [pathSuggestions, setPathSuggestions] = useState2([]);
-  const historyIndexRef = useRef2(null);
-  const draftRef = useRef2("");
-  const refillSeqRef = useRef2(0);
+  const historyIndexRef = useRef3(null);
+  const draftRef = useRef3("");
+  const refillSeqRef = useRef3(0);
   const [search, setSearch] = useState2(null);
-  const searchSavedRef = useRef2(null);
-  const pastesRef = useRef2(/* @__PURE__ */ new Map());
-  const pasteSeqRef = useRef2(0);
-  const bracketRef = useRef2({ active: false, buffer: "", pending: "" });
-  const lastPasteRef = useRef2(
+  const searchSavedRef = useRef3(null);
+  const pastesRef = useRef3(/* @__PURE__ */ new Map());
+  const pasteSeqRef = useRef3(0);
+  const bracketRef = useRef3({ active: false, buffer: "", pending: "" });
+  const lastPasteRef = useRef3(
     null
   );
-  const valueRef = useRef2(value);
-  const cursorRef = useRef2(cursor);
-  useEffect(() => {
+  const valueRef = useRef3(value);
+  const cursorRef = useRef3(cursor);
+  useEffect2(() => {
     valueRef.current = value;
     cursorRef.current = cursor;
   });
   const { stdout } = useStdout();
-  useEffect(() => {
+  useEffect2(() => {
     if (!stdout?.isTTY) return;
     stdout.write("\x1B[?2004h");
     return () => {
@@ -3495,7 +4066,7 @@ function InputBox({
       }
     }
   };
-  useEffect(() => {
+  useEffect2(() => {
     if (refill && refill.seq !== refillSeqRef.current) {
       refillSeqRef.current = refill.seq;
       edit(refill.text, refill.text.length);
@@ -3503,7 +4074,7 @@ function InputBox({
   });
   const suggestionsEnabled = !isStreaming && !disabled && !suggestionsDismissed && !search;
   const suggestions = suggestionsEnabled && commands ? filterCommands(value, commands) : [];
-  useEffect(() => {
+  useEffect2(() => {
     if (!suggestionsEnabled || !cwd) {
       setPathSuggestions([]);
       return;
@@ -3541,7 +4112,7 @@ function InputBox({
       token.start + replacement.length
     );
   };
-  useInput2((input, key) => {
+  useInput((input, key) => {
     if (!disabled) {
       const bracket = bracketRef.current;
       const feedable = input.length > 0 && !key.ctrl && !key.meta;
@@ -3774,9 +4345,9 @@ ${value.slice(cursor)}`, cursor + 1);
   const after = value.slice(cursor + 1);
   const cursorChar = at === "\n" || at === void 0 || at === PASTE_DELIM ? " " : at;
   const tail = (at === "\n" ? "\n" : "") + stylePasteTokens(after);
-  const styled = search ? `\x1B[36m(reverse-search) \x1B[39m'${search.query}': ${search.match === null ? "\x1B[2mno match\x1B[22m\x1B[7m \x1B[27m" : `${history[search.match]}\x1B[7m \x1B[27m`}` : `\x1B[36m> \x1B[39m${stylePasteTokens(before)}\x1B[7m${cursorChar}\x1B[27m${tail}`;
+  const styled2 = search ? `\x1B[36m(reverse-search) \x1B[39m'${search.query}': ${search.match === null ? "\x1B[2mno match\x1B[22m\x1B[7m \x1B[27m" : `${history[search.match]}\x1B[7m \x1B[27m`}` : `\x1B[36m\u276F \x1B[39m${stylePasteTokens(before)}\x1B[7m${cursorChar}\x1B[27m${tail}`;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { children: styled }) }),
+    /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { children: styled2 }) }),
     suggestions.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: suggestions.map((cmd, index) => {
       const label = cmd.usage ?? `/${cmd.name}`;
       return index === activeIndex ? /* @__PURE__ */ jsx2(Text2, { bold: true, inverse: true, children: `${label} - ${cmd.description}` }, cmd.name) : /* @__PURE__ */ jsxs2(Text2, { children: [
@@ -3805,8 +4376,8 @@ function TextField({
   onCancel
 }) {
   const [value, setValue] = useState3(initialValue);
-  const valueRef = useRef3(initialValue);
-  const bracketRef = useRef3({ active: false, buffer: "", pending: "" });
+  const valueRef = useRef4(initialValue);
+  const bracketRef = useRef4({ active: false, buffer: "", pending: "" });
   const flushBracket = () => {
     const bracket = bracketRef.current;
     const content = bracket.buffer.replace(/[\r\n]+/g, "");
@@ -3818,7 +4389,7 @@ function TextField({
       setValue(valueRef.current);
     }
   };
-  useInput3((input, key) => {
+  useInput((input, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -3857,7 +4428,7 @@ function TextField({
 // src/cli/components/ConnectWizard.tsx
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function YN({ question, onAnswer }) {
-  useInput4((input, key) => {
+  useInput((input, key) => {
     const ch = input.toLowerCase();
     if (ch === "y") onAnswer(true);
     else if (ch === "n" || key.escape) onAnswer(false);
@@ -3887,8 +4458,8 @@ function ConnectWizard({
   const [error, setError] = useState4(null);
   const [busy, setBusy] = useState4(false);
   const [notes, setNotes] = useState4([]);
-  const busyRef = useRef4(false);
-  const notesRef = useRef4([]);
+  const busyRef = useRef5(false);
+  const notesRef = useRef5([]);
   const pushNote = (note) => {
     notesRef.current = [...notesRef.current, note];
     setNotes(notesRef.current);
@@ -4071,10 +4642,10 @@ function ConnectWizard({
 }
 
 // src/cli/components/ExitPlanPrompt.tsx
-import { Box as Box5, Text as Text5, useInput as useInput5 } from "ink";
+import { Box as Box5, Text as Text5 } from "ink";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function ExitPlanPrompt({ onDecision }) {
-  useInput5((input, key) => {
+  useInput((input, key) => {
     const ch = input.toLowerCase();
     if (ch === "y") onDecision("yes");
     else if (ch === "n" || key.escape) onDecision("no");
@@ -4087,7 +4658,7 @@ function ExitPlanPrompt({ onDecision }) {
 }
 
 // src/cli/components/MessageList.tsx
-import { Box as Box6, Static, Text as Text7 } from "ink";
+import { Box as Box6, Static, Text as Text7, useStdout as useStdout2 } from "ink";
 import { memo } from "react";
 
 // src/cli/components/DiffLines.tsx
@@ -4119,26 +4690,44 @@ function DiffLines({ lines }) {
 // src/cli/components/MessageList.tsx
 import { jsx as jsx7, jsxs as jsxs7 } 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" }
+  assistant: { label: "\u2726 star", color: "green" },
+  system: { label: "\u25CF system", color: "yellow" }
 };
 var interruptedMarker = (text) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: text.length > 0 ? " [interrupted]" : "[interrupted]" });
 var MessageList = memo(function MessageList2({ messages }) {
+  const { stdout } = useStdout2();
+  const termWidth = stdout.columns ?? 80;
   return /* @__PURE__ */ jsx7(Static, { items: messages, children: (message) => {
     const marginBottom = message.tight ? 0 : 1;
     if (message.role === "assistant-cont") {
       return /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", marginBottom, children: /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
-        message.text,
+        renderMarkdown(message.text, "32", termWidth),
         message.interrupted && interruptedMarker(message.text)
       ] }) }, message.id);
     }
+    if (message.role === "user") {
+      return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", marginBottom, children: [
+        /* @__PURE__ */ jsxs7(Box6, { children: [
+          /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "\u276F " }),
+          /* @__PURE__ */ jsxs7(Text7, { color: "cyan", children: [
+            message.text,
+            message.interrupted && interruptedMarker(message.text)
+          ] })
+        ] }),
+        message.note && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " ",
+          message.note
+        ] })
+      ] }, message.id);
+    }
+    if (message.role === "tool") {
+      return /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", marginBottom, children: /* @__PURE__ */ jsx7(Text7, { color: "magenta", children: message.text }) }, message.id);
+    }
     const style = roleStyles[message.role];
     return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", marginBottom, children: [
       /* @__PURE__ */ jsx7(Text7, { bold: true, color: style.color, children: style.label }),
       /* @__PURE__ */ jsxs7(Text7, { color: style.color, children: [
-        message.text,
+        message.role === "assistant" ? renderMarkdown(message.text, "32", termWidth) : message.text,
         message.interrupted && interruptedMarker(message.text)
       ] }),
       message.diff && /* @__PURE__ */ jsx7(DiffLines, { lines: message.diff }),
@@ -4148,7 +4737,7 @@ var MessageList = memo(function MessageList2({ messages }) {
 });
 
 // src/cli/components/PermissionPrompt.tsx
-import { Box as Box7, Text as Text8, useInput as useInput6 } from "ink";
+import { Box as Box7, Text as Text8 } from "ink";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var BASH_COMMAND_MAX = 1e3;
 function middleTruncate(text, max) {
@@ -4162,7 +4751,7 @@ function bashCommand(args) {
   return typeof command === "string" ? command : null;
 }
 function PermissionPrompt({ request, preview, onDecision }) {
-  useInput6((input) => {
+  useInput((input) => {
     const ch = input.toLowerCase();
     if (ch === "y") onDecision("yes");
     else if (ch === "n") onDecision("no");
@@ -4189,7 +4778,7 @@ function PermissionPrompt({ request, preview, onDecision }) {
 }
 
 // src/cli/components/RewindConfirmPrompt.tsx
-import { Box as Box8, Text as Text9, useInput as useInput7 } from "ink";
+import { Box as Box8, Text as Text9 } from "ink";
 import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 function RewindConfirmPrompt({
   summary,
@@ -4198,7 +4787,7 @@ function RewindConfirmPrompt({
   diffs,
   onDecision
 }) {
-  useInput7((input, key) => {
+  useInput((input, key) => {
     const ch = input.toLowerCase();
     if (ch === "y") onDecision("yes");
     else if (ch === "n" || key.escape) onDecision("no");
@@ -4219,8 +4808,74 @@ function RewindConfirmPrompt({
 }
 
 // src/cli/components/StatusBar.tsx
-import { Box as Box9, Text as Text10, useStdout as useStdout2 } from "ink";
+import { Box as Box9, Text as Text10, useStdout as useStdout3 } from "ink";
 import { memo as memo2 } from "react";
+
+// src/cli/icons.ts
+var EMOJI_TERM_PROGRAMS = /* @__PURE__ */ new Set([
+  "vscode",
+  "WezTerm",
+  "iTerm.app",
+  "Apple_Terminal",
+  "ghostty",
+  "kitty",
+  "Hyper",
+  "WarpTerminal"
+]);
+function resolveIconMode(env = process.env) {
+  const override = env.STAR_ICONS;
+  if (override === "emoji" || override === "plain") return override;
+  if (env.WT_SESSION) return "emoji";
+  if (EMOJI_TERM_PROGRAMS.has(env.TERM_PROGRAM ?? "")) return "emoji";
+  const term = env.TERM ?? "";
+  if (term.includes("kitty") || term.includes("alacritty")) return "emoji";
+  return "plain";
+}
+var EMOJI_TOOL_ICONS = {
+  bash: "\u{1F4BB}",
+  read_file: "\u{1F4C4}",
+  write_file: "\u{1F4DD}",
+  edit_file: "\u270F\uFE0F",
+  glob: "\u{1F4C2}",
+  grep: "\u{1F50D}",
+  web_search: "\u{1F50E}",
+  web_fetch: "\u{1F310}",
+  todo_write: "\u{1F4CB}",
+  todo_read: "\u{1F4CB}",
+  task_list: "\u{1F9F5}",
+  task_output: "\u{1F9F5}",
+  task_kill: "\u{1F6D1}",
+  subagent: "\u{1F916}",
+  skill: "\u2728",
+  remember: "\u{1F9E0}"
+};
+var PLAIN_TOOL_ICONS = {
+  bash: "$",
+  read_file: "\u2261",
+  write_file: "+",
+  edit_file: "\u270E",
+  glob: "*",
+  grep: "/",
+  web_search: "?",
+  web_fetch: "\u21D3",
+  todo_write: "\u2023",
+  todo_read: "\u2023",
+  task_list: "\xB6",
+  task_output: "\xB6",
+  task_kill: "\xD7",
+  subagent: "\u25C9",
+  skill: "\u2727",
+  remember: "\u203B"
+};
+var iconMode = resolveIconMode();
+function toolIcon(name) {
+  const map = iconMode === "emoji" ? EMOJI_TOOL_ICONS : PLAIN_TOOL_ICONS;
+  return map[name] ?? (iconMode === "emoji" ? "\u{1F527}" : "\u25B8");
+}
+var thinkingIcon = iconMode === "emoji" ? "\u{1F4AD}" : "\u2727";
+var folderIcon = iconMode === "emoji" ? "\u{1F4C1} " : "";
+
+// src/cli/components/StatusBar.tsx
 import { jsxs as jsxs10 } from "react/jsx-runtime";
 var BG_LABEL_MAX = 40;
 var WIDE_COLUMNS = 120;
@@ -4240,12 +4895,13 @@ var StatusBar = memo2(function StatusBar2({
   sessionCostUsd,
   backgroundTasks = []
 }) {
-  const { stdout } = useStdout2();
+  const { stdout } = useStdout3();
   const wide = (stdout?.columns ?? 80) >= WIDE_COLUMNS;
   const joined = backgroundTasks.map((label) => toTerminalSafe(label)).join(", ");
   const labels = joined.length > BG_LABEL_MAX ? `${joined.slice(0, BG_LABEL_MAX)}\u2026` : joined;
   return /* @__PURE__ */ jsxs10(Box9, { justifyContent: "space-between", children: [
     /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      folderIcon,
       cwdLabel(cwd, wide),
       gitBranch ? ` [${gitBranch}]` : ""
     ] }),
@@ -4257,7 +4913,7 @@ var StatusBar = memo2(function StatusBar2({
       ")"
     ] }),
     /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
-      "model: ",
+      "\u2726 ",
       model
     ] }),
     contextPercent != null && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
@@ -4285,23 +4941,24 @@ var StatusBar = memo2(function StatusBar2({
 });
 
 // src/cli/components/StreamingMessage.tsx
-import { Box as Box10, Text as Text11 } from "ink";
+import { Box as Box10, Text as Text11, useStdout as useStdout4 } from "ink";
 import { memo as memo3 } from "react";
 import { jsx as jsx10, jsxs as jsxs11 } from "react/jsx-runtime";
 var StreamingMessage = memo3(function StreamingMessage2({
   text,
   continuation
 }) {
+  const { stdout } = useStdout4();
   return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", marginBottom: 1, children: [
-    !continuation && /* @__PURE__ */ jsx10(Text11, { bold: true, color: "green", children: "star" }),
-    /* @__PURE__ */ jsx10(Text11, { color: "green", children: text })
+    !continuation && /* @__PURE__ */ jsx10(Text11, { bold: true, color: "green", children: "\u2726 star" }),
+    /* @__PURE__ */ jsx10(Text11, { color: "green", children: renderMarkdown(text, "32", stdout.columns ?? 80) })
   ] });
 });
 
 // src/cli/components/ThinkingIndicator.tsx
 import { Box as Box11, Text as Text12 } from "ink";
 import { jsxs as jsxs12 } from "react/jsx-runtime";
-var SPINNER_FRAMES = ["-", "\\", "|", "/"];
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var REASONING_TAIL_LENGTH = 200;
 var THOUGHT_SUMMARY_LENGTH = 100;
 function truncateTail(text, max) {
@@ -4316,14 +4973,15 @@ function ThinkingIndicator({
 }) {
   const tail = reasoning ? truncateTail(reasoning, REASONING_TAIL_LENGTH) : "";
   const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+  const label = activity ?? `${thinkingIcon} star is thinking\u2026`;
   return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
       spinner,
       " ",
-      activity ?? "star is thinking\u2026"
+      label
     ] }),
     tail !== "" && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
-      " ",
+      "   ",
       tail
     ] })
   ] });
@@ -4333,9 +4991,9 @@ function ThinkingIndicator({
 import { Box as Box12, Text as Text13 } from "ink";
 import { jsxs as jsxs13 } from "react/jsx-runtime";
 var SYMBOLS = {
-  pending: "[ ]",
-  in_progress: "[~]",
-  done: "[x]"
+  pending: "\u25CB",
+  in_progress: "\u25D0",
+  done: "\u25CF"
 };
 var MAX_VISIBLE_TODOS = 10;
 function visibleTodoWindow(todos, max = MAX_VISIBLE_TODOS) {
@@ -4362,6 +5020,7 @@ function TodoPanel({ todos }) {
       Text13,
       {
         dimColor: todo.status === "done",
+        strikethrough: todo.status === "done",
         color: todo.status === "in_progress" ? "cyan" : void 0,
         children: [
           SYMBOLS[todo.status],
@@ -4381,7 +5040,7 @@ function TodoPanel({ todos }) {
 
 // src/cli/components/ToolCallCard.tsx
 function formatToolCard(card) {
-  const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
+  const header = `${toolIcon(card.name)} ${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
   if (card.result === void 0) return header;
   const preview = previewLines(toTerminalSafe(card.result), 10);
   return `${header}
@@ -4609,6 +5268,7 @@ function formatUsage(usage) {
 var SESSION_PICKER_CAP = 20;
 var SESSION_PREVIEW_MAX = 60;
 var MAX_VISIBLE_QUEUED = 5;
+var REASONING_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "max"];
 function Repl({
   backend,
   model,
@@ -4640,47 +5300,47 @@ function Repl({
   const [pendingRewind, setPendingRewindState] = useState5(null);
   const [picker, setPickerState] = useState5(null);
   const [pendingConnect, setPendingConnectState] = useState5(null);
-  const backendRef = useRef5(backend);
-  const nextIdRef = useRef5(initialDisplay.length);
-  const abortRef = useRef5(null);
-  const streamedRef = useRef5("");
-  const lastCommittedLenRef = useRef5(0);
-  const thinkingRef = useRef5(false);
-  const reasoningRef = useRef5("");
-  const tickerStopRef = useRef5(null);
-  const flushedRef = useRef5({ streamed: "", reasoning: "" });
-  const toolCardsRef = useRef5(/* @__PURE__ */ new Map());
-  const pendingRef = useRef5(null);
-  const permissionChainRef = useRef5(Promise.resolve());
-  const alwaysAllowedRef = useRef5(/* @__PURE__ */ new Set());
-  const prevModeRef = useRef5(null);
-  const planApprovalRef = useRef5(false);
-  const pendingRewindRef = useRef5(null);
-  const pickerRef = useRef5(null);
-  const pendingConnectRef = useRef5(null);
-  const modelNameRef = useRef5(model);
-  const sessionStoreRef = useRef5(sessionStore);
-  const configRef = useRef5(config);
-  useEffect2(() => {
+  const backendRef = useRef6(backend);
+  const nextIdRef = useRef6(initialDisplay.length);
+  const abortRef = useRef6(null);
+  const streamedRef = useRef6("");
+  const lastCommittedLenRef = useRef6(0);
+  const thinkingRef = useRef6(false);
+  const reasoningRef = useRef6("");
+  const tickerStopRef = useRef6(null);
+  const flushedRef = useRef6({ streamed: "", reasoning: "" });
+  const toolCardsRef = useRef6(/* @__PURE__ */ new Map());
+  const pendingRef = useRef6(null);
+  const permissionChainRef = useRef6(Promise.resolve());
+  const alwaysAllowedRef = useRef6(/* @__PURE__ */ new Set());
+  const prevModeRef = useRef6(null);
+  const planApprovalRef = useRef6(false);
+  const pendingRewindRef = useRef6(null);
+  const pickerRef = useRef6(null);
+  const pendingConnectRef = useRef6(null);
+  const modelNameRef = useRef6(model);
+  const sessionStoreRef = useRef6(sessionStore);
+  const configRef = useRef6(config);
+  useEffect3(() => {
     configRef.current = config;
   }, [config]);
-  const usageRef = useRef5(initialUsage ? { ...initialUsage } : emptyUsage());
-  const turnChunksRef = useRef5(0);
-  const messagesRef = useRef5(initialDisplay);
+  const usageRef = useRef6(initialUsage ? { ...initialUsage } : emptyUsage());
+  const turnChunksRef = useRef6(0);
+  const messagesRef = useRef6(initialDisplay);
   const [queueItems, setQueueItems] = useState5([]);
-  const queueRef = useRef5(new PromptQueue());
+  const queueRef = useRef6(new PromptQueue());
   const [pendingImages, setPendingImages] = useState5([]);
-  const pendingImagesRef = useRef5([]);
-  const imageSeqRef = useRef5(1);
+  const pendingImagesRef = useRef6([]);
+  const imageSeqRef = useRef6(1);
   const [inputRefill, setInputRefill] = useState5();
-  const refillSeqRef = useRef5(0);
-  const lastEscRef = useRef5(null);
+  const refillSeqRef = useRef6(0);
+  const lastEscRef = useRef6(null);
   const [gitBranch, setGitBranch] = useState5(null);
   const [contextPercent, setContextPercent] = useState5(null);
   const [initialHistory] = useState5(() => loadHistory());
-  const budgetWarnedRef = useRef5(false);
-  const budgetExceededRef = useRef5(false);
-  const runStreamRef = useRef5(
+  const budgetWarnedRef = useRef6(false);
+  const budgetExceededRef = useRef6(false);
+  const runStreamRef = useRef6(
     null
   );
   const pushMessage = useCallback(
@@ -4860,7 +5520,7 @@ function Repl({
     },
     [setPendingPermission, cwd, pushMessage]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     attachConfirmHandler(backendRef.current);
     return () => {
       tickerStopRef.current?.();
@@ -4868,19 +5528,19 @@ function Repl({
       pendingRef.current?.resolve(false);
     };
   }, [attachConfirmHandler]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (process.env.STAR_NO_UPDATE_CHECK === "1") return;
     void checkForUpdate(VERSION).then((message) => {
       if (message) pushMessage("system", message);
     });
   }, [pushMessage]);
   const resumedAtStart = initialMessages !== void 0;
-  useEffect2(() => {
+  useEffect3(() => {
     if (!resumedAtStart) return;
     loadTodos(cwd).then(setTodos).catch(() => {
     });
   }, [cwd, resumedAtStart]);
-  useEffect2(() => {
+  useEffect3(() => {
     const onUpdate = (task) => {
       setBgLabels(runningTaskLabels());
       pushMessage(
@@ -4963,7 +5623,7 @@ function Repl({
     }
     exit();
   }, [exit, pushMessage]);
-  useInput8((_input, key) => {
+  useInput((_input, key) => {
     if (key.escape) {
       const busy = abortRef.current !== null || pendingRef.current !== null || planApprovalRef.current || pendingRewindRef.current !== null || pendingConnectRef.current !== null || pickerRef.current !== null;
       if (busy) {
@@ -5022,7 +5682,8 @@ function Repl({
           cwd,
           system: SYSTEM_PROMPT,
           sessionStore: sessionStoreRef.current,
-          contextMaxTokens: contextWindowTokens(config, name)
+          contextMaxTokens: contextWindowTokens(config, name),
+          providerMetadata: reasoningEffortMetadata(config, name)
         });
         const prev = backendRef.current;
         if (prev instanceof AgentLoop) {
@@ -5039,6 +5700,42 @@ function Repl({
     },
     [config, cwd, attachConfirmHandler]
   );
+  const pickReasoningEffort = useCallback(
+    async (name) => {
+      const modelConfig = config.models.find((m) => m.name === name);
+      const current = modelConfig?.reasoningEffort;
+      const levels = current && !REASONING_EFFORT_LEVELS.includes(current) ? [...REASONING_EFFORT_LEVELS, current] : REASONING_EFFORT_LEVELS;
+      const options = [
+        {
+          value: "",
+          label: "default",
+          description: "send no effort field \u2014 the provider's server-side default applies",
+          hint: current === void 0 ? "current" : void 0
+        },
+        ...levels.map((level) => ({
+          value: level,
+          label: level,
+          description: "only works if the model/provider supports this level",
+          hint: level === current ? "current" : void 0
+        }))
+      ];
+      const picked = await showPicker(`Reasoning effort for "${name}"`, options);
+      if (picked === null || picked === "" && current === void 0 || picked === current) {
+        return `Reasoning effort unchanged${current ? ` \u2014 still "${current}"` : " \u2014 server default"}.`;
+      }
+      const effort = picked === "" ? void 0 : picked;
+      if (modelConfig) modelConfig.reasoningEffort = effort;
+      const backend2 = backendRef.current;
+      if (backend2 instanceof AgentLoop) {
+        backend2.setProviderMetadata(reasoningEffortMetadata(config, name));
+      }
+      const saved = await saveReasoningEffort(name, effort);
+      const applied = effort === void 0 ? "server default" : `"${effort}"`;
+      const suffix = saved ? "Saved to config." : `This session only \u2014 "${name}" has no [[models]] block in the global config file; add reasoningEffort there to persist it.`;
+      return `Reasoning effort for "${name}" set to ${applied}. ${suffix}`;
+    },
+    [config, showPicker]
+  );
   const handleConnectSetDefault = useCallback(
     async (modelName2) => {
       saveDefaultModel(modelName2);
@@ -5148,7 +5845,7 @@ function Repl({
               setThinking(false);
               if (reasoningRef.current.length > 0) {
                 setThoughtSummary(
-                  `thought: ${truncateTail(reasoningRef.current, THOUGHT_SUMMARY_LENGTH)}`
+                  `${thinkingIcon} thought: ${truncateTail(reasoningRef.current, THOUGHT_SUMMARY_LENGTH)}`
                 );
               }
             }
@@ -5166,7 +5863,9 @@ function Repl({
               const list = parseTodoArgs(event.args);
               if (list) setTodos(list);
             }
-            setActivity(`running ${event.name}: ${summarizeArgs(event.args, 60)}`);
+            setActivity(
+              `${toolIcon(event.name)} running ${event.name}: ${summarizeArgs(event.args, 60)}`
+            );
           } else if (event.type === "tool-result") {
             const card = toolCardsRef.current.get(event.id) ?? {
               id: event.id,
@@ -5315,7 +6014,7 @@ function Repl({
       sessionCostUsd
     ]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     runStreamRef.current = runStream;
   }, [runStream]);
   const handlePlanDecision = useCallback(
@@ -5369,7 +6068,7 @@ function Repl({
         const models = listModels(config);
         if (models.length === 0) return "No models configured.";
         const lines = models.map(
-          (m) => `${m.name === modelNameRef.current ? "*" : " "} ${m.name} (${m.provider}/${m.model})`
+          (m) => `${m.name === modelNameRef.current ? "*" : " "} ${m.name} (${m.provider}/${m.model})${m.reasoningEffort ? ` [effort: ${m.reasoningEffort}]` : ""}`
         );
         return `Models (* = current):
 ${lines.join("\n")}`;
@@ -5388,6 +6087,7 @@ ${lines.join("\n")}`;
         if (models.length === 0) return "No models configured.";
         const options = models.map((m) => {
           const parts = [`${m.provider}/${m.model}`, `${contextWindowTokens(config, m.name)} ctx`];
+          if (m.reasoningEffort) parts.push(`effort: ${m.reasoningEffort}`);
           if (m.promptPrice !== void 0 && m.completionPrice !== void 0) {
             parts.push(`$${m.promptPrice}/$${m.completionPrice} per 1M tokens`);
           }
@@ -5399,10 +6099,17 @@ ${lines.join("\n")}`;
           };
         });
         const picked = await showPicker("Select a model", options);
-        if (!picked || picked === modelNameRef.current) {
-          return `Model unchanged \u2014 still "${modelNameRef.current}".`;
+        if (!picked) return `Model unchanged \u2014 still "${modelNameRef.current}".`;
+        const results = [];
+        if (picked === modelNameRef.current) {
+          results.push(`Model unchanged \u2014 still "${picked}".`);
+        } else {
+          const switched = await switchModel(picked);
+          if (switched.startsWith("Failed to switch model:")) return switched;
+          results.push(switched);
         }
-        return switchModel(picked);
+        results.push(await pickReasoningEffort(picked));
+        return results.join("\n");
       },
       pickPermissionMode: async () => {
         const current = config.permissionMode;
@@ -5719,7 +6426,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         `permissionMode: ${config.permissionMode}`,
         `providers (${config.providers.length}): ${config.providers.map((p) => p.name).join(", ") || "(none)"}`,
         `models (${config.models.length}): ${config.models.map((m) => m.name).join(", ") || "(none)"}`,
-        `maxSteps: ${config.maxSteps}`,
+        `maxSteps: ${config.maxSteps === 0 ? "unlimited" : config.maxSteps}`,
         `contextMaxTokens: ${config.contextMaxTokens}`,
         `compactThresholdTokens: ${config.compactThresholdTokens ?? "(context window)"}`,
         `streamIdleTimeoutSec: ${config.streamIdleTimeoutSec}`,
@@ -5740,6 +6447,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     config,
     cwd,
     switchModel,
+    pickReasoningEffort,
     resume,
     runStream,
     applyMessages,
@@ -5843,7 +6551,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     })),
     [registry]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     setGitBranch(getGitSummary(cwd)?.branch ?? null);
     const current = backendRef.current;
     if (current instanceof AgentLoop) {
@@ -6059,7 +6767,8 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     cwd,
     system: SYSTEM_PROMPT,
     sessionStore,
-    contextMaxTokens: contextWindowTokens(config, modelName)
+    contextMaxTokens: contextWindowTokens(config, modelName),
+    providerMetadata: reasoningEffortMetadata(config, modelName)
   });
 }
 async function printMode(loop, prompt, cwd, json, imagePaths, sessionStore) {