slidemind 0.3.4 → 0.3.12

package/src/builders/gate-server.mjs

@@ -22,8 +22,9 @@ const GATE_SESSION_PATH = path.join(__dirname, "gate-session.js");
 // overlays as CFG.pollMs / CFG.pollTtlMs:
 //   GRACE_MS  > POLL_MS so a waiting tab always lands one poll inside the
 //              open-browser grace window;
-//   POLL_TTL_MS > the gates' 30-min decision timeout so an abandoned tab stops
-//              polling only after the server side has certainly given up.
+//   POLL_TTL_MS caps how long an abandoned tab keeps polling for a NEXT round
+//              (the gates themselves have no decision timeout — a live gate
+//              serves its own tab directly; polling only matters between runs).
 // One favicon for every page slidemind opens in a browser (gates, previews,
 // sign-in): an inline data URI, so no server needs a /favicon.ico route and
 // the static preview file stays self-contained.
@@ -87,7 +88,14 @@ export function serveStaticFile({ roots, pathname, res }) {
       continue; // missing here — try the next root
     }
     const ext = path.extname(resolved).toLowerCase();
-    res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream" });
+    // Gate tabs deliberately reuse a stable localhost URL across review rounds
+    // while build.mjs overwrites CSS, fonts and assets in place.  Without an
+    // explicit no-cache policy the browser can combine fresh HTML with stale
+    // design resources, making the review diverge from the generated PPTX.
+    res.writeHead(200, {
+      "Content-Type": MIME[ext] || "application/octet-stream",
+      "Cache-Control": "no-store, max-age=0",
+    });
     res.end(data);
     return true;
   }
@@ -96,8 +104,8 @@ export function serveStaticFile({ roots, pathname, res }) {
 
 // Read a JSON POST body off a gate request and hand the parsed object to `cb`
 // (an unparseable/absent body becomes `{}` — a gate normalizes its own fields
-// anyway). Shared by every gate POST route (plan decision, plan backlog, and
-// the preview gate's decision + backlog next), so the 5 MB flood guard lives in
+// anyway). Shared by every gate POST route (both gates' decision POSTs), so
+// the 5 MB flood guard lives in
 // exactly one place. The guard matters: these servers bind loopback but any
 // page in the user's browser can POST to a known localhost port.
 export function readJsonBody(req, cb) {
@@ -130,13 +138,13 @@ export function readJsonBody(req, cb) {
 // ---------------------------------------------------------------------------
 // shared gate ROUTES + comment normalization
 //
-// Both gates ran byte-identical copies of the backlog route, the approve-409
-// guard and the row-normalization preamble. One copy, two per-gate field shapes.
+// Both gates ran byte-identical copies of the approve-409 guard and the
+// row-normalization preamble. One copy, two per-gate field shapes.
 // ---------------------------------------------------------------------------
 
 // The identity + text core every gate row shares: `id` dedupes a client retry
 // of the same batch, `round` says which round the comment was written against
-// (a queued row is delivered a round later, so the two can differ), and a row
+// (rounds print it so the agent knows which render a pin sits on), and a row
 // without text is dropped — an empty row prints as an instruction-free bullet.
 // `fields(c)` contributes the gate's own anchor columns.
 export function normalizeGateComments(raw, fields) {
@@ -161,37 +169,18 @@ export function normalizeGateComments(raw, fields) {
   return out;
 }
 
-// The reloaded tab flushes its queued rows here. Non-empty ⇒ that run never
-// parks: it resolves at once as a drain round. (The page only POSTs when it HAS
-// a backlog, so the empty branch is just a defensive ack.)
-//
-// `isSuperseded` (the gate's settled check): once another tab's drain or
-// decision has resolved this run, a late backlog must NOT be acked "drained" —
-// the client would flip its rows to "sent" while gate.resolve is a no-op and
-// the reviewer's comments silently vanish. "superseded" keeps them queued, and
-// the tab's heartbeat poll carries them into the next run.
-export function serveBacklogPost(req, res, { normalize, onDrained, isSuperseded = () => false }) {
-  readJsonBody(req, (payload) => {
-    const comments = normalize(payload.comments);
-    const state = !comments.length ? "parked" : isSuperseded() ? "superseded" : "drained";
-    res.writeHead(200, { "Content-Type": MIME[".json"] });
-    res.end(JSON.stringify({ ok: state !== "superseded", state }));
-    if (state === "drained") onDrained(comments);
-  });
-}
-
-// The decision POST, with the shared 409 guard: once this run has settled —
-// a backlog drained (the displayed round is superseded by comments the agent
-// has already been told to work) or another tab's decision landed — a late
+// The decision POST, with the shared 409 guard: once this run has settled
+// (another tab's decision landed — every waiting tab reloads into a new round,
+// so two windows posting into one run is the normal multi-window case) a late
 // decision of EITHER kind is refused. Acking a late "comments" with 200 would
-// mark them sent while gate.resolve is a no-op; the 409 keeps them queued
-// client-side for the next round.
+// mark them sent while gate.resolve is a no-op; the 409 lets the tab keep them
+// as unsent drafts for the next round.
 export function serveDecisionPost(req, res, { normalize, isSuperseded, onDecision }) {
   readJsonBody(req, (payload) => {
     const decision = payload.decision === "comments" ? "comments" : "approve";
     if (isSuperseded()) {
       res.writeHead(409, { "Content-Type": MIME[".json"] });
-      res.end(JSON.stringify({ ok: false, error: "backlog_pending" }));
+      res.end(JSON.stringify({ ok: false, error: "round_settled" }));
       return;
     }
     res.writeHead(200, { "Content-Type": MIME[".json"] });
@@ -217,7 +206,7 @@ export function stripModuleSyntax(src) {
 
 // gate-session.js as a browser IIFE exposing window.__SLIDEMIND_GATE__. Both
 // gate pages inline this BEFORE their overlay script — the overlays' whole
-// ledger/backlog/round machinery is that one shared factory.
+// ledger/round machinery is that one shared factory.
 export function bundleGateSession() {
   return (
     "(function () {\n" +
@@ -249,8 +238,8 @@ export function createDecisionGate({
       isSettled = true;
       resolveDecision(value);
     },
-    // Whether a decision/drain already resolved this run — the POST routes
-    // refuse late input on it, because a resolve after the first is a no-op.
+    // Whether a decision already resolved this run — the POST route refuses
+    // late input on it, because a resolve after the first is a no-op.
     settled() {
       return isSettled;
     },

package/src/builders/gate-session.js

@@ -1,9 +1,17 @@
 // Shared browser-side session machinery for the CLI's two blocking gates —
 // the plan sign-off gate (plan-overlay.js) and the spatial preview gate
 // (review-overlay.js). Both overlays used to carry byte-identical copies of the
-// sessionStorage ledger, the backlog flush, the round-transition detection, the
-// round-ready announcement and the heartbeat poll; a fix landed in one and not
-// the other is exactly how the two drifted apart. This module is the ONE copy.
+// sessionStorage ledger, the round-transition detection, the round-ready
+// announcement and the heartbeat poll; a fix landed in one and not the other is
+// exactly how the two drifted apart. This module is the ONE copy.
+//
+// ROUNDS ARE SYNCHRONOUS (add-in parity). A round is: the reviewer comments,
+// sends, the agent works, the next run presents a new round. Nothing is queued
+// behind the agent's back: while the agent works the gate is not accepting
+// input, and the tab says so. (An earlier design let the tab keep collecting
+// comments in sessionStorage and flushed them to the next run as a "drain
+// round" — that made the add-in and the CLI behave differently and was
+// removed.)
 //
 // It is plain dependency-free ESM so a test can `import` it directly, and the
 // gates inline it into their page (import-free, `export ` stripped) as
@@ -24,7 +32,7 @@
 
 // The wire shape each gate's server persists and prints. Per-gate because the
 // anchors differ (spatial pin vs. slide-anchored comment), shared here because
-// flushBacklog posts it and the gate's normalizer has to accept it.
+// the gate's normalizer has to accept exactly this.
 const WIRE = {
   // Preview pins carry FULL-PRECISION 0..1 fractions. Rounding to whole percent
   // on the wire cost ±6px on a 1280px stage and collapsed sub-1% offsets; the
@@ -66,9 +74,9 @@ export function createGateSession(cfg) {
   const store = cfg.storage;
   const doFetch = cfg.fetch;
   const wire = cfg.wire || WIRE[name];
-  // Deck-scoped, NOT round-scoped: the rows carry their own round, and keying
-  // the store by the round would strand the queue on exactly the reload that
-  // has to flush it (a new round's key differs by definition).
+  // Deck-scoped, NOT round-scoped: the rows carry their own round, and the
+  // ledger has to survive the reload INTO the next round (a new round's key
+  // would differ by definition).
   const LEDGER_KEY = "slidemind-" + name + "-ledger:" + deck;
   const CTX_KEY = "slidemind-" + name + "-ctx:" + deck;
   const ROUND_READY_FLAG = "slidemind-" + name + "-round-ready";
@@ -113,19 +121,18 @@ export function createGateSession(cfg) {
     }, DRAFT_DEBOUNCE_MS);
   }
 
-  // The backlog: written in this tab, not yet delivered to any gate run.
-  function queued(ledger) {
-    return (ledger || []).filter(function (c) {
-      return c.status === "queued";
-    });
-  }
-
   // Restore this tab's session and work out whether THIS load is a new round.
   // Returns the ledger plus the round state; the caller applies its own ctx
   // fields from the returned `ctx` and its own round-arrival cosmetics.
   function restore(seed) {
     let ledger = read(LEDGER_KEY, []) || [];
     if (!Array.isArray(ledger)) ledger = [];
+    // A tab left open across the upgrade from the queueing release still holds
+    // "queued" rows: undelivered, so they are the reviewer's drafts — never
+    // silently relabelled as sent.
+    ledger.forEach(function (c) {
+      if (c.status === "queued") c.status = "draft";
+    });
     let ctx = read(CTX_KEY, null);
     if (!ctx || typeof ctx !== "object") ctx = null;
     let roundNo = ctx && typeof ctx.round === "number" ? ctx.round : 1;
@@ -154,41 +161,16 @@ export function createGateSession(cfg) {
       row.status = s.status === "addressed" ? "addressed" : "sent";
       ledger.push(row);
     });
-    // Queued rows mean the agent is still working on the round they were
-    // written against — this load is a drain round, not a park.
-    return { ledger, roundNo, working: queued(ledger).length > 0, newRound, ctx };
-  }
-
-  // POST the queued backlog to the gate. A non-empty backlog resolves that run
-  // at once (drain round), so the rows flip to "sent". A failure (the command
-  // already exited) leaves them queued for the next run — nothing is dropped.
-  function flushBacklog(ledger) {
-    const pending = queued(ledger);
-    if (!pending.length) return Promise.resolve(false);
-    return doFetch(cfg.backlogEndpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ comments: pending.map(wire) }),
-    })
-      .then(function (r) {
-        return r.ok ? r.json() : null;
-      })
-      .then(function (data) {
-        if (!data || data.state !== "drained") return false;
-        pending.forEach(function (c) {
-          c.status = "sent";
-        });
-        saveLedger(ledger);
-        return true;
-      })
-      .catch(function () {
-        return false; // gate gone — the rows stay queued for the next run
-      });
+    // WORKING survives a plain refresh of the same run (the reviewer already
+    // sent this round; approving the same render again would only 409), and
+    // ends the moment a newer run serves the page.
+    const working = !newRound && !!(ctx && ctx.working);
+    return { ledger, roundNo, working, newRound, ctx };
   }
 
   // Where a row stands, for the ledger rail / sidebar chip.
   function statusLabel(c) {
-    if (c.status === "queued") return "queued";
+    if (c.status === "draft") return "not sent yet";
     if (c.status === "addressed") {
       return "addressed" + (c.addressedInRound ? " · round " + c.addressedInRound : "");
     }
@@ -225,7 +207,7 @@ export function createGateSession(cfg) {
     }
     location.reload();
   }
-  // Always consumed at boot (a drain round must not leave the flag armed for a
+  // Always consumed at boot (a refresh must not leave the flag armed for a
   // later parked load), but only ACTED on when this round parks.
   function consumeRoundFlag() {
     try {
@@ -341,9 +323,7 @@ export function createGateSession(cfg) {
     saveLedger,
     saveCtx,
     saveCtxSoon,
-    queued,
     restore,
-    flushBacklog,
     statusLabel,
     notifyPermission,
     requestNotifyPermission,

package/src/builders/lint-fix.mjs

@@ -0,0 +1,88 @@
+// Deterministic autofixes for the two lint warnings agents statistically never
+// clear by hand (measured across seven sim campaigns: 7-66 unique warnings
+// left standing at the final build in 8/10 sessions, resistant to four
+// instruction shapes — see experiments/LEDGER.md). Both rewrites are safe
+// because the fixed value is derived from the file itself, never guessed:
+//
+//   1. An inline `<svg>` with a `viewBox` but no explicit `width`/`height`
+//      gets both, taken verbatim from the viewBox — the aspect the author
+//      drew is preserved exactly, and the render's aspect check stops
+//      drifting with the flex cell.
+//   2. `letter-spacing: <n>em` becomes px ONLY when the same declaration
+//      block names a px `font-size` to multiply against; without that context
+//      the correct px value is unknowable, so the declaration is left for the
+//      lint warning to report.
+//
+// Everything else the lint engine flags (raw colors, token choices, spacing
+// scales) is a judgment call and deliberately NOT auto-fixed.
+
+import fs from "node:fs";
+import path from "node:path";
+
+// Declaration blocks inside a <style> string or a style attribute: convert
+// `letter-spacing: Nem` when the SAME block carries `font-size: Mpx`.
+const DECL_BLOCK = /\{[^{}]*\}/g;
+const LS_EM = /letter-spacing\s*:\s*(-?[\d.]+)em/g;
+const FS_PX = /font-size\s*:\s*([\d.]+)px/;
+
+function fixLetterSpacingBlock(block) {
+  const fs_ = block.match(FS_PX);
+  if (!fs_) return null;
+  const base = Number(fs_[1]);
+  if (!Number.isFinite(base) || base <= 0) return null;
+  let changed = false;
+  const fixed = block.replace(LS_EM, (m, em) => {
+    const px = Math.round(Number(em) * base * 100) / 100;
+    if (!Number.isFinite(px)) return m;
+    changed = true;
+    return `letter-spacing: ${px}px`;
+  });
+  return changed ? fixed : null;
+}
+
+/** Fix one slide source. Returns { src, fixes } — fixes is a list of labels. */
+export function fixSlideSource(src) {
+  const fixes = [];
+  // NOTE: svg pinning (adding width/height from the viewBox) was measured to
+  // HARM fidelity and is disabled: the viewBox dimensions are drawing-space
+  // coordinates, not the layout size the author's flex cell implied, so the
+  // pinned svg resizes out of its cell (collisions/clipping) — the lint
+  // warning was satisfied by breaking the layout (sim batch 2026-08-28T06-34-11:
+  // fidelity 0.809 → 0.660). The correct px size is not statically knowable;
+  // that warning stays a judgment call for the author.
+  let out = src;
+  out = out.replace(DECL_BLOCK, (block) => {
+    const fixed = fixLetterSpacingBlock(block);
+    if (!fixed) return block;
+    fixes.push("letter-spacing-px");
+    return fixed;
+  });
+  return { src: out, fixes };
+}
+
+/**
+ * Fix every slides/*.jsx in a deck, writing only changed files.
+ * Returns { files: <changed file count>, fixes: <total fix count> }.
+ */
+export function fixDeckSlides(deckDir) {
+  const slidesDir = path.join(deckDir, "slides");
+  let files = 0;
+  let fixes = 0;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(slidesDir).filter((f) => f.endsWith(".jsx"));
+  } catch {
+    return { files, fixes };
+  }
+  for (const f of entries) {
+    const p = path.join(slidesDir, f);
+    const src = fs.readFileSync(p, "utf8");
+    const res = fixSlideSource(src);
+    if (res.fixes.length) {
+      fs.writeFileSync(p, res.src);
+      files += 1;
+      fixes += res.fixes.length;
+    }
+  }
+  return { files, fixes };
+}