@botconnector/bccli 0.4.0-beta.2 → 0.4.0-beta.21

package/dist/{ui-A32PTF4F.js → ui-SRXPL7KU.js}

@@ -5,7 +5,7 @@ import {
   instructionPaths,
   parseFrontmatter,
   toolLabel
-} from "./chunk-OSWQPSA4.js";
+} from "./chunk-HP3J6JEY.js";
 import {
   nextMode
 } from "./chunk-ELML4KVQ.js";
@@ -13,24 +13,35 @@ import {
   hasKey,
   providerName,
   writeGlobalConfig
-} from "./chunk-U7DLMVPZ.js";
+} from "./chunk-K5JNR3HL.js";
+import {
+  REASONING_LEVELS,
+  assertReasoningSupported,
+  parseReasoningLevel,
+  supportedReasoningLevels
+} from "./chunk-SN3ODJZN.js";
 import {
   Session
 } from "./chunk-SJH3YLW4.js";
 import {
   CATALOG,
   fillTemplate
-} from "./chunk-UESQNU4A.js";
+} from "./chunk-BEXQSEBI.js";
 import {
   addGlobalServer,
   globalMcpPath,
   readMcpFile,
   removeGlobalServer
-} from "./chunk-NGLKANMD.js";
+} from "./chunk-44MXWCFN.js";
 import {
   PRESETS,
-  removeCredential
-} from "./chunk-RZUJYAQV.js";
+  getLanguage,
+  locale,
+  parseLang,
+  removeCredential,
+  setLanguage,
+  t
+} from "./chunk-EO7IVVX4.js";
 
 // src/ui/index.tsx
 import { render } from "ink";
@@ -45,30 +56,32 @@ import { useCallback, useEffect as useEffect2, useRef, useState as useState8 } f
 
 // src/commands.ts
 var SLASH_COMMANDS = [
-  { name: "help", description: "daftar perintah dan pintasan" },
-  { name: "model", description: "ganti model" },
-  { name: "provider", description: "tambah/pilih provider AI" },
-  { name: "mcp", description: "pasang/kelola server MCP" },
-  { name: "new", description: "sesi baru (sesi lama tetap tersimpan)" },
-  { name: "resume", description: "lanjutkan sesi lain di folder ini" },
-  { name: "session", description: "info sesi ini" },
-  { name: "status", description: "versi, model, mode izin, MCP, konteks" },
-  { name: "permissions", description: "lihat/cabut izin" },
-  { name: "undo", description: "batalkan edit file giliran terakhir" },
-  { name: "diff", description: "git diff project" },
-  { name: "copy", description: "salin jawaban terakhir" },
-  { name: "export", description: "simpan percakapan ke markdown" },
-  { name: "memory", description: "instruksi project (/memory <teks>, /memory global <teks>)" },
-  { name: "init", description: "buat/perbarui AGENTS.md untuk project ini" },
-  { name: "agents", description: "daftar subagent" },
-  { name: "skills", description: "daftar skill dan perintah custom" },
-  { name: "doctor", description: "cek kesehatan instalasi" },
-  { name: "login", description: "simpan API key provider aktif" },
-  { name: "logout", description: "hapus API key provider aktif" },
-  { name: "clear", description: "mulai percakapan baru" },
-  { name: "compact", description: "ringkas percakapan" },
-  { name: "cost", description: "pemakaian token sesi ini" },
-  { name: "exit", description: "keluar" }
+  { name: "help", description: "list of commands and shortcuts" },
+  { name: "model", description: "change model" },
+  { name: "reasoning", description: "set reasoning: auto/off/low/medium/high/max" },
+  { name: "provider", description: "add/choose an AI provider" },
+  { name: "mcp", description: "install/manage MCP servers" },
+  { name: "new", description: "new session (the old one stays saved)" },
+  { name: "resume", description: "continue another session in this folder" },
+  { name: "session", description: "info about this session" },
+  { name: "status", description: "version, model, permission mode, MCP, context" },
+  { name: "permissions", description: "view/revoke permissions" },
+  { name: "undo", description: "undo the file edits of the last turn" },
+  { name: "diff", description: "git diff of the project" },
+  { name: "copy", description: "copy the last answer" },
+  { name: "export", description: "save the conversation as markdown" },
+  { name: "memory", description: "project instructions (/memory <text>, /memory global <text>)" },
+  { name: "init", description: "create/update AGENTS.md for this project" },
+  { name: "agents", description: "list subagents" },
+  { name: "skills", description: "list skills and custom commands" },
+  { name: "doctor", description: "check installation health" },
+  { name: "login", description: "save the API key of the current provider" },
+  { name: "logout", description: "delete the API key of the current provider" },
+  { name: "language", description: "set the interface language: en/id" },
+  { name: "clear", description: "start a new conversation" },
+  { name: "compact", description: "summarize the conversation" },
+  { name: "cost", description: "token usage of this session" },
+  { name: "exit", description: "quit" }
 ];
 function parseSlash(text) {
   if (!text.startsWith("/")) return void 0;
@@ -102,8 +115,8 @@ function git(cwd, args, bin = "git") {
 }
 async function gitDiff(cwd, maxLines = 400, bin = "git") {
   const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
-  if (inside.missing) return "git tidak terpasang atau tidak ada di PATH, jadi /diff tidak bisa dipakai.";
-  if (!inside.ok || inside.out.trim() !== "true") return "Folder ini bukan repository git, jadi tidak ada diff.";
+  if (inside.missing) return t("git is not installed or not on PATH, so /diff cannot be used.");
+  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
   const base = (await git(cwd, ["rev-parse", "--verify", "-q", "HEAD"])).ok ? "HEAD" : "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   const [stat, diff, untracked] = await Promise.all([
     git(cwd, ["diff", "--stat", base]),
@@ -111,23 +124,23 @@ async function gitDiff(cwd, maxLines = 400, bin = "git") {
     git(cwd, ["ls-files", "--others", "--exclude-standard"])
   ]);
   const fresh = untracked.out.split("\n").filter(Boolean);
-  if (!diff.out.trim() && !fresh.length) return "Tidak ada perubahan yang belum di-commit.";
+  if (!diff.out.trim() && !fresh.length) return t("No uncommitted changes.");
   const lines = diff.out.trimEnd().split("\n");
   const more = lines.length > maxLines ? `
-\u2026 ${lines.length - maxLines} baris lagi` : "";
-  return [stat.out.trim(), lines.slice(0, maxLines).join("\n") + more, fresh.length ? `File baru (belum di-track): ${fresh.join(", ")}` : ""].filter(Boolean).join("\n\n");
+${t("\u2026 {n} more lines", { n: lines.length - maxLines })}` : "";
+  return [stat.out.trim(), lines.slice(0, maxLines).join("\n") + more, fresh.length ? t("New files (untracked): {files}", { files: fresh.join(", ") }) : ""].filter(Boolean).join("\n\n");
 }
 
 // src/slash/doctor.ts
 async function doctorText(input, deps) {
   const major = Number(deps.nodeVersion.replace(/^v/, "").split(".")[0]);
-  const lines = [major >= 22 ? `\u2713 Node ${deps.nodeVersion}` : `\u2717 Node ${deps.nodeVersion} (butuh \u2265 22)`];
-  for (const p of input.providers) lines.push(p.ready ? `\u2713 ${p.name}` : `\u25CB ${p.name} (belum ada key)`);
+  const lines = [major >= 22 ? `\u2713 Node ${deps.nodeVersion}` : t("\u2717 Node {version} (needs \u2265 22)", { version: deps.nodeVersion })];
+  for (const p of input.providers) lines.push(p.ready ? `\u2713 ${p.name}` : t("\u25CB {name} (no key yet)", { name: p.name }));
   const cmds = ["rg", "git", "npx", "uvx"];
   const [connection, found] = await Promise.all([
     deps.listModels().then(
-      (models) => `\u2713 Koneksi ${input.activeProvider} (${models.length} model)`,
-      (error) => `\u2717 Koneksi ${input.activeProvider}: ${error.message}`
+      (models) => t("\u2713 Connection {provider} ({n} models)", { provider: input.activeProvider, n: models.length }),
+      (error) => t("\u2717 Connection {provider}: {error}", { provider: input.activeProvider, error: error.message })
     ),
     Promise.all(cmds.map(async (cmd) => deps.which(cmd)))
   ]);
@@ -158,31 +171,31 @@ function statusText(s) {
   return [
     `BCCLI ${s.version}`,
     `Model: ${s.modelRef} (${s.providerLabel})`,
-    `Mode izin: ${s.mode}`,
-    `Folder: ${s.cwd}`,
-    `MCP: ${ready} aktif, ${errors} error`,
-    `Token sesi: ${k(s.usage.inputTokens)} masuk \xB7 ${k(s.usage.outputTokens)} keluar`,
-    `Konteks: \xB1${Math.round(s.lastInputTokens / 128e3 * 100)}% dari 128k`
+    t("Permission mode: {mode}", { mode: s.mode }),
+    t("Folder: {cwd}", { cwd: s.cwd }),
+    t("MCP: {ready} active, {errors} errors", { ready, errors }),
+    t("Session tokens: {input} in \xB7 {output} out", { input: k(s.usage.inputTokens), output: k(s.usage.outputTokens) }),
+    t("Context: ~{pct}% of 128k", { pct: Math.round(s.lastInputTokens / 128e3 * 100) })
   ].join("\n");
 }
 function agentsText(defs) {
-  return defs.map((d) => `${d.name} \u2014 ${d.description} \xB7 alat: ${d.tools ? d.tools.join(", ") : "semua"} \xB7 model: ${d.model ?? "ikut utama"}`).join("\n");
+  return defs.map((d) => t("{name} \u2014 {description} \xB7 tools: {tools} \xB7 model: {model}", { name: d.name, description: d.description, tools: d.tools ? d.tools.join(", ") : t("all"), model: d.model ?? t("same as main") })).join("\n");
 }
 function skillsText(skills, commands) {
-  const s = skills.length ? skills.map((x) => `${x.name} \u2014 ${x.description.slice(0, 80)} (${x.dir})`).join("\n") : "(tidak ada skill)";
-  const c = commands.length ? commands.map((x) => `/${x.name} \u2014 ${x.description ?? ""}`).join("\n") : "(tidak ada perintah custom)";
-  return `Skill:
+  const s = skills.length ? skills.map((x) => `${x.name} \u2014 ${x.description.slice(0, 80)} (${x.dir})`).join("\n") : t("(no skills)");
+  const c = commands.length ? commands.map((x) => `/${x.name} \u2014 ${x.description ?? ""}`).join("\n") : t("(no custom commands)");
+  return `${t("Skills")}:
 ${s}
 
-Perintah custom:
+${t("Custom commands")}:
 ${c}`;
 }
 function sessionText(s) {
   return [
-    `Mulai: ${s.started.toLocaleString("id-ID")}`,
-    `${s.messages} pesan \xB7 ${k(s.usage.inputTokens)} token masuk \xB7 ${k(s.usage.outputTokens)} keluar`,
+    t("Started: {when}", { when: s.started.toLocaleString(locale()) }),
+    t("{messages} messages \xB7 {input} tokens in \xB7 {output} out", { messages: s.messages, input: k(s.usage.inputTokens), output: k(s.usage.outputTokens) }),
     `Model: ${s.modelRef}`,
-    `File: ${s.file}`
+    t("File: {file}", { file: s.file })
   ].join("\n");
 }
 
@@ -202,7 +215,308 @@ function parseMemoryArgs(args) {
 }
 
 // src/ui/Markdown.tsx
-import { Box, Text } from "ink";
+import { Box, Text, useStdout } from "ink";
+
+// src/ui/table.ts
+var WIDE = [
+  [4352, 4447],
+  [8986, 8987],
+  [9193, 9196],
+  [9200, 9200],
+  [9203, 9203],
+  [9725, 9726],
+  [9748, 9749],
+  [9800, 9811],
+  [9855, 9855],
+  [9875, 9875],
+  [9889, 9889],
+  [9898, 9899],
+  [9917, 9918],
+  [9924, 9925],
+  [9934, 9934],
+  [9940, 9940],
+  [9962, 9962],
+  [9970, 9971],
+  [9973, 9973],
+  [9978, 9978],
+  [9981, 9981],
+  [9989, 9989],
+  [9994, 9995],
+  [10024, 10024],
+  [10060, 10060],
+  [10062, 10062],
+  [10067, 10069],
+  [10071, 10071],
+  [10133, 10135],
+  [10160, 10160],
+  [10175, 10175],
+  [11035, 11036],
+  [11088, 11088],
+  [11093, 11093],
+  [11904, 42191],
+  [44032, 55203],
+  [63744, 64255],
+  [65072, 65135],
+  [65280, 65376],
+  [65504, 65510],
+  [127744, 128591],
+  [128640, 128767],
+  [129280, 129791],
+  [131072, 262141]
+];
+var ZERO = [
+  [768, 879],
+  [6832, 6911],
+  [7616, 7679],
+  [8203, 8207],
+  [8400, 8447],
+  [65024, 65039],
+  [65279, 65279],
+  [917760, 917999]
+];
+var inRanges = (cp, ranges) => ranges.some(([a, b]) => cp >= a && cp <= b);
+function charWidth(cp) {
+  if (cp < 32 || cp >= 127 && cp < 160) return 0;
+  if (cp < 768) return 1;
+  if (inRanges(cp, ZERO)) return 0;
+  return inRanges(cp, WIDE) ? 2 : 1;
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const ch of text) width += charWidth(ch.codePointAt(0));
+  return width;
+}
+var segsWidth = (segs) => segs.reduce((sum, s) => sum + displayWidth(s.text), 0);
+var INLINE = /(`[^`]+`|\*\*[^*]+\*\*|~~[^~]+~~|!?\[[^\]\n]+\]\([^)\s]+\)|(?<![\w*])\*(?![\s*])[^*\n]+?(?<![\s*])\*(?![\w*])|(?<!\w)_(?![\s_])[^_\n]+?(?<![\s_])_(?!\w))/g;
+function parseInline(text) {
+  const segs = [];
+  for (const part of text.split(INLINE)) {
+    if (part === "") continue;
+    if (part.length > 2 && part.startsWith("`") && part.endsWith("`")) segs.push({ text: part.slice(1, -1), style: "code" });
+    else if (part.length > 4 && part.startsWith("**") && part.endsWith("**")) segs.push({ text: part.slice(2, -2), style: "bold" });
+    else if (part.length > 4 && part.startsWith("~~") && part.endsWith("~~")) segs.push({ text: part.slice(2, -2), style: "strike" });
+    else if (/^!?\[[^\]\n]+\]\([^)\s]+\)$/.test(part)) {
+      const m = /^(!?)\[([^\]]+)\]\(([^)\s]+)\)$/.exec(part);
+      const [, image, label, url] = m;
+      segs.push({ text: label, style: image ? "plain" : "link" });
+      if (label !== url && !url.startsWith("#")) segs.push({ text: ` (${url})`, style: "dim" });
+    } else if (part.length > 2 && (part.startsWith("*") && part.endsWith("*") || part.startsWith("_") && part.endsWith("_"))) {
+      segs.push({ text: part.slice(1, -1), style: "italic" });
+    } else segs.push({ text: part, style: "plain" });
+  }
+  return segs;
+}
+function splitRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells = [];
+  let current = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\" && s[i + 1] === "|") {
+      current += "|";
+      i++;
+    } else if (s[i] === "|") {
+      cells.push(current);
+      current = "";
+    } else current += s[i];
+  }
+  cells.push(current);
+  return cells.map((c) => c.trim());
+}
+var SEPARATOR = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+var isSeparator = (line) => line.includes("|") && SEPARATOR.test(line);
+var cell = (raw) => parseInline(raw.replace(/<br\s*\/?>/gi, "\n"));
+function parseTable(lines, start) {
+  if (start + 1 >= lines.length || !lines[start].includes("|") || !isSeparator(lines[start + 1])) return void 0;
+  const header = splitRow(lines[start]);
+  const sep = splitRow(lines[start + 1]);
+  if (sep.length !== header.length) return void 0;
+  const body = [];
+  let end = start + 2;
+  while (end < lines.length && lines[end].trim() && lines[end].includes("|")) body.push(splitRow(lines[end++]));
+  const columns = Math.max(header.length, ...body.map((r) => r.length));
+  const pad2 = (row, fill) => [...row, ...Array.from({ length: columns - row.length }, () => fill)];
+  const align = pad2(
+    sep.map((s) => s.startsWith(":") && s.endsWith(":") ? "center" : s.endsWith(":") ? "right" : "left"),
+    "left"
+  );
+  return { table: { header: pad2(header, "").map(cell), align, rows: body.map((r) => pad2(r, "").map(cell)) }, end };
+}
+function tokenize(segs) {
+  const tokens = [];
+  let word = [];
+  const endWord = () => {
+    if (word.length) tokens.push(word);
+    word = [];
+  };
+  for (const seg of segs) {
+    for (const piece of seg.text.match(/\n|[^\S\n]+|[^\s]+/g) ?? []) {
+      if (piece === "\n") {
+        endWord();
+        tokens.push("br");
+      } else if (/^\s+$/.test(piece)) endWord();
+      else word.push({ text: piece, style: seg.style });
+    }
+  }
+  endWord();
+  return tokens;
+}
+function splitWord(word, width) {
+  const pieces = [];
+  let current = [];
+  let used = 0;
+  for (const seg of word) {
+    let text = "";
+    for (const ch of seg.text) {
+      const w = charWidth(ch.codePointAt(0));
+      if (used + w > width && used > 0) {
+        if (text) current.push({ text, style: seg.style });
+        pieces.push(current);
+        current = [];
+        text = "";
+        used = 0;
+      }
+      text += ch;
+      used += w;
+    }
+    if (text) current.push({ text, style: seg.style });
+  }
+  if (current.length) pieces.push(current);
+  return pieces;
+}
+function wrap(tokens, width) {
+  const lines = [];
+  let line = [];
+  let used = 0;
+  const flush = () => {
+    lines.push(line);
+    line = [];
+    used = 0;
+  };
+  for (const token of tokens) {
+    if (token === "br") {
+      flush();
+      continue;
+    }
+    const w = segsWidth(token);
+    if (w > width) {
+      if (used > 0) flush();
+      const pieces = splitWord(token, width);
+      for (const piece of pieces.slice(0, -1)) {
+        line = piece;
+        flush();
+      }
+      line = pieces.at(-1) ?? [];
+      used = segsWidth(line);
+    } else if (used === 0) {
+      line = [...token];
+      used = w;
+    } else if (used + 1 + w <= width) {
+      line.push({ text: " ", style: "plain" }, ...token);
+      used += 1 + w;
+    } else {
+      flush();
+      line = [...token];
+      used = w;
+    }
+  }
+  flush();
+  return lines;
+}
+var SEP = " \u2502 ";
+var RULE_JOIN = "\u2500\u253C\u2500";
+var MAX_MIN_WIDTH = 12;
+var dim = (text) => ({ text, style: "dim" });
+function rtrim(line) {
+  const out = [...line];
+  while (out.length) {
+    const last = out[out.length - 1];
+    const text = last.text.trimEnd();
+    if (text) {
+      out[out.length - 1] = { ...last, text };
+      break;
+    }
+    out.pop();
+  }
+  return out;
+}
+var bold = (segs) => segs.map((s) => s.style === "plain" ? { ...s, style: "bold" } : s);
+function pad(segs, width, align, last) {
+  const space = Math.max(0, width - segsWidth(segs));
+  const left = align === "right" ? space : align === "center" ? Math.floor(space / 2) : 0;
+  const right = last ? 0 : space - left;
+  return [...left ? [{ text: " ".repeat(left), style: "plain" }] : [], ...segs, ...right ? [{ text: " ".repeat(right), style: "plain" }] : []];
+}
+function columnWidths(table, available) {
+  const columns = table.align.length;
+  const all = [table.header, ...table.rows];
+  const natural = [];
+  const minimum = [];
+  for (let c = 0; c < columns; c++) {
+    let widest = 1;
+    let longestWord = 1;
+    for (const row of all) {
+      const tokens = tokenize(row[c]);
+      for (const line of wrap(tokens, Number.POSITIVE_INFINITY)) widest = Math.max(widest, segsWidth(line));
+      for (const token of tokens) if (token !== "br") longestWord = Math.max(longestWord, segsWidth(token));
+    }
+    natural.push(widest);
+    minimum.push(Math.min(longestWord, MAX_MIN_WIDTH, widest));
+  }
+  if (minimum.reduce((a, b) => a + b, 0) > available) return void 0;
+  const widths = [...natural];
+  let total = widths.reduce((a, b) => a + b, 0);
+  while (total > available) {
+    let pick = -1;
+    for (let c = 0; c < columns; c++) if (widths[c] > minimum[c] && (pick < 0 || widths[c] > widths[pick])) pick = c;
+    if (pick < 0) return void 0;
+    widths[pick]--;
+    total--;
+  }
+  return widths;
+}
+function stacked(table, width) {
+  const lines = [];
+  table.rows.forEach((row, r) => {
+    if (r > 0) lines.push([dim("\u2500".repeat(Math.min(width, 40)))]);
+    row.forEach((value, c) => {
+      const label = [...bold(table.header[c]), { text: ": ", style: "plain" }, ...value];
+      lines.push(...wrap(tokenize(label), width));
+    });
+  });
+  return lines.length ? lines : [bold(table.header.flat())];
+}
+function layoutTable(table, width) {
+  const columns = table.align.length;
+  const available = Math.max(columns, width - (columns - 1) * SEP.length);
+  const widths = columnWidths(table, available);
+  if (!widths) return stacked(table, Math.max(10, width));
+  const renderRow = (cells, header) => {
+    const wrapped = cells.map((segs, c) => wrap(tokenize(header ? bold(segs) : segs), widths[c]));
+    const height = Math.max(...wrapped.map((w) => w.length));
+    const lines = [];
+    for (let l = 0; l < height; l++) {
+      const line = [];
+      wrapped.forEach((w, c) => {
+        if (c > 0) line.push(dim(SEP));
+        line.push(...pad(w[l] ?? [], widths[c], table.align[c], c === columns - 1));
+      });
+      lines.push(rtrim(line));
+    }
+    return { lines, height };
+  };
+  const rule = [dim(widths.map((w) => "\u2500".repeat(w)).join(RULE_JOIN))];
+  const head = renderRow(table.header, true);
+  const body = table.rows.map((r) => renderRow(r, false));
+  const wrappedRows = body.some((b) => b.height > 1);
+  const out = [...head.lines, rule];
+  body.forEach((b, i) => {
+    if (wrappedRows && i > 0) out.push(rule);
+    out.push(...b.lines);
+  });
+  return out;
+}
 
 // src/ui/theme.ts
 function color(name) {
@@ -211,58 +525,136 @@ function color(name) {
 var ACCENT = "green";
 
 // src/ui/Markdown.tsx
-import { jsx } from "react/jsx-runtime";
-function inline(line) {
-  return line.split(/(\*\*[^*]+\*\*|`[^`]+`)/g).map((part, i) => {
-    if (part.length > 4 && part.startsWith("**") && part.endsWith("**")) {
-      return /* @__PURE__ */ jsx(Text, { bold: true, children: part.slice(2, -2) }, i);
-    }
-    if (part.length > 2 && part.startsWith("`") && part.endsWith("`")) {
-      return /* @__PURE__ */ jsx(Text, { color: color("cyan"), children: part.slice(1, -1) }, i);
-    }
-    return part;
-  });
+import { jsx, jsxs } from "react/jsx-runtime";
+function segment(seg, key) {
+  switch (seg.style) {
+    case "bold":
+      return /* @__PURE__ */ jsx(Text, { bold: true, children: seg.text }, key);
+    case "italic":
+      return /* @__PURE__ */ jsx(Text, { italic: true, children: seg.text }, key);
+    case "strike":
+      return /* @__PURE__ */ jsx(Text, { strikethrough: true, children: seg.text }, key);
+    case "link":
+      return /* @__PURE__ */ jsx(Text, { underline: true, color: color("cyan"), children: seg.text }, key);
+    case "code":
+      return /* @__PURE__ */ jsx(Text, { color: color("cyan"), children: seg.text }, key);
+    case "dim":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: seg.text }, key);
+    default:
+      return seg.text;
+  }
 }
-function Markdown({ text }) {
-  let inCode = false;
+var inline = (line) => parseInline(line).map(segment);
+var HEADING = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+var RULE = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+var QUOTE = /^\s{0,3}((?:>\s?)+)(.*)$/;
+var BULLET = /^(\s*)[-*+]\s+(.*)$/;
+var NUMBERED = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+var BULLETS = ["\u2022", "\u25E6", "\u25AA"];
+var bulletFor = (spaces) => BULLETS[spaces === 0 ? 0 : spaces <= 4 ? 1 : 2];
+function hanging(key, marker, body, width, padding = 0) {
+  const textWidth = Math.max(10, width - padding - displayWidth(marker) - 1);
+  return /* @__PURE__ */ jsxs(Box, { paddingLeft: padding, children: [
+    /* @__PURE__ */ jsx(Box, { flexShrink: 0, marginRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: marker }) }),
+    /* @__PURE__ */ jsx(Box, { width: textWidth, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { children: body }) })
+  ] }, key);
+}
+function Markdown({ text, indent = 2 }) {
+  const { stdout } = useStdout();
+  const width = Math.max(20, (stdout?.columns ?? 80) - indent - 1);
+  const lines = text.split("\n");
   const rows = [];
-  text.split("\n").forEach((line, i) => {
+  let inCode = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     if (line.trimStart().startsWith("```")) {
       inCode = !inCode;
-      return;
+      continue;
     }
-    rows.push(
-      inCode ? /* @__PURE__ */ jsx(Text, { color: color("cyan"), children: `  ${line}` }, i) : /* @__PURE__ */ jsx(Text, { children: line ? inline(line) : " " }, i)
-    );
-  });
+    if (inCode) {
+      rows.push(
+        /* @__PURE__ */ jsx(Text, { color: color("cyan"), children: `  ${line}` }, i)
+      );
+      continue;
+    }
+    const parsed = parseTable(lines, i);
+    if (parsed) {
+      layoutTable(parsed.table, width).forEach((tableLine, n) => {
+        rows.push(/* @__PURE__ */ jsx(Text, { children: tableLine.length ? tableLine.map(segment) : " " }, `${i}-${n}`));
+      });
+      i = parsed.end - 1;
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      const level = heading[1].length;
+      rows.push(
+        /* @__PURE__ */ jsx(Text, { bold: true, underline: level === 1, color: level <= 2 ? color(ACCENT) : void 0, children: parseInline(heading[2]).map((s) => s.text).join("") }, i)
+      );
+      continue;
+    }
+    if (RULE.test(line)) {
+      rows.push(
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(Math.min(width, 80)) }, i)
+      );
+      continue;
+    }
+    const quote = QUOTE.exec(line);
+    if (quote) {
+      const depth = quote[1].replace(/\s/g, "").length;
+      rows.push(hanging(i, "\u258E".repeat(depth), /* @__PURE__ */ jsx(Text, { italic: true, children: inline(quote[2]) }), width));
+      continue;
+    }
+    const bullet = BULLET.exec(line);
+    if (bullet) {
+      const padding = Math.min(bullet[1].replace(/\t/g, "    ").length, 16);
+      const task = /^\[([ xX])\]\s+(.*)$/.exec(bullet[2]);
+      rows.push(
+        task ? hanging(i, task[1] === " " ? "\u2610" : "\u2611", inline(task[2]), width, padding) : hanging(i, bulletFor(padding), inline(bullet[2]), width, padding)
+      );
+      continue;
+    }
+    const numbered = NUMBERED.exec(line);
+    if (numbered) {
+      const padding = Math.min(numbered[1].replace(/\t/g, "    ").length, 16);
+      rows.push(hanging(i, `${numbered[2]}.`, inline(numbered[3]), width, padding));
+      continue;
+    }
+    rows.push(/* @__PURE__ */ jsx(Text, { children: line ? inline(line) : " " }, i));
+  }
   return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rows });
 }
 
 // src/ui/LinePrompt.tsx
 import { Box as Box2, Text as Text2, useInput } from "ink";
 import { useState } from "react";
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+
+// src/ui/focusReport.ts
+var isFocusReport = (input) => input === "[I" || input === "[O";
+
+// src/ui/LinePrompt.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function LinePrompt({ label, mask, onSubmit, onCancel }) {
   const [value, setValue] = useState("");
   useInput((input, key) => {
     if (key.return) onSubmit(value.trim());
     else if (key.escape) onCancel();
     else if (key.backspace || key.delete) setValue((v) => v.slice(0, -1));
-    else if (!key.ctrl && !key.meta && !key.tab && !key.upArrow && !key.downArrow) setValue((v) => v + input.replace(/[\r\n]/g, ""));
+    else if (!key.ctrl && !key.meta && !key.tab && !key.upArrow && !key.downArrow && !isFocusReport(input)) setValue((v) => v + input.replace(/[\r\n]/g, ""));
   });
   const shown = mask ? "\u2022".repeat(value.length) : value;
-  return /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: /* @__PURE__ */ jsxs(Text2, { children: [
+  return /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: /* @__PURE__ */ jsxs2(Text2, { children: [
     `${label}: `,
     shown,
     /* @__PURE__ */ jsx2(Text2, { inverse: true, children: " " }),
-    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "   enter simpan \xB7 esc batal" })
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: t("   enter save \xB7 esc cancel") })
   ] }) });
 }
 
 // src/ui/ListPicker.tsx
 import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
 import { useState as useState2 } from "react";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var VISIBLE = 12;
 function ListPicker({ title, items, onPick }) {
   const [filter, setFilter] = useState2("");
@@ -272,31 +664,31 @@ function ListPicker({ title, items, onPick }) {
   useInput2((input, key) => {
     if (key.upArrow) setIndex(Math.max(0, cursor - 1));
     else if (key.downArrow) setIndex(Math.min(shown.length - 1, cursor + 1));
-    else if (key.return) onPick(shown[cursor]?.id);
+    else if (key.return && !shown[cursor]?.disabled) onPick(shown[cursor]?.id);
     else if (key.escape) onPick(void 0);
     else if (key.backspace || key.delete) {
       setFilter((f) => f.slice(0, -1));
       setIndex(0);
-    } else if (!key.ctrl && !key.meta && !key.tab && input) {
+    } else if (!key.ctrl && !key.meta && !key.tab && input && !isFocusReport(input)) {
       setFilter((f) => f + input);
       setIndex(0);
     }
   });
   const start = Math.max(0, Math.min(cursor - 5, shown.length - VISIBLE));
-  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: `${title} (\u2191\u2193 enter \xB7 ketik untuk menyaring${filter ? `: ${filter}` : ""} \xB7 esc batal)` }),
-    shown.slice(start, start + VISIBLE).map((item, i) => /* @__PURE__ */ jsxs2(Text3, { color: start + i === cursor ? color("green") : void 0, children: [
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: t("{title} (\u2191\u2193 enter \xB7 type to filter{filter} \xB7 esc cancel)", { title, filter: filter ? `: ${filter}` : "" }) }),
+    shown.slice(start, start + VISIBLE).map((item, i) => /* @__PURE__ */ jsxs3(Text3, { color: start + i === cursor && !item.disabled ? color("green") : void 0, dimColor: item.disabled, children: [
       `${start + i === cursor ? "\u203A" : " "} ${item.label}`,
       item.hint ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `   ${item.hint}` }) : null
     ] }, item.id)),
-    shown.length ? null : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Tidak ada yang cocok." })
+    shown.length ? null : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: t("No matches.") })
   ] });
 }
 
 // src/ui/ModelPicker.tsx
 import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
 import { useState as useState3 } from "react";
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var VISIBLE2 = 14;
 function ModelPicker({ groups, current, onPick }) {
   const [filter, setFilter] = useState3("");
@@ -322,18 +714,18 @@ function ModelPicker({ groups, current, onPick }) {
     else if (key.backspace || key.delete) {
       setFilter((f) => f.slice(0, -1));
       setIndex(0);
-    } else if (!key.ctrl && !key.meta && !key.tab && input) {
+    } else if (!key.ctrl && !key.meta && !key.tab && input && !isFocusReport(input)) {
       setFilter((f) => f + input);
       setIndex(0);
     }
   });
   const start = Math.max(0, Math.min(cursor - 5, rows.length - VISIBLE2));
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
-    /* @__PURE__ */ jsx4(Text4, { bold: true, children: `Pilih model (ketik untuk menyaring${filter ? `: ${filter}` : ""} \xB7 \u2191\u2193 enter \xB7 esc batal)` }),
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: t("Choose a model (type to filter{filter} \xB7 \u2191\u2193 enter \xB7 esc cancel)", { filter: filter ? `: ${filter}` : "" }) }),
     rows.slice(start, start + VISIBLE2).map(
       (row, i) => row.kind === "header" ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `\u2500\u2500 ${row.text} ` }, `h${start + i}`) : /* @__PURE__ */ jsx4(Text4, { color: start + i === cursor ? color("green") : void 0, children: `${start + i === cursor ? "\u203A" : " "} ${row.label}${row.ref === current ? "  (aktif)" : ""}` }, row.ref)
     ),
-    !selectable.length ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Tidak ada model yang cocok." }) : null,
+    !selectable.length ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: t("No matching models.") }) : null,
     groups.filter((g) => g.error).map((g) => /* @__PURE__ */ jsx4(Text4, { color: color("yellow"), children: `${g.providerName} \u2014 ${g.error}` }, `e-${g.providerId}`))
   ] });
 }
@@ -341,7 +733,7 @@ function ModelPicker({ groups, current, onPick }) {
 // src/ui/ProviderMenu.tsx
 import { Box as Box5, Text as Text5, useInput as useInput4 } from "ink";
 import { useState as useState4 } from "react";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function ProviderMenu({ entries, onPick }) {
   const rows = [...entries.map((e) => e.id), "custom"];
   const [index, setIndex] = useState4(0);
@@ -351,9 +743,9 @@ function ProviderMenu({ entries, onPick }) {
     else if (key.return) onPick(rows[index]);
     else if (key.escape) onPick(void 0);
   });
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
-    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Provider (\u2191\u2193 enter, esc batal) \xB7 \u2713 siap \xB7 \u25CB butuh API key" }),
-    entries.map((e, i) => /* @__PURE__ */ jsxs4(Text5, { color: i === index ? color("green") : void 0, children: [
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: t("Provider (\u2191\u2193 enter, esc cancel) \xB7 \u2713 ready \xB7 \u25CB needs API key") }),
+    entries.map((e, i) => /* @__PURE__ */ jsxs5(Text5, { color: i === index ? color("green") : void 0, children: [
       `${i === index ? "\u203A" : " "} ${e.ready ? "\u2713" : "\u25CB"} ${e.name}`,
       /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: `  ${e.baseURL}` })
     ] }, e.id)),
@@ -376,8 +768,8 @@ function DiffView({ diff }) {
 }
 
 // src/ui/PermissionPrompt.tsx
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-var VERB = { edit: "edit", write: "tulis", bash: "jalankan", fetch: "ambil" };
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var VERB = { edit: "edit", write: "write", bash: "run", fetch: "fetch" };
 function PermissionPrompt({
   request,
   onAnswer
@@ -390,16 +782,16 @@ function PermissionPrompt({
     else if (k2 === "n" || key.escape) onAnswer("no");
   });
   const rules = request.sessionRules ?? [];
-  const sessionLabel = !rules.length ? null : request.kind === "edit" ? "ya untuk semua edit di project ini, sesi ini" : `ya sesi ini untuk ${rules.join(", ")}`;
-  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", borderStyle: "round", borderColor: color("yellow"), paddingX: 1, children: [
-    /* @__PURE__ */ jsx7(Text7, { bold: true, children: `${request.agent ? `[${request.agent}] ` : ""}Izinkan ${VERB[request.tool] ?? request.tool} ${request.target}?` }),
+  const sessionLabel = !rules.length ? null : request.kind === "edit" ? t("yes for all edits in this project, this session") : t("yes this session for {rules}", { rules: rules.join(", ") });
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", borderStyle: "round", borderColor: color("yellow"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, children: `${request.agent ? `[${request.agent}] ` : ""}${t("Allow {verb} {target}?", { verb: t(VERB[request.tool] ?? request.tool), target: request.target })}` }),
     request.preview ? /* @__PURE__ */ jsx7(DiffView, { diff: request.preview }) : null,
-    /* @__PURE__ */ jsxs5(Text7, { children: [
-      /* @__PURE__ */ jsx7(Text7, { color: color("green"), children: "[y] ya" }),
+    /* @__PURE__ */ jsxs6(Text7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { color: color("green"), children: t("[y] yes") }),
       "   ",
       sessionLabel ? /* @__PURE__ */ jsx7(Text7, { color: color("cyan"), children: `[a] ${sessionLabel}   ` }) : null,
-      /* @__PURE__ */ jsx7(Text7, { color: color("yellow"), children: "[s] ya semua   " }),
-      /* @__PURE__ */ jsx7(Text7, { color: color("red"), children: "[n] tidak" })
+      /* @__PURE__ */ jsx7(Text7, { color: color("yellow"), children: t("[s] yes to all   ") }),
+      /* @__PURE__ */ jsx7(Text7, { color: color("red"), children: t("[n] no") })
     ] })
   ] });
 }
@@ -422,7 +814,7 @@ function completeFile(value, cwd) {
 }
 
 // src/ui/PromptInput.tsx
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
 function PromptInput({ disabled, history, cwd, onSubmit, extraCommands }) {
   const [value, setValue] = useState5("");
   const [historyIndex, setHistoryIndex] = useState5(null);
@@ -491,18 +883,18 @@ function PromptInput({ disabled, history, cwd, onSubmit, extraCommands }) {
         edit((v) => completeFile(v, cwd));
         return;
       }
-      if (key.ctrl || key.meta || key.escape || key.tab || key.leftArrow || key.rightArrow) return;
+      if (key.ctrl || key.meta || key.escape || key.tab || key.leftArrow || key.rightArrow || isFocusReport(input)) return;
       edit((v) => v + input.replace(/\r/g, "\n"));
     },
     { isActive: !disabled }
   );
-  return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx8(Box8, { borderStyle: "round", borderColor: color("gray"), paddingX: 1, children: /* @__PURE__ */ jsxs6(Text8, { children: [
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Box8, { borderStyle: "round", borderColor: color("gray"), paddingX: 1, children: /* @__PURE__ */ jsxs7(Text8, { children: [
       /* @__PURE__ */ jsx8(Text8, { color: color("green"), children: "> " }),
       value,
       disabled ? "" : /* @__PURE__ */ jsx8(Text8, { inverse: true, children: " " })
     ] }) }),
-    suggestions.map((s, i) => /* @__PURE__ */ jsx8(Text8, { color: i === highlighted ? color("green") : void 0, dimColor: i !== highlighted, children: `${i === highlighted ? "\u203A" : " "} /${s.name}  ${s.description}` }, s.name))
+    suggestions.map((s, i) => /* @__PURE__ */ jsx8(Text8, { color: i === highlighted ? color("green") : void 0, dimColor: i !== highlighted, children: `${i === highlighted ? "\u203A" : " "} /${s.name}  ${t(s.description)}` }, s.name))
   ] });
 }
 
@@ -514,11 +906,11 @@ var FRAMES = ["\xB7", "\u2722", "\u2733", "\u2736", "\u273B", "\u273D"];
 function Spinner({ label, startedAt }) {
   const [tick, setTick] = useState6(0);
   useEffect(() => {
-    const id = setInterval(() => setTick((t) => t + 1), 120);
+    const id = setInterval(() => setTick((t2) => t2 + 1), 120);
     return () => clearInterval(id);
   }, []);
   const seconds = Math.floor((Date.now() - startedAt) / 1e3);
-  return /* @__PURE__ */ jsx9(Text9, { color: color(ACCENT), children: `${FRAMES[tick % FRAMES.length]} ${label}\u2026 (${seconds} dtk \xB7 esc batal)` });
+  return /* @__PURE__ */ jsx9(Text9, { color: color(ACCENT), children: `${FRAMES[tick % FRAMES.length]} ${t("{label}\u2026 ({seconds}s \xB7 esc to cancel)", { label, seconds })}` });
 }
 
 // src/ui/StatusBar.tsx
@@ -533,15 +925,15 @@ var LABEL = {
 function formatTokens(n) {
   return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
 }
-function StatusBar({ mode, tokens, busy, model }) {
+function StatusBar({ mode, tokens, busy, model, reasoning = "auto" }) {
   const danger = mode === "allowAll";
-  return /* @__PURE__ */ jsx10(Text10, { color: danger ? color("red") : void 0, dimColor: !danger, children: `  ${LABEL[mode]}${model ? ` \xB7 ${model}` : ""} \xB7 shift+tab ganti mode \xB7 ${formatTokens(tokens)} token \xB7 ${busy ? "esc batal" : "/ perintah"}` });
+  return /* @__PURE__ */ jsx10(Text10, { color: danger ? color("red") : void 0, dimColor: !danger, children: `  ${LABEL[mode]}${model ? ` \xB7 ${model}` : ""} \xB7 reasoning: ${reasoning} \xB7 ${t("shift+tab switch mode")} \xB7 ${t("{n} tokens", { n: formatTokens(tokens) })} \xB7 ${busy ? t("esc to cancel") : t("/ for commands")}` });
 }
 
 // src/ui/McpMenu.tsx
 import { Box as Box9, Text as Text11, useInput as useInput7 } from "ink";
 import { useState as useState7 } from "react";
-import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
 var MARK = { ready: "\u2713", error: "\u2717", starting: "\u2026", off: "\u25CB" };
 function McpMenu({ items, onPick }) {
   const [index, setIndex] = useState7(0);
@@ -551,9 +943,9 @@ function McpMenu({ items, onPick }) {
     else if (key.return) onPick(items[index]?.name);
     else if (key.escape) onPick(void 0);
   });
-  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
-    /* @__PURE__ */ jsx11(Text11, { bold: true, children: "Server MCP (enter: pasang / hapus \xB7 esc tutup) \xB7 \u2713 aktif \u25CB belum \u2717 error" }),
-    items.map((item, i) => /* @__PURE__ */ jsxs7(Text11, { color: i === index ? color("green") : void 0, children: [
+  return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx11(Text11, { bold: true, children: t("MCP servers (enter: install / remove \xB7 esc close) \xB7 \u2713 active \u25CB not installed \u2717 error") }),
+    items.map((item, i) => /* @__PURE__ */ jsxs8(Text11, { color: i === index ? color("green") : void 0, children: [
       `${i === index ? "\u203A" : " "} ${MARK[item.status]} ${item.name.padEnd(12)}`,
       /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: item.status === "error" ? ` ${item.error ?? ""}` : ` ${item.description}` })
     ] }, item.name))
@@ -562,7 +954,7 @@ function McpMenu({ items, onPick }) {
 
 // src/ui/PlanApproval.tsx
 import { Box as Box10, Text as Text12, useInput as useInput8 } from "ink";
-import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
 function PlanApproval({ plan, onAnswer }) {
   useInput8((input, key) => {
     const k2 = input.toLowerCase();
@@ -570,15 +962,15 @@ function PlanApproval({ plan, onAnswer }) {
     else if (k2 === "y") onAnswer("default");
     else if (k2 === "n" || key.escape) onAnswer("no");
   });
-  return /* @__PURE__ */ jsxs8(Box10, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
-    /* @__PURE__ */ jsx12(Text12, { bold: true, children: "Rencana dari agent" }),
-    /* @__PURE__ */ jsx12(Markdown, { text: plan }),
-    /* @__PURE__ */ jsxs8(Text12, { children: [
-      /* @__PURE__ */ jsx12(Text12, { color: color("green"), children: "[a] ya, edit otomatis" }),
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Text12, { bold: true, children: t("Plan from the agent") }),
+    /* @__PURE__ */ jsx12(Markdown, { text: plan, indent: 5 }),
+    /* @__PURE__ */ jsxs9(Text12, { children: [
+      /* @__PURE__ */ jsx12(Text12, { color: color("green"), children: t("[a] yes, auto-edit") }),
       "   ",
-      /* @__PURE__ */ jsx12(Text12, { color: color("cyan"), children: "[y] ya, tanya tiap langkah" }),
+      /* @__PURE__ */ jsx12(Text12, { color: color("cyan"), children: t("[y] yes, ask at each step") }),
       "   ",
-      /* @__PURE__ */ jsx12(Text12, { color: color("red"), children: "[n] belum, perbaiki dulu" })
+      /* @__PURE__ */ jsx12(Text12, { color: color("red"), children: t("[n] not yet, revise first") })
     ] })
   ] });
 }
@@ -588,34 +980,34 @@ import { Box as Box11, Text as Text13 } from "ink";
 import { jsx as jsx13 } from "react/jsx-runtime";
 var MARK2 = { completed: "\u2611", in_progress: "\u25FC", pending: "\u2610" };
 function TodoList({ items }) {
-  if (!items.length || items.every((t) => t.status === "completed")) return null;
-  return /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: items.map((t, i) => /* @__PURE__ */ jsx13(Text13, { dimColor: t.status === "completed", color: t.status === "in_progress" ? color("yellow") : void 0, children: `${MARK2[t.status]} ${t.content}` }, i)) });
+  if (!items.length || items.every((t2) => t2.status === "completed")) return null;
+  return /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: items.map((t2, i) => /* @__PURE__ */ jsx13(Text13, { dimColor: t2.status === "completed", color: t2.status === "in_progress" ? color("yellow") : void 0, children: `${MARK2[t2.status]} ${t2.content}` }, i)) });
 }
 
 // src/ui/ToolBlock.tsx
 import { Box as Box12, Text as Text14 } from "ink";
-import { jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
 var PREVIEW_LINES = 5;
 function ToolBlock({ tool, target, output, display, isError, done, expanded, sub }) {
   const isTask = tool === "task";
   const isDiff = !!display && /^\s*\d+ [+\- ] /.test(display);
   const lines = (output ?? "").split("\n");
   const shown = expanded ? lines : lines.slice(0, PREVIEW_LINES);
-  return /* @__PURE__ */ jsxs9(Box12, { flexDirection: "column", marginLeft: 2, children: [
-    /* @__PURE__ */ jsxs9(Text14, { children: [
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs10(Text14, { children: [
       /* @__PURE__ */ jsx14(Text14, { color: isError ? color("red") : done ? color("green") : color("yellow"), children: "\u23BF " }),
       /* @__PURE__ */ jsx14(Text14, { bold: true, children: toolLabel(tool) }),
       /* @__PURE__ */ jsx14(Text14, { children: `  ${target}` }),
       display && !isDiff && !isTask ? /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: `  (${display})` }) : null
     ] }),
-    sub?.length ? /* @__PURE__ */ jsxs9(Box12, { flexDirection: "column", marginLeft: 3, children: [
+    sub?.length ? /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", marginLeft: 3, children: [
       sub.slice(-6).map((s) => /* @__PURE__ */ jsx14(Text14, { dimColor: s.done && !s.isError, color: s.isError ? color("red") : void 0, children: `\u23BF ${toolLabel(s.tool)}  ${s.target}` }, s.id)),
-      sub.length > 6 ? /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: `\u2026 ${sub.length - 6} langkah sebelumnya` }) : null
+      sub.length > 6 ? /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: t("\u2026 {n} earlier steps", { n: sub.length - 6 }) }) : null
     ] }) : null,
-    isTask && done ? /* @__PURE__ */ jsx14(Box12, { marginLeft: 3, children: /* @__PURE__ */ jsx14(Text14, { color: isError ? color("red") : color("green"), children: `${isError ? "\u2717 gagal" : "\u2713 selesai"}${display ? ` \xB7 ${display}` : ""}` }) }) : null,
-    isDiff ? /* @__PURE__ */ jsx14(Box12, { marginLeft: 3, children: /* @__PURE__ */ jsx14(DiffView, { diff: display }) }) : output && (isError || tool === "bash") && !(isTask && !isError) ? /* @__PURE__ */ jsxs9(Box12, { flexDirection: "column", marginLeft: 3, children: [
+    isTask && done ? /* @__PURE__ */ jsx14(Box12, { marginLeft: 3, children: /* @__PURE__ */ jsx14(Text14, { color: isError ? color("red") : color("green"), children: `${isError ? t("\u2717 failed") : t("\u2713 done")}${display ? ` \xB7 ${display}` : ""}` }) }) : null,
+    isDiff ? /* @__PURE__ */ jsx14(Box12, { marginLeft: 3, children: /* @__PURE__ */ jsx14(DiffView, { diff: display }) }) : output && (isError || tool === "bash") && !(isTask && !isError) ? /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", marginLeft: 3, children: [
       shown.map((line, i) => /* @__PURE__ */ jsx14(Text14, { dimColor: !isError, color: isError ? color("red") : void 0, children: line }, i)),
-      lines.length > shown.length ? /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: `\u2026 ${lines.length - shown.length} baris lagi (ctrl+o)` }) : null
+      lines.length > shown.length ? /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: t("\u2026 {n} more lines (ctrl+o)", { n: lines.length - shown.length }) }) : null
     ] }) : null
   ] });
 }
@@ -624,73 +1016,105 @@ function ToolBlock({ tool, target, output, display, isError, done, expanded, sub
 var nextId = 0;
 var entry = (e) => ({ ...e, id: nextId++ });
 var NOTICES = {
-  compacted: ["Percakapan diringkas agar muat di konteks model.", "info"],
-  stepLimit: ['Batas 50 langkah tercapai. Ketik "lanjut" untuk meneruskan.', "warn"],
-  aborted: ["Dibatalkan.", "warn"]
+  compacted: ["Conversation summarized to fit the model context.", "info"],
+  stepLimit: ['Step limit of 50 reached. Type "continue" to keep going.', "warn"],
+  aborted: ["Cancelled.", "warn"]
 };
-function endTurn(t) {
-  return { done: [...t.done, ...t.live], live: [] };
+var isEmptyCont = (e) => e.kind === "assistant" && e.cont && !e.text;
+function endTurn(t2) {
+  return { done: [...t2.done, ...t2.live.filter((e) => !isEmptyCont(e))], live: [] };
 }
-function applyEvent(t, event) {
+var TOOL_MARKUP = /<\/?tool_call>|<\/?arg_(?:key|value)>|Tool call list|^\s*\d+\.\s*Tool:|`\s*=\s*`/;
+function finishedCut(text) {
+  let inFence = false;
+  let pos = 0;
+  let cut = -1;
+  const lines = text.split("\n");
+  for (const line of lines.slice(0, -1)) {
+    if (TOOL_MARKUP.test(line)) break;
+    if (line.trimStart().startsWith("```")) inFence = !inFence;
+    const tableRow = !inFence && !line.trimStart().startsWith("```") && line.includes("|") && line.trim() !== "";
+    pos += line.length + 1;
+    if (!inFence && !tableRow) cut = pos - 1;
+  }
+  return cut;
+}
+function flushLines(t2) {
+  const last = t2.live.at(-1);
+  if (last?.kind !== "assistant") return t2;
+  const cut = finishedCut(last.text);
+  if (cut < 0) return t2;
+  const chunk = last.text.slice(0, cut);
+  if (!last.cont && !chunk.trim()) return t2;
+  const rest = entry({ kind: "assistant", text: last.text.slice(cut + 1), cont: true, flushed: (last.flushed ?? 0) + cut + 1 });
+  return { done: [...t2.done, ...t2.live.slice(0, -1).filter((e) => !isEmptyCont(e)), { ...last, text: chunk || " " }], live: [rest] };
+}
+function applyEvent(t2, event) {
   switch (event.type) {
     case "text": {
-      const last = t.live.at(-1);
-      if (last?.kind === "assistant") return { ...t, live: [...t.live.slice(0, -1), { ...last, text: last.text + event.delta }] };
-      return { ...t, live: [...t.live, entry({ kind: "assistant", text: event.delta })] };
+      const last = t2.live.at(-1);
+      if (last?.kind === "assistant") return flushLines({ ...t2, live: [...t2.live.slice(0, -1), { ...last, text: last.text + event.delta }] });
+      return flushLines({ ...t2, live: [...t2.live, entry({ kind: "assistant", text: event.delta })] });
+    }
+    case "thinking": {
+      const last = t2.live.at(-1);
+      if (last?.kind === "thinking") return { ...t2, live: [...t2.live.slice(0, -1), { ...last, text: last.text + event.delta }] };
+      return { ...t2, live: [...t2.live, entry({ kind: "thinking", text: event.delta })] };
     }
     case "textReplace": {
-      const last = t.live.at(-1);
-      if (last?.kind !== "assistant") return t;
-      return { ...t, live: [...t.live.slice(0, -1), { ...last, text: event.text }] };
+      const last = t2.live.at(-1);
+      if (last?.kind !== "assistant") return t2;
+      return { ...t2, live: [...t2.live.slice(0, -1), { ...last, text: event.text.slice(last.flushed ?? 0) }] };
     }
     case "toolStart": {
-      const running = t.live.some((e) => e.kind === "tool" && !e.done);
+      const running = t2.live.some((e) => e.kind === "tool" && !e.done);
       const tool = entry({ kind: "tool", callId: event.id, tool: event.tool, target: event.target, done: false });
-      return running ? { ...t, live: [...t.live, tool] } : { done: [...t.done, ...t.live], live: [tool] };
+      return running ? { ...t2, live: [...t2.live, tool] } : { done: [...t2.done, ...t2.live.filter((e) => !isEmptyCont(e))], live: [tool] };
     }
     case "toolEnd": {
-      const live = t.live.map(
+      const live = t2.live.map(
         (e) => e.kind === "tool" && e.callId === event.id ? { ...e, output: event.output, display: event.display, isError: event.isError, done: true } : e
       );
       const firstRunning = live.findIndex((e) => e.kind === "tool" && !e.done);
       const cut = firstRunning === -1 ? live.length : firstRunning;
-      return { done: [...t.done, ...live.slice(0, cut)], live: live.slice(cut) };
+      return { done: [...t2.done, ...live.slice(0, cut)], live: live.slice(cut) };
     }
     case "subagent": {
       const inner = event.event;
-      if (inner.type !== "toolStart" && inner.type !== "toolEnd") return t;
+      if (inner.type !== "toolStart" && inner.type !== "toolEnd") return t2;
       const update = (e) => {
         if (e.kind !== "tool" || e.callId !== event.parentId) return e;
         const sub = e.sub ?? [];
         if (inner.type === "toolStart") return { ...e, sub: [...sub, { id: inner.id, tool: inner.tool, target: inner.target, done: false }] };
         return { ...e, sub: sub.map((s) => s.id === inner.id ? { ...s, done: true, isError: inner.isError } : s) };
       };
-      return { ...t, live: t.live.map(update) };
+      return { ...t2, live: t2.live.map(update) };
     }
     case "error":
-      return { ...t, live: [...t.live, entry({ kind: "notice", text: `Error: ${event.message}`, tone: "error" })] };
+      return { ...t2, live: [...t2.live, entry({ kind: "notice", text: `Error: ${event.message}`, tone: "error" })] };
     default: {
       const notice = NOTICES[event.type];
-      return notice ? { ...t, live: [...t.live, entry({ kind: "notice", text: notice[0], tone: notice[1] })] } : t;
+      return notice ? { ...t2, live: [...t2.live, entry({ kind: "notice", text: t(notice[0]), tone: notice[1] })] } : t2;
     }
   }
 }
 
 // src/ui/App.tsx
-import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
 function helpText(runtime) {
   const custom = runtime.commands.filter((c) => !SLASH_COMMANDS.some((b) => b.name === c.name));
   return [
-    ...SLASH_COMMANDS.map((c) => `/${c.name.padEnd(12)} ${c.description}`),
-    ...custom.length ? ["", "Perintah custom:", ...custom.map((c) => `/${c.name.padEnd(8)} ${c.description ?? ""}`)] : [],
-    ...runtime.skills.length ? ["", "Skill:", ...runtime.skills.map((s) => `/${s.name.padEnd(8)} ${s.description.slice(0, 60)}`)] : [],
+    ...SLASH_COMMANDS.map((c) => `/${c.name.padEnd(12)} ${t(c.description)}`),
+    ...custom.length ? ["", t("Custom commands:"), ...custom.map((c) => `/${c.name.padEnd(8)} ${c.description ?? ""}`)] : [],
+    ...runtime.skills.length ? ["", t("Skills:"), ...runtime.skills.map((s) => `/${s.name.padEnd(8)} ${s.description.slice(0, 60)}`)] : [],
     "",
-    "shift+tab  ganti mode izin    esc  batalkan giliran",
-    "ctrl+o     output alat terakhir lengkap    \\ + enter  baris baru",
-    "@file + tab  lengkapi nama file    \u2191\u2193  riwayat input"
+    t("shift+tab  switch permission mode    esc  cancel the turn"),
+    t("ctrl+o     full output of the last tool    \\ + enter  new line"),
+    t("ctrl+t     show/hide the model\u2019s thinking"),
+    t("@file + tab  complete file names    \u2191\u2193  input history")
   ].join("\n");
 }
-var INIT_PROMPT = "Pelajari project ini (struktur folder, file package/build, perintah test dan lint, konvensi kode yang terlihat). Lalu buat AGENTS.md di root project, atau perbarui bila sudah ada, berisi: cara build, test, dan lint; struktur singkat; konvensi penting. Ringkas dan faktual, hanya yang benar-benar ada di project.";
+var INIT_PROMPT = "Study this project (folder structure, package/build files, test and lint commands, visible code conventions). Then create AGENTS.md in the project root, or update it if it already exists, covering: how to build, test, and lint; a short structure overview; important conventions. Keep it concise and factual, only what actually exists in the project.";
 var labelFor = (runtime, ref) => `${ref.slice(ref.indexOf("/") + 1)} \xB7 ${runtime.providerLabel()}`;
 function App({ runtime, initialPrompt, version }) {
   const { exit } = useApp();
@@ -698,6 +1122,7 @@ function App({ runtime, initialPrompt, version }) {
   const [busy, setBusy] = useState8(false);
   const [startedAt, setStartedAt] = useState8(0);
   const [mode, setMode] = useState8(runtime.agent.permissions.mode);
+  const [reasoning, setReasoning] = useState8(runtime.reasoning);
   const [tokens, setTokens] = useState8(runtime.agent.totalUsage.inputTokens + runtime.agent.totalUsage.outputTokens);
   const [asks, setAsks] = useState8([]);
   const pending = asks[0] ?? null;
@@ -713,15 +1138,17 @@ function App({ runtime, initialPrompt, version }) {
   const [mcpMenu, setMcpMenu] = useState8(null);
   const [listPicker, setListPicker] = useState8(null);
   const [planAsk, setPlanAsk] = useState8(null);
+  const [queued, setQueued] = useState8([]);
+  const [showThinking, setShowThinking] = useState8(false);
   useEffect2(() => runtime.todos.subscribe(setTodos), [runtime]);
   const extraCommands = [
-    ...runtime.commands.filter((c) => !SLASH_COMMANDS.some((b) => b.name === c.name.toLowerCase())).map((c) => ({ name: c.name.toLowerCase(), description: c.description ?? "perintah custom" })),
-    ...runtime.skills.filter((s) => !runtime.commands.some((c) => c.name.toLowerCase() === s.name.toLowerCase())).filter((s) => !SLASH_COMMANDS.some((b) => b.name === s.name.toLowerCase())).map((s) => ({ name: s.name, description: `skill \xB7 ${s.description.slice(0, 50)}` }))
+    ...runtime.commands.filter((c) => !SLASH_COMMANDS.some((b) => b.name === c.name.toLowerCase())).map((c) => ({ name: c.name.toLowerCase(), description: c.description ?? t("custom command") })),
+    ...runtime.skills.filter((s) => !runtime.commands.some((c) => c.name.toLowerCase() === s.name.toLowerCase())).filter((s) => !SLASH_COMMANDS.some((b) => b.name === s.name.toLowerCase())).map((s) => ({ name: s.name, description: t("skill \xB7 {description}", { description: s.description.slice(0, 50) }) }))
   ];
   const lastTool = useRef(null);
   const toolTargets = useRef(/* @__PURE__ */ new Map());
   const notice = useCallback((text, tone = "info") => {
-    setTranscript((t) => ({ ...t, done: [...t.done, entry({ kind: "notice", text, tone })] }));
+    setTranscript((t2) => ({ ...t2, done: [...t2.done, entry({ kind: "notice", text, tone })] }));
   }, []);
   const onEvent = useCallback((event) => {
     if (event.type === "toolStart") toolTargets.current.set(event.id, event.target);
@@ -729,7 +1156,7 @@ function App({ runtime, initialPrompt, version }) {
       lastTool.current = { tool: event.tool, target: toolTargets.current.get(event.id) ?? "", output: event.output };
     }
     if (event.type === "usage") setTokens(event.inputTokens + event.outputTokens);
-    setTranscript((t) => applyEvent(t, event));
+    setTranscript((t2) => applyEvent(t2, event));
   }, []);
   useEffect2(() => {
     runtime.agent.onEvent = onEvent;
@@ -738,7 +1165,7 @@ function App({ runtime, initialPrompt, version }) {
   }, [runtime, onEvent]);
   const runTurn = useCallback(
     async (text) => {
-      setTranscript((t) => ({ ...t, done: [...t.done, entry({ kind: "user", text })] }));
+      setTranscript((t2) => ({ ...t2, done: [...t2.done, entry({ kind: "user", text })] }));
       setBusy(true);
       setStartedAt(Date.now());
       controller.current = new AbortController();
@@ -761,11 +1188,11 @@ function App({ runtime, initialPrompt, version }) {
         case "clear":
           runtime.agent.clear();
           setTokens(0);
-          notice("Percakapan dikosongkan.");
+          notice(t("Conversation cleared."));
           return;
         case "cost": {
           const u = runtime.agent.totalUsage;
-          notice(`${u.inputTokens.toLocaleString("id-ID")} token masuk \xB7 ${u.outputTokens.toLocaleString("id-ID")} token keluar`);
+          notice(t("{input} tokens in \xB7 {output} tokens out", { input: u.inputTokens.toLocaleString(locale()), output: u.outputTokens.toLocaleString(locale()) }));
           return;
         }
         case "compact": {
@@ -775,19 +1202,54 @@ function App({ runtime, initialPrompt, version }) {
           try {
             await runtime.agent.compact(controller.current.signal);
           } catch (error) {
-            notice(`Gagal meringkas: ${error.message}`, "error");
+            notice(t("Could not summarize: {error}", { error: error.message }), "error");
           }
           controller.current = null;
           setBusy(false);
           return;
         }
+        case "reasoning": {
+          const apply = (value) => {
+            try {
+              const level = parseReasoningLevel(value, "/reasoning");
+              const providerId2 = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
+              assertReasoningSupported(providerId2, level);
+              runtime.setReasoning(level);
+              writeGlobalConfig({ reasoning: level }, runtime.env);
+              setReasoning(level);
+              notice(t("Reasoning: {level} (saved as default)", { level }));
+            } catch (error) {
+              notice(error.message, "error");
+            }
+          };
+          if (args) {
+            apply(args);
+            return;
+          }
+          const providerId = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
+          const supported = supportedReasoningLevels(providerId);
+          setListPicker({
+            title: "Reasoning",
+            items: REASONING_LEVELS.map((level) => ({
+              id: level,
+              label: level === "auto" ? "Auto (model default)" : level.charAt(0).toUpperCase() + level.slice(1),
+              disabled: !supported.includes(level),
+              hint: supported.includes(level) ? void 0 : t("not supported by this provider")
+            })),
+            onPick: (id) => {
+              setListPicker(null);
+              if (id) apply(id);
+            }
+          });
+          return;
+        }
         case "model": {
           if (args) {
             try {
               runtime.setModel(args);
               writeGlobalConfig({ model: args }, runtime.env);
               setModelLabel(labelFor(runtime, args));
-              notice(`Model: ${args} (tersimpan sebagai default)`);
+              notice(t("Model: {model} (saved as default)", { model: args }));
             } catch (error) {
               notice(error.message, "error");
             }
@@ -796,7 +1258,7 @@ function App({ runtime, initialPrompt, version }) {
           try {
             setPicker(await runtime.listModels());
           } catch (error) {
-            notice(`Tidak bisa mengambil daftar model: ${error.message}`, "error");
+            notice(t("Cannot fetch the model list: {error}", { error: error.message }), "error");
           }
           return;
         }
@@ -804,7 +1266,7 @@ function App({ runtime, initialPrompt, version }) {
           const installed = readMcpFile(globalMcpPath(runtime.home));
           const states = runtime.mcp.states();
           const items = [
-            ...CATALOG.map((c) => ({ name: c.name, description: c.description, installed: !!installed[c.name] })),
+            ...CATALOG.map((c) => ({ name: c.name, description: t(c.description), installed: !!installed[c.name] })),
             ...Object.keys(installed).filter((n) => !CATALOG.some((c) => c.name === n)).map((n) => ({ name: n, description: "(custom)", installed: true }))
           ].map((i) => {
             const s = states.find((st) => st.name === i.name);
@@ -816,7 +1278,7 @@ function App({ runtime, initialPrompt, version }) {
         case "new":
           runtime.newSession();
           setTokens(0);
-          notice("Sesi baru dimulai. Sesi sebelumnya tetap tersimpan (/resume).");
+          notice(t("New session started. The previous session stays saved (/resume)."));
           return;
         case "session":
           notice(
@@ -832,15 +1294,15 @@ function App({ runtime, initialPrompt, version }) {
         case "resume": {
           const others = Session.list(runtime.home, runtime.cwd).filter((s) => s.session.file !== runtime.session.file);
           if (!others.length) {
-            notice("Belum ada sesi lain di folder ini.");
+            notice(t("No other sessions in this folder yet."));
             return;
           }
           setListPicker({
-            title: "Lanjutkan sesi",
+            title: t("Continue a session"),
             items: others.map((s) => ({
               id: s.session.file,
-              label: `${s.mtime.toLocaleString("id-ID")}  ${s.preview || "(kosong)"}`,
-              hint: `${s.session.load().length} pesan`
+              label: `${s.mtime.toLocaleString(locale())}  ${s.preview || t("(empty)")}`,
+              hint: t("{n} messages", { n: s.session.load().length })
             })),
             onPick: (id) => {
               setListPicker(null);
@@ -848,12 +1310,23 @@ function App({ runtime, initialPrompt, version }) {
               if (!chosen) return;
               runtime.resume(chosen.session);
               setTokens(0);
-              const tail = runtime.agent.messages.filter((m) => (m.role === "user" || m.role === "assistant") && m.content).slice(-3);
-              notice(
-                [`Melanjutkan sesi (${runtime.agent.messages.length} pesan):`, ...tail.map((m) => `${m.role === "user" ? ">" : "\u25CF"} ${String(m.content).slice(0, 200)}`)].join(
-                  "\n"
-                )
+              const chat = runtime.agent.messages.filter(
+                (m) => (m.role === "user" || m.role === "assistant") && typeof m.content === "string" && !!m.content.trim()
               );
+              setTranscript({
+                done: [
+                  entry({ kind: "header" }),
+                  entry({
+                    kind: "notice",
+                    text: t("Resuming the session ({messages} messages saved \xB7 {chat} user/assistant chats shown).", { messages: runtime.agent.messages.length, chat: chat.length }),
+                    tone: "info"
+                  }),
+                  ...chat.map(
+                    (m) => entry(m.role === "user" ? { kind: "user", text: m.content } : { kind: "assistant", text: m.content })
+                  )
+                ],
+                live: []
+              });
             }
           });
           return;
@@ -879,7 +1352,7 @@ function App({ runtime, initialPrompt, version }) {
           notice(skillsText(runtime.skills, runtime.commands));
           return;
         case "doctor": {
-          notice("Memeriksa\u2026");
+          notice(t("Checking\u2026"));
           const c = runtime.config;
           notice(
             await doctorText(
@@ -900,20 +1373,20 @@ function App({ runtime, initialPrompt, version }) {
         case "permissions": {
           const rules = runtime.agent.permissions.list();
           if (!rules.length) {
-            notice("Belum ada izin tersimpan. Izin dari jawaban [a] dan dari config akan muncul di sini.");
+            notice(t("No saved permissions yet. Permissions from [a] answers and from the config will appear here."));
             return;
           }
           setListPicker({
-            title: "Izin aktif (enter: cabut izin sesi)",
-            items: rules.map((r) => ({ id: r.rule, label: r.rule, hint: r.source === "config" ? "config" : "sesi ini" })),
+            title: t("Active permissions (enter: revoke a session permission)"),
+            items: rules.map((r) => ({ id: r.rule, label: r.rule, hint: r.source === "config" ? "config" : t("this session") })),
             onPick: (id) => {
               setListPicker(null);
               const rule = rules.find((r) => r.rule === id);
               if (!rule) return;
-              if (rule.source === "config") notice(`${rule.rule} berasal dari config/flag; hapus dari ~/.bccli/config.json untuk mencabutnya.`, "warn");
+              if (rule.source === "config") notice(t("{rule} comes from the config/flag; remove it from ~/.bccli/config.json to revoke it.", { rule: rule.rule }), "warn");
               else {
                 runtime.agent.permissions.revoke(rule.rule);
-                notice(`Izin ${rule.rule} dicabut.`);
+                notice(t("Permission {rule} revoked.", { rule: rule.rule }));
               }
             }
           });
@@ -922,12 +1395,12 @@ function App({ runtime, initialPrompt, version }) {
         case "memory": {
           if (!args) {
             const files = instructionFiles(runtime.cwd, runtime.home);
-            notice(files.length ? files.map((f) => `${f.path} (${f.lines} baris)`).join("\n") : "Belum ada AGENTS.md / BCCLI.md. Tambah dengan /memory <teks>.");
+            notice(files.length ? files.map((f) => t("{path} ({lines} lines)", { path: f.path, lines: f.lines })).join("\n") : t("No AGENTS.md / BCCLI.md yet. Add one with /memory <text>."));
             return;
           }
           const { global, text } = parseMemoryArgs(args);
           if (!text) {
-            notice("Tulis teksnya: /memory global <teks>.", "warn");
+            notice(t("Write the text: /memory global <text>."), "warn");
             return;
           }
           const file = global ? join(runtime.home, "BCCLI.md") : join(runtime.cwd, "AGENTS.md");
@@ -935,19 +1408,38 @@ function App({ runtime, initialPrompt, version }) {
             mkdirSync(dirname(file), { recursive: true });
             appendMemory(file, text);
           } catch (error) {
-            notice(`Gagal menulis ${file}: ${error.message}`, "error");
+            notice(t("Could not write {file}: {error}", { file, error: error.message }), "error");
             return;
           }
           runtime.rebuildSystemPrompt();
-          notice(`Ditambahkan ke ${file}.`);
+          notice(t("Added to {file}.", { file }));
           return;
         }
         case "init":
           void runTurn(INIT_PROMPT);
           return;
+        case "language": {
+          if (!args) {
+            notice(t("Language: {lang}. Change it with /language en or /language id.", { lang: getLanguage() }));
+            return;
+          }
+          const wanted = parseLang(args);
+          if (!wanted) {
+            notice(t('Unknown language "{lang}". Use en or id.', { lang: args }), "warn");
+            return;
+          }
+          setLanguage(wanted);
+          try {
+            writeGlobalConfig({ language: wanted }, runtime.env);
+          } catch (error) {
+            notice(t("Could not save the language: {error}", { error: error.message }), "error");
+          }
+          notice(t("Language set to {lang} (saved as default).", { lang: wanted }));
+          return;
+        }
         case "login": {
           const id = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
-          const key = await ask(`API key untuk ${runtime.providerLabel()}`, true);
+          const key = await ask(t("API key for {provider}", { provider: runtime.providerLabel() }), true);
           if (!key) return;
           const result = await runtime.addProviderKey(id, key);
           if (!result.ok) {
@@ -957,10 +1449,10 @@ function App({ runtime, initialPrompt, version }) {
           runtime.setModel(runtime.modelRef);
           const envName = runtime.config.providers[id]?.apiKeyEnv;
           if (envName && runtime.env[envName]) {
-            notice(`Key ${runtime.providerLabel()} tersimpan, tapi ${envName} di environment lebih diutamakan dan tetap dipakai.`, "warn");
+            notice(t("Key for {provider} saved, but {env} in the environment takes precedence and is still used.", { provider: runtime.providerLabel(), env: envName }), "warn");
             return;
           }
-          notice(`Key ${runtime.providerLabel()} tersimpan \xB7 ${result.models} model.`);
+          notice(t("Key for {provider} saved \xB7 {n} models.", { provider: runtime.providerLabel(), n: result.models }));
           return;
         }
         case "logout": {
@@ -969,13 +1461,13 @@ function App({ runtime, initialPrompt, version }) {
           const envName = runtime.config.providers[id]?.apiKeyEnv;
           if (envName && runtime.env[envName]) {
             notice(
-              `${removed ? "Key tersimpan dihapus, tapi" : "Tidak ada key tersimpan;"} ${envName} masih ada di environment dan tetap dipakai.`,
+              removed ? t("Stored key deleted, but {env} is still set in the environment and is still used.", { env: envName }) : t("No stored key; {env} is still set in the environment and is still used.", { env: envName }),
               "warn"
             );
             return;
           }
           if (!removed) {
-            notice(`Tidak ada key tersimpan untuk ${runtime.providerLabel()}.`);
+            notice(t("No stored key for {provider}.", { provider: runtime.providerLabel() }));
             return;
           }
           try {
@@ -986,7 +1478,7 @@ function App({ runtime, initialPrompt, version }) {
             };
             runtime.agent.provider = { chat: fail, listModels: fail };
           }
-          notice(`Key ${runtime.providerLabel()} dihapus. Pakai /login atau /provider untuk menambah lagi.`);
+          notice(t("Key for {provider} deleted. Use /login or /provider to add one again.", { provider: runtime.providerLabel() }));
           return;
         }
         case "diff":
@@ -995,17 +1487,17 @@ function App({ runtime, initialPrompt, version }) {
         case "undo": {
           const result = await runtime.checkpoints.undo();
           if (!result) {
-            notice("Tidak ada edit file yang bisa dibatalkan.");
+            notice(t("No file edits to undo."));
             return;
           }
           const rel = (p) => relative(runtime.cwd, p) || p;
           notice(
             [
-              result.failed.length ? `Gagal dikembalikan: ${result.failed.map(rel).join(", ")}` : "",
-              result.restored.length ? `Dikembalikan: ${result.restored.map(rel).join(", ")}` : "",
-              result.deleted.length ? `Dihapus (file baru): ${result.deleted.map(rel).join(", ")}` : "",
-              result.skipped.length ? `Terlalu besar untuk disimpan, tidak diubah: ${result.skipped.map(rel).join(", ")}` : "",
-              "Catatan: perubahan lewat perintah bash tidak bisa di-undo."
+              result.failed.length ? t("Could not restore: {files}", { files: result.failed.map(rel).join(", ") }) : "",
+              result.restored.length ? t("Restored: {files}", { files: result.restored.map(rel).join(", ") }) : "",
+              result.deleted.length ? t("Deleted (new files): {files}", { files: result.deleted.map(rel).join(", ") }) : "",
+              result.skipped.length ? t("Too large to back up, left unchanged: {files}", { files: result.skipped.map(rel).join(", ") }) : "",
+              t("Note: changes made through bash commands cannot be undone.")
             ].filter(Boolean).join("\n")
           );
           return;
@@ -1013,33 +1505,33 @@ function App({ runtime, initialPrompt, version }) {
         case "copy": {
           const last = runtime.agent.messages.findLast((m) => m.role === "assistant" && typeof m.content === "string" && m.content.trim());
           if (!last || typeof last.content !== "string") {
-            notice("Belum ada jawaban untuk disalin.");
+            notice(t("No answer to copy yet."));
             return;
           }
           process.stdout.write(osc52(last.content, !!process.env.TMUX));
           const file = join(runtime.home, "last-answer.md");
           mkdirSync(runtime.home, { recursive: true });
           writeFileSync(file, last.content);
-          notice(`Disalin ke clipboard (bila terminal mendukung OSC 52) dan disimpan di ${file}.`);
+          notice(t("Copied to the clipboard (if the terminal supports OSC 52) and saved to {file}.", { file }));
           return;
         }
         case "export": {
           const name2 = args || `bccli-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace(/[:T]/g, "-")}.md`;
           const file = resolve(runtime.cwd, name2);
           if (existsSync2(file)) {
-            const answer2 = await ask(`${file} sudah ada. Timpa? (y/N)`);
+            const answer2 = await ask(t("{file} already exists. Overwrite? (y/N)", { file }));
             if (!answer2 || !/^y(a|es)?$/i.test(answer2.trim())) {
-              notice("Ekspor dibatalkan.");
+              notice(t("Export cancelled."));
               return;
             }
           }
           try {
-            writeFileSync(file, exportMarkdown(runtime.agent.messages, `Sesi BCCLI ${runtime.startedAt.toLocaleString("id-ID")}`));
+            writeFileSync(file, exportMarkdown(runtime.agent.messages, t("BCCLI session {when}", { when: runtime.startedAt.toLocaleString(locale()) })));
           } catch (error) {
-            notice(`Gagal menulis ${file}: ${error.message}`, "error");
+            notice(t("Could not write {file}: {error}", { file, error: error.message }), "error");
             return;
           }
-          notice(`Percakapan disimpan di ${file}.`);
+          notice(t("Conversation saved to {file}.", { file }));
           return;
         }
         case "provider": {
@@ -1050,7 +1542,7 @@ function App({ runtime, initialPrompt, version }) {
           return;
         }
         default:
-          notice(`Perintah tidak dikenal: /${name}. Ketik /help.`, "warn");
+          notice(t("Unknown command: /{name}. Type /help.", { name }), "warn");
       }
     },
     [runtime, notice, exit, version, runTurn, ask]
@@ -1076,7 +1568,7 @@ function App({ runtime, initialPrompt, version }) {
         try {
           body = parseFrontmatter(readFileSync2(skill.file, "utf8")).body;
         } catch (error) {
-          notice(`Skill ${skill.name} tidak bisa dibaca: ${error.code ?? error.message}`, "error");
+          notice(t("Skill {name} cannot be read: {error}", { name: skill.name, error: error.code ?? error.message }), "error");
           return;
         }
         void runTurn(`${body}
@@ -1086,6 +1578,19 @@ ARGUMENTS: ${slash.args}`);
     },
     [runSlash, runTurn, runtime, notice]
   );
+  const onPrompt = useCallback(
+    (text) => {
+      if (busy) setQueued((q) => [...q, text]);
+      else submit(text);
+    },
+    [busy, submit]
+  );
+  useEffect2(() => {
+    if (busy || pending || planAsk || !queued.length) return;
+    const [next, ...rest] = queued;
+    setQueued(rest);
+    submit(next);
+  }, [busy, pending, planAsk, queued, submit]);
   const initialSent = useRef(false);
   useEffect2(() => {
     if (initialPrompt && !initialSent.current) {
@@ -1100,10 +1605,30 @@ ARGUMENTS: ${slash.args}`);
       setMode(next);
     } else if (key.escape && busy && !pending) {
       controller.current?.abort();
+      if (queued.length) {
+        setQueued([]);
+        notice(t("{n} queued messages cancelled.", { n: queued.length }), "warn");
+      }
+    } else if (key.ctrl && input === "t") {
+      const next = !showThinking;
+      const toggled = next ? t("Thinking shown (ctrl+t to hide).") : t("Thinking hidden (ctrl+t to show).");
+      setShowThinking(next);
+      setTranscript((t2) => {
+        const last = [...t2.done, ...t2.live].findLast((e) => e.kind === "thinking");
+        const reprint = next && last?.kind === "thinking" && t2.done.includes(last);
+        return {
+          ...t2,
+          done: [
+            ...t2.done,
+            ...reprint ? [entry({ kind: "thinking", text: last.text, open: true })] : [],
+            entry({ kind: "notice", text: toggled, tone: "info" })
+          ]
+        };
+      });
     } else if (key.ctrl && input === "o" && lastTool.current) {
-      const t = lastTool.current;
-      notice(`\u23BF ${t.tool} ${t.target}
-${t.output}`);
+      const t2 = lastTool.current;
+      notice(`\u23BF ${t2.tool} ${t2.target}
+${t2.output}`);
     }
   });
   const pickMcp = async (name) => {
@@ -1113,24 +1638,24 @@ ${t.output}`);
     if (item.installed) {
       removeGlobalServer(runtime.home, item.name);
       await runtime.mcp.remove(item.name);
-      notice(`MCP ${item.name} dihapus.`);
+      notice(t("MCP {name} removed.", { name: item.name }));
       return;
     }
     const entry2 = CATALOG.find((c) => c.name === item.name);
     if (!entry2) return;
     const values = {};
     for (const input of entry2.inputs ?? []) {
-      const v = await ask(input.label, !!input.secret);
+      const v = await ask(t(input.label), !!input.secret);
       if (!v) return;
       values[input.key] = v;
     }
     const config = fillTemplate(entry2.config, values);
     addGlobalServer(runtime.home, entry2.name, config);
-    notice(`MCP ${entry2.name} dipasang, menghubungkan\u2026`);
+    notice(t("MCP {name} installed, connecting\u2026", { name: entry2.name }));
     await runtime.mcp.add({ name: entry2.name, config, source: "global" });
     const state = runtime.mcp.states().find((s) => s.name === entry2.name);
-    if (state?.status === "ready") notice(`MCP ${entry2.name} aktif \xB7 ${state.tools} alat.`);
-    else notice(`MCP ${entry2.name} gagal: ${state?.error ?? "tidak diketahui"}`, "error");
+    if (state?.status === "ready") notice(t("MCP {name} active \xB7 {n} tools.", { name: entry2.name, n: state.tools }));
+    else notice(t("MCP {name} failed: {error}", { name: entry2.name, error: state?.error ?? t("unknown") }), "error");
   };
   const pickProvider = async (id) => {
     setProviderMenu(null);
@@ -1147,7 +1672,7 @@ ${t.output}`);
     const c = runtime.config;
     const keyless = !c.providers[target].apiKeyEnv && PRESETS.some((p) => p.id === target);
     if (!hasKey(c, target, runtime.env) || id === "custom") {
-      const key = keyless ? "" : await ask(`API key untuk ${providerName(c, target)}`, true);
+      const key = keyless ? "" : await ask(t("API key for {provider}", { provider: providerName(c, target) }), true);
       if (key === void 0) return;
       const result = await runtime.addProviderKey(target, key);
       if (!result.ok) {
@@ -1167,7 +1692,7 @@ ${t.output}`);
   const renderEntry = (e) => {
     switch (e.kind) {
       case "header":
-        return /* @__PURE__ */ jsx15(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsxs10(Text15, { children: [
+        return /* @__PURE__ */ jsx15(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Text15, { children: [
           /* @__PURE__ */ jsx15(Text15, { color: color(ACCENT), bold: true, children: " \u273B " }),
           /* @__PURE__ */ jsx15(Text15, { bold: true, children: `BCCLI ${version}` }),
           /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: ` \xB7 ${runtime.modelRef} (${runtime.providerLabel()}) \xB7 ${cwd}` })
@@ -1175,21 +1700,36 @@ ${t.output}`);
       case "user":
         return /* @__PURE__ */ jsx15(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: `> ${e.text}` }) }, e.id);
       case "assistant":
+        if (e.cont) {
+          return e.text ? /* @__PURE__ */ jsx15(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsx15(Markdown, { text: e.text }) }, e.id) : null;
+        }
         if (!e.text.trim()) return null;
-        return /* @__PURE__ */ jsxs10(Box13, { marginTop: 1, children: [
+        return /* @__PURE__ */ jsxs11(Box13, { marginTop: 1, children: [
           /* @__PURE__ */ jsx15(Text15, { color: color(ACCENT), children: "\u25CF " }),
           /* @__PURE__ */ jsx15(Markdown, { text: e.text.replace(/^\s+/, "") })
         ] }, e.id);
+      case "thinking": {
+        const text = e.text.trim();
+        if (!text) return null;
+        if (!(e.open ?? showThinking)) {
+          const lines = text.split("\n").length;
+          return /* @__PURE__ */ jsx15(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u273B Thinking \xB7 {n} lines \xB7 ctrl+t to show", { n: lines }) }) }, e.id);
+        }
+        return /* @__PURE__ */ jsxs11(Box13, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u273B Thinking (ctrl+t to hide)") }),
+          /* @__PURE__ */ jsx15(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, italic: true, children: text }) })
+        ] }, e.id);
+      }
       case "tool":
         return /* @__PURE__ */ jsx15(ToolBlock, { tool: e.tool, target: e.target, output: e.output, display: e.display, isError: e.isError, done: e.done, sub: e.sub }, e.id);
       case "notice":
         return /* @__PURE__ */ jsx15(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { color: e.tone === "error" ? color("red") : e.tone === "warn" ? color("yellow") : void 0, dimColor: e.tone === "info", children: e.text }) }, e.id);
     }
   };
-  return /* @__PURE__ */ jsxs10(Box13, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs11(Box13, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx15(Static, { items: transcript.done, children: renderEntry }),
     transcript.live.map(renderEntry),
-    busy && !pending && !planAsk ? /* @__PURE__ */ jsx15(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx15(Spinner, { label: "Berpikir", startedAt }) }) : null,
+    busy && !pending && !planAsk ? /* @__PURE__ */ jsx15(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx15(Spinner, { label: t("Thinking"), startedAt }) }) : null,
     pending ? /* @__PURE__ */ jsx15(PermissionPrompt, { request: pending.request, onAnswer: answer }, pending.id) : null,
     picker ? /* @__PURE__ */ jsx15(
       ModelPicker,
@@ -1232,8 +1772,9 @@ ${t.output}`);
       }
     ) : null,
     /* @__PURE__ */ jsx15(TodoList, { items: todos }),
-    /* @__PURE__ */ jsx15(PromptInput, { disabled: busy || !!pending || !!picker || !!providerMenu || !!prompt || !!planAsk || !!mcpMenu || !!listPicker, history, cwd: runtime.cwd, onSubmit: submit, extraCommands }),
-    /* @__PURE__ */ jsx15(StatusBar, { mode, tokens, busy, model: modelLabel })
+    queued.map((q, i) => /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("  \u23F3 queued: {q}", { q }) }, `${i}-${q}`)),
+    /* @__PURE__ */ jsx15(PromptInput, { disabled: !!pending || !!picker || !!providerMenu || !!prompt || !!planAsk || !!mcpMenu || !!listPicker, history, cwd: runtime.cwd, onSubmit: onPrompt, extraCommands }),
+    /* @__PURE__ */ jsx15(StatusBar, { mode, tokens, busy, model: modelLabel, reasoning })
   ] });
 }
 
@@ -1243,27 +1784,27 @@ async function startInteractive(rt, opts) {
   if (opts.resume) {
     const { Session: Session2 } = await import("./session-7UB77CEG.js");
     const list = Session2.list(rt.home, rt.cwd).slice(0, 20);
-    if (!list.length) console.log("Belum ada sesi di folder ini; memulai sesi baru.");
+    if (!list.length) console.log(t("No sessions in this folder yet; starting a new one."));
     else {
       list.forEach((s, i) => {
-        console.log(`${String(i + 1).padStart(2)}. ${s.mtime.toLocaleString("id-ID")}  ${s.preview}`);
+        console.log(`${String(i + 1).padStart(2)}. ${s.mtime.toLocaleString(locale())}  ${s.preview}`);
       });
       const { createInterface } = await import("readline/promises");
       const rl = createInterface({ input: process.stdin, output: process.stdout });
-      const answer = Number(await rl.question("Nomor sesi (enter = baru): "));
+      const answer = Number(await rl.question(t("Session number (enter = new): ")));
       rl.close();
       const chosen = list[answer - 1];
       if (chosen) rt.resume(chosen.session);
     }
   }
-  const { serversToStart, setProjectTrust } = await import("./config-NPSYFAFD.js");
+  const { serversToStart, setProjectTrust } = await import("./config-PBEZ3IGD.js");
   const plan = serversToStart(rt.home, rt.cwd);
   if (plan.needTrust.length) {
     const { createInterface } = await import("readline/promises");
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     for (const s of plan.needTrust) {
       const what = s.config.type === "http" ? s.config.url : [s.config.command, ...s.config.args ?? []].join(" ");
-      const answer = (await rl.question(`Repo ini ingin menjalankan server MCP "${s.name}" (${what}). Izinkan? [y/N] `)).trim().toLowerCase();
+      const answer = (await rl.question(t('This repo wants to run the MCP server "{name}" ({what}). Allow? [y/N] ', { name: s.name, what }))).trim().toLowerCase();
       setProjectTrust(rt.home, rt.cwd, s.name, answer === "y", s.config);
       if (answer === "y") plan.start.push(s);
     }