@floless/app 0.29.0 → 0.30.0

package/dist/floless-server.cjs

@@ -51016,6 +51016,8 @@ function readApp(id) {
       kind: locked && typeof locked.kind === "string" ? locked.kind : "agent",
       mode: lockMode === "write" || lockMode === "read" ? lockMode : "unknown",
       runtimeModel: !!locked && locked["runtime-model"] === true,
+      // `frozen:` lives on the SOURCE node (the user froze it); present (non-null) = frozen.
+      frozen: n.frozen != null,
       inputs: asRecord(locked?.inputs),
       config: asRecord(n.config),
       notes: notes2,
@@ -51627,6 +51629,10 @@ function assertId(id) {
   if (!APP_ID.test(id)) throw new AwareError(`invalid app id: ${JSON.stringify(id)}`);
   return id;
 }
+function assertNodeId(id) {
+  if (!APP_ID.test(id)) throw new AwareError(`invalid node id: ${JSON.stringify(id)}`);
+  return id;
+}
 var SOURCE_EXT = /\.(flo|app|flow|aware)$/i;
 function assertSourcePath(p) {
   if (!SOURCE_EXT.test(p)) throw new AwareError(`source must be a .flo/.app file: ${JSON.stringify(p)}`);
@@ -52008,6 +52014,39 @@ var aware = {
     }
     return { compiled: /lock refreshed/i.test(stdout), output: stdout.trim() };
   },
+  /**
+   * Freeze a node (`aware app freeze <app> <node>`, CLI ≥ 0.77, aware-aeco#261). Pins the
+   * node's LAST run output into the source as a `frozen:` block so Run skips the agent
+   * (replays the pinned value, never re-runs it) and recompiles the lock. Fails when the
+   * node has never produced output (nothing to pin) — the route relays that as "run it
+   * once first". Throws AwareUnsupportedError on a pre-0.77 CLI so the route can say "update
+   * AWARE" instead of treating an old CLI as a hard fault (mirrors rename/duplicate).
+   */
+  async freeze(appId, nodeId) {
+    const { code, stdout, stderr } = await runRaw(["app", "freeze", assertId(appId), assertNodeId(nodeId)]);
+    if (code !== 0) {
+      if (isInvokeUnsupported({ stdout, stderr })) {
+        throw new AwareUnsupportedError("aware CLI does not support `app freeze` (needs \u2265 0.77) \u2014 update AWARE", { stdout, stderr });
+      }
+      throw new AwareError(`aware app freeze ${nodeId} failed (exit ${code})`, { stdout, stderr, code });
+    }
+    return { output: stdout.trim() };
+  },
+  /**
+   * Unfreeze a node (`aware app unfreeze <app> <node>`, CLI ≥ 0.77). Removes the node's
+   * `frozen:` block so it runs normally again and recompiles. Same unsupported-degradation
+   * contract as freeze.
+   */
+  async unfreeze(appId, nodeId) {
+    const { code, stdout, stderr } = await runRaw(["app", "unfreeze", assertId(appId), assertNodeId(nodeId)]);
+    if (code !== 0) {
+      if (isInvokeUnsupported({ stdout, stderr })) {
+        throw new AwareUnsupportedError("aware CLI does not support `app unfreeze` (needs \u2265 0.77) \u2014 update AWARE", { stdout, stderr });
+      }
+      throw new AwareError(`aware app unfreeze ${nodeId} failed (exit ${code})`, { stdout, stderr, code });
+    }
+    return { output: stdout.trim() };
+  },
   /**
    * Install a first-party agent by registry id (`aware agent install <id>`). The
    * registry install pulls a large tarball (~200s observed) — far over runRaw's 60s
@@ -52796,7 +52835,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.29.0" : void 0,
+    define: true ? "0.30.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -52806,7 +52845,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.29.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.30.0" : void 0 });
 }
 
 // oauth-presets.ts
@@ -58225,6 +58264,42 @@ async function startServer() {
     broadcast({ type: "apps-changed", id: req.params.id });
     return { ok: true };
   });
+  app.post("/api/app/:id/freeze", async (req, reply) => {
+    const nodeId = typeof req.body?.nodeId === "string" ? req.body.nodeId.trim() : "";
+    if (!nodeId) return reply.status(400).send({ ok: false, error: "nodeId required" });
+    try {
+      await aware.freeze(req.params.id, nodeId);
+    } catch (e) {
+      if (e instanceof AwareUnsupportedError) {
+        return reply.status(422).send({ ok: false, error: "Freezing needs AWARE 0.77 or newer \u2014 update AWARE from the footer." });
+      }
+      if (e instanceof AwareError) {
+        app.log.warn({ id: req.params.id, nodeId, detail: e.detail }, "freeze failed");
+        return reply.status(422).send({ ok: false, error: "Couldn't freeze this node \u2014 it may have no saved output yet (run it once first).", reason: awareStderr(e) });
+      }
+      throw e;
+    }
+    broadcast({ type: "apps-changed", id: req.params.id });
+    return { ok: true };
+  });
+  app.post("/api/app/:id/unfreeze", async (req, reply) => {
+    const nodeId = typeof req.body?.nodeId === "string" ? req.body.nodeId.trim() : "";
+    if (!nodeId) return reply.status(400).send({ ok: false, error: "nodeId required" });
+    try {
+      await aware.unfreeze(req.params.id, nodeId);
+    } catch (e) {
+      if (e instanceof AwareUnsupportedError) {
+        return reply.status(422).send({ ok: false, error: "Freezing needs AWARE 0.77 or newer \u2014 update AWARE from the footer." });
+      }
+      if (e instanceof AwareError) {
+        app.log.warn({ id: req.params.id, nodeId, detail: e.detail }, "unfreeze failed");
+        return reply.status(422).send({ ok: false, error: "Could not unfreeze this node.", reason: awareStderr(e) });
+      }
+      throw e;
+    }
+    broadcast({ type: "apps-changed", id: req.params.id });
+    return { ok: true };
+  });
   app.post("/api/compile", async (req, reply) => {
     const { id, sourcePath } = req.body ?? {};
     const path = sourcePath ?? (id ? readApp(id).source.path : void 0);

package/dist/web/app.css

@@ -608,6 +608,20 @@
     border: 1px solid var(--accent-dim); border-radius: 999px;
     cursor: help;
   }
+  /* Frozen node (aware app freeze): its last output is pinned and Run skips this node.
+     A quiet, INERT read — badge + a one-step-cooler surface — NOT a disabled state (the
+     card stays fully interactive; it's just static). Mirrors the rt-model-badge recipe but
+     with neutral-cool tokens so it reads distinct from the accent-blue runtime-model badge.
+     (No left ::after ribbon: that pseudo-element is already the node mode stripe.) */
+  .agent-card.frozen { background: var(--surface-2); }
+  .agent-card .frozen-badge {
+    display: inline-flex; align-items: center; gap: 4px;
+    margin: 0 0 8px; padding: 2px 8px;
+    font: 600 10px/1.4 var(--ui); letter-spacing: 0.01em;
+    color: var(--text-muted); background: var(--surface-3);
+    border: 1px solid var(--border-strong); border-radius: 999px;
+    cursor: help;
+  }
   .agent-card .footer-row {
     display: flex;
     justify-content: space-between;
@@ -1855,6 +1869,19 @@
     background: var(--border);
     margin: 5px 4px;
   }
+  /* Cursor-anchored node context menu (right-click a card). Reuses .menu/.menu-item; only
+     the fixed 280px width is wrong for it — the pointer anchor (top/left) is set inline. */
+  .menu.context-menu { width: auto; min-width: 168px; }
+  /* Non-interactive node-name header line atop the context menu. */
+  .menu-head {
+    padding: 6px 9px 4px;
+    font-size: 11px;
+    color: var(--text-dim);
+    max-width: 220px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
   .menu-theme {
     display: flex;
     align-items: center;

package/dist/web/app.js

@@ -339,7 +339,9 @@ function cardEl(id, ports) {
   const a = AGENTS[id];
   ports = ports || { in: 0, out: 0 };
   const div = document.createElement('div');
-  div.className = 'agent-card';
+  // `frozen` = the node's output is pinned and Run skips it (aware app freeze). A quiet,
+  // inert card treatment + badge so it reads as "static / won't re-run" at a glance.
+  div.className = 'agent-card' + (a._frozen ? ' frozen' : '');
   div.dataset.agentId = id;
   div.draggable = true;
   const faved = state.favorites.some(f => f.id === id);
@@ -355,6 +357,7 @@ function cardEl(id, ports) {
     <div class="title">${a.title}</div>
     <div class="subtitle">${a.subtitle}</div>
     ${a._runtimeModel ? '<div class="rt-model-badge" title="This node calls a model at run time (vision.extract). Output is content-cached and sits behind an approve gate — review the extraction before any write.">⚡ calls a model at run time</div>' : ''}
+    ${a._frozen ? '<div class="frozen-badge" title="Frozen — its last result is pinned and Run skips this node. Right-click to unfreeze.">❄ Frozen</div>' : ''}
     <div class="blurb">${a.blurb}</div>
     <div class="footer-row">
       <span class="ports"><span class="ports-num">${ports.in}</span> in <span class="ports-arrow">·</span> <span class="ports-num">${ports.out}</span> out</span>

package/dist/web/aware.js

@@ -294,6 +294,7 @@
     return {
       _mode: n.mode,
       _runtimeModel: !!n.runtimeModel, // B2: lock stamped runtime-model → card badge
+      _frozen: !!n.frozen, // source node carries a `frozen:` block → card badge + Unfreeze menu
       icon: iconFor(n.agent),
       kind: n.kind === 'agent' && n.agent ? `${agentLabel} agent` : escapeHtml(n.kind),
       version: pin ? `v${escapeHtml(String(pin))}` : '—',
@@ -1392,6 +1393,106 @@
     }
   }
 
+  // ── Right-click Freeze / Unfreeze a node (aware-aeco#261) ─────────────────────
+  // A general per-node toggle: right-click a canvas node → Freeze output (Run then
+  // REPLAYS the node's last result instead of re-running its agent — so e.g. a
+  // drawing-reader node won't re-read & wipe the user's edits, "whatever's there is
+  // there") or Unfreeze (runs normally again). Needs AWARE ≥ 0.77; on an older runtime
+  // the menu simply doesn't appear and the native menu passes through (the app keeps
+  // AWARE at latest, so that's rare/transient — never a dead/disabled control).
+  let _freezeMenuEl = null, _freezeMenuEsc = null, _freezeMenuOutside = null;
+
+  // numeric major.minor.patch compare; an empty/unparseable version sorts BELOW (-1),
+  // so a missing awareVersion safely reads as "freeze unsupported". `Number` (not parseInt)
+  // is strict — a prerelease segment like "0-rc1" → NaN → unsupported (defer to the server
+  // backstop), never silently treated as the release.
+  function cmpSemver(a, b) {
+    const pa = String(a || '').split('.').map((x) => Number(x));
+    const pb = String(b || '').split('.').map((x) => Number(x));
+    if (pa.length < 3 || pa.some(Number.isNaN)) return -1;
+    for (let i = 0; i < 3; i++) {
+      const d = (pa[i] || 0) - (pb[i] || 0);
+      if (d !== 0) return d < 0 ? -1 : 1;
+    }
+    return 0;
+  }
+  function awareSupportsFreeze() { return cmpSemver(awareRuntimeVersion, '0.77.0') >= 0; }
+
+  function closeNodeMenu() {
+    if (_freezeMenuEsc) { document.removeEventListener('keydown', _freezeMenuEsc, true); _freezeMenuEsc = null; }
+    if (_freezeMenuOutside) { document.removeEventListener('mousedown', _freezeMenuOutside, true); _freezeMenuOutside = null; }
+    if (_freezeMenuEl) { _freezeMenuEl.remove(); _freezeMenuEl = null; }
+  }
+
+  // Build + open the cursor-anchored menu over a node card. Reuses the hamburger
+  // `.menu`/`.menu-item` vocabulary (+ a `.context-menu` width modifier) so it matches
+  // the existing popover language; dismiss mirrors openNotesPopover (Escape + click-away).
+  function openNodeMenu(card, x, y) {
+    closeNodeMenu();
+    const nodeId = card.dataset.agentId;
+    if (!nodeId) return;
+    const node = AGENTS[nodeId];
+    const frozen = !!(node && node._frozen);
+    // A 4-line snowflake glyph as a stroke SVG — matches `.menu-icon svg` (Lucide family).
+    const ice = '<span class="menu-icon"><svg viewBox="0 0 24 24" aria-hidden="true"><line x1="12" y1="2" x2="12" y2="22"/><line x1="2" y1="12" x2="22" y2="12"/><line x1="4.6" y1="4.6" x2="19.4" y2="19.4"/><line x1="19.4" y1="4.6" x2="4.6" y2="19.4"/></svg></span>';
+    const menu = document.createElement('div');
+    menu.className = 'menu context-menu show';
+    menu.setAttribute('role', 'menu');
+    menu.setAttribute('aria-label', 'Node actions');
+    menu.innerHTML =
+      `<div class="menu-head" role="none">${escapeHtml(nodeId)}</div>`
+      + `<div class="menu-divider"></div>`
+      + `<button type="button" class="menu-item" role="menuitem">${ice}<span class="menu-label">${frozen ? 'Unfreeze' : 'Freeze output'}</span></button>`;
+    document.body.appendChild(menu);
+    // Anchor at the pointer, then clamp so a card near the right/bottom edge can't push
+    // the menu off-screen (same intent as openNotesPopover's edge-clamp).
+    const r = menu.getBoundingClientRect();
+    menu.style.left = Math.max(8, Math.min(x, window.innerWidth - r.width - 8)) + 'px';
+    menu.style.top = Math.max(8, Math.min(y, window.innerHeight - r.height - 8)) + 'px';
+    const item = menu.querySelector('.menu-item');
+    item.onclick = () => { closeNodeMenu(); toggleFreeze(nodeId, frozen); };
+    try { item.focus(); } catch { /* container handles focus */ }
+    _freezeMenuEl = menu;
+    _freezeMenuEsc = (e) => { if (e.key === 'Escape') { e.preventDefault(); closeNodeMenu(); try { card.focus(); } catch { /* card not focusable */ } } };
+    document.addEventListener('keydown', _freezeMenuEsc, true);
+    _freezeMenuOutside = (e) => { if (_freezeMenuEl && !_freezeMenuEl.contains(e.target)) closeNodeMenu(); };
+    document.addEventListener('mousedown', _freezeMenuOutside, true);
+  }
+
+  // Toggle a node's frozen state via the server (which shells `aware app freeze/unfreeze`
+  // + recompiles), then re-read the app so the badge + state repaint. api() throws on any
+  // failure (non-2xx OR in-band ok:false) with the server's plain-English message — e.g.
+  // "No output to freeze — run this node at least once first." — so one catch covers it.
+  async function toggleFreeze(nodeId, currentlyFrozen) {
+    if (!currentId) return;
+    const verb = currentlyFrozen ? 'unfreeze' : 'freeze';
+    try {
+      await api(`/api/app/${encodeURIComponent(currentId)}/${verb}`, { method: 'POST', body: JSON.stringify({ nodeId }) });
+      await loadApp(currentId); // re-read → frozen badge/state repaints
+      showToast(currentlyFrozen
+        ? 'Node unfrozen — it will run normally.'
+        : 'Output frozen — this node will replay its last result on the next run.',
+        currentlyFrozen ? 'info' : 'ok');
+    } catch (e) {
+      // Surface the real aware reason the route attached as body.reason — otherwise the friendly
+      // lead hides the actual cause. First non-empty line, capped, keeps the warn toast sane.
+      const lead = (e && e.message) || `Could not ${verb} this node.`;
+      const raw = e && e.body && typeof e.body.reason === 'string' ? e.body.reason.trim() : '';
+      const reason = raw ? (raw.split('\n').find((l) => l.trim()) || '').trim().slice(0, 200) : '';
+      showToast(reason ? `${lead} — ${reason}` : lead, 'warn');
+    }
+  }
+
+  // Right-click a node card → the Freeze/Unfreeze menu. preventDefault is scoped to cards
+  // (right-click stays normal everywhere else), and only when AWARE supports it — on an
+  // older runtime the native menu passes through, so there's no dead interaction.
+  document.addEventListener('contextmenu', (e) => {
+    const card = e.target.closest && e.target.closest('.agent-card');
+    if (!card || !awareSupportsFreeze()) return;
+    e.preventDefault();
+    openNodeMenu(card, e.clientX, e.clientY);
+  });
+
   // Approve & bake — freezes the edited contract into the .lock, arming Run.
   // Flushes the editor's pending debounce save first so Approve always bakes the
   // latest in-memory edits, not a stale snapshot. api() throws on non-2xx, so
@@ -3284,6 +3385,8 @@
   }
   let shownVersion = false;
   let loadedAppVersion = null; // the build this tab is running against (first health wins)
+  let awareRuntimeVersion = null; // installed AWARE version (from /api/health) — gates the freeze menu
+  let freezeHintAppended = false; // append the right-click-to-freeze canvas hint once, when supported
   function startHealthPoll() {
     const tick = async () => {
       let ok = false;
@@ -3326,6 +3429,15 @@
           // After the build version is stamped, reveal the relaunch-surviving what's-new
           // panel iff this is the build we just self-updated into (guarded to once).
           maybeShowWhatsNew();
+          // Track the installed AWARE runtime version so the right-click freeze menu can
+          // gate itself (needs ≥ 0.77) and the canvas hint can advertise it once available.
+          if (h && h.awareVersion) {
+            awareRuntimeVersion = h.awareVersion;
+            if (!freezeHintAppended && awareSupportsFreeze()) {
+              const ch = document.getElementById('canvas-hint');
+              if (ch) { ch.textContent += ' Right-click a node to freeze its output.'; freezeHintAppended = true; }
+            }
+          }
           const wv = document.getElementById('aware-version');
           if (wv && h && h.awareVersion) {
             const next = 'AWARE ' + h.awareVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floless/app",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "type": "module",
   "description": "Thin localhost host for floless.app — serves web/ and shells the aware CLI. No engine, no LLM.",
   "bin": {