comfyui-mcp 0.52.4 → 0.52.7

package/dist/orchestrator/panel-tools.js

@@ -23,7 +23,7 @@
 // gating for panel_clear/panel_restart_comfyui) is IDENTICAL across providers,
 // so parity is automatic — neither path reimplements a tool.
 import { z } from "zod";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 // #873 — the operator's tool-surface policy also governs the panel surface.
 import { resolveToolSurfacePolicy, toolActionPolicyError, toolAllowed, } from "../tools/tool-surface-filter.js";
 import { logger as toolPolicyLogger } from "../utils/logger.js";
@@ -34,6 +34,7 @@ import { fileURLToPath } from "node:url";
 import { comfyuiFetch } from "../comfyui/fetch.js";
 import { assertPanelNotTargetedUnverifiable } from "../services/panel-pin-guard.js";
 import { nodesInstallCommandArgs } from "../services/node-management.js";
+import { formatQueueStatusPartialNote, getManifestPartialLeftover, } from "../services/manifest-partial.js";
 import { searchPanelNodes } from "../services/manager-node-search.js";
 import { isPanelAnsweredError } from "../services/panel-answered.js";
 import { isPreExecutorRefusal } from "../services/panel-refusal.js";
@@ -45,6 +46,7 @@ import { primePanelBase, verifiedPanelDiskVersion, } from "../services/panel-wor
 import { conversationOfScopeAddress, isScopeAddress, shortTabId } from "../services/session-scope.js";
 import { NODE_ID_MESSAGE, NODE_ID_PATTERN, normalizeNodeId } from "./node-id.js";
 import { parseContradictoryPromotedWidgetRefusal, resolveInnerPromotedTarget, } from "./promoted-widget.js";
+import { isPlainObject, isStampMismatchSaveRefusal, patchOpenIdentity, shouldRebindOpenIdentity, workflowFromSerializeReply, } from "./open-identity-normalization.js";
 import { clearSwitchHold, describeSwitchHold, recordSwitchHold, successProvesSwitchCleared, } from "./switch-hold.js";
 import { NO_ORIGIN_REMEDY } from "./fence-refusal.js";
 /** #884 — journal TICKETS (run completions #468, ask answers #486) must be
@@ -72,7 +74,7 @@ function journalTabFor(ctx) {
 function journalConversationFor(ctx) {
     return conversationOfScopeAddress(ctx.tabId);
 }
-import { BRIDGE_DEFAULT_TIMEOUT_MS, BRIDGE_READ_DEFAULT_TIMEOUT_MS, dispatchOutcomeOf, isCapabilityRefusal, isPanelCmdUnsupportedError, isReplyTimeoutTagged, isRoutingAmbiguity, } from "../services/ui-bridge.js";
+import { BRIDGE_DEFAULT_TIMEOUT_MS, BRIDGE_READ_DEFAULT_TIMEOUT_MS, dispatchOutcomeOf, isCapabilityRefusal, isPanelCmdUnsupportedError, isReplyTimeoutTagged, isRoutingAmbiguity, requiresWorkflowStampEnforcement, } from "../services/ui-bridge.js";
 import { withWorkflowTarget, } from "../services/workflow-target-store.js";
 import { addUserMcpServer, readUserMcpServers, removeUserMcpServer, setUserMcpServerSecret, } from "../services/user-mcp-config.js";
 import { setComfyuiSecret, setAgentSecret, isAllowedAgentSecretKey, receiptDisclosures, shadowedNote, storeDamageNote, } from "../services/panel-secrets.js";
@@ -94,6 +96,13 @@ import { config, isRemoteMode, isCloudMode, getBootLocalComfyUIBaseUrl, getComfy
 import { normalizeInstallPathEnv } from "../utils/install-path-env.js";
 import { sliceWorkflow } from "../services/workflow-slicer.js";
 import { validateA2UISpecServer } from "../services/a2ui-spec.js";
+/** #1700 — orchestrator wires this so panel_reload can fork-respawn the agent
+ *  with a freshly-read MCP set. Unset in tests that only exercise the tool. */
+let applyMcpReload;
+/** Bind (or clear) the in-process MCP-config respawn used by panel_reload. */
+export function setApplyMcpReload(fn) {
+    applyMcpReload = fn;
+}
 /** Treat these as an affirmative answer to a yes/no confirm card (destructive-op
  *  gate). Deliberately BROAD/lenient — a false "no" only SKIPS a destructive op, so
  *  erring toward "not yes" is safe. NEVER use this for the adult-consent gate: a
@@ -782,6 +791,26 @@ function isFencedGraphRead(cmd) {
     const name = typeof cmd.cmd === "string" ? cmd.cmd : "";
     return name.startsWith("graph_") && !MUTATING_GRAPH_EDIT_CMDS.has(name);
 }
+/**
+ * #1778 — a fenced command that is neither a graph edit nor a graph read.
+ *
+ * `workflow_save` / `workflow_save_as` / `workflow_rename` / `workflow_close`
+ * require a workflow stamp (`requiresWorkflowStampEnforcement`) and the
+ * dispatch gate refuses them the same way it refuses a graph_* command. They
+ * are not in MUTATING_GRAPH_EDIT_CMDS and they do not start with `graph_`, so
+ * neither existing probe branch fires. The save handler then returns at
+ * `if (res.isError) return res` with the generic "tab may be disconnected"
+ * wrapper and an empty corroboration, so a save-only retry never self-heals.
+ *
+ * Derived from the stamp-enforcement classifier minus the `graph_` prefix, so
+ * a newly added active-workflow mutator cannot drift out. The prefix is still
+ * load-bearing for the same reason as `isFencedGraphRead`: the diagnosis runs
+ * `workflow_list`, which must not re-enter this branch.
+ */
+function isFencedActiveWorkflowMutator(cmd) {
+    const name = typeof cmd.cmd === "string" ? cmd.cmd : "";
+    return !name.startsWith("graph_") && requiresWorkflowStampEnforcement(cmd);
+}
 /** True when an error is a TRANSIENT transport/reconnect drop (the tab went away
  *  or was replaced), NOT a genuine command error or a live-but-frozen reply
  *  timeout. Deliberately EXCLUDES "did not reply within N ms" (a backgrounded/
@@ -844,6 +873,17 @@ function isWorkflowInstanceMismatch(err) {
     const msg = err instanceof Error ? err.message : String(err ?? "");
     return /workflow instance mismatch/i.test(msg);
 }
+/** Would the next graph command still resolve `ctx.tabId` to a live tab? */
+function sessionRouteIsLive(ctx) {
+    if (typeof ctx.bridge.canReach !== "function")
+        return true;
+    try {
+        return ctx.bridge.canReach(ctx.tabId) === true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * #1331 — the bridge refused a mutation because the active workflow has no identity to
  * fence against (ui-bridge's `no trusted identity` branch).
@@ -2342,6 +2382,35 @@ async function settleDroppedEnqueue(ctx, res, dispatch) {
         `when the Manager will not take it. This tool cannot clone for you — it drives whatever ` +
         `ComfyUI the panel is bound to, which need not be this machine.`);
 }
+/**
+ * #1699 — a drained Manager queue is not apply_manifest completion when
+ * custom_nodes were never submitted. Keep the panel payload parseable (do not
+ * append prose after the JSON) and name the leftover entries on the object.
+ */
+function annotateQueueStatusWithManifestPartial(res) {
+    const leftover = getManifestPartialLeftover();
+    if (!leftover || leftover.not_started.length === 0)
+        return res;
+    if (res.isError)
+        return res;
+    const parsed = parseToolResultJson(res);
+    if (!parsed)
+        return appendNote(res, formatQueueStatusPartialNote(leftover));
+    return {
+        ...res,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    ...parsed,
+                    apply_manifest_partial: leftover,
+                    queue_complete_for_apply_manifest: false,
+                }, null, 2),
+            },
+            ...res.content.slice(1),
+        ],
+    };
+}
 /** Parse a ctx.call ToolResult's text payload as JSON, or null if not parseable. */
 function parseToolResultJson(res) {
     if (!res || res.isError)
@@ -2386,6 +2455,31 @@ function isStaleNodeSchemaRefusal(res) {
         return false;
     return /added or retyped since this page loaded its node schema/i.test(textOfToolResult(res));
 }
+/**
+ * #1708 — the panel's add-node guard polls `app.widgets` for a constructor. ComfyUI
+ * 1.49+ puts `getCustomWidgets()` results in the Pinia widget store, so
+ * AUTOCOMPLETE_TEXT_* (LoRA Manager Vue widgets) never appears there. The 5s wait
+ * always expires and the refusal names a reload that cannot help.
+ */
+function isLoraManagerAutocompleteRefusal(res) {
+    if (!res.isError)
+        return false;
+    const text = textOfToolResult(res);
+    return (/had no widget after .+ waiting for node extensions to register/i.test(text) &&
+        /AUTOCOMPLETE_TEXT_/i.test(text));
+}
+const LORA_MANAGER_AUTOCOMPLETE_NOTE = `\n\nThis is NOT a missing pack and NOT a widget that is still loading. ` +
+    `ComfyUI-LoRA-Manager registers AUTOCOMPLETE_TEXT_* via getCustomWidgets() into ` +
+    `the frontend widget store; the add-node guard only looks at app.widgets (core types), ` +
+    `so reload / panel_refresh_nodes / retry will keep failing. ` +
+    `Add "LoRA Text Loader (LoraManager)" instead — same MODEL/CLIP/trigger_words outputs, ` +
+    `but its lora_syntax input is a standard STRING socket you can drive with panel_set_widget ` +
+    `or a wired string. Core LoraLoader also works. Do not retry this class_type.`;
+function withLoraManagerAutocompleteNote(res) {
+    if (!isLoraManagerAutocompleteRefusal(res))
+        return res;
+    return appendToolResultText(res, LORA_MANAGER_AUTOCOMPLETE_NOTE);
+}
 function appendToolResultText(res, extra) {
     const idx = res?.content?.findIndex((c) => c.type === "text") ?? -1;
     const block = idx >= 0 ? res.content[idx] : undefined;
@@ -2395,6 +2489,62 @@ function appendToolResultText(res, extra) {
     content[idx] = { type: "text", text: `${block.text}${extra}` };
     return { ...res, content };
 }
+// ---- #1695: bound the panel_set_widget previous/new echo --------------------
+//
+// Code-mode clients (Codex `functions.exec`) batch several panel_set_widget
+// calls into one script, and the OUTER tool result accumulates every nested
+// reply. Each reply echoes the previous and new widget values verbatim; two
+// long CLIPTextEncode prompts per call push the aggregate past the client's
+// tool-result budget ("Output exceeded the available model context and was
+// truncated") even though every mutation succeeded — and the truncation can
+// hide exactly the per-call status the caller needs. The echo is confirmation,
+// not transport (a read-back belongs to panel_query_graph), so a long string
+// value is summarized server-side as { chars, sha256, preview }: the hash keeps
+// the confirmation verifiable, the preview keeps it legible, and `echo: "full"`
+// opts back into the verbatim reply.
+//
+// Server-side on purpose — the echo is produced by the panel frontend, and an
+// old panel keeps echoing verbatim no matter what a new one would do (the same
+// reason fitQueryGraphReply re-fits here, #807).
+const SET_WIDGET_ECHO_SUMMARY_THRESHOLD = 1000;
+const SET_WIDGET_ECHO_PREVIEW_CHARS = 160;
+function summarizeSetWidgetEcho(res, full) {
+    if (full || res.isError)
+        return res;
+    const payload = parseToolResultJson(res);
+    const set = payload?.set;
+    if (!payload || !set || typeof set !== "object" || Array.isArray(set))
+        return res;
+    const record = set;
+    const summarize = (v) => {
+        if (typeof v !== "string" || v.length <= SET_WIDGET_ECHO_SUMMARY_THRESHOLD)
+            return v;
+        return {
+            chars: v.length,
+            sha256: createHash("sha256").update(v, "utf8").digest("hex"),
+            preview: `${v.slice(0, SET_WIDGET_ECHO_PREVIEW_CHARS)}…`,
+        };
+    };
+    const previous = summarize(record.previous);
+    const value = summarize(record.value);
+    // Nothing crossed the threshold — return the reply untouched rather than
+    // dressing up an unfitted payload as a fitted one.
+    if (previous === record.previous && value === record.value)
+        return res;
+    const idx = res.content.findIndex((c) => c.type === "text");
+    if (idx < 0)
+        return res;
+    const fitted = {
+        ...payload,
+        set: { ...record, previous, value },
+        echo: "summary",
+        echo_full: 'Long string values were summarized as {chars, sha256, preview} so batched calls do not overflow the outer tool result; the mutation was applied. Re-call with echo: "full" for the verbatim strings, or read the live value back with panel_query_graph.',
+    };
+    return {
+        ...res,
+        content: res.content.map((c, i) => i === idx && c.type === "text" ? { ...c, text: JSON.stringify(fitted, null, 2) } : c),
+    };
+}
 // ---- #809: turn the panel's silent `truncated: true` booleans into a remedy --------
 //
 // A bare boolean is the WORST truncation signal there is: it is a field, not prose, so
@@ -3586,6 +3736,79 @@ function identityClaimedContentUnverifiedNote(detail) {
         `expecting the opened file. Retry the graph read (panel_graph_outline) once the tab answers.` +
         busy);
 }
+/**
+ * #1710 — restamp extra.comfyui_mcp onto the dest the tab is already bound to,
+ * and copy dest-file promoted widgets onto any live empty slots.
+ *
+ * Fail-closed: dest file unreadable, node-set mismatch, or a non-empty live
+ * widget that disagrees with dest (#1639 previous graph) leaves extra alone.
+ */
+async function tryRebindConfirmedOpenIdentity(ctx, destPath) {
+    let live = null;
+    try {
+        const serialized = await ctx.call({ cmd: "graph_serialize" }, 8000);
+        live = workflowFromSerializeReply(parseToolResultJson(serialized));
+    }
+    catch {
+        return { status: "skipped" };
+    }
+    if (!live)
+        return { status: "skipped" };
+    let dest;
+    try {
+        dest = await readWorkflowFromPath(destPath);
+    }
+    catch {
+        return { status: "skipped" };
+    }
+    if (!shouldRebindOpenIdentity({ live, dest, destPath }))
+        return { status: "skipped" };
+    const destUuid = await activeWorkflowUuidForPath(ctx, destPath);
+    const { graph, restoredWidgets } = patchOpenIdentity(live, dest, destPath, destUuid);
+    const loaded = await ctx.call({ cmd: "graph_load", graph }, 30000);
+    if (loaded.isError)
+        return { status: "skipped" };
+    if (destUuid)
+        refreshWorkflowUuid(ctx, { workflow_uuid: destUuid });
+    return { status: "rebound", destPath, destUuid, restoredWidgets };
+}
+async function activeWorkflowUuidForPath(ctx, destPath) {
+    try {
+        const list = parseToolResultJson(await ctx.call({ cmd: "workflow_list" }, 6000));
+        if (!list)
+            return undefined;
+        if (readOpenActiveAgainstTarget(list.active, destPath, list.active_confirmed) !== "same") {
+            return undefined;
+        }
+        return responseWorkflowUuid(list.active);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function activeSavedPath(ctx) {
+    try {
+        const list = parseToolResultJson(await ctx.call({ cmd: "workflow_list" }, 6000));
+        const path = isPlainObject(list?.active) ? list.active.path : undefined;
+        return typeof path === "string" && path ? path : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function openedIdentityReboundResult(destPath, rebound) {
+    return ok({
+        opened: { path: destPath },
+        identity_rebound: true,
+        restored_promoted_widgets: rebound.restoredWidgets,
+        note: `Opened ${destPath}. Frontend-normalized presentation/widget fields differed after load; ` +
+            `extra.comfyui_mcp.workflow_path/workflow_uuid were rebound to this workflow so a later ` +
+            `save will not refuse a source-stamp mismatch.` +
+            (rebound.restoredWidgets > 0
+                ? ` Restored ${rebound.restoredWidgets} empty promoted widget value(s) from the saved graph.`
+                : ""),
+    });
+}
 function identityClaimedButLiveGraphUnchangedNote(ctx) {
     const fence = currentWorkflowFence(ctx);
     const fenceTxt = fence.known && fence.uuid
@@ -3600,7 +3823,7 @@ function identityClaimedButLiveGraphUnchangedNote(ctx) {
         `Read the graph (panel_graph_outline) to see what is actually open, then retry ` +
         `panel_open_workflow or panel_load_workflow if the canvas did not switch.`);
 }
-async function clearFenceOnIdentityProvenOpen(ctx, res) {
+async function clearFenceOnIdentityProvenOpen(ctx, res, requestedPath) {
     const text = toolResultText(res);
     // ONLY the class that states identity was proven. The UNPROVEN verdict ("could not
     // prove that the active canvas was rebound") must keep failing closed: re-deriving a
@@ -3609,6 +3832,15 @@ async function clearFenceOnIdentityProvenOpen(ctx, res) {
         return { res, repaired: false };
     const canvas = await probeLiveGraphUnderCurrentFence(ctx);
     if (canvas.status === "answered") {
+        // #1710 — the old stamp still answering is ALSO what a save-as copy looks
+        // like: dest tab, dest nodes, extra.comfyui_mcp still naming the source.
+        // Confirm dest file content before touching extra (#1639 stays fail-closed).
+        if (requestedPath) {
+            const rebound = await tryRebindConfirmedOpenIdentity(ctx, requestedPath);
+            if (rebound.status === "rebound") {
+                return { res: openedIdentityReboundResult(requestedPath, rebound), repaired: true };
+            }
+        }
         return { res: appendToolResultText(res, identityClaimedButLiveGraphUnchangedNote(ctx)), repaired: false };
     }
     if (canvas.status === "unanswered") {
@@ -3793,6 +4025,20 @@ function responseWorkflowUuid(value) {
     return WORKFLOW_UUID_RE.test(raw) ? raw : undefined;
 }
 /** Refresh only the bridge-owned command stamp, never caller data. */
+/** #1656 — tell the orchestrator that a live read confirmed the routed tab's CURRENT
+ *  stamp, so a value inherited on a same-socket re-hello stops being treated as
+ *  inherited. Never throws, and can never move a fence (see the bridge method). */
+function corroborateTabStamp(ctx, workflowUuid) {
+    const fn = ctx.bridge.corroborateTabStamp;
+    if (typeof fn !== "function")
+        return false;
+    try {
+        return fn.call(ctx.bridge, ctx.tabId, workflowUuid) === true;
+    }
+    catch {
+        return false;
+    }
+}
 function refreshWorkflowUuid(ctx, value) {
     const uuid = responseWorkflowUuid(value);
     const refresh = ctx.bridge.refreshWorkflowUuid;
@@ -4295,8 +4541,29 @@ async function rebindWorkflowFence(ctx, opts) {
     // "already current" requires a KNOWN prior fence equal to the live uuid. An
     // UNKNOWN prior fence must not short-circuit the adoption: we would be claiming
     // the stamp already matched without ever having read it.
-    if (before.known && before.uuid === uuid)
+    if (before.known && before.uuid === uuid) {
+        // #1656 — THE FENCE DOES NOT MOVE HERE, BUT THE EVIDENCE DOES.
+        //
+        // Reaching this line means the panel's own corroborated workflow_list says the
+        // LIVE canvas is this very instance. If the routed tab's stamp was one CARRIED
+        // onto a new tab id by a same-socket re-hello that could not resolve an identity,
+        // that carried value has now been confirmed by an observation of the tab under its
+        // CURRENT id — so the dispatch-time agreement gate must stop treating it as
+        // inherited. Without this, a rename/save whose hello merely RACED the canvas
+        // identity would leave the session refusing edits to a canvas the panel agrees is
+        // the right one: the fix would be worse than the bug.
+        //
+        // This is NOT the retarget #1646 removed, and deliberately not `refreshWorkflowUuid`
+        // either — that one WRITES a stamp (and a conversation's issue-time stamp with it).
+        // `corroborateTabStamp` can only promote the provenance of a uuid the orchestrator
+        // has itself confirmed already equals the tab's current stamp; it writes no stamp and
+        // refuses outright when the values differ, so no target changes and no later edit is
+        // re-aimed. The uuid still goes through the orchestrator's identity validator, never
+        // off parsed prose, and the result is ignored: this is corroboration, and a diagnostic
+        // must never replace the outcome it is describing.
+        corroborateTabStamp(ctx, uuid);
         return { status: "already_current", uuid, before };
+    }
     // #1646 — a READ-ONLY probe never moves the fence: the live canvas naming a
     // DIFFERENT workflow is reported, not adopted. Only a deliberate rebind
     // (panel_set_workflow_target, open/new) may replace the fence — a mismatch
@@ -5051,7 +5318,7 @@ async function openWorkflowWithVerify(path, ctx) {
                 return res;
             const probe = await observeActiveAfterOpen(ctx, path);
             if (probe.status !== "different") {
-                const cleared = await clearFenceOnIdentityProvenOpen(ctx, res);
+                const cleared = await clearFenceOnIdentityProvenOpen(ctx, res, path);
                 // #1560 — the probe's SILENCE, reported. Suppressed when the fence was in fact
                 // repaired: that re-derivation is itself a `workflow_list` round trip, so a
                 // success there proves the channel answered and the note would contradict the
@@ -6769,7 +7036,47 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
             //
             // Safe to recommend a retry because a fence refusal is checked BEFORE the handler
             // runs — "Nothing was applied" is structural here, not an echoed claim.
-            if (isWorkflowInstanceMismatch(err) && isMutatingGraphCmd(cmd)) {
+            //
+            // #1778 — the same refusal on workflow_save / save_as / rename / close. Those
+            // carry a workflow target but are not graph_*, so neither isMutatingGraphCmd
+            // nor isFencedGraphRead was true and the call fell through to the generic
+            // dispatched:false wrapper: no probe, no corroborateTabStamp, and a
+            // "tab may be disconnected" line that is false here (the tab is connected;
+            // what is stale is the stamp). Widening this branch is the self-heal.
+            //
+            // THE PHRASE IS NOT THE STATE, AND TWO OTHER REFUSALS QUOTE IT.
+            //
+            // `isWorkflowInstanceMismatch` is an unanchored `/workflow instance mismatch/i`,
+            // and the fence is not the only thing that says those words. The bridge's
+            // `"<cmd>" cannot be safely targeted to the active workflow` reject quotes them
+            // inside its `readsNote` — to describe what a DIFFERENT command would get — and
+            // carries the second look-alike, `no trusted identity`, in its `why` clause.
+            // Both are minted pre-dispatch and flagged `dispatched:false`, so both satisfy
+            // the phrase match on their way through here.
+            //
+            // For a mutating graph edit that never surfaced, by ORDERING rather than by
+            // design: the #1401 branch catches `no trusted identity` for `isMutatingGraphCmd`
+            // above. The four active-workflow mutators have no branch above them, so the
+            // widening alone handed each of these two states the OTHER's remedy — measured,
+            // not reasoned. A capability refusal ending "Update the panel and hard-refresh
+            // the browser tab" came back with "Retry once — … panel_open_workflow is the way
+            // to settle which one you mean" appended to it: the futile retry #709 exists to
+            // suppress, contradicting the sentence directly above it, plus a wasted
+            // workflow_list round trip. And a fence-less session got #1330's "the fence
+            // already names the live canvas" for the state whose own docstring says "a
+            // mismatch may clear by itself, this never does".
+            //
+            // So the arm carries the discriminators the graph arm gets from ordering. Both
+            // are TYPED-or-explicit, never a second reading of the same prose:
+            // `isCapabilityRefusal` is the bridge's own symbol marker, and
+            // `isNoTrustedIdentityRefusal` matches a distinct phrase a mismatch refusal never
+            // contains. Scoped to THIS arm on purpose — `isMutatingGraphCmd` keeps its exact
+            // prior behaviour, so nothing about the graph path moves here.
+            if (isWorkflowInstanceMismatch(err) &&
+                (isMutatingGraphCmd(cmd) ||
+                    (isFencedActiveWorkflowMutator(cmd) &&
+                        !isCapabilityRefusal(err) &&
+                        !isNoTrustedIdentityRefusal(err)))) {
                 const name = typeof cmd.cmd === "string" ? cmd.cmd : "panel command";
                 const raw = err instanceof Error ? err.message : String(err);
                 // The uuid the command CARRIED, read from the panel's own refusal rather than
@@ -8788,7 +9095,7 @@ export function buildPanelToolDefs() {
                 },
             },
         ])),
-        def("panel_add_node", "Add a node to the user's OPEN ComfyUI graph by class_type (e.g. 'KSampler', 'CheckpointLoaderSimple'). The user sees it appear live; Ctrl+Z undoes it. Returns the created node's id, slots, and default widget values. Frontend-only virtual types are addable too: 'Note' and 'MarkdownNote' — the supported way to ANNOTATE a workflow with on-canvas instructions (add the node, then put the text in its 'text' widget via panel_set_widget) — plus 'Reroute' and 'PrimitiveNode'. These are LiteGraph-native and never appear in the backend node registry, so they legitimately bypass the backend class_type check. ADD NODES ONE AT A TIME, not as a parallel batch: each add carries a fresh /object_info payload and those register SERIALLY, so N concurrent adds become N sequential refresh cycles. On a large install that outruns the 30s per-command deadline and the later adds time out WHILE STILL QUEUED — they then apply when their turn arrives, leaving nodes you were told had failed (panel#767). Sequential adds each get the refresh to themselves and stay well inside the deadline.", {
+        def("panel_add_node", "Add a node to the user's OPEN ComfyUI graph by class_type (e.g. 'KSampler', 'CheckpointLoaderSimple'). The user sees it appear live; Ctrl+Z undoes it. Returns the created node's id, slots, and default widget values. Frontend-only virtual types are addable too: 'Note' and 'MarkdownNote' — the supported way to ANNOTATE a workflow with on-canvas instructions (add the node, then put the text in its 'text' widget via panel_set_widget) — plus 'Reroute' and 'PrimitiveNode'. These are LiteGraph-native and never appear in the backend node registry, so they legitimately bypass the backend class_type check. ComfyUI-LoRA-Manager's 'Lora Loader (LoraManager)' (and other AUTOCOMPLETE_TEXT_* nodes) cannot be added: the pack is healthy, but the add-node guard cannot see its Vue autocomplete widget. Use 'LoRA Text Loader (LoraManager)' — same outputs, lora_syntax is a STRING — or core LoraLoader; reload/retry will not clear it. ADD NODES ONE AT A TIME, not as a parallel batch: each add carries a fresh /object_info payload and those register SERIALLY, so N concurrent adds become N sequential refresh cycles. On a large install that outruns the 30s per-command deadline and the later adds time out WHILE STILL QUEUED — they then apply when their turn arrives, leaving nodes you were told had failed (panel#767). Sequential adds each get the refresh to themselves and stay well inside the deadline.", {
             class_type: z.string().describe("Exact ComfyUI node class_type to create."),
             pos: xy()
                 .optional()
@@ -8802,7 +9109,7 @@ export function buildPanelToolDefs() {
             const add = () => ctx.call({ cmd: "graph_add_node", class_type: args.class_type, pos: args.pos, title: args.title }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
             const first = await add();
             if (!isStaleNodeSchemaRefusal(first))
-                return first;
+                return withLoraManagerAutocompleteNote(first);
             // #1329 — DO THE REFRESH THE REFUSAL ASKS FOR, instead of billing the caller.
             //
             // The reporter uploaded two images, and both LoadImage adds were refused with
@@ -8820,19 +9127,19 @@ export function buildPanelToolDefs() {
                 // The refusal is the better error: it names what is wrong with the SCHEMA and
                 // what clears it. Carry the refresh failure alongside so the caller knows the
                 // automatic attempt happened and why it did not help.
-                return appendToolResultText(first, `\n\n(Tried to clear this automatically: panel_refresh_nodes was dispatched and FAILED, ` +
+                return withLoraManagerAutocompleteNote(appendToolResultText(first, `\n\n(Tried to clear this automatically: panel_refresh_nodes was dispatched and FAILED, ` +
                     `so the schema is unchanged and retrying the add will refuse again. ` +
-                    `${textOfToolResult(refreshed)})`);
+                    `${textOfToolResult(refreshed)})`));
             }
             const second = await add();
             if (!isStaleNodeSchemaRefusal(second))
-                return second;
+                return withLoraManagerAutocompleteNote(second);
             // Still stale after a successful refresh: report THAT, because it means the
             // remedy the refusal prescribes does not fix this instance and a caller
             // following it by hand would loop.
-            return appendToolResultText(second, `\n\n(This was already retried ONCE automatically: panel_refresh_nodes reported success ` +
+            return withLoraManagerAutocompleteNote(appendToolResultText(second, `\n\n(This was already retried ONCE automatically: panel_refresh_nodes reported success ` +
                 `and the add still refuses, so repeating panel_refresh_nodes will not clear it. ` +
-                `Reload the ComfyUI browser tab, which rebuilds the page's node registry from scratch.)`);
+                `Reload the ComfyUI browser tab, which rebuilds the page's node registry from scratch.)`));
         }),
         def("panel_remove_node", "Remove a node (and its connections) from the user's open graph by id. Undoable with Ctrl+Z.", { node_id: nodeId().describe("Node id from panel_graph_outline / panel_query_graph.") }, async (args, ctx) => ctx.call({ cmd: "graph_remove_node", node_id: args.node_id })),
         def("panel_clear", "Remove EVERY node from the user's open graph — only for an explicit 'clear/reset the canvas'. Just CALL THIS DIRECTLY when they ask to clear: the tool itself pops a confirm card and only wipes on a yes (don't ask separately first). The wipe is a single Ctrl+Z undo. NEVER use this for a 'new workflow' — that's panel_new_workflow (a new tab, leaves this graph intact).", {}, async (_args, ctx) => {
@@ -9227,7 +9534,7 @@ export function buildPanelToolDefs() {
             node_id: nodeId().describe("Node id whose input to disconnect."),
             input: slotRef.optional().describe("Input slot name or index (default 0)."),
         }, async (args, ctx) => ctx.call({ cmd: "graph_disconnect", node_id: args.node_id, input: args.input })),
-        def("panel_set_widget", "Set a widget value on a node in the user's open graph (steps, cfg, seed, ckpt_name, text prompts, …). Returns the previous and new value. Undoable with Ctrl+Z. To CLEAR a text widget to an empty string, pass `clear: true` (some MCP clients drop an empty-string `value` from the serialized payload, so `value: \"\"` may not arrive — `clear: true` always works). For the LTXDirector timeline node (WhatDreamsCost CSGlide), set `timeline_data` with the FULL timeline JSON (segments + global_prompt) to drive its custom timeline UI — this re-syncs the editor and regenerates its derived `local_prompts`/`segment_lengths`/`guide_strength` widgets; setting those derived widgets directly is refused (they are silently reverted).", {
+        def("panel_set_widget", "Set a widget value on a node in the user's open graph (steps, cfg, seed, ckpt_name, text prompts, …). Returns the previous and new value (a string longer than 1000 chars is echoed as {chars, sha256, preview} so batched calls stay inside the outer tool-result budget — pass `echo: \"full\"` for the verbatim string). Undoable with Ctrl+Z. To CLEAR a text widget to an empty string, pass `clear: true` (some MCP clients drop an empty-string `value` from the serialized payload, so `value: \"\"` may not arrive — `clear: true` always works). For the LTXDirector timeline node (WhatDreamsCost CSGlide), set `timeline_data` with the FULL timeline JSON (segments + global_prompt) to drive its custom timeline UI — this re-syncs the editor and regenerates its derived `local_prompts`/`segment_lengths`/`guide_strength` widgets; setting those derived widgets directly is refused (they are silently reverted).", {
             node_id: nodeId().describe("Node id from panel_graph_outline / panel_query_graph."),
             widget: z.string().describe("Widget name (e.g. 'steps', 'cfg', 'text')."),
             value: z
@@ -9238,6 +9545,10 @@ export function buildPanelToolDefs() {
                 .boolean()
                 .optional()
                 .describe("Set true to clear the widget to an empty string (\"\"). Escape hatch for when a client cannot carry an empty-string `value` through tool-arg JSON. Overrides `value`."),
+            echo: z
+                .enum(["summary", "full"])
+                .optional()
+                .describe("How to echo the previous/new values back. 'summary' (default) replaces a string longer than 1000 chars with {chars, sha256, preview} — the mutation is applied either way. 'full' returns the verbatim strings."),
         }, async (args, ctx) => {
             // Distinguish "value present but empty" from "value absent" by key
             // presence, NOT a truthiness check — an empty string is a legitimate
@@ -9251,7 +9562,14 @@ export function buildPanelToolDefs() {
             // a single revalidation, #338/#458) — that authoritative fetch can outlast
             // the 6000 ms default ack on a large install and return a FALSE timeout.
             // Give the guarded write the bounded refresh ack budget.
-            const write = (nodeId, widget) => ctx.call({ cmd: "graph_set_widget", node_id: nodeId, widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
+            // #1695: summarize the previous/new echo of every successful write
+            // (direct, remapped, or inner-subgraph) before anything else touches
+            // it — long prompts batched in one code-mode script otherwise overflow
+            // the outer tool result even though the mutations succeeded. Applied
+            // to the raw success reply so a later appendToolResultText disclosure
+            // (which makes the text no longer parse as JSON) cannot dodge it.
+            const echoFull = args.echo === "full";
+            const write = async (nodeId, widget) => summarizeSetWidgetEcho(await ctx.call({ cmd: "graph_set_widget", node_id: nodeId, widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS), echoFull);
             const first = await write(args.node_id, args.widget);
             if (!first.isError)
                 return first;
@@ -9871,6 +10189,13 @@ export function buildPanelToolDefs() {
                 }
             }
             const scope = args.scope ?? "orchestrator";
+            // #1700 — the frontend soft_reload only drops the websocket (this pack's
+            // /reload is a 503). The live agent keeps the MCP set it was spawned
+            // with, and a plain resume restores the session-recorded set anyway.
+            // Schedule a forked in-process respawn so makeMcpServers() re-reads
+            // ~/.claude.json and the replacement session is NOT the old MCP set.
+            if (scope === "orchestrator")
+                applyMcpReload?.(ctx.tabId);
             const res = await ctx.call({ cmd: "soft_reload", scope }, 15000);
             // #765 — the agent reads this result as its last context before the
             // reload, and again after the resume, so it is the place to state what
@@ -10599,9 +10924,23 @@ export function buildPanelToolDefs() {
             if (ctx.awaitReachable && !(await ctx.awaitReachable())) {
                 return noReachableTabFail(args.name ? "workflow_save_as" : "workflow_save", ctx);
             }
-            const res = args.name
-                ? await ctx.call({ cmd: "workflow_save_as", name: args.name }, 15000)
-                : await ctx.call({ cmd: "workflow_save" }, 15000);
+            const saveOnce = () => args.name
+                ? ctx.call({ cmd: "workflow_save_as", name: args.name }, 15000)
+                : ctx.call({ cmd: "workflow_save" }, 15000);
+            let res = await saveOnce();
+            // #1710 — dest tab + dest nodes, extra still stamped as the save-as SOURCE.
+            // Rebind extra to the confirmed dest, then retry the same save once.
+            if (res.isError && isStampMismatchSaveRefusal(toolResultText(res))) {
+                const destPath = await activeSavedPath(ctx);
+                if (destPath) {
+                    const rebound = await tryRebindConfirmedOpenIdentity(ctx, destPath);
+                    if (rebound.status === "rebound") {
+                        const retried = await saveOnce();
+                        if (!retried.isError)
+                            res = retried;
+                    }
+                }
+            }
             if (res.isError)
                 return res;
             // #1045 — a SAVE-AS replaces the active workflow instance: the canvas is
@@ -11040,19 +11379,50 @@ export function buildPanelToolDefs() {
                 //    known-negative write case is stated rather than papered over.
                 let probeRefused;
                 let probeOk = false;
-                try {
-                    // The cheapest fenced read there is: ids only, one row. It is refused by the
-                    // same instance fence every graph command carries, which is exactly the
-                    // question — a full outline would answer it no better and would cost the caller
-                    // a page of graph on a recovery path.
-                    const probe = await ctx.call({ cmd: "graph_query", fields: "ids", limit: 1 }, 8000);
-                    if (!probe.isError)
-                        probeOk = true;
-                    else
-                        probeRefused = isWorkflowInstanceMismatch(toolResultText(probe));
+                const probeOnce = async () => {
+                    probeRefused = undefined;
+                    probeOk = false;
+                    try {
+                        // The cheapest fenced read there is: ids only, one row. It is refused by the
+                        // same instance fence every graph command carries, which is exactly the
+                        // question — a full outline would answer it no better and would cost the caller
+                        // a page of graph on a recovery path.
+                        const probe = await ctx.call({ cmd: "graph_query", fields: "ids", limit: 1 }, 8000);
+                        if (!probe.isError)
+                            probeOk = true;
+                        else
+                            probeRefused = isWorkflowInstanceMismatch(toolResultText(probe));
+                    }
+                    catch (err) {
+                        probeRefused = isWorkflowInstanceMismatch(err);
+                    }
+                };
+                await probeOnce();
+                // #1703 — a passing graph_query is not evidence the NEXT graph command
+                // will route. After a restart the scope pin can still name the OLD
+                // wf:<route>:<path> while the reconnect has already hellod under a new
+                // one; ensureReachable will not move a scope-bound ctx, so claiming
+                // "no recovery needed" stranded the following panel_graph_outline with
+                // "no connected tab". Confirm the live route; if it is dead, take the
+                // same explicit rebind the caller would get from repeating this tool,
+                // and only then re-probe on the tab the next command will use.
+                if (probeOk && !sessionRouteIsLive(ctx)) {
+                    try {
+                        ctx.rebindToActiveTab?.({ scopeRecoveryConsent: true });
+                    }
+                    catch {
+                        // a failed rebind is not a fence verdict
+                    }
+                    if (sessionRouteIsLive(ctx))
+                        await probeOnce();
+                    else {
+                        probeOk = false;
+                        probeRefused = undefined;
+                    }
                 }
-                catch (err) {
-                    probeRefused = isWorkflowInstanceMismatch(err);
+                if (probeOk && !sessionRouteIsLive(ctx)) {
+                    probeOk = false;
+                    probeRefused = undefined;
                 }
                 if (probeOk) {
                     probePassed = true;
@@ -11476,7 +11846,15 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
             assertPanelNotTargetedUnverifiable("panel_update_node", args.id);
             return ctx.call({ cmd: "graph_update_node", id: args.id, version: args.version, channel: args.channel, mode: args.mode }, 30000);
         }),
-        def("panel_node_queue_status", "Check the built-in Manager's install/update queue status (to see if a queued install finished). Read-only.", {}, async (_args, ctx) => ctx.call({ cmd: "nodes_queue_status" }, 20000)),
+        def("panel_node_queue_status", "Check the built-in Manager's install/update queue status (to see if a queued install finished). Read-only. " +
+            "A drained queue (total_count: 0, is_processing: false) only means THIS queue is idle — " +
+            "it does not include apply_manifest custom_nodes that were never submitted (#1699). " +
+            "When apply_manifest returned a PARTIAL INSTALL, this tool names the leftover entries and " +
+            "sets queue_complete_for_apply_manifest:false; do not restart ComfyUI until those are " +
+            "submitted (re-run apply_manifest).", {}, async (_args, ctx) => {
+            const res = await ctx.call({ cmd: "nodes_queue_status" }, 20000);
+            return annotateQueueStatusWithManifestPartial(res);
+        }),
         def("panel_restart_comfyui", "Restart the user's ComfyUI server via the built-in Manager — needed to load newly installed/updated custom nodes. CALL THIS DIRECTLY when a restart is needed: it pops a confirm card and only restarts on a yes (don't ask separately first). ComfyUI and this agent go down briefly, then the panel auto-reconnects and you resume. ⚠️ BUSY GUARD: a restart ABORTS any in-progress or queued generation — if ComfyUI is generating, this tool REFUSES and tells you (it does NOT restart). When that happens, tell the user a render is running and WAIT for it (poll panel_node_queue_status), or pass force:true ONLY if the user explicitly confirms they want to kill the running generation. Best practice: before restarting after an install, check the queue is idle first. Only call when a restart is actually needed. If a crash takes the panel bridge offline so the confirmation card cannot be shown, this tool falls back to a headless restart of the configured local process (or COMFYUI_RESTART_COMMAND) instead of depending on the dead bridge — it still refuses a readable busy queue without force:true, and still refuses when a relaunch cannot be proven. On an externally-managed install whose relaunch can't be proven from here (e.g. Pinokio), the restart is REFUSED before anything is stopped — restart from the launcher that owns the server instead, or set COMFYUI_RESTART_COMMAND to the exact command that restarts the instance (e.g. `docker restart <container>`): the restart then runs through that command (the busy guard above still applies) instead of needing the launch path.", { force: z.boolean().optional() }, async ({ force }, ctx) => {
             // Whole-handler budget (#536): confirm + dispatch + readiness — INCLUDING
             // the legacy path's UNPREEMPTIBLE synchronous execSync blocks — must ALL finish