@nac3/forge-cli 1.8.4 → 1.8.6

package/dist/chat/server.js

@@ -131,6 +131,49 @@ export async function startChatServer(opts) {
      *  CLI + panel converge. */
     const { resolveProjectSlug } = await import('./project_slug.js');
     const projectSlug = await resolveProjectSlug(opts.projectRoot);
+    /* COLISION DE SLUG (Pablo 2026-10-04). El slug es la clave de identidad de
+     * TODO lo que es por proyecto: el grafo semantico, los pendings, el wiring,
+     * el cerebro, y la entrada del registro que alimenta el selector del
+     * celular. Dos carpetas distintas que resuelven al mismo slug comparten
+     * todo eso en silencio.
+     *
+     * Paso de verdad: C:\yujin-kikan (el CRM generico) y C:\adip\kikan (el
+     * adaptado para ADIP, que es una copia y por eso tiene el MISMO
+     * package.json name) resolvian los dos a 'yujin-kikan'. Resultado: un solo
+     * pending.json de 354KB y un solo grafo para los dos proyectos, y la
+     * entrada del registro apuntando a la carpeta de quien arranco ultimo -- el
+     * celular mostraba un proyecto y abria el otro.
+     *
+     * No se renombra nada solo: cambiarle el slug a un proyecto le huerfana el
+     * grafo y los pendings que ya tiene. Se AVISA, fuerte, con el arreglo
+     * exacto -- un `project_slug` explicito en yujin.forge.json, que el
+     * resolver respeta antes que cualquier otra cosa. */
+    try {
+        const reg = await readRegistry();
+        const choque = (reg.projects || []).find((p) => {
+            if (p.slug !== projectSlug || !p.path)
+                return false;
+            const norm = (s) => s.replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+            return norm(p.path) !== norm(opts.projectRoot);
+        });
+        if (choque) {
+            const aviso = '[yf] ATENCION: colision de slug. "' + projectSlug + '" ya estaba usado por '
+                + choque.path + ' y esta carpeta es ' + opts.projectRoot + '. Los dos proyectos comparten '
+                + 'grafo, pendings, wiring y cerebro, y el selector del celular no puede distinguirlos. '
+                + 'Arreglo: agregale "project_slug": "<un-slug-propio>" al yujin.forge.json de uno de los dos.';
+            try {
+                console.error(aviso);
+            }
+            catch { /* noop */ }
+            /* Que ademas llegue al chat, no solo al stdout que nadie mira. */
+            try {
+                const { enqueuePanelDispatch } = await import('./panel_queue.js');
+                enqueuePanelDispatch('system.chat-log', { text: aviso }, new Date().toISOString());
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    catch { /* sin registro no hay con que comparar */ }
     /* Cerebro por instancia (Pablo, 2026-09-30). Habia una sola config para
      * todas: cambiar el cerebro en un `yf chat` lo cambiaba en todos. Este
      * proceso queda atado al cerebro de SU proyecto -- lee el del proyecto si
@@ -164,7 +207,20 @@ export async function startChatServer(opts) {
      *  alpha.59v.2 -- registered via startAutoIngest so the
      *  /api/forge/graph-status endpoint can await it (avoiding
      *  the panel showing partial data during the ingest). */
+    /* AISLAMIENTO EN TESTS (Pablo 2026-10-04). Estos tres trabajos del boot son
+     * fire-and-forget y escriben en el store por slug (projects/<slug>/
+     * semantic_graph.db, pending.json). El path lo resuelven POR LLAMADA desde
+     * YF_CONFIG_DIR, pero sobreviven al test que los disparo: cuando corren, el
+     * afterEach ya restauro la env var, asi que terminan escribiendo en el
+     * config dir REAL del usuario. Evidencia: `projects/demo-scope/`,
+     * `projects/mode-console/`, `projects/lifecycle-test/` aparecieron en el
+     * ~/.yujin-forge de Pablo con fecha de las corridas de hoy. Y ese directorio
+     * es el que alimenta el selector de proyectos del celular, asi que la
+     * basura de los tests se ve en pantalla. En test no corren. */
+    const enTest = !!process.env.VITEST || process.env.NODE_ENV === 'test';
     try {
+        if (enTest)
+            throw new Error('test env: sin auto-ingest');
         const { startAutoIngest } = await import('./graph_auto_ingest.js');
         startAutoIngest({
             project_root: opts.projectRoot,
@@ -181,17 +237,18 @@ export async function startChatServer(opts) {
      * background, para que al abrir el panel el grafo este completo.
      * El boton Refresh + el watcher lo regeneran luego ante cambios.
      * Fire-and-forget; nunca rompe el boot. */
-    void (async () => {
-        try {
-            const { regenerateAndPersist } = await import('../semantic_graph/derive.js');
-            const s = await regenerateAndPersist({ project_root: opts.projectRoot, project_slug: projectSlug, enrich: false });
+    if (!enTest)
+        void (async () => {
             try {
-                console.error('[graph-regen] boot -> ' + (s.module_edges + s.lib_edges) + ' edges (' + s.pruned + ' pruned)');
+                const { regenerateAndPersist } = await import('../semantic_graph/derive.js');
+                const s = await regenerateAndPersist({ project_root: opts.projectRoot, project_slug: projectSlug, enrich: false });
+                try {
+                    console.error('[graph-regen] boot -> ' + (s.module_edges + s.lib_edges) + ' edges (' + s.pruned + ' pruned)');
+                }
+                catch { /* */ }
             }
-            catch { /* */ }
-        }
-        catch { /* never break boot */ }
-    })();
+            catch { /* never break boot */ }
+        })();
     /* alpha.59w -- fs.watch over src/components, src/hooks, src/lib,
      *  src/core. When the user adds or modifies a TS/JS file, the
      *  watcher extracts top-level exports (regex), creates one
@@ -200,6 +257,8 @@ export async function startChatServer(opts) {
      *  attached to the returned StartedServer.close(). */
     let componentWatcherHandle = null;
     try {
+        if (enTest)
+            throw new Error('test env: sin component watcher');
         const { startComponentWatcher } = await import('./graph_component_watcher.js');
         componentWatcherHandle = await startComponentWatcher({
             project_root: opts.projectRoot,
@@ -366,6 +425,15 @@ export async function startChatServer(opts) {
      * ephemeral runs (vitest sets VITEST; also skip an obvious temp root). */
     const isTestEnv = !!process.env.VITEST || process.env.NODE_ENV === 'test';
     const isTempRoot = /[\\/](?:te?mp|yf-[a-z-]*proj|yf-startup)/i.test(opts.projectRoot);
+    /* El mismo guard, pero evaluable contra CUALQUIER root -- lo necesita el
+     * reanchor, que recibe uno nuevo (Pablo 2026-10-04). El reanchor escribia
+     * en el registro sin guard alguno, asi que un test que cambia de proyecto
+     * dejaba sus carpetas temporales en el registro REAL del usuario: y el
+     * registro alimenta el selector de proyectos del celular, de modo que la
+     * basura termina en pantalla. */
+    const puedeEscribirRegistro = (root) => !isTestEnv
+        && !/[\\/](?:te?mp|yf-[a-z-]*proj|yf-startup)/i.test(root)
+        && !opts.agentMode;
     /* A headless agent sub-session must NEVER touch the global registry --
      * it would flip the parent's active project (Pablo's scramble bug). */
     if (!isTestEnv && !isTempRoot && !opts.agentMode) {
@@ -410,11 +478,13 @@ export async function startChatServer(opts) {
         }
         catch { /* best-effort */ }
         /* keep the registry in sync after a hot switch (task #33) */
-        try {
-            await upsertProject({ slug: session.projectSlug, path: abs });
-            await setActive(session.projectSlug);
+        if (puedeEscribirRegistro(abs)) {
+            try {
+                await upsertProject({ slug: session.projectSlug, path: abs });
+                await setActive(session.projectSlug);
+            }
+            catch { /* best-effort */ }
         }
-        catch { /* best-effort */ }
         chatLog('Cambiando al proyecto ' + session.projectName + ' (' + abs + ')...');
         /* re-hidratar ingest + reiniciar el watcher sobre el nuevo dir */
         try {
@@ -459,6 +529,12 @@ export async function startChatServer(opts) {
          * terminar dispara el re-tabs. */
         const slugNow = session.projectSlug;
         const nameNow = session.projectName;
+        /* Mismo aislamiento que el regen del boot (2026-10-04): este tambien es
+         * fire-and-forget y sobrevive al test que lo disparo, asi que terminaba
+         * creando projects/<slug>/semantic_graph.db en el config dir REAL. Se vio
+         * con los slugs 'pin-to' y 'switch-to', del test de reanchor. */
+        if (enTest)
+            return { projectRoot: session.projectRoot, projectName: nameNow, projectSlug: slugNow };
         chatLog('Regenerando el grafo semantico de ' + nameNow + '...');
         void (async () => {
             try {
@@ -1083,7 +1159,16 @@ function publishBoardSnapshot() {
                 snap.projects = (reg.projects || []).slice(0, 30).map((p) => ({
                     slug: p.slug, path: p.path || '',
                 }));
-                snap.activeProject = reg.active_slug || cx.slug || null;
+                /* El proyecto activo que el celular espeja es el de ESTA instancia,
+                 * no el puntero global del registro (Pablo 2026-10-04: "la otra la
+                 * sincroniza mal, me sincroniza el yujin-kikan en vez del que
+                 * tengo"). Con dos `yf chat` abiertos, active_slug es el del que
+                 * arranco o cambio de proyecto ultimo, asi que las DOS instancias
+                 * publicaban el mismo activeProject: el celular, espejando una,
+                 * mostraba el proyecto de la otra. cx.slug es el de la instancia que
+                 * publica este board. El global queda de respaldo para el caso en
+                 * que la instancia todavia no tenga slug. */
+                snap.activeProject = cx.slug || reg.active_slug || null;
             }
             catch { /* leave unset */ }
             /* Relay budget (bug 2026-07-10): the worker rejects events over 32KB
@@ -2244,6 +2329,12 @@ async function route(req, res, ctx) {
                 month: status.month,
                 renewal_at: status.renewal_at,
                 extension_url: status.extension_url,
+                /* 2026-10-04 -- `source` (y el plan del worker) no se reenviaban, asi
+                 * que el chip de fuente del panel era codigo muerto: la tarjeta no
+                 * podia decir si el numero venia del worker o del medidor local.
+                 * Justo el dato que hace falta cuando los tokens se ven en cero. */
+                source: status.source,
+                server_plan: status.server_plan,
                 eco: {
                     cap: finite(status.eco.cap),
                     used: status.eco.used,
@@ -5925,6 +6016,12 @@ async function handleChat(req, res, ctx) {
              * this block was byte-identical turn-to-turn yet re-sent uncached. */
             systemDynamic: projectContextSection + wiringSection + toolingSection + recentSessionsRecap + graphSection + snapshotSection + workflowSection + approvalPostureSection + toolStatusSection(),
             maxTokens: _maxTokensPerTurn,
+            /* Tope del turno en Plan, POR TURNO (Pablo 2026-10-04). Se leia solo al
+             * construir el cliente, asi que subir claude_cli_timeout_ms en el panel
+             * no hacia nada hasta reiniciar: el panel decia 10000000 y el corte
+             * seguia avisando 5000000. Sale del mismo `_limits` que ya se lee cada
+             * turno para max_tokens_per_turn. Los clientes HTTP lo ignoran. */
+            timeoutMs: _limits.claude_cli_timeout_ms,
             /* Plan/CLI uses Claude Code's native tools (FORGE_TOOL_SPECS = just
              * nac3_invoke via the MCP bridge); the HTTP path (BYOK/Console + managed)
              * gets direct native file tools + nac3_invoke so the model is fluent with