@botconnector/bccli 0.4.0-beta.44 → 0.4.0-beta.46

package/dist/statsCli-G7GYLCPM.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+import {
+  estimateTokens
+} from "./chunk-QZKLZELZ.js";
+import {
+  t
+} from "./chunk-GI5GVU2L.js";
+
+// src/statsCli.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+function isUsageRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.t === "usage" && typeof v.inputTokens === "number" && typeof v.outputTokens === "number";
+}
+function isMsgRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.t === "msg" && !!v.m;
+}
+function emptyRow(project) {
+  return {
+    project,
+    sessions: 0,
+    messages: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    usageInputTokens: 0,
+    usageOutputTokens: 0,
+    cachedInputTokens: 0,
+    cacheWriteTokens: 0,
+    toolCalls: {},
+    sessionTotals: [],
+    modelUsage: {}
+  };
+}
+function aggregateSessions(home, opts) {
+  const now = opts.now ?? Date.now();
+  const cutoff = now - opts.days * 864e5;
+  const root = join(home, "sessions");
+  if (!existsSync(root)) return [];
+  const byProject = /* @__PURE__ */ new Map();
+  for (const project of readdirSync(root)) {
+    const dir = join(root, project);
+    let st;
+    try {
+      st = statSync(dir);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+    for (const file of readdirSync(dir)) {
+      if (!file.endsWith(".jsonl")) continue;
+      const path = join(dir, file);
+      let fst;
+      try {
+        fst = statSync(path);
+      } catch {
+        continue;
+      }
+      if (fst.mtimeMs < cutoff) continue;
+      let row = byProject.get(project);
+      if (!row) {
+        row = emptyRow(project);
+        byProject.set(project, row);
+      }
+      row.sessions++;
+      let usageIn = 0;
+      let usageOut = 0;
+      let cachedIn = 0;
+      let cacheWrite = 0;
+      let usageCount = 0;
+      let estIn = 0;
+      let estOut = 0;
+      let messages = 0;
+      const tools = {};
+      for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim()) continue;
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (isUsageRecord(record)) {
+          usageIn += record.inputTokens;
+          usageOut += record.outputTokens;
+          cachedIn += record.cachedInputTokens ?? 0;
+          cacheWrite += record.cacheWriteTokens ?? 0;
+          usageCount++;
+          if (record.model) {
+            let mt = row.modelUsage[record.model];
+            if (!mt) {
+              mt = { turns: 0, inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cacheWriteTokens: 0 };
+              row.modelUsage[record.model] = mt;
+            }
+            mt.turns++;
+            mt.inputTokens += record.inputTokens;
+            mt.outputTokens += record.outputTokens;
+            mt.cachedInputTokens += record.cachedInputTokens ?? 0;
+            mt.cacheWriteTokens += record.cacheWriteTokens ?? 0;
+          }
+          continue;
+        }
+        if (!isMsgRecord(record)) continue;
+        messages++;
+        if (record.m.role === "user" || record.m.role === "assistant") {
+          const text = typeof record.m.content === "string" ? record.m.content : JSON.stringify(record.m.content ?? "");
+          const tokens = estimateTokens(text);
+          if (record.m.role === "user") estIn += tokens;
+          else estOut += tokens;
+        }
+        if (record.m.role === "assistant") {
+          for (const call of record.m.tool_calls ?? []) {
+            const name = call?.function?.name;
+            if (typeof name === "string" && name) tools[name] = (tools[name] ?? 0) + 1;
+          }
+        }
+      }
+      row.messages += messages;
+      if (usageCount > 0) {
+        row.usageInputTokens += usageIn;
+        row.usageOutputTokens += usageOut;
+        row.cachedInputTokens += cachedIn;
+        row.cacheWriteTokens += cacheWrite;
+        row.sessionTotals.push(usageIn + usageOut + cachedIn + cacheWrite);
+      } else {
+        row.inputTokens += estIn;
+        row.outputTokens += estOut;
+        row.sessionTotals.push(estIn + estOut);
+      }
+      for (const [name, count] of Object.entries(tools)) row.toolCalls[name] = (row.toolCalls[name] ?? 0) + count;
+    }
+  }
+  return [...byProject.values()].sort((a, b) => b.messages - a.messages || a.project.localeCompare(b.project));
+}
+function fmtCompact(n) {
+  if (n < 1e3) return String(Math.round(n));
+  const units = [
+    [1e9, "B"],
+    [1e6, "M"],
+    [1e3, "K"]
+  ];
+  for (const [size, suffix] of units) {
+    if (n >= size) return `${(n / size).toFixed(1)}${suffix}`;
+  }
+  return String(Math.round(n));
+}
+function fmtCount(n) {
+  return n.toLocaleString("en-US");
+}
+function median(values) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+var BOX_INNER = 46;
+function border(left, right) {
+  return `${left}${"\u2500".repeat(BOX_INNER + 2)}${right}`;
+}
+function center(text) {
+  const pad = Math.max(0, BOX_INNER - text.length);
+  const left = Math.floor(pad / 2);
+  return `\u2502${" ".repeat(left)}${text}${" ".repeat(pad - left)}\u2502`;
+}
+function contentLine(content) {
+  return `\u2502${content}${" ".repeat(Math.max(1, BOX_INNER + 1 - content.length))}\u2502`;
+}
+function valueLine(label, value) {
+  return contentLine(` ${label}${" ".repeat(Math.max(1, BOX_INNER - 1 - label.length - value.length))}${value}`);
+}
+function box(title, rows) {
+  return [border("\u250C", "\u2510"), center(title), border("\u251C", "\u2524"), ...rows.map(([l, v]) => valueLine(l, v)), border("\u2514", "\u2518")];
+}
+function truncateName(name) {
+  return name.length > 18 ? `${name.slice(0, 16)}..` : name;
+}
+function toolBox(tools) {
+  const total = tools.reduce((sum, [, n]) => sum + n, 0);
+  const max = tools[0]?.[1] ?? 1;
+  const lines = tools.map(([name, count]) => {
+    const blocks = Math.max(1, Math.round(count / max * 20));
+    const pct = (count / total * 100).toFixed(1).padStart(5);
+    return contentLine(` ${truncateName(name).padEnd(16)} ${"\u2588".repeat(blocks).padEnd(20)} ${count} (${pct}%)`);
+  });
+  return [border("\u250C", "\u2510"), center("TOOL USAGE"), border("\u251C", "\u2524"), ...lines, border("\u2514", "\u2518")];
+}
+function modelBox(models) {
+  const lines = [];
+  for (let i = 0; i < models.length; i++) {
+    const [name, m] = models[i];
+    if (i > 0) lines.push(border("\u251C", "\u2524"));
+    lines.push(contentLine(` ${truncateName(name)}`));
+    lines.push(valueLine(" Turns", fmtCount(m.turns)));
+    lines.push(valueLine(" Input Tokens", fmtCompact(m.inputTokens)));
+    lines.push(valueLine(" Output Tokens", fmtCompact(m.outputTokens)));
+    lines.push(valueLine(" Cache Read", fmtCompact(m.cachedInputTokens)));
+    lines.push(valueLine(" Cache Write", fmtCompact(m.cacheWriteTokens)));
+  }
+  return [border("\u250C", "\u2510"), center("MODEL USAGE"), border("\u251C", "\u2524"), ...lines, border("\u2514", "\u2518")];
+}
+function projectSlug(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
+}
+function runStatsCommand(args, deps) {
+  let days = args.days ?? 7;
+  let toolsCap = args.tools;
+  let modelsFlag = args.models;
+  let projectFilter = args.project;
+  const rest = args.subArgs;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--days" || a === "--tools" || a === "--models" || a === "--project") {
+      const raw = rest[++i] ?? "";
+      if (a === "--days") {
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1) {
+          deps.err?.(t("--days must be a positive integer"));
+          return 1;
+        }
+        days = n;
+      } else if (a === "--tools") {
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1) {
+          deps.err?.(t("--tools must be a positive integer"));
+          return 1;
+        }
+        toolsCap = n;
+      } else if (a === "--models") {
+        if (raw === "" || raw === "all" || raw.startsWith("-")) {
+          modelsFlag = "all";
+          if (raw.startsWith("-")) i--;
+        } else {
+          const n = Number(raw);
+          if (!Number.isInteger(n) || n < 1) {
+            deps.err?.(t('--models must be a positive integer or "all"'));
+            return 1;
+          }
+          modelsFlag = raw;
+        }
+      } else {
+        projectFilter = raw;
+      }
+    } else if (a.startsWith("--days=")) {
+      const n = Number(a.slice("--days=".length));
+      if (!Number.isInteger(n) || n < 1) {
+        deps.err?.(t("--days must be a positive integer"));
+        return 1;
+      }
+      days = n;
+    } else if (a.startsWith("--tools=")) {
+      const n = Number(a.slice("--tools=".length));
+      if (!Number.isInteger(n) || n < 1) {
+        deps.err?.(t("--tools must be a positive integer"));
+        return 1;
+      }
+      toolsCap = n;
+    } else if (a.startsWith("--models=")) {
+      const raw = a.slice("--models=".length);
+      if (raw === "" || raw === "all") {
+        modelsFlag = "all";
+      } else {
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1) {
+          deps.err?.(t('--models must be a positive integer or "all"'));
+          return 1;
+        }
+        modelsFlag = raw;
+      }
+    } else if (a.startsWith("--project=")) {
+      projectFilter = a.slice("--project=".length);
+    }
+  }
+  let rows = aggregateSessions(args.home, { days, now: args.now });
+  if (projectFilter !== void 0) {
+    const needle = projectFilter === "" ? projectSlug(args.cwd ?? "") : projectFilter;
+    rows = rows.filter((r) => r.project.includes(needle));
+  }
+  if (!rows.length) {
+    deps.out(t("no sessions in the last {days} day(s)", { days: String(days) }));
+    return 0;
+  }
+  const sessions = rows.reduce((s, r) => s + r.sessions, 0);
+  const messages = rows.reduce((s, r) => s + r.messages, 0);
+  const input = rows.reduce((s, r) => s + r.inputTokens + r.usageInputTokens, 0);
+  const output = rows.reduce((s, r) => s + r.outputTokens + r.usageOutputTokens, 0);
+  const cachedIn = rows.reduce((s, r) => s + r.cachedInputTokens, 0);
+  const cacheWrite = rows.reduce((s, r) => s + r.cacheWriteTokens, 0);
+  const totals = rows.flatMap((r) => r.sessionTotals);
+  const avg = totals.length ? totals.reduce((s, n) => s + n, 0) / totals.length : 0;
+  const tools = {};
+  for (const r of rows) for (const [name, count] of Object.entries(r.toolCalls)) tools[name] = (tools[name] ?? 0) + count;
+  const modelUsage = {};
+  for (const r of rows) {
+    for (const [name, m] of Object.entries(r.modelUsage)) {
+      let mt = modelUsage[name];
+      if (!mt) {
+        mt = { turns: 0, inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cacheWriteTokens: 0 };
+        modelUsage[name] = mt;
+      }
+      mt.turns += m.turns;
+      mt.inputTokens += m.inputTokens;
+      mt.outputTokens += m.outputTokens;
+      mt.cachedInputTokens += m.cachedInputTokens;
+      mt.cacheWriteTokens += m.cacheWriteTokens;
+    }
+  }
+  for (const line of box("OVERVIEW", [
+    ["Sessions", fmtCount(sessions)],
+    ["Messages", fmtCount(messages)],
+    ["Days", String(days)]
+  ])) deps.out(line);
+  deps.out("");
+  for (const line of box("TOKENS", [
+    ["Input", fmtCompact(input)],
+    ["Output", fmtCompact(output)],
+    ["Cache Read", fmtCompact(cachedIn)],
+    ["Cache Write", fmtCompact(cacheWrite)],
+    ["Avg Tokens/Session", fmtCompact(avg)],
+    ["Median Tokens/Session", fmtCompact(median(totals))]
+  ])) deps.out(line);
+  if (modelsFlag !== void 0) {
+    let modelEntries = Object.entries(modelUsage).sort(
+      (a, b) => b[1].inputTokens + b[1].outputTokens - (a[1].inputTokens + a[1].outputTokens) || a[0].localeCompare(b[0])
+    );
+    if (modelsFlag !== "all") modelEntries = modelEntries.slice(0, Number(modelsFlag));
+    if (modelEntries.length) {
+      deps.out("");
+      for (const line of modelBox(modelEntries)) deps.out(line);
+    }
+  }
+  let toolEntries = Object.entries(tools).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  if (toolsCap !== void 0) toolEntries = toolEntries.slice(0, toolsCap);
+  if (toolEntries.length) {
+    deps.out("");
+    for (const line of toolBox(toolEntries)) deps.out(line);
+  }
+  deps.out("");
+  deps.out(t("sessions (last {days} day(s)):", { days: String(days) }));
+  for (const r of rows) {
+    const inputTotal = r.inputTokens + r.usageInputTokens;
+    const outputTotal = r.outputTokens + r.usageOutputTokens;
+    deps.out(`${r.project}  ${r.sessions} ${t("session(s)")}  ${r.messages} ${t("message(s)")}  ${fmtCompact(inputTotal)}in/${fmtCompact(outputTotal)}out`);
+  }
+  return 0;
+}
+export {
+  aggregateSessions,
+  fmtCompact,
+  runStatsCommand
+};

package/dist/{transferCli-RQBB6RVY.js → transferCli-7FW2SJY4.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   Session
-} from "./chunk-BQHKN7JI.js";
-import "./chunk-RMDW3OQ6.js";
-import "./chunk-ZKMSTD6G.js";
+} from "./chunk-IA5PRX4Z.js";
+import "./chunk-ASJRO2WF.js";
+import "./chunk-FIY424O5.js";
 import {
   t
-} from "./chunk-QHNWI3OT.js";
+} from "./chunk-GI5GVU2L.js";
 
 // src/transferCli.ts
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";

package/dist/{ui-4ZTUMTYM.js → ui-KHNDA2RT.js}

@@ -2,14 +2,14 @@
 import {
   CATALOG,
   fillTemplate
-} from "./chunk-I7GXIJCY.js";
+} from "./chunk-K3SWFB5S.js";
 import {
   MAX_VERIFY_ROUNDS,
   runVerify,
   toolLabel,
   verifyFollowup,
   worktreeListText
-} from "./chunk-TW5HZOTB.js";
+} from "./chunk-33OBF43H.js";
 import {
   BUILTIN_AGENTS,
   appendMemory,
@@ -21,7 +21,7 @@ import {
   renderBackgroundTasks,
   runHooks,
   validateGlobPattern
-} from "./chunk-PSRNKKGA.js";
+} from "./chunk-7PRH5NDO.js";
 import "./chunk-PSO7R5AD.js";
 import {
   nextMode
@@ -30,39 +30,39 @@ import {
   hasKey,
   providerName,
   writeGlobalConfig
-} from "./chunk-VO6MF6JJ.js";
+} from "./chunk-65OGHOGS.js";
 import {
   Session
-} from "./chunk-BQHKN7JI.js";
+} from "./chunk-IA5PRX4Z.js";
 import {
   contentText
-} from "./chunk-RMDW3OQ6.js";
+} from "./chunk-ASJRO2WF.js";
 import {
   REASONING_LEVELS,
   assertReasoningSupported,
   parseReasoningLevel,
   supportedReasoningLevels
-} from "./chunk-ZKMSTD6G.js";
+} from "./chunk-FIY424O5.js";
 import {
   addGlobalServer,
   globalMcpPath,
   readMcpFile,
   removeGlobalServer
-} from "./chunk-PZC2Q6MJ.js";
+} from "./chunk-PQB4CGSL.js";
 import {
   ACCENT,
   PRESETS,
   color,
   matchKeybind,
   removeCredential
-} from "./chunk-GIGWZFCY.js";
+} from "./chunk-NGHOZRIM.js";
 import {
   getLanguage,
   locale,
   parseLang,
   setLanguage,
   t
-} from "./chunk-QHNWI3OT.js";
+} from "./chunk-GI5GVU2L.js";
 
 // src/ui/index.tsx
 import { render } from "ink";
@@ -72,7 +72,7 @@ import { execFile as execFile3 } from "child_process";
 import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir, tmpdir } from "os";
 import { dirname, join as join3, relative, resolve } from "path";
-import { Box as Box13, Static, Text as Text16, useApp, useInput as useInput9 } from "ink";
+import { Box as Box13, Static, Text as Text16, measureElement, useApp, useInput as useInput9, useStdin, useStdout as useStdout2 } from "ink";
 import { useCallback, useEffect as useEffect3, useRef, useState as useState8 } from "react";
 
 // src/commands.ts
@@ -782,11 +782,46 @@ function EditableText({ state, mask = false, showCursor = true }) {
 // src/ui/focusReport.ts
 var isFocusReport = (input) => input === "[I" || input === "[O";
 
+// src/ui/thinkingMouse.ts
+function parseMousePress(value) {
+  const start = value.indexOf("\x1B[<");
+  if (start < 0) return void 0;
+  const match = /^<(\d+);(\d+);(\d+)M/.exec(value.slice(start + 2));
+  if (!match) return void 0;
+  const button = Number(match[1]);
+  if (button !== 0) return void 0;
+  const x = Number(match[2]);
+  const y = Number(match[3]);
+  if (x < 1 || y < 1) return void 0;
+  return { x, y };
+}
+function parseCursorPosition(value) {
+  const start = value.indexOf("\x1B[");
+  if (start < 0) return void 0;
+  const match = /^(\d+);(\d+)R/.exec(value.slice(start + 2));
+  if (!match) return void 0;
+  const row = Number(match[1]);
+  const col = Number(match[2]);
+  if (row < 1 || col < 1) return void 0;
+  return { row, col };
+}
+function clickedThinking(click, cursorRow, rootHeight, target) {
+  if (!rootHeight || !target.width || !target.height) return false;
+  const origin = cursorRow - rootHeight + 1;
+  const row = origin + target.y;
+  const col = target.x + 1;
+  return click.y >= row && click.y < row + target.height && click.x >= col && click.x < col + Math.min(target.width, 46);
+}
+function isMouseControlInput(input) {
+  return /^\[<(?:\d+;){2}\d+[mM]$/.test(input) || /^\[(?:\d+;)\d+R$/.test(input);
+}
+
 // src/ui/LinePrompt.tsx
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function LinePrompt({ label, mask, onSubmit, onCancel }) {
   const [line, setLine] = useState({ value: "", cursor: 0 });
   useInput((input, key) => {
+    if (isMouseControlInput(input)) return;
     if (key.return) onSubmit(line.value.trim());
     else if (key.escape) onCancel();
     else if (applyEditKey(line, input, key)) setLine((current) => applyEditKey(current, input, key) ?? current);
@@ -1080,6 +1115,7 @@ function PromptInput({ disabled, history, cwd, onSubmit, extraCommands, injected
   };
   useInput6(
     (input, key) => {
+      if (isMouseControlInput(input)) return;
       if (suggestions.length) {
         if (key.upArrow) {
           setSelected(Math.max(0, highlighted - 1));
@@ -1494,7 +1530,11 @@ function App({ runtime, initialPrompt, version }) {
   const [listPicker, setListPicker] = useState8(null);
   const [planAsk, setPlanAsk] = useState8(null);
   const [queued, setQueued] = useState8([]);
-  const [showThinking, setShowThinking] = useState8(false);
+  const [showThinking, setShowThinking] = useState8(runtime.config.thinkingVisible === true);
+  const { stdin } = useStdin();
+  const { stdout } = useStdout2();
+  const liveRootRef = useRef(null);
+  const thinkingTargetRef = useRef(null);
   const [injected, setInjected] = useState8();
   useEffect3(() => runtime.todos.subscribe(setTodos), [runtime]);
   const extraCommands = [
@@ -2043,6 +2083,55 @@ ARGUMENTS: ${slash.args}`);
       submit(initialPrompt);
     }
   }, [initialPrompt, submit]);
+  const toggleThinking = useCallback(() => {
+    const bind = runtime.config.keybinds.thinking.spec;
+    const next = !showThinking;
+    const toggled = next ? t("Thinking shown ({bind} to hide).", { bind }) : t("Thinking hidden ({bind} to show).", { bind });
+    setShowThinking(next);
+    try {
+      writeGlobalConfig({ thinkingVisible: next }, runtime.env);
+    } catch (error) {
+      notice(t("Could not save thinking visibility: {error}", { error: error.message }), "warn");
+    }
+    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" })
+        ]
+      };
+    });
+  }, [runtime, showThinking, notice]);
+  useEffect3(() => {
+    if (!busy || pending || !stdin.isTTY || !stdout.isTTY || !thinkingTargetRef.current) return;
+    let click;
+    const onData = (data) => {
+      const value = String(data);
+      const press = parseMousePress(value);
+      if (press) {
+        click = press;
+        stdout.write("\x1B[6n");
+        return;
+      }
+      const cursor = parseCursorPosition(value);
+      if (!cursor || !click || !liveRootRef.current || !thinkingTargetRef.current) return;
+      const current = click;
+      click = void 0;
+      const root = measureElement(liveRootRef.current);
+      const target = measureElement(thinkingTargetRef.current);
+      if (clickedThinking(current, cursor.row, root.height, target)) toggleThinking();
+    };
+    stdin.on("data", onData);
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    return () => {
+      stdin.off("data", onData);
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+    };
+  }, [busy, pending, stdin, stdout, toggleThinking]);
   useInput9((input, key) => {
     if (key.tab && key.shift) {
       const next = nextMode(runtime.agent.permissions.mode);
@@ -2066,22 +2155,7 @@ ARGUMENTS: ${slash.args}`);
         }
       })();
     } else if (matchKeybind(runtime.config.keybinds.thinking, input, key)) {
-      const bind = runtime.config.keybinds.thinking.spec;
-      const next = !showThinking;
-      const toggled = next ? t("Thinking shown ({bind} to hide).", { bind }) : t("Thinking hidden ({bind} to show).", { bind });
-      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" })
-          ]
-        };
-      });
+      toggleThinking();
     } else if (matchKeybind(runtime.config.keybinds.toolOutput, input, key) && lastTool.current) {
       const t2 = lastTool.current;
       notice(`\u23BF ${t2.tool} ${t2.target}
@@ -2183,10 +2257,24 @@ ${t2.output}`);
         return /* @__PURE__ */ jsx16(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { color: e.tone === "error" ? color("red") : e.tone === "warn" ? color("yellow") : void 0, dimColor: e.tone === "info", children: e.text }) }, e.id);
     }
   };
-  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs12(Box13, { ref: liveRootRef, flexDirection: "column", children: [
     /* @__PURE__ */ jsx16(Static, { items: transcript.done, children: renderEntry }),
     transcript.live.map(renderEntry),
-    busy && !pending && !planAsk ? /* @__PURE__ */ jsx16(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx16(Spinner, { label: cancelling ? t("Cancelling") : t("Thinking"), startedAt }) }) : null,
+    busy && !pending && !planAsk ? /* @__PURE__ */ jsxs12(Box13, { ref: thinkingTargetRef, marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs12(Box13, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx16(Spinner, { label: cancelling ? t("Cancelling") : t("Thinking"), startedAt }),
+        /* @__PURE__ */ jsxs12(Text16, { dimColor: true, children: [
+          " \xB7 ",
+          runtime.config.keybinds.thinking.spec,
+          " \xB7 ",
+          t("click to toggle")
+        ] })
+      ] }),
+      showThinking ? /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingLeft: 2, children: [
+        /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("Model: {model} \xB7 reasoning: {level}", { model: runtime.modelRef, level: reasoning }) }),
+        ![...transcript.done, ...transcript.live].some((e) => e.kind === "thinking" && !!e.text.trim()) ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("No reasoning summary received yet; tool activity remains visible above.") }) : null
+      ] }) : null
+    ] }) : null,
     pending ? /* @__PURE__ */ jsx16(PermissionPrompt, { request: pending.request, onAnswer: answer }, pending.id) : null,
     picker ? /* @__PURE__ */ jsx16(
       ModelPicker,
@@ -2239,7 +2327,7 @@ ${t2.output}`);
 import { jsx as jsx17 } from "react/jsx-runtime";
 async function startInteractive(rt, opts) {
   if (opts.resume) {
-    const { Session: Session2 } = await import("./session-KRV2UP5C.js");
+    const { Session: Session2 } = await import("./session-QIZKAZK3.js");
     const list = Session2.list(rt.home, rt.cwd).slice(0, 20);
     if (!list.length) console.log(t("No sessions in this folder yet; starting a new one."));
     else {
@@ -2254,7 +2342,7 @@ async function startInteractive(rt, opts) {
       if (chosen) rt.resume(chosen.session);
     }
   }
-  const { serversToStart, setProjectTrust } = await import("./config-Z4HSA435.js");
+  const { serversToStart, setProjectTrust } = await import("./config-BAAESXVB.js");
   const plan = serversToStart(rt.home, rt.cwd);
   if (plan.needTrust.length) {
     const { createInterface } = await import("readline/promises");

package/dist/{update-34FDI6H3.js → update-UG7GWBXT.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   VERSION
-} from "./chunk-LTAQXU5Z.js";
+} from "./chunk-IHYNME3G.js";
 import {
   t
-} from "./chunk-QHNWI3OT.js";
+} from "./chunk-GI5GVU2L.js";
 
 // src/update.ts
 import { spawnSync } from "child_process";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botconnector/bccli",
-  "version": "0.4.0-beta.44",
+  "version": "0.4.0-beta.46",
   "description": "BCCLI — BotConnector AI coding agent for the terminal",
   "type": "module",
   "bin": {

package/dist/chunk-U6PCNS4B.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-
-// src/tokenBudget.ts
-var estimateTokens = (text) => Math.ceil(text.length / 4);
-var estimateMessages = (messages) => estimateTokens(JSON.stringify(messages));
-function trimToFit(messages, maxTokens) {
-  let out = messages;
-  while (estimateMessages(out) > maxTokens) {
-    const boundary = out.findIndex((m, i) => i > 0 && m.role === "user");
-    if (boundary === -1) return out;
-    out = out.slice(boundary);
-  }
-  return out;
-}
-
-export {
-  estimateTokens,
-  estimateMessages,
-  trimToFit
-};