jaitus 0.3.16 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "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/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.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/service-notices.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 && node tests/compaction.js && node tests/copy-clean.js && node tests/parallel-tools.js",
+    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.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/service-notices.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 && node tests/compaction.js && node tests/copy-clean.js && node tests/parallel-tools.js && node tests/plan-percent.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/compact.js

@@ -1,224 +1,286 @@
-// ─── Compaction: summarising a conversation so it fits again ──────────────────────
-//
-// Shared by /compact, automatic compaction between prompts, compaction between the
-// steps of one long task, and the automatic recovery from "too large / too long".
-//
-// The one rule: the summary request itself must always fit. It used to carry up to
-// 360,000 characters of transcript whatever the model's window was, with pasted text and
-// @mentions unclipped — so on exactly the sessions that needed it, /compact failed with
-// the same "too long" error it was meant to cure, and the history stayed as it was.
-// Now the transcript is sized from the window the gateway advertises, a session bigger
-// than that is summarised in parts (each part folded into the summary so far), and a
-// refused summary request is retried with half as much.
-
-import { streamTurn } from './agent/loop.js';
-import { JaitusError } from './errors.js';
-
-/** Errors that mean "this request is too big" — the ones compaction can cure. */
-export const SIZE_FAULTS = new Set(['context_too_long', 'request_too_large']);
-
-/** Rough token estimate — ~4 characters per token of English. */
-export function estimateTokens(messages) {
-  let chars = 0;
-  for (const m of messages || []) {
-    if (typeof m.content === 'string') chars += m.content.length;
-    else if (Array.isArray(m.content)) {
-      for (const b of m.content) {
-        if (b.type === 'text') chars += (b.text || '').length;
-        else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length;
-        else if (b.type === 'tool_result') {
-          chars += typeof b.content === 'string' ? b.content.length
-            : Array.isArray(b.content) ? b.content.reduce((n, c) => n + (c?.text?.length || (c?.type === 'image' ? 6000 : 0)), 0) : 0;
-        } else if (b.type === 'image') chars += 6000; // ~1.5k tokens, what providers count for one
-      }
-    }
-  }
-  return Math.ceil(chars / 4);
-}
-
-/** How many characters of transcript one summary request may carry for this window. */
-export function summaryBudgetChars(contextTokens) {
-  const window = Number(contextTokens) > 0 ? Number(contextTokens) : 128_000;
-  // Half the window for the transcript (≈ 2 characters per token of window, code and
-  // JSON tokenise denser than prose), the rest for the instructions, the reply and the
-  // gateway's own system prompt. Bounded: a 1M window does not need a 2 MB request.
-  return Math.max(20_000, Math.min(240_000, Math.floor(window * 2)));
-}
-
-const clip = (s, n) => (s.length > n ? `${s.slice(0, n)}… [${s.length - n} more characters left out]` : s);
-
-/**
- * The conversation as plain lines, for summarising. Tool calls and results become short
- * lines, images a note, and any one text block is clipped — the person's own words are
- * kept far longer than anything a tool printed, because they are what a summary must
- * not lose.
- */
-export function transcriptLines(messages) {
-  const lines = [];
-  for (const m of messages || []) {
-    const who = m.role === 'assistant' ? 'ASSISTANT' : 'USER';
-    const textCap = m.role === 'assistant' ? 6_000 : 12_000;
-    if (typeof m.content === 'string') { lines.push(`${who}: ${clip(m.content, textCap)}`); continue; }
-    for (const b of Array.isArray(m.content) ? m.content : []) {
-      if (b?.type === 'text' && b.text) lines.push(`${who}: ${clip(b.text, textCap)}`);
-      else if (b?.type === 'tool_use') lines.push(`${who} ran ${b.name}: ${clip(JSON.stringify(b.input ?? {}), 400)}`);
-      else if (b?.type === 'tool_result') {
-        const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
-        lines.push(`RESULT${b.is_error ? ' (error)' : ''}: ${clip(t, 1500)}`);
-      } else if (b?.type === 'image') lines.push(`${who}: [an image]`);
-    }
-  }
-  return lines;
-}
-
-/** Lines → parts of at most `maxChars` each, cutting only between lines. */
-export function chunkLines(lines, maxChars) {
-  const parts = [];
-  let cur = '';
-  for (const line of lines) {
-    const l = line.length > maxChars ? clip(line, maxChars - 80) : line;
-    if (cur && cur.length + l.length + 1 > maxChars) { parts.push(cur); cur = ''; }
-    cur = cur ? `${cur}\n${l}` : l;
-  }
-  if (cur) parts.push(cur);
-  return parts;
-}
-
-/** Kept for callers that want the single-request transcript (and its tests). */
-export function transcriptForSummary(messages, maxChars = 240_000) {
-  let text = transcriptLines(messages).join('\n');
-  if (text.length > maxChars) {
-    const head = text.slice(0, Math.floor(maxChars * 0.25));
-    const tail = text.slice(-Math.floor(maxChars * 0.7));
-    text = `${head}\n\n[… the middle of the session is left out …]\n\n${tail}`;
-  }
-  return text;
-}
-
-const HEADINGS = '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.';
-
-async function summaryRequest(client, model, prompt, signal) {
-  // Streamed, like every other turn: the proxy in front of the gateway cuts a response
-  // that is silent for 100 s, and a long summary used to be exactly that.
-  const turn = await streamTurn({
-    client,
-    model,
-    // Room for the model to reason before it writes; at 2048 the reasoning could use
-    // it all and the summary came back empty.
-    maxTokens: 6000,
-    system: 'You write precise working summaries of coding sessions.',
-    messages: [{ role: 'user', content: prompt }],
-    signal,
-  });
-  // Half a summary would silently become the whole memory of the session.
-  if (turn.stopReason === 'cut') throw new JaitusError({ code: 'interrupted', message: 'The summary was cut off on the way. Try /compact again.' });
-  const text = (turn.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
-  if (!text) throw new Error('the summary came back empty');
-  return text;
-}
-
-/**
- * Summarise `messages`. `contextTokens` is the window the gateway advertises; the
- * transcript is cut into parts that fit it, and each part is folded into the summary so
- * far (a rolling summary — nothing in the middle is dropped). A part the provider still
- * refuses as too large is retried at half the size, down to a floor.
- */
-export async function summarise(client, model, messages, focus = '', { contextTokens = 128_000, signal, onProgress } = {}) {
-  const lines = transcriptLines(messages);
-  let budget = summaryBudgetChars(contextTokens);
-  const focusNote = focus ? ` Focus on: ${focus}.` : '';
-  for (let attempt = 0; ; attempt++) {
-    const parts = chunkLines(lines, budget);
-    try {
-      let summary = '';
-      for (let i = 0; i < parts.length; i++) {
-        if (parts.length > 1) onProgress?.(i + 1, parts.length);
-        const prompt = summary
-          ? `You are summarising a long coding session in parts. Here is the summary of everything before this part:\n<summary>\n${summary}\n</summary>\n\n`
-            + `Write ONE updated summary that keeps everything that still matters from it and adds this part. ${HEADINGS}${focusNote}`
-            + `\n\n<conversation part="${i + 1} of ${parts.length}">\n${parts[i]}\n</conversation>`
-          : 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
-            + `${HEADINGS}${focusNote}\n\n<conversation>\n${parts[i]}\n</conversation>`;
-        summary = await summaryRequest(client, model, prompt, signal);
-      }
-      return summary;
-    } catch (e) {
-      if (!SIZE_FAULTS.has(e?.code) || budget <= 20_000 || attempt >= 3) throw e;
-      budget = Math.max(20_000, Math.floor(budget / 2));
-    }
-  }
-}
-
-/** The single message a summary becomes. */
-export const summaryMessage = (summary) => ({ role: 'user', content: `[Earlier conversation, summarized:]\n${summary}\n\n[Continue from here.]` });
-
-/**
- * Where to cut so the newest exchange stays word for word. Between the steps of a task
- * the history ends with the model's tool calls and their results: those stay, so the
- * task carries on from them. Before a new prompt the last message is the person's: it
- * stays, so their question is sent whole instead of as a summary of it.
- */
-export function tailStart(messages) {
-  const n = messages.length;
-  if (n < 2) return n;
-  const last = messages[n - 1];
-  const prev = messages[n - 2];
-  const hasResults = Array.isArray(last?.content) && last.content.some((b) => b?.type === 'tool_result');
-  if (last?.role === 'user' && hasResults && prev?.role === 'assistant') return n - 2;
-  if (last?.role === 'user') return n - 1;
-  return n;
-}
-
-/**
- * Replace `messages` (in place) with a summary of everything before the tail, followed
- * by the tail. Returns what happened, or null when there was too little to compact.
- */
-export async function compactInPlace(client, model, messages, { focus = '', contextTokens, keepTail = true, signal, onProgress } = {}) {
-  const cut = keepTail ? tailStart(messages) : messages.length;
-  const head = messages.slice(0, cut);
-  if (!head.length) return null;
-  const tail = messages.slice(cut);
-  const before = estimateTokens(messages);
-  const summary = await summarise(client, model, head, focus, { contextTokens, signal, onProgress });
-  messages.length = 0;
-  // The tail after a summary must still alternate: summary (user) → assistant tool calls
-  // → user results. A tail that starts with the person's message is joined to the
-  // summary instead, so two user messages never sit side by side.
-  if (tail[0]?.role === 'user') {
-    const t = tail[0];
-    const blocks = typeof t.content === 'string' ? [{ type: 'text', text: t.content }] : t.content;
-    messages.push({ role: 'user', content: [{ type: 'text', text: summaryMessage(summary).content }, ...blocks] }, ...tail.slice(1));
-  } else {
-    messages.push(summaryMessage(summary), ...tail);
-  }
-  return { before, after: estimateTokens(messages), dropped: head.length };
-}
-
-/**
- * Images are the usual reason a request is too large in BYTES. Every image except those
- * in the newest message becomes a short note.
- */
-export function dropOldImages(messages) {
-  let dropped = 0;
-  for (let i = 0; i < messages.length - 1; i++) {
-    const m = messages[i];
-    if (!Array.isArray(m.content)) continue;
-    m.content = m.content.map((b) => {
-      if (b?.type === 'image') { dropped++; return { type: 'text', text: '[an image was here; removed to keep the request small]' }; }
-      if (b?.type === 'tool_result' && Array.isArray(b.content) && b.content.some((c) => c?.type === 'image')) {
-        dropped++;
-        return { ...b, content: b.content.map((c) => (c?.type === 'image' ? { type: 'text', text: '[an image was here; removed to keep the request small]' } : c)) };
-      }
-      return b;
-    });
-  }
-  return dropped;
-}
+// ─── Compaction: summarising a conversation so it fits again ──────────────────────
+//
+// Shared by /compact, automatic compaction between prompts, compaction between the
+// steps of one long task, and the automatic recovery from "too large / too long".
+//
+// The one rule: the summary request itself must always fit. It used to carry up to
+// 360,000 characters of transcript whatever the model's window was, with pasted text and
+// @mentions unclipped — so on exactly the sessions that needed it, /compact failed with
+// the same "too long" error it was meant to cure, and the history stayed as it was.
+// Now the transcript is sized from the window the gateway advertises, a session bigger
+// than that is summarised in parts (each part folded into the summary so far), and a
+// refused summary request is retried with half as much.
+
+import { streamTurn } from './agent/loop.js';
+import { JaitusError } from './errors.js';
+
+/** Errors that mean "this request is too big" — the ones compaction can cure. */
+export const SIZE_FAULTS = new Set(['context_too_long', 'request_too_large']);
+
+/** Rough token estimate — ~4 characters per token of English. */
+export function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages || []) {
+    if (typeof m.content === 'string') chars += m.content.length;
+    else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === 'text') chars += (b.text || '').length;
+        else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length;
+        else if (b.type === 'tool_result') {
+          chars += typeof b.content === 'string' ? b.content.length
+            : Array.isArray(b.content) ? b.content.reduce((n, c) => n + (c?.text?.length || (c?.type === 'image' ? 6000 : 0)), 0) : 0;
+        } else if (b.type === 'image') chars += 6000; // ~1.5k tokens, what providers count for one
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+/** How many characters of transcript one summary request may carry for this window. */
+export function summaryBudgetChars(contextTokens) {
+  const window = Number(contextTokens) > 0 ? Number(contextTokens) : 128_000;
+  // Half the window for the transcript (≈ 2 characters per token of window, code and
+  // JSON tokenise denser than prose), the rest for the instructions, the reply and the
+  // gateway's own system prompt. Bounded: a 1M window does not need a 2 MB request.
+  return Math.max(20_000, Math.min(240_000, Math.floor(window * 2)));
+}
+
+const clip = (s, n) => (s.length > n ? `${s.slice(0, n)}… [${s.length - n} more characters left out]` : s);
+
+/**
+ * The conversation as plain lines, for summarising. Tool calls and results become short
+ * lines, images a note, and any one text block is clipped — the person's own words are
+ * kept far longer than anything a tool printed, because they are what a summary must
+ * not lose.
+ */
+export function transcriptLines(messages) {
+  const lines = [];
+  for (const m of messages || []) {
+    const who = m.role === 'assistant' ? 'ASSISTANT' : 'USER';
+    const textCap = m.role === 'assistant' ? 6_000 : 12_000;
+    if (typeof m.content === 'string') { lines.push(`${who}: ${clip(m.content, textCap)}`); continue; }
+    for (const b of Array.isArray(m.content) ? m.content : []) {
+      if (b?.type === 'text' && b.text) lines.push(`${who}: ${clip(b.text, textCap)}`);
+      else if (b?.type === 'tool_use') lines.push(`${who} ran ${b.name}: ${clip(JSON.stringify(b.input ?? {}), 400)}`);
+      else if (b?.type === 'tool_result') {
+        const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
+        lines.push(`RESULT${b.is_error ? ' (error)' : ''}: ${clip(t, 1500)}`);
+      } else if (b?.type === 'image') lines.push(`${who}: [an image]`);
+    }
+  }
+  return lines;
+}
+
+/** Lines → parts of at most `maxChars` each, cutting only between lines. */
+export function chunkLines(lines, maxChars) {
+  const parts = [];
+  let cur = '';
+  for (const line of lines) {
+    const l = line.length > maxChars ? clip(line, maxChars - 80) : line;
+    if (cur && cur.length + l.length + 1 > maxChars) { parts.push(cur); cur = ''; }
+    cur = cur ? `${cur}\n${l}` : l;
+  }
+  if (cur) parts.push(cur);
+  return parts;
+}
+
+/** Kept for callers that want the single-request transcript (and its tests). */
+export function transcriptForSummary(messages, maxChars = 240_000) {
+  let text = transcriptLines(messages).join('\n');
+  if (text.length > maxChars) {
+    const head = text.slice(0, Math.floor(maxChars * 0.25));
+    const tail = text.slice(-Math.floor(maxChars * 0.7));
+    text = `${head}\n\n[… the middle of the session is left out …]\n\n${tail}`;
+  }
+  return text;
+}
+
+const HEADINGS = '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.';
+
+// A reasoning model given a big part can spend its whole output on hidden reasoning and
+// write nothing. Asked again with more room first; still nothing → the part is made
+// smaller (summarise) and, past that, the session gets a mechanical digest.
+const SUMMARY_OUTPUT = [6000, 16000];
+
+async function summaryRequest(client, model, prompt, signal) {
+  for (const maxTokens of SUMMARY_OUTPUT) {
+    // Streamed, like every other turn: the proxy in front of the gateway cuts a response
+    // that is silent for 100 s, and a long summary used to be exactly that.
+    const turn = await streamTurn({
+      client,
+      model,
+      maxTokens,
+      system: 'You write precise working summaries of coding sessions.',
+      messages: [{ role: 'user', content: prompt }],
+      signal,
+    });
+    // Half a summary would silently become the whole memory of the session.
+    if (turn.stopReason === 'cut') throw new JaitusError({ code: 'interrupted', message: 'The summary was cut off on the way. Try /compact again.' });
+    const text = (turn.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
+    if (text) return text;
+  }
+  throw new JaitusError({ code: 'summary_empty', message: 'the summary came back empty' });
+}
+
+// Faults that a smaller part can fix.
+const RETRY_SMALLER = new Set([...SIZE_FAULTS, 'summary_empty']);
+
+/**
+ * The summary of last resort: built from the conversation itself, no model call, so it
+ * cannot fail. What the person asked (their words), the files touched, the commands run
+ * and where the work stood. Detail is lost — less than in the conversation, more than
+ * nothing — and the session keeps working instead of retrying a failing summary forever.
+ */
+export function digestSummary(messages) {
+  const asks = [];
+  const files = new Set();
+  const commands = [];
+  let lastAnswer = '';
+  for (const m of messages || []) {
+    const blocks = typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (b?.type === 'text' && b.text?.trim()) {
+        if (m.role === 'user') asks.push(clip(b.text.trim(), 1500));
+        else lastAnswer = b.text.trim();
+      } else if (b?.type === 'tool_use') {
+        const input = b.input || {};
+        for (const k of ['path', 'file_path', 'file', 'filename']) if (typeof input[k] === 'string') files.add(input[k]);
+        if (Array.isArray(input.paths)) for (const p of input.paths) if (typeof p === 'string') files.add(p);
+        if (typeof input.command === 'string') commands.push(clip(input.command, 200));
+      }
+    }
+  }
+  const out = ['(A model summary could not be made, so this is a mechanical digest of the earlier conversation.)'];
+  if (asks.length) out.push('1. Request — what the user said, oldest first:', ...asks.slice(-25).map((a) => `- ${a}`));
+  if (files.size) out.push('3. Files touched:', ...[...files].slice(-80).map((f) => `- ${f}`));
+  if (commands.length) out.push('4. Commands run (latest):', ...commands.slice(-20).map((c) => `- ${c}`));
+  if (lastAnswer) out.push('6. Current state — the last thing the assistant said:', clip(lastAnswer, 3000));
+  return clip(out.join('\n'), 40_000);
+}
+
+/**
+ * Summarise `messages`. `contextTokens` is the window the gateway advertises; the
+ * transcript is cut into parts that fit it, and each part is folded into the summary so
+ * far (a rolling summary — nothing in the middle is dropped). A part the provider still
+ * refuses as too large is retried at half the size, down to a floor.
+ */
+export async function summarise(client, model, messages, focus = '', { contextTokens = 128_000, signal, onProgress } = {}) {
+  const lines = transcriptLines(messages);
+  let budget = summaryBudgetChars(contextTokens);
+  const focusNote = focus ? ` Focus on: ${focus}.` : '';
+  for (let attempt = 0; ; attempt++) {
+    const parts = chunkLines(lines, budget);
+    try {
+      let summary = '';
+      for (let i = 0; i < parts.length; i++) {
+        if (parts.length > 1) onProgress?.(i + 1, parts.length);
+        const prompt = summary
+          ? `You are summarising a long coding session in parts. Here is the summary of everything before this part:\n<summary>\n${summary}\n</summary>\n\n`
+            + `Write ONE updated summary that keeps everything that still matters from it and adds this part. ${HEADINGS}${focusNote}`
+            + `\n\n<conversation part="${i + 1} of ${parts.length}">\n${parts[i]}\n</conversation>`
+          : 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
+            + `${HEADINGS}${focusNote}\n\n<conversation>\n${parts[i]}\n</conversation>`;
+        summary = await summaryRequest(client, model, prompt, signal);
+      }
+      return summary;
+    } catch (e) {
+      if (!RETRY_SMALLER.has(e?.code) || budget <= 20_000 || attempt >= 3) throw e;
+      budget = Math.max(20_000, Math.floor(budget / 2));
+    }
+  }
+}
+
+/**
+ * Whether to compact before the next step. Past the threshold — unless the conversation
+ * is no bigger than a compaction already left it (+10%): then what remains is the newest
+ * exchange, and compacting again would only repeat itself on every step.
+ */
+export function needsAutoCompact(used, threshold, compactedAt = 0) {
+  if (used < threshold) return false;
+  return !(compactedAt > 0 && used <= compactedAt * 1.1);
+}
+
+/** The single message a summary becomes. */
+export const summaryMessage = (summary) => ({ role: 'user', content: `[Earlier conversation, summarized:]\n${summary}\n\n[Continue from here.]` });
+
+/**
+ * Where to cut so the newest exchange stays word for word. Between the steps of a task
+ * the history ends with the model's tool calls and their results: those stay, so the
+ * task carries on from them. Before a new prompt the last message is the person's: it
+ * stays, so their question is sent whole instead of as a summary of it.
+ */
+export function tailStart(messages) {
+  const n = messages.length;
+  if (n < 2) return n;
+  const last = messages[n - 1];
+  const prev = messages[n - 2];
+  const hasResults = Array.isArray(last?.content) && last.content.some((b) => b?.type === 'tool_result');
+  if (last?.role === 'user' && hasResults && prev?.role === 'assistant') return n - 2;
+  if (last?.role === 'user') return n - 1;
+  return n;
+}
+
+/**
+ * Replace `messages` (in place) with a summary of everything before the tail, followed
+ * by the tail. Returns what happened, or null when there was too little to compact.
+ */
+export async function compactInPlace(client, model, messages, { focus = '', contextTokens, keepTail = true, signal, onProgress } = {}) {
+  const cut = keepTail ? tailStart(messages) : messages.length;
+  const head = messages.slice(0, cut);
+  if (!head.length) return null;
+  const tail = messages.slice(cut);
+  const before = estimateTokens(messages);
+  let summary;
+  let digest = false;
+  try {
+    summary = await summarise(client, model, head, focus, { contextTokens, signal, onProgress });
+  } catch (e) {
+    // Stopped by the person: leave the conversation as it was.
+    if (signal?.aborted || e?.name === 'AbortError') throw e;
+    // Anything else (an empty or cut summary, a provider fault): the digest. Leaving the
+    // conversation at the limit only made the next step try — and fail — again.
+    summary = digestSummary(head);
+    digest = true;
+  }
+  messages.length = 0;
+  // The tail after a summary must still alternate: summary (user) → assistant tool calls
+  // → user results. A tail that starts with the person's message is joined to the
+  // summary instead, so two user messages never sit side by side.
+  if (tail[0]?.role === 'user') {
+    const t = tail[0];
+    const blocks = typeof t.content === 'string' ? [{ type: 'text', text: t.content }] : t.content;
+    messages.push({ role: 'user', content: [{ type: 'text', text: summaryMessage(summary).content }, ...blocks] }, ...tail.slice(1));
+  } else {
+    messages.push(summaryMessage(summary), ...tail);
+  }
+  return { before, after: estimateTokens(messages), dropped: head.length, digest };
+}
+
+/**
+ * Images are the usual reason a request is too large in BYTES. Every image except those
+ * in the newest message becomes a short note.
+ */
+export function dropOldImages(messages) {
+  let dropped = 0;
+  for (let i = 0; i < messages.length - 1; i++) {
+    const m = messages[i];
+    if (!Array.isArray(m.content)) continue;
+    m.content = m.content.map((b) => {
+      if (b?.type === 'image') { dropped++; return { type: 'text', text: '[an image was here; removed to keep the request small]' }; }
+      if (b?.type === 'tool_result' && Array.isArray(b.content) && b.content.some((c) => c?.type === 'image')) {
+        dropped++;
+        return { ...b, content: b.content.map((c) => (c?.type === 'image' ? { type: 'text', text: '[an image was here; removed to keep the request small]' } : c)) };
+      }
+      return b;
+    });
+  }
+  return dropped;
+}

package/src/errors.js

@@ -13,15 +13,16 @@ const CATALOG = {
   account_suspended: { title: 'Account suspended', hint: 'Contact support if you think this is a mistake.' },
   email_unverified: { title: 'Email not verified', hint: 'Open the verification link in your inbox, then retry.' },
   free_limit_reached: { title: 'Free prompts used up', hint: 'Subscribe on the website, then retry this turn.' },
-  free_machine_limit: { title: 'No free prompts on this account', hint: 'This computer already has its free accounts. Subscribe on the website to use this one.' },
+  free_machine_limit: { title: 'No free prompts on this account', hint: 'Subscribe on the website to keep using Jaitus on this account.' },
+  free_needs_check: { title: 'Unlock your free prompts', hint: 'A one-time ₹1 UPI check at jaitus.com/billing (refunded). Or subscribe.' },
   free_needs_cli: { title: 'Update Jaitus for free prompts', hint: 'Run npm i -g jaitus, then try again.' },
   free_request_too_large: { title: 'Too large for the free plan', hint: 'Run /compact or start a new session, or subscribe.' },
-  plan_limit_reached: { title: 'Monthly allowance used', hint: 'It resets at the start of your next period, or upgrade on the website. /usage shows where you are.' },
+  plan_limit_reached: { title: 'Monthly usage used up', hint: 'It resets at the start of your next period, or upgrade on the website. /usage shows where you are.' },
   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: 'Usage limit reached', hint: 'It refills automatically. /usage shows where you are.' },
-  window_limit_reached: { title: 'This usage window is used up', hint: 'It refills when the window ends — the rest of your month is still there. /usage shows when.' },
+  window_limit_reached: { title: 'Usage limit reached', hint: 'It resets by itself — /usage shows your 5-hour session and week, and when each resets.' },
   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.' },