npm - changebook - Versions diffs - 0.4.7 → 0.4.9 - Mend

changebook 0.4.7 → 0.4.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/login.js CHANGED Viewed

@@ -15,6 +15,38 @@ import * as http from "node:http";
 import { atlasWebUrl, openInBrowser } from "./browser.js";
 import { credentialsPath, saveCredentials } from "./credentials.js";
 const LOGIN_TIMEOUT_MS = 5 * 60_000;
+const SUPABASE_URL = process.env.CHANGEBOOK_SUPABASE_URL ??
+    "https://oyosihxkecspjkiligga.supabase.co";
+const ANON_KEY = process.env.CHANGEBOOK_SUPABASE_ANON_KEY ??
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im95b3NpaHhrZWNzcGpraWxpZ2dhIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODMwMDYyNTUsImV4cCI6MjA5ODU4MjI1NX0.TU-UK1DToHmLHp9q7QEQ5eAa7V3sq3HtgCxPEa-DvDE";
+/**
+ * Canjea un codigo de un solo uso por una sesion PROPIA de este CLI.
+ *
+ * Espejo de `exchangeTokenHash` de la extension (src/auth/supabaseAuth.ts), que
+ * lleva usando este camino desde que se diagnostico el problema. El backend
+ * acuña el codigo con `generateLink({type:"magiclink"})` en la funcion
+ * editor-handoff — no se manda ningun correo — y aqui se cambia por tokens que
+ * no comparte nadie mas.
+ */
+async function canjearTokenHash(tokenHash) {
+    const res = await fetch(`${SUPABASE_URL}/auth/v1/verify`, {
+        method: "POST",
+        headers: { apikey: ANON_KEY, "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "magiclink", token_hash: tokenHash }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        throw new Error(`No se pudo canjear el codigo de acceso (${res.status}). Vuelve a intentarlo.`);
+    }
+    const data = (await res.json());
+    if (!data.refresh_token) {
+        throw new Error("El canje no devolvio una sesion utilizable.");
+    }
+    return {
+        access_token: data.access_token ?? undefined,
+        refresh_token: data.refresh_token,
+    };
+}
 const CALLBACK_PAGE = `<!DOCTYPE html>
 <html><head><meta charset="utf-8"><title>ChangeBook</title></head>
 <body style="font-family: sans-serif; max-width: 480px; margin: 80px auto; text-align: center;">
@@ -22,6 +54,7 @@ const CALLBACK_PAGE = `<!DOCTYPE html>
 <script>
   const params = new URLSearchParams(window.location.hash.slice(1));
   const payload = {
+    token_hash: params.get("token_hash"),
     access_token: params.get("access_token"),
     refresh_token: params.get("refresh_token"),
     state: params.get("state"),
@@ -62,6 +95,28 @@ export async function login() {
                             res.end();
                             return;
                         }
+                        // VIA PREFERIDA: un codigo de un solo uso que se canjea por una
+                        // sesion PROPIA de este CLI. La via heredada —recibir los tokens
+                        // vivos de la pestana web— entrega a dos clientes el MISMO refresh
+                        // token rotatorio, y Supabase revoca la familia entera en cuanto uno
+                        // de los dos lo rota. Como el navegador refresca solo en segundo
+                        // plano, siempre gana el, y la sesion del CLI moria ~30 min despues
+                        // de cada login, con reloj. La extension ya usaba este camino desde
+                        // que se diagnostico; al CLI no se le habia traido.
+                        if (data.token_hash) {
+                            canjearTokenHash(data.token_hash).then((sesion) => {
+                                res.writeHead(200, { "Content-Type": "application/json" });
+                                res.end('{"ok":true}');
+                                server.close();
+                                resolve(sesion);
+                            }, (err) => {
+                                res.writeHead(400);
+                                res.end();
+                                server.close();
+                                reject(err);
+                            });
+                            return;
+                        }
                         if (!data.refresh_token) {
                             res.writeHead(400);
                             res.end();
@@ -93,7 +148,12 @@ export async function login() {
                 reject(new Error("Could not open a loopback port."));
                 return;
             }
-            const url = `${atlasWebUrl()}/?connect=cli&port=${address.port}&state=${state}`;
+            // `th=1` anuncia que este CLI sabe canjear un token_hash. La web solo lo
+            // manda si lo ve: sin la marca, un CLI antiguo recibiria un codigo que no
+            // entiende y el login fallaria sin explicacion. Arreglar un fallo de
+            // sesion rompiendo el login de quien no ha actualizado no seria arreglar
+            // nada.
+            const url = `${atlasWebUrl()}/?connect=cli&port=${address.port}&state=${state}&th=1`;
             console.error("Opening your browser to sign in to ChangeBook…");
             console.error(`If it doesn't open, visit:\n\n  ${url}\n`);
             openInBrowser(url);

package/dist/supabase.js CHANGED Viewed

@@ -5,7 +5,7 @@
  * every query to the signed-in user. Refreshes the access token with the
  * refresh token when needed (refresh does not require a captcha).
  */
-import { loadCredentials, saveCredentials, withCredentialsLock, } from './credentials.js';
+import { clearRefreshInFlight, credentialsPath, loadCredentials, markRefreshInFlight, readRefreshInFlight, saveCredentials, withCredentialsLock, } from './credentials.js';
 import { slugifyProject } from './guard.js';
 // Public defaults — the anon key is the same public key the web app ships.
 const DEFAULT_URL = 'https://oyosihxkecspjkiligga.supabase.co';
@@ -64,7 +64,21 @@ export class Supabase {
     // True when the tokens came from ~/.changebook/credentials.json: rotated
     // refresh tokens must be written back there or the stored one goes stale.
     persistRotation = false;
-    constructor(env = process.env) {
+    /**
+     * Whether this process is allowed to SPEND the rotating refresh token.
+     *
+     * False for callers that run under a hard deadline and end in process.exit()
+     * — today, the pre-commit guard. Supabase rotates the refresh token the
+     * moment it RECEIVES the request, not when we read the reply, so a process
+     * that is killed mid-refresh burns the stored token without ever persisting
+     * the new one. The next process replays a spent token, Supabase's reuse
+     * detection fires, and the whole session dies. That is a silent logout
+     * caused by an optional warning — a terrible trade (diagnosed 2026-07-25:
+     * the session died ~30 min after every login, always on a commit).
+     */
+    allowRefresh = true;
+    constructor(env = process.env, opts = {}) {
+        this.allowRefresh = opts.allowRefresh ?? true;
         this.url = (env.CHANGEBOOK_SUPABASE_URL ?? DEFAULT_URL).replace(/\/+$/, '');
         this.anonKey = env.CHANGEBOOK_SUPABASE_ANON_KEY ?? DEFAULT_ANON_KEY;
         this.accessToken = env.CHANGEBOOK_ACCESS_TOKEN?.trim() || undefined;
@@ -288,6 +302,12 @@ export class Supabase {
         return this.refreshing;
     }
     doRefresh() {
+        // Refusing BEFORE the request is the whole point: once it leaves, the token
+        // is spent whether or not we survive to store the replacement. Callers that
+        // opt out get a plain 401 they can treat as "no atlas this time".
+        if (!this.allowRefresh) {
+            return Promise.reject(new SupabaseError("The stored session needs renewing and this process is not allowed to spend it (it runs under a deadline). Skipping.", 401));
+        }
         // Env-var sessions aren't shared through the credentials file, so there is
         // nothing to coordinate between processes: refresh in place.
         if (!this.persistRotation)
@@ -315,10 +335,30 @@ export class Supabase {
             return;
         }
         this.refreshToken = plan.refresh_token;
+        // Una renovacion anterior que quedo a medias: la dejo escrita ANTES de que
+        // esta salga, para no confundirla con la mia.
+        const aMedias = this.persistRotation ? readRefreshInFlight() : null;
+        // Supabase rota el token AL RECIBIR la peticion, asi que desde esta linea y
+        // hasta que se guarde el nuevo, el token del disco esta muerto sin que nadie
+        // lo sepa. Dejar constancia no evita que maten al proceso en esa ventana
+        // —el analyze post-commit corre desacoplado— pero convierte el sintoma de
+        // dentro de media hora en algo explicable.
+        if (this.persistRotation)
+            markRefreshInFlight();
         const res = await this.refreshOnce(this.refreshToken);
         if (!res.ok) {
             const body = (await res.text()).slice(0, 300);
-            throw new SupabaseError(`Could not refresh the ChangeBook session (${res.status}): ${body}\n\n${AUTH_HELP}`, res.status);
+            // El token esta gastado o muerto de todos modos: la marca ya no sirve.
+            if (this.persistRotation)
+                clearRefreshInFlight();
+            const yaUsado = /already[ _]used|refresh[ _]token[ _]not[ _]valid/i.test(body);
+            const explicacion = yaUsado && aMedias
+                ? `\n\nQUE PASO: una renovacion anterior empezo el ${aMedias.at} (proceso ${aMedias.pid}) y no llego a terminar. ` +
+                    `El servidor rotó el token al recibirla, pero este equipo no guardó el nuevo — normalmente porque mataron al proceso ` +
+                    `(el analisis post-commit corre en segundo plano). Al reintentar con el viejo, Supabase lo toma por robado y cierra la sesion. ` +
+                    `No has hecho nada mal y no hay nada que reparar: basta con volver a entrar.`
+                : '';
+            throw new SupabaseError(`Could not refresh the ChangeBook session (${res.status}): ${body}${explicacion}\n\n${AUTH_HELP}`, res.status);
         }
         const data = (await res.json());
         this.accessToken = data.access_token;
@@ -332,9 +372,33 @@ export class Supabase {
                     refresh_token: this.refreshToken,
                     access_token: this.accessToken,
                 });
+                // Guardado: la ventana peligrosa se ha cerrado. Se retira la marca
+                // DESPUES de escribir, no antes — al reves dejaria un hueco en el que
+                // ni hay marca ni hay token nuevo, que es justo el estado que la marca
+                // existe para poder contar.
+                clearRefreshInFlight();
             }
-            catch {
-                // Non-fatal: the in-memory session still works for this process.
+            catch (err) {
+                // NO es inofensivo, aunque lo parezca desde aquí.
+                //
+                // Este proceso sigue funcionando con su sesion en memoria, y por eso el
+                // codigo anterior se lo tragaba en silencio. Pero el token rotado se ha
+                // perdido: Supabase ya invalido el viejo, asi que el SIGUIENTE proceso
+                // leera del disco un token gastado, lo reenviara, y la deteccion de
+                // reutilizacion revocara la sesion entera. El sintoma aparece minutos u
+                // horas despues, sin ninguna relacion visible con este fallo de
+                // escritura — que es lo que lo hacia indiagnosticable.
+                //
+                // Firma en los logs de auth del 2026-07-25: un refresco con 200 a las
+                // 06:51:54 y, diez minutos mas tarde y sin nada en medio, un 400
+                // "Possible abuse attempt". Es exactamente lo que deja este camino.
+                //
+                // No se lanza: tumbar la orden en curso castigaria al usuario por algo
+                // que todavia funciona. Se avisa, alto y con el arreglo puesto.
+                const motivo = err instanceof Error ? err.message : String(err);
+                console.error(`ChangeBook: no se pudo guardar la sesion renovada en ${credentialsPath()} (${motivo}).\n` +
+                    `Esta orden termina bien, pero la siguiente reutilizara un token ya gastado y la sesion se cerrara sola.\n` +
+                    `Comprueba los permisos de ese fichero y vuelve a entrar con:  changebook login`);
             }
         }
     }

package/dist/sync.js CHANGED Viewed

@@ -50,6 +50,27 @@ const SYNC_BUDGET_CHARS = 2_000;
 // shared analyses and a ≥60% rate before we call it a dependency.
 const MIN_PAIR_COUNT = 3;
 const MIN_PAIR_RATE = 0.6;
+/**
+ * Espejo de supabase/functions/mcp/scope.ts::summarizeHealth — el paquete npm
+ * es autocontenido. Paridad fijada en test/saludEnBrief.
+ */
+export function summarizeHealth(rows) {
+    let passed = 0;
+    const at_risk = [];
+    for (const r of rows) {
+        if (r.status === 'passed') {
+            passed += 1;
+        }
+        else if (r.status === 'at_risk') {
+            at_risk.push({
+                check: r.check_id,
+                evidence: (r.evidence ?? '').trim(),
+                since: r.updated_at ? r.updated_at.slice(0, 10) : null,
+            });
+        }
+    }
+    return { passed, at_risk };
+}
 // Same window/limit the web uses for the signals strip.
 const ALERT_WINDOW_DAYS = 14;
 const MAX_ALERTS = 3;
@@ -76,7 +97,7 @@ export async function fetchBriefSection(db, targetDir) {
     }
     const projectId = /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
     const since = new Date(Date.now() - ALERT_WINDOW_DAYS * 24 * 3600 * 1000).toISOString();
-    const [moduleRows, changes, alerts, pendingTasks] = await Promise.all([
+    const [moduleRows, changes, alerts, pendingTasks, healthRows] = await Promise.all([
         db.rest('change_module?select=changelog_id,module,domain,risk,files,note,created_at&order=created_at.desc&limit=500' +
             projectFilter),
         db.rest(`changelog?select=business_impact,created_at&order=created_at.desc&limit=${MAX_CHANGES}` +
@@ -93,8 +114,14 @@ export async function fetchBriefSection(db, targetDir) {
                 .then((rows) => rows.filter((r) => r.status === 'pending'))
                 .catch(() => [])
             : Promise.resolve([]),
+        // Salud (project_checks): tabla diminuta (≤8 filas/proyecto), en paralelo.
+        db
+            .rest('project_checks?select=check_id,status,evidence,updated_at&order=updated_at.desc&limit=8' +
+            projectFilter)
+            .catch(() => []),
     ]);
-    const section = buildSection(moduleRows, changes, alerts, projectName, pendingTasks);
+    const health = summarizeHealth(healthRows);
+    const section = buildSection(moduleRows, changes, alerts, projectName, pendingTasks, health.at_risk);
     return { section, projectId, projectResolved };
 }
 export async function syncContextFiles(db, targetDir, opts = {}) {
@@ -119,7 +146,7 @@ export async function syncContextFiles(db, targetDir, opts = {}) {
     }
 }
 /** Exported for tests. */
-export function buildSection(rows, changes, alerts = [], projectName, pendingTasks = []) {
+export function buildSection(rows, changes, alerts = [], projectName, pendingTasks = [], atRiskHealth = []) {
     // Newest-first rows: the first occurrence of a module is its latest state.
     const seen = new Map();
     for (const row of rows) {
@@ -173,12 +200,27 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         // la tool solo cubre definiciones y el agente acababa pagando atlas Y
         // grep. Con repo local, grep gana; el sitio de symbol_lookup es el agente
         // hospedado sin repo. Medir → actuar, aunque sea des-haciendo lo de ayer.
-        'Disparador → tool: orientarte → `atlas_project_brief` (`intent:"orient"`) · editar un archivo → `atlas_file_context` con su ruta · riesgos/acoplamientos → el brief. Tras cada commit: `atlas_record_change` (diff, hash, fecha, `summary` tuyo; reenviar es gratis).',
+        // Los VERBOS son literales a propósito. La ley medida el 2026-07-21 fue que
+        // la adopción es coincidencia LITERAL (los disparadores literales la movieron
+        // de 60/100/0 a 100/100/60), y el 2026-07-26 se comprobó el otro lado de la
+        // misma ley: T4 pidió «vas a cambiar el comportamiento de la función X» y el
+        // agente, con el atlas disponible, fue directo a grep — 32 turnos, 1,46M
+        // tokens y CERO llamadas al atlas. «editar un archivo» no casaba con cómo
+        // habla quien programa con un agente. Quien no pregunta nada no reconoce un
+        // disparador abstracto: hay que nombrar sus verbos.
+        'Disparador → tool: orientarte → `atlas_project_brief` (`intent:"orient"`) · antes de editar/cambiar/arreglar/refactorizar un archivo o función → `atlas_file_context` (dice QUIÉN DEPENDE de eso) · riesgos/acoplamientos → el brief. Tras cada commit: `atlas_record_change` (diff, hash, fecha, `summary` tuyo; reenviar es gratis).',
         '',
         'Tools diferidas, en UNA llamada: ToolSearch `select:mcp__changebook__atlas_project_brief,mcp__changebook__atlas_file_context,mcp__changebook__atlas_symbol_lookup`.',
         '',
         // Proyecto + conducta en UNA línea: cada char de cabecera expulsa mapa.
-        `${projectName ? `Pasa SIEMPRE \`project: "${sanitizeCell(projectName)}"\`. ` : ''}Anuncia antes de atacar un encargo, y DILE al usuario los riesgos que el atlas te enseñe — él no los ve.`,
+        //
+        // «Anuncia» pasó a «di qué harías y ESPERA su OK» el 2026-07-26, a petición
+        // de Raúl y con razón: anunciar y ponerse a trabajar en el mismo turno no le
+        // deja decidir nada. Y valía para «un encargo», o sea solo para la cola;
+        // ahora vale al abrir, que es cuando el agente elige por su cuenta qué mirar
+        // y qué tocar. Lo que se gasta aquí se recupera en la línea de la cola, que
+        // decía esto mismo por segunda vez.
+        `${projectName ? `Pasa SIEMPRE \`project: "${sanitizeCell(projectName)}"\`. ` : ''}Al abrir: di en 2 líneas qué harías y por qué, y ESPERA su OK antes de tocar código. DILE los riesgos que el atlas te enseñe — él no los ve.`,
         '',
     ];
     if (modules.length === 0) {
@@ -225,6 +267,11 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         return `- **${m.module}** está marcado crítico${note ? ` — ${note}` : ''}`;
     });
     const changeLines = changes.map((c) => `- ${c.created_at.slice(0, 10)} — ${sanitizeCell((c.business_impact ?? '').slice(0, 140))}`);
+    // Salud en riesgo: los controles (auth, secretos, validación, límites…) que
+    // el análisis ya marcó rotos con evidencia. Alta prioridad de presupuesto —
+    // es seguridad. Solo los at_risk (lo accionable); el texto entero va a
+    // `atlas_project_brief`. Cap a 130 chars como las alertas.
+    const healthLines = atRiskHealth.map((h) => `- ⚠ **${h.check}**${h.since ? ` (desde ${h.since})` : ''} — ${sanitizeCell(h.evidence.slice(0, 130))}`);
     // Auto-remediación fase 2: la cola entra en cada sesión para que el agente
     // se OFREZCA a atacarla — proponer con plan y esperar el OK del humano,
     // nunca ejecutar por su cuenta. Títulos deduplicados (la cola real puede
@@ -234,7 +281,7 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
     ].slice(0, 3);
     const taskLines = taskTitles.length > 0
         ? [
-            `- Hay ${pendingTasks.length} encargo(s) pendientes en la cola de este proyecto. Al empezar, propón al usuario cuál atacarías y por qué, y espera su OK antes de tocar código. Cola viva: \`atlas_pending_tasks\`; cierra con \`atlas_complete_task\`.`,
+            `- Hay ${pendingTasks.length} encargo(s) pendientes en la cola de este proyecto. Propón cuál atacarías. Cola viva: \`atlas_pending_tasks\`; cierra con \`atlas_complete_task\`.`,
             ...taskTitles.map((t) => `- ${sanitizeCell(t.slice(0, 120))}`),
         ]
         : [];
@@ -261,6 +308,12 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
             title: '### Regresiones detectadas (resolver o verificar YA)',
             lines: alertLines,
         },
+        {
+            key: 'health',
+            priority: 1,
+            title: '### Salud en riesgo (verifica antes de tocar)',
+            lines: healthLines,
+        },
         {
             key: 'hotspots',
             priority: 4,

package/dist/tools.js CHANGED Viewed

@@ -96,6 +96,49 @@ export function quotedInList(values) {
         .join(",");
 }
 export const FILES_CAP = 8;
+const MAX_DEPENDENTS = 6;
+/** Espejo de MODULE_COUNT_WINDOW_ROWS (supabase/functions/mcp/scope.ts).
+ *  El mapa de la web dibuja las flechas sobre esta misma ventana: dos
+ *  ventanas distintas darían dependencias distintas según se mire el dibujo
+ *  o se pregunte al atlas. Paridad fijada en test/radioDeImpacto. */
+const MODULE_GRAPH_WINDOW_ROWS = 1000;
+export function dependentsOf(targets, rows) {
+    const graph = new Map();
+    for (const r of rows) {
+        const label = (r.module ?? "").trim();
+        if (!label || graph.has(label.toLowerCase()))
+            continue;
+        const deps = Array.isArray(r.deps)
+            ? r.deps.map((d) => (typeof d === "string" ? d.trim() : "")).filter(Boolean)
+            : [];
+        graph.set(label.toLowerCase(), deps);
+    }
+    const reverse = new Map();
+    for (const r of rows) {
+        const from = (r.module ?? "").trim();
+        if (!from)
+            continue;
+        for (const to of graph.get(from.toLowerCase()) ?? []) {
+            const key = to.toLowerCase();
+            if (key === from.toLowerCase())
+                continue;
+            const set = reverse.get(key) ?? new Set();
+            set.add(from);
+            reverse.set(key, set);
+        }
+    }
+    const out = new Map();
+    for (const t of targets) {
+        const label = (t ?? "").trim();
+        if (!label)
+            continue;
+        const found = reverse.get(label.toLowerCase());
+        if (!found || found.size === 0)
+            continue;
+        out.set(label, [...found].sort((a, b) => a.localeCompare(b)).slice(0, MAX_DEPENDENTS));
+    }
+    return out;
+}
 /**
  * Reincidencia (espejo de supabase/functions/mcp/scope.ts::computeRecidivism —
  * paridad en test/reincidenciaFileContext). Por módulo, nº de problemas de
@@ -735,7 +778,7 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             for (const f of perFile) {
                 commitsByFile.set(f.file, recentCommitsForFile(f.changelogIds, commitById));
             }
-            const [alerts, watched, recidivismRows] = await Promise.all([
+            const [alerts, watched, recidivismRows, depsRows] = await Promise.all([
                 moduleNames.length
                     ? db.rest(`regression_alerts?select=module,plain,evidence_symbol,evidence_expect&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
                         pf)
@@ -759,6 +802,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                         pf)
                         .catch(() => [])
                     : Promise.resolve([]),
+                // Radio de impacto: grafo COMPLETO del proyecto (no filtrado por
+                // moduleNames — quién depende de X vive en las filas de OTROS
+                // módulos). En el mismo Promise.all: cero rondas extra, cero turnos
+                // extra. Best-effort: sin columna, el contexto se sirve sin radio.
+                db
+                    .rest(`change_module?select=module,deps&deps=not.is.null&order=created_at.desc&limit=${MODULE_GRAPH_WINDOW_ROWS}` +
+                    pf)
+                    .catch(() => []),
             ]);
             const watchedByFile = new Map();
             for (const w of watched) {
@@ -787,6 +838,7 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             // (count(distinct plain), all-time), solo los con antecedentes (>= 2).
             // Fuente única compartida (computeRecidivism) — antes 3 copias.
             const recidivismByModule = computeRecidivism(recidivismRows);
+            const dependentsByModule = dependentsOf(moduleNames, depsRows);
             // Ancla temporal: el último commit analizado del proyecto vs el HEAD
             // de este árbol (misma puerta de proyecto que la refutación).
             // Best-effort: el ancla jamás rompe la lectura que ancla.
@@ -829,6 +881,10 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     for (const plain of alertsByModule.get(m.module) ?? []) {
                         lines.push(`  - ⚠ OPEN ALERT: ${plain}`);
                     }
+                    const dependents = dependentsByModule.get(m.module);
+                    if (dependents?.length) {
+                        lines.push(`  - ↘ DEPENDS ON THIS: ${dependents.join(", ")} — check these too before you finish`);
+                    }
                 }
                 for (const w of watchedByFile.get(f.file) ?? []) {
                     lines.push(`- Current value: ${w.name} = ${w.value}` +
@@ -864,6 +920,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                         prior_regressions: recidivismByModule.get(m.module) ?? 0,
                     }))
                         .filter((x) => x.prior_regressions >= 2),
+                    // Espejo del hospedado: el structuredContent no puede prometer
+                    // menos que la prosa.
+                    dependents: f.modules
+                        .map((m) => ({
+                        module: m.module,
+                        dependents: dependentsByModule.get(m.module) ?? [],
+                    }))
+                        .filter((x) => x.dependents.length > 0),
                     watched_values: (watchedByFile.get(f.file) ?? []).map((w) => ({
                         name: w.name,
                         value: w.value,

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "mcpName": "io.github.raulbr90/changebook",
   "description": "ChangeBook for coding agents: MCP server (product memory for Claude Code/Codex) + CLI to sign in, analyze changes and sync the product map.",
   "type": "module",

package/server.json CHANGED Viewed

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.raulbr90/changebook",
   "description": "Query your product's living memory: module map + analyzed change history. Read-only MCP tools.",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.4.7",
+      "version": "0.4.9",
       "transport": {
         "type": "stdio"
       }