@jossuealcala/madre 1.0.2 → 1.0.4

package/public/tour.js

@@ -24,6 +24,8 @@ import { CHAPTERS, GESTURES, ORDER } from './tour-chapters.js';
 const say = (pair) => (typeof pair === 'string' ? pair : pair?.[language()] ?? pair?.es ?? '');
 const fill = (template, vars) => template.replace(/\{(\w+)\}/g, (whole, name) => (Object.hasOwn(vars, name) ? String(vars[name]) : whole));
 const still = () => typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
+// Up, turned for down: the way to a hint whose place is out of view.
+const ARROW_UP = '<svg viewBox="0 0 20 20" aria-hidden="true"><path d="M10 15.5V4.5M5.5 9 10 4.5 14.5 9" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"/></svg>';
 const CLOSE_ICON = '<svg viewBox="0 0 20 20" aria-hidden="true"><path d="M5.5 5.5l9 9M14.5 5.5l-9 9" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>';
 const FOLDER = '<svg viewBox="0 0 32 26" aria-hidden="true"><path d="M2 5.5A2.5 2.5 0 0 1 4.5 3h7.2l3 3.2h12.8A2.5 2.5 0 0 1 30 8.7v12.8a2.5 2.5 0 0 1-2.5 2.5h-23A2.5 2.5 0 0 1 2 21.5z" fill="currentColor"/></svg>';
 const ROBOT = '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="5" y="8" width="14" height="11" rx="3.5" fill="none" stroke="currentColor" stroke-width="1.8"/><path d="M12 4.5V8M3 13v2M21 13v2" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/><circle cx="9.5" cy="13.5" r="1.3" fill="currentColor"/><circle cx="14.5" cy="13.5" r="1.3" fill="currentColor"/></svg>';
@@ -104,7 +106,7 @@ export function spotlight(node) {
   window.addEventListener('resize', place);
   window.addEventListener('scroll', place, true);
   place();
-  return { place, remove };
+  return { place, remove, node: spot };
 }
 
 // `onChange` hears the kept state each time it is known or changes (null if it could not be read).
@@ -517,15 +519,22 @@ export function startTour({ page, go = {}, ready = () => true, phone = false, de
     card.setAttribute('role', 'note');
     card.append(el('span', 'tour-hint-eyebrow', t('The first time')), el('b', null, title), el('p', null, text));
     let spot = null;
+    let away = null;
+    let follow = null;
     const done = () => {
       if (!hintNode) return;
       void keep({ hint: id });
       spot?.remove();
       card.remove();
+      away?.remove();
       hintNode = null;
       document.removeEventListener('keydown', onKey, true);
+      if (follow) { window.removeEventListener('scroll', follow, true); window.removeEventListener('resize', follow); }
     };
-    const onKey = (event) => { if (event.key === 'Escape' && hintNode && !inside) { event.stopPropagation(); done(); } };
+    // Esc puts away the hint in sight, or the one its way-there key speaks of; one hidden under a
+    // layer (the Project map) is not the one meant.
+    const shown = (node) => Boolean(node?.isConnected) && getComputedStyle(node).display !== 'none';
+    const onKey = (event) => { if (event.key === 'Escape' && hintNode && !inside && (shown(card) || shown(away))) { event.stopPropagation(); done(); } };
     card.append(key('tour-btn small primary', t('Got it'), done));
     hintNode = card;
     if (inside) {
@@ -541,11 +550,44 @@ export function startTour({ page, go = {}, ready = () => true, phone = false, de
     const width = Math.min(300, window.innerWidth - 24);
     card.style.width = `${width}px`;
     const height = card.getBoundingClientRect().height;
-    const onTheRight = box.left + box.width / 2 > window.innerWidth / 2;
-    const left = Math.max(12, Math.min(window.innerWidth - width - 12, onTheRight ? box.right - width : box.left));
-    const below = box.bottom + 10 + height < window.innerHeight;
-    Object.assign(card.style, { left: `${left}px`, top: `${below ? box.bottom + 10 : Math.max(12, box.top - height - 10)}px` });
+    // When the place is scrolled out of view (or was never in it: a widget below the fold), the
+    // bubble does not stay behind on its own, out of reach (2026-10-17): it steps aside, and a key at
+    // the edge the place went past says where it is and takes the page there.
+    away = key('tour-hint-away', '', () => anchor.scrollIntoView?.({ block: 'center', behavior: still() ? 'auto' : 'smooth' }));
+    away.hidden = true;
+    if (typeof away.showPopover === 'function') away.popover = 'manual';
+    document.body.append(away);
+    const sayAway = (up) => {
+      away.dataset.side = up ? 'up' : 'down';
+      away.innerHTML = ARROW_UP; // trusted: our own SVG string
+      away.append(el('b', null, title), el('span', null, up ? t('Scroll up to see it') : t('Scroll down to see it')));
+      away.setAttribute('aria-label', `${title} · ${up ? t('Scroll up to see it') : t('Scroll down to see it')}`);
+    };
+    const place = () => {
+      if (!anchor.isConnected) { done(); return; }
+      const at = anchor.getBoundingClientRect();
+      const out = at.bottom < 8 ? 'up' : at.top > window.innerHeight - 8 ? 'down' : null;
+      card.hidden = Boolean(out);
+      if (out && away.dataset.side !== out) sayAway(out === 'up');
+      if (out && away.hidden) { away.hidden = false; try { away.showPopover?.(); } catch { /* on the page */ } }
+      if (!out && !away.hidden) { away.hidden = true; delete away.dataset.side; try { away.hidePopover?.(); } catch { /* on the page */ } }
+      if (out) return;
+      const onTheRight = at.left + at.width / 2 > window.innerWidth / 2;
+      const left = Math.max(12, Math.min(window.innerWidth - width - 12, onTheRight ? at.right - width : at.left));
+      const below = at.bottom + 10 + height < window.innerHeight;
+      Object.assign(card.style, { left: `${left}px`, top: `${below ? at.bottom + 10 : Math.max(12, at.top - height - 10)}px` });
+    };
     spot = spotlight(anchor);
+    follow = () => place();
+    window.addEventListener('scroll', follow, true);
+    window.addEventListener('resize', follow);
+    place();
+    // Where it points: on the page, or on a layer over it (Home's Project map). A layer opened over
+    // the page hides the hints that point under it, and they come back when it closes (salas-mac.css).
+    const layer = anchor.closest?.('.mv') ? 'map' : 'page';
+    card.dataset.under = layer;
+    away.dataset.under = layer;
+    if (spot.node) spot.node.dataset.under = layer;
     document.addEventListener('keydown', onKey, true);
     return true;
   }

package/public/troubleshooting.js

@@ -36,6 +36,10 @@ const installAgent = {
     darwin: ['brew install opencode', '# or: npm install -g opencode-ai'],
     linux: ['curl -fsSL https://opencode.ai/install | bash', '# or: npm install -g opencode-ai']
   },
+  cursor: {
+    darwin: ['curl https://cursor.com/install -fsS | bash'],
+    linux: ['curl https://cursor.com/install -fsS | bash']
+  },
 };
 
 const loginAgent = {
@@ -43,6 +47,7 @@ const loginAgent = {
   claude: { darwin: ['claude auth login', 'claude auth status --text'], linux: ['claude auth login', 'claude auth status --text']},
   gemini: { darwin: ['gemini', '# inside gemini: /auth  → "Use Gemini API key" or Google login'], linux: ['gemini', '# inside gemini: /auth']},
   opencode: { darwin: ['opencode auth login', 'opencode auth list'], linux: ['opencode auth login', 'opencode auth list']},
+  cursor: { darwin: ['cursor-agent login', 'cursor-agent status'], linux: ['cursor-agent login', 'cursor-agent status']},
 };
 
 const same = (commands) => ({ darwin: commands, linux: commands });
@@ -706,7 +711,7 @@ export const allConditions = () => CONDITIONS.map(said);
 
 // Lowercase and without accents: «limite» finds «límite», and a person types what they type.
 const fold = (text) => String(text ?? '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
-const AGENT_WORDS = new Set(['codex', 'claude', 'gemini', 'opencode', 'madre', 'ollama']);
+const AGENT_WORDS = new Set(['codex', 'claude', 'gemini', 'opencode', 'cursor', 'madre', 'ollama']);
 
 export function searchConditions(query) {
   const words = fold(query).split(/[^a-z0-9#.@_-]+/).filter(Boolean);

package/public/wallpaper.js

@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
+// Your own wallpaper (1.0.3): a picture of yours behind MADRE, fitted to the screen like the ones
+// that ship. The page does here what was done by hand for each of those (wallpapers/ →
+// public/assets/wallpapers, and their colours in styles.css): it reads the picture, keeps its
+// longest side at SIDE, encodes it, and takes its colours for the veil, the mesh and the tint. The
+// server keeps it once for every page (src/looks.mjs); each page still chooses it or not. Shared by
+// the room (app.js) and Home (salas-mac.js), which each draw it with their own keys.
+import { t } from './i18n.js';
+
+export const CUSTOM_WALL = 'custom';
+const SIDE = 2880;
+const READ_MAX = 40 * 1024 * 1024;
+const SEND_MAX = 8 * 1024 * 1024;
+const META_KEY = 'pulse.wallpaper.custom';
+const PLUS_ICON = '<svg viewBox="0 0 20 20" aria-hidden="true"><path d="M10 4.5v11M4.5 10h11" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>';
+
+const node = (tag, className, text) => {
+  const made = document.createElement(tag);
+  if (className) made.className = className;
+  if (text !== undefined && text !== null) made.textContent = text;
+  return made;
+};
+
+let current = null;
+export const customWall = () => current;
+// The last picture this browser knew, so a page paints with it before the server answers.
+export function rememberedWall() {
+  try { return JSON.parse(localStorage.getItem(META_KEY) ?? 'null'); } catch { return null; }
+}
+
+// The picture and its colours, as variables on the root (styles.css, --wpc-*): every wallpaper rule
+// reads them. `null` takes them away; a page that had chosen it then wears no picture.
+const VARIABLES = ['--wpc-url', '--wpc-pos', '--wpc-veil-d', '--wpc-veil-l', '--wpc-tint-d', '--wpc-tint-l', '--wpc-m1-d', '--wpc-m2-d', '--wpc-m3-d', '--wpc-m1-l', '--wpc-m2-l', '--wpc-m3-l'];
+export function paintCustomWall(meta, root = globalThis.document?.documentElement) {
+  current = meta ?? null;
+  try { if (current) localStorage.setItem(META_KEY, JSON.stringify(current)); else localStorage.removeItem(META_KEY); } catch { /* this page only */ }
+  const style = root?.style;
+  if (!style?.setProperty) return;
+  if (!current) { for (const name of VARIABLES) style.removeProperty(name); return; }
+  const rgb = (colour) => colour.join(' ');
+  const { dark, light } = current.palette;
+  style.setProperty('--wpc-url', `url("/api/looks/wallpaper?v=${current.v}")`);
+  style.setProperty('--wpc-pos', `${current.focus.x}% ${current.focus.y}%`);
+  style.setProperty('--wpc-veil-d', rgb(dark.veil));
+  style.setProperty('--wpc-veil-l', rgb(light.veil));
+  style.setProperty('--wpc-tint-d', rgb(dark.tint));
+  style.setProperty('--wpc-tint-l', rgb(light.tint));
+  dark.mesh.forEach((colour, index) => style.setProperty(`--wpc-m${index + 1}-d`, rgb(colour)));
+  light.mesh.forEach((colour, index) => style.setProperty(`--wpc-m${index + 1}-l`, rgb(colour)));
+}
+
+// Its colours, the way the shipped ones were taken: the whole for the veil and the tint, and three
+// corners for the mesh (top left, right, bottom), each pressed towards the theme's ground.
+function paletteOf(source) {
+  const canvas = node('canvas');
+  canvas.width = 48;
+  canvas.height = 32;
+  const ink = canvas.getContext('2d', { willReadFrequently: true });
+  ink.drawImage(source, 0, 0, 48, 32);
+  const { data } = ink.getImageData(0, 0, 48, 32);
+  const average = (x0, y0, x1, y1) => {
+    const sum = [0, 0, 0];
+    let count = 0;
+    for (let y = y0; y < y1; y += 1) {
+      for (let x = x0; x < x1; x += 1) {
+        const at = (y * 48 + x) * 4;
+        if (data[at + 3] < 16) continue;
+        sum[0] += data[at]; sum[1] += data[at + 1]; sum[2] += data[at + 2];
+        count += 1;
+      }
+    }
+    return count ? sum.map((value) => value / count) : [128, 128, 128];
+  };
+  const toward = (colour, ground, k) => colour.map((value, index) => Math.max(0, Math.min(255, Math.round(value * (1 - k) + ground[index] * k))));
+  const black = [0, 0, 0];
+  const white = [255, 255, 255];
+  const whole = average(0, 0, 48, 32);
+  const corners = [average(0, 0, 20, 13), average(28, 0, 48, 19), average(8, 20, 40, 32)];
+  return {
+    dark: { veil: toward(whole, black, 0.93), tint: toward(whole, black, 0.86), mesh: [toward(corners[0], black, 0.76), toward(corners[1], black, 0.66), toward(corners[2], black, 0.88)] },
+    light: { veil: toward(whole, white, 0.94), tint: toward(whole, white, 0.95), mesh: [toward(corners[0], white, 0.88), toward(corners[1], white, 0.92), toward(corners[2], white, 0.86)] },
+  };
+}
+
+const encode = (canvas, type, quality) => new Promise((resolve) => canvas.toBlob(resolve, type, quality));
+// The picture fitted and encoded, with its size and its colours. WebP where the browser writes it,
+// JPEG where it does not; smaller again if it still weighs more than the server keeps.
+export async function prepareWallpaper(file) {
+  if (!file) throw new Error(t('Choose a picture: a PNG, JPEG or WebP file.'));
+  if (file.size > READ_MAX) throw new Error(t('That picture is too large to read (more than 40 MB).'));
+  let bitmap;
+  try { bitmap = await createImageBitmap(file); } catch { throw new Error(t('That picture could not be read. Try a PNG, JPEG or WebP.')); }
+  const scale = Math.min(1, SIDE / Math.max(bitmap.width, bitmap.height));
+  const w = Math.max(1, Math.round(bitmap.width * scale));
+  const h = Math.max(1, Math.round(bitmap.height * scale));
+  const canvas = node('canvas');
+  canvas.width = w;
+  canvas.height = h;
+  const ink = canvas.getContext('2d');
+  ink.imageSmoothingQuality = 'high';
+  ink.drawImage(bitmap, 0, 0, w, h);
+  const palette = paletteOf(bitmap);
+  bitmap.close?.();
+  let blob = await encode(canvas, 'image/webp', 0.86);
+  if (!blob || blob.type !== 'image/webp') blob = await encode(canvas, 'image/jpeg', 0.88);
+  for (const quality of [0.74, 0.6]) if (blob && blob.size > SEND_MAX) blob = await encode(canvas, blob.type, quality);
+  if (!blob || blob.size > SEND_MAX) throw new Error(t('That picture could not be prepared.'));
+  return { blob, w, h, palette };
+}
+
+export async function uploadWallpaper(file, { focus = { x: 50, y: 50 } } = {}) {
+  const { blob, w, h, palette } = await prepareWallpaper(file);
+  const response = await fetch('/api/looks/wallpaper', {
+    method: 'PUT',
+    headers: { 'content-type': blob.type, 'x-madre-wallpaper': encodeURIComponent(JSON.stringify({ w, h, focus, palette })) },
+    body: blob,
+  });
+  const answer = await response.json().catch(() => ({}));
+  if (!response.ok || !answer.custom) throw new Error(answer.error ?? t('That picture could not be kept.'));
+  return answer.custom;
+}
+async function sendFrame(focus) {
+  const response = await fetch('/api/looks/wallpaper/frame', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(focus) });
+  const answer = await response.json().catch(() => ({}));
+  return response.ok ? answer.custom ?? null : null;
+}
+async function dropWallpaper() {
+  await fetch('/api/looks/wallpaper', { method: 'DELETE' }).catch(() => null);
+}
+
+// The browser's own chooser, opened from the press that asked for it.
+export function pickPicture() {
+  return new Promise((resolve) => {
+    const input = node('input');
+    input.type = 'file';
+    input.accept = 'image/png,image/jpeg,image/webp,image/avif,image/gif';
+    input.addEventListener('change', () => resolve(input.files?.[0] ?? null), { once: true });
+    input.addEventListener('cancel', () => resolve(null), { once: true });
+    input.click();
+  });
+}
+
+// The tile among the wallpapers: the picture when there is one; a «+» to add it when there is not.
+export function customTile(paper, meta) {
+  paper.dataset.wp = CUSTOM_WALL;
+  paper.classList.toggle('paper-add', !meta);
+  const swatch = node('span', 'paper-swatch');
+  if (!meta) swatch.innerHTML = PLUS_ICON; // trusted: our own SVG string
+  paper.append(swatch, node('span', 'paper-name', t('Your picture')));
+  if (!meta) paper.title = t('Choose a picture of yours as the wallpaper');
+  return paper;
+}
+
+// Adding it: the chooser, the picture prepared and kept, and then it is this page's wallpaper.
+// `busy` marks the tile while that happens; `chosen` hands the kept picture back.
+export async function addPicture({ busy = null, chosen, failed }) {
+  const file = await pickPicture();
+  if (!file) return;
+  busy?.classList.add('busy');
+  busy?.setAttribute('aria-busy', 'true');
+  try {
+    const meta = await uploadWallpaper(file);
+    paintCustomWall(meta);
+    chosen(meta);
+  } catch (error) {
+    failed(error.message);
+  } finally {
+    busy?.classList.remove('busy');
+    busy?.removeAttribute('aria-busy');
+  }
+}
+
+// The frame drawn last follows the window's proportions; one listener for the page, not one per drawing.
+let placeFrame = null;
+globalThis.addEventListener?.('resize', () => placeFrame?.());
+
+// Under the tiles while it is chosen: where the screen falls on the picture, and the picture
+// changed or taken away. The whole picture, and over it the part the screen shows, in the screen's
+// own proportions; carried by hand (or by the arrows) to the part that should stay in view.
+export function customTools(meta, { changed, removed, failed, button }) {
+  const box = node('div', 'wall-tools');
+  const head = node('div', 'wall-tools-head');
+  const words = node('div', 'wall-tools-words');
+  words.append(node('b', null, t('Framing')));
+  const hint = node('span', 'wall-tools-hint');
+  words.append(hint);
+  head.append(words);
+  const frame = node('div', 'wall-frame');
+  const fit = node('span', 'wall-frame-fit');
+  const picture = node('img', 'wall-frame-pic');
+  picture.alt = '';
+  picture.src = `/api/looks/wallpaper?v=${meta.v}`;
+  picture.draggable = false;
+  const view = node('span', 'wall-frame-view');
+  view.tabIndex = 0;
+  view.setAttribute('role', 'slider');
+  view.setAttribute('aria-label', t('Framing of your picture'));
+  fit.append(picture, view);
+  frame.append(fit);
+  let focus = { ...meta.focus };
+  const sides = () => {
+    const pictureRatio = meta.w / meta.h;
+    const screen = (globalThis.innerWidth || 16) / (globalThis.innerHeight || 9);
+    return { fw: Math.min(1, screen / pictureRatio), fh: Math.min(1, pictureRatio / screen) };
+  };
+  const free = () => { const { fw, fh } = sides(); return fw < 0.995 ? 'x' : fh < 0.995 ? 'y' : null; };
+  const place = () => {
+    const { fw, fh } = sides();
+    view.style.width = `${fw * 100}%`;
+    view.style.height = `${fh * 100}%`;
+    view.style.left = `${(1 - fw) * focus.x}%`;
+    view.style.top = `${(1 - fh) * focus.y}%`;
+    const axis = free();
+    frame.dataset.free = axis ?? 'none';
+    hint.textContent = axis ? t('Drag the frame to choose which part of your picture stays in view.') : t('Your picture fills the screen as it is.');
+    view.setAttribute('aria-valuetext', `${Math.round(axis === 'y' ? focus.y : focus.x)}%`);
+  };
+  const live = () => globalThis.document?.documentElement?.style?.setProperty('--wpc-pos', `${focus.x}% ${focus.y}%`);
+  const settle = async () => {
+    const kept = await sendFrame(focus);
+    if (kept) { paintCustomWall(kept); changed(kept, { reframed: true }); } else failed(t('The framing could not be kept.'));
+  };
+  const clamp = (value) => Math.max(0, Math.min(100, Math.round(value * 10) / 10));
+  const follow = (event) => {
+    const area = fit.getBoundingClientRect();
+    const { fw, fh } = sides();
+    const u = (event.clientX - area.left) / area.width;
+    const v = (event.clientY - area.top) / area.height;
+    if (fw < 0.995) focus.x = clamp(((u - fw / 2) / (1 - fw)) * 100);
+    if (fh < 0.995) focus.y = clamp(((v - fh / 2) / (1 - fh)) * 100);
+    place();
+    live();
+  };
+  fit.addEventListener('pointerdown', (event) => {
+    if (!free()) return;
+    event.preventDefault();
+    fit.setPointerCapture?.(event.pointerId);
+    frame.classList.add('moving');
+    follow(event);
+    const move = (next) => follow(next);
+    const up = () => {
+      fit.removeEventListener('pointermove', move);
+      frame.classList.remove('moving');
+      void settle();
+    };
+    fit.addEventListener('pointermove', move);
+    fit.addEventListener('pointerup', up, { once: true });
+    fit.addEventListener('pointercancel', up, { once: true });
+  });
+  view.addEventListener('keydown', (event) => {
+    const axis = free();
+    const step = { ArrowLeft: -5, ArrowUp: -5, ArrowRight: 5, ArrowDown: 5 }[event.key];
+    if (!axis || step === undefined) return;
+    event.preventDefault();
+    focus[axis] = clamp(focus[axis] + step);
+    place();
+    live();
+    void settle();
+  });
+  picture.addEventListener('load', place, { once: true });
+  placeFrame = place;
+  place();
+  const acts = node('div', 'wall-tools-acts');
+  const change = button(t('Change picture'), () => void addPicture({ busy: change, chosen: (kept) => changed(kept, { reframed: false }), failed }));
+  const remove = button(t('Remove'), async () => {
+    remove.disabled = true;
+    await dropWallpaper();
+    paintCustomWall(null);
+    removed();
+  });
+  acts.append(change, remove);
+  box.append(head, frame, acts);
+  return box;
+}

package/src/adapters/cursor.mjs

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
+// Cursor's agent CLI (`cursor-agent`, 2026.05), added 2026-10-17. It reads only: every turn runs in
+// Cursor's own ask mode (`--mode ask`, «Q&A style, read-only») under a configuration made for the
+// turn and removed after it (CURSOR_CONFIG_DIR), which denies every command and every write and
+// keeps the sandbox off. Print mode alone would give it every tool, write and shell included, so
+// neither is ever left out. Its sign-in lives in the system keychain, not in that folder, so the
+// turn keeps the person's session and nothing else of their settings.
+//
+// Tried against the real CLI on 2026-10-17: it read and answered; asked to create a file and to run
+// `touch`, it wrote nothing and said it was in Ask mode. `--sandbox enabled` was dropped: on a Mac
+// where Cursor's sandbox is not available the run ends at once («Sandbox mode is enabled but not
+// available on this system»). Writing (#2 and up) waits for its own trial (capabilities.mjs).
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runReadonlyProcess } from './process.mjs';
+
+// What the turn's own configuration allows: reading, and nothing else.
+export const READONLY_CONFIG = {
+  version: 1,
+  permissions: { allow: [], deny: ['Shell(*)', 'Write(**)'] },
+  approvalMode: 'allowlist',
+  sandbox: { mode: 'disabled' },
+};
+
+export function buildCursorArgs({ projectRoot, prompt, model = process.env.PULSE_CURSOR_MODEL || null }) {
+  return [
+    '--print',
+    '--output-format', 'stream-json',
+    '--mode', 'ask',
+    // A headless run cannot answer the «trust this folder?» question; the project is the human's.
+    '--trust',
+    '--workspace', projectRoot,
+    ...(model && model !== 'auto' ? ['--model', model] : []),
+    prompt,
+  ];
+}
+
+export function cursorEnvironment(environment = process.env, { configDir = null } = {}) {
+  // A turn never opens a browser: a sign-in is the room's to start, from Settings › Agents.
+  return { ...environment, NO_OPEN_BROWSER: '1', ...(configDir ? { CURSOR_CONFIG_DIR: configDir } : {}) };
+}
+
+// `--output-format stream-json` writes one JSON object per line and closes with a `result` line
+// that carries the whole answer and, when the CLI has it, the turn's tokens. The assistant lines
+// before it are the same text in pieces: read when the result never came (the run was cut short).
+export function parseCursorOutput(output) {
+  const pieces = [];
+  let result = null;
+  let usage = null;
+  let error = null;
+  for (const line of String(output ?? '').split('\n').filter(Boolean)) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    if (event?.type === 'assistant') {
+      for (const part of event.message?.content ?? []) if (part?.type === 'text' && typeof part.text === 'string') pieces.push(part.text);
+    }
+    if (event?.type === 'result') {
+      if (event.is_error) error = typeof event.result === 'string' && event.result.trim() ? event.result.trim() : 'Cursor returned an error.';
+      else if (typeof event.result === 'string') result = event.result;
+      const tokens = event.usage;
+      if (tokens && typeof tokens === 'object') {
+        const input = Number(tokens.inputTokens ?? tokens.input_tokens ?? 0);
+        const output = Number(tokens.outputTokens ?? tokens.output_tokens ?? 0);
+        const cached = Number(tokens.cacheReadTokens ?? tokens.cache_read_tokens ?? 0);
+        usage = { inputTokens: input, cachedInputTokens: cached, outputTokens: output, reasoningTokens: 0, totalTokens: input + output, costUsd: null, source: 'cursor-json' };
+      }
+    }
+    if (event?.type === 'error' && !error) error = String(event.error?.message ?? event.message ?? 'Cursor returned an error.');
+  }
+  // A run that ended in an error answers nothing, so the room reports the error, not a fragment.
+  const text = error ? '' : (result ?? pieces.join('')).trim();
+  return { text, usage, ...(error ? { error } : {}) };
+}
+
+export async function invokeCursor({ executable, projectRoot, prompt, timeoutMs = 120000, signal, model = null, onProgress = null }) {
+  const configDir = await mkdtemp(join(tmpdir(), 'madre-cursor-'));
+  try {
+    await writeFile(join(configDir, 'cli-config.json'), `${JSON.stringify(READONLY_CONFIG, null, 2)}\n`);
+    return await runReadonlyProcess({
+      onProgress: onProgress ? (out) => onProgress({ chars: out.length }) : null,
+      executable,
+      args: buildCursorArgs({ projectRoot, prompt, ...(model ? { model } : {}) }),
+      cwd: projectRoot,
+      env: cursorEnvironment(process.env, { configDir }),
+      timeoutMs,
+      signal,
+      label: 'Cursor',
+      parse: parseCursorOutput,
+    });
+  } finally {
+    // The chats and caches the CLI wrote there go with it: a turn keeps no session of its own.
+    await rm(configDir, { recursive: true, force: true, maxRetries: 6, retryDelay: 60 }).catch(() => {});
+  }
+}

package/src/adapters/gemini.mjs

@@ -278,7 +278,14 @@ export function diagnoseGeminiStderr(stderr) {
   if (/status:?\s*503|UNAVAILABLE|high demand/i.test(text)) {
     return { code: 'UNAVAILABLE', message: t('Google reported the model as unavailable (HTTP 503) and the CLI kept retrying.'), hint: t('Try again shortly or choose another model.') };
   }
-  if (/status:\s*40[13]|PERMISSION_DENIED|API key not valid|IneligibleTierError/i.test(text)) {
+  // Google closed Gemini Code Assist for individuals to this CLI (seen 2026-10-17): the personal
+  // login still holds a valid token and every request is refused before it reaches a model. Named
+  // apart from a bad key so the room says what to do, and with Google's own word in the message so
+  // Diagnóstico finds its entry (gemini-ineligible-tier) in whatever language the room speaks.
+  if (/IneligibleTierError|no longer supported for Gemini Code Assist|migrate to the Antigravity/i.test(text)) {
+    return { code: 'INELIGIBLE', message: t('Google no longer accepts this Gemini sign-in (IneligibleTierError): the free personal Google account is refused before it reaches a model.'), hint: t('Paste a Gemini API key from Google AI Studio in Settings › Agents › Gemini, or run `gemini`, type /auth and pick "Use Gemini API key".') };
+  }
+  if (/status:\s*40[13]|PERMISSION_DENIED|API key not valid/i.test(text)) {
     return { code: 'AUTH', message: t('Google rejected the Gemini credentials.'), hint: t('Run `gemini` and use /auth, or check GEMINI_API_KEY.') };
   }
   // A subagent, refused. The policy is right to refuse it — a subagent answers outside the lease
@@ -337,7 +344,7 @@ export async function invokeGemini({
         const diagnosis = diagnoseGeminiStderr(stderr);
         if (!diagnosis) return null;
         firstSeenAt ??= Date.now();
-        const terminal = diagnosis.code === 'CREDITS_DEPLETED' || diagnosis.code === 'AUTH';
+        const terminal = diagnosis.code === 'CREDITS_DEPLETED' || diagnosis.code === 'AUTH' || diagnosis.code === 'INELIGIBLE';
         if (!terminal && Date.now() - firstSeenAt < failFastMs) return null;
         return Object.assign(new Error(`${diagnosis.message} ${diagnosis.hint}`), { code: diagnosis.code, diagnosis });
       };
@@ -357,7 +364,7 @@ export async function invokeGemini({
       } catch (error) {
         const produced = parseGeminiOutput(error.partialOutput ?? '').text;
         const diagnosis = error.diagnosis ?? diagnoseGeminiStderr(error.partialStderr ?? error.stderr ?? '');
-        if (diagnosis?.code === 'AUTH' || diagnosis?.code === 'CREDITS_DEPLETED') {
+        if (diagnosis?.code === 'AUTH' || diagnosis?.code === 'INELIGIBLE' || diagnosis?.code === 'CREDITS_DEPLETED') {
           error.message = `${diagnosis.message} ${diagnosis.hint}`;
           error.code = diagnosis.code;
           throw error;

package/src/adapters/madre.mjs

@@ -6,6 +6,7 @@
 // leaves the machine. It grows as the memory grows.
 
 import { ollamaGenerate } from '../ollama.mjs';
+import { inLanguage } from '../i18n.mjs';
 
 export const MADRE_AGENT_ID = 'madre';
 export const MADRE_ADAPTER = 'madre-local';
@@ -232,7 +233,7 @@ export function gist(text, max = 240) {
 export function roundBullets(round, { es = true } = {}) {
   return round.answers.map((answer) => (answer.sequence
     ? `- @${answer.agent} [#${answer.sequence}]: ${gist(answer.text)}`
-    : `- @${answer.agent}: ${es ? 'no respondió' : 'did not answer'}${answer.error ? ` (${String(answer.error).replace(/[.\s]+$/, '')})` : ''}.`)).join('\n');
+    : `- @${answer.agent}: ${es ? 'no respondió' : 'did not answer'}${answer.error ? ` (${gist(inLanguage(answer.error, es ? 'es' : 'en'), 200).replace(/[.\s]+$/, '')})` : ''}.`)).join('\n');
 }
 export function comparisonHolds(line, round) {
   const spoke = new Set(round.answers.filter((answer) => answer.sequence).map((answer) => answer.agent));