jaitus 0.3.5 → 0.3.7

package/README.md

@@ -119,7 +119,9 @@ scrolls to the line you pick.
 
 **Pasting.** Right-click or `Ctrl+V` pastes the clipboard; a long paste becomes a
 `[#1 pasted 120 lines]` chip (the full text is sent). **Images:** drag an image file
-onto the terminal, paste a copied screenshot with `Alt+V`, type `/image path.png`, or
+onto the terminal, paste a copied screenshot (`Alt+V` on Windows — Windows Terminal and
+VS Code keep `Ctrl+V` for themselves; `Ctrl+V` on macOS and Linux, where `Cmd+V` /
+`Ctrl+Shift+V` belong to the terminal), type `/image path.png`, or
 mention `@screenshot.png` — each becomes an `[Image #N]` chip listed under the
 composer. Backspace over a chip removes it; only images whose chip is still in the
 message are sent. Screenshots over 3.5 MB are shrunk automatically.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/source-sanity.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js",
+    "test": "node tests/source-sanity.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/agent/loop.js

@@ -229,6 +229,65 @@ export function repairToolPairs(messages) {
   return messages;
 }
 
+// ── Keeping the conversation small ────────────────────────────────────────────
+//
+// Every request re-sends the whole conversation, and in real use that re-send — cached,
+// but not free — was ~75% of what a session cost: 109 requests averaged 46k tokens of
+// context each, most of it tool output from many steps ago (a file read at step 3 is
+// still paid for at step 60). This is the documented "clear old tool results" strategy
+// (Anthropic's context editing, clear_tool_uses; Claude Code's micro-compaction): once
+// the conversation passes TRIM_AT, the outputs of all but the KEEP_RECENT latest tool
+// calls are replaced with a line saying they were cleared and can be re-run. It clears
+// at least TRIM_AT_LEAST at a time, because each clearing breaks the prompt cache once
+// — clearing a little on every step would cost more than it saves. Small results (a
+// "file written", an exit code) are kept: they carry meaning and cost nothing.
+export const TRIM_AT = 100_000;         // estimated tokens of conversation (the documented default)
+export const KEEP_RECENT = 6;           // latest tool results always kept whole
+export const TRIM_AT_LEAST = 12_000;    // estimated tokens a clearing must free
+const TRIM_MIN_CHARS = 1_500;           // results shorter than this are never cleared
+const CLEARED = '[Output cleared';
+
+const blockChars = (b) => {
+  if (b?.type === 'text') return (b.text || '').length;
+  if (b?.type === 'tool_use') return JSON.stringify(b.input || {}).length;
+  if (b?.type === 'tool_result') return typeof b.content === 'string' ? b.content.length : JSON.stringify(b.content || '').length;
+  return 0;
+};
+export function conversationTokens(messages) {
+  let chars = 0;
+  for (const m of messages || []) chars += typeof m?.content === 'string' ? m.content.length : (Array.isArray(m?.content) ? m.content.reduce((n, b) => n + blockChars(b), 0) : 0);
+  return Math.ceil(chars / 4);
+}
+
+/**
+ * Clear old tool outputs in place when the conversation is large. Returns how many
+ * estimated tokens were freed (0 when nothing was worth clearing).
+ */
+export function clearOldToolResults(messages, { at = TRIM_AT, keep = KEEP_RECENT, atLeast = TRIM_AT_LEAST } = {}) {
+  if (conversationTokens(messages) < at) return 0;
+  const names = new Map();
+  for (const m of messages) {
+    if (m?.role === 'assistant' && Array.isArray(m.content)) for (const b of m.content) if (b?.type === 'tool_use') names.set(b.id, b.name);
+  }
+  const results = [];
+  for (const m of messages) {
+    if (m?.role !== 'user' || !Array.isArray(m.content)) continue;
+    m.content.forEach((b, i) => { if (b?.type === 'tool_result') results.push({ m, i, b }); });
+  }
+  const candidates = results.slice(0, Math.max(0, results.length - keep)).filter(({ b }) => {
+    const text = typeof b.content === 'string' ? b.content : '';
+    return text.length >= TRIM_MIN_CHARS && !text.startsWith(CLEARED);
+  });
+  const freed = Math.ceil(candidates.reduce((n, { b }) => n + blockChars(b), 0) / 4);
+  if (freed < atLeast) return 0;
+  for (const { m, i, b } of candidates) {
+    const chars = blockChars(b);
+    const name = names.get(b.tool_use_id) || 'this tool';
+    m.content[i] = { ...b, content: `${CLEARED}: ${name} returned ${chars.toLocaleString()} characters here, removed to keep the conversation small. Run it again if you need it.]` };
+  }
+  return freed;
+}
+
 export const IMAGE_BUDGET = 6_000_000;
 export function withinImageBudget(messages, budget = IMAGE_BUDGET) {
   let used = 0;
@@ -273,14 +332,16 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
   // — no message_stop, no stop reason — was cut, and used to be taken as a complete,
   // silent answer: the "it stops midway for no reason" bug.
   let sawStop = false;
-  const usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
+  // `credits` is what the gateway counted against the plan for this request — real cost,
+  // the one unit the plan, the dashboard and this CLI all show.
+  const usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0, credits: 0 };
   // Usage can arrive at the START of a stream (Anthropic-format providers) or only at
   // the END, in message_delta (OpenAI-format providers, translated by the gateway —
   // their usage exists only once generation finishes). Reading input from message_start
   // alone recorded every OpenAI-format turn as 0 input tokens.
   const takeUsage = (u) => {
     if (!u) return;
-    for (const k of ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens']) {
+    for (const k of ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens', 'credits']) {
       if (u[k] != null && Number.isFinite(Number(u[k]))) usage[k] = Number(u[k]);
     }
   };
@@ -395,7 +456,7 @@ export async function runAgent({
   client, messages, model, cwd, permissions, signal, tui = null,
   extraSystem = '', maxIterations = MAX_ITERATIONS, silent = false,
   onText = null, onEvent = null, systemOverride = null, journal = null,
-  subagents = true, onContext = null,
+  subagents = true, onContext = null, trimContext = true,
 }) {
   // Loop detection. A call is identified by its tool, its input, and how many files had
   // been changed when it was made — so edit → test → edit → test is progress (the count
@@ -404,7 +465,7 @@ export async function runAgent({
   const repeats = new Map();
   // input = fresh input, cached = prompt-cache reads (billed far cheaper), and
   // context = the real size of the last prompt sent, as the provider counted it.
-  const totals = { input: 0, cached: 0, output: 0, tools: 0, context: 0 };
+  const totals = { input: 0, cached: 0, output: 0, tools: 0, context: 0, credits: 0 };
   // Read once per request, not per turn: an agent that rewrites JAITUS.md mid-task
   // should not change the rules it is being judged by halfway through.
   // The model is told when it is in plan mode — it used to find out only by having its
@@ -438,6 +499,12 @@ export async function runAgent({
   let continuing = false;
 
   for (let iteration = 0; iteration < maxIterations; iteration++) {
+    // Old tool outputs are cleared once the conversation is large (see TRIM_AT) — in
+    // place, so the saved session shrinks too and the cache stays warm afterwards.
+    if (trimContext) {
+      const freed = clearOldToolResults(messages);
+      if (freed && tui?.notice) tui.notice(`Cleared old tool output (~${Math.round(freed / 1000)}k tokens) to keep each request small.`, 'info');
+    }
     let streamed = false;
     const spin = tui ? { stop: () => {}, update: () => {} } : (silent ? { stop: () => {}, update: () => {} } : spinner(glyph('Working…', 'Working...')));
     if (tui) tui.setStatus(`${c.brand(glyph('•', '*'))} ${c.brand(glyph('Working…', 'Working...'))}`);
@@ -532,6 +599,7 @@ export async function runAgent({
     totals.input += turn.usage.input_tokens || 0;
     totals.cached += (turn.usage.cache_read_input_tokens || 0) + (turn.usage.cache_creation_input_tokens || 0);
     totals.output += turn.usage.output_tokens || 0;
+    totals.credits += Number(turn.usage.credits) || 0;
     const promptSize = (turn.usage.input_tokens || 0) + (turn.usage.cache_read_input_tokens || 0) + (turn.usage.cache_creation_input_tokens || 0);
     if (promptSize) {
       totals.context = promptSize + (turn.usage.output_tokens || 0);
@@ -708,7 +776,8 @@ export async function runAgent({
         const done = `  ${toolMark(call.name)} ${c.dim(String(label).slice(0, 100))} ${c.dim(`· ${took}s`)}`;
         if (row) {
           tui.clearStatus();
-          row.update({ status: 'ok', took, preview: previewFor(call.name, output) });
+          // The whole output travels with the row (capped), so a click can open it.
+          row.update({ status: 'ok', took, preview: previewFor(call.name, output), full: String(output ?? '').slice(0, 200_000) });
         } else if (tui) { tui.clearStatus(); tui.print(done, 'tool'); } else if (!silent) out(done);
         tui?.recordActivity?.({ id: activityId, name: call.name, label, status: 'ok', detail: String(output).slice(0, 2000) });
         onEvent?.({ type: 'tool_result', name: call.name, input: call.input, ok: true, output });
@@ -761,7 +830,7 @@ export async function runAgent({
         const bad = `  ${c.red(glyph('✗', 'x'))} ${c.dim(String(label).slice(0, 80))} ${c.dim(`· ${took}s`)} — ${msg.slice(0, 120)}`;
         if (row) {
           tui.clearStatus();
-          row.update({ status: 'failed', took, error: msg.split('\n')[0].slice(0, 200), preview: msg.includes('\n') ? msg : '' });
+          row.update({ status: 'failed', took, error: msg.split('\n')[0].slice(0, 200), preview: msg.includes('\n') ? msg : '', full: msg.slice(0, 200_000) });
         } else if (tui) { tui.clearStatus(); tui.print(bad, 'tool'); } else if (!silent) out(bad);
         tui?.recordActivity?.({ id: activityId, name: call.name, label, status: 'failed', detail: msg.slice(0, 2000) });
         onEvent?.({ type: 'tool_result', name: call.name, input: call.input, ok: false, error: msg });

package/src/errors.js

@@ -18,7 +18,7 @@ const CATALOG = {
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },
   context_too_long: { title: 'Conversation too long', hint: 'Run /compact, or start a new session.' },
   request_too_large: { title: 'Request too large', hint: 'Usually images: remove some, or run /compact to drop old ones. Images over 3.5 MB are shrunk automatically.' },
-  daily_limit_reached: { title: 'Daily limit reached', hint: 'Your plan\'s daily allowance resets tomorrow. /usage shows where you are.' },
+  daily_limit_reached: { title: 'Daily limit reached', hint: 'Today\'s credits reset at midnight. /usage shows where you are.' },
   token_expired: { title: 'Signed out', hint: 'Type /login to sign in again (or run `jaitus login`).' },
   refresh_race: { title: 'Sign-in was being renewed', hint: 'Try again.' },
   content_blocked: { title: 'Request refused', hint: 'Rephrase the request and try again.' },

package/src/index.js

@@ -311,6 +311,17 @@ function requireAuth({ quiet = false } = {}) {
  */
 let activeTui = null;
 
+// Failures caused by the message itself: sending it again would fail again, so a turn
+// that failed this way is taken out of the conversation instead of kept with its error.
+const MESSAGE_FAULTS = new Set(['content_blocked', 'request_too_large', 'free_request_too_large', 'context_too_long', 'bad_request']);
+
+/** The typed text of a message, whatever its shape. */
+function textOfMessage(m) {
+  if (!m) return '';
+  if (typeof m.content === 'string') return m.content;
+  return (Array.isArray(m.content) ? m.content : []).filter((b) => b?.type === 'text').map((b) => b.text).join('\n');
+}
+
 function reportAgentError(e, context = {}) {
   const error = e instanceof Error ? e : new Error(String(e?.message ?? e ?? 'Unknown error'));
   if (activeTui?.error) {
@@ -789,7 +800,7 @@ async function session({ flags }) {
   // continues its count instead of starting again from zero.
   const saved = sessionState.spent || {};
   const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
-  const spent = { input: num(saved.input), cached: num(saved.cached), output: num(saved.output), tools: num(saved.tools), turns: num(saved.turns) };
+  const spent = { input: num(saved.input), cached: num(saved.cached), output: num(saved.output), tools: num(saved.tools), turns: num(saved.turns), credits: num(saved.credits) };
   sessionState.spent = spent;
   // The real size of the last prompt, as the provider counted it; 0 until one is known.
   let lastContext = num(sessionState.lastContext);
@@ -964,6 +975,7 @@ async function session({ flags }) {
         spent.input += result.input || 0;
         spent.cached += result.cached || 0;
         spent.output += result.output || 0;
+        spent.credits = Math.round(((spent.credits || 0) + (result.credits || 0)) * 100) / 100;
         spent.tools += result.tools || 0;
         try { tui?.setSpent?.(spent); } catch { /* header keeps last value */ }
       }
@@ -989,7 +1001,12 @@ async function session({ flags }) {
       const result = await runAgent({
         client, messages, model, cwd: flags.cwd, permissions, signal: ctrl.signal, tui, journal,
         onContext: (n) => { lastContext = n; sessionState.lastContext = n; showContext(); },
-        extraSystem: `${skillCatalog(skills)}\n\nCurrent intent: ${intentMode}. ${intentGuidance[intentMode]}${flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : ''}`,
+        // `jaitus config trimToolResults off` keeps every old tool output in context.
+        trimContext: loadSettings().trimToolResults !== false,
+        // What happened since the model's last turn (a failed request, an interrupt, a
+        // compaction, a blocked hook), told once. This was recorded all along and never
+        // read — the model never heard about any of it.
+        extraSystem: `${skillCatalog(skills)}\n\nCurrent intent: ${intentMode}. ${intentGuidance[intentMode]}${flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : ''}${ledger.drain()}`,
         systemOverride: flags.systemPrompt || null,
       });
       // An interrupted turn still spent what it spent before Esc — count it.
@@ -997,6 +1014,7 @@ async function session({ flags }) {
         spent.input += result.input || 0;
         spent.cached += result.cached || 0;
         spent.output += result.output || 0;
+        spent.credits = Math.round(((spent.credits || 0) + (result.credits || 0)) * 100) / 100;
         spent.tools += result.tools || 0;
         if (result.context) { lastContext = result.context; sessionState.lastContext = lastContext; }
       }
@@ -1026,9 +1044,21 @@ async function session({ flags }) {
       // that, its next turn begins as though nothing went wrong and it re-attempts the
       // thing that just failed.
       if (ctrl.signal.aborted) lastRunInterrupted = true;
+      const what = isJaitusError(e) ? `${e.title} — ${e.message}` : 'an unexpected error inside the CLI';
       if (messages.length === startLength && messages[messages.length - 1]?.role === 'user') {
-        messages.pop();
-        ledger.note('turn-failed', `A request to the gateway failed${e.status ? ` with HTTP ${e.status}` : ''}: ${e.message}. That turn was discarded and the user's message was not answered.`);
+        if (MESSAGE_FAULTS.has(e?.code)) {
+          // The message ITSELF was the problem (refused content, too large): sending it
+          // again with every later request would make every one of them fail too. It
+          // stays out, and the model is told what was asked and why it was rejected.
+          const failed = messages.pop();
+          const preview = e.code === 'content_blocked' ? '' : ` It began: "${textOfMessage(failed).replace(/\s+/g, ' ').slice(0, 240)}"`;
+          ledger.note('turn-failed', `The user's previous message got no answer: it was rejected (${what}) and removed from the conversation, because sending it again would fail again.${preview}`);
+        } else {
+          // Anything else — the network, a busy provider, a plan limit — says nothing
+          // about the message. It stays in the conversation, followed by what happened to
+          // it, so the model can see what was asked and pick it up.
+          messages.push({ role: 'assistant', content: `[No reply — this request failed: ${what}]` });
+        }
       } else {
         ledger.note('turn-failed', `A request to the gateway failed${e.status ? ` with HTTP ${e.status}` : ''} partway through the task: ${e.message}. The steps before it are kept; it did not finish.`);
       }
@@ -1698,7 +1728,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`],
+        [`  ${c.dim('session')}`, `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls${ctx.spent.credits ? ` · ${Math.round(ctx.spent.credits * 10) / 10} credits` : ''}`],
       ]);
       return null;
     }
@@ -1982,7 +2012,7 @@ async function slashCommand(verb, args, ctx) {
         // sessionState.spent and every reader hold this same object.
         const t = target.spent || {};
         const n = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
-        Object.assign(ctx.spent, { input: n(t.input), cached: n(t.cached), output: n(t.output), tools: n(t.tools), turns: n(t.turns) });
+        Object.assign(ctx.spent, { input: n(t.input), cached: n(t.cached), output: n(t.output), tools: n(t.tools), turns: n(t.turns), credits: n(t.credits) });
         ctx.resetContext?.();
         ctx.tui?.setSpent?.(ctx.spent);
         if (ctx.tui) replaySession(ctx.tui, target.messages);
@@ -2528,11 +2558,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) : '—'],
         ['  Input tokens', spent.input.toLocaleString()],
         ['  Cached input tokens', (spent.cached || 0).toLocaleString()],
         ['  Output tokens', spent.output.toLocaleString()],
       ]);
-      info(`${c.dim('Billed usage is what your account records — see')} ${c.bold('jaitus usage')}.`);
+      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.')}`);
       return null;
 
     case '/cwd':
@@ -2565,9 +2596,13 @@ 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']];
-  if (st?.monthlyTokens) {
+  // 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', `${fmtTokens(st.periodTokens)} of ${fmtTokens(st.monthlyTokens)} tokens${resets}`]);
+    rows.push(['This period', `${cr(st.periodCredits)} of ${cr(st.monthlyCredits)} credits${resets}`]);
+    if (st.dailyCredits) rows.push(['Today', `${cr(st.todayCredits)} of ${cr(st.dailyCredits)} credits · resets at midnight`]);
+    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;
@@ -2722,7 +2757,7 @@ const commands = {
       'jaitus config copyOnSelect <on|off>   auto-copy mouse selection',
     ],
     detail: [
-      'Settable: model, baseUrl, siteUrl, theme, copyOnSelect, scrollSpeed, wheelAccel, autoScroll, animations, autoCompact, mouse, statusLine,',
+      'Settable: model, baseUrl, siteUrl, theme, copyOnSelect, scrollSpeed, wheelAccel, autoScroll, animations, autoCompact, trimToolResults, mouse, statusLine,',
       'braveSearchKey, tavilyKey, serperKey. Stored in ~/.jaitus/settings.json.',
       '',
       'A search API key is the single biggest improvement available to web_search: the free',
@@ -2737,7 +2772,7 @@ const commands = {
       const unset = rest.length === 1 && /^(--unset|none|unset)$/i.test(rest[0]);
       const value = unset ? '' : rest.join(' ').trim();
       const settings = loadSettings();
-      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'mouse', 'autoUpdate'];
+      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'trimToolResults', 'mouse', 'autoUpdate'];
       const SECRET = ['braveSearchKey', 'tavilyKey', 'serperKey'];
       if (!key) {
         const e = endpoints();
@@ -2753,6 +2788,7 @@ const commands = {
           autoScroll: settings.autoScroll !== false,
           animations: settings.animations !== false,
           autoCompact: settings.autoCompact !== false,
+          trimToolResults: settings.trimToolResults !== false,
           mouse: settings.mouse !== false,
           // Presence and length only. A key echoed into a transcript is a key that has
           // been published, and the transcript is on disk.
@@ -2770,6 +2806,7 @@ const commands = {
           ['Auto-scroll', data.autoScroll ? 'on' : 'off'],
           ['Animations', data.animations ? 'on' : 'off'],
           ['Auto-compact', data.autoCompact ? 'on (summarises near the context limit)' : 'off'],
+          ['Trim old tool output', data.trimToolResults ? 'on (clears old outputs past ~100k tokens, keeps the last 6)' : 'off'],
           ['Mouse', data.mouse ? 'on (wheel scrolls, clicks act, drag or double-click copies)' : 'off (the terminal selects text itself)'],
           ['Search API', data.searchApi ? `${data.searchApi} (set)` : 'none — using free engines + npm/GitHub/MDN/Stack Overflow'],
           ['Status line', data.statusLine || '(unset — set a command to render one)'],

package/src/sessions.js

@@ -8,6 +8,7 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { SESSIONS } from './config.js';
 import { c } from './ui.js';
+import { unifiedDiff } from './diff.js';
 
 function safeId(id) {
   return String(id || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 80);
@@ -145,7 +146,9 @@ export function replaySession(tui, messages) {
     }
 
     if (m.role !== 'assistant') continue;
-    const blocks = Array.isArray(m.content) ? m.content : [];
+    // A plain-string assistant turn (a failed request's "[No reply — …]" note) was
+    // skipped entirely, as though the turn never happened.
+    const blocks = typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : Array.isArray(m.content) ? m.content : [];
     const text = blocks.filter((b) => b?.type === 'text' && b.text).map((b) => b.text).join('\n\n');
     if (text.trim()) {
       if (structured) tui.assistant(text); else tui.print(`${c.brand('◆')} ${text}`, 'assistant');
@@ -161,7 +164,25 @@ export function replaySession(tui, messages) {
           status: outcome ? (outcome.failed ? 'failed' : 'ok') : 'ok',
           file: call.input?.path,
           error: outcome?.failed ? outcome.text.split('\n')[0].slice(0, 200) : '',
+          // The whole result, so the row can be opened again after a resume.
+          full: outcome ? outcome.text.slice(0, 200_000) : '',
         });
+        // An edit reads back as the change it made. The file's full before/after is not
+        // in the conversation, but the replaced text and its replacement are.
+        if (!outcome?.failed && typeof tui.diff === 'function') {
+          const input = call.input || {};
+          try {
+            if (call.name === 'edit_file') {
+              const pairs = (Array.isArray(input.edits) ? input.edits : [input])
+                .filter((e) => typeof e?.old === 'string' && typeof e?.new === 'string');
+              const patch = pairs.map((e) => unifiedDiff(e.old, e.new, { file: input.path })).filter(Boolean).join('\n');
+              if (patch) tui.diff(String(input.path || 'edit'), patch);
+            } else if (call.name === 'write_file' && typeof input.content === 'string') {
+              const patch = unifiedDiff('', input.content, { file: input.path });
+              if (patch) tui.diff(String(input.path || 'file'), patch);
+            }
+          } catch { /* a missing diff never blocks the replay */ }
+        }
       } else {
         tui.print(`  ${c.accent('✓')} ${c.dim(`${call.name} ${label}`.slice(0, 100))}`, 'tool');
       }

package/src/tui/entries.js

@@ -167,8 +167,10 @@ const BUILDERS = {
     const style = styles[data.status] || styles.running;
     const icon = pick(TOOL_ICON[data.name] || ['⚙', '*']);
     const rows = [];
+    const openable = data.status !== 'running' && expandable(data);
 
     const head = [
+      ...(openable ? [{ t: `${pick(data.expanded ? ['▾', 'v'] : ['▸', '>'])} `, color: p.dim }] : []),
       { t: `${pick(style.mark)} `, color: style.color },
       { t: `${icon} `, color: data.status === 'ok' ? p.dim : style.color },
       { t: prettyName(data.name), color: data.status === 'failed' ? p.red : p.muted, bold: data.status === 'running' },
@@ -186,8 +188,8 @@ const BUILDERS = {
     }
 
     // A preview is a sample, never the whole output: a 4000-line test run in the
-    // transcript buries the answer that follows it.
-    const preview = previewLines(data);
+    // transcript buries the answer that follows it. A click on the row opens all of it.
+    const preview = data.expanded ? fullLines(data) : previewLines(data);
     if (preview.lines.length) {
       const language = data.name === 'run_command' ? 'sh' : languageForPath(data.file || data.label);
       let state = {};
@@ -198,7 +200,8 @@ const BUILDERS = {
         rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, ...truncateRow(spans, Math.max(8, width - 6))]);
       }
       if (preview.more > 0) {
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}`, color: p.faint, italic: true }]);
+        const hint = openable && !data.expanded ? ' — click the row to show all' : '';
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
       }
     }
     return rows;
@@ -211,8 +214,11 @@ const BUILDERS = {
     const lines = String(data.patch || '').split('\n');
     const added = lines.filter((l) => l.startsWith('+') && !l.startsWith('+++')).length;
     const removed = lines.filter((l) => l.startsWith('-') && !l.startsWith('---')).length;
+    const limit = data.expanded ? DIFF_OPEN_LINES : (data.max || 40);
+    const openable = lines.length > (data.max || 40);
 
     rows.push([
+      ...(openable ? [{ t: `${pick(data.expanded ? ['▾', 'v'] : ['▸', '>'])} `, color: p.dim }] : []),
       { t: `${pick(['◈', '~'])} `, color: p.brand },
       { t: String(data.file || 'diff'), color: p.body, bold: true },
       { t: '  ' },
@@ -222,7 +228,7 @@ const BUILDERS = {
     ]);
 
     const language = languageForPath(data.file);
-    const shown = lines.slice(0, data.max || 40);
+    const shown = lines.slice(0, limit);
     for (const line of shown) {
       if (/^(diff |index |--- |\+\+\+ )/.test(line)) continue;
       if (line.startsWith('@@')) {
@@ -241,7 +247,8 @@ const BUILDERS = {
       }
     }
     if (lines.length > shown.length) {
-      rows.push([{ t: '    ' }, { t: `… ${lines.length - shown.length} more lines`, color: p.faint, italic: true }]);
+      const hint = data.expanded ? '' : ' — click the file name to show all';
+      rows.push([{ t: '    ' }, { t: `… ${lines.length - shown.length} more lines${hint}`, color: p.faint, italic: true }]);
     }
     return rows;
   },
@@ -354,6 +361,30 @@ function bar(value, total, width) {
  * puts the command at the top and the failure at the bottom, and a build puts the error
  * last. Showing both ends beats showing the first twenty lines of a stack trace.
  */
+// How much an opened row shows. Enough for any real diff or test run; a 50,000-line
+// log is still a sample (the head and the tail), never the whole screen's worth of rows.
+const OPEN_LINES = 400;
+const DIFF_OPEN_LINES = 2000;
+
+/** Is there more behind this tool row than the collapsed view shows? */
+export function expandable(data) {
+  const full = String(data?.full ?? '').trimEnd();
+  if (!full) return false;
+  const shown = previewLines({ ...data, expanded: false });
+  const lines = full.split('\n').length;
+  return lines > shown.lines.length || (!shown.lines.length && full.length > 0);
+}
+
+/** An opened row: the whole output, or its head and tail past OPEN_LINES. */
+function fullLines(data) {
+  const raw = String(data.full ?? data.preview ?? '').replace(/\r\n?/g, '\n').trimEnd();
+  if (!raw) return { lines: [], more: 0 };
+  const all = raw.split('\n');
+  if (all.length <= OPEN_LINES) return { lines: all, more: 0 };
+  const head = Math.ceil(OPEN_LINES * 0.75);
+  return { lines: [...all.slice(0, head), ...all.slice(all.length - (OPEN_LINES - head))], more: all.length - OPEN_LINES };
+}
+
 function previewLines(data) {
   const raw = String(data.preview ?? data.detail ?? '').replace(/\r\n?/g, '\n').trimEnd();
   if (!raw) return { lines: [], more: 0 };

package/src/tui/widgets.js

@@ -160,6 +160,38 @@ export function Elapsed({ since, color, interval = 1000 }) {
   return h(Text, { color: color || p.dim }, label);
 }
 
+/**
+ * One composer line with the cursor drawn OVER the character at the cursor (inverse
+ * video, like a terminal's own block cursor) — never inserted between characters.
+ *
+ * The inserted glyph this replaced took a column of its own, so every character after
+ * the cursor moved one cell right as the cursor passed and back as it left ("the
+ * characters go left and right while I type"), and on a line that was exactly full the
+ * extra cell made the line re-wrap mid-typing. Here the width never changes: the cursor
+ * sits on the next character, or on the one spare column kept at the end of the line.
+ */
+export function CursorRow({ left = [], right = [], color }) {
+  const p = palette();
+  const active = motionOn();
+  const { frame } = useAnimation({ interval: 530, isActive: active });
+  const on = !active || frame % 2 === 0;
+  const rest = right.slice();
+  let under = ' ';
+  let underSpan = {};
+  if (rest.length) {
+    const first = { ...rest[0] };
+    const chars = Array.from(String(first.t));
+    under = chars[0] || ' ';
+    underSpan = first;
+    if (chars.length > 1) rest[0] = { ...first, t: chars.slice(1).join('') };
+    else rest.shift();
+  }
+  const cursor = on
+    ? { ...underSpan, t: under, inverse: !color, backgroundColor: color || undefined, color: color ? (p.name === 'light' ? '#ffffff' : '#000000') : underSpan.color }
+    : { ...underSpan, t: under };
+  return h(Row, { spans: [...left, cursor, ...rest] });
+}
+
 /** A block cursor that blinks. Off under reduced motion, where it stands solid. */
 export function Caret({ color, char = '▏' }) {
   const p = palette();

package/src/tui-ink.js

@@ -26,9 +26,9 @@ import path from 'node:path';
 import React from 'react';
 import { Box, Spacer, Text, render, useAnimation, useApp, useCursor, useInput, usePaste, useWindowSize } from 'ink';
 import { palette, resetPalette, mix, ramp } from './tui/theme.js';
-import { makeEntry, rowsFor, invalidate } from './tui/entries.js';
+import { makeEntry, rowsFor, invalidate, expandable } from './tui/entries.js';
 import { plain, stringWidth, truncateRow, wrapRow, rowText, inverseRange } from './tui/ansi.js';
-import { Spinner, Shimmer, GradientText, FlowingRule, Meter, Elapsed, Caret, Rows, Row, Reveal, motionOn, publishSettings } from './tui/widgets.js';
+import { Spinner, Shimmer, GradientText, FlowingRule, Meter, Elapsed, CursorRow, Rows, Row, Reveal, motionOn, publishSettings } from './tui/widgets.js';
 import { wordRows, wordSize } from './tui/wordmark.js';
 import { enableMouse, disableMouse, parseMouse, isMouse, isMouseFragment, createHitMap } from './tui/mouse.js';
 import { openUrl } from './open.js';
@@ -320,21 +320,25 @@ function Hero({ state, width, height }) {
 function layoutTranscript(state, width, height, top) {
   const inner = Math.max(24, width - 2);
   const rows = [];
+  // Which entry each row belongs to, and whether it is that entry's first row — so a
+  // click on a tool row's or a diff's header line can open or close it.
+  const owners = [];
   // Where each prompt starts, so the sticky header can name the one whose answer is
   // currently on screen rather than always the newest.
   const prompts = [];
   for (const entry of state.transcript) {
     const built = rowsFor(entry, inner);
     if (!built.length) continue;
-    if (rows.length) rows.push([]);
+    if (rows.length) { rows.push([]); owners.push(null); }
     if (entry.kind === 'user') prompts.push({ at: rows.length, text: String(entry.data.text || '') });
-    rows.push(...built);
+    built.forEach((row, i) => { rows.push(row); owners.push({ entry, head: i === 0 }); });
   }
   if (state.live && state.live.text) {
     const built = rowsFor(state.live.entry, inner);
     if (built.length) {
-      if (rows.length) rows.push([]);
+      if (rows.length) { rows.push([]); owners.push(null); }
       rows.push(...built);
+      for (let i = 0; i < built.length; i++) owners.push(null);
     }
   }
 
@@ -355,6 +359,7 @@ function layoutTranscript(state, width, height, top) {
   const end = rows.length - offset;
   const first = Math.max(0, end - height);
   const visible = rows.slice(first, end);
+  const visibleOwners = owners.slice(first, end);
   // Bottom-anchored: a short conversation sits at the composer, not floating at the top
   // of an empty screen with the input a dozen rows below it.
   const pad = Math.max(0, height - visible.length);
@@ -363,6 +368,7 @@ function layoutTranscript(state, width, height, top) {
   // The drag handler needs the text under the pointer, and it must be the text actually
   // on screen rather than the transcript's idea of it.
   state.screen = { top: screenTop, left: 2, rows: visible };
+  state.totalRows = rows.length;
 
   // The sticky header names the prompt whose answer you are looking at — the last one
   // that has scrolled off the top. Scroll far enough that the prompt itself is back on
@@ -370,7 +376,53 @@ function layoutTranscript(state, width, height, top) {
   const owning = prompts.filter((entry) => entry.at < first).at(-1);
   state.stickyPrompt = owning ? owning.text : '';
 
-  return { visible, pad, screenTop };
+  return { visible, pad, screenTop, owners: visibleOwners };
+}
+
+/** Can a click open this entry? A finished tool row with more behind it, or a long diff. */
+function openable(entry) {
+  if (!entry) return false;
+  if (entry.kind === 'tool') return entry.data.status !== 'running' && expandable(entry.data);
+  if (entry.kind === 'diff') return String(entry.data.patch || '').split('\n').length > (entry.data.max || 40);
+  return false;
+}
+
+/** The header line of every openable entry on screen is a click target. */
+function registerToggleHits(owners, screenTop, width, hits) {
+  if (!hits || !owners) return;
+  owners.forEach((owner, index) => {
+    if (!owner?.head || !openable(owner.entry)) return;
+    hits.add({ x1: 1, x2: width, y1: screenTop + index, y2: screenTop + index, action: { type: 'toggle', entry: owner.entry } });
+  });
+}
+
+/** Credits as the website writes them: 1,234 · 45.6 · 0.42. */
+export function fmtCredits(n) {
+  const v = Number(n) || 0;
+  if (v >= 1000) return Math.round(v).toLocaleString('en-IN');
+  if (v >= 10) return String(Math.round(v * 10) / 10);
+  return String(Math.round(v * 100) / 100);
+}
+
+/**
+ * Is this burst of input a paste rather than typing? True when a line break is followed
+ * by at least two more characters, or when it holds two or more line breaks outside a
+ * single \r\n pair. "abc\r" (typed fast, then Enter) is typing.
+ */
+export function isPasteBurst(text) {
+  const s = String(text || '');
+  const breaks = (s.replace(/\r\n/g, '\n').match(/[\r\n]/g) || []).length;
+  if (breaks >= 2) return true;
+  return /[\r\n][^\r\n\x1b]{2,}/.test(s);
+}
+
+/**
+ * The key that pastes an image here. Windows Terminal and VS Code keep Ctrl+V for their
+ * own text paste, so on Windows it is Alt+V; on macOS Cmd+V is the terminal's and Ctrl+V
+ * reaches the app (Option+V types "√" unless Option is set to act as Meta).
+ */
+export function imagePasteHint(platform = process.platform) {
+  return platform === 'win32' ? 'alt+v paste image' : 'ctrl+v paste image';
 }
 
 /**
@@ -572,19 +624,20 @@ function Composer({ state, width }) {
           // The caret sits AT the cursor. It used to be drawn after the whole line, so
           // moving left with the arrow keys showed no movement at all while typing went
           // in somewhere in the middle.
-          const [left, right] = index === caretLine ? splitSpansAt(row, caretCol) : [row, []];
-          return h(Box, { key: index, flexDirection: 'row' },
-          h(Row, { spans: left, wrap: 'wrap' }),
+          // One text run per line, the cursor drawn over the character at the cursor
+          // (CursorRow) — the line's width never changes as the cursor moves.
           // The caret is always present, including at an empty prompt. Hiding it there
           // was meant to keep it off the placeholder, but the result is a prompt with
           // no cursor at all — there is nothing on screen saying the app is waiting for
           // typing, which is the one thing a prompt has to say. The placeholder sits
           // AFTER the caret instead, so the caret is at the insertion point either way.
-          index === caretLine ? h(Caret, { color: p.brand, char: g('▏', '_') }) : null,
-          right.length ? h(Row, { spans: right, wrap: 'wrap' }) : null,
-          !state.input && index === 0
-            ? h(Text, { color: p.faint, italic: true, wrap: 'truncate-end' }, placeholder)
-            : null,
+          if (index !== caretLine) return h(Box, { key: index }, h(Row, { spans: row }));
+          const [left, right] = splitSpansAt(row, caretCol);
+          return h(Box, { key: index, flexDirection: 'row' },
+            h(CursorRow, { left, right, color: p.brand }),
+            !state.input && index === 0
+              ? h(Text, { color: p.faint, italic: true, wrap: 'truncate-end' }, placeholder)
+              : null,
           );
         }),
       ),
@@ -645,7 +698,9 @@ function composerLayout(state, width, spans = null) {
   const cursor = Math.max(0, Math.min(input.length, state.cursor ?? input.length));
   for (const para of paragraphs) {
     const text = para.map((s) => s.t).join('');
-    const rows = para.length ? wrapRow(para, width) : [[]];
+    // One column is kept spare for the cursor to sit on after a line's last character,
+    // so a full line never grows a cell when the cursor reaches its end.
+    const rows = para.length ? wrapRow(para, Math.max(4, width - 1)) : [[]];
     if (cursor >= start && cursor <= start + text.length) {
       let rowStart = start;
       let line = rows.length - 1;
@@ -704,7 +759,10 @@ function StatusBar({ state, width }) {
       : [
         ['ctrl+p palette', p.faint],
         ['shift+tab mode', p.faint],
-        ['ctrl+l clear', p.faint],
+        // How to paste a screenshot was written only in the README, and the key people
+        // try first (Ctrl+V in Windows Terminal, Cmd+V on a Mac) belongs to the terminal,
+        // which has no text to paste and sends the app nothing.
+        [imagePasteHint(), p.faint],
         ['esc esc rewind', p.faint],
         // Mouse reporting takes the terminal's own text selection away, so the way to
         // get it back has to be on screen — otherwise the first thing a new user
@@ -720,7 +778,12 @@ function StatusBar({ state, width }) {
   if (state.spent?.turns) {
     right.push({ t: `${state.spent.turns} turn${state.spent.turns === 1 ? '' : 's'}`, color: p.faint });
     right.push({ t: `  ${g('·', '|')}  `, color: p.faint });
-    right.push({ t: `${((state.spent.input || 0) + (state.spent.cached || 0) + (state.spent.output || 0)).toLocaleString()} tok`, color: p.faint });
+    // Credits — what the plan counts — when the gateway reports them. The raw token sum
+    // (input + cached + output) this used to show was ~20× the number the plan counted,
+    // for the same session, and matched neither the allowance nor the cost.
+    right.push(state.spent.credits
+      ? { t: `${fmtCredits(state.spent.credits)} credits`, color: p.faint }
+      : { t: `${((state.spent.input || 0) + (state.spent.cached || 0) + (state.spent.output || 0)).toLocaleString()} tok`, color: p.faint });
   }
   // The counter on the right keeps its width; the hints get what is left, with a gap.
   // Both used to shrink together, so the hints were cut off flush against the counter
@@ -1015,6 +1078,7 @@ function App({ controller }) {
     ? { visible: [], pad: 0, screenTop: transcriptTop + 1 }
     : layoutTranscript(state, width, transcriptHeight, transcriptTop);
   hits.add({ x1: 1, x2: width, y1: transcriptTop + 1, y2: transcriptTop + transcriptHeight, action: { type: 'transcript' } });
+  registerToggleHits(layout.owners, layout.screenTop, width, hits);
   registerLinkHits(layout.visible, layout.screenTop, hits);
   registerHeaderHits(state, width, hits);
   hits.add({ x1: 1, x2: width, y1: height, y2: height, action: { type: 'status' } });
@@ -1132,7 +1196,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     onLine: null, onEscape: null, onRewind: null, onCommand: null, onCopy: null, onModeCycle,
     debug: !!process.env.JAITUS_DEBUG, introDone: false,
     turnStartedAt: null, turnTokens: 0,
-    spent: { turns: 0, input: 0, cached: 0, output: 0 },
+    spent: { turns: 0, input: 0, cached: 0, output: 0, credits: 0 },
     meta: { model: 'loading…', mode: 'default', ctx: '0 tok', ctxUsed: 0, ctxMax: 1, intent: 'build', ...meta },
   };
 
@@ -1280,7 +1344,9 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
    */
   function handlePaste(text) {
     const value = String(text ?? '').replace(/\r\n?/g, '\n');
-    if (!value) return;
+    // An empty paste is what a terminal sends for its paste key when the clipboard holds
+    // only an image — it has no text to give. The image is right there: fetch it.
+    if (!value) { void pasteFromClipboard({ imageOnly: true }); return; }
     // Dragging image files onto the terminal pastes their paths: attach them instead.
     const images = imagePathsIn(value);
     if (images) { void attachImageFiles(images); return; }
@@ -1323,7 +1389,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         await attachImageFiles([file], { name: 'clipboard image' });
         return;
       }
-      flash(imageOnly ? 'No image on the clipboard' : 'The clipboard is empty', 'info', 1600);
+      flash(imageOnly ? 'No image on the clipboard — copy a screenshot first' : `The clipboard is empty · ${imagePasteHint()}`, 'info', 1800);
     } catch {
       flash('Could not read the clipboard', 'warn', 2000);
     } finally {
@@ -1664,6 +1730,26 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         return;
       case 'status':
         return openPalette();
+      case 'toggle': {
+        // Open or close a tool row / diff. Everything it adds or removes is BELOW the
+        // header, and the scroll offset counts rows up from the bottom — so the offset
+        // moves by exactly that much and the header stays under the pointer.
+        const entry = region.action.entry;
+        const inner = Math.max(24, (state._width || process.stdout.columns || 80) - 2);
+        const rowsOf = () => rowsFor(entry, inner).length;
+        const before = rowsOf();
+        entry.data.expanded = !entry.data.expanded;
+        entry._w = -1;
+        entry._rows = null;
+        const delta = rowsOf() - before;
+        if (delta !== 0) {
+          state.viewingTranscript = true;
+          state.transcriptOffset = Math.max(0, (state.transcriptOffset || 0) + delta);
+        }
+        clearTimeout(returnToLiveTimer);
+        notifyNow();
+        return;
+      }
       case 'transcript':
         // A click in the body is how you get back to the live end after scrolling.
         // Deferred, and cancelled by a second click: a double-click to select a word
@@ -1841,6 +1927,16 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     // Fast PTYs on Windows deliver a typed line and its carriage return in one chunk.
     // Split here or the return becomes a literal character in the composer.
     const newlineAt = String(input || '').search(/[\r\n]/);
+    // A paste the terminal did not mark as one (no bracketed-paste codes — some Windows
+    // consoles, SSH, right-click paste in older hosts) arrives as a burst with a return
+    // at every line end, and each return used to SEND: pasting a 17-line error log sent
+    // 16 messages in a few seconds (seen in production, all refused). A person never
+    // types a return and then more text inside one burst; a paste always does. So a
+    // burst with text after a line break, or several line breaks, is a paste.
+    if (newlineAt >= 0 && isPasteBurst(String(input))) {
+      handlePaste(String(input).replace(/[\r\n]+$/, ''));
+      return notifyNow();
+    }
     if (newlineAt >= 0) {
       const text = String(input);
       const typed = text.slice(0, newlineAt);