comfyui-mcp 0.51.6 → 0.51.7

package/dist/orchestrator/panel-tools.js

@@ -2960,10 +2960,15 @@ function currentWorkflowFence(ctx) {
  */
 function corroborateActiveForFence(parsed) {
     const active = parsed.active;
+    // Read once, up front, so every failure branch below can report it. Undefined
+    // whenever the record is missing, unreadable, or carries no usable uuid.
+    const seenUuid = active && typeof active === "object"
+        ? responseWorkflowUuid(active)
+        : undefined;
     if (!active || typeof active !== "object") {
         // SETTLES: mid-restore the frontend genuinely has no active workflow yet —
         // that is #1184's finding in this reply's terms, and it is the window here.
-        return { ok: false, why: "the reply carried no active-workflow record", settles: true };
+        return { ok: false, seenUuid, why: "the reply carried no active-workflow record", settles: true };
     }
     // #514: the panel says so itself when its active record is not confirmed. An
     // explicit `false` is the panel telling us the value is untrustworthy — never
@@ -2974,6 +2979,7 @@ function corroborateActiveForFence(parsed) {
         // and a moment later it says otherwise (#1292).
         return {
             ok: false,
+            seenUuid,
             why: "the panel reported its active workflow as UNCONFIRMED",
             settles: true,
         };
@@ -2987,6 +2993,7 @@ function corroborateActiveForFence(parsed) {
     if (!Array.isArray(list)) {
         return {
             ok: false,
+            seenUuid,
             why: "the reply carried no open-workflow list to corroborate the active record against",
             settles: false,
         };
@@ -2994,6 +3001,7 @@ function corroborateActiveForFence(parsed) {
     if (list.length === 0) {
         return {
             ok: false,
+            seenUuid,
             why: "the reply's open-workflow list was empty, so nothing corroborates the active record",
             settles: true,
         };
@@ -3005,6 +3013,7 @@ function corroborateActiveForFence(parsed) {
         // SETTLES: a snapshot taken before the panel re-flagged its active tab.
         return {
             ok: false,
+            seenUuid,
             why: "no entry in the open-workflow list is marked active",
             settles: true,
         };
@@ -3014,6 +3023,7 @@ function corroborateActiveForFence(parsed) {
         // uuid through, so it is refused rather than arbitrated.
         return {
             ok: false,
+            seenUuid,
             why: `${flaggedActive.length} entries in the open-workflow list are marked active (a mixed reply)`,
             // SETTLES: "mixed" IS the half-reconciled state, by definition.
             settles: true,
@@ -3026,6 +3036,7 @@ function corroborateActiveForFence(parsed) {
     if (verdict === false) {
         return {
             ok: false,
+            seenUuid,
             why: "the active record and the entry marked active in the open-workflow list name DIFFERENT workflows (a stale or mixed reply)",
             // SETTLES: a stale half of the snapshot catches up.
             settles: true,
@@ -3034,6 +3045,7 @@ function corroborateActiveForFence(parsed) {
     if (verdict !== true) {
         return {
             ok: false,
+            seenUuid,
             why: "the active record and the open-workflow list share no comparable identity field, so nothing corroborates it",
             // DOES NOT SETTLE: a field the records do not carry will not appear by
             // waiting — that is the reply's SHAPE, not its timing.
@@ -3208,6 +3220,7 @@ async function rebindWorkflowFence(ctx) {
             kind: "uncorroborated",
             why: corroborated.why,
             rechecks: { attempts, waitedMs, settles: corroborated.settles },
+            ...(corroborated.seenUuid ? { seenUuid: corroborated.seenUuid } : {}),
         };
     }
     const active = corroborated.active;
@@ -3579,6 +3592,39 @@ panelGapNote = "") {
                             `that is the answer.${remedy}`,
                     };
                 }
+                // #1401 — the SAME uuid is not the same situation.
+                //
+                // The gate is right to refuse an uncorroborated identity, and nothing here
+                // adopts one. What was wrong was the consequence asserted afterwards: when
+                // the identity the panel reported EQUALS the fence this session already
+                // holds, graph tools are not fenced to a different instance and generally
+                // keep working — the reporter's next call was a panel_graph_outline that
+                // succeeded, after being told it would keep failing and to hard-refresh.
+                //
+                // So this splits on evidence rather than reporting the worst case for both:
+                // a MATCHING uuid rules OUT the fenced-to-another-instance case without ruling
+                // IN liveness (codex: a stale/background record can carry the right uuid), so it
+                // reports what is ruled out and sends the caller to the read that settles it; a
+                // DIFFERENT or absent uuid keeps the original certain-failure wording.
+                const fenceStillMatches = r.status === "no_identity" && r.seenUuid !== undefined && r.seenUuid === r.before.uuid;
+                if (fenceStillMatches) {
+                    return {
+                        binding: "not_recovered",
+                        note: `${lead}. This session's fence was NOT re-derived, and whether that reply describes ` +
+                            `the LIVE canvas is exactly what could not be confirmed — a stale or background ` +
+                            `record can carry the right uuid and still not be the canvas in front of the user, ` +
+                            `so this is NOT a claim that graph tools work. What IS known is narrower and still ` +
+                            `useful: the identity it reported matches the fence this session already holds ` +
+                            `(${r.before.uuid}), so this is not the case where the session is fenced to a ` +
+                            `DIFFERENT workflow instance — which is the one that keeps graph tools failing.` +
+                            `
+
+WHAT TO DO: settle it with a graph read — call panel_graph_outline. That ` +
+                            `answers the question this could not: if it succeeds, the binding was fine and this ` +
+                            `was a reconciliation race. If it fails with a workflow-instance mismatch, the ` +
+                            `reply was stale after all — then ${RELOAD_TAB_REMEDY}`,
+                    };
+                }
                 return r.before.uuid
                     ? {
                         binding: "not_recovered",