@nac3/forge-cli 0.2.1-alpha.60 → 1.0.0

package/dist/chat/server.js

@@ -13,6 +13,7 @@
  */
 import { createServer } from 'node:http';
 import { promises as fs } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { ClaudeClient, ConfigurationError, ClaudeApiError } from './claude.js';
@@ -39,6 +40,12 @@ import { generatePlan } from './spec_plan.js';
 import { executeScaffold, rollbackScaffold } from './spec_scaffold.js';
 import { VERSION } from '../version.js';
 import { buildDoctrineDigestLines } from './doctrine_digest.js';
+import { RelayPublisher } from '../relay/relay_publisher.js';
+import { relayPoll } from '../relay/relay_client.js';
+import { startCommandConsumer } from '../relay/command_consumer.js';
+import { getSessionStore, DEFAULT_SESSION_ID } from './session_store.js';
+import { getSessionProject, setSessionProject } from './session_projects.js';
+import { beginTurn, endTurn, interruptActiveTurn, isTurnActive } from './turn_control.js';
 import { manifest as nac3Manifest } from '../nac3/internal_manifest.js';
 import { buildManifestForPrompt } from '../nac3/manifest_lazy.js';
 import { popPending, logApproval } from '../nac3/approval_queue.js';
@@ -126,23 +133,53 @@ export async function startChatServer(opts) {
      * (to hand to its MCP server) share it. Only meaningful in CLI
      * mode; harmless otherwise. */
     const panelPushToken = (await import('node:crypto')).randomBytes(32).toString('hex');
-    let claude;
-    if (opts.claude) {
-        claude = opts.claude;
-    }
-    else if (opts.chatProvider === 'claude-code-cli') {
-        const { ClaudeCliClient } = await import('./claude_cli.js');
-        const cliOpts = {};
-        if (opts.chatProviderAddDirs && opts.chatProviderAddDirs.length > 0) {
-            cliOpts['addDirs'] = opts.chatProviderAddDirs;
+    /* Build the chat LLM client for a provider. Extracted so the brain
+     * mode (Plan = subscription via `claude -p`, Console = BYOK Anthropic
+     * HTTP) can HOT-SWAP at runtime when the user flips it in the panel --
+     * no panel restart. */
+    async function buildClaudeClient(provider) {
+        if (provider === 'claude-code-cli') {
+            const { ClaudeCliClient } = await import('./claude_cli.js');
+            const cliOpts = {};
+            if (opts.chatProviderAddDirs && opts.chatProviderAddDirs.length > 0) {
+                cliOpts['addDirs'] = opts.chatProviderAddDirs;
+            }
+            /* Configurable Plan-mode turn cap (NADA hardcode): the 30-min default
+             * lives in limits.json and is tunable via `yf limits set
+             * claude_cli_timeout_ms <ms>` or the panel. */
+            try {
+                const { readLimitsConfig } = await import('../core/limits_config.js');
+                cliOpts['timeoutMs'] = (await readLimitsConfig()).claude_cli_timeout_ms;
+            }
+            catch { /* fall back to the ClaudeCliClient default (30 min) */ }
+            /* Wire the panel MCP bridge: the subprocess gets the forge_panel
+             * MCP server so it can create pizarron tabs. */
+            cliOpts['panelBridge'] = { port: opts.port, token: panelPushToken };
+            return new ClaudeCliClient(cliOpts);
         }
-        /* Wire the panel MCP bridge: the subprocess gets the
-         * forge_panel MCP server so it can create pizarron tabs. */
-        cliOpts['panelBridge'] = { port: opts.port, token: panelPushToken };
-        claude = new ClaudeCliClient(cliOpts);
-    }
-    else {
-        claude = new ClaudeClient();
+        return new ClaudeClient();
+    }
+    /* 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 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' ->
+     *  anthropic-api (BYOK). No-op for a test-injected client. Returns
+     *  true if the live provider actually changed. */
+    async function setBrainProvider(mode) {
+        if (opts.claude)
+            return false; /* test harness owns the client */
+        const target = mode === 'plan' ? 'claude-code-cli' : 'anthropic-api';
+        if (target === activeChatProvider)
+            return false;
+        claude = await buildClaudeClient(target);
+        activeChatProvider = target;
+        try {
+            console.error('[brain] hot-swap provider -> ' + target + ' (' + mode + ')');
+        }
+        catch { /* */ }
+        return true;
     }
     const voice = opts.voice ?? new VoiceRouter({
         configDir: configDir(),
@@ -177,6 +214,26 @@ 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 };
+    /* 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.
+     *
+     * GUARD (Pablo 2026-06-15, log evidence): every server boot here wrote
+     * to the GLOBAL registry, and the many tests that boot the server do
+     * NOT isolate the config dir -- so `pnpm test` was clobbering the real
+     * ~/.yujin-forge/projects.json with temp fixture dirs. Skip in test /
+     * 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);
+    if (!isTestEnv && !isTempRoot) {
+        void (async () => {
+            try {
+                await upsertProject({ slug: projectSlug, path: opts.projectRoot });
+                await setActive(projectSlug);
+            }
+            catch { /* registry is best-effort */ }
+        })();
+    }
     async function reanchor(newRoot) {
         const abs = (await import('node:path')).resolve(newRoot);
         const { enqueuePanelDispatch } = await import('./panel_queue.js');
@@ -193,6 +250,12 @@ export async function startChatServer(opts) {
         session.projectName = await readProjectName(abs);
         const { resolveProjectSlug } = await import('./project_slug.js');
         session.projectSlug = await resolveProjectSlug(abs);
+        /* keep the registry in sync after a hot switch (task #33) */
+        try {
+            await upsertProject({ slug: session.projectSlug, path: abs });
+            await setActive(session.projectSlug);
+        }
+        catch { /* best-effort */ }
         chatLog('Cambiando al proyecto ' + session.projectName + ' (' + abs + ')...');
         /* re-hidratar ingest + reiniciar el watcher sobre el nuevo dir */
         try {
@@ -220,6 +283,16 @@ export async function startChatServer(opts) {
             console.error('[reanchor] active project -> ' + abs + ' (slug=' + session.projectSlug + ')');
         }
         catch { /* */ }
+        /* Mobile project bubble (Pablo 2026-06-15) -- a project switch is a
+         * CONTROL command (no chat turn), and the board snapshot the phone
+         * reads `activeProject` from is only published on a chat turn. So
+         * republish it NOW with the new project, otherwise the phone's bubble
+         * stays on the old project after a switch (from either side). */
+        try {
+            setRelayBoardCtx(abs, session.projectSlug);
+            publishBoardSnapshot();
+        }
+        catch { /* best-effort */ }
         /* Regenerar el grafo del nuevo proyecto (crea los objetos si no
          * existen) en BACKGROUND -- no bloquear la respuesta HTTP del
          * verbo (sino el panel-invoke del subproceso da timeout =
@@ -267,9 +340,10 @@ export async function startChatServer(opts) {
                 voice,
                 store,
                 runtime: opts.runtime,
-                chatProvider: opts.chatProvider,
+                chatProvider: activeChatProvider,
                 panelPushToken,
                 reanchor,
+                setBrainProvider,
             });
         }
         catch (err) {
@@ -293,6 +367,45 @@ export async function startChatServer(opts) {
         server.once('error', reject);
         server.listen(opts.port, '127.0.0.1', () => resolve());
     });
+    /* P2 Fase 2 -- start the relay command consumer once we are listening
+     * (it loops back to /api/chat on this port). Gated YF_RELAY=1. */
+    let commandConsumerHandle = null;
+    if (relayEnabled()) {
+        try {
+            commandConsumerHandle = startDesktopCommandConsumer(opts.port);
+        }
+        catch {
+            commandConsumerHandle = null;
+        }
+    }
+    /* PND-007 -- Task Supervisor: reconcile persisted tasks on boot, and
+     * report completions back to the user (panel SSE + the paired phone via
+     * the relay). This is the "the SERVER tells you when it's done" that
+     * replaces the impossible in-turn watcher. */
+    try {
+        const { getTaskSupervisor, setTaskReporter } = await import('../tasks/supervisor.js');
+        setTaskReporter((rec) => {
+            /* relay to the phone (best-effort) */
+            try {
+                const pub = getRelayPublisher();
+                if (pub) {
+                    const verb = rec.status === 'done' ? 'termino'
+                        : rec.status === 'failed' ? 'fallo' : rec.status;
+                    pub.activity('Tarea ' + verb + ': ' + rec.label, { task_id: rec.id, status: rec.status, exit_code: rec.exit_code ?? null });
+                    pub.status('task_' + rec.status, { task_id: rec.id, label: rec.label });
+                    void pub.flush();
+                }
+            }
+            catch { /* noop */ }
+            /* nudge the panel (it polls /api/forge/task; this is a log marker) */
+            try {
+                console.error('[task] ' + rec.id + ' ' + rec.status + ' (' + rec.label + ')');
+            }
+            catch { /* noop */ }
+        });
+        getTaskSupervisor(projectSlug); /* triggers init()+reconcile() */
+    }
+    catch { /* supervisor optional */ }
     const url = 'http://127.0.0.1:' + opts.port + '/';
     return {
         server,
@@ -304,6 +417,13 @@ export async function startChatServer(opts) {
             if (componentWatcherHandle) {
                 Promise.resolve(componentWatcherHandle.stop()).catch(() => undefined);
             }
+            /* P2 Fase 2 -- stop the relay command consumer. */
+            if (commandConsumerHandle) {
+                try {
+                    commandConsumerHandle.stop();
+                }
+                catch { /* noop */ }
+            }
             /* alpha.59z.136 slice 14 -- flush in-flight ingest session
              * writes BEFORE the server closes so test teardowns that
              * fs.rm the home directory immediately after do not race
@@ -320,8 +440,373 @@ export async function startChatServer(opts) {
         }),
     };
 }
+/* P2 (mobile remote control) -- the desktop mirrors its Coding-feed
+ * activity to the worker relay so a paired phone can watch the work.
+ * OFF by default; opt in with env YF_RELAY=1 (the worker must exist).
+ * Best-effort: the publisher swallows every error, so an unreachable
+ * relay never affects a chat turn. */
+function relayEnabled() {
+    const v = process.env.YF_RELAY;
+    return v === '1' || v === 'true' || v === 'yes';
+}
+let _relayPub = null;
+function getRelayPublisher() {
+    if (!relayEnabled())
+        return null;
+    if (!_relayPub) {
+        _relayPub = new RelayPublisher({
+            deps: { deviceId: 'desktop-' + process.pid }, /* default auth = vault + license */
+            enabled: relayEnabled,
+        });
+    }
+    return _relayPub;
+}
+/* P2 Fase 2 -- desktop command consumer. Polls the worker relay for the
+ * paired phone's chat commands, runs each through THIS server's own
+ * /api/chat (loopback, so the full BYOK brain + project context apply),
+ * and publishes the reply back as chat_reply. Gated YF_RELAY=1. */
+function startDesktopCommandConsumer(port) {
+    const deviceId = 'desktop-' + process.pid;
+    const pollCommands = async (since) => {
+        const r = await relayPoll({ deviceId }, since, ['command']);
+        return {
+            ok: r.ok !== false,
+            events: (r.events ?? []).map((e) => ({
+                seq: e.seq,
+                payload: (e.payload ?? {}),
+                ts: e.ts,
+            })),
+            cursor: typeof r.cursor === 'number' ? r.cursor : since,
+        };
+    };
+    const reply = (commandId, text, done) => {
+        const pub = getRelayPublisher();
+        if (!pub)
+            return;
+        pub.chatReply(commandId, text, done);
+        void pub.flush(); /* push the reply promptly, do not wait the window */
+    };
+    const runTurn = async (text, sessionId) => {
+        const resp = await fetch('http://127.0.0.1:' + port + '/api/chat', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                messages: [{ role: 'user', content: text }],
+                ...(sessionId ? { session_id: sessionId } : {}),
+                /* UI sync (task #32) -- tag relay turns so handleChat can echo
+                 * the unified-thread ones to the panel (the laptop sees what was
+                 * asked from the phone). */
+                origin: 'mobile',
+            }),
+        });
+        const j = await resp.json();
+        if (!j || j.ok === false)
+            throw new Error(j?.error || 'turn failed');
+        return String(j.message?.text ?? '');
+    };
+    const onControl = async (action, args) => {
+        /* Control commands from the phone (tasks #33, #29) go through the
+         * same loopback the chat turns use -- no extra coupling. */
+        if (action === 'switch_project') {
+            const slug = typeof args.slug === 'string' ? args.slug : '';
+            if (!slug)
+                return 'Falta el slug del proyecto.';
+            const sid = typeof args.session_id === 'string' ? args.session_id : '';
+            /* Resolve the target path up front so we can ALWAYS re-point the
+             * phone's mirrored board at the new project (Pablo 2026-06-16: the
+             * board/bubble were staying on the old project because the switch
+             * moved the session/registry but did not always update the relay
+             * board ctx). */
+            const { readRegistry } = await import('../core/projects.js');
+            const reg = await readRegistry();
+            const entry = reg.projects.find((p) => p.slug === slug);
+            if (!entry || !entry.path)
+                return 'Proyecto no encontrado: ' + slug;
+            /* The phone mirrors ONE board; whichever project the phone switches
+             * to (own session OR notebook) is what its Pizarron + bubble must
+             * show. Re-point + republish directly, independent of reanchor. */
+            const followBoard = () => {
+                try {
+                    setRelayBoardCtx(entry.path, slug);
+                    publishBoardSnapshot();
+                }
+                catch { /* best-effort */ }
+            };
+            /* Per-session switch (Pablo 2026-06-15): a "Sesion Propia" points
+             * its OWN turns at this project WITHOUT moving the desktop's global
+             * project. Default/notebook session -> the global hot reanchor. */
+            if (sid && sid !== DEFAULT_SESSION_ID) {
+                setSessionProject(sid, entry.path, slug);
+                try {
+                    const pub = getRelayPublisher();
+                    if (pub) {
+                        pub.sessionProject(sid, slug);
+                        void pub.flush();
+                    }
+                }
+                catch { /* */ }
+                followBoard();
+                return 'Sesion propia -> ' + slug;
+            }
+            const resp = await fetch('http://127.0.0.1:' + port + '/api/forge/projects/active', {
+                method: 'POST', headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ slug }),
+            });
+            const j = await resp.json();
+            if (!j || j.ok === false)
+                throw new Error(j?.error || 'switch failed');
+            followBoard();
+            return 'Proyecto activo: ' + (j.active || slug)
+                + (j.reanchored === false ? ' (reinicia para aplicar)' : '');
+        }
+        if (action === 'interrupt') {
+            const resp = await fetch('http://127.0.0.1:' + port + '/api/chat/interrupt', { method: 'POST' });
+            const j = await resp.json().catch(() => ({}));
+            return j && j.active ? 'Turno interrumpido.' : 'No habia ningun turno en curso.';
+        }
+        return 'Accion no soportada: ' + action;
+    };
+    /* Two consumers over the same stream (task #29): the CHAT consumer
+     * runs turns (and is blocked while a turn is in flight); the fast
+     * CONTROL consumer handles interrupt/switch_project independently, so
+     * a phone interrupt lands MID-TURN instead of waiting for it to end.
+     * Each filters to its own subset; the other still advances its cursor
+     * past the skipped events. */
+    const chat = startCommandConsumer({
+        enabled: relayEnabled, intervalMs: 3000,
+        accept: (c) => !c.control,
+        pollCommands, runTurn, reply,
+        onError: () => { },
+    });
+    const control = startCommandConsumer({
+        enabled: relayEnabled, intervalMs: 1200,
+        accept: (c) => !!c.control,
+        pollCommands, runTurn, onControl, reply,
+        onError: () => { },
+    });
+    return {
+        stop() { chat.stop(); control.stop(); },
+        tickOnce: async () => { await chat.tickOnce(); await control.tickOnce(); },
+    };
+}
+/* Project context for board snapshots, set per chat turn (handleChat). */
+let _relayBoardCtx = null;
+function setRelayBoardCtx(projectRoot, slug) {
+    _relayBoardCtx = { projectRoot, slug };
+}
+const _recentDocs = [];
+function pushRecentDoc(title, kind, content) {
+    _recentDocs.push({
+        title: String(title || 'documento').slice(0, 120),
+        kind: String(kind || 'doc'),
+        content: String(content || '').slice(0, 40000),
+        ts: new Date().toISOString(),
+    });
+    while (_recentDocs.length > 12)
+        _recentDocs.shift();
+}
+/* Publish a compact board snapshot (workflow + pendings + recent docs)
+ * for the phone's Pizarron tab. Fire-and-forget; best-effort. */
+function publishBoardSnapshot() {
+    const pub = getRelayPublisher();
+    if (!pub || !_relayBoardCtx)
+        return;
+    const cx = _relayBoardCtx;
+    void (async () => {
+        try {
+            const { buildBoardSnapshot } = await import('../relay/board_snapshot.js');
+            const snap = await buildBoardSnapshot(cx.projectRoot, cx.slug);
+            /* newest doc first */
+            snap.docs = _recentDocs.slice().reverse();
+            /* i18n (task #34) -- stamp the desktop's active language so the
+             * paired phone inherits it (the mobile UI has no language picker;
+             * it follows the notebook). One of the 10 canonical tags. */
+            try {
+                const { currentLanguage } = await import('../i18n/index.js');
+                snap.lang = currentLanguage();
+            }
+            catch { /* leave unset -> mobile keeps its fallback */ }
+            /* Project selector (task #33) -- relay the known projects + the
+             * active slug so the phone can switch the desktop's project (a
+             * control command flows back through the consumer). Compact: slug
+             * + name + path, capped. */
+            try {
+                const reg = await readRegistry();
+                snap.projects = (reg.projects || []).slice(0, 30).map((p) => ({
+                    slug: p.slug, path: p.path || '',
+                }));
+                snap.activeProject = reg.active_slug || cx.slug || null;
+            }
+            catch { /* leave unset */ }
+            pub.board(snap);
+            /* PND-094 ext -- publish the semantic graph as its OWN event so it
+             * is not capped by the board's 32KB budget. */
+            try {
+                const { buildGraphSnapshot } = await import('../relay/board_snapshot.js');
+                const g = cx.slug ? await buildGraphSnapshot(cx.slug) : null;
+                if (g)
+                    pub.graph(g);
+            }
+            catch { /* no graph -> skip */ }
+            void pub.flush();
+        }
+        catch { /* best-effort */ }
+    })();
+}
+/* PND-007 -- Task Supervisor HTTP surface for the panel Tareas tab.
+ * GET /api/forge/task -> list; POST /api/forge/task -> run. */
+async function handleForgeTask(req, res, ctx, _url) {
+    const { getTaskSupervisor } = await import('../tasks/supervisor.js');
+    const sup = getTaskSupervisor(ctx.projectSlug ?? null);
+    if (req.method === 'GET') {
+        sendJson(res, 200, { ok: true, tasks: sup.list() });
+        return;
+    }
+    if (req.method === 'POST') {
+        let body;
+        try {
+            body = JSON.parse(await readBody(req));
+        }
+        catch {
+            sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+            return;
+        }
+        if (typeof body.cmd !== 'string' || !body.cmd) {
+            sendJson(res, 400, { ok: false, error: 'cmd (string) required' });
+            return;
+        }
+        const rec = await sup.run({
+            cmd: body.cmd,
+            args: Array.isArray(body.args) ? body.args.map(String) : [],
+            cwd: typeof body.cwd === 'string' && body.cwd ? body.cwd : ctx.projectRoot,
+            label: typeof body.label === 'string' ? body.label : undefined,
+        });
+        sendJson(res, 200, { ok: rec.status !== 'failed', task: rec });
+        return;
+    }
+    sendJson(res, 405, { ok: false, error: 'method not allowed' });
+}
+async function handleForgeTaskLog(_req, res, ctx, url) {
+    const { getTaskSupervisor } = await import('../tasks/supervisor.js');
+    const sup = getTaskSupervisor(ctx.projectSlug ?? null);
+    const id = url.searchParams.get('id') ?? '';
+    const lines = Number.parseInt(url.searchParams.get('lines') ?? '60', 10) || 60;
+    if (!sup.get(id)) {
+        sendJson(res, 404, { ok: false, error: 'unknown task id' });
+        return;
+    }
+    const tail = await sup.tailLog(id, Math.min(lines, 500));
+    sendJson(res, 200, { ok: true, id, tail });
+}
+async function handleForgeTaskKill(req, res, ctx) {
+    const { getTaskSupervisor } = await import('../tasks/supervisor.js');
+    const sup = getTaskSupervisor(ctx.projectSlug ?? null);
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+        return;
+    }
+    const id = typeof body.id === 'string' ? body.id : '';
+    const killed = sup.kill(id);
+    sendJson(res, killed ? 200 : 404, { ok: killed, id });
+}
+async function handleForgeTaskDelete(req, res, ctx) {
+    const { getTaskSupervisor } = await import('../tasks/supervisor.js');
+    const sup = getTaskSupervisor(ctx.projectSlug ?? null);
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+        return;
+    }
+    const id = typeof body.id === 'string' ? body.id : '';
+    const removed = await sup.remove(id);
+    sendJson(res, removed ? 200 : 404, { ok: removed, id });
+}
+function relayForward(event, data) {
+    const pub = getRelayPublisher();
+    if (!pub)
+        return;
+    try {
+        const d = (data && typeof data === 'object') ? data : {};
+        if (event === 'tool_round_start') {
+            pub.activity(String(d.summary || d.verb_hint || d.verb_id || 'trabajando'), d.detail);
+        }
+        else if (event === 'turn_start') {
+            pub.status('working', { tier: d.tier, provider: d.provider, model: d.model });
+        }
+        else if (event === 'turn_complete') {
+            pub.status('round_done');
+            /* refresh the phone's board after each turn (workflow/pendings may
+             * have changed). */
+            publishBoardSnapshot();
+        }
+        else if (event === 'error') {
+            pub.status('error', { message: d.message ?? d.error ?? '' });
+        }
+    }
+    catch { /* relay best-effort */ }
+}
+/* PND-045 (sec 1.1) -- CSRF / DNS-rebinding defense for the local
+ * panel server. Even bound to 127.0.0.1, the server is reachable
+ * from any web page the dev visits (a "simple" text/plain fetch
+ * needs no CORS preflight, and DNS rebinding sidesteps guessing the
+ * port). Two checks, applied to every state-mutating request:
+ *   - Host: must name a loopback host. A rebound DNS name arrives as
+ *     Host: attacker.com, so rejecting foreign Host kills rebinding.
+ *   - Origin: when present (browsers always send it on cross-origin
+ *     POST, including text/plain), it must be a loopback origin. The
+ *     panel's own requests carry Origin http://127.0.0.1:<port>, so
+ *     legitimate traffic passes; non-browser clients (tests, relay)
+ *     send no Origin and are unaffected. No feature is lost. */
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '[::1]']);
+function hostnameOf(hostHeader) {
+    const h = hostHeader.trim().toLowerCase();
+    if (!h)
+        return '';
+    if (h.startsWith('[')) {
+        const i = h.indexOf(']');
+        return i >= 0 ? h.slice(0, i + 1) : h;
+    }
+    const c = h.indexOf(':');
+    return c >= 0 ? h.slice(0, c) : h;
+}
+function isLocalMutatingRequestOk(req) {
+    const host = hostnameOf(String(req.headers.host ?? ''));
+    if (host && !LOOPBACK_HOSTS.has(host)) {
+        return { ok: false, reason: 'Host no-loopback rechazado (posible DNS-rebinding): ' + host.slice(0, 60) };
+    }
+    const origin = req.headers.origin;
+    if (typeof origin === 'string' && origin && origin.toLowerCase() !== 'null') {
+        let oh;
+        try {
+            oh = new URL(origin).hostname.toLowerCase();
+        }
+        catch {
+            return { ok: false, reason: 'Origin malformado' };
+        }
+        const normalized = oh.startsWith('[') ? oh : oh; /* URL.hostname already strips ipv6 brackets to bare ::1 on Node */
+        if (!LOOPBACK_HOSTS.has(normalized) && !LOOPBACK_HOSTS.has('[' + normalized + ']')) {
+            return { ok: false, reason: 'Origin cross-site rechazado (CSRF): ' + origin.slice(0, 80) };
+        }
+    }
+    return { ok: true };
+}
+const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 async function route(req, res, ctx) {
     const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+    if (MUTATING_METHODS.has(req.method ?? '')) {
+        const guard = isLocalMutatingRequestOk(req);
+        if (!guard.ok) {
+            sendJson(res, 403, { ok: false, error: 'forbidden', reason: guard.reason });
+            return;
+        }
+    }
     if (req.method === 'GET' && url.pathname === '/') {
         // Stateless lang resolution: query string > cookie >
         // server-wide setLanguage. This isolates per-request
@@ -419,6 +904,17 @@ async function route(req, res, ctx) {
         await handleChat(req, res, ctx);
         return;
     }
+    /* Interrupt (task #27) -- stop the in-flight turn. The panel's
+     * "Detener" button (and the mobile control path) POST here; we
+     * abort the active turn's signal so the caller unwinds (claude.ts
+     * breaks at the next round boundary; claude_cli kills `claude -p`).
+     * Idempotent: returns active:false when nothing is running. */
+    if (req.method === 'POST' && url.pathname === '/api/chat/interrupt') {
+        const wasActive = isTurnActive();
+        const r = interruptActiveTurn();
+        sendJson(res, 200, { ok: true, active: wasActive, interrupted: r.ok, turn_id: r.id });
+        return;
+    }
     /* Vault surface (V0.4 of HITO 0). Same-origin: the server only
        listens on 127.0.0.1 and the browser blocks cross-origin
        fetches from other sites by default (no CORS headers set).
@@ -996,7 +1492,7 @@ async function route(req, res, ctx) {
         return;
     }
     if (req.method === 'POST' && url.pathname === '/api/forge/projects/active') {
-        await handleProjectsSwitch(req, res);
+        await handleProjectsSwitch(req, res, ctx);
         return;
     }
     if (req.method === 'GET' && url.pathname === '/api/forge/projects/active') {
@@ -1087,7 +1583,7 @@ async function route(req, res, ctx) {
         return;
     }
     if (req.method === 'POST' && url.pathname === '/api/forge/brain-config') {
-        await handleBrainConfigSet(req, res);
+        await handleBrainConfigSet(req, res, ctx);
         return;
     }
     /* PND-069 -- modelos disponibles por provider (API en vivo con
@@ -1109,6 +1605,23 @@ async function route(req, res, ctx) {
         await handlePanelQueue(req, res, url);
         return;
     }
+    /* PND-007 -- Task Supervisor: the panel Tareas tab polls + acts here. */
+    if (url.pathname === '/api/forge/task') {
+        await handleForgeTask(req, res, ctx, url);
+        return;
+    }
+    if (req.method === 'GET' && url.pathname === '/api/forge/task/log') {
+        await handleForgeTaskLog(req, res, ctx, url);
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/task/kill') {
+        await handleForgeTaskKill(req, res, ctx);
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/task/delete') {
+        await handleForgeTaskDelete(req, res, ctx);
+        return;
+    }
     /* GRAPH-1 -- regenerar el grafo semantico (nodos + aristas
        derivadas de imports). El boton Refresh del panel lo llama. */
     if (req.method === 'POST' && url.pathname === '/api/forge/graph-regenerate') {
@@ -2059,10 +2572,35 @@ async function handleVoiceTts(req, res, ctx) {
  * ============================================================ */
 /** Check that `target` is inside `root` (after resolving both).
  *  Refuses path traversal like ../../../etc/passwd. */
+function realpathOrSelf(p) {
+    try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return p;
+    }
+}
+/* PND-045 (sec 1.7) -- containment check that also defeats symlink
+ * escapes. path.resolve does NOT follow symlinks, so a symlink that
+ * lives INSIDE the root but points OUTSIDE would pass a naive
+ * startsWith. We realpath both the root and the deepest EXISTING
+ * ancestor of the target (the target itself may not exist yet on a
+ * write), then re-append the not-yet-existing tail before comparing. */
 function isInside(target, root) {
-    const targetAbs = path.resolve(target);
-    const rootAbs = path.resolve(root) + path.sep;
-    return targetAbs === path.resolve(root) || targetAbs.startsWith(rootAbs);
+    const rootReal = realpathOrSelf(path.resolve(root));
+    let existing = path.resolve(target);
+    const tail = [];
+    while (!existsSync(existing)) {
+        const parent = path.dirname(existing);
+        if (parent === existing)
+            break; /* reached fs root */
+        tail.unshift(path.basename(existing));
+        existing = parent;
+    }
+    const realBase = realpathOrSelf(existing);
+    const targetReal = tail.length ? path.join(realBase, ...tail) : realBase;
+    const rootWithSep = rootReal + path.sep;
+    return targetReal === rootReal || targetReal.startsWith(rootWithSep);
 }
 /** Editor commands tried in order. First match wins. The args
  *  templates are joined with the file path at runtime. All
@@ -2271,7 +2809,7 @@ async function handleBrainConfigGet(_req, res, ctx) {
  *  campos; valida y persiste. anthropic_mode requiere reabrir el
  *  panel para tomar efecto (el brain client se construye al boot);
  *  eco_enabled y los bindings aplican en el proximo turno. */
-async function handleBrainConfigSet(req, res) {
+async function handleBrainConfigSet(req, res, ctx) {
     const { readBrainConfig, writeBrainConfig, ALL_BRAIN_PROVIDERS, } = await import('../core/brain_config.js');
     let body;
     try {
@@ -2307,7 +2845,21 @@ async function handleBrainConfigSet(req, res) {
             cfg[tier].model = model;
     }
     await writeBrainConfig(cfg);
-    sendJson(res, 200, { ok: true, config: cfg, restart_needed_for: ['anthropic_mode'] });
+    /* Apply the brain mode LIVE: hot-swap the provider so flipping
+     * Plan/Console takes effect on the very next turn -- no panel restart.
+     * (Fixes "clickeo Plan pero me dice que no tengo tokens de Console".) */
+    let applied_live = false;
+    if ((body.anthropic_mode === 'plan' || body.anthropic_mode === 'console') && ctx.setBrainProvider) {
+        try {
+            applied_live = await ctx.setBrainProvider(body.anthropic_mode);
+        }
+        catch { /* leave applied_live false -> client shows the restart hint */ }
+    }
+    sendJson(res, 200, {
+        ok: true, config: cfg, applied_live,
+        /* nothing needs a restart when the swap applied live */
+        restart_needed_for: applied_live ? [] : ['anthropic_mode'],
+    });
 }
 /** PND-064 -- POST /api/forge/panel-invoke. Paridad total de tools
  *  en modo Plan: el MCP server local reenvia aca cada nac3_invoke
@@ -2367,6 +2919,16 @@ async function handlePanelInvoke(req, res, ctx) {
         const shortVerb = String(verb.id || '').replace(/^yujin\./, '');
         const { enqueuePanelDispatch } = await import('./panel_queue.js');
         const seq = enqueuePanelDispatch(shortVerb, payload ? { ...dispatchArgs, server_payload: payload } : dispatchArgs, new Date().toISOString());
+        /* PND -- if it is a pizarron DOCUMENT, also relay it to the phone
+         * (its Pizarron tab has no native doc canvas). Folded into the next
+         * board snapshot. */
+        if (shortVerb === 'pizarron.create-tab') {
+            const k = String(dispatchArgs.kind || 'doc');
+            if (['doc', 'document', 'md', 'markdown', 'html', 'table'].includes(k)) {
+                pushRecentDoc(String(dispatchArgs.title || 'documento'), k, String(dispatchArgs.content || ''));
+                publishBoardSnapshot();
+            }
+        }
         sendJson(res, 200, {
             ok: true, seq, panel_dispatch: true,
             text: 'Listo: enviado al pizarron (' + shortVerb + ').',
@@ -2418,23 +2980,28 @@ async function handlePanelQueue(_req, res, url) {
 /** Mobile pairing QR -- genera el codigo + envelope cifrado y lo
  *  renderiza como QR SVG para que Forge Mobile lo escanee. El
  *  usuario solo tipea el codigo de 6 digitos en el telefono. El
- *  payload (que lleva el server_api_key) NUNCA sale por aca en
- *  claro: solo va el QR cifrado + el codigo (que el usuario ya ve
- *  en su propia pantalla). */
+ *  payload viaja DENTRO del QR (Option 3 -- code-less): el QR es
+ *  autocontenido, el usuario lo muestra en su propia pantalla y el
+ *  expires_at de 5 min acota un QR capturado. */
 async function handleMobilePair(_req, res) {
     try {
         const { assemblePairing } = await import('../commands/mobile.js');
         const built = await assemblePairing({});
-        if (!built.ok || !built.qr || !built.code) {
+        if (!built.ok || !built.qr) {
             sendJson(res, 200, { ok: false, error: built.error ?? 'no pude generar el pairing', hint: built.hint });
             return;
         }
         const QRCode = (await import('qrcode')).default;
+        /* PND-047 follow-up -- the pairing payload grew (the per-handle key is
+         * 64 hex chars + key_kind), pushing the QR from 97x97 to 105x105 modules
+         * at EC 'M', which made it hard to scan. EC 'L' brings it to 93x93 --
+         * LESS dense than the old easy-to-scan QR. The envelope is short-lived
+         * (5-min TTL) so the lighter error correction is fine for a screen scan. */
         const qrSvg = await QRCode.toString(built.qr, {
-            type: 'svg', margin: 1, errorCorrectionLevel: 'M',
-            color: { dark: '#1a1a1a', light: '#f5f0e6' },
+            type: 'svg', margin: 1, errorCorrectionLevel: 'L',
+            color: { dark: '#1a1a1a', light: '#ffffff' },
         });
-        sendJson(res, 200, { ok: true, code: built.code, expires_at: built.expires_at, qr_svg: qrSvg });
+        sendJson(res, 200, { ok: true, expires_at: built.expires_at, qr_svg: qrSvg });
     }
     catch (err) {
         sendJson(res, 200, { ok: false, error: err instanceof Error ? err.message : String(err) });
@@ -2465,25 +3032,30 @@ async function handleStartupTabs(_req, res, ctx, url) {
     /* 1 + 2: grafo (grafico + semantico). */
     try {
         const { listRelevant, listAllEdges } = await import('../semantic_graph/store.js');
-        /* Vista arquitectonica: los nodos derivados module.* y lib.*
-         * (no los comp.* de export fino del watcher, que tienen kind
-         * 'module' pero saturan el grafo). Filtro por prefijo de id. */
+        /* El grafo muestra TODO el conocimiento del proyecto: nodos
+         * arquitectonicos (module./lib. prefijo) + los declarados en chat
+         * (dominio, confidence 'claimed'). Solo se excluyen los comp. de
+         * export fino del watcher, que saturan. Antes el filtro era por
+         * prefijo module./lib., lo que ocultaba TODO lo declarado en chat
+         * (el 87% del conocimiento real -- PND graph). Los 'claimed' van
+         * atenuados + punteados via la confidence que pasamos al renderer. */
         const allNodes = slug ? await listRelevant(slug, { limit: 100000, min_confidence: 'claimed' }) : [];
-        const nodes = allNodes.filter((n) => n.id.startsWith('module.') || n.id.startsWith('lib.'));
+        const nodes = allNodes.filter((n) => !n.id.startsWith('comp.'));
         const allEdges = slug ? await listAllEdges(slug) : [];
         const nodeIdSet = new Set(nodes.map((n) => n.id));
         const edges = allEdges.filter((e) => nodeIdSet.has(e.from_id) && nodeIdSet.has(e.to_id));
-        const gNodes = nodes.map((n) => ({ id: n.id, label: n.name || n.id, weight: n.weight, kind: n.kind, detail: n.purpose || '' }));
+        const gNodes = nodes.map((n) => ({ id: n.id, label: n.name || n.id, weight: n.weight, kind: n.kind, confidence: n.confidence, detail: n.purpose || '' }));
         const gEdges = edges.map((e) => ({ from: e.from_id, to: e.to_id, kind: e.kind }));
         tabs.push({ key: 'startup_graph', title: t('startup.tab.graph'), kind: 'graph', content: JSON.stringify({ nodes: gNodes, edges: gEdges }) });
         /* Grafo semantico = misma data en markdown (tabla de nodos por
-         * peso + conteo de aristas). */
-        const top = [...nodes].sort((a, b) => (b.weight || 0) - (a.weight || 0)).slice(0, 40);
+         * peso + conteo de aristas), con la confianza para distinguir lo
+         * declarado (claimed) de lo derivado del codigo (auto). */
+        const top = [...nodes].sort((a, b) => (b.weight || 0) - (a.weight || 0)).slice(0, 60);
         let md = '# ' + t('startup.tab.graphSem') + ' -- ' + (slug || 'proyecto') + '\n\n'
             + nodes.length + ' ' + t('graph.term.nodes') + ', ' + edges.length + ' ' + t('graph.term.edges') + '.\n\n'
-            + '| ' + t('startup.tab.graphSem') + ' | | ' + t('pizarron.graph.detail.weight') + ' |\n|---|---|---|\n';
+            + '| ' + t('startup.tab.graphSem') + ' | | conf | ' + t('pizarron.graph.detail.weight') + ' |\n|---|---|---|---|\n';
         for (const n of top)
-            md += '| ' + (n.name || n.id) + ' | ' + n.kind + ' | ' + (Math.round((n.weight || 0) * 100) / 100) + ' |\n';
+            md += '| ' + (n.name || n.id) + ' | ' + n.kind + ' | ' + n.confidence + ' | ' + (Math.round((n.weight || 0) * 100) / 100) + ' |\n';
         tabs.push({ key: 'startup_graph_sem', title: t('startup.tab.graphSem'), kind: 'md', content: md });
     }
     catch { /* sin grafo */ }
@@ -2510,15 +3082,31 @@ async function handleStartupTabs(_req, res, ctx, url) {
     try {
         /* PND-094 -- vista jerarquica de FASES + tareas (no grafo): cada
          * fase con su avance + sus tareas debajo con su estado. */
-        const { readWorkflow } = await import('../workflow/state.js');
-        const { computeWorkflowView } = await import('../workflow/view.js');
-        const wf = await readWorkflow(ctx.projectRoot);
-        const view = computeWorkflowView(wf);
-        tabs.push({ key: 'startup_workflow', title: t('startup.tab.workflow'), kind: 'workflow', content: JSON.stringify(view) });
+        /* PND-094 ext -- multi-workflow: the coexisting WorkflowInstances
+         * with their tasks (pendings) grouped by stage. Falls back to the
+         * legacy single-workflow view when there are no instances yet. */
+        const { computeWorkflowsView } = await import('../workflow/multi_view.js');
+        const cards = await computeWorkflowsView(ctx.projectSlug ?? '', 'open');
+        if (cards.length > 0) {
+            tabs.push({ key: 'startup_workflow', title: t('startup.tab.workflow'), kind: 'workflow', content: JSON.stringify({ workflows: cards }) });
+        }
+        else {
+            const { readWorkflow } = await import('../workflow/state.js');
+            const { computeWorkflowView } = await import('../workflow/view.js');
+            const view = computeWorkflowView(await readWorkflow(ctx.projectRoot));
+            tabs.push({ key: 'startup_workflow', title: t('startup.tab.workflow'), kind: 'workflow', content: JSON.stringify(view) });
+        }
     }
     catch {
         tabs.push({ key: 'startup_workflow', title: t('startup.tab.workflow'), kind: 'md', content: '# Workflow\n\nSin datos.\n' });
     }
+    /* 5: PND-007 -- Tareas de fondo (se llena en vivo client-side). */
+    tabs.push({
+        key: 'startup_tasks',
+        title: lang === 'en' ? 'Tasks' : 'Tareas',
+        kind: 'tasks',
+        content: '',
+    });
     sendJson(res, 200, { ok: true, enabled: true, tabs });
 }
 /** Formato de id de pending para display (PND-NNN). */
@@ -2998,7 +3586,7 @@ async function handleProjectsActive(res) {
     const entry = slug ? reg.projects.find((p) => p.slug === slug) : null;
     sendJson(res, 200, { ok: true, active: slug, project: entry ?? null });
 }
-async function handleProjectsSwitch(req, res) {
+async function handleProjectsSwitch(req, res, ctx) {
     let body;
     try {
         body = JSON.parse(await readBody(req));
@@ -3013,7 +3601,20 @@ async function handleProjectsSwitch(req, res) {
     }
     try {
         const reg = await setActive(body.slug);
-        sendJson(res, 200, { ok: true, active: reg.active_slug, registry: reg });
+        /* Task #33 -- a switch must HOT-reanchor the live session, not just
+         * persist active_slug (otherwise the running server keeps serving
+         * the old project until restart). Look up the entry's path + call
+         * ctx.reanchor so the panel + pizarron + graph follow immediately. */
+        let reanchored = false;
+        const entry = reg.projects.find((p) => p.slug === body.slug);
+        if (entry && entry.path && ctx.reanchor) {
+            try {
+                await ctx.reanchor(entry.path);
+                reanchored = true;
+            }
+            catch { /* reanchor failed -> active_slug still persisted */ }
+        }
+        sendJson(res, 200, { ok: true, active: reg.active_slug, reanchored, registry: reg });
     }
     catch (err) {
         sendJson(res, 404, { ok: false,
@@ -3175,6 +3776,9 @@ async function handleVaultHas(res, slot) {
     }
 }
 async function handleChat(req, res, ctx) {
+    /* P2 -- remember the project context so turn_complete can publish a
+     * board snapshot to the paired phone's Pizarron tab. */
+    setRelayBoardCtx(ctx.projectRoot, ctx.projectSlug ?? null);
     const raw = await readBody(req);
     let body;
     try {
@@ -3189,6 +3793,81 @@ async function handleChat(req, res, ctx) {
         sendJson(res, 400, { ok: false, error: 'messages[] required' });
         return;
     }
+    /* Multisession: the conversation THREAD this turn belongs to. The
+     * default ('desktop-main', what the panel uses) reuses the server's
+     * main store; a mobile "Sesion propia" passes its own id for an
+     * independent parallel thread. Everything below reads/writes
+     * `sessionStore` instead of `ctx.store`. */
+    const sessionId = typeof body.session_id === 'string' && body.session_id
+        ? body.session_id : DEFAULT_SESSION_ID;
+    /* The transcript THREAD is keyed off the GLOBAL project root (a stable
+     * single thread per session), resolved BEFORE any per-session project
+     * override so switching the session's project does not fork the chat. */
+    const sessionStore = getSessionStore(sessionId, ctx.store, ctx.projectRoot, VERSION);
+    /* Per-session project (Pablo 2026-06-15) -- a "Sesion Propia"
+     * (non-default session) can point at its OWN project without moving the
+     * desktop's global project. Reassign ctx to a turn-local view pointed at
+     * the override so EVERY downstream ctx.projectRoot/projectSlug use
+     * (prompt context, graph, tooling, tool cwd) follows it. The default
+     * 'notebook' session has no override -> unchanged global behavior. The
+     * global board snapshot (set above, before this) stays on the desktop's
+     * project; the phone tracks its own-session project locally. */
+    const _sessProj = getSessionProject(sessionId);
+    if (_sessProj) {
+        ctx = { ...ctx, projectRoot: _sessProj.root, projectSlug: _sessProj.slug };
+    }
+    /* Project-switch verb routing (Pablo 2026-06-15) -- when the model
+     * calls yujin.project.set-root in a NON-default session, switch only
+     * THAT session's project (per-session override), NOT the global
+     * desktop. The default 'notebook' session uses the global hot reanchor
+     * (which also moves the desktop + republishes the board). */
+    const effReanchor = sessionId !== DEFAULT_SESSION_ID
+        ? async (newRoot) => {
+            const abs = (await import('node:path')).resolve(newRoot);
+            const { resolveProjectSlug } = await import('./project_slug.js');
+            const slug = await resolveProjectSlug(abs);
+            const name = await readProjectName(abs);
+            setSessionProject(sessionId, abs, slug);
+            /* tell the phone its session moved so the bubble follows (#2) */
+            try {
+                const pub = getRelayPublisher();
+                if (pub) {
+                    pub.sessionProject(sessionId, slug);
+                    void pub.flush();
+                }
+            }
+            catch { /* */ }
+            return { projectRoot: abs, projectName: name, projectSlug: slug };
+        }
+        : ctx.reanchor;
+    /* Diagnostic (Pablo 2026-06-15) -- tangible evidence of session
+     * routing for the mobile bugs. Records WHICH thread + origin each turn
+     * used, so we can SEE whether 'sesion propia' actually sent
+     * session_id='mobile' and whether the unified turn was tagged
+     * origin='mobile'. Fire-and-forget; ~/.yujin-forge/turn_routing.jsonl */
+    void (async () => {
+        try {
+            const { appendFile } = await import('node:fs/promises');
+            const pathMod = await import('node:path');
+            const home = process.env.YF_CONFIG_DIR
+                || pathMod.join(process.env.HOME || process.env.USERPROFILE || '', '.yujin-forge');
+            const row = JSON.stringify({
+                ts: new Date().toISOString(),
+                session_id: sessionId,
+                is_default: sessionId === DEFAULT_SESSION_ID,
+                origin: typeof body.origin === 'string' ? body.origin : 'panel',
+                project: ctx.projectSlug ?? null,
+            }) + '\n';
+            await appendFile(pathMod.join(home, 'turn_routing.jsonl'), row, 'utf-8');
+        }
+        catch { /* best-effort diagnostic */ }
+    })();
+    /* Interrupt (task #27): this turn registers itself in the single
+     * active-turn registry just before the model call so POST
+     * /api/chat/interrupt (or a mobile control event) can abort it
+     * mid-flight. Declared out here so the outer try's finally can
+     * clear it on every exit path. */
+    let turnId = null;
     /* alpha.59e -- SSE streaming mode. Client opts in via
      * body.stream=true. We keep the response open + emit events
      * during the tool loop instead of bundling everything in a
@@ -3209,6 +3888,9 @@ async function handleChat(req, res, ctx) {
                 res.write('data: ' + payload + '\n\n');
             }
             catch { /* ignore */ }
+            /* P2 Fase 1 -- ademas del panel, espejar la actividad al relay
+             * para el mobile pareado. Gateado (YF_RELAY=1) + best-effort. */
+            relayForward(event, data);
         };
     }
     /* alpha.51 -- session-level brain tier override from slash
@@ -3260,7 +3942,7 @@ async function handleChat(req, res, ctx) {
          * via the store (best-effort). The store keeps the last
          * assistant reply; if it has a `brain_tier` annotation we use
          * it. When absent, the gate just skips the sticky check. */
-        const recent = ctx.store.messages();
+        const recent = sessionStore.messages();
         const lastAssistant = recent.slice().reverse().find((m) => m.role === 'assistant');
         const previousTier = lastAssistant && (lastAssistant.brain_tier === 'eco' || lastAssistant.brain_tier === 'frontier')
             ? lastAssistant.brain_tier
@@ -3296,9 +3978,15 @@ async function handleChat(req, res, ctx) {
          * chose has zero remaining budget, return 429 BEFORE the
          * LLM call so the user never gets billed past their cap.
          * The panel modal (plan_limit_exceeded) lets them upgrade
-         * or switch tier. BYOK plans have Infinity cap so this
-         * is a no-op there. */
-        {
+         * or switch tier.
+         *
+         * BYOK-STRICT (Pablo 2026-06-15): Forge no tiene plan managed --
+         * cada turno BYOK lo paga el usuario directo al proveedor, asi que
+         * el cap mensual NO debe bloquear. Solo se aplica a turnos REALMENTE
+         * managed (provider 'yujin_managed'), que hoy no existen. Antes el
+         * gate corria por tier sin mirar el provider y bloqueaba a un BYOK
+         * con plan=pro_plus aunque tuviera saldo propio. */
+        if (brainSelection.provider === 'yujin_managed') {
             const { checkCap } = await import('../core/budget.js');
             const capCheck = await checkCap(brainSelection.tier);
             if (!capCheck.allowed) {
@@ -3467,6 +4155,18 @@ async function handleChat(req, res, ctx) {
                 wiringSection = '\n\n' + r.rendered_text;
         }
         catch (_) { /* swallow -- chat continues without wiring inject */ }
+        /* PROJECT TOOLING -- the discovered CI/CD + npm scripts + scripts/
+         * helpers, so the model uses the repo's real build/deploy chain
+         * instead of inventing commands. Generic per repo (graph 'tooling'
+         * nodes). Always present (not relevance-gated). */
+        let toolingSection = '';
+        try {
+            const { buildToolingSection } = await import('./tooling_section.js');
+            const r = await buildToolingSection(ctx.projectSlug || '');
+            if (r.rendered_text)
+                toolingSection = '\n\n' + r.rendered_text;
+        }
+        catch (_) { /* swallow -- chat continues without tooling inject */ }
         /* alpha.59z.187 PND-039 -- auto-context-load. Single compact
          * block with counts of graph nodes / wiring hooks / pending
          * items so the LLM can answer "que sabes del proyecto" / "subi
@@ -3517,8 +4217,46 @@ async function handleChat(req, res, ctx) {
             }
         }
         catch (_) { /* swallow */ }
+        /* Server-canonical conversation context. The turn is built from the
+         * SESSION store (the shared thread that accumulates BOTH desktop and
+         * mobile turns) + the new user message -- NOT from body.messages.
+         * Before, each client sent its own history (desktop = full browser
+         * history; the relay consumer = a single message), so desktop and
+         * mobile were two separate threads, blind to each other. Using the
+         * store as the source of truth unifies them into one conversation. */
+        const newUserMsg = normalized[normalized.length - 1];
+        let turnMessages;
+        if (newUserMsg && newUserMsg.role === 'user') {
+            const prior = sessionStore.messages();
+            const ptail = prior[prior.length - 1];
+            const alreadyThere = !!(ptail && ptail.role === 'user' && ptail.content === newUserMsg.content);
+            turnMessages = alreadyThere ? [...prior] : [...prior, newUserMsg];
+        }
+        else {
+            /* defensive: the last normalized message should always be the new
+             * user turn; fall back to the client view if not. */
+            turnMessages = normalized;
+        }
+        /* Register THIS turn as the active one right before the model
+         * call. beginTurn returns the AbortSignal the callers honor
+         * (claude.ts at round boundary, claude_cli kills the subprocess).
+         * A concurrent turn (desktop + mobile own-session) replaces the
+         * registry entry; interrupt then targets the latest -- acceptable
+         * until the queue (task #28) serializes turns. */
+        turnId = sessionId + ':' + String(Date.now());
+        const turnSignal = beginTurn(turnId);
         const chatRequest = {
-            messages: normalized,
+            messages: turnMessages,
+            signal: turnSignal,
+            /* Pablo 2026-06-15 -- the model MUST follow the brain config in
+             * BOTH paths. Console (unified client) already bakes it into the
+             * client; Plan (`claude -p`) reads it per turn -> without this the
+             * subprocess fell back to a default + ignored the user's eco/
+             * frontier model selection. claude_cli maps it to the CLI alias. */
+            model: brainSelection.model,
+            /* Plan mode: the `claude -p` subprocess must run in the ACTIVE
+             * project (follows a hot switch), not the launch cwd. (Pablo) */
+            cwd: ctx.projectRoot,
             /* alpha.59z.163 PND-027 -- system prompt now split into a
              * stable prefix (manifest, doctrines, design system, mode +
              * tier headers from buildSystemPrompt) and a dynamic suffix
@@ -3538,7 +4276,7 @@ async function handleChat(req, res, ctx) {
             ctx.chatProvider === 'claude-code-cli'
                 ? (ctx.panelPushToken ? 'mcp-bridge' : 'none')
                 : 'native'),
-            systemDynamic: projectContextSection + snapshotSection + graphSection + wiringSection + workflowSection,
+            systemDynamic: projectContextSection + snapshotSection + graphSection + wiringSection + toolingSection + workflowSection,
             maxTokens: 1024,
             tools: FORGE_TOOL_SPECS,
             runTool: async (name, input) => {
@@ -3607,7 +4345,8 @@ async function handleChat(req, res, ctx) {
                     projectRoot: ctx.projectRoot,
                     projectSlug: ctx.projectSlug,
                     ...(sseEmit ? { streamEmit: sseEmit } : {}),
-                    ...(ctx.reanchor ? { reanchor: ctx.reanchor } : {}),
+                    /* per-session reanchor for non-default sessions; global for notebook */
+                    ...(effReanchor ? { reanchor: effReanchor } : {}),
                 };
                 const r = await runForgeTool(name, input, toolCtx);
                 /* alpha.59i -- if the result is an approval envelope,
@@ -3652,7 +4391,8 @@ async function handleChat(req, res, ctx) {
          * frontier still has budget. Cap 1 escalation per turn. */
         let escalated = false;
         let escalationSignals = [];
-        if (brainSelection.tier === 'eco' && !brainOverride) {
+        if (brainSelection.tier === 'eco' && !brainOverride
+            && !reply.interrupted) {
             const { detectIncomplete } = await import('../core/incomplete_detector.js');
             const detect = detectIncomplete({
                 user_text: lastUserText,
@@ -3660,8 +4400,12 @@ async function handleChat(req, res, ctx) {
                 tool_rounds: reply.toolRounds,
             });
             if (detect.incomplete) {
-                const { checkCap } = await import('../core/budget.js');
-                const capCheck = await checkCap('frontier');
+                /* BYOK-strict: the frontier cap only gates MANAGED turns. A BYOK
+                 * eco turn escalates to a BYOK frontier turn -- the user pays the
+                 * provider directly, so no cap blocks the escalation. */
+                const capCheck = brainSelection.provider === 'yujin_managed'
+                    ? await (await import('../core/budget.js')).checkCap('frontier')
+                    : { allowed: true };
                 if (capCheck.allowed) {
                     const frontierSel = await selectBrainForTurn({
                         user_override: 'frontier',
@@ -3697,6 +4441,8 @@ async function handleChat(req, res, ctx) {
                          *  serving the turn. */
                         const frontierRequest = {
                             ...chatRequest,
+                            /* use the FRONTIER model, not the eco one inherited via spread */
+                            model: frontierSel.model,
                             system: buildSystemPrompt(ctx, reqMode, pilotState, {
                                 tier: frontierSel.tier,
                                 provider: frontierSel.provider,
@@ -3722,6 +4468,43 @@ async function handleChat(req, res, ctx) {
                 }
             }
         }
+        /* Panel-action enforcement (Pablo 2026-06-15) -- if the model SAID it
+         * opened a pizarron document / created a task but called NO such
+         * tool, the action never happened (Opus 4.8 narra; Gemini ejecuta).
+         * Re-issue the turn ONCE with a forcing nudge so it actually emits
+         * the verb. API/Console only: in CLI/Plan mode the subprocess runs
+         * tools natively and toolRounds is empty, so the check is N/A. */
+        if (ctx.chatProvider !== 'claude-code-cli'
+            && !reply.interrupted) {
+            const { checkClaimedPanelAction } = await import('./completion_hallucination_detector.js');
+            const firedPanelTool = (rounds) => rounds.some((r) => {
+                const vid = String(r.input?.verb_id ?? r.tool ?? '');
+                const res = r.result;
+                return /pizarron|show_in_pizarron|\.task\./i.test(vid) || (res != null && res.nac3_panel_dispatch === true);
+            });
+            const panelClaim = checkClaimedPanelAction(reply.text);
+            if (panelClaim.claimed && !firedPanelTool(reply.toolRounds)) {
+                const nudge = panelClaim.kind === 'task'
+                    ? 'Dijiste que creaste o avanzaste una tarea pero NO invocaste ninguna verb (yujin.task.*), asi que NO paso nada real. En ESTA respuesta tenes que invocar la verb ahora -- no la describas, ejecutala. Si no es posible, decilo con honestidad.'
+                    : 'Dijiste que abriste o generaste un documento en el pizarron pero NO invocaste ninguna verb (yujin.pizarron.create-tab), asi que el pizarron sigue vacio. En ESTA respuesta tenes que invocar nac3_invoke con yujin.pizarron.create-tab y el contenido real (HTML por defecto) ahora -- no lo describas, ejecutalo. Si no es posible, decilo con honestidad.';
+                try {
+                    const retryReq = {
+                        ...chatRequest,
+                        messages: [
+                            ...turnMessages,
+                            { role: 'assistant', content: reply.text },
+                            { role: 'user', content: '[SISTEMA] ' + nudge },
+                        ],
+                    };
+                    const retry = await callerForChat.chat(retryReq);
+                    if (retry && firedPanelTool(retry.toolRounds)) {
+                        reply = retry;
+                        escalationSignals = [...escalationSignals, 'panel_action_enforced[' + panelClaim.kind + ']'];
+                    }
+                }
+                catch { /* keep the original reply */ }
+            }
+        }
         // Append the latest user message + the assistant's reply to
         // the persistent transcript. Older messages may already be
         // present from previous turns; we only need to capture the
@@ -3730,10 +4513,10 @@ async function handleChat(req, res, ctx) {
         if (lastUser && lastUser.role === 'user') {
             // Only append if this user message isn't already the last
             // recorded one (prevents dup on retry).
-            const recent = ctx.store.messages();
+            const recent = sessionStore.messages();
             const tail = recent[recent.length - 1];
             if (!tail || tail.role !== 'user' || tail.content !== lastUser.content) {
-                ctx.store.append(lastUser);
+                sessionStore.append(lastUser);
             }
         }
         /* alpha.56 -- tag the assistant turn with the tier that
@@ -3760,13 +4543,13 @@ async function handleChat(req, res, ctx) {
          * way the next turn's sticky inertia + previous_tier check
          * see the canonical decision. */
         const finalTier = escalated ? 'frontier' : brainSelection.tier;
-        ctx.store.append({
+        sessionStore.append({
             role: 'assistant',
             content: reply.text,
             brain_tier: finalTier,
             ...(docLoaded ? { doc_loaded: true } : {}),
         });
-        void ctx.store.flush();
+        void sessionStore.flush();
         /* Pilot first-run auto-complete (SQ 0.10). If Pilot is
            not yet completed, decide based on the user's first
            message whether to mark setup done with defaults. */
@@ -3856,12 +4639,47 @@ async function handleChat(req, res, ctx) {
             }
         }
         catch { /* swallow */ }
+        /* UI sync (task #32) -- if this turn came from the phone in the
+         * UNIFIED thread, echo it to the panel so the laptop shows what was
+         * asked + answered from the mobile (the desktop-main thread is the
+         * shared 'notebook' session). 'own' mobile sessions stay private. */
+        if (body.origin === 'mobile' && sessionId === DEFAULT_SESSION_ID) {
+            try {
+                const { enqueuePanelDispatch } = await import('./panel_queue.js');
+                enqueuePanelDispatch('system.remote-turn', {
+                    source: 'mobile',
+                    user: lastUserText,
+                    reply: reply.text,
+                }, new Date().toISOString());
+            }
+            catch { /* best-effort */ }
+        }
+        /* UI sync (task #32, reverse) -- a turn issued on the DESKTOP (panel)
+         * in the unified thread is published to the relay so the phone's chat
+         * reflects it too. Mobile-origin turns are skipped (the phone already
+         * has them as its own bubbles). */
+        if (body.origin !== 'mobile' && sessionId === DEFAULT_SESSION_ID
+            && !reply.interrupted) {
+            try {
+                const pub = getRelayPublisher();
+                if (pub) {
+                    pub.remoteTurn('dt-' + Date.now(), lastUserText, reply.text);
+                    void pub.flush();
+                }
+            }
+            catch { /* best-effort */ }
+        }
         /* alpha.59e -- build the response payload once, then either
          * stream it as a turn_complete SSE event OR send the legacy
          * JSON response. */
+        const wasInterrupted = reply.interrupted === true;
         const responsePayload = {
             ok: true,
             message: { role: 'assistant', text: reply.text },
+            /* Interrupt (task #27): tell the panel the turn was stopped
+             * mid-flight so it can render the partial answer with a
+             * "(interrumpido)" marker instead of treating it as complete. */
+            ...(wasInterrupted ? { interrupted: true } : {}),
             tokens: { in: reply.tokensIn, out: reply.tokensOut },
             model: reply.model,
             /* alpha.43 -- manifest version stamp so the panel can detect
@@ -3966,6 +4784,14 @@ async function handleChat(req, res, ctx) {
             });
         }
     }
+    finally {
+        /* Interrupt (task #27): always clear this turn from the active
+         * registry, no matter how the turn exits. endTurn is a no-op if a
+         * newer turn has already replaced us, so it never clobbers a
+         * concurrent turn's registration. */
+        if (turnId)
+            endTurn(turnId);
+    }
 }
 export function buildSystemPrompt(ctx, mode = 'didactico', pilotState = {
     pilot_completed: true, target_pending: false, mode_pending: false,
@@ -4156,7 +4982,9 @@ panelMode = 'native') {
         '  Hallucinated completions are a credibility-destroyer; the user',
         '  finds out you did nothing the next message + loses trust in',
         '  every subsequent claim. When in doubt, ask. When sure, invoke.',
-        '  NEVER both promise AND defer.',
+        '  NEVER both promise AND defer. Opening a pizarron doc',
+        '  (yujin.pizarron.create-tab, HTML) or touching a task = CALL the',
+        '  verb THIS turn; claiming it with no tool_use is a lie.',
         '',
         '=================================================================',
         'PRODUCT WORKFLOW (on-demand)',