comfyui-mcp 0.48.21 → 0.48.22

package/dist/orchestrator/index.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
 import readline from "node:readline";
 import { startUiBridge, isLoopbackBindHost } from "../services/ui-bridge.js";
-import { setupSecureBridge } from "../services/secure-bridge.js";
+import { setupSecureBridge, resolveComfyuiPathForTarget } from "../services/secure-bridge.js";
 import { startQuickTunnel } from "../services/tunnel.js";
 import { detectInstallMode } from "../services/self-update.js";
 import { SelfRestarter } from "../services/self-restart.js";
@@ -50,6 +50,7 @@ import { resolvePrompt, registerPrompt, onPromptsChanged } from "../services/pro
 import { allBackendReadiness } from "./backend-readiness.js";
 import { handleOAuthBegin, handleOAuthStatus, handleOAuthSignout } from "./oauth-bridge.js";
 import { buildStartFailureNotice } from "./start-failure-notice.js";
+import { readyBannerText, bannerCorrection } from "./ready-banner.js";
 import { OAUTH_PROVIDERS } from "../services/oauth-flow.js";
 import { startPanelMcpHttpServer } from "./panel-mcp-http.js";
 import { startPanelConsoleHttpServer } from "./panel-console-http.js";
@@ -64,7 +65,7 @@ import { unloadAllOllama, warmOllama, resolveOllamaHost } from "../services/olla
 import { isLocalLmstudio, startLmstudioServer, unloadAllLmstudio, warmLmstudio, } from "../services/lmstudio-lifecycle.js";
 import { llamacppProps, llamacppToolsReady } from "../services/llamacpp-probe.js";
 import { getAgentSettings, setAgentSettings, normalizePreferredModels } from "../services/panel-settings.js";
-import { gatherEnvCapabilities, buildPanelSystemAppend, } from "../services/env-capabilities.js";
+import { gatherEnvCapabilities, buildPanelSystemAppend, resolveBackends, } from "../services/env-capabilities.js";
 import { WorkflowTargetStore } from "../services/workflow-target-store.js";
 const PANEL_SYSTEM_APPEND = `You are the autonomous assistant embedded directly in a ComfyUI sidebar panel. The person is working in ComfyUI and talks to you through that panel: their messages arrive as your prompts, and everything you write is shown to them in the panel chat. Write for that reader — lead with the result, keep replies short and concrete, and don't narrate routine internal steps.
 
@@ -80,7 +81,7 @@ If a workflow needs a custom node the user doesn't have, don't silently skip it
 
 CRASH RECOVERY — when a custom node BREAKS or CRASHED ComfyUI, fix it before giving up. If your turn begins with a "⚠️ ComfyUI crashed …" note (it names the fatal log block and the most likely culprit custom node + file:line), or a run dies with a node-level error you can pin to one pack, do NOT just re-run the same graph — ESCALATE to actually fix that node, narrating each step to the user as you go: (a) UPDATE it to the latest code — call panel_update_node with the culprit's id (or the comfyui MCP update_custom_node / fix_custom_node). Try version 'nightly' to grab a just-landed upstream fix. Poll panel_node_queue_status, then panel_restart_comfyui → you resume and RETRY the action to see if the crash is gone. (b) If updating doesn't fix it, reach into COMFYUI_PATH/custom_nodes/<NodeDir> with your shell (Bash): if it's a git repo (a .git dir), run git fetch && git pull (or check out the nightly branch) to force the latest, reinstall its requirements if needed, then restart + retry. (c) If there's no git or it's still broken, attempt a TARGETED source patch of the crashing file:line, then VERIFY the fix actually resolves the crash (restart + retry the same action — confirm it no longer faults). Once verified, OFFER to suggest the fix upstream to the repo owner (open an issue or PR describing the crash + your patch) — describe it and ask the user first; do NOT auto-file anything. Combine this cleanly with the normal install→restart→continue flow above: a fresh install that crashes on first use is the same loop (update/patch the just-installed node, don't abandon it).
 
-REPORT OUR OWN BUGS (we're in beta — bias HARD toward filing) — distinct from the third-party case above. Whenever YOU hit a defect in comfyui-mcp or the sidebar panel ITSELF — a tool/panel/orchestrator call that errors, crashes ComfyUI, returns wrong/misleading/empty output, fails silently, or a limitation that forced you into an awkward workaround/retry — invoke the report-bug skill (read_skill "report-bug") to autonomously file a via-panel report, EVEN IF you already recovered or worked around it. You do NOT need to be blocked, and it does NOT need to be fatal — the workaround itself is the signal. The skill scrubs secrets and files through our intake Worker (which dedupes server-side, so over-reporting is cheap); then just drop the user a one-line note. Do NOT ask permission for OUR bugs — file them autonomously (unlike third-party/custom-node bugs above, where you OFFER and ask first). Ordinary generation errors (OOM, missing model, bad params, user mistakes) are NOT bug reports — those stay troubleshooting.
+REPORT OUR OWN BUGS (we're in beta — bias HARD toward filing) — distinct from the third-party case above. Whenever YOU hit a defect in comfyui-mcp or the sidebar panel ITSELF — a tool/panel/orchestrator call that errors, crashes ComfyUI, returns wrong/misleading/empty output, fails silently, or a limitation that forced you into an awkward workaround/retry — invoke the report-bug skill (read_skill "report-bug") to autonomously file a via-panel report, EVEN IF you already recovered or worked around it. You do NOT need to be blocked, and it does NOT need to be fatal — the workaround itself is the signal. AND report the FIX, not just the failure: any time a defect in comfyui-mcp or the panel gets fixed or patched during the session — you edited/worked around the code, changed a setting, or otherwise made a broken thing work — and the user confirms it's working (they're happy with the fix), file the report RIGHT THEN, capturing BOTH the original bug AND the fix that worked, so it can be fixed upstream at the source (a confirmed working fix is the most valuable thing to send upstream). File it immediately and autonomously — do NOT wait, and do NOT ask. The skill scrubs secrets and files through our intake Worker (which dedupes server-side, so over-reporting is cheap); then just drop the user a one-line note. Do NOT ask permission for OUR bugs — file them autonomously (unlike third-party/custom-node bugs above, where you OFFER and ask first). Ordinary generation errors (OOM, missing model, bad params, user mistakes) are NOT bug reports — those stay troubleshooting.
 
 WEDGED RENDER / OOM / VRAM PINNED — when a generation is stuck or hits CUDA out-of-memory, or a cancel didn't actually free GPU memory (models still resident, VRAM pinned, the next run still OOMs), call panel_free_vram to UNLOAD all models and free VRAM before retrying — it does NOT restart ComfyUI, so it's the cheap first move. Escalation ladder: cancel the run → panel_free_vram (unload + free) → retry; only as a LAST RESORT panel_restart_comfyui (which refuses mid-render and guards the running generation). Reach for panel_free_vram before a restart whenever a cancel left memory pinned.
 
@@ -94,7 +95,7 @@ MERGE / COMPOSE WORKFLOWS — to bring nodes from ONE workflow into ANOTHER (com
 
 REUSE SUBGRAPHS via the blueprint library — when the user builds a useful subgraph and wants to reuse it (now or in other workflows), SAVE it: panel_create_subgraph to group the nodes (if not already a subgraph), then panel_save_subgraph(node_id, name) publishes it to their library programmatically (no dialog). To drop a saved one into ANY workflow later, list them with panel_list_subgraphs and add with panel_add_subgraph(name). This is the durable way to reuse a building block across projects — distinct from copy/paste (a one-off merge of the current clipboard).
 
-PREFER READY EXPERTISE OVER HAND-BUILDING. When the user asks you to "set up", "build", or "make" a workflow for a specific model FAMILY (krea2, wan, flux, qwen, ltx, z-image, ideogram, anima, ernie, etc.), do NOT immediately hand-build a generic graph from scratch. FIRST, in order: (a) consult the matching SKILL for that family. If you already have a skill for it loaded in your context, use it. If you do NOT have its full guidance in front of you, do NOT guess from memory — actually CALL the comfyui MCP's list_skills to see what's bundled, then read_skill(name) to load the real family expertise (model slots, the node graph, settings, gotchas) before you build; (b) check the installer PACKS by CALLING list_packs (each packs/<name>/ has a ready manifest.yaml AND a ready workflow.json). If a pack matches the family, PREFER it: apply_manifest --path <its manifest_path> installs the right custom nodes + model weights, and the pack's workflow.json is the expert graph — CALL read_pack_workflow(name) to get that ready graph and recreate it on the live canvas via panel_add_node/panel_connect/panel_set_widget so the user watches it build (or enqueue it headlessly when they don't need it on-canvas), instead of inventing your own. Don't claim a skill or pack exists unless a tool result confirmed it; (c) check the official ComfyUI workflow Templates — call list_workflow_templates (it lists the server's bundled comfyui-workflow-templates + custom-node templates) for a matching starter, and point the user at it in the frontend's Templates browser. Only build from scratch if NOTHING matches — and when you do, briefly say what you checked (skill, packs, templates) so the user knows you didn't reinvent the wheel. And never wipe the user's current canvas (no panel_clear) until the replacement is actually ready to drop in. To load a ready pack graph onto the live canvas in one shot (instead of recreating it node-by-node), use panel_load_workflow(pack:<name>) — the pack's UI workflow.json is read server-side and dropped onto the canvas, undoable.
+PREFER READY EXPERTISE OVER HAND-BUILDING. When the user asks you to "set up", "build", or "make" a workflow for a specific model FAMILY (krea2, wan, flux, qwen, ltx, z-image, ideogram, anima, ernie, etc.), do NOT immediately hand-build a generic graph from scratch. FIRST, in order: (a) consult the matching SKILL for that family. If you already have a skill for it loaded in your context, use it. If you do NOT have its full guidance in front of you, do NOT guess from memory — actually CALL the comfyui MCP's list_skills to see what's bundled, then read_skill(name) to load the real family expertise (model slots, the node graph, settings, gotchas) before you build; (b) check the installer PACKS by CALLING list_packs (each packs/<name>/ has a ready manifest.yaml AND a ready workflow.json). If a pack matches the family, PREFER it: apply_manifest --path <its manifest_path> installs the right custom nodes + model weights, and the pack's workflow.json is the expert graph — CALL read_pack_workflow(name) to get that ready graph and recreate it on the live canvas via panel_add_node/panel_connect/panel_set_widget so the user watches it build (or enqueue it headlessly when they don't need it on-canvas), instead of inventing your own. Don't claim a skill or pack exists unless a tool result confirmed it; (c) check the ComfyUI workflow Templates — call list_workflow_templates (it lists CUSTOM-NODE-contributed templates from the server's /api/workflow_templates index; it does NOT enumerate ComfyUI's own core bundled templates, which are served separately) for a matching starter, and ALSO point the user at the frontend's Templates browser directly, since core templates only appear there. Only build from scratch if NOTHING matches — and when you do, briefly say what you checked (skill, packs, templates) so the user knows you didn't reinvent the wheel. And never wipe the user's current canvas (no panel_clear) until the replacement is actually ready to drop in. To load a ready pack graph onto the live canvas in one shot (instead of recreating it node-by-node), use panel_load_workflow(pack:<name>) — the pack's UI workflow.json is read server-side and dropped onto the canvas, undoable.
 
 OPENING A STAGED / DOWNLOADED WORKFLOW. When you've saved or downloaded a workflow .json into the user's ComfyUI workflows folder (e.g. an example you fetched), open it with panel_open_workflow(path:<name-or-path>) — it now REFRESHES the frontend's (cached) workflow list before searching, so a just-staged file is found and opened natively in its own tab. For a workflow .json that lives OUTSIDE the workflows folder (any absolute path on the ComfyUI machine, or a downloaded example you didn't move into workflows/), load it directly onto the live canvas with panel_load_workflow(path:<file>) — the orchestrator reads + parses the JSON server-side and drops it on the canvas in one shot, so even a large (100KB+) workflow never has to shuttle through this chat. Prefer panel_load_workflow(path:<file>) over pasting a big workflow JSON inline as the graph arg.
 
@@ -965,7 +966,26 @@ export async function runPanelOrchestrator() {
     // local install — the spawn env builders prefer COMFYUI_PATH over the
     // force-remote flag, so a leaked path would silently defeat --force-remote.
     const localPathForTarget = (url) => !isForceRemoteFlagSet() && isLoopbackUrl(url) ? localComfyuiPath : undefined;
-    let comfyuiPath = localPathForTarget(comfyuiUrl);
+    // #296: an embedded LOCAL sidebar session with NO CLI-configured workspace
+    // (COMFYUI_PATH unset AND auto-detect empty) would otherwise spawn path-less —
+    // its comfyui MCP stuck in a degraded "local but path-less" state (no
+    // download_model/apply_manifest/model-scan LOCAL surface, panel_load_workflow's
+    // local fallback blind). The panel already KNOWS where ComfyUI lives and serves
+    // it at GET /comfyui_mcp_panel/status (base_path). resolveComfyuiPathForTarget
+    // consumes it as a last-resort fallback for a loopback, non-force-remote target
+    // (adopting only a path that actually exists on THIS machine). Awaited here so
+    // the recovered path is in place BEFORE the MCP-env builders / manager below
+    // capture it. Best-effort — a failed/absent status route leaves us path-less.
+    let comfyuiPath = await resolveComfyuiPathForTarget({
+        target: comfyuiUrl,
+        localPath: localComfyuiPath,
+        forceRemote: isForceRemoteFlagSet(),
+        isLoopback: isLoopbackUrl(comfyuiUrl),
+    });
+    if (comfyuiPath && comfyuiPath !== localPathForTarget(comfyuiUrl)) {
+        logger.info(`[panel-orchestrator] no COMFYUI_PATH/default workspace; adopted ComfyUI ` +
+            `base_path from the panel status route: ${comfyuiPath} (#296).`);
+    }
     // Force the child remote only when opted in (--force-remote) or the target is
     // non-loopback; a default loopback panel user with no COMFYUI_PATH is left to
     // auto-detect its local install (keeps download_model/apply_manifest/scans).
@@ -1214,6 +1234,15 @@ export async function runPanelOrchestrator() {
     const defaultBackend = KNOWN_BACKENDS.has(backendId) ? backendId : "claude";
     const AGENT_KEY_SEP = "::";
     const tabBackends = new Map(); // panel tabId -> selected backend
+    // #376: the model label advertised in a tab's ready banner (sent at hello, before
+    // the SDK reports the real model). onSession re-sends a corrected banner when the
+    // resolved model differs from what's stored here. A tab with NO entry never got a
+    // greeting (a resume/reconnect), so it must never be "corrected".
+    const advertisedBannerModel = new Map();
+    // The SDK-resolved model per tab, learned from the session/init event. Kept so a
+    // greeting emitted AFTER the model is already known (the onSession-before-greeting
+    // race) can label itself correctly instead of showing the pre-init default.
+    const resolvedModelByTab = new Map();
     const headlessTabs = new Set(); // tabs with no ComfyUI canvas (mobile/remote) — deliver renders in-turn
     const workflowTargets = new WorkflowTargetStore();
     const backendForTab = (panelTabId) => tabBackends.get(panelTabId) ?? defaultBackend;
@@ -1272,11 +1301,32 @@ export async function runPanelOrchestrator() {
             if (gen !== envRefreshGen)
                 return; // superseded — let the newer refresh own the prompt
             // Belt-and-suspenders: gather is internally guarded, but never let a stray
-            // throw break the prompt — fall back to the static append.
+            // throw break the prompt — fall back to the static append. Also DROP any
+            // previously-gathered envCaps so systemAppendForBackend() falls back to the
+            // same static append for EVERY backend (not just the default) — otherwise a
+            // non-default backend would rebuild a stale env block off the old caps,
+            // disagreeing with the reset panelSystemAppend (#358 wiring).
+            envCaps = undefined;
             panelSystemAppend = resolvePrompt("panel.persona", PANEL_SYSTEM_APPEND);
             logger.debug(`[panel-orchestrator] env-capabilities probe failed (using static prompt): ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // The ENVIRONMENT block's `Backend:` line must name the provider running THIS
+    // tab's turn, not the process default (#358). Backends are per-tab now, so the
+    // single `panelSystemAppend` (built with the default backend id) would tell a
+    // Grok tab it's Claude. Rebuild the block per-tab-backend: same env facts, but
+    // the backend label recomputed from the tab's actual backend id. Falls back to
+    // the shared append when the env probe produced nothing (envCaps undefined).
+    const systemAppendForBackend = (bId) => {
+        if (!envCaps)
+            return panelSystemAppend;
+        const { backend, otherBackendAvailable } = resolveBackends(bId);
+        // Already the default's label → reuse the shared string (no rebuild).
+        if (envCaps.backend === backend && envCaps.otherBackendAvailable === otherBackendAvailable) {
+            return panelSystemAppend;
+        }
+        return buildPanelSystemAppend(resolvePrompt("panel.persona", PANEL_SYSTEM_APPEND), { ...envCaps, backend, otherBackendAvailable });
+    };
     // Build it before any agent could spawn. Guarded so a probe stall can't block
     // orchestrator startup beyond the probes' own (short) timeouts.
     await refreshEnvCapabilities();
@@ -1425,12 +1475,14 @@ export async function runPanelOrchestrator() {
     const makeBackend = (key) => {
         const backend = backendOf(key);
         const panelTabId = panelTabOf(key);
+        // The ENVIRONMENT block's `Backend:` line must name THIS backend (#358).
+        const sysAppend = systemAppendForBackend(backend);
         try {
             if (backend === "codex") {
                 return new CodexBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: codexModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1439,7 +1491,7 @@ export async function runPanelOrchestrator() {
                 return new GeminiBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: geminiModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1448,7 +1500,7 @@ export async function runPanelOrchestrator() {
                 return new AntigravityBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     ...(antigravityModel ? { model: antigravityModel } : {}),
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
             }
@@ -1456,7 +1508,7 @@ export async function runPanelOrchestrator() {
                 return new GrokBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: grokModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1465,7 +1517,7 @@ export async function runPanelOrchestrator() {
                 return new OllamaBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: ollamaModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                     ...ollamaDeps(),
@@ -1475,7 +1527,7 @@ export async function runPanelOrchestrator() {
                 return new OllamaBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: openrouterModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                     ...openrouterDeps(),
@@ -1485,7 +1537,7 @@ export async function runPanelOrchestrator() {
                 return new OllamaBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: lmstudioModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                     ...lmstudioDeps(),
@@ -1495,7 +1547,7 @@ export async function runPanelOrchestrator() {
                 return new OllamaBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: llamacppModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                     ...llamacppDeps(),
@@ -1505,7 +1557,7 @@ export async function runPanelOrchestrator() {
                 return new OllamaBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: customModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                     ...customDeps(),
@@ -1515,7 +1567,7 @@ export async function runPanelOrchestrator() {
                 return new ChatGptOAuthBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: chatgptModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1524,7 +1576,7 @@ export async function runPanelOrchestrator() {
             if (simpleKeyReg) {
                 // glm/moonshot (and any future simple api-key provider) share one factory.
                 return makeOpenAiKeyBackend(simpleKeyReg, {
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1533,7 +1585,7 @@ export async function runPanelOrchestrator() {
                 return new KimiBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: kimiModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1546,7 +1598,7 @@ export async function runPanelOrchestrator() {
                 return new CopilotBackend({
                     cwd: comfyuiPath ?? process.cwd(),
                     model: copilotModel,
-                    systemAppend: panelSystemAppend,
+                    systemAppend: sysAppend,
                     comfyuiUrl,
                     mcpServers: makeHttpBackendMcpServers(panelTabId),
                 });
@@ -1649,6 +1701,10 @@ export async function runPanelOrchestrator() {
         makeBackend,
         comfyuiUrl, // for fetching image bytes to inline into agent turns
         systemAppend: panelSystemAppend,
+        // Per-KEY env block so the CLAUDE path (makeBackend returns undefined) still
+        // gets the tab's actual backend on its `Backend:` line (#358). Non-claude
+        // tabs get it via makeBackend's sysAppend; this covers the built-in default.
+        makeSystemAppend: (key) => systemAppendForBackend(backendOf(key)),
         pluginPath: pluginAvailable ? pluginPath : undefined,
         // In-process live-graph MCP for CLAUDE keys only (codex/gemini drive the
         // canvas through the loopback HTTP MCP instead). Bound to the PANEL tab so
@@ -1675,9 +1731,28 @@ export async function runPanelOrchestrator() {
         // Per-response usage → the panel's context/usage meter (updates live).
         onStatus: (key, status) => pushStatus(panelTabOf(key), status),
         // Report the SDK session id so the panel can persist it and resume on reload.
-        onSession: (key, sessionId) => {
-            bridge.push({ type: "session", session_id: sessionId }, panelTabOf(key));
+        onSession: (key, sessionId, model) => {
+            const panelTab = panelTabOf(key);
+            bridge.push({ type: "session", session_id: sessionId }, panelTab);
             bridge.broadcastTabList(); // a session started/changed → refresh mirror pickers
+            // #376: the ready banner was sent at hello with the PRE-init default model.
+            // Now the SDK reports the ACTUALLY-resolved model — remember it, then re-send
+            // a corrected banner IFF a banner was actually advertised for this tab AND the
+            // resolved model differs (bannerCorrection returns null otherwise, so a resume
+            // with no prior greeting is never "corrected" and a correct banner never
+            // duplicates).
+            if (typeof model === "string" && model.trim())
+                resolvedModelByTab.set(panelTab, model);
+            const corrected = bannerCorrection({
+                backend: backendForTab(panelTab),
+                advertisedLabel: advertisedBannerModel.get(panelTab),
+                resolvedModel: model,
+                customBaseUrl,
+            });
+            if (corrected) {
+                advertisedBannerModel.set(panelTab, model);
+                bridge.push({ type: "say", text: corrected }, panelTab);
+            }
         },
         // Per-turn rewind anchor (assistant UUID) → the panel stores it so a later
         // "rewind conversation to here" can fork the session at that point.
@@ -1856,6 +1931,38 @@ export async function runPanelOrchestrator() {
         // (hello, runpod tools, watcher auto-stop/vanish), so they can't drift
         // split-brained again (#269).
         logger.info(`[panel-orchestrator] retargeted ComfyUI ${prev} → ${comfyuiUrl} (${isLoopbackUrl(next) ? "local" : "remote"} mode) from panel hello`);
+        // #296: the synchronous `localPathForTarget(next)` above can't see the NEWLY
+        // targeted panel's base_path, so a retarget to a loopback ComfyUI with no
+        // env/auto-detected path lands path-less even though that panel serves it. Kick
+        // off a best-effort recovery from the NEW target's status route (fire-and-forget
+        // so the retarget stays synchronous). On success — and only if a newer retarget
+        // hasn't superseded us mid-fetch — adopt the path and rebuild the comfyui MCP
+        // spawn env so each tab's child respawns in LOCAL mode. Skipped entirely when a
+        // local path is already set (the common case does no I/O).
+        if (!comfyuiPath) {
+            void (async () => {
+                const recovered = await resolveComfyuiPathForTarget({
+                    target: next,
+                    localPath: localComfyuiPath,
+                    forceRemote: isForceRemoteFlagSet(),
+                    isLoopback: isLoopbackUrl(next),
+                });
+                if (!recovered)
+                    return;
+                // Superseded by a newer retarget while we fetched — do nothing.
+                if (canonTargetUrl(comfyuiUrl) !== canonTargetUrl(next))
+                    return;
+                if (comfyuiPath === recovered)
+                    return;
+                comfyuiPath = recovered;
+                logger.info(`[panel-orchestrator] recovered ComfyUI base_path from panel status route ` +
+                    `after retarget: ${recovered} (#296).`);
+                // Rebuild the comfyui MCP spawn env (now carrying COMFYUI_PATH) and respawn
+                // each tab's agent at its next idle so the LIVE child runs in LOCAL mode.
+                manager.setMcpServers(buildMcpServers());
+                manager.restartAllForMcpEnv();
+            })();
+        }
         // Advertising itself happens unconditionally on every hello (see below) —
         // a retarget doesn't need its own advertise call here.
         return true;
@@ -1868,10 +1975,23 @@ export async function runPanelOrchestrator() {
     // idle so the LIVE comfyui MCP subprocess is recreated WITH the new env, and
     // nudge it to retry the action the secret unblocked. No process restart, no
     // reload fight. The value is never logged — only the env-var KEYS.
-    const unsubscribeSecrets = onComfyuiSecretsChanged(() => {
+    const SECRET_RETRY_NUDGE = "🔑 The API token you just provided is now active for the comfyui tools — retry the action that needed it (e.g. the download that returned 401).";
+    const unsubscribeSecrets = onComfyuiSecretsChanged((change) => {
         manager.setMcpServers(buildMcpServers());
-        manager.restartAllForMcpEnv("🔑 The API token you just provided is now active for the comfyui tools — retry the action that needed it (e.g. the download that returned 401).");
-        logger.info(`[panel-orchestrator] tool secret saved → comfyui MCP env updated + agents respawn on idle (keys: ${comfyuiSecretKeys().join(", ") || "none"})`);
+        // EVERY tab's comfyui child needs the new/removed env, so respawn each at its
+        // next idle — but SILENTLY (no nudge). The env rebuild is shared; the "retry
+        // the action" nudge is not, so it must never broadcast to unrelated tabs.
+        // restartAllForMcpEnv() is nudge-preserving, so this can't erase a per-request
+        // nudge already queued on another tab (#164).
+        manager.restartAllForMcpEnv();
+        // NUDGE only the tab whose panel_request_secret this change answers — a
+        // Settings slot save, a background token (re)load, or a revoke leaves
+        // `requested` false and nudges nothing. The per-tab pending-restart map
+        // coalesces, so a repeat event for the same tab can't double-inject (#164).
+        const nudgedTab = change.requested && change.tabId ? change.tabId : null;
+        if (nudgedTab)
+            manager.restartForMcpEnv(agentKeyFor(nudgedTab), SECRET_RETRY_NUDGE);
+        logger.info(`[panel-orchestrator] tool secret ${change.requested ? "saved (requested)" : "changed"} → comfyui MCP env updated + agents respawn on idle${nudgedTab ? ` + retry nudge → tab ${nudgedTab.slice(0, 8)}` : ""} (keys: ${comfyuiSecretKeys().join(", ") || "none"})`);
     });
     // An agent-provider secret changed (e.g. the OpenRouter API key set from the
     // panel). Hydrate it into env, drop the cached openrouter probe/model list so
@@ -2383,32 +2503,13 @@ export async function runPanelOrchestrator() {
                     }
                     // Greet only on a FRESH session (a resume/reconnect already has the thread).
                     if (!resume) {
-                        const readyText = reg
-                            ? reg.readyMessage(agentLabel)
-                            : isCx
-                                ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your Codex (ChatGPT) account. Ask away.`
-                                : isCg
-                                    ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your ChatGPT subscription (direct OAuth). Ask away.`
-                                    : isGm
-                                        ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your Google account (Gemini Code Assist). Ask away.`
-                                        : isAg
-                                            ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your Google AI subscription via Antigravity CLI. Note: agy turns show final answers only (no live tool progress). Ask away.`
-                                            : isGk
-                                                ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your Grok (xAI) account. Ask away.`
-                                                : isOl
-                                                    ? `🟢 comfyui-mcp agent ready — ${agentLabel} running locally via Ollama (no account, no API key). Small local models are slower and simpler than frontier ones — expect fewer frills. Ask away.`
-                                                    : isLs
-                                                        ? `🟢 comfyui-mcp agent ready — ${agentLabel} running locally via LM Studio (no account, no API key). Small local models are slower and simpler than frontier ones — expect fewer frills. Ask away.`
-                                                        : isLc
-                                                            ? `🟢 comfyui-mcp agent ready — ${agentLabel} running locally via llama.cpp (no account, no API key). Small local models are slower and simpler than frontier ones — expect fewer frills. Ask away.`
-                                                            : isCu
-                                                                ? `🟢 comfyui-mcp agent ready — ${agentLabel} via your custom endpoint (${customBaseUrl}). Ask away.`
-                                                                : isOr
-                                                                    ? `🟢 comfyui-mcp agent ready — ${agentLabel} via OpenRouter (hosted API, your OPENROUTER_API_KEY). Ask away.`
-                                                                    : isCp
-                                                                        ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your GitHub Copilot subscription (⚠️ experimental, ToS risk — you opted in). Ask away.`
-                                                                        : `🟢 comfyui-mcp agent ready — ${agentLabel} on your Claude subscription. Ask away.`;
-                        bridge.push({ type: "say", text: readyText }, panelTab);
+                        // Prefer an ALREADY-resolved model if the SDK init raced ahead of this
+                        // greeting (#376) — otherwise the pre-init label. Remember what we
+                        // advertised so the onSession correction re-sends only on a real
+                        // mismatch.
+                        const bannerLabel = resolvedModelByTab.get(panelTab) ?? agentLabel;
+                        advertisedBannerModel.set(panelTab, bannerLabel);
+                        bridge.push({ type: "say", text: readyBannerText(backend, bannerLabel, customBaseUrl) }, panelTab);
                     }
                     bridge.push({ type: "ack", ok: true, kind: "ready", agent: agentLabel, backend }, panelTab);
                     logger.debug(`[panel-orchestrator] tab ${panelTab.slice(0, 8)} connected (${backend}) — agent healthy, ready ack`);