@manny-est/node-red-flowpilot 0.5.1 → 0.6.0-beta.1

package/lib/core/apply-review.js

@@ -28,7 +28,21 @@
         // throwing) AND on disk (each string serializes with id
         // undefined -> null, confirmed via a live flows.json). Group
         // membership must only ever change through applyGroupChanges().
-        nodes: 1
+        nodes: 1,
+        // Node appearance/documentation fields and node-type-specific
+        // internal defaults that models hallucinate sentinel placeholders
+        // for during build-loop reviews. None of these are meaningfully
+        // settable via a Modify patch — they're either Appearance-tab
+        // metadata or type-internal runtime flags. Adding them here
+        // prevents false "redaction" blocks with no actionable remediation.
+        // Appearance/docs (all node types):
+        info: 1, inputLabels: 1, outputLabels: 1, icon: 1,
+        // debug node internal display flags:
+        console: 1, tostatus: 1, targetType: 1, statusVal: 1, statusType: 1,
+        // function node internal flags:
+        noerr: 1, initialize: 1, finalize: 1,
+        // mqtt in/out retain handling:
+        rh: 1
     };
 
     // Sentinel strings written by sanitizeNode (and redactDebugValue) for
@@ -112,8 +126,19 @@
     // existing nodes. Uses RED.nodes.add (the same path Node-RED's undo uses
     // internally for t:"add" events) and pushes one compound history entry so
     // a single Ctrl+Z removes both the new nodes and their wires together.
-    function applyInsertions(newNodes, newWires, contextNodeIds) {
-        if (!newNodes || !newNodes.length) { return; }
+    //
+    // historyEvents (optional, CLAUDE-027): when the caller passes a shared
+    // array here (an agentic run's own accumulator — see runAgentLoop in
+    // modes.js), the compound event below is collected into it INSTEAD of
+    // being pushed to RED.history directly, so the run's own flush can fold
+    // it together with every other WRITE-tool call this same run made into
+    // ONE RED.history entry (RED.history's native t:"multi" wrapper —
+    // confirmed via @node-red/editor-client's red.js, e.g. its
+    // deleteSelection()). Omitted (undefined), this behaves exactly as
+    // before — every other caller (classic Modify/Generate apply, the build
+    // loop) still gets its own immediate, standalone push.
+    function applyInsertions(newNodes, newWires, contextNodeIds, historyEvents) {
+        if ((!newNodes || !newNodes.length) && (!newWires || !newWires.length)) { return; }
 
         // Determine z (flow-tab id) from the active workspace.
         var z = "";
@@ -246,6 +271,57 @@
             });
         });
 
+        // Collision-avoidance stagger: independent components that happen to
+        // share the same anchor (e.g. several standalone new nodes each
+        // wired from/to the SAME existing node — "add 5 debug taps after
+        // this http request node") compute identical target coordinates
+        // above and land exactly on top of each other. Detect a component
+        // whose origin collides with an earlier one and nudge the WHOLE
+        // component (preserving its own internal layout) into a small grid
+        // offset from the first occupant, so multi-node insertions never
+        // pile invisibly at one point.
+        var occupiedOrigins = [];
+        function collidesWithOccupied(x, y) {
+            return occupiedOrigins.some(function (p) {
+                return Math.abs(p.x - x) < 20 && Math.abs(p.y - y) < 20;
+            });
+        }
+        Object.keys(componentAnchors).forEach(function (c) {
+            var members = laid.filter(function (n) { return componentOf[n.id] === c; });
+            if (!members.length) { return; }
+            var baseX = members.reduce(function (m, n) { return Math.min(m, n.x); }, members[0].x);
+            var baseY = members.reduce(function (m, n) { return Math.min(m, n.y); }, members[0].y);
+            // Walk a single-column grid outward from the natural origin
+            // until we find a slot nothing else already occupies — one
+            // node per row, never two at the same y (CLAUDE-012: Manny's
+            // original spec, which the earlier 2-wide grid still violated
+            // by putting a pair at the same vertical level). After 5 nodes
+            // in a column, wrap to a new column further right than the
+            // first node in the previous one, so wires stay visually
+            // distinguishable instead of stacking on top of each other.
+            var slot = 0;
+            var x = baseX, y = baseY;
+            while (collidesWithOccupied(x, y) && slot < 200) {
+                slot++;
+                x = baseX + Math.floor(slot / 5) * 250;
+                y = baseY + (slot % 5) * 90;
+            }
+            if (slot > 0) {
+                var dx = x - baseX, dy = y - baseY;
+                members.forEach(function (n) { n.x += dx; n.y += dy; });
+            }
+            occupiedOrigins.push({ x: x, y: y });
+        });
+
+        // B3: snapshot placeholder→type before ids are overwritten, so wire
+        // failure messages can name the placeholder id and type rather than the
+        // opaque real hex id the node was never given (node not inserted = id
+        // exists in idMap but never landed in the live graph).
+        var placeholderToType = {};
+        laid.forEach(function (n) {
+            if (placeholderIds[n.id]) { placeholderToType[n.id] = n.type || "?"; }
+        });
+
         // Build placeholder-id → real-id map and assign real ids + z.
         var idMap = {};
         laid.forEach(function (n) {
@@ -338,6 +414,15 @@
                     ? typeDef.outputs
                     : (Array.isArray(n.wires) ? n.wires.length : 0);
             }
+            // The model's "wires" array can disagree with the node type's
+            // real port count (e.g. a hallucinated single empty port on a
+            // 0-output type like http response) — the editor draws one
+            // anchor per n.wires entry regardless of n.outputs, so a
+            // mismatch renders a phantom port. Reconcile the array length
+            // to the authoritative n.outputs count now that it's resolved.
+            if (!Array.isArray(n.wires)) { n.wires = []; }
+            while (n.wires.length < n.outputs) { n.wires.push([]); }
+            if (n.wires.length > n.outputs) { n.wires.length = n.outputs; }
             // Apply type-definition defaults for any property the model omitted.
             // This covers required fields (e.g. statusVal/statusType on debug)
             // that oneditsave would normally set, preventing a spurious triangle.
@@ -396,7 +481,16 @@
             var fromNode = findLiveNode(fromId);
             var toNode = findLiveNode(toId);
             if (!fromNode || !toNode) {
-                addMessage("error", "Cannot wire — node not found: " + (!fromNode ? fromId : toId));
+                var _failRef = !fromNode ? wire.from : wire.to;
+                var _failMsg;
+                if (placeholderIds[_failRef]) {
+                    _failMsg = "Cannot wire — referenced node was not inserted (" +
+                        _failRef + " / type: " + (placeholderToType[_failRef] || "?") + ")";
+                } else {
+                    _failMsg = "Cannot wire — node not found in editor: " +
+                        (!fromNode ? fromId : toId);
+                }
+                addMessage("error", _failMsg);
                 return;
             }
             var fromPort = wire.fromPort || 0;
@@ -454,7 +548,7 @@
         // NB: for t:"add", ev.nodes must be an array of ID STRINGS — NR's undo
         // does RED.nodes.node(ev.nodes[i]) then reads .z, which throws (and
         // silently breaks Ctrl+Z) if given node objects instead of ids.
-        RED.history.push({
+        var insertHistoryEvent = {
             t: "add",
             nodes: addedNodes.map(function (n) { return n.id; }),
             links: addedLinks,
@@ -464,7 +558,8 @@
             subflowInputs: [],
             subflowOutputs: [],
             dirty: RED.nodes.dirty()
-        });
+        };
+        if (historyEvents) { historyEvents.push(insertHistoryEvent); } else { RED.history.push(insertHistoryEvent); }
 
         RED.nodes.dirty(true);
         RED.view.redraw(true);
@@ -524,12 +619,13 @@
         var propertyChanges = [];
         var wiresChanged = false;
         var redactionSkips = 0;
+        var redactedKeys = [];
         Object.keys(modNode).forEach(function (k) {
             if (DIFF_SKIP[k]) { return; }
             var newRaw = modNode[k];
             // If the model echoed a sanitizer sentinel, the field is opaque —
             // we can't meaningfully compare or apply it, so skip entirely.
-            if (isSanitizeSentinel(newRaw)) { redactionSkips++; return; }
+            if (isSanitizeSentinel(newRaw)) { redactionSkips++; redactedKeys.push(k); return; }
             var oldRaw = liveNode ? liveNode[k] : undefined;
             var oldStr, newStr;
             try { oldStr = JSON.stringify(oldRaw); } catch (e) { oldStr = String(oldRaw); }
@@ -538,7 +634,7 @@
             if (k === "wires") { wiresChanged = true; return; }
             propertyChanges.push({ key: k, oldVal: oldRaw, newVal: newRaw });
         });
-        return { propertyChanges: propertyChanges, wiresChanged: wiresChanged, redactionSkips: redactionSkips };
+        return { propertyChanges: propertyChanges, wiresChanged: wiresChanged, redactionSkips: redactionSkips, redactedKeys: redactedKeys };
     }
 
     // Diff outgoing wires for an existing node: compare what's live in the graph
@@ -642,6 +738,7 @@
                 propertyChanges: diff.propertyChanges,
                 wiresChanged: diff.wiresChanged,
                 redactionSkips: diff.redactionSkips,
+                redactedKeys: diff.redactedKeys,
                 wiresDiff: wiresDiff,
                 name: modNode.name || (liveNode && liveNode.name) || "",
                 type: modNode.type || (liveNode && liveNode.type) || ""
@@ -662,7 +759,7 @@
         var hasNewNodes = newNodes.length > 0;
         var hasRemoveNodes = removeNodes.length > 0;
         var hasNewGroups = newGroups.length > 0;
-        var hasAnyChanges = hasPropChanges || hasWireChanges || hasNewNodes || hasRemoveNodes || hasNewGroups;
+        var hasAnyChanges = hasPropChanges || hasWireChanges || hasNewNodes || hasRemoveNodes || hasNewGroups || (newWires && newWires.length > 0);
         var totalRedactionSkips = nodeDiffs.reduce(function (s, d) { return s + (d.redactionSkips || 0); }, 0);
 
         var $msg = $("<div>").addClass("fp-message fp-review");
@@ -715,15 +812,27 @@
         });
         if (redactionOnlyDiffs.length > 0) {
             var redSectionTop = hasPropChanges ? "12px" : "0";
-            $("<div>").addClass("fp-review-count").css("margin-top", redSectionTop)
-                .text("Not applied — targets redacted value(s):")
+            var totalRedFields = redactionOnlyDiffs.reduce(function (s, d) {
+                return s + (Array.isArray(d.redactedKeys) && d.redactedKeys.length ? d.redactedKeys.length : 1);
+            }, 0);
+            var $redToggle = $("<div>").addClass("fp-review-count")
+                .css({ "margin-top": redSectionTop, "cursor": "pointer" })
+                .text("▶ Not applied — FlowPilot can’t change these directly (" + totalRedFields + " field(s))")
                 .appendTo($summaryPanel);
+            var $redContent = $("<div>").addClass("fp-hidden").appendTo($summaryPanel);
+            $redToggle.on("click", function () {
+                var collapsed = $redContent.hasClass("fp-hidden");
+                $redContent.toggleClass("fp-hidden", !collapsed);
+                $redToggle.text((collapsed ? "▼" : "▶") + " Not applied — FlowPilot can’t change these directly (" + totalRedFields + " field(s))");
+            });
             redactionOnlyDiffs.forEach(function (d) {
-                var $section = $("<div>").addClass("fp-diff-node").appendTo($summaryPanel);
+                var $section = $("<div>").addClass("fp-diff-node").appendTo($redContent);
                 var title = d.type + (d.name ? " — \"" + d.name + "\"" : "");
                 $("<div>").addClass("fp-diff-node-title").text(title).appendTo($section);
+                var keys = Array.isArray(d.redactedKeys) && d.redactedKeys.length ? d.redactedKeys : [];
+                var fieldList = keys.length ? keys.join(", ") : "one or more fields";
                 $("<div>").addClass("fp-diff-warn")
-                    .text("Proposed change targets a redacted field — edit the value directly in the node editor.")
+                    .text("Cannot change “" + fieldList + "” — FlowPilot cannot read the live value for this field (internal node config). Edit it directly in the node editor if needed.")
                     .appendTo($section);
             });
         }
@@ -845,7 +954,7 @@
         if (!hasAnyChanges) {
             if (totalRedactionSkips > 0) {
                 $("<div>").addClass("fp-warning")
-                    .text("All proposed changes target redacted fields — FlowPilot can only see those values as placeholders. Edit the field(s) directly in the node editor, then retry for any remaining changes.")
+                    .text("None of the proposed changes could be applied — all targeted fields are internal node config that FlowPilot cannot read or modify directly. See the field names above and edit them in the node editor if needed.")
                     .appendTo($actions);
             } else {
                 $("<div>").addClass("fp-review-hint")
@@ -894,34 +1003,49 @@
             });
             $msg.attr("data-fp-record-id", _modRecord.id);
 
+            var hintParts = [];
+            if (hasPropChanges || hasWireChanges) { hintParts.push("changes mutate live nodes"); }
+            if (hasRemoveNodes) { hintParts.push("removals delete nodes"); }
+            if (hasNewGroups) { hintParts.push("groups are created/updated"); }
+            if (hasNewNodes) { hintParts.push("insertions add new nodes"); }
+            if (!hasNewNodes && newWires && newWires.length > 0) { hintParts.push("connections added"); }
+            var applySub = hintParts.length ? "Review above — " + hintParts.join(", ") + ". Ctrl+Z to undo." : "";
             var $applyBtn = $("<button>")
-                .addClass("red-ui-button red-ui-button-primary")
+                .addClass("fp-chip fp-chip-card")
                 .attr("type", "button")
-                .text(btnLabel)
                 .on("click", function () {
-                    $applyBtn.prop("disabled", true).text("Applying…");
+                    $applyBtn.prop("disabled", true);
+                    $applyTitle.text("Applying…");
                     // Insertions run FIRST so their placeholder→real-id map is
                     // available to applyModifications/applyGroupChanges — an
                     // existing node's rewired "wires" (Tier 3) or a new
                     // group's membership may point at a node being inserted
                     // in this same response.
                     var idMap = {};
-                    if (hasNewNodes) {
+                    var hasNewWires = newWires && newWires.length > 0;
+                    if (hasNewNodes || hasNewWires) {
                         idMap = applyInsertions(newNodes, newWires, nodes.map(function (n) { return n.id; })) || {};
                     }
-                    if (hasMutations && applyCallback) { applyCallback(nodeDiffs, removeNodes, null, idMap); }
+                    // W4 Phase 2: applyCallback also runs the verify read-back,
+                    // so it must fire for insertion-only Modifies too (no
+                    // property/wire change on an EXISTING node), not just when
+                    // hasMutations is true — otherwise "exists"/"wire" checks on
+                    // newly inserted nodes would never run.
+                    if ((hasMutations || hasNewNodes || hasNewWires) && applyCallback) {
+                        applyCallback(nodeDiffs, removeNodes, null, idMap);
+                    }
                     if (hasNewGroups) { applyGroupChanges(newGroups, idMap); }
                     if (_modRecord) { _modRecord.state = "applied"; }
-                    $applyBtn.text("Done ✓");
+                    $applyTitle.text("Done ✓");
                 });
+            $("<span>").addClass("fp-chip-icon")
+                .append($("<i>").addClass(buildFixInfo ? "fa fa-wrench" : "fa fa-check-circle"))
+                .appendTo($applyBtn);
+            var $applyBody = $("<span>").addClass("fp-chip-body").appendTo($applyBtn);
+            var $applyTitle = $("<span>").addClass("fp-chip-title").text(buildFixInfo ? "Apply Fix" : btnLabel).appendTo($applyBody);
+            $("<span>").addClass("fp-chip-sub").text(buildFixInfo && buildFixInfo.capReached ? "Apply final fix and stop the loop" : applySub).appendTo($applyBody);
+            $("<span>").addClass("fp-chip-go").html("&rsaquo;").appendTo($applyBtn);
             $actions.append($applyBtn);
-            var hintParts = [];
-            if (hasPropChanges || hasWireChanges) { hintParts.push("changes mutate live nodes"); }
-            if (hasRemoveNodes) { hintParts.push("removals delete nodes"); }
-            if (hasNewGroups) { hintParts.push("groups are created/updated"); }
-            if (hasNewNodes) { hintParts.push("insertions add new nodes"); }
-            var hintText = "Review above — " + hintParts.join(", ") + ". Ctrl+Z to undo.";
-            $("<span>").addClass("fp-review-hint").text(hintText).appendTo($actions);
         }
 
         $box.append($msg);
@@ -932,8 +1056,16 @@
     //   Tier 1 — property changes: mutate live node + {t:"edit"} history entry
     //   Tier 3 — wire changes: removeLink/addLink + {t:"add", removedLinks} entry
     //   Tier 4 — node removals: collect links, removeLink, remove node + {t:"delete"} entry
-    // One history entry per node per type so Ctrl+Z steps back through them cleanly.
-    function applyModifications(nodeDiffs, removeNodes, $applyBtn, idMap) {
+    // One history entry per node per type so Ctrl+Z steps back through them cleanly
+    // — UNLESS historyEvents (optional, CLAUDE-027) is passed: an agentic run's
+    // shared accumulator, into which every event below is collected instead of
+    // pushed immediately, so the run's own flush (runAgentLoop, modes.js) can
+    // fold ALL of this run's WRITE-tool calls together into ONE RED.history
+    // entry via t:"multi" — see applyInsertions' historyEvents doc above for
+    // the same mechanism. Every other caller (classic Modify/Generate apply,
+    // build loop) omits it and keeps this function's original per-node/per-
+    // type granularity unchanged.
+    function applyModifications(nodeDiffs, removeNodes, $applyBtn, idMap, historyEvents) {
         idMap = idMap || {};
         var propApplied = 0;
         var wireNodesApplied = 0;
@@ -949,7 +1081,17 @@
 
             var oldValues = {};
             d.propertyChanges.forEach(function (c) { oldValues[c.key] = liveNode[c.key]; });
-            d.propertyChanges.forEach(function (c) { liveNode[c.key] = c.newVal; });
+            d.propertyChanges.forEach(function (c) {
+                // Rewrite placeholder ids that point at newly-inserted config
+                // nodes (e.g. an MQTT out node's broker: "fp-new-0" referring
+                // to a new mqtt-broker in the same response's newNodes).
+                // applyInsertions returns idMap and it flows to us via the
+                // applyCallback chain — idMap[placeholder] is the real id.
+                var val = (idMap && typeof c.newVal === "string" && idMap[c.newVal])
+                    ? idMap[c.newVal]
+                    : c.newVal;
+                liveNode[c.key] = val;
+            });
 
             // Switch nodes derive their port count from rules.length (the edit
             // dialog's "outputCount" map assigns each rule its own output and
@@ -968,12 +1110,13 @@
 
             liveNode.changed = true;
             liveNode.dirty = true;
-            RED.history.push({
+            var editHistoryEvent = {
                 t: "edit",
                 node: liveNode,
                 changes: oldValues,
                 dirty: RED.nodes.dirty()
-            });
+            };
+            if (historyEvents) { historyEvents.push(editHistoryEvent); } else { RED.history.push(editHistoryEvent); }
             propApplied++;
         });
 
@@ -1029,12 +1172,13 @@
             });
 
             if (removedLinks.length || addedLinks.length) {
-                RED.history.push({
+                var wireHistoryEvent = {
                     t: "add",
                     links: addedLinks,
                     removedLinks: removedLinks,
                     dirty: RED.nodes.dirty()
-                });
+                };
+                if (historyEvents) { historyEvents.push(wireHistoryEvent); } else { RED.history.push(wireHistoryEvent); }
                 wireNodesApplied++;
             }
         });
@@ -1094,7 +1238,7 @@
                 }
             }
 
-            RED.history.push({
+            var removeHistoryEvent = {
                 t: "delete",
                 nodes: isJunction ? [] : [liveNode],
                 links: connectedLinks,
@@ -1104,7 +1248,8 @@
                 subflowInputs: [],
                 subflowOutputs: [],
                 dirty: RED.nodes.dirty()
-            });
+            };
+            if (historyEvents) { historyEvents.push(removeHistoryEvent); } else { RED.history.push(removeHistoryEvent); }
             nodesRemoved++;
         });
 
@@ -1652,19 +1797,72 @@
                 state: "pending"
             });
             $msg.attr("data-fp-record-id", _genRecord.id);
-            var $addBtn = $("<button>")
-                .addClass("red-ui-button red-ui-button-primary")
-                .attr("type", "button")
-                .text("Add to workspace")
-                .on("click", function () {
-                    $addBtn.prop("disabled", true).text("Click the canvas to place…");
-                    if (_genRecord) { _genRecord.state = "applied"; }
-                    importGeneratedFlow(nodes, onImported);
-                });
-            $actions.append($addBtn);
-            $("<span>").addClass("fp-review-hint")
-                .text("Opens Node-RED's normal place-at-cursor import — click the canvas to drop the nodes.")
-                .appendTo($actions);
+            if (onImported && buildGoal) {
+                // B1: primary deploy-and-verify chip (accent, full-width) + secondary
+                // plain escape hatch. Only when buildGoal is set — that signals this
+                // is a build-loop context, not just a plain post-import callback.
+                var $primaryChip = $("<button>")
+                    .addClass("fp-chip fp-chip-card")
+                    .attr("type", "button")
+                    .on("click", function () {
+                        $primaryChip.prop("disabled", true);
+                        $secondaryAddBtn.prop("disabled", true);
+                        if (_genRecord) { _genRecord.state = "applied"; }
+                        importGeneratedFlow(nodes, onImported);
+                    });
+                $("<span>").addClass("fp-chip-icon")
+                    .append($("<i>").addClass("fa fa-check-circle"))
+                    .appendTo($primaryChip);
+                var $chipBody = $("<span>").addClass("fp-chip-body").appendTo($primaryChip);
+                $("<span>").addClass("fp-chip-title").text("Deploy & verify this works →").appendTo($chipBody);
+                $("<span>").addClass("fp-chip-sub").text("Add to canvas, deploy, then run the verification loop").appendTo($chipBody);
+                $("<span>").addClass("fp-chip-go").html("&rsaquo;").appendTo($primaryChip);
+                $actions.append($primaryChip);
+                var $secondaryAddBtn = $("<button>")
+                    .addClass("fp-chip fp-chip-card fp-chip-card-alt")
+                    .attr("type", "button")
+                    .on("click", function () {
+                        $secondaryAddBtn.prop("disabled", true);
+                        $primaryChip.prop("disabled", true);
+                        if (_genRecord) { _genRecord.state = "applied"; }
+                        importGeneratedFlow(nodes, null);
+                    });
+                var $altBody = $("<span>").addClass("fp-chip-body").appendTo($secondaryAddBtn);
+                $("<span>").addClass("fp-chip-title").text("Just add to canvas").appendTo($altBody);
+                $("<span>").addClass("fp-chip-sub").text("Skips deploy & verification").appendTo($altBody);
+                $("<span>").addClass("fp-chip-go").html("&rsaquo;").appendTo($secondaryAddBtn);
+                $actions.append($secondaryAddBtn);
+            } else if (onImported) {
+                // Has a post-import callback (e.g. verifyImportedNodes) but no build
+                // loop — chip button that still fires the callback on import.
+                var $addBtn = $("<button>")
+                    .addClass("fp-chip fp-chip-card")
+                    .attr("type", "button")
+                    .on("click", function () {
+                        $addBtn.prop("disabled", true);
+                        if (_genRecord) { _genRecord.state = "applied"; }
+                        importGeneratedFlow(nodes, onImported);
+                    });
+                var $addBody = $("<span>").addClass("fp-chip-body").appendTo($addBtn);
+                $("<span>").addClass("fp-chip-title").text("Add to canvas").appendTo($addBody);
+                $("<span>").addClass("fp-chip-sub").text("Click the canvas to place the nodes").appendTo($addBody);
+                $("<span>").addClass("fp-chip-go").html("&rsaquo;").appendTo($addBtn);
+                $actions.append($addBtn);
+            } else {
+                var $addBtn = $("<button>")
+                    .addClass("fp-chip fp-chip-card")
+                    .attr("type", "button")
+                    .on("click", function () {
+                        $addBtn.prop("disabled", true);
+                        if (_genRecord) { _genRecord.state = "applied"; }
+                        importGeneratedFlow(nodes, null);
+                    });
+                var $addBody = $("<span>").addClass("fp-chip-body").appendTo($addBtn);
+                $("<span>").addClass("fp-chip-title").text("Add to canvas").appendTo($addBody);
+                $("<span>").addClass("fp-chip-sub").text("Click the canvas to place the nodes").appendTo($addBody);
+                $("<span>").addClass("fp-chip-go").html("&rsaquo;").appendTo($addBtn);
+                $actions.append($addBtn);
+            }
         }
 
         $box.append($msg);
@@ -1867,12 +2065,21 @@
                 : hasMutations ? "Apply Changes"
                 : hasNewNodes ? "Insert Nodes"
                 : "Apply Changes";
-            var $applyBtn = $("<button>").addClass("red-ui-button red-ui-button-primary")
-                .attr("type", "button").text(btnLabel)
+            var hintParts = [];
+            if (hasPropChanges || hasWireChanges) { hintParts.push("changes mutate live nodes"); }
+            if (hasRemoveNodes) { hintParts.push("removals delete nodes"); }
+            if (hasNewGroups) { hintParts.push("groups are created/updated"); }
+            if (hasNewNodes) { hintParts.push("insertions add new nodes"); }
+            if (!hasNewNodes && newWires && newWires.length > 0) { hintParts.push("connections added"); }
+            var applySub = hintParts.length ? "Review above — " + hintParts.join(", ") + ". Ctrl+Z to undo." : "";
+            var $applyBtn = $("<button>")
+                .addClass("fp-chip fp-chip-card")
+                .attr("type", "button")
                 .on("click", function () {
-                    $applyBtn.prop("disabled", true).text("Applying…");
+                    $applyBtn.prop("disabled", true);
+                    $applyTitle.text("Applying…");
                     var idMap = {};
-                    if (hasNewNodes) { idMap = applyInsertions(newNodes, newWires, existingIds) || {}; }
+                    if (hasNewNodes || (newWires && newWires.length > 0)) { idMap = applyInsertions(newNodes, newWires, existingIds) || {}; }
                     if (isBuildFix) {
                         applyBuildLoopFix(nodeDiffs, removeNodes, idMap, capReached);
                     } else {
@@ -1880,19 +2087,16 @@
                         if (hasNewGroups) { applyGroupChanges(newGroups, idMap); }
                     }
                     if (_newRec) { _newRec.state = "applied"; }
-                    $applyBtn.text("Done ✓");
+                    $applyTitle.text("Done ✓");
                 });
+            $("<span>").addClass("fp-chip-icon")
+                .append($("<i>").addClass(isBuildFix ? "fa fa-wrench" : "fa fa-check-circle"))
+                .appendTo($applyBtn);
+            var $applyBody = $("<span>").addClass("fp-chip-body").appendTo($applyBtn);
+            var $applyTitle = $("<span>").addClass("fp-chip-title").text(isBuildFix ? "Apply Fix" : btnLabel).appendTo($applyBody);
+            $("<span>").addClass("fp-chip-sub").text(isBuildFix && capReached ? "Apply final fix and stop the loop" : applySub).appendTo($applyBody);
+            $("<span>").addClass("fp-chip-go").html("&rsaquo;").appendTo($applyBtn);
             $actions.append($applyBtn);
-            var hintParts = [];
-            if (hasPropChanges || hasWireChanges) { hintParts.push("changes mutate live nodes"); }
-            if (hasRemoveNodes) { hintParts.push("removals delete nodes"); }
-            if (hasNewGroups) { hintParts.push("groups are created/updated"); }
-            if (hasNewNodes) { hintParts.push("insertions add new nodes"); }
-            if (hintParts.length) {
-                $("<span>").addClass("fp-review-hint")
-                    .text("Review above — " + hintParts.join(", ") + ". Ctrl+Z to undo.")
-                    .appendTo($actions);
-            }
         }
 
         $box.append($msg);

package/lib/core/graph-truth.js

@@ -0,0 +1,63 @@
+    // P10-E (ADR-005): the single implementation of graph truth. Every
+    // verification consumer — runSingleVerifyCheck's per-check-type
+    // dispatch (modes.js), the WRITE-tool tool_result checks
+    // (runChecksForToolResult, main.js), verifyImportedNodes (modes.js),
+    // and group_nodes's post-check (main.js) — delegates here instead of
+    // re-reading RED.nodes/RED.nodes.eachLink locally. Wires are read
+    // exclusively via RED.nodes.eachLink, never node.wires: addLink/
+    // removeLink never re-sync a live node's own .wires array mid-session
+    // (CLAUDE-010 — the drift this module exists to prevent from
+    // recurring). Diff computation (apply-review.js's computeWireDiff and
+    // its own eachLink scans) is a different concern — "what changed" vs.
+    // "is this true right now" — and stays out of scope per ADR-005.
+
+    function nodeExists(id) {
+        return !!RED.nodes.node(id);
+    }
+
+    function nodeAbsent(id) {
+        return !RED.nodes.node(id);
+    }
+
+    function propertyEquals(id, key, want) {
+        var node = RED.nodes.node(id);
+        return !!node && node[key] === want;
+    }
+
+    // Read-only counterpart to propertyEquals, for diagnostics that need to
+    // show the actual current value alongside the expected one (CLAUDE-018)
+    // rather than just a boolean match. Returns { exists, value } — value is
+    // undefined when the node doesn't exist so callers can tell "no node"
+    // apart from "property is actually undefined".
+    function readProperty(id, key) {
+        var node = RED.nodes.node(id);
+        return { exists: !!node, value: node ? node[key] : undefined };
+    }
+
+    function wireExists(fromId, port, toId) {
+        var found = false;
+        RED.nodes.eachLink(function (l) {
+            if (found) { return; }
+            if (l.source && l.source.id === fromId &&
+                    (l.sourcePort || 0) === (port || 0) &&
+                    l.target && l.target.id === toId) {
+                found = true;
+            }
+        });
+        return found;
+    }
+
+    function wireAbsent(fromId, port, toId) {
+        return !wireExists(fromId, port, toId);
+    }
+
+    // ids: a single node id or an array of ids — true only if every one of
+    // them currently belongs to groupId (per its live .g ref).
+    function groupContains(groupId, ids) {
+        var list = Array.isArray(ids) ? ids : [ids];
+        if (!list.length) { return false; }
+        return list.every(function (id) {
+            var node = RED.nodes.node(id);
+            return !!node && node.g === groupId;
+        });
+    }

package/lib/core/history.js

@@ -17,10 +17,19 @@
         return id;
     }
 
+    // CLAUDE-029: whether conversationId above came from an existing
+    // sessionStorage entry (a page reload continuing a prior conversation)
+    // rather than being freshly minted — drives whether page init rehydrates
+    // the Chat panel from the server. See rehydrateConversationOnLoad().
+    var conversationIdWasRestored = false;
+
     var conversationId = (function () {
         try {
             var existing = sessionStorage.getItem("fp-conversation-id");
-            if (existing) { return existing; }
+            if (existing) {
+                conversationIdWasRestored = true;
+                return existing;
+            }
         } catch (e) { /* storage unavailable */ }
         return newConversationId();
     })();