@nac3/forge-cli 1.19.1 → 1.19.3

package/dist/chat/server.js

@@ -1777,6 +1777,89 @@ async function route(req, res, ctx) {
         }
         return;
     }
+    /* One project document, for the links of the Urazuke card modal. Gated to
+     * the project root: a path that escapes it is refused. */
+    if (req.method === 'GET' && url.pathname === '/api/forge/project-doc') {
+        const rel = (url.searchParams.get('path') || '').trim();
+        if (!rel) {
+            sendJson(res, 400, { ok: false, error: 'path required' });
+            return;
+        }
+        try {
+            const nodePath = await import('node:path');
+            const fsp = await import('node:fs/promises');
+            const abs = nodePath.resolve(ctx.projectRoot, rel);
+            const inside = abs === ctx.projectRoot || abs.startsWith(ctx.projectRoot + nodePath.sep);
+            if (!inside) {
+                sendJson(res, 403, { ok: false, error: 'path outside the project' });
+                return;
+            }
+            const st = await fsp.stat(abs);
+            if (!st.isFile()) {
+                sendJson(res, 404, { ok: false, error: 'not a file' });
+                return;
+            }
+            if (st.size > 2 * 1024 * 1024) {
+                sendJson(res, 413, { ok: false, error: 'file too big for the panel (2 MB)' });
+                return;
+            }
+            const content = await fsp.readFile(abs, 'utf8');
+            const ext = nodePath.extname(abs).replace('.', '').toLowerCase();
+            sendJson(res, 200, { ok: true, path: nodePath.relative(ctx.projectRoot, abs).split(nodePath.sep).join('/'), content, language: ext || null });
+        }
+        catch (e) {
+            sendJson(res, 404, { ok: false, error: e instanceof Error ? e.message : String(e) });
+        }
+        return;
+    }
+    /* One pending item in full, for the click on a Workflow task. */
+    if (req.method === 'GET' && url.pathname === '/api/forge/pending-item') {
+        const id = (url.searchParams.get('id') || '').trim();
+        if (!id) {
+            sendJson(res, 400, { ok: false, error: 'id required' });
+            return;
+        }
+        try {
+            const { findPending } = await import('../pending/store.js');
+            const item = await findPending(ctx.projectSlug || '', id);
+            if (!item) {
+                sendJson(res, 404, { ok: false, error: 'pending ' + id + ' not found' });
+                return;
+            }
+            sendJson(res, 200, { ok: true, item });
+        }
+        catch (e) {
+            sendJson(res, 500, { ok: false, error: e instanceof Error ? e.message : String(e) });
+        }
+        return;
+    }
+    /* URAZUKE start (2026-10-19): the panel button. */
+    if (req.method === 'POST' && url.pathname === '/api/forge/urazuke-start') {
+        let body = {};
+        try {
+            body = JSON.parse(await readBody(req) || '{}');
+        }
+        catch {
+            body = {};
+        }
+        try {
+            const { startUrazuke } = await import('../urazuke/start.js');
+            const r = await startUrazuke(ctx.projectSlug || '', ctx.projectRoot, { force: body.force === true });
+            if (r.ok) {
+                try {
+                    const { urazukeCurrent } = await import('../urazuke/current.js');
+                    const { announceStepIfChanged } = await import('../urazuke/announce.js');
+                    await announceStepIfChanged(ctx.projectSlug || '', await urazukeCurrent(ctx.projectSlug || '', ctx.projectRoot));
+                }
+                catch { /* best effort */ }
+            }
+            sendJson(res, r.ok ? 200 : 409, { ...r });
+        }
+        catch (e) {
+            sendJson(res, 500, { ok: false, error: e instanceof Error ? e.message : String(e) });
+        }
+        return;
+    }
     if (req.method === 'POST' && url.pathname === '/api/forge/urazuke-prompts') {
         let body;
         try {
@@ -4594,6 +4677,8 @@ async function handleMobilePair(_req, res) {
  *  Devuelve {enabled, tabs:[{key,title,kind,content}]}. El panel
  *  las materializa al abrir (salvo las que el usuario cerro) y
  *  hace polling para auto-refrescarlas. */
+/* One leftover-tasks notice per panel process (2026-10-20). */
+let leftoverTasksAnnounced = false;
 async function handleStartupTabs(_req, res, ctx, url) {
     const slug = ctx.projectSlug || '';
     let enabled = true;
@@ -4702,7 +4787,17 @@ async function handleStartupTabs(_req, res, ctx, url) {
     catch {
         ladderActive = false;
     }
-    hidden.push(ladderActive ? 'startup_workflow' : 'startup_urazuke');
+    let urazukeOn = false;
+    try {
+        urazukeOn = await (await import('../urazuke/enabled.js')).urazukeEnabled();
+    }
+    catch {
+        urazukeOn = false;
+    }
+    if (ladderActive)
+        hidden.push('startup_workflow');
+    else if (!urazukeOn)
+        hidden.push('startup_urazuke');
     /* 4: workflow como GRAFO de nodos (las 6 fases del flujo yujin
      * con sus pasos), coloreadas por estado (done/pendiente) cuando
      * hay workflow state. Cumple el pedido de "workflow como grafo
@@ -4749,6 +4844,12 @@ async function handleStartupTabs(_req, res, ctx, url) {
             } : null;
             tabs.push({ key: 'startup_urazuke', title: t('startup.tab.urazuke'), kind: 'urazuke', content: JSON.stringify({ ladder, current }) });
         }
+        else if (slugU && urazukeOn) {
+            /* No ladder yet: the tab offers the door in (yujin.urazuke.start). */
+            const { urazukeStartHint } = await import('../urazuke/start.js');
+            const start = await urazukeStartHint(slugU, ctx.projectRoot);
+            tabs.push({ key: 'startup_urazuke', title: t('startup.tab.urazuke'), kind: 'urazuke', content: JSON.stringify({ ladder: null, current: null, start }) });
+        }
     }
     catch { /* sin escalera: la pestana no aparece */ }
     /* 5: PND-007 -- Tareas de fondo (se llena en vivo client-side). */
@@ -6206,12 +6307,37 @@ async function handleChat(req, res, ctx) {
          * the mechanical state of its checks, injected every turn. This is the
          * mechanism that replaces the advisory 18-step flow: the brain gets the
          * method's exact instruction, and the close gate refuses a red step. */
+        /* Live background tasks (2026-10-20): the brain sees what is still up so
+         * it does not relaunch it, and the owner gets one notice when the panel
+         * opens with servers left over from another session. */
+        let liveTasksSection = '';
+        try {
+            const { liveTasks, renderLiveTasksSection, renderLeftoverNotice } = await import('../tasks/alive.js');
+            const live = await liveTasks(ctx.projectSlug || '');
+            liveTasksSection = renderLiveTasksSection(live);
+            if (!leftoverTasksAnnounced) {
+                leftoverTasksAnnounced = true;
+                const notice = renderLeftoverNotice(live);
+                if (notice) {
+                    const { enqueuePanelDispatch } = await import('./panel_queue.js');
+                    enqueuePanelDispatch('system.chat-log', { text: notice }, new Date().toISOString());
+                }
+            }
+        }
+        catch (_) { /* swallow */ }
         let urazukeSection = '';
         try {
             const { buildUrazukeSection } = await import('./urazuke_section.js');
             const r = await buildUrazukeSection({ project_slug: ctx.projectSlug || '', project_root: ctx.projectRoot, char_budget: 6000 });
             if (r.rendered_text)
                 urazukeSection = r.rendered_text;
+            /* The owner sees in the chat which step runs and what is expected of
+             * them (never the prompt): one system line per step change. */
+            try {
+                const { announceStepIfChanged } = await import('../urazuke/announce.js');
+                await announceStepIfChanged(ctx.projectSlug || '', r.current);
+            }
+            catch { /* best effort */ }
         }
         catch (_) { /* swallow */ }
         /* alpha.59z.15 HITO 6.3 -- prefetch global learnings from
@@ -6245,6 +6371,14 @@ async function handleChat(req, res, ctx) {
         try {
             const { readLimitsConfig } = await import('../core/limits_config.js');
             multiagentEnabled = (await readLimitsConfig()).multiagent.enabled === true;
+            /* 2026-10-19: on the Claude Plan without another provider's key the
+             * children cannot run; hide the verbs instead of letting the brain
+             * discover it by four dead sub-sessions. */
+            if (multiagentEnabled) {
+                const { hasUsableChildBrain } = await import('./tools/session_verbs.js');
+                if (!(await hasUsableChildBrain()))
+                    multiagentEnabled = false;
+            }
         }
         catch (_) { /* config failure -> stay OFF (safe default) */ }
         /* alpha.59z.37 NAC-3 v3.x backend tools -- prefetch the
@@ -6413,7 +6547,7 @@ async function handleChat(req, res, ctx) {
              * stable-first suffix lets a prefix cache extend through the unchanged
              * dynamic lines instead of missing on the first per-turn byte. ~84% of
              * this block was byte-identical turn-to-turn yet re-sent uncached. */
-            systemDynamic: projectContextSection + sizingSection + urazukeSection + wiringSection + toolingSection + recentSessionsRecap + graphSection + snapshotSection + workflowSection + approvalPostureSection + toolStatusSection(),
+            systemDynamic: projectContextSection + sizingSection + liveTasksSection + urazukeSection + 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