@bunshin-cc/bunshin 0.10.0 → 0.10.2

package/dist/bin.js

@@ -6508,9 +6508,11 @@ var route_exports = {};
 __export(route_exports, {
   ROUTER_MODEL: () => ROUTER_MODEL,
   lastReply: () => lastReply,
+  localDay: () => localDay,
   promptContext: () => promptContext,
   readAnswer: () => readAnswer,
   readJob: () => readJob,
+  readStats: () => readStats,
   routeJob: () => routeJob,
   sweepRouter: () => sweepRouter,
   writeJob: () => writeJob
@@ -6636,17 +6638,24 @@ async function routeJob(store, sessionId, seq) {
   const job = readJob(v2, sessionId);
   if (!job || job.seq !== seq || job.cancelled) return null;
   const started = Date.parse(job.at) || Date.now();
-  const write = (a) => {
-    const answer = { seq, at: (/* @__PURE__ */ new Date()).toISOString(), ms: Date.now() - started, ...a };
-    writeJsonAtomic(answerFile(v2, sessionId, seq), answer);
-    v2.log("v2-router", { session: sessionId, seq, serve: answer.serve ?? null, rules: answer.rules ?? [], hint: answer.hint ?? [], ms: answer.ms, modelMs: answer.modelMs, error: answer.error, dense: job.dense?.serve ?? null, usage: answer.usage });
-    return answer;
-  };
+  const model = config.recall.routerModel || process.env.BUNSHIN_ROUTER_MODEL || ROUTER_MODEL;
+  const { picks, indexHash } = await askRouter(store, v2, sessionId, model);
+  const answer = { seq, at: (/* @__PURE__ */ new Date()).toISOString(), ms: Date.now() - started, ...picks };
+  writeJsonAtomic(answerFile(v2, sessionId, seq), answer);
+  const dense = (readJob(v2, sessionId) ?? job).dense;
+  v2.log("v2-router", { session: sessionId, seq, serve: answer.serve ?? null, rules: answer.rules ?? [], hint: answer.hint ?? [], ms: answer.ms, modelMs: answer.modelMs, error: answer.error, dense: dense?.serve ?? null, denseHint: dense?.hint ?? [], usage: answer.usage, costUsd: answer.costUsd });
+  await recordStats(v2, sessionId, answer, model, indexHash);
+  return answer;
+}
+async function askRouter(store, v2, sessionId, model) {
+  const config = store.config();
+  let indexHash;
   try {
     const session = v2.readSession(sessionId);
-    if (!session?.lastPrompt) return write({ error: "no prompt in the session file" });
-    if (!canCall(config)) return write({ error: "offline: the router's index comes from the server" });
+    if (!session?.lastPrompt) return { picks: { error: "no prompt in the session file" } };
+    if (!canCall(config)) return { picks: { error: "offline: the router's index comes from the server" } };
     const index = await routerIndex(store, v2, session.source ?? "");
+    indexHash = index.hash;
     const systemFile = path11.join(dir(v2), `system-${index.hash}.txt`);
     if (!fs16.existsSync(systemFile)) fs16.writeFileSync(systemFile, index.system);
     const cwd = path11.join(dir(v2), "cwd");
@@ -6654,16 +6663,44 @@ async function routeJob(store, sessionId, seq) {
     const inContext2 = session.inContext ?? [...session.loaded, ...session.pushed];
     const titles = new Map((v2.readBundle()?.sections ?? []).map((s) => [s.id, s.skill?.name ?? s.title]));
     const message = routerMessage(session.lastPrompt, promptContext(session), inContext2.map((id) => titles.get(id)).filter((t) => !!t));
-    const res = await askClaude(systemFile, message, config.recall.routerModel || process.env.BUNSHIN_ROUTER_MODEL || ROUTER_MODEL, cwd);
+    const res = await askClaude(systemFile, message, model, cwd);
     const u = res.usage ?? {};
     const usage = { input: u.input_tokens ?? 0, cacheRead: u.cache_read_input_tokens ?? 0, cacheWrite: u.cache_creation_input_tokens ?? 0, output: u.output_tokens ?? 0, ...u.output_tokens_details?.thinking_tokens ? { thinking: u.output_tokens_details.thinking_tokens } : {} };
-    const meta = { ...res.duration_ms ? { modelMs: res.duration_ms } : {}, usage };
-    if (res.is_error) return write({ ...meta, error: `claude: ${(res.result ?? "error").slice(0, 300)}` });
+    const meta = { ...res.duration_ms ? { modelMs: res.duration_ms } : {}, usage, ...typeof res.total_cost_usd === "number" ? { costUsd: res.total_cost_usd } : {} };
+    if (res.is_error) return { picks: { ...meta, error: `claude: ${(res.result ?? "error").slice(0, 300)}` }, indexHash };
     const picks = parseRouterAnswer(res.result ?? "", index.items, inContext2);
-    if (!picks) return write({ ...meta, error: `not JSON: ${(res.result ?? "").slice(0, 120)}` });
-    return write({ ...picks, ...meta });
+    if (!picks) return { picks: { ...meta, error: `not JSON: ${(res.result ?? "").slice(0, 120)}` }, indexHash };
+    return { picks: { ...picks, ...meta }, indexHash };
   } catch (err) {
-    return write({ error: (err instanceof Error ? err.message : String(err)).slice(0, 300) });
+    return { picks: { error: (err instanceof Error ? err.message : String(err)).slice(0, 300) }, ...indexHash ? { indexHash } : {} };
+  }
+}
+async function recordStats(v2, sessionId, a, model, indexHash) {
+  let release = null;
+  for (let i = 0; i < 40 && !(release = v2.tryLock("router-stats", 3e4)); i++) await new Promise((r) => setTimeout(r, 50));
+  try {
+    const day = localDay();
+    const prev = readStats(v2);
+    const stats = prev?.v === 1 && prev.day === day ? prev : { v: 1, day, model, today: emptyTally(), sessions: {} };
+    const u = a.usage ?? { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+    const add = (t) => {
+      t.calls++;
+      if (a.error) t.errors++;
+      t.costUsd += a.costUsd ?? 0;
+      t.input += u.input;
+      t.cacheRead += u.cacheRead;
+      t.cacheWrite += u.cacheWrite;
+      t.output += u.output;
+      t.msTotal += a.ms;
+    };
+    add(stats.today);
+    add(stats.sessions[sessionId] ??= emptyTally());
+    stats.model = model;
+    if (a.usage || !stats.last) stats.last = { at: a.at, session: sessionId, ms: a.ms, costUsd: a.costUsd ?? 0, input: u.input, cacheRead: u.cacheRead, cacheWrite: u.cacheWrite, ...indexHash ? { indexHash } : {}, ...a.error ? { error: a.error } : {} };
+    writeJsonAtomic(path11.join(dir(v2), "stats.json"), stats);
+  } catch {
+  } finally {
+    release?.();
   }
 }
 function sweepRouter(v2, now = Date.now()) {
@@ -6676,7 +6713,7 @@ function sweepRouter(v2, now = Date.now()) {
   } catch {
   }
 }
-var ROUTER_MODEL, INDEX_TTL_MS, CLAUDE_TIMEOUT_MS, dir, safe2, jobFile, answerFile, readJob, writeJob, readAnswer;
+var ROUTER_MODEL, INDEX_TTL_MS, CLAUDE_TIMEOUT_MS, dir, safe2, jobFile, answerFile, readJob, writeJob, readAnswer, emptyTally, localDay, readStats;
 var init_route = __esm({
   "src/v2/route.ts"() {
     "use strict";
@@ -6696,6 +6733,9 @@ var init_route = __esm({
     readJob = (v2, session) => readJson2(jobFile(v2, session));
     writeJob = (v2, session, job) => writeJsonAtomic(jobFile(v2, session), job);
     readAnswer = (v2, session, seq) => readJson2(answerFile(v2, session, seq));
+    emptyTally = () => ({ calls: 0, errors: 0, costUsd: 0, input: 0, cacheRead: 0, cacheWrite: 0, output: 0, msTotal: 0 });
+    localDay = (d = /* @__PURE__ */ new Date()) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+    readStats = (v2) => readJson2(path11.join(dir(v2), "stats.json"));
   }
 });
 
@@ -7324,7 +7364,7 @@ async function routedText(v2, ctx, session) {
   const rules = (await Promise.all(fresh(fallback ? [] : answer.rules ?? []).filter((id) => id !== doc?.id).map(find))).filter((s) => !!s);
   const hints = fresh(fallback ? job.dense?.hint ?? [] : answer.hint ?? []).filter((id) => id !== doc?.id && !session.hinted?.includes(id));
   const hintTitles = hints.map((id) => view.sections.find((s) => s.id === id)?.title).filter((t) => !!t);
-  v2.log("v2-router-delivered", { session: session.sessionId, seq: job.seq, tool: ctx.input.tool_name, afterMs: Date.now() - Date.parse(job.at), serve: doc?.id ?? null, rules: rules.map((r) => r.id), hint: hints, fallback, ...answer.error ? { error: answer.error } : {} });
+  v2.log("v2-router-delivered", { session: session.sessionId, seq: job.seq, tool: ctx.input.tool_name, afterMs: Date.now() - Date.parse(job.at), serve: doc?.id ?? null, rules: rules.map((r) => r.id), hint: hints, fallback, dense: job.dense?.serve ?? null, ...answer.error ? { error: answer.error } : {} });
   const ids = [...doc ? [doc.id] : [], ...rules.map((r) => r.id)];
   if (!ids.length && !hintTitles.length) return "";
   v2.updateSession(session.sessionId, ctx.cwd, (s) => {

package/dist/claude-code-ui/hooks/bunshin-ui.mjs

@@ -6,9 +6,14 @@
 // checkpoints, reviews waiting. This mod draws it:
 //
 //   above the prompt  one line: the latest document served and why, then the session's counts
-//   /bunshin          a pane: everything served, the lessons, recent events; Learn now, Sync, Review
+//                     (and, with the claude-cli recall router, whether its cache is warm and today's cost)
+//   /bunshin          a pane: everything served, the lessons, recent events, the router's calls and
+//                     cost; Learn now, Sync, Review
 //   toasts            library updates, lessons learned, reviews waiting, the /learn nudge
 //
+// The claude-cli router (packages/cli/src/v2/route.ts) keeps its calls, tokens and cost at API
+// prices in .bunshin/v2/router/stats.json; the index stays cached for an hour after each call.
+//
 // While it runs it writes a heartbeat beside the feed (<session>.mod.json); the CLI then stops
 // printing its plain one-line fallback (systemMessage), so nothing is said twice.
 
@@ -16,6 +21,9 @@ const FEED = { plugin: "bunshin-ui", key: "feed" };
 const WHERE = { plugin: "bunshin-ui", key: "where" };
 const SEEN = { plugin: "bunshin-ui", key: "seen" };
 const PANEL = { plugin: "bunshin-ui", key: "panel" };
+const ROUTER = { plugin: "bunshin-ui", key: "router" };
+/** Claude Code caches the router's index for an hour; each call that reads it starts the hour again. */
+const CACHE_TTL_MS = 60 * 60_000;
 
 const PANE_ID = "bunshin";
 const POLL_MS = 15_000;
@@ -90,16 +98,18 @@ export function register(on) {
     if (e.props.hasSurvey) return next(e);
     const { value: feed } = await $.state.get(FEED);
     if (!feed) return next(e);
+    const { value: router = null } = await $.state.get(ROUTER);
     const { Box, Text } = $.ui.resolve(e);
-    return band(Box, Text, feed, e.props.bodyColumns);
+    return band(Box, Text, feed, e.props.bodyColumns, router);
   });
 
   on("ui.render", { component: "Pane" }, async ($, e, next) => {
     if (e.requestId !== PANE_ID || e.surface === "mobile") return next(e);
     const { value: feed } = await $.state.get(FEED);
     const { value: panel = { view: "session", busy: "", output: "" } } = await $.state.get(PANEL);
+    const { value: router = null } = await $.state.get(ROUTER);
     const { Box, Text, Button } = $.ui.resolve(e);
-    return pane({ Box, Text, Button }, feed, panel, e.props.bodyColumns, e.props.scroll?.bodyRows ?? 30);
+    return pane({ Box, Text, Button }, feed, panel, e.props.bodyColumns, e.props.scroll?.bodyRows ?? 30, router);
   });
 }
 
@@ -149,6 +159,7 @@ async function refresh($, { first = false } = {}) {
       feed = null;
     }
     const now = await $.clock.now();
+    await refreshRouter($, where, now);
     if (now - lastBeat >= BEAT_MS) {
       lastBeat = now;
       await $.fs.write(`${where.store}/ui/${safe(where.sessionId)}.mod.json`, JSON.stringify({ at: new Date(now).toISOString(), mod: "bunshin-ui" })).catch(() => undefined);
@@ -176,6 +187,48 @@ async function refresh($, { first = false } = {}) {
   }
 }
 
+/** The local date, YYYY-MM-DD, as the CLI writes it. */
+const localDay = (ms) => {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+};
+
+/**
+ * What the router's stats say now: is the cache warm (the latest call read or wrote it under an
+ * hour ago) and for how much longer, and today's and this session's calls and cost. Null when the
+ * claude-cli router has not run. Written to state only when it reads differently (at most a minute).
+ */
+function routerView(stats, sessionId, now) {
+  if (!stats || stats.v !== 1) return null;
+  const fresh = stats.day === localDay(now);
+  const tally = (t) => (t && fresh ? { calls: t.calls, errors: t.errors, costUsd: t.costUsd, avgMs: t.calls ? Math.round(t.msTotal / t.calls) : 0 } : { calls: 0, errors: 0, costUsd: 0, avgMs: 0 });
+  const last = stats.last;
+  const age = last ? now - Date.parse(last.at) : Number.POSITIVE_INFINITY;
+  const cached = last ? last.cacheRead + last.cacheWrite : 0;
+  const warm = !!last && cached > 0 && age >= 0 && age < CACHE_TTL_MS;
+  return {
+    model: stats.model,
+    warm,
+    minutesLeft: warm ? Math.max(1, Math.ceil((CACHE_TTL_MS - age) / 60_000)) : 0,
+    last: last ? { cacheRead: last.cacheRead, tokens: cached + last.input, costUsd: last.costUsd, ms: last.ms, at: last.at } : null,
+    today: tally(stats.today),
+    session: tally(stats.sessions?.[sessionId]),
+  };
+}
+
+async function refreshRouter($, where, now) {
+  const file = `${where.store}/router/stats.json`;
+  let stats = null;
+  try {
+    if (await $.fs.exists(file)) stats = JSON.parse(await $.fs.read(file));
+  } catch {
+    stats = null;
+  }
+  const view = routerView(stats, where.sessionId, now);
+  const { value: prev = null } = await $.state.get(ROUTER);
+  if (JSON.stringify(prev) !== JSON.stringify(view)) await $.state.set(ROUTER, view);
+}
+
 /** Run the CLI for the session (its argv is in the feed, so the runtime copy the hooks use). */
 async function act($, what) {
   const { value: where } = await $.state.get(WHERE);
@@ -211,6 +264,11 @@ async function showReview($) {
 // ── drawing ─────────────────────────────────────────────────────────────────────────────────────
 
 const label = (s) => (s.skill ? `${s.skill} skill` : `${s.title}`);
+const usd = (n) => `$${n < 0.1 ? n.toFixed(3) : n.toFixed(2)}`;
+const kTokens = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
+const modelName = (m) => String(m ?? "").replace(/^claude-/, "").replace(/-(\d+)-(\d+)$/, " $1.$2").replace(/^./, (c) => c.toUpperCase());
+/** The router in the band's few columns: "cache warm 52m · $0.04 today". */
+const routerShort = (r) => (r ? `${r.warm ? `cache warm ${r.minutesLeft}m` : "cache cold"} · ${usd(r.today.costUsd)} today` : "");
 const clip = (s, n) => (s.length > n ? `${s.slice(0, Math.max(1, n - 1))}…` : s);
 const hhmm = (iso) => String(iso).slice(11, 16);
 
@@ -237,10 +295,12 @@ const shortWhy = (why) =>
  *   ◆ bunshin  complete-ticket skill  embedders agree          lib@209 · 1 served · 7 to review
  *   ◇ bunshin  maybe  agent-grid · manage-agent-fleet skill    lib@209 · 7 to review
  *
- * What does not fit is dropped whole, least useful first: the quiet counts, then the reason (never
- * the reviews waiting, in yellow); only then does the name end in "…".
+ *   ◆ bunshin  complete-ticket skill  router   lib@249 · 1 served · cache warm 52m · $0.04 today
+ *
+ * What does not fit is dropped whole, least useful first: the quiet counts, then the reason, then
+ * the router's cache and cost (never the reviews waiting, in yellow); only then does the name end in "…".
  */
-function band(Box, Text, feed, columns) {
+function band(Box, Text, feed, columns, router = null) {
   const latest = feed.served.find((s) => s.how !== "hint");
   const hint = feed.served[0]?.how === "hint" ? feed.served.filter((s) => s.how === "hint" && s.at === feed.served[0].at) : [];
   const served = feed.served.filter((s) => s.how !== "hint").length;
@@ -250,13 +310,15 @@ function band(Box, Text, feed, columns) {
   const why = latest?.why ? `  ${shortWhy(latest.why)}` : "";
   // The cells each piece takes: "◆ bunshin  " (11), the name, the reason; the counts plus a 2-cell gap.
   const room = columns - 2;
-  const fits = (withWhy, withQuiet) => {
-    const right = [withQuiet ? quiet : "", review].filter(Boolean).join(" · ");
+  const cache = routerShort(router);
+  const fits = (withWhy, withQuiet, withCache) => {
+    const right = [withQuiet ? quiet : "", withCache ? cache : "", review].filter(Boolean).join(" · ");
     return 11 + name.length + (withWhy ? why.length : 0) + (right ? right.length + 2 : 0) <= room;
   };
-  // Keep, in order: the name, the reviews waiting, the reason, the quiet counts.
-  const showWhy = !!why && fits(true, false);
-  const showQuiet = !!quiet && fits(showWhy, true);
+  // Keep, in order: the name, the reviews waiting, the router's cache and cost, the reason, the quiet counts.
+  const showCache = !!cache && fits(false, false, true);
+  const showWhy = !!why && fits(true, false, showCache);
+  const showQuiet = !!quiet && fits(showWhy, true, showCache);
 
   const left = [];
   if (latest) {
@@ -273,6 +335,11 @@ function band(Box, Text, feed, columns) {
   }
   const right = [];
   if (showQuiet) right.push(Text({ dimColor: true, children: quiet }));
+  if (showCache) {
+    if (right.length) right.push(Text({ dimColor: true, children: " · " }));
+    right.push(router.warm ? Text({ color: "green", children: `cache warm ${router.minutesLeft}m` }) : Text({ dimColor: true, children: "cache cold" }));
+    right.push(Text({ dimColor: true, children: ` · ${usd(router.today.costUsd)} today` }));
+  }
   if (review) {
     if (right.length) right.push(Text({ dimColor: true, children: " · " }));
     right.push(Text({ color: "yellow", children: review }));
@@ -300,7 +367,26 @@ function heading(Text, text) {
   return Text({ bold: true, color: BRAND, children: text });
 }
 
-function pane({ Box, Text, Button }, feed, panel, columns, rows) {
+/** The pane's router section: the cache, then today's and this session's calls and cost. */
+function routerLines(Text, r, width) {
+  const out = [Text({ children: " " }), heading(Text, `Recall router · ${modelName(r.model)} on your Claude plan`)];
+  const hit = r.last && r.last.tokens ? Math.round((100 * r.last.cacheRead) / r.last.tokens) : 0;
+  out.push(
+    Text({
+      wrap: "truncate-end",
+      children: r.warm
+        ? [Text({ children: "  cache " }), Text({ color: "green", children: `warm, ${r.minutesLeft} min left` }), Text({ dimColor: true, children: r.last ? `  · last call read ${kTokens(r.last.cacheRead)} of ${kTokens(r.last.tokens)} tokens from cache (${hit}%)` : "" })]
+        : [Text({ children: "  cache " }), Text({ color: "yellow", children: "cold" }), Text({ dimColor: true, children: "  · the next call writes the index again (it stays cached an hour after each call)" })],
+    }),
+  );
+  const t = r.today;
+  const each = t.calls ? ` · ≈${usd(t.costUsd / t.calls)} a call · ${(t.avgMs / 1000).toFixed(1)} s on average` : "";
+  out.push(Text({ children: clip(`  today         ${t.calls} call${t.calls === 1 ? "" : "s"} · ${usd(t.costUsd)} at API prices${each}${t.errors ? ` · ${t.errors} failed` : ""}`, width), wrap: "truncate-end" }));
+  out.push(Text({ dimColor: true, children: clip(`  this session  ${r.session.calls} call${r.session.calls === 1 ? "" : "s"} · ${usd(r.session.costUsd)}`, width), wrap: "truncate-end" }));
+  return out;
+}
+
+function pane({ Box, Text, Button }, feed, panel, columns, rows, router = null) {
   const width = Math.max(30, columns - 2);
   const body = [];
   if (!feed) {
@@ -333,6 +419,7 @@ function pane({ Box, Text, Button }, feed, panel, columns, rows) {
     body.push(heading(Text, "Learned from this session"));
     if (!feed.lessons.length) body.push(Text({ dimColor: true, children: feed.reflectedAt ? "  nothing new" : "  not reflected on yet (Learn now, or at session end)" }));
     for (const l of feed.lessons.slice(-6)) body.push(Text({ children: clip(`  ${l.status.padEnd(10)} ${l.target}: ${l.summary}`, width), wrap: "truncate-end" }));
+    if (router) body.push(...routerLines(Text, router, width));
     const recent = feed.events.filter((x) => x.kind !== "served" && x.kind !== "hint" && x.kind !== "push").slice(-4);
     if (recent.length) {
       body.push(Text({ children: " " }));

package/dist/claude-code-ui/types/index.d.ts

@@ -18,6 +18,16 @@ export type BunshinUiFeed = {
 };
 export type BunshinUiWhere = { store: string; project: string; sessionId: string };
 export type BunshinUiPanel = { view: "session" | "review"; busy: string; output: string };
+export type BunshinUiRouterTally = { calls: number; errors: number; costUsd: number; avgMs: number };
+/** The claude-cli recall router as drawn: its cache and its cost (router/stats.json, read). */
+export type BunshinUiRouter = {
+  model: string;
+  warm: boolean;
+  minutesLeft: number;
+  last: { cacheRead: number; tokens: number; costUsd: number; ms: number; at: string } | null;
+  today: BunshinUiRouterTally;
+  session: BunshinUiRouterTally;
+};
 
 declare module "claude-code" {
   interface PluginState {
@@ -26,6 +36,7 @@ declare module "claude-code" {
       where: BunshinUiWhere | null;
       seen: number;
       panel: BunshinUiPanel;
+      router: BunshinUiRouter | null;
     };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunshin-cc/bunshin",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
   "type": "module",
   "bin": {