@jossuealcala/madre 1.0.1 → 1.0.3

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { priceTokens, PRICES_CHECKED } from '../prices.mjs';
 import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { t } from '../i18n.mjs';
@@ -276,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
@@ -288,7 +297,7 @@ export function diagnoseGeminiStderr(stderr) {
   if (/Unauthorized tool call:\s*'?invoke_agent'?|Blocked call:[^\n]*invoke_agent/i.test(text)) {
     return {
       code: 'SUBAGENT_BLOCKED',
-      message: t('Gemini tried to hand this turn to one of its own subagents. MADRE does not allow that: a subagent answers outside the lease, so nothing it wrote would be checked, shown or undoable.'),
+      message: t('Gemini tried to hand this task to one of its own subagents. MADRE does not allow that: a subagent answers outside the permission MADRE controls, so nothing it wrote would be checked, shown or undoable.'),
       hint: t('Ask again saying it should do the work itself, without subagents.'),
     };
   }
@@ -335,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 });
       };
@@ -355,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

@@ -1,9 +1,12 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // @madre: the room's own intelligence. A local model (Ollama) that answers
 // from what the room remembers: the whole archive, not only the recent window,
 // plus the files the human points at. It never writes, never delegates, never
 // 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';
@@ -230,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));
@@ -264,7 +267,7 @@ export async function gather(memory, text, { maxChars = 7000 } = {}) {
 export function madreInvoker({ memory, ollama, fetchImpl = globalThis.fetch }) {
   return async ({ prompt, text = '', timeoutMs = 180000, model = null, requester = 'you', crew = [], delegation = false, maxSteps = 4, round = null, bishop = null }) => {
     const state = typeof ollama === 'function' ? ollama() : ollama;
-    if (!state?.running || !state.chatModel) throw new Error('@madre left the room: Ollama is not running. Start Ollama, or open Ollama in Modules.');
+    if (!state?.running || !state.chatModel) throw new Error('@madre left the project: Ollama is not running. Start Ollama, or open Local AI in Modules.');
     const question = text || prompt.match(/User message: ([\s\S]*)$/)?.[1] || prompt.slice(-2000);
     const local = localReply(question, { requester, crew, delegation, maxSteps, model: model ?? state.chatModel });
     if (local) return { text: local.text, usage: { ...NO_USAGE }, grounded: { notes: 0, quotes: 0 }, synthetic: local.kind, declined: local.kind === 'declined' ? 'action' : undefined };

package/src/adapters/opencode.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { runReadonlyProcess } from './process.mjs';
 
 const readonlyConfig = {
@@ -21,13 +23,15 @@ const readonlyConfig = {
 // Optional provider/model override (e.g. "openai/gpt-5.6-sol"). Without it,
 // OpenCode picks its own default provider, which may not be the one the user
 // actually signed in to.
-export function buildOpenCodeArgs({ projectRoot, prompt, model = process.env.PULSE_OPENCODE_MODEL, attachments = [] }) {
+export function buildOpenCodeArgs({ projectRoot, prompt, model = process.env.PULSE_OPENCODE_MODEL, effort = null, attachments = [] }) {
   return [
     '--pure',
     'run',
     '--format', 'json',
     '--agent', 'pulse-readonly',
     ...(model ? ['--model', model] : []),
+    // The model's reasoning rung, as OpenCode names it (`--variant`, 1.18).
+    ...(effort ? ['--variant', effort] : []),
     ...attachments.flatMap((file) => ['--file', file.path]),
     '--dir', projectRoot,
     prompt,
@@ -154,11 +158,11 @@ export function parseOpenCodeOutput(output) {
   return { text: text.join('').trim(), usage, ...(error ? { error } : {}) };
 }
 
-export function invokeOpenCode({ executable, projectRoot, prompt, timeoutMs = 120000, signal, model = null, attachments = [], lease = null, scopes = null, imageStudio = null, memoryServer = null, mcpServers = [], onProgress = null }) {
+export function invokeOpenCode({ executable, projectRoot, prompt, timeoutMs = 120000, signal, model = null, effort = null, attachments = [], lease = null, scopes = null, imageStudio = null, memoryServer = null, mcpServers = [], onProgress = null }) {
   return runReadonlyProcess({
     onProgress: onProgress ? (out) => onProgress({ chars: out.length }) : null,
     executable,
-    args: buildOpenCodeArgs({ projectRoot, prompt, attachments, ...(model ? { model } : {}) }),
+    args: buildOpenCodeArgs({ projectRoot, prompt, attachments, effort, ...(model ? { model } : {}) }),
     cwd: projectRoot,
     env: openCodeEnvironment(process.env, { lease, scopes, imageStudio, memoryServer, mcpServers }),
     timeoutMs,

package/src/adapters/process.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { spawn } from 'node:child_process';
 import { t } from '../i18n.mjs';
 

package/src/asking.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // What the room should ask next.
 //
 // The maturity reading says where the archive is thin; it does not say what to do about it on a

package/src/auth-probe.mjs

@@ -1,6 +1,8 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { execFile } from 'node:child_process';
 import { t } from './i18n.mjs';
-import { access, readFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
@@ -43,6 +45,18 @@ export function parseOpenCodeAuthList({ stdout = '' }) {
   return { state: 'signed-out', detail: 'no providers configured', providers: [] };
 }
 
+// `cursor-agent status` says «Not logged in», or who is signed in («Logged in as …»). A key in the
+// environment (CURSOR_API_KEY) signs every run in on its own, so it counts too.
+export function parseCursorStatus({ stdout = '', stderr = '' }, env = process.env) {
+  const said = stripAnsi(`${stdout}\n${stderr}`);
+  if (/not\s+logged\s+in|not\s+authenticated|log\s*in\s+first/i.test(said)) {
+    return env.CURSOR_API_KEY ? { state: 'signed-in', detail: 'via CURSOR_API_KEY' } : { state: 'signed-out', detail: 'not logged in' };
+  }
+  const who = said.match(/logged\s+in\s+(?:as\s+)?([^\s]+@[^\s]+|\S+)/i)?.[1];
+  if (who) return { state: 'signed-in', detail: `as ${who}` };
+  return env.CURSOR_API_KEY ? { state: 'signed-in', detail: 'via CURSOR_API_KEY' } : { state: 'unknown', detail: said.trim().split('\n')[0]?.slice(0, 120) || 'no answer from cursor-agent status' };
+}
+
 export function geminiAuthState({ settings, hasOauth, hasApiKey }) {
   const type = settings?.security?.auth?.selectedType;
   if (type === 'gemini-api-key') return hasApiKey ? { state: 'signed-in', detail: 'via API key' } : { state: 'signed-out', detail: 'API key selected but not found' };
@@ -85,8 +99,9 @@ export async function probeGemini({ env = process.env } = {}) {
   return geminiAuthState({ settings, hasOauth, hasApiKey });
 }
 
-// What each CLI needs from the user. Commands are run in the user's terminal
-// by the setup wizard; install hints are only printed.
+// What each CLI needs from the user. The room runs the sign-in itself; the same command typed in a
+// terminal stays as the other way in (`terminal`, `terminalNote`), offered and never required.
+// The setup wizard runs them in the user's terminal; install hints are only printed.
 export const AGENT_SETUP = {
   codex: {
     install: ['npm install -g @openai/codex', 'or install the ChatGPT desktop app, which bundles codex'],
@@ -114,27 +129,86 @@ export const AGENT_SETUP = {
     // Its browser flow has no local server to come back to: the page gives a code and the CLI
     // waits for it on its own input. The room asks for it and types it in.
     asksForCode: true,
+    terminalNote: 'Add --console to bill the work to the Anthropic Console instead of your subscription.',
     vendor: 'Anthropic',
     account: 'Signs in with a Claude account or with the Anthropic Console. An Anthropic API key works too.',
     paid: true,
   },
   gemini: {
     install: ['npm install -g @google/gemini-cli'],
-    login: [],
-    loginNote: 'Gemini signs in from its own prompt: run `gemini`, type /auth, pick "Use Gemini API key" (get one at aistudio.google.com/app/apikey) or Google login.',
+    // Gemini has no sign-in command: it signs in the first time it is asked something with
+    // "Login with Google" selected. Without a terminal it asks one yes/no, opens the browser by
+    // itself and waits on 127.0.0.1 for Google to come back, so the room needs no code and no
+    // address. The one-word question it is launched with is let through once the credentials are
+    // written: Google refuses free personal accounts only there, and a refused sign-in is undone
+    // (see geminiSignIn and loginAgent in server.mjs).
+    login: ['--prompt', 'ok'],
+    loginNote: 'Opens your browser to sign in with your Google account.',
+    browser: true,
+    methods: [
+      // The free personal account is refused by Google on this CLI (IneligibleTierError, 2026-10-17);
+      // the door stays for the accounts Google still serves, and says so.
+      { id: 'google', label: 'Google account', args: ['--prompt', 'ok'], note: 'Opens your browser to sign in with your Google account. Google refuses free personal accounts on this CLI; if it refuses yours, paste a Gemini API key from Google AI Studio instead.' },
+    ],
+    room: {
+      display: 'gemini · Login with Google',
+      flow: 'gemini-google',
+      // It asks "Do you want to continue? [Y/n]" first; the click on the button was the yes.
+      consent: true,
+      // With CI set the CLI refuses to open a browser and gives up without a terminal.
+      ci: false,
+      // A key in the environment would sign it in with the key instead of the account chosen.
+      dropEnv: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+      // One process, so cancelling stops the one that holds the browser's way back.
+      env: { GEMINI_CLI_NO_RELAUNCH: 'true' },
+    },
+    // In a terminal it is its own prompt that signs in (the setup wizard hands it over whole).
     interactive: true,
+    terminal: 'gemini',
+    terminalNote: 'Then type /auth and pick "Use Gemini API key" with a key from aistudio.google.com/app/apikey. "Login with Google" is refused for free personal accounts.',
     vendor: 'Google',
-    account: 'Signs in with a Google account and has a free tier. A Gemini API key from AI Studio works too.',
-    paid: false,
+    account: 'Connects with a Gemini API key from Google AI Studio. A Google account works only where Google still accepts it: free personal accounts are refused.',
+    // Whether it costs depends on the key's project, not on the CLI: no «free option» promised.
+    paid: null,
   },
   opencode: {
     install: ['brew install opencode', 'or: npm install -g opencode-ai'],
     login: ['auth', 'login'],
     loginNote: 'Pick a provider and paste its key or complete its OAuth flow.',
+    // Its keys are pasted from the room (see openCodeProviders); these are the providers it signs
+    // in to with an account. `-p` skips its provider list, so the room never draws a menu. Only
+    // the ones whose owner says a third party may sign in this way: GitHub supports Copilot in
+    // OpenCode since 2026-01. Left out on purpose: a Claude subscription (Anthropic does not allow
+    // claude.ai sign-ins in other tools), and ChatGPT and GitLab, until OpenAI or GitLab say so in
+    // writing. They stay one `opencode auth login` away, in the terminal, for whoever chooses them.
+    browser: true,
+    methods: [
+      {
+        id: 'github-copilot',
+        label: 'GitHub Copilot',
+        args: ['auth', 'login', '-p', 'github-copilot'],
+        note: 'Gives you a code to type at github.com/login/device: the work goes against your Copilot subscription (Pro, Pro+, Business or Enterprise).',
+        // It asks which GitHub first; the room takes github.com. Enterprise is in the terminal.
+        room: { deviceCode: true, answers: [{ prompt: 'Select GitHub deployment type', send: '\r' }] },
+      },
+    ],
+    terminalNote: 'Pick a provider, then paste its key or sign in with its account. GitHub Enterprise and the other providers are in its list.',
     vendor: 'OpenCode',
     account: 'Brings no model of its own: you point it at a provider you already use, in the cloud or on this computer.',
     paid: null,
   },
+  // Cursor's agent CLI (2026-10-17): `login` opens the browser and waits for Cursor to come back.
+  // It has no npm package; its own installer is the way in, typed in a terminal.
+  cursor: {
+    install: ['curl https://cursor.com/install -fsS | bash'],
+    login: ['login'],
+    loginNote: 'Opens your browser to sign in with your Cursor account.',
+    browser: true,
+    terminal: 'cursor-agent login',
+    vendor: 'Cursor',
+    account: 'Signs in with your Cursor account and uses its plan. For now it reads and answers; it does not write in your project.',
+    paid: true,
+  },
 };
 
 // Installing a CLI from the room itself. npm is the common denominator: every one of these
@@ -155,6 +229,10 @@ export const TAKES_KEY = new Set(['claude', 'gemini', 'opencode']);
 export const SIGN_IN_URL = /https?:\/\/\S+/;
 export const CODE_PROMPT = /paste\s+(?:the\s+)?code|enter\s+(?:the\s+)?code|c[oó]digo\s*[:>]/i;
 export const looksLikeCodePrompt = (line) => CODE_PROMPT.test(String(line ?? ''));
+// The other way round: a device sign-in shows a code to type on the provider's page
+// ("Enter code: 3475-C193"), and the room has to show it, not ask for one.
+export const DEVICE_CODE = /enter\s+(?:the\s+|this\s+)?code:?\s+([A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+)/i;
+export const deviceCodeIn = (line) => String(line ?? '').match(DEVICE_CODE)?.[1] ?? null;
 
 export function accountNoteFor(id) {
   // Said in the room's language when it is asked for, not when this file is imported.
@@ -183,10 +261,10 @@ export function installPlanFor(agent, { prefix = null } = {}) {
   };
 }
 
-// How the room can (re)connect an agent. Codex and Claude sign in with a
-// browser flow their own CLI drives, so the server can run them and stream the
-// URL; Gemini and OpenCode need their interactive prompt, so the user gets the
-// exact command instead.
+// How the room can (re)connect an agent. Codex, Claude and Gemini sign in with a browser flow
+// their own CLI drives, so the server can run them and stream what they say; OpenCode too, for
+// the providers in its `methods`, and its keys are pasted. Every plan also carries `terminal`:
+// the same sign-in typed by hand, for whoever prefers it.
 export function loginPlanFor(agent, { method = null } = {}) {
   const setup = AGENT_SETUP[agent.id];
   if (!setup) return null;
@@ -194,17 +272,71 @@ export function loginPlanFor(agent, { method = null } = {}) {
   // Which door: the one asked for, the first one the CLI offers, or the single flow it has.
   const chosen = setup.methods?.find((one) => one.id === method) ?? setup.methods?.[0] ?? null;
   const args = chosen?.args ?? setup.login;
+  const room = headless ? { ...(setup.room ?? {}), ...(chosen?.room ?? {}) } : {};
   return {
     headless,
     command: agent.path ?? agent.id,
     args: headless ? args : [],
-    display: headless ? `${agent.id} ${args.join(' ')}` : agent.id === 'gemini' ? 'gemini   # then type /auth' : `${agent.id} ${setup.login.join(' ')}`,
+    display: room.display ?? `${agent.id} ${(headless ? args : setup.login).join(' ')}`,
     note: chosen?.note ?? setup.loginNote,
+    terminal: { command: setup.terminal ?? `${agent.id} ${setup.login.join(' ')}`, note: setup.terminalNote ?? setup.loginNote },
     install: setup.install,
     // What the room offers as a choice, and what it must be ready to be asked for.
     methods: setup.methods ? setup.methods.map(({ id, label, note }) => ({ id, label, note })) : null,
     method: chosen?.id ?? null,
     asksForCode: Boolean(headless && setup.asksForCode),
+    // How the room runs it, when the CLI needs more than its arguments (see AGENT_SETUP.gemini.room).
+    ...(room.flow ? { flow: room.flow } : {}),
+    ...(room.consent ? { consent: true } : {}),
+    ...(room.ci === false ? { ci: false } : {}),
+    ...(room.env ? { env: room.env } : {}),
+    ...(room.dropEnv ? { dropEnv: room.dropEnv } : {}),
+    // A code to show rather than one to paste, and the menu questions the click already answered.
+    ...(room.deviceCode ? { deviceCode: true } : {}),
+    ...(room.answers ? { answers: room.answers } : {}),
+  };
+}
+
+// The yes/no Gemini asks before opening the browser, when it has no terminal to draw a dialog in.
+export const CONSENT_PROMPT = /do you want to continue\?\s*\[y\/n\]/i;
+export const looksLikeConsentPrompt = (line) => CONSENT_PROMPT.test(String(line ?? ''));
+
+const GEMINI_REFUSED = /IneligibleTierError|no longer supported for Gemini Code Assist|migrate to the Antigravity/i;
+
+// Gemini's Google sign-in, run from the room. Before: "Login with Google" selected in its own
+// settings, and the account it had put aside, so the run signs in anew instead of answering with
+// the old one. During: `signedIn` says when the credentials are written, which is when the room
+// stops the run. After a sign-in that did not finish: `undo` puts both files back as they were.
+// MADRE never reads the token: it moves the file it is in and checks that it exists.
+export function geminiSignIn({ env = process.env, verifyMs = 30000 } = {}) {
+  const dir = join(env.GEMINI_CLI_HOME ?? homedir(), '.gemini');
+  const settingsFile = join(dir, 'settings.json');
+  const credsFile = join(dir, 'oauth_creds.json');
+  let before = null;
+  const readIfThere = (path) => readFile(path, 'utf8').catch(() => null);
+  const putBack = (path, previous) => (previous === null ? rm(path, { force: true }) : writeFile(path, previous, { mode: 0o600 }));
+  return {
+    async prepare() {
+      await mkdir(dir, { recursive: true });
+      before = { settings: await readIfThere(settingsFile), creds: await readIfThere(credsFile) };
+      let settings = {};
+      try { settings = JSON.parse(before.settings ?? '{}') ?? {}; } catch { settings = {}; }
+      settings.security = { ...(settings.security ?? {}), auth: { ...(settings.security?.auth ?? {}), selectedType: 'oauth-personal' } };
+      await writeFile(settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
+      if (before.creds !== null) await rm(credsFile, { force: true });
+    },
+    signedIn: () => exists(credsFile),
+    // Google lets a free personal account sign in and refuses it at the first question
+    // (IneligibleTierError, 2026-10-17): a sign-in is only good once that question was not refused.
+    refused: (line) => GEMINI_REFUSED.test(String(line ?? '')),
+    // How long that first question is waited for before the run is stopped and the sign-in kept.
+    verifyMs,
+    async undo() {
+      if (!before) return;
+      await putBack(settingsFile, before.settings);
+      await putBack(credsFile, before.creds);
+      before = null;
+    },
   };
 }
 
@@ -215,6 +347,7 @@ export async function probeAgentAuth(agent) {
     case 'codex': return parseCodexLoginStatus(await run(agent.path, ['login', 'status']));
     case 'claude': return parseClaudeAuthStatus(await run(agent.path, ['auth', 'status', '--json']));
     case 'opencode': return parseOpenCodeAuthList(await run(agent.path, ['auth', 'list']));
+    case 'cursor': return parseCursorStatus(await run(agent.path, ['status']));
     case 'gemini': return probeGemini();
     default: return { state: 'unknown', detail: 'no probe for this agent' };
   }

package/src/bridge/devices.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // The phones that may reach this Mac, and the networks where they may.
 //
 // One file, `~/.pulse/devices.json`, owner-only, shared by every room on this Mac: any of them can

package/src/bridge/handoff.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Where the person was, on the Mac and on the phone (docs/MOBILE.md, MOV-005).
 //
 // One small file for the whole Mac, `~/.pulse/handoff.json`, owner-only: the last place each side

package/src/bridge/host.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Who keeps the bridge up. Every room on this Mac offers to; the port decides.
 //
 // No process of its own and nothing to start: each room, every few seconds, asks whether a phone

package/src/bridge/network.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Which network this Mac is on, and how a phone on it reaches the Mac.
 //
 // A network is known by its router: the hardware address of the default gateway, hashed. Two

package/src/bridge/policy.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // What a phone may do in a room (docs/MOBILE.md, section 4).
 //
 // A list of what passes, not of what does not: a route the room grows tomorrow stays on the Mac
@@ -15,7 +17,7 @@ import { t } from '../i18n.mjs';
 
 // Every file the room's page loads: one missing here and app.js cannot import it, so the whole page
 // stops on the phone (test/phone-bridge.test.mjs reads app.js's imports to keep this whole).
-const STATIC = new Set(['/', '/app.js', '/nostromo-engine.js', '/brands.js', '/troubleshooting.js', '/inquiry.js', '/i18n.js', '/es.js', '/resay.js', '/syntax.js', '/editor.js', '/routing.js', '/abduction.js', '/styles.css', '/review-ask.js', '/loader.js', '/tour.js', '/tour-chapters.js', '/touch.js']);
+const STATIC = new Set(['/', '/app.js', '/nostromo-engine.js', '/brands.js', '/troubleshooting.js', '/inquiry.js', '/i18n.js', '/es.js', '/resay.js', '/syntax.js', '/editor.js', '/routing.js', '/abduction.js', '/styles.css', '/review-ask.js', '/loader.js', '/tour.js', '/tour-chapters.js', '/touch.js', '/attribution.js', '/power.js', '/wallpaper.js', '/neural.js', '/hardware.js', '/code-tools.js', '/market.js', '/market-view.js', '/market-art.js']);
 
 const READ = new Set([
   '/api/state', '/api/events', '/api/chats', '/api/version', '/api/whats-new', '/api/glance', '/api/handoff',

package/src/bridge/qr.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // The QR a phone scans to pair with this Mac: text in, a grid of dark and light modules out, and
 // an SVG of that grid the room sizes and colours with CSS.
 //

package/src/bridge/server.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // The bridge: the one thing on this Mac a phone can reach (docs/MOBILE.md, MOV-001).
 //
 // Rooms keep listening on 127.0.0.1 and keep refusing anything that does not call them by that

package/src/capabilities.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // What each CLI can do from MADRE, verified against the installed versions on
 // 2026-09-16 (Codex 0.153, Claude Code 2.1, Gemini CLI 0.60, OpenCode 1.18).
 // The room shows this so a human knows whom to ask for what, and an
@@ -33,6 +35,15 @@ export const CAPABILITIES = {
     imageGen: false,
     web: { how: 'policy: allow google_web_search, web_fetch', note: 'Off until turned on in Settings › Agents › Web access.' },
   },
+  // Cursor (2026-10-17) reads only, in its own ask mode: writing waits until its confinement has
+  // been tried against the real CLI, as OpenCode's was. Attachments are named in the briefing.
+  cursor: {
+    read: true,
+    imageIn: false,
+    write: false,
+    imageGen: false,
+    web: false,
+  },
   opencode: {
     read: true,
     imageIn: { how: '-f <file>', note: 'Files attach to the message.' },

package/src/chats.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // A project has one memory and many conversations.
 //
 // The archive, the crew, the modules and the privacy list belong to the project: they are what

package/src/checkpoint.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { execFile } from 'node:child_process';
 import { access, mkdir, mkdtemp, readFile, readdir, rm, rmdir, stat, unlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -224,7 +226,9 @@ async function diffOne(root, before, prefix = '', exclude = []) {
   if (!files.length) return { files: [], stat: '' };
   const only = files.length < listed.length ? ['--', ...files.flatMap((file) => [file.path.slice(prefix.length), ...(file.from ? [file.from.slice(prefix.length)] : [])])] : [];
   const stat = (await git(root, ['diff', '--no-ext-diff', '--no-textconv', '--stat=100', before.tree, after, ...only], { via })).trim();
-  return { files, stat: prefix && stat ? stat.split('\n').map((line) => (line.startsWith(' ') ? ` ${prefix}${line.trimStart()}` : line)).join('\n') : stat };
+  // The tree the turn left is kept with what it changed (the code workspace reads it back): the
+  // agent's own lines stay its own even after the human edits the file again.
+  return { files, afterTree: after, stat: prefix && stat ? stat.split('\n').map((line) => (line.startsWith(' ') ? ` ${prefix}${line.trimStart()}` : line)).join('\n') : stat };
 }
 
 // What changed since the checkpoint, in the project and in every nested repository, paths
@@ -241,6 +245,19 @@ export async function diffCheckpoint(root, checkpoint) {
   return { afterTree: outer.afterTree ?? null, files, stat, forbidden: files.filter((file) => forbiddenIn(file.path)).map((file) => file.path) };
 }
 
+// What a file said at a photograph, or in the tree a turn left behind, read from git and never from
+// the disk. `null` when git no longer has it (a shadow repository gone with a restart, a tree git
+// pruned), when the file was not there, or when the path is not a path inside the project.
+const CHECKPOINT_ID = /^[0-9A-Za-z][\w-]{0,79}$/;
+const TREE_ID = /^[0-9a-f]{40,64}$/;
+export async function readAt(root, { checkpointId = null, tree = null, path = '' } = {}) {
+  const inner = String(path ?? '');
+  if (!inner || inner.startsWith('/') || inner.startsWith('-') || inner.split('/').includes('..')) return null;
+  const rev = checkpointId ? (CHECKPOINT_ID.test(String(checkpointId)) ? `${CHECKPOINT_REF}/${checkpointId}` : null) : (TREE_ID.test(String(tree ?? '')) ? tree : null);
+  if (!rev) return null;
+  try { return await git(root, ['show', `${rev}:${inner}`]); } catch { return null; }
+}
+
 // Which repository a project-relative path belongs to, and the path inside it.
 function repoFor(root, checkpoint, path) {
   for (const part of checkpoint.nested ?? []) {

package/src/choices.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // An agent asking the human to choose.
 //
 // The room already has one fenced channel, ```pulse, and it puts other agents to work. This is

package/src/cli-args.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Tiny argv reader for the MADRE CLI. Accepts `--name value` and
 // `--name=value`, and remembers which options the user set explicitly so the
 // room can choose sensible defaults (like the next free port) only when they

package/src/cold.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Cold zones: the part of the archive nothing has ever reached for.
 //
 // A memory is cold when three things are true at once, and the three together are what make the

package/src/commands.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { execFile } from 'node:child_process';
 import { access } from 'node:fs/promises';
 import { join } from 'node:path';