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

package/lib/agent-contract.js

@@ -0,0 +1,45 @@
+"use strict";
+
+// ---------------------------------------------------------------------
+// The agent-strategy contract: a "strategy":"agent" turn is only ever
+// allowed to mutate the flow via a WRITE tool call, never via the classic
+// JSON-envelope mutation fields (changes/newNodes/newWires/removeNodes/
+// newGroups). If a model still emits those fields on a turn that made no
+// tool calls, strip them before the response reaches the client and log
+// what was stripped — the two mutation code paths (classic envelope vs.
+// agentic WRITE tools) must stay mutually exclusive per agent turn.
+// Classic-strategy turns and turns that DID make tool calls are untouched
+// by design (guard clause below) — this only fires on the one contract-
+// violating shape it exists to catch.
+// ---------------------------------------------------------------------
+
+const AGENT_MUTATION_FIELDS = ["changes", "newNodes", "newWires", "removeNodes", "newGroups"];
+
+function enforceAgentContract(result, execution, hasToolCalls) {
+  if (!result || !execution || execution.strategy !== "agent" || hasToolCalls) {
+    return result;
+  }
+
+  const strippedFields = [];
+  const counts = {};
+  AGENT_MUTATION_FIELDS.forEach(function (field) {
+    if (!Object.prototype.hasOwnProperty.call(result, field)) { return; }
+    strippedFields.push(field);
+    counts[field] = Array.isArray(result[field]) ? result[field].length : 1;
+    delete result[field];
+  });
+
+  if (strippedFields.length) {
+    result.strippedFields = strippedFields;
+    console.warn(
+      "[FlowPilot] agent contract stripped mutation fields strategy=%s entry=%s conversationId=%s counts=%s",
+      execution.strategy,
+      execution.entry,
+      execution.conversationId || "none",
+      JSON.stringify(counts)
+    );
+  }
+  return result;
+}
+
+module.exports = { enforceAgentContract, AGENT_MUTATION_FIELDS };

package/lib/build-core-script.js

@@ -22,6 +22,7 @@ const FRAGMENT_ORDER = [
   "markdown.js",
   "selection-context.js",
   "apply-review.js",
+  "graph-truth.js",
   "modes.js",
   "main.js",
   "init.js"

package/lib/chat-data.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const { findMatchingBrace } = require("./envelope");
+
+const CHAT_DATA_MARKER = "<<<FLOWPILOT_DATA>>>";
+const CHAT_DATA_MARKER_RE = /<<<\s{0,8}FLOWPILOT_DATA\s{0,8}>>>/i;
+const CHAT_DATA_MARKER_MAX_SCAN = 40;
+
+function stripTrailingDataFence(text) {
+  return String(text || "")
+    .replace(/(?:\r?\n)?```(?:json)?[ \t]*(?:\r?\n)?$/i, "")
+    .replace(/\s+$/, "");
+}
+
+function stripLeadingDataFence(text) {
+  return String(text || "")
+    .replace(/^\s*```(?:json)?[ \t]*\r?\n?/i, "")
+    .replace(/\s*```[\s\r\n]*$/i, "")
+    .trim();
+}
+
+function findChatDataMarker(text) {
+  const source = String(text || "");
+  const match = CHAT_DATA_MARKER_RE.exec(source);
+  if (!match) { return null; }
+  return {
+    index: match.index,
+    marker: match[0]
+  };
+}
+
+function parseChatDataObject(text) {
+  const source = stripLeadingDataFence(text);
+  const firstBrace = source.indexOf("{");
+  if (firstBrace === -1) { return null; }
+  const end = findMatchingBrace(source, firstBrace);
+  if (end === -1) { return null; }
+  try {
+    return JSON.parse(source.slice(firstBrace, end + 1));
+  } catch (e) {
+    return null;
+  }
+}
+
+function stripChatDataFromVisibleText(content) {
+  const text = String(content || "");
+  const found = findChatDataMarker(text);
+  if (!found) { return text; }
+  return stripTrailingDataFence(text.slice(0, found.index));
+}
+
+function splitChatDataBlock(content) {
+  const text = String(content || "");
+  const found = findChatDataMarker(text);
+  if (!found) { return { message: text, data: null }; }
+
+  const message = stripTrailingDataFence(text.slice(0, found.index));
+  const data = parseChatDataObject(text.slice(found.index + found.marker.length));
+  return { message: message, data: data };
+}
+
+function createChatDataStreamSplitter() {
+  let held = "";
+  let inData = false;
+  let dataBuf = "";
+
+  function push(delta) {
+    if (inData) { dataBuf += delta; return ""; }
+
+    const combined = held + String(delta || "");
+    const found = findChatDataMarker(combined);
+    if (found) {
+      inData = true;
+      dataBuf = combined.slice(found.index + found.marker.length);
+      held = "";
+      return stripTrailingDataFence(combined.slice(0, found.index));
+    }
+
+    if (combined.length <= CHAT_DATA_MARKER_MAX_SCAN) {
+      held = combined;
+      return "";
+    }
+    held = combined.slice(-CHAT_DATA_MARKER_MAX_SCAN);
+    return combined.slice(0, -CHAT_DATA_MARKER_MAX_SCAN);
+  }
+
+  function finish() {
+    const tail = inData ? "" : held;
+    held = "";
+    const data = inData ? parseChatDataObject(dataBuf) : null;
+    return {
+      tail: inData ? "" : stripChatDataFromVisibleText(tail),
+      data: data
+    };
+  }
+
+  return { push: push, finish: finish };
+}
+
+module.exports = {
+  CHAT_DATA_MARKER,
+  createChatDataStreamSplitter,
+  findChatDataMarker,
+  splitChatDataBlock,
+  stripChatDataFromVisibleText
+};

package/lib/core/apply-review.js

@@ -126,7 +126,18 @@
     // 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) {
+    //
+    // 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.
@@ -537,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,
@@ -547,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);
@@ -1044,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;
@@ -1090,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++;
         });
 
@@ -1151,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++;
             }
         });
@@ -1216,7 +1238,7 @@
                 }
             }
 
-            RED.history.push({
+            var removeHistoryEvent = {
                 t: "delete",
                 nodes: isJunction ? [] : [liveNode],
                 links: connectedLinks,
@@ -1226,7 +1248,8 @@
                 subflowInputs: [],
                 subflowOutputs: [],
                 dirty: RED.nodes.dirty()
-            });
+            };
+            if (historyEvents) { historyEvents.push(removeHistoryEvent); } else { RED.history.push(removeHistoryEvent); }
             nodesRemoved++;
         });
 

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();
     })();

package/lib/core/init.js

@@ -24,7 +24,8 @@
         "- `/build` — describe a goal; I'll plan, propose, and walk an iterative build → deploy → debug → review → fix loop with you\n" +
         "- `/compact` — hide labels on the selected node(s) (icon-only); `/expand` restores them. Instant, no AI involved — one Ctrl+Z undoes it.\n" +
         "- `/disable` — disable the selected node(s) (skipped on Deploy); `/enable` re-enables them. Instant, no AI involved — one Ctrl+Z undoes it.\n" +
-        "- `/refresh` — re-render all messages from the in-memory record store (restores interactive Apply buttons if they were lost).\n\n" +
+        "- `/refresh` — re-render all messages from the in-memory record store (restores interactive Apply buttons if they were lost).\n" +
+        "- `/debug` — toggle debug logging (full prompts/replies/decisions to `flowpilot/debug.log`) on/off. Instant, no AI involved.\n\n" +
         "### Also worth knowing\n\n" +
         "- Action chips (paper-plane buttons) offer a one-click follow-up — review and send, nothing fires automatically.\n" +
         "- When I ask a clarifying question, I'll often offer quick-reply buttons (plus \"Other\" for your own answer) — clicking one sends it right away.\n" +
@@ -64,6 +65,7 @@
         { cmd: "/disable",  desc: "Disable selected nodes" },
         { cmd: "/enable",   desc: "Enable selected nodes" },
         { cmd: "/refresh",  desc: "Re-render all messages from shadow record store" },
+        { cmd: "/debug",    desc: "Toggle debug logging on/off" },
         { cmd: "/demo",     desc: "Type in a demo prompt" },
         { cmd: "/help",     desc: "Show all available commands" },
         { cmd: "/feedback", desc: "Show feedback info" }
@@ -237,6 +239,17 @@
                 refreshView();
                 if ($promptBox.length) { $promptBox.val(""); }
                 break;
+            // Deterministic, no AI round-trip: flips the same
+            // settings.debugLogging field the Hangar checkbox binds to, via
+            // the normal saveSettings() round trip, so the two never drift.
+            case "/debug":
+                var newDebugState = !el("#fp-debug-logging").prop("checked");
+                el("#fp-debug-logging").prop("checked", newDebugState);
+                saveSettings(function () {
+                    addMessage("assistant", "Debug logging is now " + (newDebugState ? "ON" : "OFF") + ".");
+                });
+                if ($promptBox.length) { $promptBox.val(""); }
+                break;
             // Deterministic, no LLM round-trip: just invokes Node-RED's own
             // native "show/hide selected node labels" action (RED.actions
             // "core:show-selected-node-labels" / "core:hide-selected-node-
@@ -567,7 +580,7 @@
             $panel.data("fp-review-apply-bound", true);
             var recordId = parseInt($panel.attr("data-fp-record-id"), 10);
             if (isNaN(recordId)) { return; }
-            $panel.find(".fp-review-actions button.red-ui-button-primary").on("click", function () {
+            $panel.find(".fp-review-actions button.fp-chip.fp-chip-card:not(:disabled)").on("click", function () {
                 var $btn = $(this);
                 if ($btn.prop("disabled")) { return; }
                 $btn.prop("disabled", true).text("Applying…");
@@ -579,6 +592,50 @@
         });
     }
 
+    // Interactive question/consent buttons are cloned into the pop-out as
+    // HTML, so their main-window click closures do not survive. Relay the
+    // record id plus the selected action back to the parent, where the live
+    // record still owns the continuation callback/state.
+    function bindRecordActionButtons($scope) {
+        $scope.filter("[data-fp-record-id]").add($scope.find("[data-fp-record-id]"))
+            .filter("button").each(function () {
+                var $btn = $(this);
+                if ($btn.data("fp-record-action-bound") || $btn.prop("disabled")) { return; }
+                var recordId = parseInt($btn.attr("data-fp-record-id"), 10);
+                var action = $btn.attr("data-fp-record-action");
+                if (isNaN(recordId) || !action) { return; }
+                $btn.data("fp-record-action-bound", true).on("click", function () {
+                    if (action === "show-other") {
+                        $btn.closest(".fp-question-row").next(".fp-question-other-row")
+                            .removeClass("fp-hidden").find("input").focus();
+                        return;
+                    }
+                    var relayAction = action;
+                    var value = $btn.attr("data-fp-record-value") || "";
+                    if (action === "answer-other") {
+                        value = $btn.siblings("input").val().trim();
+                        if (!value) { return; }
+                        relayAction = "answer";
+                    }
+                    var $questionRow = $btn.closest(".fp-question-row");
+                    var $otherRow = $btn.closest(".fp-question-other-row");
+                    $questionRow.find("button, input").prop("disabled", true);
+                    $questionRow.next(".fp-question-other-row").find("button, input").prop("disabled", true);
+                    $otherRow.find("button, input").prop("disabled", true);
+                    $otherRow.prev(".fp-question-row").find("button, input").prop("disabled", true);
+                    if (!window.opener || window.opener.closed) { return; }
+                    try {
+                        window.opener.postMessage({
+                            event: "resolveRecordAction",
+                            recordId: recordId,
+                            action: relayAction,
+                            value: value
+                        }, location.origin);
+                    } catch (e) { /* ignore */ }
+                });
+            });
+    }
+
     // The loop stepper's "Stop build loop" button is relayed the same
     // generic way as any other chat message (renderLoopStepper appends/
     // replaces a #fp-loop-stepper element, which the MutationObserver
@@ -830,6 +887,7 @@
             if (data.event === "initialSync") {
                 el("#fp-messages").html(data.html);
                 bindReviewApplyButtons(el("#fp-messages"));
+                bindRecordActionButtons(el("#fp-messages"));
                 bindStopLoopButton(el("#fp-messages"));
                 bindTabSwitching(el("#fp-messages"));
                 bindDebugAttachButtons(el("#fp-messages"));
@@ -837,6 +895,7 @@
             } else if (data.event === "appendMessage") {
                 el("#fp-messages").append(data.html);
                 bindReviewApplyButtons(el("#fp-messages").children().last());
+                bindRecordActionButtons(el("#fp-messages").children().last());
                 bindStopLoopButton(el("#fp-messages").children().last());
                 bindTabSwitching(el("#fp-messages").children().last());
                 bindDebugAttachButtons(el("#fp-messages").children().last());
@@ -1034,8 +1093,8 @@
                 '      </div>' +
 
                 '      <div class="fp-settings-section">Personality</div>' +
-                '      <label>Persona intensity: <span id="fp-persona-value">3</span>/10</label>' +
-                '      <input id="fp-persona-intensity" type="range" min="1" max="10" step="1">' +
+                '      <label>Persona intensity: <span id="fp-persona-value">2</span>/5</label>' +
+                '      <input id="fp-persona-intensity" type="range" min="1" max="5" step="1">' +
                 '      <div id="fp-persona-label" class="fp-consent-hint"></div>' +
                 '      <div class="fp-consent-hint">Chat only. Scales the AI\'s voice at greetings, ' +
                 '        capability questions, and brief transitions — 1 is a plain Node-RED engineer, ' +
@@ -1062,10 +1121,14 @@
 
                 '      <div class="fp-settings-section">Request timeout</div>' +
                 '      <label>Give up after (seconds)</label>' +
-                '      <input id="fp-request-timeout" type="number" min="5" step="5" placeholder="180">' +
+                '      <input id="fp-request-timeout" type="number" step="any" placeholder="180">' +
                 '      <div class="fp-consent-hint">How long to wait for a provider response before ' +
                 '        giving up. Raise this if you\'re running a large local model on slow hardware ' +
                 '        (e.g. Ollama without a GPU) and seeing timeout errors.</div>' +
+                '      <label>Max tokens per agent turn</label>' +
+                '      <input id="fp-agent-turn-max-tokens" type="number" min="1" max="65536" step="1" placeholder="4096">' +
+                '      <div class="fp-consent-hint">Hard output limit for each tool-calling agent step. ' +
+                '        Classic (no-tools) requests are not capped.</div>' +
 
                 '      <div class="fp-settings-section">Agentic build loop</div>' +
                 '      <label>Max build/fix attempts</label>' +
@@ -1125,6 +1188,15 @@
                 '        sent either way. To disable, check the box and type ' +
                 '        <strong>disable redaction</strong> below.</div>' +
                 '      <input id="fp-redaction-confirm" type="text" placeholder="Type: disable redaction">' +
+
+                '      <div class="fp-settings-section">Debug mode</div>' +
+                '      <label class="fp-checkbox-row">' +
+                '        <input id="fp-debug-logging" type="checkbox"> ' +
+                '        Debug mode' +
+                '      </label>' +
+                '      <div class="fp-consent-hint">Logs full prompts, replies, and decisions to ' +
+                '        <code>flowpilot/debug.log</code> for troubleshooting. Off by default — ' +
+                '        this file can get large.</div>' +
                 '      </details>' +
 
                 '      <div class="fp-settings-actions">' +
@@ -1287,6 +1359,13 @@
             RED.events.on("deploy", function () {
                 if (activeBuildLoop && activeBuildLoop.waypoint === "apply") {
                     activeBuildLoop.waypoint = "attach";
+                    // CLAUDE-025: marks the start of THIS attempt's own
+                    // evidence window — see freshBuildLoopEvidence. Anything
+                    // that arrived before this (a prior attempt's debug
+                    // output, a manual attach, an unrelated still-running
+                    // flow) is stale and must not count toward this
+                    // attempt's own goal.
+                    activeBuildLoop.deployedAt = Date.now();
                     renderLoopStepper(activeBuildLoop);
                     // Start a timer so flows with no debug nodes (e.g. HTTP
                     // endpoints) don't leave the loop stuck silently waiting.
@@ -1368,6 +1447,36 @@
                         }
                         rec.state = "applied";
                     }
+                } else if (data.event === "resolveRecordAction" && typeof data.recordId === "number") {
+                    var actionRec = null;
+                    for (var ai = 0; ai < messageRecords.length; ai++) {
+                        if (messageRecords[ai].id === data.recordId) { actionRec = messageRecords[ai]; break; }
+                    }
+                    if (actionRec && actionRec.kind === "question" && !actionRec.decision) {
+                        if (actionRec.buildConsentGate && (data.action === "proceed" || data.action === "skip")) {
+                            actionRec.decision = data.action;
+                            runBuildConsentDecision(actionRec, data.action === "proceed");
+                        } else if (actionRec.agentToolConsent && (data.action === "proceed" || data.action === "skip")) {
+                            actionRec.decision = data.action;
+                            if (typeof actionRec.onResume === "function") { actionRec.onResume(data.action === "proceed"); }
+                        } else if (actionRec.askUserTool && data.action === "answer") {
+                            actionRec.decision = "answered";
+                            actionRec.answerText = String(data.value || "");
+                            if (typeof actionRec.onAnswer === "function") { actionRec.onAnswer(actionRec.answerText); }
+                        } else if (actionRec.loopCheckpoint && (data.action === "continue" || data.action === "stop")) {
+                            actionRec.decision = data.action;
+                            if (typeof actionRec.onResume === "function") { actionRec.onResume(data.action); }
+                        }
+                    } else if (actionRec && actionRec.kind === "chip" && actionRec.chipType === "suggestedAction"
+                            && data.action === "apply-suggested-action") {
+                        // CLAUDE-028: the redirect chip's own click handler (bound
+                        // directly on the button at render time) doesn't survive the
+                        // pop-out's innerHTML clone. Rides the same rebind-by-record-id
+                        // relay renderAskUserQuestion's quick-reply buttons already use
+                        // (bindRecordActionButtons in this file) — no chip-specific wiring
+                        // needed on the pop-out side.
+                        applySuggestedAction(actionRec.suggestedAction);
+                    }
                 } else if (data.event === "stopBuildLoop") {
                     stopBuildLoop("Build loop stopped — applied nodes remain as-is.");
                 } else if (data.event === "clearChat") {
@@ -1440,6 +1549,30 @@
             loadSettings();
             updateSelectionStatus();
             showChat();
+            rehydrateConversationOnLoad();
+    }
+
+    // CLAUDE-029: on a page reload, sessionStorage already retains the
+    // conversation-id (see history.js) and the backend already has the full
+    // transcript (History panel proves it's retrievable) — but nothing ever
+    // fetched and rendered it into the Chat panel on init, so a reload left
+    // Chat looking empty even though the conversation was never lost.
+    // Reuses loadConversation() verbatim (same fetch + same addMessage()
+    // render path the History panel's click handler uses) so there is no
+    // second copy of the message-rendering logic to drift out of sync.
+    function rehydrateConversationOnLoad() {
+        if (!conversationIdWasRestored) { return; }
+        loadConversation(conversationId, function (msg, xhr) {
+            // Conversation no longer exists server-side (404) — the
+            // sessionStorage entry is stale, so drop it rather than retry
+            // this same failed fetch on every future reload. Any other
+            // failure (network hiccup, etc.) leaves it in place in case it
+            // was transient. Either way: stay quiet, Chat simply stays
+            // empty exactly as it does today — no error bubble on load.
+            if (xhr && xhr.status === 404) {
+                try { sessionStorage.removeItem("fp-conversation-id"); } catch (e) { /* storage unavailable */ }
+            }
+        });
     }
 
     window.FlowPilotCore = { initMainWindow: initMainWindow, initPopout: initPopout };