@intentius/behold 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/behold",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "behold — a live control plane on chant. See your whole estate (every substrate in one graph), coloured by drift; act through delegated, gated Ops.",
   "bin": {
@@ -35,9 +35,9 @@
   },
   "dependencies": {
     "@hono/node-server": "^2.0.5",
-    "@intentius/chant": "^0.38.0",
+    "@intentius/chant": "^0.44.12",
     "@intentius/chant-k8s-client": "^0.44.5",
-    "@intentius/pinhole": "^0.3.4",
+    "@intentius/pinhole": "^0.3.5",
     "hono": "^4.12.34"
   },
   "devDependencies": {

package/web/app.js

@@ -1233,6 +1233,35 @@ const carveActions = {
   },
   runEmit: () => runCarveStep("emit"),
   runBridge: () => runCarveStep("bridge"),
+  // The observe beat (#254, chant#1647). Not runCarveStep: the refusal has to
+  // land on the Emit step (where the button lives), and "observe" is a live-
+  // tier action on that step, not a step of its own.
+  async runObserve() {
+    if (carveState.busy || !carveState.pick) return;
+    carveState.busy = "observe";
+    carveState.error = null;
+    renderPanelCarve();
+    try {
+      const res = await fetch("/api/carve/observe", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ select: carveState.pick.node.id }),
+      });
+      const body = await res.json().catch(() => ({ error: "observe returned an unreadable body", remedy: "" }));
+      if (!res.ok || body.error) {
+        carveState.error = { step: "emit", ...body };
+        showToast(`✗ observe: ${body.error || res.status}`, false);
+      } else {
+        carveState.observe = body;
+        showToast(body.verdict === "observed" ? "✓ chant read it live — nothing blinked" : `✗ observe: ${body.verdict}`, body.verdict === "observed");
+      }
+    } catch (err) {
+      carveState.error = { step: "emit", error: String((err && err.message) || err), remedy: "Is the behold server still running?" };
+    } finally {
+      carveState.busy = null;
+      renderPanelCarve();
+    }
+  },
   async runPlan() {
     if (carveState.busy) return;
     carveState.busy = "plan";
@@ -1321,6 +1350,7 @@ function carvePick(node) {
     carveState.emit = null;
     carveState.bridge = null;
     carveState.handoff = false;
+    carveState.observe = null;
     carveState.error = null;
     carveState.step = pickStep;
   } else if (carveState.step < pickStep) {
@@ -2319,26 +2349,19 @@ function currentLensKey() {
  * Wrap each containment box in a `<g data-layout-box>` and give it a corner
  * handle, once per rendered SVG.
  *
- * TWO WAYS TO FIND A BOX, in that order (#250):
- *
- * 1. `rect[data-group-id]` — pinhole stamps the container key on an
- *    architecture group box from 0.3.3 (pinhole#103/#104), the same hook
- *    `data-node-id` gives a card. That key is also what the box's delta is
- *    stored under, so a box keeps its size when its title changes and two
- *    boxes that happen to read alike stay separate placements.
- * 2. The structural match #245 shipped, kept for one release as a fallback and
- *    then deleted. It is still load-bearing, not dead weight: `layoutArchitecture`
- *    is the only pinhole layout that sets `GroupBox.id`, so the wave/stack/
- *    container boxes `renderGraph` draws (src/render.ts) arrive with a title
- *    and nothing else. FRAGILE BY CONSTRUCTION and knowingly so — the
- *    discriminators are a positive `rx` (the two page-background rects have
- *    none), a `<text>` as the next non-badge sibling, and svg-root parentage
- *    (a card's rect lives inside `[data-node-id]`, an edge-label's inside its
- *    own `<g>`), exactly the way addGitlabWaveBadges still has to.
+ * ONE WAY TO FIND A BOX (#250, closed): `rect[data-group-id]` — pinhole stamps
+ * the group key on every layout's boxes from 0.3.5 (layoutArchitecture since
+ * 0.3.3, pinhole#103/#104; layoutIr's wave/stack/container boxes via
+ * pinhole#111), the same hook `data-node-id` gives a card. That key is also
+ * what the box's delta is stored under, so a box keeps its size when its title
+ * changes and two boxes that happen to read alike stay separate placements.
+ * The structural match #245 shipped (rx sniff + next-sibling text + svg-root
+ * parentage, marked fragile by construction) served its one fallback release
+ * and is deleted — the ^0.3.5 floor guarantees the attribute.
  *
  * Identification runs over a DOM nothing has moved yet and the wrapping happens
- * after: both paths read `nextElementSibling`, and inserting a wrapper mid-walk
- * would put one box's `<g>` in the middle of the next box's member run.
+ * after: the title walk reads `nextElementSibling`, and inserting a wrapper
+ * mid-walk would put one box's `<g>` in the middle of the next box's member run.
  *
  * MIGRATION, said plainly: a box that gains an id changes storage key —
  * `layoutArchitecture` titles a box `<id>  ·  <kind>`, so `box:vpc  ·  VPC`
@@ -2361,10 +2384,9 @@ function wrapContainmentBoxes(svgEl) {
     const w = parseFloat(rect.getAttribute("width"));
     const h = parseFloat(rect.getAttribute("height"));
     if (!(w > 0) || !(h > 0) || Number.isNaN(x) || Number.isNaN(y)) continue;
-    // The `rx` sniff is the fallback's discriminator only. An id'd rect has
-    // already said what it is, and hardening a shape pinhole never promised
-    // would be the same mistake this issue exists to undo.
-    if (!groupId && !(parseFloat(rect.getAttribute("rx")) > 0)) continue;
+    // An unstamped rect is not a group box — the page-background rects and any
+    // decoration pinhole paints at the root stay untouched.
+    if (!groupId) continue;
     // Collect rect → title, stepping over anything already stamped between
     // them (the GitLab wave badge), and bail at the next box or card.
     const members = [rect];
@@ -2378,13 +2400,11 @@ function wrapContainmentBoxes(svgEl) {
         break;
       }
     }
-    // An untitled box is only knowable by its attribute — the structural path
-    // has literally nothing else to go on, and a titleless id'd box keeps its
-    // resize handle and simply has no drag-by-title. It also keeps nothing but
-    // its own rect: the walk above only stops at a title, so without one it has
-    // swept up whatever pinhole painted next, which is not this box's to move.
-    if (!title && !groupId) continue;
-    const id = `box:${groupId || (title.textContent || "").trim() || found.length}`;
+    // A titleless box keeps its resize handle and simply has no drag-by-title.
+    // It also keeps nothing but its own rect: the walk above only stops at a
+    // title, so without one it has swept up whatever pinhole painted next,
+    // which is not this box's to move.
+    const id = `box:${groupId}`;
     if (claimed.has(id)) continue;
     claimed.add(id);
     found.push({ id, rect, members: title ? members : [rect], title, x, y, w, h });
@@ -2468,35 +2488,28 @@ function userRect(el, toUser) {
  * The chip pinhole paints on a labelled edge (`project`, `sourceRef`,
  * `selector` — the IR edge's `viaAttr`), or null if this edge has none.
  *
- * HOW THE TWO ARE ASSOCIATED, and why it is what it is: `renderSvg` emits
- * `Canvas.edge(...)` and then, for a labelled edge, `Canvas.edgeLabel(...)` —
- * an ANONYMOUS `<g><rect rx="9"/><text>…</text></g>` carrying no edge identity
- * whatsoever. There is no id, no data attribute, no shared class. What is left
- * is document order (the chip is the edge group's next element sibling) and the
- * one piece of content the two provably share: the chip's text IS the edge
- * group's `data-edge-via` value. Behold requires BOTH before it will move
- * anything, so a pinhole that stops emitting chips, reorders them, or slips
- * something between the pair leaves the label untouched rather than dragging an
- * unrelated group around the canvas.
- *
- * Read at index time and kept as an element reference, never re-derived:
- * wireEdgeHighlight's `raise()` re-appends a hovered edge group to the end of
- * the SVG, so the sibling link is gone the instant a pointer crosses an edge.
+ * HOW THE TWO ARE ASSOCIATED: pinhole stamps the chip group with its edge's
+ * own `data-edge-from`/`data-edge-to` (pinhole#110, 0.3.5 — the same ask boxes
+ * made and won with `data-group-id`), so the pair is an attribute match. The
+ * chip is the stamped sibling that holds no `path` — the line group always
+ * carries one. The sibling-order + text-sniffing inference this replaces
+ * (#267/#271) went with the ^0.3.5 floor.
  *
- * The real fix is upstream, and it is the same ask boxes made and won in
- * pinhole 0.3.3 (`data-group-id`, #250): stamp the chip with the edge it
- * belongs to. The moment pinhole emits a `data-edge-*` pairing on the label
- * group, prefer it here the way wrapContainmentBoxes now prefers the attribute.
+ * Still read at index time and kept as an element reference, never re-derived:
+ * wireEdgeHighlight's `raise()` re-appends hovered groups, so document order is
+ * unstable even though identity now isn't.
  */
 function edgeLabelOf(g) {
-  const via = (g.getAttribute("data-edge-via") || "").trim();
-  if (!via) return null;
-  const next = g.nextElementSibling;
-  if (!next || next.tagName.toLowerCase() !== "g") return null;
-  if (next.hasAttribute("data-node-id") || next.hasAttribute("data-edge-from")) return null;
-  const text = next.querySelector("text");
-  if (!text || (text.textContent || "").trim() !== via) return null;
-  return next;
+  if (!(g.getAttribute("data-edge-via") || "").trim()) return null;
+  const from = g.getAttribute("data-edge-from");
+  const to = g.getAttribute("data-edge-to");
+  for (const cand of g.parentNode ? g.parentNode.children : []) {
+    if (cand === g || cand.tagName.toLowerCase() !== "g") continue;
+    if (cand.getAttribute("data-edge-from") !== from || cand.getAttribute("data-edge-to") !== to) continue;
+    if (cand.hasAttribute("data-node-id") || cand.querySelector("path")) continue;
+    return cand;
+  }
+  return null;
 }
 
 /** Index the freshly rendered SVG: node groups, containment boxes, edge paths. */

package/web/carve-steps.js

@@ -66,7 +66,11 @@ export function initialCarveState() {
     /** POST /api/carve/plan's answer (live tier only). Estate-wide, so a new
      * pick keeps it — the plan is about the armed Terraform, not the pick. */
     plan: null,
-    /** Which step is mid-run ("emit" | "bridge" | "plan" | null). */
+    /** POST /api/carve/observe's answer (live tier only) — chant reading the
+     * carved resource live while Terraform still owns it (chant#1647). About
+     * THIS pick's carveout, so a new pick drops it with emit/bridge. */
+    observe: null,
+    /** Which step is mid-run ("emit" | "bridge" | "plan" | "observe" | null). */
     busy: null,
     /** The last structured refusal, keyed by step id. */
     error: null,
@@ -276,6 +280,32 @@ export function lintVerdict(lint) {
   return { tone: "bad", text: `chant lint exited ${lint.code} — the emitted source doesn't pass yet` };
 }
 
+/**
+ * The observe verdict as one line + a tone (chant#1647). `observed` with
+ * EXTERNAL/foreign IS the beat: live, outside every stack, still Terraform's —
+ * and chant read it clean anyway. `unobserved` repeats chant's own hole
+ * ("not a verdict about the resource" is #1089's rule said small). `missing`
+ * names the one honest local cause: a demo-copy chant that predates the
+ * identity read path.
+ */
+export function observeSummary(o) {
+  if (!o) return null;
+  if (o.verdict === "observed") {
+    const how = [o.status, o.ownership ? `ownership ${o.ownership}` : null].filter(Boolean).join(", ");
+    return {
+      tone: "good",
+      text: `${o.entity}: observed${how ? ` (${how})` : ""} — Terraform still owns it, and chant read it clean. Nothing blinked.`,
+    };
+  }
+  if (o.verdict === "unobserved") {
+    return { tone: "warn", text: `${o.entity}: the read itself had a hole — ${o.detail || "unobserved"}. Not a verdict about the resource.` };
+  }
+  return {
+    tone: "warn",
+    text: `${o.entity}: read MISSING. The demo copy's chant predates the identity read path (chant#1647, fixed in chant ≥ 0.44.12) — npm install in the copy's app/ and re-run.`,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // The DOM half. Plain browser JS, no build step, themed entirely by the shared
 // CSS vars — same rules as app.js. `actions` is the host's wiring:
@@ -436,7 +466,7 @@ function renderAdvise(body, ctx) {
           "panel-muted carve-live-note",
           `Live tier: the starred resources are REALLY applied into a scratch Floci (${ctx.demo.live.endpoint}, ` +
             "deleted when this server exits) and the tfstate the advisor read was written by terraform, not shipped. " +
-            "The observe beat — chant reading the bucket live while Terraform still owns it — waits on chant#1647.",
+            "After Emit, the observe beat reads the carved resource live while Terraform still owns it (chant#1647).",
         ),
       );
     }
@@ -519,6 +549,27 @@ function renderEmit(body, state, ctx, actions) {
   caveat.appendChild(el("p", "panel-muted", e.buildCaveat || (ctx.demo && ctx.demo.buildCaveat) || ""));
   body.appendChild(caveat);
 
+  // The observe beat (#254, chant#1647): chant reads the carved resource live
+  // FROM THE CARVEOUT, against the scratch Floci, while Terraform still owns
+  // it. Live tier only — offline has no live to read.
+  if (ctx.demo && ctx.demo.live) {
+    const obsBtn = el("button", "act carve-observe", state.busy === "observe" ? "observing…" : "▶ watch chant read it live");
+    obsBtn.disabled = !!state.busy;
+    obsBtn.title = "Runs chant lifecycle diff --live in the carveout against the scratch Floci. Reads everything, changes nothing.";
+    obsBtn.addEventListener("click", actions.runObserve);
+    body.appendChild(obsBtn);
+    const summary = observeSummary(state.observe);
+    if (summary) {
+      const row = el("div", "count-row");
+      const dot = el("span", "dot");
+      dot.style.background = summary.tone === "good" ? "var(--managed)" : "var(--degraded)";
+      row.append(dot, el("span", "grow", summary.text));
+      body.appendChild(row);
+      if (state.observe.queried) body.appendChild(pre(state.observe.command + "\n→ queried " + state.observe.queried, "carve-cmd"));
+      else body.appendChild(pre(state.observe.command, "carve-cmd"));
+    }
+  }
+
   body.appendChild(el("h3", null, "emitted"));
   for (const a of e.artifacts || []) body.appendChild(artifactBlock(a, actions));
 

package/web/carve-steps.test.js

@@ -15,6 +15,7 @@ import {
   edgeLine,
   initialCarveState,
   lintVerdict,
+  observeSummary,
   pickFacts,
   runbookCommands,
   stepStatus,
@@ -241,6 +242,36 @@ describe("lintVerdict", () => {
     expect(bad.tone).toBe("bad");
     expect(bad.text).toContain("exited 1");
   });
+});
+
+// The observe beat's one-line verdicts (#254, chant#1647). `observed` is the
+// claim the whole tier films; the other two must stay distinguishable — a hole
+// in the read is not a verdict about the resource (#1089), and MISSING has
+// exactly one honest local cause worth naming.
+describe("observeSummary", () => {
+  it("is null before any observe ran", () => {
+    expect(observeSummary(null)).toBeNull();
+  });
+
+  it("observed: names the how and claims the beat", () => {
+    const s = observeSummary({ entity: "assets", verdict: "observed", status: "EXTERNAL", ownership: "foreign" });
+    expect(s.tone).toBe("good");
+    expect(s.text).toContain("assets: observed (EXTERNAL, ownership foreign)");
+    expect(s.text).toContain("Nothing blinked");
+  });
+
+  it("unobserved: repeats chant's own hole and refuses to call it a verdict", () => {
+    const s = observeSummary({ entity: "assets", verdict: "unobserved", detail: "read-failed: connection refused" });
+    expect(s.tone).toBe("warn");
+    expect(s.text).toContain("read-failed: connection refused");
+    expect(s.text).toContain("Not a verdict about the resource");
+  });
+
+  it("missing: names the one honest local cause", () => {
+    const s = observeSummary({ entity: "assets", verdict: "missing" });
+    expect(s.tone).toBe("warn");
+    expect(s.text).toContain("chant#1647");
+  });
 
   it("is null with no lint at all — nothing to claim", () => {
     expect(lintVerdict(null)).toBeNull();

package/web/layout-store.js

@@ -157,10 +157,10 @@ export function straightEdge(anchors, from, to) {
 // "I need more room" means grow the box first (#245 already resizes them).
 //
 // No twin in src/layout.ts, unlike the three functions above: the server-side
-// bake does not reconstruct containment boxes (only pinhole's architecture
-// layout stamps them with a `data-group-id`, and not every lens uses it — see
-// wrapContainmentBoxes in web/app.js), so it has nothing to clamp against and
-// deliberately does not try.
+// bake does not reconstruct containment boxes (pinhole stamps every layout's
+// boxes with `data-group-id` since 0.3.5, but the bake still parses no box
+// geometry — see wrapContainmentBoxes in web/app.js), so it has nothing to
+// clamp against and deliberately does not try.
 
 /** How far a card keeps off its container's edge, in viewBox units. */
 export const CLAMP_PAD = 8;