jaitus 0.3.13 → 0.3.16

package/src/machine.js

@@ -0,0 +1,192 @@
+// ─── This computer's identifiers, for the free tier ───────────────────────────────
+//
+// Only so many accounts on one computer get free prompts (the server decides; see
+// backend/services/deviceGuard.js). The CLI tells it which computer it is on with
+// several identifiers, each one HASHED here — the raw values never leave the machine:
+//
+//   m  the operating system's machine id: Windows MachineGuid, Linux /etc/machine-id
+//   h  the firmware's hardware UUID (SMBIOS / macOS IOPlatformUUID) — survives an OS
+//      reinstall
+//   i  this CLI's install id, kept in two places (~/.jaitus and the OS's app-data
+//      folder), each restoring the other
+//   n  the address of each physical network adapter (virtual and randomised ones are
+//      skipped: they change by themselves)
+//
+// A VPN, a new network or a new email changes none of these. They are reported by this
+// program, so they identify a computer for an honest client — the same ceiling every
+// product that does this has (Cursor's machine ids are reset by published tools).
+//
+// Everything here is best-effort and never blocks or breaks a request: a probe that
+// fails just leaves its identifier out. The slow one (Windows SMBIOS, ~1 s through
+// PowerShell) runs once in the background and is cached.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { HOME } from './config.js';
+import { deviceId } from './session.js';
+
+const CACHE_FILE = path.join(HOME, 'machine.json');
+const hash = (kind, raw) => crypto.createHash('sha256').update(`jaitus-device:${kind}:${String(raw).trim().toLowerCase()}`).digest('hex');
+
+// Values firmware vendors ship unset, shared by thousands of boards.
+const JUNK_UUID = /^(0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12}|03000200-0400-0500-0006-000700080009|00020003-0004-0005-0006-000700080009)$/i;
+// Adapters that are virtual or move by themselves: Hyper-V, VirtualBox, VMware,
+// Parallels, Docker/WSL bridges.
+const VIRTUAL_OUI = /^(00:15:5d|08:00:27|0a:00:27|00:05:69|00:0c:29|00:1c:14|00:50:56|00:1c:42|02:42)/i;
+
+function readCache() {
+  try { return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8')) || {}; } catch { return {}; }
+}
+function writeCache(obj) {
+  try {
+    fs.mkdirSync(HOME, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(obj, null, 2), { mode: 0o600 });
+  } catch { /* unwritable home: probed again next launch */ }
+}
+
+/** The OS machine id (fast: one registry read or one file). */
+function osMachineId() {
+  try {
+    if (process.platform === 'win32') {
+      const r = spawnSync('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], { encoding: 'utf8', timeout: 2000, windowsHide: true });
+      const m = /MachineGuid\s+REG_SZ\s+([0-9a-f-]{36})/i.exec(r.stdout || '');
+      return m ? m[1] : null;
+    }
+    if (process.platform === 'linux') {
+      for (const f of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+        try { const v = fs.readFileSync(f, 'utf8').trim(); if (/^[0-9a-f]{32}$/i.test(v)) return v; } catch { /* next */ }
+      }
+    }
+  } catch { /* left out */ }
+  return null;
+}
+
+/** The firmware's hardware UUID, synchronously where that is cheap (macOS, Linux). */
+function hardwareIdSync() {
+  try {
+    if (process.platform === 'darwin') {
+      const r = spawnSync('ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], { encoding: 'utf8', timeout: 2000 });
+      const m = /"IOPlatformUUID"\s*=\s*"([0-9A-F-]{36})"/i.exec(r.stdout || '');
+      return m && !JUNK_UUID.test(m[1]) ? m[1] : null;
+    }
+    if (process.platform === 'linux') {
+      const v = fs.readFileSync('/sys/class/dmi/id/product_uuid', 'utf8').trim(); // root-only on most distros
+      return /^[0-9a-f-]{36}$/i.test(v) && !JUNK_UUID.test(v) ? v : null;
+    }
+  } catch { /* left out */ }
+  return null;
+}
+
+let smbiosProbe = null;
+/** Windows: SMBIOS UUID through CIM, in the background, cached. */
+function probeWindowsHardware() {
+  if (process.platform !== 'win32' || smbiosProbe) return smbiosProbe;
+  smbiosProbe = new Promise((resolve) => {
+    let out = '';
+    let child;
+    try {
+      child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '(Get-CimInstance -ClassName Win32_ComputerSystemProduct).UUID'], { windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch { resolve(null); return; }
+    const t = setTimeout(() => { try { child.kill(); } catch { /* gone */ } resolve(null); }, 8000);
+    t.unref?.();
+    child.stdout.on('data', (d) => { out += d; });
+    child.on('error', () => { clearTimeout(t); resolve(null); });
+    child.on('close', () => {
+      clearTimeout(t);
+      const v = String(out).trim();
+      resolve(/^[0-9a-f-]{36}$/i.test(v) && !JUNK_UUID.test(v) ? v : null);
+    });
+  }).then((v) => {
+    const cache = readCache();
+    cache.h = v ? hash('h', v) : '';
+    cache.hAt = new Date().toISOString();
+    writeCache(cache);
+    return v;
+  });
+  return smbiosProbe;
+}
+
+/** Physical adapters' addresses, globally administered only, at most three. */
+function adapterIds() {
+  const out = new Set();
+  try {
+    for (const list of Object.values(os.networkInterfaces())) {
+      for (const a of list || []) {
+        const mac = String(a.mac || '').toLowerCase();
+        if (a.internal || !/^([0-9a-f]{2}:){5}[0-9a-f]{2}$/.test(mac) || mac === '00:00:00:00:00:00') continue;
+        if (parseInt(mac.slice(0, 2), 16) & 0x02) continue; // locally administered / randomised
+        if (VIRTUAL_OUI.test(mac)) continue;
+        out.add(mac);
+      }
+    }
+  } catch { /* none */ }
+  return [...out].sort().slice(0, 3);
+}
+
+/**
+ * Where the install id's second copy lives: outside ~/.jaitus, in the OS's app-data
+ * folder. Always under os.homedir() (not LOCALAPPDATA / XDG_DATA_HOME), so a test run
+ * with its own home never writes into the real one.
+ */
+function mirrorPath() {
+  if (process.platform === 'win32') return path.join(os.homedir(), 'AppData', 'Local', 'Jaitus', 'install-id');
+  if (process.platform === 'darwin') return path.join(os.homedir(), 'Library', 'Application Support', 'Jaitus', 'install-id');
+  return path.join(os.homedir(), '.local', 'share', 'jaitus', 'install-id');
+}
+
+/** The install id, restored from either copy and written back to both. */
+function installId() {
+  const mirror = mirrorPath();
+  let fromMirror = null;
+  try { const v = fs.readFileSync(mirror, 'utf8').trim(); if (/^[A-Za-z0-9_-]{8,80}$/.test(v)) fromMirror = v; } catch { /* first run */ }
+  const deviceFile = path.join(HOME, 'device.json');
+  let id = null;
+  try { const saved = JSON.parse(fs.readFileSync(deviceFile, 'utf8')); if (/^[A-Za-z0-9_-]{8,80}$/.test(saved?.id || '')) id = saved.id; } catch { /* none */ }
+  if (!id && fromMirror) {
+    id = fromMirror;
+    try { fs.mkdirSync(HOME, { recursive: true, mode: 0o700 }); fs.writeFileSync(deviceFile, JSON.stringify({ id, createdAt: new Date().toISOString() }, null, 2), { mode: 0o600 }); } catch { /* best effort */ }
+  }
+  if (!id) id = deviceId();
+  if (fromMirror !== id) {
+    try { fs.mkdirSync(path.dirname(mirror), { recursive: true }); fs.writeFileSync(mirror, id); } catch { /* best effort */ }
+  }
+  return id;
+}
+
+let header = null;
+/**
+ * The `x-jaitus-device` header: "m=<hash>,h=<hash>,i=<hash>,n=<hash>,…". Built once
+ * per process; the Windows hardware id joins it once its background probe is done.
+ */
+export function machineHeader() {
+  if (process.env.JAITUS_DEVICE_HEADER !== undefined) return process.env.JAITUS_DEVICE_HEADER; // tests
+  if (header) return header;
+  const cache = readCache();
+  const parts = [];
+  try {
+    const m = cache.m || (osMachineId() ? hash('m', osMachineId()) : '');
+    if (m) parts.push(`m=${m}`);
+    let h = cache.h;
+    if (h === undefined) {
+      const sync = hardwareIdSync();
+      h = sync ? hash('h', sync) : undefined;
+      if (h === undefined && process.platform === 'win32') {
+        probeWindowsHardware()?.then(() => { header = null; }).catch(() => {});
+      }
+    }
+    if (h) parts.push(`h=${h}`);
+    parts.push(`i=${hash('i', installId())}`);
+    for (const mac of adapterIds()) parts.push(`n=${hash('n', mac)}`);
+    if (m && cache.m !== m) writeCache({ ...cache, m, ...(h ? { h } : {}) });
+  } catch { /* whatever was gathered */ }
+  header = parts.join(',');
+  return header;
+}
+
+/** Start the slow probe early (at launch), so the first request already carries it. */
+export function warmMachineHeader() {
+  try { if (readCache().h === undefined) probeWindowsHardware(); } catch { /* best effort */ }
+}

package/src/serviceNotice.js

@@ -0,0 +1,151 @@
+// ─── Service notices in the CLI ─────────────────────────────────────────────────
+//
+// The status page (www.jaitus.com/status) is the record. The CLI only says something
+// when it affects using Jaitus right now, the way flyctl checks its status page:
+//
+//   - At start-up, in the background with a short timeout: one line for a major or
+//     critical incident on the Jaitus service, maintenance in progress, or maintenance
+//     starting within 24 hours. Each notice at most once a day on this machine.
+//   - When a request has finally failed (after the usual retries) as unavailable, timed
+//     out or down for maintenance: the error says which known problem it is, or when
+//     Jaitus will be back.
+//
+// The server decides which notices qualify (GET /api/status/notices), by its own clock.
+// Nothing here ever blocks, and any failure is silent. JAITUS_NO_STATUS_CHECK=1 or CI
+// turns the start-up line off.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME, endpoints } from './config.js';
+
+const TIMEOUT_MS = 2000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SHOWN_FILE = path.join(HOME, 'notice-check.json');
+
+/** Whether the start-up line may run at all. */
+export function noticeCheckEnabled(env = process.env) {
+  return !(env.JAITUS_NO_STATUS_CHECK || env.CI);
+}
+
+/** The public notices payload, or null. Never throws. */
+export async function fetchNotices({ baseUrl = endpoints().baseUrl, fetchImpl = fetch, timeoutMs = TIMEOUT_MS } = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(`${baseUrl}/api/status/notices`, { signal: ctrl.signal, headers: { accept: 'application/json' } });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body && typeof body === 'object' && body.data && typeof body.data === 'object' ? body.data : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** "www.jaitus.com/status", from the configured site. */
+export function statusAddress(siteUrl = endpoints().siteUrl) {
+  return `${String(siteUrl).replace(/^https?:\/\//, '').replace(/\/+$/, '')}/status`;
+}
+
+// Text from the server is printed into a terminal: no escape codes, no control
+// characters, one short line.
+const clean = (t, max = 100) => {
+  const s = String(t ?? '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+};
+const dropStop = (t) => t.replace(/[.!?…]+$/, '');
+
+/** The start-up line for one notice from the server's `cli` list. */
+export function lineFor(item, where = statusAddress()) {
+  if (!item || typeof item !== 'object') return null;
+  const title = dropStop(clean(item.title));
+  if (item.kind === 'incident') {
+    return `Jaitus is having problems${title ? `: ${title}` : ''}. Updates: ${where}`;
+  }
+  if (item.kind === 'maintenance' && item.phase === 'in_progress') {
+    const until = clean(item.until, 40);
+    if (item.overrun && until) return `Jaitus is down for maintenance, running past its planned end (${until}). Updates: ${where}`;
+    if (until) return `Jaitus is down for maintenance until ${until}. Updates: ${where}`;
+    return `Jaitus is down for maintenance. Updates: ${where}`;
+  }
+  if (item.kind === 'maintenance' && item.phase === 'upcoming') {
+    const when = clean(item.window, 60);
+    if (!when) return null;
+    return `Planned maintenance ${when}: Jaitus will not answer during it. Details: ${where}`;
+  }
+  return null;
+}
+
+function readShown(file) {
+  try {
+    const v = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return v && typeof v.shown === 'object' && v.shown ? v.shown : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * The one line to show at start-up, or null. A notice is shown at most once a day per
+ * machine; a planned window and the same window in progress are separate notices.
+ */
+export async function startupNotice({ env = process.env, now = Date.now(), file = SHOWN_FILE, fetchNotices: get = fetchNotices, where } = {}) {
+  if (!noticeCheckEnabled(env)) return null;
+  const data = await get().catch(() => null);
+  const items = Array.isArray(data?.cli) ? data.cli : [];
+  if (!items.length) return null;
+  const shown = readShown(file);
+  for (const item of items) {
+    const key = `${item?.id}:${item?.phase}`;
+    if (shown[key] != null && now - Number(shown[key]) < DAY_MS) continue;
+    const line = lineFor(item, where);
+    if (!line) continue;
+    shown[key] = now;
+    // Forget anything a week old, so the file never grows.
+    for (const k of Object.keys(shown)) if (now - Number(shown[k]) > 7 * DAY_MS) delete shown[k];
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, JSON.stringify({ shown }));
+    } catch { /* read-only home: it may show again next start */ }
+    return line;
+  }
+  return null;
+}
+
+const EXPLAINED = new Set(['maintenance', 'unavailable', 'timeout']);
+
+/**
+ * A request that finally failed: add what the status page knows to the error's hint —
+ * when Jaitus is back from maintenance, or which known problem this is. Mutates and
+ * returns `error`; leaves it alone when there is nothing to add or the check fails.
+ */
+export async function explainFailure(error, { baseUrl, fetchNotices: get = fetchNotices, where } = {}) {
+  if (!error || !EXPLAINED.has(error.code)) return error;
+  const data = await get(baseUrl ? { baseUrl } : undefined).catch(() => null);
+  if (!data) return error;
+  const at = where || statusAddress();
+  const m = data.maintenance;
+  if (error.code === 'maintenance' || m?.enabled) {
+    const until = clean(m?.until, 40);
+    error.title = 'Down for maintenance';
+    error.hint = m?.enabled && until
+      ? (m.overrun
+        ? `It was planned to end at ${until} and is running late. Updates: ${at}`
+        : `Jaitus should be back by ${until}. Updates: ${at}`)
+      : `Try again shortly. Updates: ${at}`;
+    return error;
+  }
+  const incident = Array.isArray(data.incidents) ? data.incidents[0] : null;
+  const title = incident ? dropStop(clean(incident.title)) : '';
+  error.hint = title
+    ? `Known problem: ${title}. Updates: ${at}`
+    : `${error.hint ? `${dropStop(error.hint)}. ` : ''}Service status: ${at}`;
+  return error;
+}

package/src/sessions.js

@@ -9,6 +9,7 @@ import crypto from 'node:crypto';
 import { SESSIONS } from './config.js';
 import { c } from './ui.js';
 import { unifiedDiff } from './diff.js';
+import { TOOLS } from './agent/tools.js';
 
 function safeId(id) {
   return String(id || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 80);
@@ -195,6 +196,13 @@ export function replaySession(tui, messages) {
 /** The same one-line summary the live loop shows, without importing the tool table. */
 function summariseCall(call) {
   const input = call.input && typeof call.input === 'object' ? call.input : {};
+  // The same label the row had while the session ran. A second, guessed label here
+  // showed a resumed task list as `{"todos":[{"content":…` and a background read as
+  // `{"id":"bg1"}`.
+  const tool = TOOLS.find((t) => t.name === call.name);
+  if (tool?.summarise) {
+    try { const s = tool.summarise(input); if (s) return String(s); } catch { /* fall back below */ }
+  }
   if (input.command) return String(input.command);
   if (input.path) return String(input.path);
   if (input.pattern) return String(input.pattern);

package/src/tui/ansi.js

@@ -188,6 +188,12 @@ export function truncateRow(row, width, ellipsis = '…') {
  * bullet or a wrapped tool row stay visually attached to its marker.
  */
 export function wrapRow(row, width, indent = '') {
+  // A newline inside a span is a line break, never a character to print: Ink would draw
+  // it as an extra screen line the layout never counted, and every row below it — and
+  // the selection — would be off by one. Pasted multi-line text arrives exactly so.
+  if (row.some((span) => typeof span.t === 'string' && span.t.includes('\n'))) {
+    return splitAtNewlines(row).flatMap((line) => wrapRow(line, width, indent));
+  }
   if (width < 4) return [row];
   if (rowWidth(row) <= width) return [row];
 
@@ -200,10 +206,15 @@ export function wrapRow(row, width, indent = '') {
   // Every line after the first opens with the hanging indent, so a wrapped bullet or a
   // wrapped tool row stays visually attached to its marker instead of resetting to
   // column zero and reading as a new item.
+  // A continuation line is the same line of text, so copying rejoins it (SOFT): the
+  // marker carries what the break swallowed — a space between words, nothing in a word
+  // cut mid-way. The hanging indent is layout, so it is never copied.
+  let breakJoin = ' ';
   const flush = () => {
     lines.push(current.length ? current : [{ t: '' }]);
-    current = indent ? [...indentSpan] : [];
+    current = [{ t: '', soft: breakJoin }, ...(indent ? [{ ...indentSpan[0], copy: '' }] : [])];
     used = indent ? indentWidth : 0;
+    breakJoin = ' ';
   };
 
   for (const span of row) {
@@ -228,6 +239,7 @@ export function wrapRow(row, width, indent = '') {
           // `cut` marks a word split mid-way, so a URL cut here can be rejoined when it is
           // clicked (the renderer ignores the field).
           current.push(piece ? { ...span, t: piece, cut: true } : { ...span, t: piece });
+          breakJoin = '';
           flush();
           piece = '';
           pieceWidth = 0;
@@ -255,6 +267,58 @@ export function wrapRows(rows, width, indent = '') {
 /** The plain text of a row of spans, for selection, search and the clipboard. */
 export const rowText = (row) => (row || []).map((span) => span.t).join('');
 
+/** One row with newlines in its spans → one row per line, styles kept. */
+export function splitAtNewlines(row) {
+  const lines = [[]];
+  for (const span of row) {
+    const parts = String(span.t ?? '').split('\n');
+    parts.forEach((part, i) => {
+      if (i > 0) lines.push([]);
+      if (part) lines[lines.length - 1].push({ ...span, t: part });
+    });
+  }
+  return lines.map((line) => (line.length ? line : [{ t: '' }]));
+}
+
+// ── Copying what is on screen ──────────────────────────────────────────────────
+//
+// A row on screen is source text plus decoration: the bar beside a message, a code
+// block's gutter and frame, a quote mark, a table's column rules, a bullet glyph, the
+// indent under a wrapped line. A span says what it contributes to a COPY with `copy`
+// (absent = its own text; '' = nothing; '- ' for a bullet), and a wrapped line says how
+// it rejoins the line above with a `soft` marker. Copying a command out of an answer
+// used to bring the gutter's ▐ (| in plain terminals) and the bullet with it.
+
+/** True for a row that is decoration only (a code block's frame, a rule). */
+export const isDecorationRow = (row) => (row || []).length > 0
+  && row.every((span) => span.copy === '' || !span.t)
+  && row.some((span) => span.t && span.copy === '');
+
+/** How a row joins the row above when both are copied: null = a new line. */
+export const softJoin = (row) => {
+  const marker = (row || []).find((span) => span.soft !== undefined);
+  return marker ? marker.soft : null;
+};
+
+/** The copy text of the cells [from, to) of a row (string offsets, as selection uses). */
+export function copyText(row, from = 0, to = Infinity) {
+  let at = 0;
+  let out = '';
+  for (const span of row || []) {
+    const t = String(span.t ?? '');
+    const start = at;
+    const end = at + t.length;
+    at = end;
+    if (end <= from || start >= to) {
+      // A zero-width marker inside the range still counts (it is how bullets survive).
+      if (!(t.length === 0 && start >= from && start < to)) continue;
+    }
+    if (span.copy !== undefined) { out += span.copy; continue; }
+    out += t.slice(Math.max(0, from - start), Math.min(t.length, to - start));
+  }
+  return out;
+}
+
 /**
  * Invert the cells between two columns of a row, splitting spans where the range falls
  * inside one. Used to show a drag selection: the terminal's own highlight is gone once

package/src/tui/entries.js

@@ -137,12 +137,18 @@ const BUILDERS = {
   // ── What the user said ───────────────────────────────────────────────────────
   user(data, width) {
     const p = palette();
-    const bar = { t: pick(['▌', '|']), color: p.brand };
+    // One mark beside the message, on its first row — not a bar on every row: a pasted
+    // command or log used to arrive striped with ▌ (| in plain terminals) down its whole
+    // length. Later rows sit under the text, indented. Neither is ever copied.
+    const bar = { t: pick(['▌', '|']), color: p.brand, copy: '' };
+    const gap = { t: ' ', copy: '' };
+    const indent = { t: '  ', copy: '' };
     const inner = Math.max(12, width - 2);
-    const body = wrapRow([{ t: String(data.text || ''), color: p.body, bold: true }], inner);
-    const rows = body.map((row) => [bar, { t: ' ' }, ...row]);
+    const text = String(data.text || '').replace(/\r\n?/g, '\n').replace(/\t/g, '    ');
+    const body = wrapRow([{ t: text, color: p.body, bold: true }], inner);
+    const rows = body.map((row, index) => (index === 0 ? [bar, gap, ...row] : [indent, ...row]));
     if (data.attachments?.length) {
-      rows.push([bar, { t: ' ' }, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
+      rows.push([indent, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
     }
     return rows;
   },
@@ -156,8 +162,8 @@ const BUILDERS = {
     // A lead mark on the first row only: it identifies the speaker without spending a
     // whole line on a name label, and the indent keeps the column under it aligned.
     return body.map((row, index) => (index === 0
-      ? [{ t: pick(['● ', '* ']), color: p.teal }, ...row]
-      : [{ t: '  ' }, ...row]));
+      ? [{ t: pick(['● ', '* ']), color: p.teal, copy: '' }, ...row]
+      : [{ t: '  ', copy: '' }, ...row]));
   },
 
   // ── A tool call ──────────────────────────────────────────────────────────────
@@ -197,11 +203,11 @@ const BUILDERS = {
         const tinted = highlightLine(line.replace(/\t/g, '  '), language, state);
         state = tinted.state;
         const spans = tinted.spans.length ? tinted.spans : [{ t: '' }];
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, ...truncateRow(spans, Math.max(8, width - 6))]);
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft, copy: '' }, ...truncateRow(spans, Math.max(8, width - 6))]);
       }
       if (preview.more > 0) {
         const hint = openable && !data.expanded ? ' — click the row to show all' : '';
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft, copy: '' }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
       }
     }
     return rows;
@@ -262,7 +268,7 @@ const BUILDERS = {
   error(data, width) {
     const p = palette();
     const rows = [];
-    const bar = { t: pick(['▌', '|']), color: p.red };
+    const bar = { t: pick(['▌', '|']), color: p.red, copy: '' };
     const inner = Math.max(12, width - 2);
 
     rows.push([bar, { t: ' ' }, { t: `${pick(['✗', 'x'])} ${data.title || 'Error'}`, color: p.red, bold: true }]);

package/src/tui/markdown.js

@@ -122,14 +122,14 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
       for (const row of wrapRow(content, w)) rows.push(row);
       if (level <= 2) {
         const ruleWidth = Math.min(w, Math.max(8, contentWidth(content)));
-        rows.push([{ t: (level === 1 ? g('━', '=') : g('─', '-')).repeat(ruleWidth), color: level === 1 ? p.brandDeep : p.line }]);
+        rows.push([{ t: (level === 1 ? g('━', '=') : g('─', '-')).repeat(ruleWidth), color: level === 1 ? p.brandDeep : p.line, copy: '' }]);
       }
       i += 1;
       continue;
     }
 
     // ── horizontal rule ────────────────────────────────────────────────────────
-    if (RULE.test(line)) { rows.push([{ t: g('─', '-').repeat(w), color: p.line }]); i += 1; continue; }
+    if (RULE.test(line)) { rows.push([{ t: g('─', '-').repeat(w), color: p.line, copy: '' }]); i += 1; continue; }
 
     // ── blockquote ─────────────────────────────────────────────────────────────
     const quote = QUOTE.exec(line);
@@ -138,7 +138,7 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
       while (i < lines.length && QUOTE.test(lines[i])) { body.push(QUOTE.exec(lines[i])[1]); i += 1; }
       if (!compact) blank();
       for (const inner of renderMarkdown(body.join('\n'), w - 2, { compact: true })) {
-        rows.push([{ t: g('▏ ', '| '), color: p.teal }, ...inner]);
+        rows.push([{ t: g('▏ ', '| '), color: p.teal, copy: '> ' }, ...inner]);
       }
       if (!compact) rows.push([]);
       continue;
@@ -159,10 +159,10 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
         const done = !!task && /[xX]/.test(task[1]);
         let marker;
         if (task) {
-          marker = { t: done ? g('✔ ', '[x] ') : g('○ ', '[ ] '), color: done ? p.green : p.dim };
+          marker = { t: done ? g('✔ ', '[x] ') : g('○ ', '[ ] '), color: done ? p.green : p.dim, copy: done ? '- [x] ' : '- [ ] ' };
           content = task[2];
         } else if (b) {
-          marker = { t: `${(ascii() ? ['-', '*', '+'] : ['•', '◦', '▪'])[depth % 3]} `, color: p.brand };
+          marker = { t: `${(ascii() ? ['-', '*', '+'] : ['•', '◦', '▪'])[depth % 3]} `, color: p.brand, copy: '- ' };
         } else {
           marker = { t: `${o[2]}. `, color: p.brand };
         }
@@ -206,6 +206,28 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
 
 const contentWidth = (spans) => spans.reduce((sum, s) => sum + stringWidth(s.t), 0);
 
+/** Spans cut into rows of at most `width` cells, character by character, styles kept. */
+function hardWrap(spans, width) {
+  const rows = [[]];
+  let used = 0;
+  for (const span of spans) {
+    let piece = '';
+    for (const ch of String(span.t ?? '')) {
+      const cw = stringWidth(ch);
+      if (used + cw > width && used > 0) {
+        if (piece) rows[rows.length - 1].push({ ...span, t: piece });
+        rows.push([]);
+        piece = '';
+        used = 0;
+      }
+      piece += ch;
+      used += cw;
+    }
+    if (piece) rows[rows.length - 1].push({ ...span, t: piece });
+  }
+  return rows.map((r) => (r.length ? r : [{ t: '' }]));
+}
+
 /**
  * A fenced block: a language tag, a tinted body, and a left gutter that makes the code
  * a distinct object on the page without the cost of a full border (which would eat two
@@ -214,14 +236,14 @@ const contentWidth = (spans) => spans.reduce((sum, s) => sum + stringWidth(s.t),
 function codeBlock(body, language, width) {
   const p = palette();
   const rows = [];
-  const gutter = { t: g('▐ ', '| '), color: p.tealDeep };
+  const gutter = { t: g('▐ ', '| '), color: p.tealDeep, copy: '' };
   const label = language && isKnownLanguage(language) ? language : language || '';
   const inner = Math.max(8, width - 2);
 
   rows.push([
-    { t: g('▛', '+'), color: p.tealDeep },
-    { t: label ? `${g('─', '-')} ${label} ` : g('─', '-'), color: p.dim },
-    { t: g('─', '-').repeat(Math.max(0, width - 2 - (label ? label.length + 3 : 1))), color: p.lineSoft },
+    { t: g('▛', '+'), color: p.tealDeep, copy: '' },
+    { t: label ? `${g('─', '-')} ${label} ` : g('─', '-'), color: p.dim, copy: '' },
+    { t: g('─', '-').repeat(Math.max(0, width - 2 - (label ? label.length + 3 : 1))), color: p.lineSoft, copy: '' },
   ]);
 
   let state = {};
@@ -231,11 +253,13 @@ function codeBlock(body, language, width) {
     state = result.state;
     const spans = result.spans.length ? result.spans : [{ t: '' }];
     // Code is not prose: wrapping it on spaces would move a token onto a line where it
-    // does not belong. Long lines are cut with a marker instead, which is honest about
-    // there being more and keeps the block rectangular.
-    rows.push([gutter, ...truncateRow(spans, inner, g('›', '>'))]);
+    // does not belong — so a long line is cut at the edge, character by character, and
+    // carries on under a fainter gutter. It used to be cut off with › and the rest was
+    // gone: a long command copied out of an answer came back truncated.
+    const pieces = hardWrap(spans, inner);
+    pieces.forEach((piece, k) => rows.push(k === 0 ? [gutter, ...piece] : [{ ...gutter, t: g('┆ ', ': '), color: p.faint }, { t: '', soft: '' }, ...piece]));
   }
-  rows.push([{ t: g('▙', '+'), color: p.tealDeep }, { t: g('─', '-').repeat(Math.max(0, width - 2)), color: p.lineSoft }]);
+  rows.push([{ t: g('▙', '+'), color: p.tealDeep, copy: '' }, { t: g('─', '-').repeat(Math.max(0, width - 2)), color: p.lineSoft, copy: '' }]);
   return rows;
 }
 
@@ -265,7 +289,8 @@ function table(block, width) {
     const header = index === 0;
     const spans = [];
     for (let col = 0; col < columns; col++) {
-      if (col) spans.push({ t: g(' │ ', ' | '), color: p.line });
+      // Copied as a tab: a table pasted into a sheet lands in cells.
+      if (col) spans.push({ t: g(' │ ', ' | '), color: p.line, copy: '\t' });
       const content = truncateRow(inlineSpans(row[col] || '', header ? { bold: true, color: p.tealSoft } : {}), widths[col]);
       spans.push(...content);
       const gap = widths[col] - contentWidth(content);
@@ -273,7 +298,7 @@ function table(block, width) {
     }
     rows.push(spans);
     if (header) {
-      rows.push(widths.flatMap((w, col) => (col ? [{ t: g('─┼─', '-+-'), color: p.line }, { t: g('─', '-').repeat(w), color: p.line }] : [{ t: g('─', '-').repeat(w), color: p.line }])));
+      rows.push(widths.flatMap((w, col) => (col ? [{ t: g('─┼─', '-+-'), color: p.line, copy: '' }, { t: g('─', '-').repeat(w), color: p.line, copy: '' }] : [{ t: g('─', '-').repeat(w), color: p.line, copy: '' }])));
     }
   });
   return rows;