@nac3/forge-cli 1.8.0 → 1.8.3

package/dist/chat/server.js

@@ -131,6 +131,20 @@ export async function startChatServer(opts) {
      *  CLI + panel converge. */
     const { resolveProjectSlug } = await import('./project_slug.js');
     const projectSlug = await resolveProjectSlug(opts.projectRoot);
+    /* 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
+     * existe y cae al global si no, asi que nada cambia hasta que alguien
+     * elige uno aca, y ahi el cambio se queda aca.
+     *
+     * 2026-10-03 -- esto estaba DESPUES de construir el brain client, asi que
+     * la modalidad (Plan/Console) se decidia con el scope todavia sin atar.
+     * Va antes de cualquier lectura de brain_config. */
+    try {
+        const { setBrainConfigScope } = await import('../core/brain_config.js');
+        setBrainConfigScope(projectSlug);
+    }
+    catch { /* sin scope se sigue usando el global, como antes */ }
     /* Director sprint slice 9 -- hydrate ingest sessions from disk
      *  for this project so spec extract+plan survive restarts. */
     try {
@@ -234,9 +248,42 @@ export async function startChatServer(opts) {
         }
         return new ClaudeClient();
     }
+    /* De donde sale la modalidad cuando el llamador no la fija: la config del
+     * cerebro de ESTE proyecto (ya scopeada arriba) y, si no dice nada, el
+     * camino que eligio el wizard. Prioridad: --provider > brain_config >
+     * wizard_state > anthropic-api.
+     *
+     * 2026-10-03 -- esto se derivaba en `yf chat` ANTES de arrancar el server,
+     * con un scope resuelto por otro camino (resolveProjectSlugSync). Cuando
+     * los dos slugs no coincidian, el boot leia la config del proyecto
+     * equivocado: el panel mostraba la modalidad correcta (lee la config ya
+     * scopeada) y el cerebro vivo era el de arrastre. Ahora la cadena vive
+     * aca, que es donde se resuelve el slug autoritativo. */
+    async function providerFromBrainConfig() {
+        try {
+            const { readBrainConfig } = await import('../core/brain_config.js');
+            const bc = await readBrainConfig();
+            if (bc.anthropic_mode === 'plan')
+                return 'claude-code-cli';
+            if (bc.anthropic_mode === 'console')
+                return 'anthropic-api';
+        }
+        catch { /* sin config -> probamos el wizard */ }
+        try {
+            const { readWizardState } = await import('../core/wizard_state.js');
+            if ((await readWizardState()).path_chosen === 'claude_plan')
+                return 'claude-code-cli';
+        }
+        catch { /* swallow */ }
+        return null;
+    }
+    /* `--provider` -- y el anthropic-api forzado de una sub-sesion agentMode,
+     * que es lo que hace que el scope de verbos aplique -- pisan la config y
+     * NO se re-derivan: ni al boot ni al cambiar de proyecto. */
+    const providerPinned = !!opts.chatProvider;
     /* MUTABLE per-session provider state, so flipping Plan/Console in the
      * panel applies LIVE (mirrors the reanchor pattern). */
-    let activeChatProvider = opts.chatProvider ?? 'anthropic-api';
+    let activeChatProvider = opts.chatProvider ?? (await providerFromBrainConfig()) ?? 'anthropic-api';
     let claude = opts.claude ?? await buildClaudeClient(activeChatProvider);
     /** Hot-swap the brain provider when the user flips the mode in the
      *  panel. 'plan' -> claude-code-cli (subscription); 'console' ->
@@ -256,6 +303,25 @@ export async function startChatServer(opts) {
         catch { /* */ }
         return true;
     }
+    /** El cerebro sigue al proyecto activo: despues de un reanchor hay que
+     *  re-derivar la modalidad del proyecto NUEVO. Sin esto el provider
+     *  quedaba de arrastre (el del proyecto anterior) mientras el selector del
+     *  panel -- que lee la config ya re-scopeada -- mostraba la del nuevo, y
+     *  solo se enderezaba al tocar Plan/Console a mano. */
+    async function applyProviderFromBrainConfig() {
+        if (providerPinned || opts.claude)
+            return false;
+        const target = (await providerFromBrainConfig()) ?? 'anthropic-api';
+        if (target === activeChatProvider)
+            return false;
+        claude = await buildClaudeClient(target);
+        activeChatProvider = target;
+        try {
+            console.error('[brain] provider del proyecto activo -> ' + target);
+        }
+        catch { /* */ }
+        return true;
+    }
     const voice = opts.voice ?? new VoiceRouter({
         configDir: configDir(),
         registry: buildDefaultRegistry(),
@@ -289,16 +355,6 @@ export async function startChatServer(opts) {
      * handlers (que leen de `session`) pasan a apuntar al nuevo root
      * sin reiniciar el panel. */
     const session = { projectRoot: opts.projectRoot, projectName, projectSlug };
-    /* 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
-     * existe y cae al global si no, asi que nada cambia hasta que alguien
-     * elige uno aca, y ahi el cambio se queda aca. */
-    try {
-        const { setBrainConfigScope } = await import('../core/brain_config.js');
-        setBrainConfigScope(projectSlug);
-    }
-    catch { /* sin scope se sigue usando el global, como antes */ }
     /* Project registry (task #33) -- record the project we just opened in
      * ~/.yujin-forge/projects.json + mark it active, so the project
      * selector (panel + mobile) always lists at least the current one.
@@ -344,6 +400,15 @@ export async function startChatServer(opts) {
             setBrainConfigScope(session.projectSlug);
         }
         catch { /* best-effort */ }
+        /* ...y con el scope nuevo, la modalidad (Plan/Console) del proyecto
+         * nuevo. Antes se quedaba la del anterior hasta tocarla a mano. */
+        try {
+            if (await applyProviderFromBrainConfig()) {
+                chatLog('Cerebro de este proyecto: '
+                    + (activeChatProvider === 'claude-code-cli' ? 'Plan (suscripcion)' : 'Console (API)') + '.');
+            }
+        }
+        catch { /* best-effort */ }
         /* keep the registry in sync after a hot switch (task #33) */
         try {
             await upsertProject({ slug: session.projectSlug, path: abs });
@@ -492,6 +557,16 @@ export async function startChatServer(opts) {
         };
         tryListen(opts.port);
     });
+    /* El puerto REAL, no el pedido (2026-10-03). El retry de EADDRINUSE ya
+     * reescribia opts.port, pero un port:0 (liga uno efimero) no pasa por ahi:
+     * opts.port se quedaba en 0 y entonces la url, el lock de instancia y el
+     * panelBridge del subproceso apuntaban a un puerto que no existe. */
+    {
+        const addr = server.address();
+        if (addr && typeof addr === 'object' && typeof addr.port === 'number' && addr.port > 0) {
+            opts.port = addr.port;
+        }
+    }
     /* Port-race fix (2026-09-01). The eager `claude` client above was built
      * BEFORE the EADDRINUSE retry could finalize opts.port. The CLI client
      * FREEZES panelBridge.port at construction, so when two instances race for
@@ -605,6 +680,7 @@ export async function startChatServer(opts) {
         port: opts.port,
         store,
         bridge: bridgeHandle,
+        reanchor,
         close: () => new Promise((resolve) => {
             /* alpha.59w -- stop the component watcher on shutdown so
              *  vitest does not hang on lingering fs watchers. */