jaitus 0.3.2 → 0.3.4

package/README.md

@@ -219,7 +219,7 @@ or pipes. Force either way with `JAITUS_FULLSCREEN=1` / `JAITUS_NO_FULLSCREEN=1`
   the default; without a terminal to ask in, an action that needs permission is refused
   rather than assumed.
 - Commands run with no TTY, so anything interactive exits instead of hanging forever.
-- The agent stops after 40 steps rather than looping on your bill.
+- The agent runs until the task is done. If it repeats the same action four times without changing anything it stops and says so, rather than looping on your bill.
 - `jaitus doctor` never prints your sign-in token — only whether you are signed in.
 
 ## Signing in

package/bin/jaitus.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
-import main from '../src/index.js';
+// The app is imported only after an unfinished update has completed: importing it
+// statically would load a half-installed copy and crash before any check could run.
+import { waitForPendingUpdate } from '../src/pendingUpdate.js';
+
+await waitForPendingUpdate().catch(() => false);
+const { default: main } = await import('../src/index.js');
 
 // Node 20 is the floor: the CLI uses global fetch, and on 18 it exists but streaming
 // bodies behave differently enough to matter. Better a clear message than a confusing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "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",
+    "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/context-budget.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/agent/loop.js

@@ -15,8 +15,12 @@
 //   • Every tool_use must get a tool_result, including ones that failed or were refused.
 //     A missing result is a malformed conversation, and the error text is also how the
 //     model learns to try something else.
-//   • A hard iteration cap. A model that gets stuck in a read-file loop would otherwise
-//     spend real money until someone notices.
+//   • A stuck detector, not a step count. A model caught in a loop would otherwise spend
+//     real money until someone notices — but a fixed cap of 40 steps also stopped every
+//     long, perfectly healthy task halfway and made the user type "continue". A run now
+//     ends when the model finishes, or when it repeats the same call with the same input
+//     STUCK_REPEATS times with no file changed in between (see `stuck` below). A very
+//     high backstop remains so no run is unbounded.
 
 import { byName, toolSchemas, ToolError, readImageForModel } from './tools.js';
 import { PermissionDenied } from './permissions.js';
@@ -29,7 +33,8 @@ import { discoverMcpTools } from '../mcp.js';
 import { unifiedDiff } from '../diff.js';
 import { fromResponse, fromGatewayBody } from '../errors.js';
 
-const MAX_ITERATIONS = 40;
+const MAX_ITERATIONS = 1000;
+const STUCK_REPEATS = 4;
 
 // Room for a long answer or a large file in one reply. The models behind Jaitus reason
 // before they answer, and that reasoning is spent from the same budget — at 8192 a long
@@ -295,8 +300,13 @@ 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,
+  subagents = true, onContext = null,
 }) {
+  // 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
+  // moves), while reading the same file over and over is not.
+  let changes = 0;
+  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 };
@@ -398,7 +408,13 @@ export async function runAgent({
     totals.cached += (turn.usage.cache_read_input_tokens || 0) + (turn.usage.cache_creation_input_tokens || 0);
     totals.output += turn.usage.output_tokens || 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);
+    if (promptSize) {
+      totals.context = promptSize + (turn.usage.output_tokens || 0);
+      // The header's context meter moves after every step. It used to be told only when
+      // the whole run returned, so through a long task — and after one stopped with
+      // Esc or an error — it sat at 0.
+      try { onContext?.(totals.context); } catch { /* the meter never breaks a turn */ }
+    }
     // The work bar's live count. It was declared and drawn but never fed, so it never
     // appeared; now it moves after every step of the turn.
     tui?.setTurnTokens?.(totals.input + totals.cached + totals.output);
@@ -447,6 +463,27 @@ export async function runAgent({
 
     if (!calls.length) { tui?.bellIfAway?.(); return { ...totals, stopReason: turn.stopReason }; }
 
+    // The same call, same input, nothing changed since: STUCK_REPEATS times is a loop.
+    // Checked before running, so the repeat that proves it is not paid for again.
+    const stuckOn = calls.find((call) => {
+      const key = `${changes}\u0000${call.name}\u0000${JSON.stringify(call.input ?? null)}`;
+      const n = (repeats.get(key) || 0) + 1;
+      repeats.set(key, n);
+      return n >= STUCK_REPEATS;
+    });
+    if (stuckOn) {
+      // Every tool_use still gets a result — the model is told why these did not run, so
+      // after "continue" it does not simply make the same call a fifth time.
+      messages.push({ role: 'user', content: calls.map((call) => result(call.id,
+        `Not run: this exact call was already made ${STUCK_REPEATS - 1} times with no file changed since, and the run was stopped as stuck. Do something different.`, true)) });
+      const label = toolMap[stuckOn.name]?.summarise ? toolMap[stuckOn.name].summarise(stuckOn.input) : stuckOn.name;
+      const why = `Stopped: it made the same ${stuckOn.name} call (${String(label).slice(0, 60)}) ${STUCK_REPEATS} times without changing anything, so it looks stuck. Tell it what to do differently, or say "continue".`;
+      if (tui?.notice) tui.notice(why, 'warn');
+      else if (!silent) out(c.yellow(`\n${why}`));
+      tui?.bellIfAway?.();
+      return { ...totals, stopReason: 'stuck' };
+    }
+
     // Every call gets a result, whatever happened.
     const results = [];
     for (const call of calls) {
@@ -529,6 +566,8 @@ export async function runAgent({
         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 });
         results.push(result(call.id, output, false));
+        // A changed file is progress: calls made after it are not repeats of those before.
+        if (['write_file', 'edit_file'].includes(call.name)) changes += 1;
         // read_image: the pixels ride along as an image block in the tool-result
         // message, so the model actually sees the picture instead of a caption of it.
         if (call.name === 'read_image' && !silent) {
@@ -587,7 +626,7 @@ export async function runAgent({
     messages.push({ role: 'user', content: withImages });
   }
 
-  if (!silent) out(c.yellow(`\nStopped after ${maxIterations} steps without finishing. Say "continue" to keep going.`));
+  if (!silent) out(c.yellow(`\nStopped after ${maxIterations} steps — the safety limit for one request. Say "continue" to keep going.`));
   tui?.bellIfAway?.();
   return { ...totals, stopReason: 'max_iterations' };
 }
@@ -636,7 +675,9 @@ function makeSubagentTool({ client, model, cwd, signal, tui }) {
         tui: null,
         silent: true,
         subagents: false,
-        maxIterations: 20,
+        // Read-only research across a codebase is many small reads; 20 cut it off
+        // mid-search. The stuck detector is what catches a loop.
+        maxIterations: 100,
         extraSystem: '\n\nYou are a subagent. You cannot ask questions and nobody will read your intermediate '
           + 'steps — only your final message. End with the findings themselves, with exact file paths and line '
           + 'numbers where they apply, not a description of how you looked.',

package/src/api.js

@@ -10,6 +10,10 @@ import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
 
 export class NotSignedIn extends Error {}
 
+// The context window the gateway last advertised, or null before it has been asked.
+let contextWindowSeen = null;
+export const advertisedContextWindow = () => contextWindowSeen;
+
 export function createClient() {
   const { baseUrl } = endpoints();
   if (!signedIn()) throw new NotSignedIn('Not signed in. Run `jaitus login` first.');
@@ -63,6 +67,9 @@ export function createClient() {
       const body = await res.json().catch(() => ({}));
       if (!res.ok) throw fromGatewayBody(res.status, body, { requestId: res.headers.get('x-request-id') || '' });
       const models = (body?.data || []).map((m) => m?.id).filter(Boolean);
+      // How much conversation fits, as the gateway computed it for this account.
+      const ctx = (body?.data || []).map((m) => Number(m?.context_window)).find((n) => n > 0);
+      if (ctx) contextWindowSeen = ctx;
       // An empty list is a service fault, not something the user can fix — and naming
       // the gateway's model map to them would be naming our internals.
       if (!models.length) throw new JaitusError({ code: 'unavailable', status: 502 });

package/src/commands/update.js

@@ -16,6 +16,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { c, out, ok, info, warn, fail, present, askKey } from '../ui.js';
 import { version, HOME } from '../config.js';
+import { RUNNING_FILE } from '../pendingUpdate.js';
 
 const REGISTRY = process.env.JAITUS_REGISTRY || 'https://registry.npmjs.org';
 const TIMEOUT_MS = 5000;
@@ -108,6 +109,33 @@ function run(cmd, args, { capture = false } = {}) {
   });
 }
 
+/**
+ * `npm install -g jaitus@<version>`, run so that it cannot be cut off halfway.
+ *
+ * A global install takes 30–60s (measured: 46s on Windows), and a Ctrl+C in the
+ * terminal reaches every process attached to it — npm killed mid-install can leave the
+ * package half-replaced and `jaitus` unable to start. So npm runs in its own process
+ * group (detached; windowsHide keeps Windows from opening a console for it) and carries
+ * on to the end whatever happens to this process. `onTick` gets the seconds elapsed.
+ */
+export function installGlobal(v, { onTick = () => {}, onStart = () => {} } = {}) {
+  return new Promise((resolve) => {
+    const args = ['install', '-g', `jaitus@${v}`, '--no-audit', '--no-fund', '--loglevel=error'];
+    const opts = { stdio: ['ignore', 'ignore', 'pipe'], detached: true, windowsHide: true };
+    const child = process.platform === 'win32'
+      ? spawn(['npm', ...args].join(' '), { ...opts, shell: true })
+      : spawn('npm', args, opts);
+    if (child.pid) onStart(child.pid);
+    let stderr = '';
+    child.stderr?.on('data', (d) => { stderr = (stderr + d).slice(-4000); });
+    const t0 = Date.now();
+    const ticker = setInterval(() => onTick(Math.round((Date.now() - t0) / 1000)), 1000);
+    const finish = (code) => { clearInterval(ticker); resolve({ code, stderr: stderr.trim() }); };
+    child.on('error', () => finish(-1));
+    child.on('close', (code) => finish(code));
+  });
+}
+
 /**
  * How this copy was installed: 'npm-global', 'npx', or 'other'.
  *
@@ -158,8 +186,10 @@ export function isNewer(a, b) {
  * Returns the child's exit code when it relaunched, or null to carry on in this process.
  */
 export async function autoUpdate({ argv = [], settings = {}, env = process.env, current = version(), log = out,
-  check = () => checkRegistry(), method = () => installMethod(), install = (v) => run('npm', ['install', '-g', `jaitus@${v}`], { capture: true }),
-  relaunch = defaultRelaunch, now = Date.now(), failFile = path.join(HOME, 'update-failed.json') } = {}) {
+  check = () => checkRegistry(), method = () => installMethod(), install = null,
+  relaunch = defaultRelaunch, now = Date.now(), failFile = path.join(HOME, 'update-failed.json'),
+  cacheFile = CHECK_FILE, waitMs = 1500, write = (s) => process.stdout.write(s),
+  runningFile = RUNNING_FILE } = {}) {
   if (env.JAITUS_UPDATED_FROM) return null;                // just relaunched: never loop
   if (!updateCheckEnabled(env) || env.JAITUS_NO_AUTOUPDATE || settings.autoUpdate === false) return null;
   if (!process.stdout.isTTY || !process.stdin.isTTY) return null;   // scripts and pipes get a stable version
@@ -170,22 +200,58 @@ export async function autoUpdate({ argv = [], settings = {}, env = process.env,
     if (now - Number(failed.at) < DAY_MS) return null;
   } catch { /* no recent failure */ }
 
-  const { version: latest } = await Promise.race([
-    check(),
-    // unref: a quick command must not sit waiting for this timer after the answer came.
-    new Promise((resolve) => setTimeout(() => resolve({ version: null }), 1500).unref()),
-  ]);
+  // What the last check found. A check that outlived its wait on a slow connection still
+  // finishes and records its answer here, so the NEXT launch updates without waiting —
+  // before this, a network slower than the wait skipped the update on every launch.
+  const remember = (latest) => {
+    try { fs.mkdirSync(path.dirname(cacheFile), { recursive: true }); fs.writeFileSync(cacheFile, JSON.stringify({ checkedAt: Date.now(), latest: latest || null })); } catch { /* read-only home */ }
+  };
+  let latest = null;
+  try {
+    const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+    if (cached?.latest && isNewer(cached.latest, current) && now - Number(cached.checkedAt) < 6 * 3600e3) latest = cached.latest;
+  } catch { /* no earlier answer */ }
+  if (!latest) {
+    const asked = Promise.resolve().then(check).then((r) => { if (r?.version) remember(r.version); return r; }, () => ({ version: null }));
+    ({ version: latest } = await Promise.race([
+      asked,
+      // unref: a quick command must not sit waiting for this timer after the answer came.
+      new Promise((resolve) => setTimeout(() => resolve({ version: null }), waitMs).unref()),
+    ]));
+  }
   if (!latest || !isNewer(latest, current)) return null;
   if ((await method()) !== 'npm-global') return null;       // the in-app notice covers these
 
-  log(`  ${c.brand('Jaitus')} ${c.dim(`v${current} →`)} ${c.bold(`v${latest}`)} ${c.dim('— updating…')}`);
-  const { code } = await install(latest);
-  if (code !== 0) {
+  const head = `  ${c.brand('Jaitus')} ${c.dim(`v${current} →`)} ${c.bold(`v${latest}`)}`;
+  write(`${head} ${c.dim('— updating…')}`);
+  // Ctrl+C now leaves npm to finish on its own (it is detached) — say so rather than
+  // leaving someone to wonder whether they broke the install. Runs before the bin's own
+  // SIGINT handler, which exits.
+  const onInterrupt = () => {
+    write(`\n  ${c.dim(`The update keeps installing in the background. Start ${c.bold('jaitus')} again in a minute.`)}\n`);
+  };
+  process.prependListener('SIGINT', onInterrupt);
+  const doInstall = install || ((v) => installGlobal(v, {
+    onTick: (s) => write(`\r${head} ${c.dim(`— updating… ${s}s (this takes about a minute)`)}`),
+    // Left behind only if this process is gone before npm is — the next launch waits on it.
+    onStart: (pid) => { try { fs.mkdirSync(path.dirname(runningFile), { recursive: true }); fs.writeFileSync(runningFile, JSON.stringify({ pid, at: Date.now(), version: v })); } catch { /* best effort */ } },
+  }));
+  let result;
+  try { result = await doInstall(latest); } finally {
+    process.removeListener('SIGINT', onInterrupt);
+    try { fs.rmSync(runningFile, { force: true }); } catch { /* best effort */ }
+  }
+  write('\n');
+  if (result.code !== 0) {
     try { fs.mkdirSync(path.dirname(failFile), { recursive: true }); fs.writeFileSync(failFile, JSON.stringify({ at: now, version: latest })); } catch { /* best effort */ }
-    log(`  ${c.yellow('!')} ${c.dim('Could not update automatically — continuing on')} v${current}${c.dim('. To update:')} ${c.bold(process.platform === 'win32' ? 'npm install -g jaitus@latest' : 'sudo npm install -g jaitus@latest')}`);
+    const needsSudo = /EACCES|permission denied/i.test(result.stderr || '');
+    log(`  ${c.yellow('!')} ${c.dim('Could not update automatically — continuing on')} v${current}${c.dim('. To update:')} ${c.bold(process.platform !== 'win32' && needsSudo ? 'sudo npm install -g jaitus@latest' : 'npm install -g jaitus@latest')}`);
+    const reason = (result.stderr || '').split('\n').map((l) => l.trim()).filter(Boolean).find((l) => /ERR|EACCES|EPERM|EBUSY|ENOTEMPTY/i.test(l));
+    if (reason) log(`  ${c.dim(reason.slice(0, 200))}`);
     return null;
   }
-  log(`  ${c.accent('✓')} ${c.dim('Updated — reopening')}`);
+  remember(latest);
+  log(`  ${c.accent('✓')} ${c.dim(`Updated to v${latest} — reopening`)}`);
   return relaunch({ ...env, JAITUS_UPDATED_FROM: current });
 }
 

package/src/index.js

@@ -9,7 +9,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { spawn, spawnSync } from 'node:child_process';
-import { createClient, NotSignedIn } from './api.js';
+import { createClient, NotSignedIn, advertisedContextWindow } from './api.js';
 import { fromResponse, isJaitusError } from './errors.js';
 import { signedIn } from './session.js';
 import {
@@ -81,7 +81,7 @@ const FLAG_NAMES = ['--print', '-p', '--continue', '-c', '--resume', '-r', '--ou
 function parseArgs(argv) {
   const flags = {
     model: null, yes: false, cwd: process.cwd(), json: false, help: false, version: false,
-    print: false, continue: false, resume: null, outputFormat: 'text', maxTurns: 40,
+    print: false, continue: false, resume: null, outputFormat: 'text', maxTurns: undefined,
     permissionMode: 'default', systemPrompt: '', appendSystemPrompt: '',
   };
   const rest = [];
@@ -97,7 +97,7 @@ function parseArgs(argv) {
     else if (a === '--continue' || a === '-c') flags.continue = true;
     else if (a === '--resume' || a === '-r') flags.resume = argv[++i];
     else if (a === '--output-format') flags.outputFormat = argv[++i] || 'text';
-    else if (a === '--max-turns') flags.maxTurns = Math.max(1, Number(argv[++i]) || 40);
+    else if (a === '--max-turns') flags.maxTurns = Math.max(1, Number(argv[++i]) || 1000);
     else if (a === '--permission-mode') flags.permissionMode = argv[++i] || 'default';
     else if (a === '--dangerously-skip-permissions') flags.permissionMode = 'bypassPermissions';
     else if (a === '--system-prompt') flags.systemPrompt = argv[++i] || '';
@@ -300,10 +300,18 @@ function gitBranch(cwd) {
   }
 }
 
-// Used only to fill the context meter. The real ceiling is the model's, which the
-// gateway does not advertise; this is the conservative floor of what any model it
-// serves accepts, so the bar reads "getting full" before anything actually breaks.
-const CONTEXT_BUDGET = 180_000;
+// How much conversation a session carries before it is compacted. The gateway works it
+// out from the providers' real limits and the admin's cap, and advertises it on its
+// model list; this floor is only used until that answer arrives, or if it never does.
+const CONTEXT_FALLBACK = 128_000;
+let CONTEXT_BUDGET = CONTEXT_FALLBACK;
+async function loadContextBudget(client) {
+  try {
+    if (!advertisedContextWindow()) await client.models();
+    CONTEXT_BUDGET = advertisedContextWindow() || CONTEXT_FALLBACK;
+  } catch { /* keep the floor */ }
+  return CONTEXT_BUDGET;
+}
 
 // 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.
@@ -548,6 +556,7 @@ async function session({ flags }) {
   let [model, device] = await Promise.all([
     resolveModel(client, flags.model),
     probeDevice({}).catch(() => ({ vt: !!process.stdout.isTTY, sixel: false })),
+    loadContextBudget(client),
   ]);
   // Degrade on EVIDENCE, not on silence.
   //
@@ -769,9 +778,12 @@ async function session({ flags }) {
     const ctrl = new AbortController();
     activeAbort = ctrl;
     const turnStarted = Date.now();
+    // The new message counts toward the context from the moment it is sent.
+    try { showContext(); } catch { /* header keeps last value */ }
     try {
       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}` : ''}`,
         systemOverride: flags.systemPrompt || null,
       });

package/src/pendingUpdate.js

@@ -0,0 +1,41 @@
+// ─── An update still installing ─────────────────────────────────────────────────
+//
+// Loaded by bin/jaitus.js BEFORE the app, and so only from Node's own modules.
+//
+// A launch that is closed with Ctrl+C during its auto-update leaves npm to finish on its
+// own (commands/update.js runs it detached so it cannot be cut off halfway). npm writes
+// the new package.json before it has finished unpacking the dependencies, so a launch in
+// those seconds would load a half-installed copy — measured: ERR_UNSUPPORTED_DIR_IMPORT
+// from ink, a crash before any of our code runs. So the launcher waits for that npm to
+// exit (up to 3 minutes), then loads the app, which is by then the new version.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const RUNNING_FILE = path.join(os.homedir(), '.jaitus', 'update-running.json');
+
+export function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+export async function waitForPendingUpdate({ file = RUNNING_FILE, alive = pidAlive, write = (s) => process.stderr.write(s), maxMs = 180e3, pollMs = 500 } = {}) {
+  let running;
+  try { running = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return false; }
+  // Stale (a crashed machine, a reused pid long after): ignore it and clear it.
+  if (!running?.pid || !alive(running.pid) || Date.now() - Number(running.at) > 10 * 60e3) {
+    try { fs.rmSync(file, { force: true }); } catch { /* best effort */ }
+    return false;
+  }
+  const tty = process.stderr.isTTY;
+  const head = `  Jaitus — finishing the update to v${running.version}…`;
+  write(head);
+  const t0 = Date.now();
+  while (alive(running.pid) && Date.now() - t0 < maxMs) {
+    await new Promise((r) => setTimeout(r, pollMs));
+    if (tty) write(`\r${head} ${Math.round((Date.now() - t0) / 1000)}s`);
+  }
+  write('\n');
+  try { fs.rmSync(file, { force: true }); } catch { /* best effort */ }
+  return true;
+}

package/src/tui/clipboard.js

@@ -0,0 +1,68 @@
+// ─── Reading the system clipboard ───────────────────────────────────────────────
+//
+// The app takes the mouse, so a terminal's own right-click paste never happens — the
+// click is reported to the app instead, and it used to be thrown away: "paste does not
+// work". Ctrl+V is the terminal's in some terminals and the app's in others. So the app
+// reads the clipboard itself for right-click and Ctrl+V, and for Alt+V (an image, which
+// no terminal can type in).
+//
+// Asynchronous on purpose: PowerShell takes a few hundred milliseconds to start, and a
+// synchronous read froze the whole interface for that long.
+
+import { spawn } from 'node:child_process';
+
+function capture(cmd, args, { timeout = 4000, binary = false } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try { child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }); } catch { resolve(null); return; }
+    const chunks = [];
+    const timer = setTimeout(() => { try { child.kill(); } catch { /* gone */ } resolve(null); }, timeout);
+    timer.unref?.();
+    child.stdout.on('data', (d) => chunks.push(d));
+    child.on('error', () => { clearTimeout(timer); resolve(null); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) return resolve(null);
+      const buf = Buffer.concat(chunks);
+      resolve(binary ? buf : buf.toString('utf8'));
+    });
+  });
+}
+
+/** Plain text on the clipboard, or null (empty, not text, or no clipboard tool). */
+export async function readClipboardText({ platform = process.platform, run = capture } = {}) {
+  let text = null;
+  if (platform === 'win32') {
+    // UTF-8 out, or anything outside the console code page (quotes, dashes, non-Latin
+    // text) arrives as '?'. -Raw keeps line breaks as they were copied.
+    text = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      '[Console]::OutputEncoding=[Text.Encoding]::UTF8; $t = Get-Clipboard -Raw; if ($null -ne $t) { [Console]::Out.Write($t) }']);
+  } else if (platform === 'darwin') {
+    text = await run('pbpaste', []);
+  } else {
+    for (const [cmd, args] of [['wl-paste', ['--no-newline']], ['xclip', ['-selection', 'clipboard', '-o']], ['xsel', ['--clipboard', '--output']]]) {
+      text = await run(cmd, args);
+      if (text != null) break;
+    }
+  }
+  return text ? text : null;
+}
+
+/** PNG bytes of an image on the clipboard, or null. */
+export async function readClipboardImage({ platform = process.platform, run = capture } = {}) {
+  if (platform === 'win32') {
+    const b64 = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      'Add-Type -AssemblyName System.Windows.Forms,System.Drawing; $i = [Windows.Forms.Clipboard]::GetImage(); if (!$i) { exit 1 }; $m = New-Object IO.MemoryStream; $i.Save($m, [Drawing.Imaging.ImageFormat]::Png); [Console]::Out.Write([Convert]::ToBase64String($m.ToArray()))'],
+    { timeout: 8000 });
+    return b64 && b64.trim() ? Buffer.from(b64.trim(), 'base64') : null;
+  }
+  if (platform === 'darwin') {
+    const bytes = await run('pngpaste', ['-'], { timeout: 8000, binary: true });
+    return bytes?.length ? bytes : null;
+  }
+  for (const [cmd, args] of [['wl-paste', ['--type', 'image/png']], ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o']]]) {
+    const bytes = await run(cmd, args, { timeout: 8000, binary: true });
+    if (bytes?.length) return bytes;
+  }
+  return null;
+}

package/src/tui/widgets.js

@@ -194,8 +194,12 @@ export function Reveal({ children, rows, duration = 140 }) {
 /** Rows of spans → Ink text. The single place span objects become pixels. */
 export function Rows({ rows, maxRows }) {
   const visible = maxRows && rows.length > maxRows ? rows.slice(rows.length - maxRows) : rows;
-  return h(Box, { flexDirection: 'column' }, visible.map((row, index) =>
-    h(Text, { key: index, wrap: 'truncate-end' }, row.length
+  // flexShrink 0, on the column and on every row: inside a box with a fixed height,
+  // Yoga otherwise SHRINKS rows to fit, and shrunk rows in a terminal are drawn on top
+  // of each other — two lines of a reply painted onto one ("while it arrives.is a
+  // reply…", measured). Rows that do not fit must be clipped by the parent, never merged.
+  return h(Box, { flexDirection: 'column', flexShrink: 0 }, visible.map((row, index) =>
+    h(Text, { key: index, wrap: 'truncate-end', flexShrink: 0 }, row.length
       ? row.map((span, i) => h(Text, {
         key: i,
         color: span.color,