jaitus 0.3.6 → 0.3.8

package/src/index.js

@@ -17,7 +17,7 @@ import {
   endpoints, version, HOME, HISTORY,
 } from './config.js';
 import { runAgent, repairToolPairs } from './agent/loop.js';
-import { createPermissions } from './agent/permissions.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';
 import { shrinkImageFile } from './tui/clipboard.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) {
@@ -361,6 +372,11 @@ async function loadContextBudget(client) {
 // Compact at this fraction of the budget. Low enough that the summarisation request
 // itself still fits comfortably, high enough that a normal session never sees it.
 const AUTO_COMPACT_AT = 0.78;
+// The budget is what the gateway advertises — the providers' limit, or the admin's
+// Context cap when it is lower (Admin → Settings → Plans & credits). That cap is the ONE
+// control for how big a session gets before it is summarised: a second ceiling here
+// would silently override whatever the admin set.
+const compactThreshold = () => CONTEXT_BUDGET * AUTO_COMPACT_AT;
 
 // An expanded @mention is capped: pulling a 4 MB lockfile into the prompt because
 // someone typed `@package-lock.json` would blow the context it is meant to save.
@@ -410,8 +426,20 @@ async function summarise(client, model, messages, focus) {
     messages: [
       {
         role: 'user',
-        content: 'Summarize this conversation compactly for a successor agent: what was asked, '
-          + 'what was done (files changed, commands run, outcomes), what remains. Be specific and terse.'
+        // Sections a successor needs to carry on without re-asking or re-reading — the
+        // same structure agent tools use for their own compaction. Losing the user's
+        // exact instructions or where the work stopped is what makes a compacted session
+        // feel worse; everything else can be re-read from disk.
+        content: 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
+          + 'Use these headings, and be specific (paths, names, numbers) rather than general:\n'
+          + '1. Request — what the user asked for, with their exact words for any instruction, constraint or preference.\n'
+          + '2. Corrections — anything the user rejected, corrected or asked to do differently, verbatim where short.\n'
+          + '3. Files — every file read or changed: path, what changed or what matters in it.\n'
+          + '4. Commands and results — what was run and what it showed (test/build results, errors and how each was fixed).\n'
+          + '5. Decisions — what was chosen and why.\n'
+          + '6. Current state — exactly what was being done when this summary was made, and what is unfinished.\n'
+          + '7. Next step — the single next action, if the work was mid-way.\n'
+          + 'Omit headings that have nothing. No preamble.'
           + (focus ? ` Focus on: ${focus}.` : '')
           + `\n\n<conversation>\n${transcriptForSummary(messages)}\n</conversation>`,
       },
@@ -491,6 +519,37 @@ function projectRules(cwd) {
   return { allow: Array.isArray(saved.allow) ? saved.allow : [], deny: Array.isArray(saved.deny) ? saved.deny : [] };
 }
 
+/** The bypass confirmation, wherever bypass is switched on from. */
+const BYPASS_CHOICES = [
+  { label: 'Yes, for this session', value: 'y' },
+  { label: 'Yes, and start every new session in bypass', value: 'always' },
+  { label: 'No, stay put', value: 'n' },
+];
+const BYPASS_WARNING = [
+  'Writes and shell commands will run with NO permission prompts.',
+  'Use only in a trusted workspace you can afford to rebuild. Deny rules still apply.',
+];
+
+/** The mode every new session starts in; null goes back to "the last one used". */
+function saveDefaultMode(mode) {
+  const settings = loadSettings();
+  if (mode) settings.defaultMode = mode;
+  else delete settings.defaultMode;
+  saveSettings(settings);
+}
+
+/**
+ * What to say beside a mode when a saved rule already approves a whole tool here —
+ * otherwise "Ask" is on screen while every command runs unasked, and the modes look
+ * like they do nothing.
+ */
+function wideRuleNote(permissions, mode) {
+  if (mode === 'plan' || mode === 'bypassPermissions') return '';
+  const wide = permissions?.wide || [];
+  if (!wide.length) return '';
+  return `Saved rule ${wide.join(', ')} skips the permission question in every mode here — /permissions forget ${wide[0]} to let the mode decide.`;
+}
+
 /** The key rules are saved under: the existing spelling when there is one. */
 function rulesKey(cwd) {
   return Object.keys(loadSettings().permissionRules || {}).find((k) => sameDir(k, cwd)) || path.resolve(cwd);
@@ -536,8 +595,11 @@ async function oneShot(task, { flags }) {
   messages.push({ role: 'user', content: task });
 
   const explicitPlan = flags.permissionModeExplicit && flags.permissionMode === 'plan';
+  // The saved default mode applies here too — "every session" includes `jaitus -p`.
+  const savedDefault = loadSettings().defaultMode;
+  const oneShotMode = !flags.permissionModeExplicit && PERMISSION_MODES.includes(savedDefault) ? savedDefault : flags.permissionMode;
   const permissions = createPermissions({
-    autoApprove: flags.yes && !explicitPlan, mode: flags.permissionMode,
+    autoApprove: flags.yes && !explicitPlan, mode: oneShotMode,
     interactive: false, ...projectRules(flags.cwd),
   });
 
@@ -547,7 +609,7 @@ async function oneShot(task, { flags }) {
       ...(flags.maxTurns ? { maxIterations: flags.maxTurns } : {}),
       silent: true,
       systemOverride: flags.systemPrompt || null,
-      extraSystem: flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : '',
+      extraSystem: `${skillCatalog(discoverSkills(flags.cwd))}${flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : ''}`,
       onText: (text) => {
         answer += text;
         if (format === 'stream-json') out(JSON.stringify({ type: 'content_block_delta', delta: { text } }));
@@ -602,7 +664,7 @@ const SLASH = {
   '/tasks': { summary: 'review tool activity from this session' },
   '/image <path>': { summary: 'attach an image (png/jpg/gif/webp) the model will see with your next message' },
   '/memory [text]': { summary: 'show or append to JAITUS.md (# does this inline)' },
-  '/permissions [mode|rules]': { summary: 'permission mode, and the allow/deny rules for this project' },
+  '/permissions [mode|rules|default]': { summary: 'permission mode, the mode new sessions start in, and the allow/deny rules for this project' },
   '/skills': { summary: 'list project workflows' },
   '/sessions': { summary: 'list saved sessions in this directory' },
   '/session': { summary: 'show this session id', hidden: true },  // the id is already in /status
@@ -767,11 +829,21 @@ async function session({ flags }) {
   // flag used to be overridden by it, so after one Shift+Tab `--permission-mode plan`
   // started a session that edited files without asking. Plan (often set by /ask or
   // /plan, not chosen) and bypass never carry into a new session on their own.
-  const lastMode = loadSettings().lastMode;
-  if (lastMode && !flags.yes && !flags.permissionModeExplicit && ['default', 'acceptEdits'].includes(lastMode)) permissions.setMode(lastMode);
+  // A saved default mode (`/permissions default <mode>`, or "Yes, every session" on the
+  // bypass prompt) is a choice made once, on purpose, and it wins over the last mode:
+  // turning bypass on in every new chat was the thing people had to repeat.
+  const startSettings = loadSettings();
+  const defaultMode = PERMISSION_MODES.includes(startSettings.defaultMode) ? startSettings.defaultMode : null;
+  const lastMode = startSettings.lastMode;
+  if (!flags.yes && !flags.permissionModeExplicit) {
+    if (defaultMode) permissions.setMode(defaultMode);
+    else if (['default', 'acceptEdits'].includes(lastMode)) permissions.setMode(lastMode);
+  }
+  const bypassIsDefault = defaultMode === 'bypassPermissions' && !flags.permissionModeExplicit;
   // Starting straight into bypass gets one explicit confirmation (§11) when a
-  // human is present; headless runs just get the warning on stderr.
-  if (permissions.mode === 'bypassPermissions' && !flags.yes) {
+  // human is present; headless runs just get the warning on stderr. A saved bypass
+  // default was confirmed when it was saved and is not asked again.
+  if (permissions.mode === 'bypassPermissions' && !flags.yes && !bypassIsDefault) {
     if (process.stdin.isTTY && process.stdout.isTTY) {
       out(`\n  ${c.red(c.bold('● BYPASS'))} ${c.red('requested — writes and shell commands would run with no permission checks.')}`);
       const answer = await askKey(`  ${c.dim(`Enable bypass mode for this session? [y/N] ${glyph('›', '>')}`)} `, ['y', 'n', '\r', ' ']);
@@ -789,7 +861,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);
@@ -862,17 +934,15 @@ async function session({ flags }) {
       const order = ['default', 'acceptEdits', 'plan', 'bypassPermissions'];
       const next = order[(order.indexOf(permissions.mode) + 1) % order.length];
       if (next === 'bypassPermissions') {
-        const ans = await tui.askDialog('Enable bypass mode?', [
-          { label: 'Yes, skip all checks', value: 'y' },
-          { label: 'No, stay put', value: 'n' },
-        ], [
-          'Writes and shell commands will run with NO permission prompts.',
-          'Use only in a trusted workspace you can afford to rebuild.',
-        ]);
-        if (dialogValue(ans) !== 'y') return permissions.mode;
+        const ans = await tui.askDialog('Enable bypass mode?', BYPASS_CHOICES, BYPASS_WARNING);
+        const picked = dialogValue(ans);
+        if (picked !== 'y' && picked !== 'always') return permissions.mode;
+        if (picked === 'always') saveDefaultMode('bypassPermissions');
       }
       const m = permissions.cycleMode();
       refreshStatusLine('mode');
+      const note = wideRuleNote(permissions, m);
+      if (note) tui.flash?.(note, 'warn', 4500);
       return m;
     },
   };
@@ -964,6 +1034,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 +1060,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 +1073,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 +1103,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.`);
       }
@@ -1079,7 +1168,7 @@ async function session({ flags }) {
   const autoCompactIfNeeded = async () => {
     if (loadSettings().autoCompact === false) return;
     const used = estimateTokens(messages);
-    if (used < CONTEXT_BUDGET * AUTO_COMPACT_AT) return;
+    if (used < compactThreshold()) return;
     if (messages.length < 4) return;
 
     tui.setStatus?.(`Compacting — ${format(used)} of ${format(CONTEXT_BUDGET)} context used`);
@@ -1396,6 +1485,15 @@ async function session({ flags }) {
     showContext();
     tui.setSpent?.(spent);
     refreshStatusLine('start');
+    // 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.' : '',
+      wideRuleNote(permissions, permissions.mode),
+    ].filter(Boolean);
+    // The welcome screen hides transcript notices until the first message, so the status
+    // line carries them at start; the notice keeps the record in the transcript.
+    for (const note of startNotes) { if (tui.notice) tui.notice(note, 'warn'); else tui.print(c.yellow(`  ${note}`)); }
+    if (startNotes.length) tui.flash?.(startNotes.join('  ·  '), 'warn', 9000);
 
     /** Esc+Esc: pick a checkpoint, restore the conversation and the files. */
     const doRewind = async () => {
@@ -1698,7 +1796,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;
     }
@@ -1861,17 +1959,15 @@ async function slashCommand(verb, args, ctx) {
       const applyMode = async (next) => {
         const real = next === 'auto' ? 'bypassPermissions' : next;
         if ((real === 'bypassPermissions') && ctx.tui && ctx.permissions.mode !== 'bypassPermissions') {
-          const ans = await ctx.tui.askDialog('Enable bypass mode?', [
-            { label: 'Yes, skip all checks', value: 'y' },
-            { label: 'No, stay put', value: 'n' },
-          ], [
-            'Writes and shell commands will run with NO permission prompts.',
-            'Use only in a trusted workspace you can afford to rebuild.',
-          ], { title: 'Bypass mode', hideComment: true });
-          if (dialogValue(ans) !== 'y') { info(`Staying in ${c.bold(ctx.permissions.mode)}.`); return; }
+          const ans = await ctx.tui.askDialog('Enable bypass mode?', BYPASS_CHOICES, BYPASS_WARNING, { title: 'Bypass mode', hideComment: true });
+          const picked = dialogValue(ans);
+          if (picked !== 'y' && picked !== 'always') { info(`Staying in ${c.bold(ctx.permissions.mode)}.`); return; }
+          if (picked === 'always') { saveDefaultMode('bypassPermissions'); ok('Bypass is now the default for every new session — /permissions default ask undoes it.'); }
         }
         ctx.permissions.setMode(real);
         ok(`Permission mode: ${c.bold(next)}`);
+        const note = wideRuleNote(ctx.permissions, real);
+        if (note) warn(note);
         if (real === 'bypassPermissions') warn('The agent will not ask before writing files or running commands.');
         if (next === 'plan') info('The agent can read and think, but nothing runs until you switch out of plan mode.');
       };
@@ -1880,6 +1976,27 @@ async function slashCommand(verb, args, ctx) {
       // shows what has accumulated, which matters because "always allow" writes to
       // disk and a list nobody can read is a list nobody can revoke.
       const next = args[0];
+      // ── the mode every new session starts in ──
+      if (next === 'default' && args.length > 1 || next === 'startup') {
+        const wanted = normaliseMode(args[1]) || (/^(off|none|last|unset)$/i.test(args[1] || '') ? 'off' : null);
+        if (!wanted) {
+          const current = loadSettings().defaultMode;
+          info(`New sessions start in ${c.bold(current || 'the last mode used (ask or auto-edit)')}.`);
+          info(`${c.dim('Change it with')} ${c.bold('/permissions default bypass')}${c.dim(', ask, acceptEdits, plan — or off.')}`);
+          return null;
+        }
+        if (wanted === 'bypassPermissions' && ctx.tui && loadSettings().defaultMode !== 'bypassPermissions') {
+          const ans = await ctx.tui.askDialog('Start every new session in bypass?', [
+            { label: 'Yes, every session', value: 'y' },
+            { label: 'No', value: 'n' },
+          ], BYPASS_WARNING, { title: 'Bypass mode', hideComment: true });
+          if (dialogValue(ans) !== 'y') { info('Unchanged.'); return null; }
+        }
+        saveDefaultMode(wanted === 'off' ? null : wanted);
+        ok(wanted === 'off' ? 'New sessions start in the last mode used (ask or auto-edit).' : `New sessions start in ${c.bold(wanted)}.`);
+        if (wanted !== 'off' && ctx.permissions.mode !== wanted) info(`This session stays in ${c.bold(ctx.permissions.mode)} — Shift+Tab or /permissions ${wanted} to switch now.`);
+        return null;
+      }
       if (next === 'rules' || next === 'allow' || next === 'deny' || next === 'forget') {
         const { parseRule } = await import('./agent/rules.js');
         if (next === 'rules') {
@@ -1912,8 +2029,10 @@ async function slashCommand(verb, args, ctx) {
       }
 
       if (next) {
-        if (!Object.keys(MODES).concat('auto').includes(next)) { warn(`Unknown mode: ${next}. Try a mode, or ${c.bold('/permissions rules')}.`); return null; }
-        await applyMode(next);
+        // `bypass`, `ask`, `auto-edit` are what the badge says; they are modes too.
+        const named = normaliseMode(next);
+        if (!named) { warn(`Unknown mode: ${next}. Try ask, acceptEdits, plan, bypass — or ${c.bold('/permissions rules')}.`); return null; }
+        await applyMode(named);
         return null;
       }
       if (!ctx.tui) {
@@ -1982,7 +2101,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 +2647,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 +2685,18 @@ 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.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;
@@ -2720,9 +2849,10 @@ const commands = {
       'jaitus config theme <name>       dark, light, ocean, daltonized, auto',
       'jaitus config <key> --unset      back to the default',
       'jaitus config copyOnSelect <on|off>   auto-copy mouse selection',
+      'jaitus config defaultMode bypass      start every session in bypass (ask, acceptEdits, plan; --unset = last mode used)',
     ],
     detail: [
-      'Settable: model, baseUrl, siteUrl, theme, copyOnSelect, scrollSpeed, wheelAccel, autoScroll, animations, autoCompact, mouse, statusLine,',
+      'Settable: model, baseUrl, siteUrl, theme, defaultMode, 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 +2867,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();
@@ -2746,6 +2876,7 @@ const commands = {
           website: e.siteUrl,
           model: settings.model || null,
           theme: settings.theme || 'auto',
+          defaultMode: settings.defaultMode || null,
           statusLine: settings.statusLine || null,
           copyOnSelect: settings.copyOnSelect !== false,
           scrollSpeed: settings.scrollSpeed ?? 1,
@@ -2753,6 +2884,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.
@@ -2764,12 +2896,14 @@ const commands = {
           ['Website', data.website],
           ['Model', data.model || 'whatever the gateway lists first'],
           ['Theme', `${data.theme} (${[...THEME_NAMES, 'auto'].join(', ')})`],
+          ['Start mode', data.defaultMode || 'the last mode used (ask or auto-edit)'],
           ['Copy on select', data.copyOnSelect ? 'on (drag selects, auto-copies)' : 'off (Ctrl+Shift+C copies)'],
           ['Scroll speed', String(data.scrollSpeed)],
           ['Wheel accel', data.wheelAccel ? 'on' : 'off'],
           ['Auto-scroll', data.autoScroll ? 'on' : 'off'],
           ['Animations', data.animations ? 'on' : 'off'],
-          ['Auto-compact', data.autoCompact ? 'on (summarises near the context limit)' : 'off'],
+          ['Auto-compact', data.autoCompact ? 'on (summarises at 78% of the context size the service allows)' : 'off'],
+          ['Trim old tool output', data.trimToolResults ? 'on (clears old outputs past ~40k 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)'],
@@ -2777,13 +2911,13 @@ const commands = {
         ]));
         return 0;
       }
-      if (!['model', 'baseUrl', 'siteUrl', 'theme', 'statusLine', ...ONOFF, ...SECRET, 'scrollSpeed'].includes(key)) {
-        fail(`Unknown setting: ${key}. Try model, baseUrl, siteUrl, theme, statusLine, ${ONOFF.join(', ')}, ${SECRET.join(', ')} or scrollSpeed.`);
+      if (!['model', 'baseUrl', 'siteUrl', 'theme', 'defaultMode', 'statusLine', ...ONOFF, ...SECRET, 'scrollSpeed'].includes(key)) {
+        fail(`Unknown setting: ${key}. Try model, baseUrl, siteUrl, theme, defaultMode, statusLine, ${ONOFF.join(', ')}, ${SECRET.join(', ')} or scrollSpeed.`);
         return 1;
       }
       // Clearing a value (there was no way: an empty value just printed the current one).
       if (unset) {
-        if (!['model', 'baseUrl', 'siteUrl', 'statusLine', 'theme', 'scrollSpeed', ...SECRET].includes(key)) { fail(`${key} is on/off — set it with on or off.`); return 1; }
+        if (!['model', 'baseUrl', 'siteUrl', 'statusLine', 'theme', 'defaultMode', 'scrollSpeed', ...SECRET].includes(key)) { fail(`${key} is on/off — set it with on or off.`); return 1; }
         delete settings[key];
         saveSettings(settings);
         ok(`${key} cleared — back to the default.`);
@@ -2799,6 +2933,15 @@ const commands = {
         if (key === 'scrollSpeed') { out(String(settings.scrollSpeed ?? 1)); return 0; }
         out(String(settings[key] ?? '')); return 0;
       }
+      if (key === 'defaultMode') {
+        const mode = normaliseMode(value);
+        if (!mode) { fail('Use ask, acceptEdits, plan or bypass (or --unset for the last mode used).'); return 1; }
+        settings.defaultMode = mode;
+        saveSettings(settings);
+        ok(`defaultMode = ${mode} — every new session starts in it`);
+        if (mode === 'bypassPermissions') warn('Writes and shell commands will run with no permission prompts in every session. Deny rules still apply.');
+        return 0;
+      }
       if (key === 'theme') {
         // The themes that exist (ocean was refused; plain was accepted and did nothing).
         const names = [...THEME_NAMES, 'auto'];

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/skills/builtin/documents/SKILL.md

@@ -0,0 +1,91 @@
+---
+description: Load BEFORE making a PDF or any printable/shareable document — report, proposal, invoice, resume/CV, letter, certificate, brochure, one-pager, handout, slide deck. Produces typeset, professional documents instead of plain text dumps.
+---
+
+# Professional documents and PDFs
+
+The reliable route is: **write semantic HTML with print CSS, then print it to PDF with a
+headless browser.** It gives real typography, exact page control and is easy to revise.
+Use a PDF library (reportlab, pdfkit, jsPDF) only if the project already uses one.
+
+## 1. Plan the document
+
+- What is it, who reads it, and what must they do after reading? Put that first.
+- Pick a document direction that fits: corporate report (clean sans, blue-black ink, one
+  accent, data tables) · editorial/proposal (serif body, generous margins, pull quotes) ·
+  modern minimal (one sans, lots of white, strong headings) · formal letter/certificate
+  (centred serif, restrained ornament) · resume (dense but calm, two-column, no graphics
+  that ATS software cannot read).
+- Outline the sections before writing; every page should have one clear purpose.
+
+## 2. Page setup (print CSS)
+
+```css
+@page { size: A4; margin: 20mm 18mm 22mm; }            /* or: size: Letter; */
+@page :first { margin-top: 0; }                          /* full-bleed cover if wanted */
+html { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+body { font: 10.5pt/1.55 "Source Serif 4", Georgia, serif; color: #1b1d22; }
+h1, h2, h3 { font-family: "Inter Tight", "Helvetica Neue", Arial, sans-serif; line-height: 1.15; break-after: avoid; }
+h2 { break-before: auto; margin: 18pt 0 6pt; }
+table, figure, blockquote, .card { break-inside: avoid; }
+p { orphans: 3; widows: 3; }
+.page-break { break-before: page; }
+a { color: inherit; text-decoration: none; border-bottom: 0.5pt solid currentColor; }
+```
+
+- Use pt/mm for print, never viewport units. Body 10–11.5pt, headings on a scale
+  (e.g. 10.5 · 13 · 16 · 22 · 32pt). Line length ~65–80 characters; wide pages use two
+  columns (`columns: 2; column-gap: 8mm;`) or a wide margin column for notes.
+- Colour: dark ink on white, ONE accent colour for headings rules, key numbers and table
+  headers, tinted greys for secondary text. Keep it printable in greyscale.
+- Page numbers / running footer: put a footer element on each page section, or when the
+  browser supports it use `@page { @bottom-right { content: counter(page) " / " counter(pages); } }`.
+
+## 3. Typesetting details that make it look professional
+
+- A proper cover or title block: title, subtitle, author/organisation, date — aligned to a
+  grid, not just a big centred heading.
+- Consistent vertical rhythm: spacing in multiples of the body line height.
+- Tables: left-align text, right-align numbers with tabular figures
+  (`font-variant-numeric: tabular-nums`), light horizontal rules only, a bold or tinted
+  header row, units in the header, totals row emphasised. No full grid of borders.
+- Numbers: thousands separators, consistent decimals, currency symbols (₹ 1,49,900 for
+  Indian format when the audience is Indian).
+- Callouts/key figures as a small highlighted block, not colourful boxes everywhere.
+- Charts: inline SVG (or Chart.js rendered before printing) with direct labels, no 3D, no
+  heavy gridlines, the accent colour for the series that matters and grey for the rest.
+- Real content — no lorem ipsum, no "[Your Name]" left in unless it is a template.
+- Invoices: seller/buyer blocks, invoice number, dates, line items table, tax lines, total,
+  payment details and terms — every legally expected field for the country.
+- Resumes: name large, contact on one line, sections in a clear order, consistent date
+  alignment on the right, verbs and numbers in bullets, one page unless senior.
+
+## 4. Render to PDF
+
+Save the HTML (e.g. `report.html`) and print it with whichever browser is installed:
+
+```sh
+# Windows (Edge ships with Windows)
+"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --headless --disable-gpu --no-pdf-header-footer --print-to-pdf="report.pdf" "file:///C:/path/to/report.html"
+# Chrome (any OS)
+chrome --headless --disable-gpu --no-pdf-header-footer --print-to-pdf=report.pdf file:///abs/path/report.html
+# macOS Chrome
+"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless --no-pdf-header-footer --print-to-pdf=report.pdf file:///abs/path/report.html
+```
+
+If the project has Node and Playwright or Puppeteer, `page.pdf({ format: 'A4',
+printBackground: true, preferCSSPageSize: true })` works the same. Web fonts must finish
+loading before printing — with a headless browser add `--virtual-time-budget=5000`, or
+embed the fonts locally.
+
+## 5. Check before handing over
+
+1. The PDF exists and opens; report its path and page count.
+2. No heading stranded at the bottom of a page, no table row split, no blank last page.
+3. Margins are even, nothing clipped at the edges, backgrounds printed.
+4. Hierarchy is obvious at a glance; one accent colour; consistent spacing.
+5. All placeholder text replaced; numbers, dates and names are correct.
+
+For slide decks: one idea per slide, 16:9 (`@page { size: 297mm 167mm; margin: 0 }` with
+one `section` per slide), a big headline that states the point, at most ~30 words of body,
+visual consistency across slides, and slide numbers.