jaitus 0.3.16 → 0.3.18

package/src/index.js

@@ -17,7 +17,7 @@ import {
   endpoints, version, HOME, HISTORY,
 } from './config.js';
 import { runAgent, repairToolPairs, streamTurn } from './agent/loop.js';
-import { estimateTokens, summarise, compactInPlace, dropOldImages, SIZE_FAULTS } from './compact.js';
+import { estimateTokens, summarise, compactInPlace, dropOldImages, needsAutoCompact, SIZE_FAULTS } from './compact.js';
 import { createPermissions, MODES as PERMISSION_MODES } from './agent/permissions.js';
 import { DEFAULT_DENY } from './agent/rules.js';
 import { forgetIgnoreCache, imageBlock, IMAGE_MIME } from './agent/tools.js';
@@ -38,6 +38,7 @@ import {
 } from './ui.js';
 import { createTui as createClassicTui } from './tui.js';
 import { createTui as createInkTui } from './tui-ink.js';
+import { planSections, costSections, planRows, spendText, rememberPlan, planBadge, withoutCredits } from './planView.js';
 
 // The interactive surface is Node-only. The classic renderer remains an
 // explicit escape hatch for terminals that cannot support fullscreen Ink.
@@ -964,6 +965,20 @@ async function session({ flags }) {
     }
   };
 
+  // The plan as the status bar shows it ("5h 12% · week 3%"): asked for at the start
+  // and after each turn (at most every 3 s), never in the way of the turn itself.
+  let planAskedAt = 0;
+  const refreshPlan = () => {
+    if (Date.now() - planAskedAt < 3_000) return;
+    planAskedAt = Date.now();
+    client.api('/auth/me').then(({ ok: good, body }) => {
+      const u = body?.user || body?.data;
+      if (!good || !u) return;
+      rememberPlan(u.planStatus || null);
+      try { tui?.setPlan?.(u.isPaid ? planBadge(u.planStatus) : null); } catch { /* bar keeps last value */ }
+    }).catch(() => { /* offline: the bar keeps what it had */ });
+  };
+
   /** One agent run with abort wiring, error accounting, and queue draining after. */
   const runManaged = async (messages, { recovered = false } = {}) => {
     const ctrl = new AbortController();
@@ -1082,6 +1097,7 @@ async function session({ flags }) {
         tui?.setSpent?.(spent);
       } catch { /* header keeps last value */ }
       refreshStatusLine('turn');
+      refreshPlan();
     }
   };
 
@@ -1116,6 +1132,9 @@ async function session({ flags }) {
   // gateway's prompt); the estimate covers what was added since. The larger wins — the
   // estimate alone missed both and let sessions run into the wall.
   const contextUsed = () => Math.max(lastContext || 0, estimateTokens(messages) + 6_000);
+  // The size the conversation was left at by the last compaction: until it has grown
+  // past that, compacting again cannot help (what is left is the newest exchange).
+  let compactedAt = 0;
 
   /**
    * Summarise in place. `keepTail` keeps the newest exchange word for word (the person's
@@ -1135,8 +1154,11 @@ async function session({ flags }) {
       sessionState.lastContext = 0;
       sessionState.messages = messages;
       saveSession(sessionState);
+      compactedAt = contextUsed();
       showContext({ estimate: true });
-      tui.notice?.(`${why || `Context was ${format(used)}`}; ${r.dropped} messages summarised into one. /rewind still has the originals.`, 'info');
+      tui.notice?.(r.digest
+        ? `${why || `Context was ${format(used)}`}; the summary could not be written, so ${r.dropped} messages were replaced by a digest of your requests, files and commands. /rewind still has the originals.`
+        : `${why || `Context was ${format(used)}`}; ${r.dropped} messages summarised into one. /rewind still has the originals.`, r.digest ? 'warn' : 'info');
       ledger.note('compacted', `The conversation was automatically summarised to free context: ${r.dropped} messages became one summary. Detail you are not shown above is genuinely gone — ask or re-read rather than assuming.`);
       return true;
     } catch (error) {
@@ -1151,7 +1173,7 @@ async function session({ flags }) {
 
   const autoCompactIfNeeded = async ({ signal } = {}) => {
     if (loadSettings().autoCompact === false) return false;
-    if (contextUsed() < compactThreshold()) return false;
+    if (!needsAutoCompact(contextUsed(), compactThreshold(), compactedAt)) return false;
     if (messages.length < 3) return false;
     return compactNow({ keepTail: true, signal });
   };
@@ -1459,6 +1481,7 @@ async function session({ flags }) {
     showContext();
     tui.setSpent?.(spent);
     refreshStatusLine('start');
+    refreshPlan();
     // Why the session is in the mode it is in, when that is not obvious from the badge.
     const startNotes = [
       bypassIsDefault && permissions.mode === 'bypassPermissions' ? 'Bypass is your default for new sessions — /permissions default ask turns that off.' : '',
@@ -1773,7 +1796,8 @@ async function slashCommand(verb, args, ctx) {
           { label: 'Directory', value: ctx.flags.cwd },
           { gap: true },
           { meter: 'Context', used, total: CONTEXT_BUDGET, detail: `~${format(used)} of ${format(CONTEXT_BUDGET)} tokens · ${ctx.messages.length} messages`, note: used / CONTEXT_BUDGET > 0.6 ? 'compacts by itself at 78%' : '' },
-          { label: 'This session', value: `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls${ctx.spent.credits ? ` · ${fmtCredits(ctx.spent.credits)} credits` : ''}` },
+          { label: 'This session', value: `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls` },
+          ...(spendText(ctx.spent.credits) ? [{ label: 'Plan usage', value: spendText(ctx.spent.credits) }] : []),
           { gap: true },
           { label: '', value: '/usage for your plan' },
         ]);
@@ -1785,7 +1809,7 @@ async function slashCommand(verb, args, ctx) {
         [`  ${c.dim('account')}`, creds?.user?.email || 'not signed in'],
         [`  ${c.dim('directory')}`, ctx.flags.cwd],
         [`  ${c.dim('context')}`, `${ctx.messages.length} messages · ~${estimateTokens(ctx.messages).toLocaleString()} tokens`],
-        [`  ${c.dim('session')}`, `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls${ctx.spent.credits ? ` · ${Math.round(ctx.spent.credits * 10) / 10} credits` : ''}`],
+        [`  ${c.dim('session')}`, `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls${spendText(ctx.spent.credits) ? ` · ${spendText(ctx.spent.credits)}` : ''}`],
       ]);
       return null;
     }
@@ -1838,7 +1862,7 @@ async function slashCommand(verb, args, ctx) {
         });
         // Saved now: a crash before the next turn used to bring the whole history back.
         if (ctx.sessionState) { ctx.sessionState.messages = ctx.messages; ctx.sessionState.lastContext = 0; saveSession(ctx.sessionState); }
-        ok(`Conversation compacted — about ${format(before)} tokens down to ${format(r?.after ?? estimateTokens(ctx.messages))}.`);
+        ok(`Conversation compacted — about ${format(before)} tokens down to ${format(r?.after ?? estimateTokens(ctx.messages))}${r?.digest ? ' (the summary could not be written; a digest of your requests, files and commands replaced it)' : ''}.`);
         try { ctx.resetContext?.(); } catch { /* header keeps last value */ }
       } catch (e) {
         // The request id is the only thing that ties this failure to a backend log
@@ -2666,12 +2690,12 @@ async function slashCommand(verb, args, ctx) {
       table([
         ['  Turns', String(spent.turns)],
         ['  Tool calls', String(spent.tools)],
-        ['  Credits', spent.credits ? String(Math.round(spent.credits * 100) / 100) : '—'],
+        ['  Plan usage', spendText(spent.credits) || '—'],
         ['  Input tokens', spent.input.toLocaleString()],
         ['  Cached input tokens', (spent.cached || 0).toLocaleString()],
         ['  Output tokens', spent.output.toLocaleString()],
       ]);
-      info(`${c.dim('Credits are what your plan counts: real cost, cached context included at its lower price. See')} ${c.bold('/usage')} ${c.dim('for your plan.')}`);
+      info(`${c.dim('Plan usage is this session as a share of your 5-hour session and your week. See')} ${c.bold('/usage')} ${c.dim('for your plan.')}`);
       return null;
 
     case '/cwd':
@@ -2700,76 +2724,6 @@ function fmtTokens(n) {
   if (v >= 1e3) return `${Math.round(v / 1e3)}K`;
   return String(Math.round(v));
 }
-/** Credits as people read them: whole numbers in the thousands, one decimal below. */
-function fmtCredits(n) {
-  const v = Number(n) || 0;
-  return v >= 1000 ? Math.round(v).toLocaleString('en-IN') : String(Math.round(v * 10) / 10);
-}
-
-const clock = (d) => new Date(d).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-const dayAndClock = (d) => new Date(d).toLocaleString([], { weekday: 'short', day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' });
-
-/**
- * The plan as meters: the 5-hour window, the week and the month each fill at their own
- * rate from the same requests, so each gets its own bar and its own refill time. Extra
- * credits and the free tier follow. Used by /usage (popup) and `jaitus usage` (text).
- */
-function planSections(u) {
-  const st = u?.planStatus || null;
-  const out = [];
-  if (!u?.isPaid) {
-    out.push({ heading: 'Free plan' });
-    if (st?.freeTierStatus === 'locked') {
-      out.push({ label: 'Free prompts', value: 'not available — this computer already has its free accounts', tone: 'bad' });
-    } else {
-      out.push({ meter: 'Free prompts', used: u?.freeRequestsUsed ?? 0, total: u?.freeRequestLimit || 0, detail: `${u?.freeRequestsUsed ?? 0} of ${u?.freeRequestLimit ?? '?'} used` });
-    }
-  } else {
-    out.push({ heading: st?.name || 'Your plan' });
-    if (st?.windowCredits) {
-      out.push({
-        meter: `${st.windowHours || 5}-hour window`, used: st.windowUsed, total: st.windowCredits,
-        detail: `${fmtCredits(st.windowUsed)} of ${fmtCredits(st.windowCredits)} credits`,
-        note: st.windowResetsAt ? `refills at ${clock(st.windowResetsAt)}` : 'starts with your next request',
-      });
-    }
-    if (st?.weeklyCredits) {
-      out.push({
-        meter: 'This week', used: st.weekUsed, total: st.weeklyCredits,
-        detail: `${fmtCredits(st.weekUsed)} of ${fmtCredits(st.weeklyCredits)} credits`,
-        note: st.weekResetsAt ? `refills ${dayAndClock(st.weekResetsAt)}` : 'starts with your next request',
-      });
-    }
-    if (st?.monthlyCredits) {
-      out.push({
-        meter: 'This month', used: st.periodCredits, total: st.monthlyCredits,
-        detail: `${fmtCredits(st.periodCredits)} of ${fmtCredits(st.monthlyCredits)} credits`,
-        note: st.periodResetsAt ? `resets ${new Date(st.periodResetsAt).toLocaleDateString([], { day: 'numeric', month: 'short' })}` : '',
-      });
-    }
-    if (u.planExpiresAt) out.push({ label: 'Renews by', value: new Date(u.planExpiresAt).toLocaleDateString([], { day: 'numeric', month: 'short', year: 'numeric' }) });
-  }
-  if (st?.bonusCredits > 0) {
-    out.push({ label: 'Extra credits', value: `${fmtCredits(st.bonusCredits)} left — used once a limit above runs out${st.bonusExpiresAt ? ` · until ${new Date(st.bonusExpiresAt).toLocaleDateString()}` : ''}`, tone: 'good' });
-  }
-  return out;
-}
-
-/** The session's spend, for /cost and the foot of /usage. */
-function costSections(spent) {
-  return [
-    { label: 'Credits', value: spent.credits ? `${fmtCredits(spent.credits)}` : '—', tone: 'good' },
-    { label: 'Turns', value: String(spent.turns) },
-    { label: 'Tool calls', value: String(spent.tools) },
-    { gap: true },
-    { label: 'Fresh input', value: `${(spent.input || 0).toLocaleString()} tokens` },
-    { label: 'Cached input', value: `${(spent.cached || 0).toLocaleString()} tokens (billed at the lower cached price)` },
-    { label: 'Output', value: `${(spent.output || 0).toLocaleString()} tokens` },
-    { gap: true },
-    { label: '', value: '/usage for your plan' },
-  ];
-}
-
 /** A meters list as plain text, for `jaitus usage` outside the app view. */
 function sectionsAsTable(sections) {
   const rows = [];
@@ -2784,27 +2738,6 @@ function sectionsAsTable(sections) {
   return rows;
 }
 
-function planRows(u) {
-  const st = u.planStatus || null;
-  if (!u.isPaid) return [['Plan', 'Free'], ['Free prompts', `${u.freeRequestsUsed ?? 0} of ${u.freeRequestLimit ?? '?'} used`]];
-  const rows = [['Plan', st?.name || 'Paid']];
-  // Credits: what the plan counts (real cost), the same number the website shows.
-  const cr = (n) => ((Number(n) || 0) >= 1000 ? Math.round(n).toLocaleString('en-IN') : String(Math.round((Number(n) || 0) * 10) / 10));
-  if (st?.monthlyCredits) {
-    const resets = st.periodResetsAt ? ` · resets ${new Date(st.periodResetsAt).toLocaleDateString()}` : '';
-    rows.push(['This period', `${cr(st.periodCredits)} of ${cr(st.monthlyCredits)} credits${resets}`]);
-    if (st.windowCredits) {
-      const refill = st.windowResetsAt
-        ? `refills at ${new Date(st.windowResetsAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`
-        : 'opens with your next request';
-      rows.push([`This ${st.windowHours || 5}h window`, `${cr(st.windowUsed)} of ${cr(st.windowCredits)} credits · ${refill}`]);
-    }
-    if (st.periodTokens) rows.push(['Behind them', `${fmtTokens(st.periodTokens)} tokens of input and replies`]);
-  }
-  if (u.planExpiresAt) rows.push(['Renews by', new Date(u.planExpiresAt).toLocaleDateString()]);
-  return rows;
-}
-
 const commands = {
   login: {
     summary: 'sign in through your browser',
@@ -2837,7 +2770,8 @@ const commands = {
       const { ok: good, body } = await client.api('/auth/me');
       if (!good) { fail(body?.message || 'Could not reach your account.'); return 1; }
       const u = body.user || body.data || {};
-      present(json, u, () => table([
+      rememberPlan(u.planStatus);
+      present(json, withoutCredits(u), () => table([
         ['Account', u.email || '—'],
         ...planRows(u),
         ['Gateway', endpoints().baseUrl],
@@ -2865,7 +2799,9 @@ const commands = {
         { label: 'Today', value: `${(d.today?.requests ?? 0).toLocaleString()} requests` },
         { label: 'This month', value: `${(d.month?.requests ?? 0).toLocaleString()} requests · ${fmtTokens(d.totalTokensConsumed ?? 0)} tokens in total` },
       ];
-      const session = spent ? [{ gap: true }, { heading: 'This session' }, { label: 'Credits', value: `${fmtCredits(spent.credits || 0)} · ${spent.turns} turns · ${spent.tools} tool calls` }] : [];
+      if (u?.planStatus) rememberPlan(u.planStatus);
+      const used = spent ? spendText(spent.credits || 0) : '';
+      const session = spent ? [{ gap: true }, { heading: 'This session' }, { label: 'Turns', value: `${spent.turns} turns · ${spent.tools} tool calls` }, ...(used ? [{ label: 'Plan usage', value: used }] : [])] : [];
       const sections = [...(u ? planSections(u) : []), ...activity, ...session];
       // In the app view: a popup over the conversation that Esc closes, not rows that
       // stay in the transcript for good.
@@ -2873,7 +2809,7 @@ const commands = {
         void tui.showMeters('Usage', sections);
         return 0;
       }
-      present(json, { ...d, planStatus: u?.planStatus || null }, () => table(sectionsAsTable(sections)));
+      present(json, withoutCredits({ ...d, planStatus: u?.planStatus || null }), () => table(sectionsAsTable(sections)));
       return 0;
     },
   },

package/src/machine.js

@@ -11,6 +11,8 @@
 //      folder), each restoring the other
 //   n  the address of each physical network adapter (virtual and randomised ones are
 //      skipped: they change by themselves)
+//   g  the git identity this computer commits as (global user.email) — the same on
+//      every computer one person sets up, so it recognises the person, not the machine
 //
 // A VPN, a new network or a new email changes none of these. They are reported by this
 // program, so they identify a computer for an honest client — the same ceiling every
@@ -126,6 +128,32 @@ function adapterIds() {
   return [...out].sort().slice(0, 3);
 }
 
+/** Hostname, OS user, CPU model, memory and OS — together, never one alone. */
+function softFingerprint() {
+  try {
+    let user = '';
+    try { user = os.userInfo().username; } catch { /* no user database */ }
+    const cpu = (os.cpus()?.[0]?.model || '').replace(/\s+/g, ' ').trim();
+    const gb = Math.round(os.totalmem() / 2 ** 30);
+    const host = os.hostname();
+    if (!host && !user) return null;
+    return [process.platform, os.arch(), host, user, cpu, `${gb}GB`].join('|');
+  } catch { return null; }
+}
+
+// Addresses git ships as examples or that many people leave unset-looking: not a person.
+const PLACEHOLDER_EMAIL = /(^|@)(example\.(com|org|net)|localhost)$|^(you|your[._-]?email|email|user|root|test|admin)@/i;
+
+/** The global git identity (user.email), or null when unset or a placeholder. */
+function gitIdentity() {
+  try {
+    const r = spawnSync('git', ['config', '--global', 'user.email'], { encoding: 'utf8', timeout: 2000, windowsHide: true });
+    const v = String(r.stdout || '').trim().toLowerCase();
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) || PLACEHOLDER_EMAIL.test(v)) return null;
+    return v;
+  } catch { return null; }
+}
+
 /**
  * Where the install id's second copy lives: outside ~/.jaitus, in the OS's app-data
  * folder. Always under os.homedir() (not LOCALAPPDATA / XDG_DATA_HOME), so a test run
@@ -180,6 +208,13 @@ export function machineHeader() {
     if (h) parts.push(`h=${h}`);
     parts.push(`i=${hash('i', installId())}`);
     for (const mac of adapterIds()) parts.push(`n=${hash('n', mac)}`);
+    // s: the computer as it describes itself — what an id-reset tool leaves alone. The
+    // server links it only together with a network both accounts were used from, so two
+    // people with the same laptop model are never taken for one.
+    const soft = softFingerprint();
+    if (soft) parts.push(`s=${hash('s', soft)}`);
+    const git = gitIdentity();
+    if (git) parts.push(`g=${hash('g', git)}`);
     if (m && cache.m !== m) writeCache({ ...cache, m, ...(h ? { h } : {}) });
   } catch { /* whatever was gathered */ }
   header = parts.join(',');

package/src/planView.js

@@ -0,0 +1,215 @@
+// ─── How a plan reads to the person using it: percentages, never credits ───────
+//
+// The gateway counts usage in credits (a fixed slice of real model cost) — that is its
+// internal unit and an admin's, not a customer's. Everything the CLI shows about a plan
+// is a percentage of the 5-hour session or of the week, with when each resets, the way
+// Claude's /usage reads. /usage, /cost, /status, `jaitus whoami`, `jaitus usage`, the
+// status bar and the work bar all come from here, so no screen can say it differently.
+
+const pctOf = (used, total) => (Number(total) > 0
+  ? Math.max(0, Math.min(100, Math.floor((100 * (Number(used) || 0)) / Number(total))))
+  : null);
+
+/** "4%", "0.6%", "<0.1%" — a share that can be small (one turn) or whole (a limit). */
+export function fmtShare(p) {
+  const v = Number(p);
+  if (!Number.isFinite(v) || v <= 0) return '0%';
+  if (v >= 10) return `${Math.round(v)}%`;
+  if (v >= 0.1) return `${Math.round(v * 10) / 10}%`;
+  return '<0.1%';
+}
+
+/** Whether this plan status has a month that is enforced (and so worth showing). */
+function monthShown(st) {
+  if (st?.monthlyLimit === true) return true;
+  // A gateway from before the switch existed enforced every month it sent.
+  return st?.monthlyLimit === undefined && Number(st?.monthlyCredits) > 0;
+}
+
+/**
+ * Where a subscriber stands, as whole percentages (null = no such limit). Read from the
+ * gateway's own percentages when it sends them, else worked out the same way (floor, so
+ * 100% means stopped).
+ */
+export function planPercents(st) {
+  if (!st) return null;
+  const window = st.windowPercent ?? pctOf(st.windowUsed, st.windowCredits);
+  const week = st.weekPercent ?? pctOf(st.weekUsed, st.weeklyCredits);
+  const month = monthShown(st) ? (st.monthPercent ?? pctOf(st.periodCredits, st.monthlyCredits)) : null;
+  const extra = Number(st.bonusCredits) > 0
+    ? (st.extraWeekPercent ?? (Number(st.weeklyCredits) > 0 ? Math.round((100 * st.bonusCredits) / st.weeklyCredits) : null))
+    : null;
+  return {
+    window, week, month,
+    windowHours: st.windowHours || 5,
+    windowResetsAt: st.windowResetsAt || null,
+    weekResetsAt: st.weekResetsAt || null,
+    monthResetsAt: month != null ? (st.periodResetsAt || null) : null,
+    hasExtra: Number(st.bonusCredits) > 0,
+    extraWeekPercent: extra,
+    extraExpiresAt: st.bonusExpiresAt || null,
+  };
+}
+
+/**
+ * A spend in credits (one turn, one session) as a share of the 5-hour session and of
+ * the week — null for either the plan does not have.
+ */
+export function spendShare(credits, st) {
+  const c = Number(credits) || 0;
+  if (!st || c <= 0) return { window: null, week: null };
+  return {
+    window: Number(st.windowCredits) > 0 ? (100 * c) / st.windowCredits : null,
+    week: Number(st.weeklyCredits) > 0 ? (100 * c) / st.weeklyCredits : null,
+  };
+}
+
+// The last plan status the gateway sent this process, so the status bar, /cost and
+// /status can turn a spend into a share without asking again.
+let lastPlan = null;
+export const rememberPlan = (st) => { if (st && typeof st === 'object') lastPlan = st; return lastPlan; };
+export const knownPlan = () => lastPlan;
+
+/**
+ * What the status bar and the work bar need: the two percentages, and the two budgets
+ * a turn's spend is measured against. null for an account with no plan limits.
+ */
+export function planBadge(st) {
+  const p = planPercents(st);
+  if (!p || (p.window == null && p.week == null)) return null;
+  return {
+    window: p.window, week: p.week, windowHours: p.windowHours,
+    windowCredits: Number(st.windowCredits) || 0, weeklyCredits: Number(st.weeklyCredits) || 0,
+  };
+}
+
+/** "5h 12% · week 3%" for the status bar. */
+export function badgeText(b) {
+  if (!b) return '';
+  const parts = [];
+  if (b.window != null) parts.push(`${b.windowHours || 5}h ${b.window}%`);
+  if (b.week != null) parts.push(`week ${b.week}%`);
+  return parts.join(' · ');
+}
+
+/** What one turn has used so far, for the work bar: "0.6% of session". '' when unknown. */
+export function turnShareText(credits, b) {
+  const c = Number(credits) || 0;
+  if (!b || c <= 0) return '';
+  if (b.windowCredits > 0) return `${fmtShare((100 * c) / b.windowCredits)} of session`;
+  if (b.weeklyCredits > 0) return `${fmtShare((100 * c) / b.weeklyCredits)} of week`;
+  return '';
+}
+
+const clock = (d) => new Date(d).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+const dayAndClock = (d) => new Date(d).toLocaleString([], { weekday: 'short', day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' });
+const shortDate = (d) => new Date(d).toLocaleDateString([], { day: 'numeric', month: 'short' });
+const longDate = (d) => new Date(d).toLocaleDateString([], { day: 'numeric', month: 'short', year: 'numeric' });
+
+function extraLine(p) {
+  if (!p?.hasExtra) return null;
+  const until = p.extraExpiresAt ? ` · until ${longDate(p.extraExpiresAt)}` : '';
+  return p.extraWeekPercent != null
+    ? `${p.extraWeekPercent}% of a week left — used once a limit above runs out${until}`
+    : `available — used once your free prompts run out${until}`;
+}
+
+/**
+ * The plan as meters for /usage (popup) and `jaitus usage` (text): the 5-hour session
+ * and the week fill at their own rates from the same requests, so each gets its own bar
+ * and its own reset time. Extra usage and the free tier follow.
+ */
+export function planSections(u) {
+  const st = u?.planStatus || null;
+  const out = [];
+  if (!u?.isPaid) {
+    out.push({ heading: 'Free plan' });
+    if (st?.freeTierStatus === 'locked') {
+      out.push({ label: 'Free prompts', value: 'not available — this computer already has its free accounts', tone: 'bad' });
+    } else {
+      out.push({ meter: 'Free prompts', used: u?.freeRequestsUsed ?? 0, total: u?.freeRequestLimit || 0, detail: `${u?.freeRequestsUsed ?? 0} of ${u?.freeRequestLimit ?? '?'} prompts used` });
+    }
+  } else {
+    out.push({ heading: st?.name || 'Your plan' });
+    const p = planPercents(st);
+    if (p?.window != null) {
+      out.push({ meter: `${p.windowHours}-hour session`, used: p.window, total: 100, note: p.windowResetsAt ? `resets at ${clock(p.windowResetsAt)}` : 'starts with your next request' });
+    }
+    if (p?.week != null) {
+      out.push({ meter: 'Week', used: p.week, total: 100, note: p.weekResetsAt ? `resets ${dayAndClock(p.weekResetsAt)}` : 'starts with your next request' });
+    }
+    if (p?.month != null) {
+      out.push({ meter: 'Month', used: p.month, total: 100, note: p.monthResetsAt ? `resets ${shortDate(p.monthResetsAt)}` : '' });
+    }
+    if (u.planExpiresAt) out.push({ label: 'Renews by', value: longDate(u.planExpiresAt) });
+  }
+  const extra = extraLine(planPercents(st));
+  if (extra) out.push({ label: 'Extra usage', value: extra, tone: 'good' });
+  return out;
+}
+
+/** A session's spend as plan shares: "2.1% of a 5-hour session · 0.5% of your week". */
+export function spendText(credits, st = lastPlan) {
+  const s = spendShare(credits, st);
+  const parts = [];
+  if (s.window != null) parts.push(`${fmtShare(s.window)} of a 5-hour session`);
+  if (s.week != null) parts.push(`${fmtShare(s.week)} of your week`);
+  return parts.join(' · ');
+}
+
+/** The session's spend, for /cost and the foot of /usage. */
+export function costSections(spent, st = lastPlan) {
+  const used = spendText(spent?.credits, st);
+  return [
+    ...(used ? [{ label: 'Plan usage', value: used, tone: 'good' }] : []),
+    { label: 'Turns', value: String(spent?.turns || 0) },
+    { label: 'Tool calls', value: String(spent?.tools || 0) },
+    { gap: true },
+    { label: 'Fresh input', value: `${(spent?.input || 0).toLocaleString()} tokens` },
+    { label: 'Cached input', value: `${(spent?.cached || 0).toLocaleString()} tokens (counted at the lower cached price)` },
+    { label: 'Output', value: `${(spent?.output || 0).toLocaleString()} tokens` },
+    { gap: true },
+    { label: '', value: '/usage for your plan' },
+  ];
+}
+
+/** The plan as rows for `jaitus whoami`. */
+export function planRows(u) {
+  const st = u?.planStatus || null;
+  if (!u?.isPaid) return [['Plan', 'Free'], ['Free prompts', `${u?.freeRequestsUsed ?? 0} of ${u?.freeRequestLimit ?? '?'} used`]];
+  const rows = [['Plan', st?.name || 'Paid']];
+  const p = planPercents(st);
+  if (p?.window != null) rows.push([`${p.windowHours}-hour session`, `${p.window}% used · ${p.windowResetsAt ? `resets at ${clock(p.windowResetsAt)}` : 'starts with your next request'}`]);
+  if (p?.week != null) rows.push(['Week', `${p.week}% used · ${p.weekResetsAt ? `resets ${dayAndClock(p.weekResetsAt)}` : 'starts with your next request'}`]);
+  if (p?.month != null) rows.push(['Month', `${p.month}% used${p.monthResetsAt ? ` · resets ${shortDate(p.monthResetsAt)}` : ''}`]);
+  const extra = extraLine(p);
+  if (extra) rows.push(['Extra usage', extra]);
+  if (u.planExpiresAt) rows.push(['Renews by', new Date(u.planExpiresAt).toLocaleDateString()]);
+  return rows;
+}
+
+/** The plan as --json prints it: percentages and times, no credits. */
+export function publicPlan(st) {
+  if (!st) return null;
+  const p = planPercents(st);
+  return {
+    key: st.key, name: st.name, paid: Boolean(st.paid), expiresAt: st.expiresAt || null,
+    session: p.window != null ? { hours: p.windowHours, percentUsed: p.window, resetsAt: p.windowResetsAt } : null,
+    week: p.week != null ? { percentUsed: p.week, resetsAt: p.weekResetsAt } : null,
+    month: p.month != null ? { percentUsed: p.month, resetsAt: p.monthResetsAt } : null,
+    extraUsage: p.hasExtra ? { percentOfWeek: p.extraWeekPercent, expiresAt: p.extraExpiresAt } : null,
+    freeTierStatus: st.freeTierStatus || null,
+  };
+}
+
+/** A copy of a response for --json with every credit field taken out, at any depth. */
+export function withoutCredits(value) {
+  if (Array.isArray(value)) return value.map(withoutCredits);
+  if (!value || typeof value !== 'object' || value instanceof Date) return value;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (/credit/i.test(k)) continue;
+    out[k] = k === 'planStatus' ? publicPlan(v) : withoutCredits(v);
+  }
+  return out;
+}

package/src/tui/entries.js

@@ -10,7 +10,7 @@
 
 import { palette, mix, ramp } from './theme.js';
 import { renderMarkdown, inlineSpans } from './markdown.js';
-import { ansiToRows, wrapRows, wrapRow, truncateRow, stringWidth, plain } from './ansi.js';
+import { ansiToRows, wrapRows, wrapRow, truncateRow, stringWidth, plain, padRow } from './ansi.js';
 import { highlightLine, languageForPath } from './highlight.js';
 import { wordRows, wordSize } from './wordmark.js';
 import { MASCOT_ROWS } from '../brand.js';
@@ -150,7 +150,13 @@ const BUILDERS = {
     if (data.attachments?.length) {
       rows.push([indent, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
     }
-    return rows;
+    // The whole message sits on a faint band the full width of the window, with a row of
+    // it above and below, so what the person said never reads as part of the answer. The
+    // band is drawn, never copied (the padding is decoration).
+    const band = p.raised;
+    const shade = (row) => padRow(row.map((span) => ({ ...span, backgroundColor: span.backgroundColor || band })), width, { backgroundColor: band, copy: '' });
+    const edge = [{ t: ' '.repeat(Math.max(1, width)), backgroundColor: band, copy: '' }];
+    return [edge, ...rows.map(shade), edge];
   },
 
   // ── What the model said ──────────────────────────────────────────────────────