@jossuealcala/madre 0.7.2 → 1.0.0

package/src/setup.mjs

@@ -123,6 +123,7 @@ async function listOpenCodeModels(agent) {
   return new Promise((resolve) => {
     const child = spawn(agent.path, ['models'], { stdio: ['ignore', 'pipe', 'ignore'] });
     let out = '';
+    child.stdout.setEncoding('utf8');
     child.stdout.on('data', (chunk) => { out += chunk; });
     const timer = setTimeout(() => child.kill('SIGKILL'), 15000);
     child.on('close', () => { clearTimeout(timer); resolve(out.split('\n').map((line) => line.trim()).filter((line) => /^[\w.-]+\/[\w.:-]+$/.test(line))); });

package/src/tour.mjs

@@ -0,0 +1,159 @@
+// The welcome of MADRE 1.0 (2026-10-11): one bonjour per person and per major version, then the
+// chapters that tell everything new, at the person's own pace (docs: the «Recorrido de MADRE 1.0»
+// decision, option B with two pieces of C — the one-line hints and the sheet of gestures).
+//
+// Where it was, what was read, which hints were seen: kept in ~/.pulse/tour.json, never in a
+// browser. Every project is its own origin and a project may open on another port next time, so a
+// flag in the browser would be forgotten or said twice; this file is one per person, as
+// whats-new.json and review-ask.json are.
+//
+// It also brings the projects of 0.7.2 to Home. 0.7.2 never wrote where a project is
+// (project.json), so Home cannot list them; but a room's id is its folder's name and a hash of its
+// path (src/salas.mjs), so the folder is found by looking for that name where people keep their
+// projects and is proved by the hash. Nothing is guessed: a folder whose hash does not match is
+// not that project, and a project MADRE was told to forget is never brought back.
+
+import { createReadStream } from 'node:fs';
+import { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { oneAtATime, writeWhole } from './json-file.mjs';
+import { PROJECT_HOMES, associateProject, projectRoomId, salasRoomId } from './salas.mjs';
+
+export const TOUR_VERSION = '1.0';
+// The chapters, in their order; «moved» is only for whoever comes from 0.7.2.
+export const CHAPTERS = ['moved', 'home', 'project', 'talk', 'modes', 'coordinator', 'links', 'maps', 'settings', 'modules', 'phone', 'gestures'];
+// The places that confuse most, each told once in one line (from option C).
+export const HINTS = ['switch', 'links', 'key4'];
+const PATHS = ['new', 'back'];
+
+const fresh = () => ({ version: TOUR_VERSION, path: null, bonjourAt: null, done: [], at: null, closed: false, finished: null, hints: {}, held: null });
+// A tab that shows the bonjour or the chapters says so every few seconds; another tab that finds it
+// said within this long tells the person it is open there, instead of a second bonjour.
+export const HELD_MS = 45 * 1000;
+const TAB = /^[\w-]{6,64}$/;
+const tourFile = (stateRoot) => join(stateRoot, 'tour.json');
+
+// What is kept, checked field by field: a file written by hand or by an older MADRE is read for
+// what it says correctly and nothing else. A file for another version starts the tour again.
+export async function readTour(stateRoot) {
+  const raw = await readFile(tourFile(stateRoot), 'utf8').then((text) => JSON.parse(text)).catch(() => null);
+  if (!raw || typeof raw !== 'object' || raw.version !== TOUR_VERSION) return fresh();
+  const iso = (value) => (typeof value === 'string' && !Number.isNaN(Date.parse(value)) ? value : null);
+  return {
+    version: TOUR_VERSION,
+    path: PATHS.includes(raw.path) ? raw.path : null,
+    bonjourAt: iso(raw.bonjourAt),
+    done: Array.isArray(raw.done) ? CHAPTERS.filter((id) => raw.done.includes(id)) : [],
+    at: CHAPTERS.includes(raw.at) ? raw.at : null,
+    closed: raw.closed === true,
+    finished: iso(raw.finished),
+    hints: Object.fromEntries(HINTS.filter((id) => iso(raw.hints?.[id])).map((id) => [id, raw.hints[id]])),
+    held: raw.held && TAB.test(String(raw.held.by ?? '')) && iso(raw.held.at) ? { by: raw.held.by, at: raw.held.at } : null,
+  };
+}
+
+async function writeTour(stateRoot, state) {
+  await writeWhole(tourFile(stateRoot), `${JSON.stringify(state, null, 2)}\n`);
+  return state;
+}
+
+// One change at a time, from the page: the path taken at the bonjour, a chapter read, where the
+// person is, closed to go on later, finished, a hint seen, or everything again from the start.
+// One change at a time (src/json-file.mjs): every tab says it holds the tour every few seconds,
+// through whichever project it is on, and a chapter read in between was lost to it.
+export function changeTour(stateRoot, change, now = new Date()) {
+  return oneAtATime(tourFile(stateRoot), () => applyChange(stateRoot, change, now));
+}
+async function applyChange(stateRoot, change, now) {
+  if (!change || typeof change !== 'object') return { error: 'change' };
+  if (change.reset === true) return writeTour(stateRoot, fresh());
+  const state = await readTour(stateRoot);
+  const at = new Date(now).toISOString();
+  if (change.path !== undefined) {
+    if (!PATHS.includes(change.path)) return { error: 'path' };
+    state.path = change.path;
+  }
+  if (change.bonjour === true) state.bonjourAt ??= at;
+  if (change.chapter !== undefined) {
+    if (!CHAPTERS.includes(change.chapter)) return { error: 'chapter' };
+    if (!state.done.includes(change.chapter)) state.done = CHAPTERS.filter((id) => id === change.chapter || state.done.includes(id));
+  }
+  if (change.at !== undefined) {
+    if (change.at !== null && !CHAPTERS.includes(change.at)) return { error: 'chapter' };
+    state.at = change.at;
+  }
+  if (change.closed !== undefined) state.closed = change.closed === true;
+  if (change.finished === true) { state.finished ??= at; state.closed = false; }
+  // Which tab has the tour open now (one says it every few seconds while it does), and that it
+  // let go — only the tab that holds it lets go.
+  if (change.hold !== undefined) {
+    if (!TAB.test(String(change.hold))) return { error: 'tab' };
+    state.held = { by: change.hold, at };
+  }
+  if (change.release !== undefined && state.held?.by === change.release) state.held = null;
+  if (change.hint !== undefined) {
+    if (!HINTS.includes(change.hint)) return { error: 'hint' };
+    state.hints[change.hint] ??= at;
+  }
+  return writeTour(stateRoot, state);
+}
+
+// Whoever already used MADRE wrote in it: a message of theirs in the record of a room. Having a room
+// proves nothing — a room is made with its record and its memory the moment it opens, a new
+// person's first `madre start` too (2026-10-11) — and a project added in Home and never opened has
+// not even that. The Coordinator's own room is not counted either.
+const PERSON_SPOKE = /"type":"message\.created".*"role":"user"/;
+async function spoke(file) {
+  const lines = createInterface({ input: createReadStream(file, { encoding: 'utf8' }), crlfDelay: Infinity });
+  try {
+    for await (const line of lines) if (PERSON_SPOKE.test(line)) return true;
+  } catch { /* unreadable: not proof of anything */ } finally {
+    lines.close();
+  }
+  return false;
+}
+export async function cameBefore(stateRoot) {
+  const dir = join(stateRoot, 'rooms');
+  const salas = salasRoomId(stateRoot);
+  for (const id of await readdir(dir).catch(() => [])) {
+    if (id === salas) continue;
+    const chats = await readdir(join(dir, id, 'chats')).catch(() => []);
+    for (const file of [join(dir, id, 'events.jsonl'), ...chats.map((chat) => join(dir, id, 'chats', chat, 'events.jsonl'))]) {
+      if (await stat(file).then((info) => info.isFile(), () => false) && await spoke(file)) return true;
+    }
+  }
+  return false;
+}
+
+// The rooms Home cannot list: no record of where their project is, and not set aside on purpose.
+export async function roomsWithoutProject(stateRoot) {
+  const dir = join(stateRoot, 'rooms');
+  const salas = salasRoomId(stateRoot);
+  const out = [];
+  for (const id of (await readdir(dir).catch(() => [])).sort()) {
+    if (id === salas || !/-[0-9a-f]{16}$/.test(id)) continue;
+    const has = (name) => stat(join(dir, id, name)).then(() => true, () => false);
+    if (await has('project.json') || await has('project.forgotten.json')) continue;
+    if (!(await has('events.jsonl')) && !(await has('memory.sqlite'))) continue;
+    out.push({ id, name: id.replace(/-[0-9a-f]{16}$/, '') });
+  }
+  return out;
+}
+
+// One room: its folder looked for by name where people keep their projects, proved by its hash,
+// and written beside its record as adding it in Home would. Answers where it was, or that it was
+// not found (a folder that was deleted, moved, or lived somewhere else).
+export async function recoverProject({ stateRoot, home, id }) {
+  const room = (await roomsWithoutProject(stateRoot)).find((one) => one.id === id);
+  if (!room) return { error: 'unknown' };
+  for (const where of PROJECT_HOMES) {
+    const candidate = join(home, where, room.name);
+    const real = await realpath(candidate).catch(() => null);
+    if (!real || projectRoomId(real) !== id) continue;
+    const added = await associateProject({ root: real, home, stateRoot });
+    if (added.error) continue;
+    return { id, name: added.name, root: added.root, found: true };
+  }
+  return { id, name: room.name, found: false };
+}

package/src/updates.mjs

@@ -10,12 +10,33 @@ import { dirname } from 'node:path';
 export const REGISTRY = 'https://registry.npmjs.org';
 export const UPDATE_TTL_MS = 24 * 60 * 60 * 1000;
 
-const parse = (version) => String(version ?? '').trim().replace(/^v/, '').split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+// A version read as semver reads it: three numbers, then the pre-release, if any; build metadata
+// (after +) never counts.
+const parse = (version) => {
+  const text = String(version ?? '').trim().replace(/^v/, '').split('+')[0];
+  const dash = text.indexOf('-');
+  const core = (dash >= 0 ? text.slice(0, dash) : text).split('.').slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+  while (core.length < 3) core.push(0);
+  return { core, pre: dash >= 0 ? text.slice(dash + 1).split('.').filter(Boolean) : [] };
+};
 
-// -1 when a < b, 0 when equal, 1 when a > b. Pre-release tags are ignored: a room compares releases.
+// -1 when a < b, 0 when equal, 1 when a > b, with semver's precedence for pre-releases (2026-10-12,
+// LOG-16): `1.1.0-alpha.1` comes before `1.1.0`, and `alpha.2` after `alpha.1`. They were read as
+// equal, so whoever ran an alpha was never told the release was out — and the Windows port (1.1)
+// ships its alphas and betas this way.
 export function compareVersions(a, b) {
   const [x, y] = [parse(a), parse(b)];
-  for (let i = 0; i < 3; i += 1) if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1;
+  for (let i = 0; i < 3; i += 1) if (x.core[i] !== y.core[i]) return x.core[i] < y.core[i] ? -1 : 1;
+  if (!x.pre.length || !y.pre.length) return x.pre.length === y.pre.length ? 0 : x.pre.length ? -1 : 1;
+  for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i += 1) {
+    const [p, q] = [x.pre[i], y.pre[i]];
+    if (p === undefined || q === undefined) return p === undefined ? -1 : 1;
+    if (p === q) continue;
+    const [pn, qn] = [/^\d+$/.test(p), /^\d+$/.test(q)];
+    if (pn && qn) return Number(p) < Number(q) ? -1 : 1;
+    if (pn !== qn) return pn ? -1 : 1;
+    return p < q ? -1 : 1;
+  }
   return 0;
 }
 
@@ -29,6 +50,13 @@ export function detectInstall({ script = process.argv[1] ?? '', projectRoot = pr
   return 'source';
 }
 
+// A version as semver writes it, and nothing else (2026-10-12, SRV-07 of the 1.0 review). What the
+// registry or the cache in ~/.pulse says is read as data: a «version» with a `;` in it went, whole,
+// into the shell line that restarts the room.
+const VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const PACKAGE_NAME = /^(?:@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*$/;
+export const isVersion = (value) => typeof value === 'string' && VERSION.test(value);
+
 export function updateCommand(install, name, version = 'latest') {
   switch (install) {
     case 'npx': return `npx ${name}@${version} start`;
@@ -38,15 +66,27 @@ export function updateCommand(install, name, version = 'latest') {
   }
 }
 
+// The version, downloaded into npm's own cache while the room is still open. A release is listed
+// by the registry a little before its tarball can be fetched, and a room that closed first and
+// then found nothing to start was simply gone: the restart below runs detached and nobody is left
+// to say why. Fetched first, the restart starts from the cache; refused, the room stays.
+export function fetchCommand({ name, version }) {
+  if (!PACKAGE_NAME.test(String(name)) || !isVersion(version)) return null;
+  return { command: 'npm', args: ['cache', 'add', `${name}@${version}`, '--no-fund', '--no-audit'] };
+}
+
 // One shell line that installs the version and starts the same room on the same port.
 // The room's own process runs it detached after closing its listener, then exits.
 const shq = (value) => `'${String(value).replace(/'/g, `'\\''`)}'`;
 export function applyCommand({ install, name, version, port, projectRoot }) {
+  if (!PACKAGE_NAME.test(String(name)) || !isVersion(version)) return null;
   const start = `start --no-open --port ${Number(port) || 4317} --project ${shq(projectRoot)}`;
+  const spec = shq(`${name}@${version}`);
+  const bin = shq(name.split('/').pop());
   switch (install) {
-    case 'npx': return `exec npx -y ${name}@${version} ${start}`;
-    case 'project': return `npm install ${name}@${version} --no-fund --no-audit && exec npx --no ${name.split('/').pop()} ${start}`;
-    case 'global': return `npm install -g ${name}@${version} --no-fund --no-audit && exec ${name.split('/').pop()} ${start}`;
+    case 'npx': return `exec npx -y ${spec} ${start}`;
+    case 'project': return `npm install ${spec} --no-fund --no-audit && exec npx --no ${bin} ${start}`;
+    case 'global': return `npm install -g ${spec} --no-fund --no-audit && exec ${bin} ${start}`;
     default: return null;   // source: the human pulls
   }
 }
@@ -74,7 +114,7 @@ async function readCache(file) {
 export async function checkForUpdate({ name, current, cacheFile, fetchImpl = globalThis.fetch, now = Date.now(), ttlMs = UPDATE_TTL_MS, enabled = true, force = false, cacheOnly = false, timeoutMs = 4000 } = {}) {
   const cached = cacheFile ? await readCache(cacheFile) : null;
   const fresh = cached && cached.name === name && Number.isFinite(cached.checkedAt) && now - cached.checkedAt < ttlMs;
-  let latest = cached?.name === name ? cached.latest ?? null : null;
+  let latest = cached?.name === name && isVersion(cached.latest) ? cached.latest : null;
   let checkedAt = cached?.name === name ? cached.checkedAt ?? null : null;
   let source = latest ? 'cache' : 'none';
   let error = null;
@@ -83,7 +123,7 @@ export async function checkForUpdate({ name, current, cacheFile, fetchImpl = glo
       const response = await fetchImpl(`${REGISTRY}/${encodeURIComponent(name).replace('%40', '@')}/latest`, { headers: { accept: 'application/json' }, signal: AbortSignal.timeout(timeoutMs) });
       if (!response.ok) throw new Error(`registry HTTP ${response.status}`);
       const doc = await response.json();
-      if (typeof doc?.version !== 'string') throw new Error('registry answered without a version');
+      if (!isVersion(doc?.version)) throw new Error('registry answered without a version');
       latest = doc.version;
       checkedAt = now;
       source = 'registry';

package/src/usage-sentinel.mjs

@@ -48,7 +48,7 @@ export class UsageSentinel {
       ? t(' Continue with {who}.', { who: alternatives.map((item) => `@${item}`).join(t(' or ')) })
       : t(' Prepare a handoff before the current agent becomes unavailable.');
     const label = source === 'room-soft-budget'
-      ? t("local room token budget (MADRE's own soft limit, not the provider's quota; cache reads count a tenth)")
+      ? t("local project token budget (MADRE's own soft limit, not the provider's quota; cache reads count a tenth)")
       : source === 'test-simulation'
         ? t('simulated provider usage window')
         : t('provider usage window');

package/src/verdict.mjs

@@ -13,7 +13,7 @@
 // language and read at call time, not when this file is imported.
 import { t } from './i18n.mjs';
 
-export const WHERE = { nostromo: 'NOSTROMO', ask: 'NOSTROMO · ASK', room: 'THE ROOM', tests: 'THE THREE TESTS' };
+export const WHERE = { nostromo: 'MEMORY MAP', ask: 'MEMORY MAP · ASK', room: 'THE PROJECT', tests: 'MEMORY REVIEW' };
 const where = (key) => t(WHERE[key]);
 
 export function verdictFor({ maturity = null, exams = {}, cold = null, asks = 0 } = {}) {
@@ -39,8 +39,8 @@ export function verdictFor({ maturity = null, exams = {}, cold = null, asks = 0
       headline: stage?.label ?? null,
       says: coverage.says,
       next: asks
-        ? { text: t('Answer the {n} questions the room wrote for itself. They are the holes this test is finding.', { n: asks }), where: where('ask') }
-        : { text: t('Keep working in the room. The archive fills where the work happens, and this test measures exactly that.'), where: where('room') },
+        ? { text: t('Answer the {n} questions the project wrote for itself. They are the holes this test is finding.', { n: asks }), where: where('ask') }
+        : { text: t('Keep working in the project. The archive fills where the work happens, and this test measures exactly that.'), where: where('room') },
     };
   }
 
@@ -54,8 +54,8 @@ export function verdictFor({ maturity = null, exams = {}, cold = null, asks = 0
   if (!match?.ran) {
     return {
       headline: stage?.label ?? null,
-      says: coverage?.ran ? coverage.says : t('Nothing contradicts anything and the archive answers what this room asks.'),
-      next: { text: t('Run the third test: it puts real questions from this room back to the local model and says whether it lands where the agents landed.'), where: where('tests') },
+      says: coverage?.ran ? coverage.says : t('Nothing contradicts anything and the archive answers what this project asks.'),
+      next: { text: t('Run the third test: it puts real questions from this project back to the local model and says whether it lands where the agents landed.'), where: where('tests') },
     };
   }
 
@@ -63,12 +63,12 @@ export function verdictFor({ maturity = null, exams = {}, cold = null, asks = 0
   return {
     headline: stage?.label ?? null,
     says: match.passed
-      ? `${match.says} ${t('This room is ready to be worked in with the local model.')}`
+      ? `${match.says} ${t('This project is ready to be worked on with the local model.')}`
       : match.says,
     next: match.passed
       ? (dead
         ? { text: t('Nothing is wrong. {n} memories have had every chance and were never the answer: look at them and decide.', { n: dead }), where: where('nostromo') }
-        : { text: t('Nothing to fix. Keep using the room; the archive grows where the work is.'), where: where('room') })
+        : { text: t('Nothing to fix. Keep using the project; the archive grows where the work is.'), where: where('room') })
       : { text: t('The local model does not land where the agents land yet. Keep the archive growing and run this test again in a week.'), where: where('tests') },
   };
 }

package/src/whats-new.mjs

@@ -22,7 +22,165 @@ const FILE = 'whats-new.json';
 
 // `icon` names one of the room's 8-bit icons. `where` says where it lives, in the words the
 // screens use. `more` is the one thing nobody is told how to find.
+//
+// From 1.0 a sheet is a board: each item also has an `id`, a picture (`image`, under
+// /assets/news/<major.minor>/, whitelisted in server.mjs) and an `action`, the place «Take me
+// there» opens, or null when there is nowhere to go. The page knows exactly these places.
+export const NEWS_ACTIONS = ['settings', 'mother', 'intents', 'permissions', 'github', 'bar', 'modules', 'nostromo', 'room', 'looks', 'finder'];
+
 export const NOTES = {
+  '1.0.0': {
+    intro: {
+      es: 'MADRE 1.0 se ve y se usa como un producto: todo lo que configuras en un solo lugar, ayudas que aprenden de cómo trabajas y un proyecto que acomodas a tu gusto.',
+      en: 'MADRE 1.0 looks and works like a product: everything you configure in one place, help that learns from how you work, and a project you arrange your way.',
+    },
+    items: [
+      {
+        id: 'settings',
+        icon: 'gear',
+        image: '/assets/news/1.0/settings.webp',
+        title: { es: 'Ajustes en una ventana', en: 'Settings in one window' },
+        body: {
+          es: 'Todo lo que configuras está junto: apariencia, proyecto, agentes, memoria, permisos, privacidad y versión. Cada tarjeta dice cómo está antes de abrirla, y lo que más usas se cambia ahí mismo. Un buscador encuentra cualquier ajuste.',
+          en: 'Everything you configure is together: appearance, project, agents, memory, permissions, privacy and version. Each card tells you how things stand before you open it, and what you use most changes right there. A search finds any setting.',
+        },
+        where: { es: 'El botón de ajustes de la barra · también ⌘,', en: 'The settings button in the bar · also ⌘,' },
+        action: 'settings',
+      },
+      {
+        id: 'mother',
+        icon: 'check',
+        image: '/assets/news/1.0/mother.webp',
+        title: { es: 'Diagnóstico te da el remedio', en: 'Diagnostics gives you the remedy' },
+        body: {
+          es: 'Escribe lo que pasa con tus palabras y ves qué hacer, con la tecla que lo resuelve sin salir del proyecto. Lo que falló en este proyecto aparece primero y marcado, para que no tengas que adivinar.',
+          en: 'Describe what is happening in your own words and you see what to do, with the key that fixes it without leaving the project. What failed in this project shows first and marked, so you do not have to guess.',
+        },
+        where: { es: 'El botón DIAGNÓSTICO de la barra', en: 'The DIAGNOSTICS button in the bar' },
+        action: 'mother',
+      },
+      {
+        id: 'intents',
+        icon: 'chip',
+        image: '/assets/news/1.0/intents.webp',
+        title: { es: 'Intenciones aprende de tu uso', en: 'Intenciones learns from how you work' },
+        body: {
+          es: 'Mientras escribes, sugiere cuánto debe pensar cada agente para lo que pides, a partir de tus propios turnos y sin gastar tokens. Puede proponerte un nivel más bajo para un solo mensaje, y si se quedó corto vuelve a subir.',
+          en: 'As you write, it suggests how hard each agent should think for what you ask, learned from your own turns at no token cost. It can offer a lower level for a single message, and if that fell short it goes back up.',
+        },
+        where: { es: 'Bajo la caja de texto · Módulos › Intenciones', en: 'Under the message box · Modules › Intenciones' },
+        action: 'intents',
+      },
+      {
+        id: 'permissions',
+        icon: 'lock',
+        image: '/assets/news/1.0/permissions.webp',
+        title: { es: 'Permisos a tu manera', en: 'Permissions your way' },
+        body: {
+          es: 'Elige qué abre #3 y #4: el nombre del proyecto, una frase tuya o, en #3, solo confirmar. Una llave aceptada puede valer unos minutos, y el modo máximo de cada agente cabe en una sola tabla.',
+          en: 'Choose what unlocks #3 and #4: the project name, a phrase of your own or, for #3, just a confirmation. An accepted key can hold for a few minutes, and every agent’s highest mode fits in one table.',
+        },
+        where: { es: 'Ajustes › Permisos', en: 'Settings › Permissions' },
+        action: 'permissions',
+      },
+      {
+        id: 'github',
+        icon: 'branch',
+        image: '/assets/news/1.0/github.webp',
+        title: { es: 'GitHub en el proyecto', en: 'GitHub in the project' },
+        body: {
+          es: 'Revisa pull requests, CI e issues con /gh, usando la sesión de gh que ya tienes. Antes de publicar algo te enseña qué saldría y te pregunta, y los agentes solo publican en #4.',
+          en: 'Check pull requests, CI and issues with /gh, using the gh session you already have. Before anything is posted it shows you what would go out and asks, and agents only post in #4.',
+        },
+        where: { es: 'Módulos › GitHub · luego /gh en la caja', en: 'Modules › GitHub · then /gh in the box' },
+        action: 'github',
+      },
+      {
+        id: 'bar',
+        icon: 'bars',
+        image: '/assets/news/1.0/bar.webp',
+        title: { es: 'Tu barra, a tu gusto', en: 'Your bar, your way' },
+        body: {
+          es: 'Clic derecho en la barra y los íconos tiemblan: quita con − lo que no usas y agrega Memoria, Ahorro de tokens, Intenciones, IA local o cualquier módulo con ventana.',
+          en: 'Right-click the bar and the icons jiggle: take off what you do not use with − and add Memory, Token saver, Intenciones, Local AI or any module with a window.',
+        },
+        where: { es: 'Clic derecho en la barra · o déjala presionada', en: 'Right-click the bar · or press and hold it' },
+        action: 'bar',
+      },
+      {
+        id: 'modules',
+        icon: 'grid',
+        image: '/assets/news/1.0/modules.webp',
+        title: { es: 'Módulos como apps', en: 'Modules as apps' },
+        body: {
+          es: 'Los módulos son un tablero de mosaicos, cada uno con su interruptor y su ficha. Ahorro de tokens, Intenciones e IA local se abren en su propia ventana, y las descargas e instalaciones muestran su avance real.',
+          en: 'Modules are a board of tiles, each with its switch and its sheet. Token saver, Intenciones and Local AI open in a window of their own, and downloads and installs show their real progress.',
+        },
+        where: { es: 'El botón de módulos de la barra', en: 'The modules button in the bar' },
+        action: 'modules',
+      },
+      {
+        id: 'nostromo',
+        icon: 'orbit',
+        image: '/assets/news/1.0/nostromo.webp',
+        title: { es: 'El Mapa de memoria a un clic', en: 'The Memory map one click away' },
+        body: {
+          es: 'El cerebro de la memoria tiene su propio botón en la barra. Las conexiones entre memorias se ven aunque Ollama esté apagado.',
+          en: 'The memory brain has its own button in the bar. The links between memories show even with Ollama off.',
+        },
+        where: { es: 'El botón Mapa de memoria de la barra', en: 'The Memory map button in the bar' },
+        action: 'nostromo',
+      },
+      {
+        id: 'room',
+        icon: 'home',
+        image: '/assets/news/1.0/room.webp',
+        title: { es: 'El proyecto, acomodado a tu gusto', en: 'The project, arranged your way' },
+        body: {
+          es: 'Cada panel se abre al lado o en una ventana que mueves. Varias conversaciones trabajan a la vez, los servidores de tu proyecto viven dentro del proyecto y el visor edita código.',
+          en: 'Every panel opens beside you or in a window you move. Several conversations work at once, your project’s servers live inside the project, and the viewer edits code.',
+        },
+        where: { es: 'El encabezado de cada panel · Ajustes › Proyecto y turnos', en: 'The header of every panel · Settings › Project and turns' },
+        action: 'room',
+      },
+      {
+        id: 'looks',
+        icon: 'star',
+        image: '/assets/news/1.0/looks.webp',
+        title: { es: '17 acentos y 12 fondos', en: '17 accents and 12 wallpapers' },
+        body: {
+          es: 'Cada uno pensado para tema claro y oscuro. Las respuestas se leen sobre vidrio esmerilado encima de tu fondo, y las tarjetas tienen un relieve suave.',
+          en: 'Each one made for light and dark themes. Replies read on frosted glass over your wallpaper, and cards stand out in soft relief.',
+        },
+        where: { es: 'Ajustes › Apariencia', en: 'Settings › Appearance' },
+        action: 'looks',
+      },
+      {
+        id: 'alerts',
+        icon: 'bell',
+        image: '/assets/news/1.0/alerts.webp',
+        title: { es: 'Alertas más claras', en: 'Clearer alerts' },
+        body: {
+          es: 'Las confirmaciones y las llaves de #3 y #4 llegan en una sola hoja clara, con lo que vas a aprobar a la vista. El menú «revisarlo con» ya no se corta.',
+          en: 'Confirmations and the keys for #3 and #4 arrive as one clear sheet, with what you are approving in view. The “review it with” menu is no longer cut off.',
+        },
+        where: { es: 'Aparecen solas cuando el proyecto necesita tu palabra', en: 'They appear on their own when the project needs your word' },
+        action: null,
+      },
+      {
+        id: 'finder',
+        icon: 'list',
+        image: '/assets/news/1.0/finder.webp',
+        title: { es: 'Archivos nuevos desde Finder', en: 'New files from the Finder' },
+        body: {
+          es: 'Una tecla junto al buscador crea un archivo y lo abre en el visor, listo para escribir. Las carpetas que falten se crean solas.',
+          en: 'A key beside the search creates a file and opens it in the viewer, ready to write. Any missing folders are made for you.',
+        },
+        where: { es: 'Finder › junto al buscador', en: 'Finder › next to the search' },
+        action: 'finder',
+      },
+    ],
+  },
   '0.7.0': {
     intro: {
       es: 'Esta versión le da forma a la memoria de la sala: ahora la ves en tres dimensiones, la lees en un tablero y cada memoria te dice cómo está.',
@@ -96,6 +254,8 @@ export const NOTES = {
 };
 
 export const notesFor = (version) => NOTES[version] ?? null;
+// The newest version that has a sheet: what a preview opens on a copy whose own version has none.
+export const newestNotes = () => Object.keys(NOTES).sort(compareVersions).at(-1) ?? null;
 
 // Whether this person should see the sheet for this version. Someone who has seen an older one,
 // or who used the room before the sheet existed, sees it once; a first install never does.