slidemind 0.1.7 → 0.1.9

package/src/builders/red-thread-backbone.mjs

@@ -0,0 +1,194 @@
+/**
+ * Red-thread backbone editing.
+ *
+ * The red thread is the structural backbone of the plan: one presentation
+ * move per slide, mirrored by one `### Slide N` storyboard subsection. This
+ * module maps a user-edited backbone (renamed, reordered, added, or removed
+ * slides) back onto the plan markdown in one pass: it rewrites the
+ * `## Red thread` bullets and restructures the per-slide sections to match —
+ * reordering, renumbering headings and storyboard `slide` fields, dropping
+ * removed slides, and inserting placeholder sections for new ones.
+ *
+ * Pure string logic — no React, no Office (unit-testable).
+ *
+ * 1:1 port of the add-in's red-thread-backbone.ts. Top-level helpers are
+ * prefixed `rt…` so the browser bundle (one IIFE across five modules) has no
+ * name collisions; exported API names match the add-in verbatim.
+ */
+
+import { extractRedThreadMessages, findRedThreadSection } from "./storyboard-markdown.mjs";
+
+/**
+ * One slide in the user-edited backbone draft:
+ *   { key: string, originalIndex: number | null, message: string }
+ * `originalIndex` is the index into the original plan's slide sections, or
+ * null for a new slide.
+ */
+export function backboneFromMessages(messages) {
+  return messages.map((message, index) => ({
+    key: `slide-${index}`,
+    originalIndex: index,
+    message,
+  }));
+}
+
+const RT_SLIDE_HEADING_RE = /^###\s+Slide\s+\d+.*$/gim;
+const RT_NEXT_H2_IN_SECTION_RE = /^##\s/m;
+
+function rtFindSlideSections(markdown) {
+  const starts = [];
+  for (const match of markdown.matchAll(RT_SLIDE_HEADING_RE)) {
+    starts.push(match.index ?? 0);
+  }
+  return starts.map((start, index) => {
+    let end = starts[index + 1] ?? markdown.length;
+    // A later `## ` heading closes the storyboard area before the doc ends;
+    // search after the section's own heading line.
+    const headingLineEnd = markdown.indexOf("\n", start);
+    const searchFrom =
+      headingLineEnd === -1 ? end : Math.min(headingLineEnd + 1, end);
+    const followUp = RT_NEXT_H2_IN_SECTION_RE.exec(markdown.slice(searchFrom, end));
+    if (followUp) end = searchFrom + followUp.index;
+    return { start, end, text: markdown.slice(start, end) };
+  });
+}
+
+/**
+ * The backbone is editable only when the red-thread moves and the slide
+ * sections line up one-to-one — otherwise a positional restructure could
+ * attach the wrong storyboard to a move.
+ *
+ * Returns { messages, sectionCount } or null.
+ */
+export function parsePlanBackbone(markdown) {
+  const messages = extractRedThreadMessages(markdown);
+  if (!messages.length) return null;
+  if (!findRedThreadSection(markdown)) return null;
+  const sections = rtFindSlideSections(markdown);
+  if (sections.length !== messages.length) return null;
+  return { messages, sectionCount: sections.length };
+}
+
+function rtSanitizeMessage(message) {
+  return message.replace(/\s+/g, " ").trim();
+}
+
+function rtRenumberSection(text, slideNumber, editedMessage) {
+  let next = text.replace(/^###\s+Slide\s+\d+/, `### Slide ${slideNumber}`);
+  if (editedMessage) {
+    next = next.replace(
+      /^(###\s+Slide\s+\d+)(?::[^\n]*)?$/m,
+      `$1: ${editedMessage}`,
+    );
+  }
+  return next.replace(/("slide"\s*:\s*)\d+/, `$1${slideNumber}`);
+}
+
+const RT_NEW_SLIDE_CONTENT_MAX = 28;
+
+function rtPlaceholderSection(message, slideNumber) {
+  const content =
+    message.slice(0, RT_NEW_SLIDE_CONTENT_MAX).trim() || `Slide ${slideNumber}`;
+  const storyboard = {
+    version: 1,
+    slide: slideNumber,
+    blocks: [
+      {
+        id: "block-1",
+        x: 80,
+        y: 110,
+        w: 1440,
+        h: 300,
+        designElement: "Open canvas",
+        content,
+      },
+    ],
+    keyMessage: message,
+  };
+  return [
+    `### Slide ${slideNumber}: ${message}`,
+    "",
+    `Core message: ${message}`,
+    "",
+    "```storyboard-canvas",
+    JSON.stringify(storyboard, null, 2),
+    "```",
+  ].join("\n");
+}
+
+/**
+ * Turns a staged backbone draft into the feedback round that asks the agent
+ * to build it: the restructured plan markdown plus a feedback message naming
+ * each added/renamed slide. Returns null when the draft cannot be applied or
+ * contains no content-affecting change.
+ *
+ * Returns { feedback, editedPlanMarkdown } or null.
+ */
+export function stageStoryIteration(markdown, slides) {
+  const editedPlanMarkdown = applyPlanBackbone(markdown, slides);
+  if (!editedPlanMarkdown) return null;
+  const committed = extractRedThreadMessages(markdown);
+  const changes = [];
+  slides.forEach((slide, index) => {
+    const position = index + 1;
+    if (slide.originalIndex === null) {
+      changes.push(`Added slide ${position} for the move "${slide.message}".`);
+    } else if (committed[slide.originalIndex] !== slide.message) {
+      changes.push(`Renamed slide ${position}'s move to "${slide.message}".`);
+    }
+  });
+  if (!changes.length) return null;
+  const feedback = [
+    "I edited the red thread.",
+    ...changes,
+    "Build the storyboards and slide content for the new moves and adapt any renamed moves so the deck stays coherent, keeping the other slides intact.",
+  ].join(" ");
+  return { feedback, editedPlanMarkdown };
+}
+
+/**
+ * Rewrites the plan markdown to match the edited backbone. Returns null when
+ * the plan's structure cannot be edited safely (see `parsePlanBackbone`).
+ */
+export function applyPlanBackbone(markdown, slides) {
+  const cleaned = slides
+    .map((slide) => ({ ...slide, message: rtSanitizeMessage(slide.message) }))
+    .filter((slide) => slide.message.length > 0);
+  if (!cleaned.length) return null;
+
+  const backbone = parsePlanBackbone(markdown);
+  const redThread = findRedThreadSection(markdown);
+  if (!backbone || !redThread) return null;
+  const sections = rtFindSlideSections(markdown);
+
+  const firstSection = sections[0];
+  const lastSection = sections[sections.length - 1];
+  if (!firstSection || !lastSection) return null;
+  if (firstSection.start < redThread.bodyEnd) return null;
+
+  const newRedThreadBody = `\n\n${cleaned
+    .map((slide) => `- ${slide.message}`)
+    .join("\n")}\n\n`;
+
+  const newSections = cleaned.map((slide, index) => {
+    const slideNumber = index + 1;
+    if (slide.originalIndex === null) {
+      return rtPlaceholderSection(slide.message, slideNumber);
+    }
+    const section = sections[slide.originalIndex];
+    if (!section) return rtPlaceholderSection(slide.message, slideNumber);
+    const originalMessage = backbone.messages[slide.originalIndex] ?? "";
+    const edited =
+      rtSanitizeMessage(originalMessage) !== slide.message ? slide.message : null;
+    return rtRenumberSection(section.text.trimEnd(), slideNumber, edited);
+  });
+
+  return [
+    markdown.slice(0, redThread.bodyStart),
+    newRedThreadBody,
+    markdown.slice(redThread.bodyEnd, firstSection.start),
+    newSections.join("\n\n"),
+    "\n",
+    markdown.slice(lastSection.end),
+  ].join("");
+}

package/src/builders/resolve-skill.mjs

@@ -176,17 +176,52 @@ export function resolveSkill(skillName, planMeta = {}, opts = {}) {
 // plan.md frontmatter
 // ---------------------------------------------------------------------------
 
+// Split a plan.md into its YAML-ish frontmatter fence and the markdown body,
+// LOSSLESSLY: `frontmatterRaw + body === text` byte-for-byte for every input.
+// Same fence rule as the frontmatter parser: frontmatter exists iff the text
+// starts with "---" and there is a later "\n---". `frontmatterRaw` runs through
+// the END of the closing fence line INCLUDING its trailing newline (or the whole
+// text, with an empty body, when the closing fence is the last line and carries
+// no trailing newline). `bodyStartLine` is the 1-based line the body begins on
+// (= count of "\n" in frontmatterRaw + 1). With no frontmatter the whole text is
+// the body and `bodyStartLine` is 1.
+export function splitPlanFrontmatter(text) {
+  const s = String(text);
+  if (!s.startsWith("---")) {
+    return { frontmatterRaw: "", body: s, bodyStartLine: 1 };
+  }
+  const end = s.indexOf("\n---", 3);
+  if (end < 0) {
+    return { frontmatterRaw: "", body: s, bodyStartLine: 1 };
+  }
+  // The closing fence line starts at end+1 (the first "-"); it ends at the next
+  // newline. frontmatterRaw includes that newline so the body starts clean.
+  const nlAfterFence = s.indexOf("\n", end + 1);
+  let frontmatterRaw;
+  let body;
+  if (nlAfterFence < 0) {
+    frontmatterRaw = s; // closing fence at EOF, no trailing newline
+    body = "";
+  } else {
+    frontmatterRaw = s.slice(0, nlAfterFence + 1);
+    body = s.slice(nlAfterFence + 1);
+  }
+  const bodyStartLine = (frontmatterRaw.match(/\n/g) || []).length + 1;
+  return { frontmatterRaw, body, bodyStartLine };
+}
+
 function readPlanFrontmatter(deckDir) {
   if (!deckDir) return {};
   const file = path.join(deckDir, "plan.md");
   if (!fs.existsSync(file)) return {};
   const text = fs.readFileSync(file, "utf8");
-  if (!text.startsWith("---")) return {};
-  const end = text.indexOf("\n---", 3);
-  if (end < 0) return {};
-  const body = text.slice(3, end);
+  const { frontmatterRaw } = splitPlanFrontmatter(text);
+  if (!frontmatterRaw) return {}; // no frontmatter fence → {}, exactly as before
+  // Parse key: value fields out of the fence block. The two "---" fence lines
+  // never match the field regex, so scanning the whole raw block is equivalent
+  // to scanning strictly between the fences.
   const out = {};
-  for (const line of body.split("\n")) {
+  for (const line of frontmatterRaw.split("\n")) {
     const m = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.+?)\s*$/);
     if (m) out[m[1]] = stripQuotes(m[2]);
   }

package/src/builders/review-overlay.js

@@ -120,6 +120,7 @@
     "@keyframes sm-pin-in{from{transform:translate(-50%,-50%) scale(0)}to{transform:translate(-50%,-50%) scale(1)}}" +
     "@keyframes sm-veil-in{from{opacity:0}to{opacity:1}}" +
     "@keyframes sm-rise{from{opacity:0;transform:translateY(14px)}to{opacity:1;transform:none}}" +
+    "@keyframes sm-pulse{0%,100%{opacity:.45}50%{opacity:.85}}" +
     ":root{--sm-bg:var(--deck-chrome-bg,#111113);--sm-surface:var(--deck-chrome-bg-2,#161618);" +
     "--sm-border:var(--deck-chrome-border,#2b2b30);--sm-fg:var(--deck-chrome-fg,#ededed);" +
     "--sm-dim:var(--deck-chrome-dim,#9a9aa0);--sm-accent:#a9c2ff;--sm-success:#2ecc71;--sm-danger:#f87171;" +
@@ -143,6 +144,9 @@
     ".sm-meta{display:flex;flex-direction:column;gap:2px;}" +
     ".sm-meta .t{font-weight:600;font-size:13px;}" +
     ".sm-meta .h{font-size:11.5px;color:var(--sm-dim);}" +
+    ".sm-note{max-width:min(560px,38vw);font-size:10.5px;line-height:1.35;color:#c7c7cf;" +
+    "border-left:2px solid var(--sm-accent);padding-left:10px;}" +
+    ".sm-note b{font-weight:600;color:#f4f4f5;}" +
     ".sm-bar~.deck__rail,.deck__rail{top:var(--deck-chrome-h,62px);}" +
     ".sm-grow{flex:1;}" +
     ".sm-count{font-size:12px;color:var(--sm-dim);font-variant-numeric:tabular-nums;}" +
@@ -195,6 +199,7 @@
     ".sm-veil .status{display:flex;align-items:center;gap:10px;font-size:18px;font-weight:600;animation:sm-rise .6s .12s cubic-bezier(.2,.7,.2,1) both;}" +
     ".sm-veil .status svg{width:24px;height:24px;color:var(--sm-success);}" +
     ".sm-veil .sub{color:var(--sm-dim);font-size:13.5px;animation:sm-rise .6s .18s cubic-bezier(.2,.7,.2,1) both;}" +
+    ".sm-veil .sub.sm-pulse{animation:sm-rise .6s .18s cubic-bezier(.2,.7,.2,1) both,sm-pulse 2s .9s ease-in-out infinite;}" +
     /* hover box */
     ".sm-hover{position:fixed;z-index:2147483450;pointer-events:none;border-radius:5px;border:2px solid var(--sm-accent);" +
     "box-shadow:0 0 0 1px rgba(0,0,0,.3),0 6px 22px rgba(0,0,0,.28);opacity:0;" +
@@ -317,7 +322,7 @@
   }
 
   // ---------- chrome (top bar) ----------
-  var bar, sendBtn, countLabel;
+  var bar, sendBtn, approveBtn, countLabel;
   function buildChrome() {
     bar = el("div", "sm-o sm-bar");
     bar.setAttribute("data-sm-overlay", "1");
@@ -333,6 +338,13 @@
     meta.appendChild(el("div", "h", "Click any element to comment · ← → to switch slide"));
     bar.appendChild(meta);
 
+    var note = el(
+      "div",
+      "sm-note",
+      "<b>Ask for slide changes here.</b> Direct PowerPoint edits after approval are not tracked and may be overwritten. HTML preview may differ slightly from final PowerPoint.",
+    );
+    bar.appendChild(note);
+
     bar.appendChild(el("div", "sm-grow"));
 
     countLabel = el("div", "sm-count");
@@ -345,8 +357,9 @@
     };
     bar.appendChild(sendBtn);
 
-    var approveBtn = mkButton("Approve & continue", "primary", "check");
+    approveBtn = mkButton("Approve & continue", "primary", "check");
     approveBtn.onclick = function () {
+      if (totalComments() > 0) return;
       submit("approve");
     };
     bar.appendChild(approveBtn);
@@ -360,6 +373,11 @@
     sendBtn.querySelector("span").textContent =
       n > 0 ? "Send " + n + " comment" + (n === 1 ? "" : "s") : "Send comments";
     sendBtn.classList.toggle("is-off", n === 0);
+    approveBtn.disabled = n > 0;
+    approveBtn.setAttribute("aria-disabled", n > 0 ? "true" : "false");
+    approveBtn.classList.toggle("is-off", n > 0);
+    approveBtn.title =
+      n > 0 ? "Send or delete active comments before approving." : "Approve and continue.";
   }
 
   // ---------- hover box (mirrors the add-in's hit-region-overlay) ----------
@@ -676,10 +694,96 @@
     lockHoverBoxToBbox(comment.resolvedTarget && comment.resolvedTarget.bbox);
   }
 
+  // ---------- next-round attention ----------
+  // Same trio as plan-overlay.js: a background tab cannot steal focus (browser
+  // design), but it CAN fire a system notification whose click is allowed to
+  // focus it, and flag itself in the tab bar until it is looked at. The
+  // permission prompt only shows inside a user gesture, so it is requested at
+  // the send-comments click; the "announce" wish survives the reload via
+  // sessionStorage (the reload wipes this JS context).
+  var ROUND_READY_FLAG = "slidemind-review-round-ready";
+  var ATTENTION_TITLE = "● Preview ready — slidemind";
+  var WAITING_TITLE = "⏳ Agent revising slides — slidemind";
+  var notifyPermPromise = null;
+
+  function notifyPermission() {
+    try {
+      return "Notification" in window ? Notification.permission : "unsupported";
+    } catch {
+      return "unsupported";
+    }
+  }
+  function requestNotifyPermission() {
+    try {
+      if (!("Notification" in window)) return Promise.resolve("unsupported");
+      if (Notification.permission !== "default") return Promise.resolve(Notification.permission);
+      return Promise.resolve(Notification.requestPermission());
+    } catch {
+      return Promise.resolve("unsupported");
+    }
+  }
+  function markRoundReadyAndReload() {
+    try {
+      sessionStorage.setItem(ROUND_READY_FLAG, "1");
+    } catch {
+      /* storage blocked — the reload still lands, just without the announce */
+    }
+    location.reload();
+  }
+  function announceNewRound() {
+    var flagged = false;
+    try {
+      flagged = sessionStorage.getItem(ROUND_READY_FLAG) === "1";
+      if (flagged) sessionStorage.removeItem(ROUND_READY_FLAG);
+    } catch {
+      /* no storage — nothing to announce */
+    }
+    if (!flagged) return;
+    try {
+      window.focus(); // best-effort; most browsers ignore it for background tabs
+    } catch {
+      /* ignore */
+    }
+    if (!document.hidden) return; // user is already looking at it
+    var origTitle = document.title;
+    var restore = function () {
+      document.title = origTitle;
+      document.removeEventListener("visibilitychange", onVis);
+      window.removeEventListener("focus", restore);
+    };
+    var onVis = function () {
+      if (!document.hidden) restore();
+    };
+    document.title = ATTENTION_TITLE;
+    document.addEventListener("visibilitychange", onVis);
+    window.addEventListener("focus", restore);
+    try {
+      if (notifyPermission() === "granted") {
+        var n = new Notification("slidemind — preview ready", {
+          body: "The revised slides are ready for another look. Click to jump back to the tab.",
+          tag: "slidemind-review-round",
+        });
+        n.onclick = function () {
+          try {
+            window.focus();
+          } catch {
+            /* ignore */
+          }
+          n.close();
+        };
+      }
+    } catch {
+      /* notification construction can throw on some platforms — title marker stands */
+    }
+  }
+
   // ---------- submit ----------
   function submit(decision) {
     if (submitted) return;
     submitted = true;
+    // Ask for notification permission HERE — the send/approve click is a user
+    // gesture, the only context where the browser will show the prompt.
+    if (decision === "comments") notifyPermPromise = requestNotifyPermission();
     var comments = [];
     Object.keys(commentsBySlide).forEach(function (stem) {
       commentsBySlide[stem].forEach(function (c) {
@@ -695,8 +799,13 @@
       }),
     })
       .then(function () {
-        showDone(decision);
-        requestTabClose();
+        if (decision === "approve") {
+          showDone("approve");
+          requestTabClose();
+        } else {
+          showWaiting();
+          startNextRoundPolling();
+        }
       })
       .catch(function () {
         submitted = false;
@@ -713,24 +822,92 @@
       }
     }, 120);
   }
-  function showDone(decision) {
+  // After a comments round the tab stays open and polls the heartbeat so the
+  // NEXT run (which binds the same deterministic port) reloads this tab instead
+  // of opening a fresh browser window. The poll reports this tab's round nonce
+  // and its visibility: only a VISIBLE tab may claim the next round for reuse —
+  // a tab buried in a background window must not swallow the round invisibly,
+  // so the server opens a fresh browser tab instead and answers `action:
+  // "close"` here, which retires this tab with a notice rather than reloading
+  // it into a hidden duplicate.
+  function startNextRoundPolling() {
+    var startedAt = Date.now();
+    var pollMs = CFG.pollMs || 1000;
+    var ttl = CFG.pollTtlMs || 35 * 60 * 1000;
+    var hb = CFG.heartbeat || "/__review/heartbeat";
+    var timer = setInterval(function () {
+      if (Date.now() - startedAt > ttl) {
+        clearInterval(timer);
+        showSessionEnded();
+        return;
+      }
+      var visible = document.visibilityState === "visible" ? "1" : "0";
+      var url = hb + (hb.indexOf("?") < 0 ? "?" : "&") +
+        "round=" + encodeURIComponent(CFG.round || "") + "&visible=" + visible;
+      fetch(url, { cache: "no-store" })
+        .then(function (r) { return r.ok ? r.json() : null; })
+        .then(function (data) {
+          // Act only on a genuine NEWER slidemind review round: shape-guard the
+          // service marker (a foreign app may have taken the port) and require a
+          // different nonce (same nonce = this run's own orphan — never self-reload).
+          if (!data || data.service !== "slidemind-review" || !data.round) return;
+          if (data.round === CFG.round) return;
+          if (data.action === "close") {
+            // The new round opened in a fresh browser tab — this one is stale.
+            clearInterval(timer);
+            showSuperseded();
+            return;
+          }
+          if (data.action === "wait") return; // grace window still deciding — keep polling
+          clearInterval(timer);
+          markRoundReadyAndReload();
+        })
+        .catch(function () { /* server down between rounds — keep polling */ });
+    }, pollMs);
+  }
+  // Shared full-screen veil (logo + wordmark + status + sub). Replaces any veil
+  // already shown rather than stacking a second one, so a comments round's
+  // "waiting" veil can be swapped for "session ended" in place.
+  function showVeil(statusHtml, subText, subPulse) {
     closePopover();
     if (pinLayer) pinLayer.style.display = "none";
     if (bar) bar.style.display = "none";
+    var existing = document.querySelector(".sm-veil[data-sm-overlay]");
+    if (existing && existing.parentNode) existing.parentNode.removeChild(existing);
     var veil = el("div", "sm-o sm-veil");
     veil.setAttribute("data-sm-overlay", "1");
     veil.appendChild(logoNode("sm-logo", "-v"));
     veil.appendChild(el("div", "word", wordmarkHtml()));
-    veil.appendChild(
-      el(
-        "div",
-        "status",
-        ICONS.check + "<span>" + (decision === "approve" ? "Approved" : "Comments sent") + "</span>",
-      ),
-    );
-    veil.appendChild(el("div", "sub", "Returned to your terminal."));
+    veil.appendChild(el("div", "status", statusHtml));
+    veil.appendChild(el("div", "sub" + (subPulse ? " sm-pulse" : ""), subText));
     document.body.appendChild(veil);
   }
+  function showDone() {
+    showVeil(ICONS.check + "<span>Approved</span>", "Returned to your terminal.");
+  }
+  function showWaiting() {
+    document.title = WAITING_TITLE; // the tab label signals the state from the tab bar
+    showVeil(
+      ICONS.check + "<span>Comments sent</span>",
+      "The agent is revising the slides — this tab refreshes automatically when the next round is ready.",
+      true,
+    );
+    (notifyPermPromise || Promise.resolve(notifyPermission())).then(function (perm) {
+      if (perm !== "granted") return;
+      var sub = document.querySelector(".sm-veil[data-sm-overlay] .sub");
+      if (sub) sub.textContent += " You'll get a notification the moment it's ready.";
+    });
+  }
+  function showSessionEnded() {
+    showVeil("<span>Session ended</span>", "You can close this tab.");
+  }
+  function showSuperseded() {
+    document.title = "Review moved — slidemind";
+    showVeil(
+      "<span>Continued in a new tab</span>",
+      "The next review round opened in a fresh browser tab — you can close this one.",
+    );
+  }
 
   // ---------- slide tracking ----------
   function syncSlideFromNav() {
@@ -826,6 +1003,7 @@
     }
     syncSlideFromNav();
     applyStageFit();
+    announceNewRound(); // notification + title marker when this load IS the next round
   }
 
   if (document.readyState === "loading") {