slidemind 0.3.4 → 0.3.12

package/src/builders/review.mjs

@@ -12,17 +12,14 @@
 //                  the click position, and a readonly-layout note where relevant
 //                  (the agent edits the cited files and re-runs review).
 //
-// ASYNC REVIEW (the drain loop, shared with the plan gate). Saving a pin sends
-// it AT ONCE and the tab does not veil over: the preview stays fully browsable
-// and pinnable in WORKING mode, and further pins queue in the tab's
-// sessionStorage. When the agent re-runs this command the waiting tab reloads
-// (heartbeat claim) and its boot script POSTs that backlog to /review/backlog.
-// A non-empty backlog resolves the gate immediately with those pins (a "drain
-// round": DECISION: comments prints and the command exits without ever
-// parking), so several consecutive comment rounds are the normal shape of a
-// review. An empty backlog never POSTs and the run parks and blocks as before.
-// Approve is refused once a backlog arrived in this run — that render is
-// already superseded by pins the agent has been told to fix.
+// ROUNDS ARE SYNCHRONOUS (add-in parity). The reviewer drops as many pins as
+// they like — those are unsent DRAFTS in the tab — then clicks "Send comments",
+// which resolves the gate with the whole batch and the command exits with
+// DECISION: comments. Approve is refused while unsent drafts exist. While the
+// agent works the tab is in WORKING mode: browsable, no new pins, no approve;
+// the next `slidemind review` run reloads that same tab with the new render and
+// the delivered pins as read-only ghosts. Nothing is queued behind the agent's
+// back and no run ever returns without the reviewer acting on it.
 //
 // Host-free: it reviews the HTML preview BEFORE any .pptx render, so it needs a
 // previously-materialized bundle (like `slidemind build`) but no open host.
@@ -42,6 +39,7 @@
 // ALWAYS opened and the stale tab retires itself; the review must never sit
 // invisible while the user thinks nothing happened.
 
+import crypto from "node:crypto";
 import fs from "node:fs";
 import http from "node:http";
 import path from "node:path";
@@ -57,7 +55,6 @@ import {
   createHeartbeat,
   bundleGateSession,
   normalizeGateComments,
-  serveBacklogPost,
   serveDecisionPost,
   listenWithFallback,
   preferredGatePort,
@@ -73,10 +70,12 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const OVERLAY_PATH = path.join(__dirname, "review-overlay.js");
 const REVIEW_STATE_FILE = "review.json";
-// Keep the review preview available for a working session, then let the
-// existing finally block close the local server when the decision or timeout
-// resolves.
-const DEFAULT_TIMEOUT_MS = 5 * 60 * 60 * 1000;
+// No decision timeout: the gate returns only on the user's decision (or when
+// no browser could be opened at all — see openFailedGraceMs). An agent cannot
+// deliver a preview a human has not approved, so the process waits as long as
+// the human does; a harness that backgrounds the call gets the decision when it
+// lands. Pass timeoutMs explicitly to cap the wait (tests).
+const DEFAULT_TIMEOUT_MS = null;
 
 function clamp01(n) {
   return n < 0 ? 0 : n > 1 ? 1 : n;
@@ -125,8 +124,7 @@ function readSourceLine(deckDir, parsed) {
 // Every row keeps its spatial anchor (jsxPath + resolvedTarget.loc + the click
 // position as FULL-PRECISION 0..1 fractions of the slide); the shared core adds
 // identity (`id` dedupes a client retry, `round` says which render the pin was
-// dropped on — a queued pin is delivered a round later, so the two can differ)
-// and drops text-less rows.
+// dropped on) and drops text-less rows.
 //
 // x/y are deliberately NOT quantized. Whole percent was ±6px of ghost-pin drift
 // on a 1280px stage and collapsed every sub-1% offset; percent is a DISPLAY
@@ -141,13 +139,13 @@ export function normalizeReviewComments(raw) {
     // The status a delivered pin carries: the agent is about to work it. A
     // later run serves these back as the ledger seed, where they stay "sent" —
     // the agent has them, but nothing has answered them yet.
-    status: c.status === "queued" || c.status === "addressed" ? c.status : "sent",
+    status: c.status === "addressed" ? "addressed" : "sent",
   }));
 }
 
 // Render the comment round for the harness — ports the add-in's
 // formatPreviewCommentsForLlm, adapted to CLI commands.
-export function formatCommentsForHarness(deckDir, comments, { drained = false } = {}) {
+export function formatCommentsForHarness(deckDir, comments) {
   const rows = normalizeReviewComments(comments);
   const n = rows.length;
   const out = [];
@@ -155,18 +153,11 @@ export function formatCommentsForHarness(deckDir, comments, { drained = false }
   out.push(
     `The user left ${n} comment${n === 1 ? "" : "s"} on the preview. Nothing was exported.`,
   );
-  if (drained) {
-    out.push(
-      "(These were queued while you were fixing and arrived with this run — that is " +
-        "why the gate returned immediately instead of waiting.)",
-    );
-  }
   out.push("");
   rows.forEach((c, i) => {
     const region = c.resolvedTarget || null;
     const parsed = region ? parseLoc(region.loc) : null;
-    // The round tag is load-bearing: a pin queued during a fix names the render
-    // it was dropped on, which may be one behind the files you are looking at.
+    // The round tag names the render the pin was dropped on.
     const head = `[${i + 1}, round ${c.round}] ${c.jsxPath} — `;
     // Percent is the unit the AGENT reads; the stored anchor stays full precision.
     const x = clamp01(c.x);
@@ -210,19 +201,16 @@ export function formatCommentsForHarness(deckDir, comments, { drained = false }
   );
   out.push("");
   // Imperative, stateful tail (mirrors plan.mjs's formatPlanCommentsForHarness):
-  // the reviewer's tab is LIVE while you fix — they keep browsing the preview and
-  // keep dropping pins — and those pins are only delivered by the next
-  // `slidemind review` run. An agent that ends its turn here strands them.
-  out.push("Fix exactly what the comments ask for at the cited lines — a pin may");
-  out.push("reference the PREVIOUS render (see its round tag), so read the file before");
-  out.push("you edit. Then re-run the gate in the same turn:");
+  // the reviewer's tab is waiting on the next `slidemind review` run — nothing
+  // reaches them until it runs. An agent that ends its turn here strands them.
+  out.push("Fix exactly what the comments ask for at the cited lines — read the file");
+  out.push("before you edit. Then re-run the gate in the same turn:");
   out.push("  1. Edit the cited slides/*.jsx file(s) at the given lines.");
   out.push(`  2. Re-run: slidemind review ${path.basename(deckDir)}`);
   out.push("The re-run rebuilds the preview and reopens their same tab (addressed pins");
-  out.push("show as ghost pins). The user may queue further comments while you fix; they");
-  out.push("are delivered on that next run, which can return immediately with them — that");
-  out.push("is normal, not an error. Do NOT end your turn, do NOT export anything, and do");
-  out.push("NOT send the user back to the browser before step 2.");
+  out.push("show as ghost pins), and the user reviews again — several rounds are normal.");
+  out.push("Do NOT end your turn, do NOT export anything, and do NOT send the user back");
+  out.push("to the browser before step 2.");
   return out.join("\n") + "\n";
 }
 
@@ -230,11 +218,13 @@ export function formatCommentsForHarness(deckDir, comments, { drained = false }
 // formatPlanPendingForHarness: an expected state with resume instructions, not
 // a failure and never an implicit approval.
 export function formatReviewPendingForHarness(deckDir, { timeoutMs, pageLoaded, url } = {}) {
-  const mins = Math.max(1, Math.round((timeoutMs ?? DEFAULT_TIMEOUT_MS) / 60000));
   const base = path.basename(deckDir);
+  const waited = timeoutMs
+    ? `the gate waited ${Math.max(1, Math.round(timeoutMs / 60000))} minutes and the user hasn't answered.`
+    : "the gate closed without an answer from the user.";
   return [
     "DECISION: pending",
-    `No decision yet — the gate waited ${mins} minutes and the user hasn't answered.`,
+    `No decision yet — ${waited}`,
     ...pendingBrowserLines({ pageLoaded, url }),
     "This is NOT an approval and NOT a rejection. Do not push or export anything.",
     "Close out your turn gracefully:",
@@ -249,7 +239,6 @@ export function formatReviewPendingForHarness(deckDir, { timeoutMs, pageLoaded,
 function injectReview(html, cfgExtra, overlayJs, logoMark = null, round = null) {
   const cfg = safeInlineJson({
     endpoint: "/review",
-    backlogEndpoint: "/review/backlog",
     heartbeat: "/__review/heartbeat",
     round,
     pollMs: POLL_MS,
@@ -283,6 +272,7 @@ export function loadReviewState(deckDir) {
       version: 2,
       decision: data.decision ?? null,
       comments: normalizeReviewComments(data.comments),
+      deckHash: data.deckHash ?? null,
       at: data.at ?? null,
     };
   } catch {
@@ -290,6 +280,56 @@ export function loadReviewState(deckDir) {
   }
 }
 
+// What the user reviewed: every file under slides/ (jsx + reused native .pptx)
+// and assets/ (downloaded imagery), hashed by path + bytes. Recorded with the
+// decision and re-checked by push/build-pptx, so an approval binds to exactly
+// the content the user saw — any edit after the checkmark sends the deck back
+// through the gate.
+export function hashDeckContent(deckDir) {
+  const h = crypto.createHash("sha256");
+  const walk = (dir) => {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => (a.name < b.name ? -1 : 1))) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile()) {
+        h.update(path.relative(deckDir, p).split(path.sep).join("/"));
+        h.update("\0");
+        h.update(fs.readFileSync(p));
+        h.update("\0");
+      }
+    }
+  };
+  for (const sub of ["slides", "assets"]) walk(path.join(deckDir, sub));
+  return h.digest("hex");
+}
+
+// The human checkmark push/build-pptx require — enforced by the CLI, not by the
+// skill's prose. null = approved and unchanged since; otherwise the agent-facing
+// reason plus the command that clears it.
+export function requireReviewApproved(deckDir) {
+  const base = path.basename(deckDir);
+  const state = loadReviewState(deckDir);
+  if (state.decision !== "approve") {
+    return (
+      `${base} has not passed the preview review — a human must approve it first: ` +
+      `run \`slidemind review ${base}\` and wait for DECISION: approved.`
+    );
+  }
+  if (state.deckHash !== hashDeckContent(deckDir)) {
+    return (
+      `${base}'s slides changed since the user approved the preview — ` +
+      `re-run \`slidemind review ${base}\` for a fresh sign-off.`
+    );
+  }
+  return null;
+}
+
 function saveReviewState(deckDir, state) {
   fs.writeFileSync(
     path.join(deckDir, REVIEW_STATE_FILE),
@@ -344,29 +384,17 @@ export async function createReviewServer({
     const u = new URL(req.url, "http://127.0.0.1");
     const pathname = decodeURIComponent(u.pathname);
 
-    // Both POST routes are gate-server's shared handlers: the backlog drain and
-    // the decision + 409 guard behave identically in both gates. `gate.settled()`
-    // guards BOTH: once one tab's drain or decision resolved this run, a late
-    // POST from another waiting tab is refused instead of being acked and
-    // silently dropped (every waiter reloads into a new round, so two tabs
-    // posting into one run is the normal multi-window case, not an anomaly).
-    if (req.method === "POST" && pathname === "/review/backlog") {
-      serveBacklogPost(req, res, {
-        normalize: normalizeReviewComments,
-        isSuperseded: () => gate.settled(),
-        onDrained: (comments) => {
-          gate.resolve({ decision: "comments", comments, drained: true });
-        },
-      });
-      return;
-    }
-
+    // The decision POST is gate-server's shared handler: the 409 guard behaves
+    // identically in both gates. `gate.settled()` refuses a late POST from
+    // another waiting tab instead of acking and silently dropping it (every
+    // waiter reloads into a new round, so two tabs posting into one run is the
+    // normal multi-window case, not an anomaly).
     if (req.method === "POST" && pathname === "/review") {
       serveDecisionPost(req, res, {
         normalize: normalizeReviewComments,
         isSuperseded: () => gate.settled(),
         onDecision: (decision, _payload, comments) => {
-          gate.resolve({ decision, comments, drained: false });
+          gate.resolve({ decision, comments });
         },
       });
       return;
@@ -400,7 +428,10 @@ export async function createReviewServer({
       // actually opened in front of the user (see gate-server's page-load
       // tracker; serveAndOpen and the pending contract report from it).
       hb.notePageLoad();
-      res.writeHead(200, { "Content-Type": MIME[".html"] });
+      res.writeHead(200, {
+        "Content-Type": MIME[".html"],
+        "Cache-Control": "no-store, max-age=0",
+      });
       res.end(indexHtml);
       return;
     }
@@ -473,7 +504,30 @@ export async function runReview({
   openFailedGraceMs = OPEN_FAILED_GRACE_MS,
 } = {}) {
   await buildDeck(deckDir);
+
+  // Headless simulation runs (scripts/codex-sim.mjs): approve without a browser.
+  // buildDeck still ran above, so lint/build errors surface before the approve.
+  if (process.env.SLIDEMIND_GATE_AUTOAPPROVE === "1") {
+    saveReviewState(deckDir, {
+      version: 2,
+      decision: "approve",
+      comments: [],
+      deckHash: hashDeckContent(deckDir),
+      at: new Date().toISOString(),
+    });
+    process.stdout.write(
+      "DECISION: approved\n" +
+        "Auto-approved via SLIDEMIND_GATE_AUTOAPPROVE — no human reviewed this preview. " +
+        "Proceed to produce the output (slidemind push / slidemind build-pptx).\n",
+    );
+    return { decision: "approve", comments: [] };
+  }
+
   const prev = loadReviewState(deckDir);
+  // Hashed after buildDeck (it copies brand assets into assets/) and before the
+  // gate opens: the agent is blocked while the user reviews, so this IS the
+  // content the decision refers to.
+  const deckHash = hashDeckContent(deckDir);
   // The review window's logo is the add-in's genuine per-brand orb: a PNG
   // shipped on the bundle as a role-keyed asset (copied into the deck by
   // buildDeck). The review UI is dark, so prefer the dark variant. When absent
@@ -494,9 +548,8 @@ export async function runReview({
     open,
     graceMs: prev.decision === "comments" ? GRACE_MS : 0,
     waitLine:
-      `Waiting for the user's decision — this command BLOCKS (up to ${Math.round(
-        timeoutMs / 60000,
-      )} min) while they review. A long quiet wait is normal; do not cancel it.`,
+      "Waiting for the user's decision — this command BLOCKS until they decide; there is no " +
+      "timeout. A long quiet wait is normal; do not cancel it, and do nothing else meanwhile.",
   });
 
   let decision;
@@ -539,6 +592,7 @@ export async function runReview({
     version: 2,
     decision: decision.decision,
     comments,
+    deckHash,
     at: new Date().toISOString(),
   });
 
@@ -550,7 +604,7 @@ export async function runReview({
     );
   } else {
     process.stdout.write(
-      formatCommentsForHarness(deckDir, comments, { drained: !!decision.drained }),
+      formatCommentsForHarness(deckDir, comments),
     );
   }
   return decision;

package/src/builders/storyboard-markdown.mjs

@@ -116,3 +116,18 @@ export function replaceStoryboardSegment(markdown, segment, nextData) {
     segment.end,
   )}`;
 }
+
+// Deck-level layout knob: binds EVERY valid storyboard fence to `layout`.
+// Fences are spliced last-to-first so earlier offsets stay valid; malformed
+// fences are left untouched. Mirrors the add-in's setStoryboardLayoutForAll.
+export function setStoryboardLayoutForAll(markdown, layout) {
+  let next = markdown;
+  const boards = splitPlanMarkdownIntoSegments(markdown).filter(
+    (segment) => segment.type === "storyboard" && segment.data !== null,
+  );
+  for (const segment of boards.reverse()) {
+    if (segment.data.layout === layout) continue;
+    next = replaceStoryboardSegment(next, segment, { ...segment.data, layout });
+  }
+  return next;
+}

package/src/builders/storyboard-schema.mjs

@@ -25,8 +25,12 @@ export const MAX_DESIGN_ELEMENT_LENGTH = 56;
 export const MAX_CONTENT_LENGTH = 28;
 const SB_MAX_KEY_MESSAGE_LENGTH = 180;
 const SB_MAX_VISUAL_FAMILY_LENGTH = 64;
+const SB_MAX_LAYOUT_NAME_LENGTH = 64;
 const SB_MAX_DEPTH_NOTES = 6;
 const SB_MAX_DEPTH_NOTE_LENGTH = 220;
+export const MAX_IMAGE_PROMPT_LENGTH = 240;
+const SB_MAX_IMAGE_PROMPTS = 4;
+const SB_IMAGE_PROMPT_KEY = /^image\d{0,2}$/;
 
 function sbIsRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -139,12 +143,12 @@ export function parseStoryboardCanvas(raw) {
     warnings.push(`Only the first ${MAX_BLOCKS} storyboard blocks are shown.`);
   }
 
-  if (blocks.length === 0) {
-    return {
-      data: null,
-      warnings,
-      error: "Storyboard needs at least one valid block.",
-    };
+  // An empty block list is a valid storyboard: a cover or closing slide whose
+  // layout carries the text itself has no content blocks. Rejecting it dropped
+  // the slide from concept generation — and shifted the server's slideCount so
+  // the LAST slide fell off the request list too.
+  if (rawBlocks.length > 0 && blocks.length === 0) {
+    warnings.push("No storyboard block was valid; the canvas is empty.");
   }
 
   const keyMessage = sbAsTrimmedString(parsed.keyMessage, SB_MAX_KEY_MESSAGE_LENGTH);
@@ -152,6 +156,17 @@ export function parseStoryboardCanvas(raw) {
     parsed.visualFamily,
     SB_MAX_VISUAL_FAMILY_LENGTH,
   );
+  const layout = sbAsTrimmedString(parsed.layout, SB_MAX_LAYOUT_NAME_LENGTH);
+  const imagePrompts = {};
+  if (sbIsRecord(parsed.imagePrompts)) {
+    for (const [key, value] of Object.entries(parsed.imagePrompts)) {
+      if (!SB_IMAGE_PROMPT_KEY.test(key)) continue;
+      const prompt = sbAsTrimmedString(value, MAX_IMAGE_PROMPT_LENGTH);
+      if (!prompt) continue;
+      imagePrompts[key] = prompt;
+      if (Object.keys(imagePrompts).length >= SB_MAX_IMAGE_PROMPTS) break;
+    }
+  }
   const rawContentNotes = Array.isArray(parsed.contentNotes)
     ? parsed.contentNotes
     : parsed.depthNotes;
@@ -168,8 +183,10 @@ export function parseStoryboardCanvas(raw) {
       slide,
       blocks,
       ...(visualFamily ? { visualFamily } : {}),
+      ...(layout ? { layout } : {}),
       ...(keyMessage ? { keyMessage } : {}),
       ...(contentNotes?.length ? { contentNotes } : {}),
+      ...(Object.keys(imagePrompts).length > 0 ? { imagePrompts } : {}),
     },
     warnings,
   };

package/src/builders/visual-families.mjs

@@ -4,6 +4,20 @@ import { splitPlanMarkdownIntoSegments } from "./storyboard-markdown.mjs";
  * Split a per-slide concept batch into the dependency waves expected by the
  * add-in: independent slides and family anchors first, family variants second.
  */
+// The slide numbers the plan's storyboards actually carry, ascending. This is
+// the set concept generation must cover — the server's slideCount is only the
+// number of beats IT parsed, and one beat it drops (an older schema rejecting
+// a cover's empty block list) would otherwise also drop the LAST slide from a
+// 2..slideCount request range.
+export function plannedSlideNumbers(planMarkdown) {
+  const slides = new Set();
+  for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
+    if (segment.type !== "storyboard" || !segment.data) continue;
+    if (Number.isFinite(segment.data.slide)) slides.add(segment.data.slide);
+  }
+  return [...slides].sort((a, b) => a - b);
+}
+
 export function conceptGenerationWaves(planMarkdown, slideCount) {
   const groups = new Map();
   for (const segment of splitPlanMarkdownIntoSegments(planMarkdown)) {
@@ -21,10 +35,12 @@ export function conceptGenerationWaves(planMarkdown, slideCount) {
     for (const slide of members.slice(1)) variants.add(slide);
   }
 
-  const remaining = Array.from(
-    { length: Math.max(0, slideCount - 1) },
-    (_, index) => index + 2,
-  );
+  // Slide 1 is the caller's probe request; everything else the plan names
+  // follows. A plan without parseable storyboards falls back to the count.
+  const planned = plannedSlideNumbers(planMarkdown);
+  const remaining = planned.length
+    ? planned.filter((slide) => slide !== 1)
+    : Array.from({ length: Math.max(0, slideCount - 1) }, (_, i) => i + 2);
   return {
     firstWave: remaining.filter((slide) => !variants.has(slide)),
     variants: remaining.filter((slide) => variants.has(slide)),

package/src/lib/adopt.mjs

@@ -30,7 +30,7 @@ import { decodeSourceTags, mintSlideGuid, readSlideTags } from "../pptx/tags.mjs
 import { foldPickedSlides } from "../pptx/slide-swap.mjs";
 import { readDeckBundleRef, writeDeckBundleRef } from "../bridge/bundle.mjs";
 import { loadSlideGuids, saveSlideGuids, slideGuidEntry } from "./slide-guids.mjs";
-import { writeConversionRecord } from "./conversions.mjs";
+import { hasSourcedChart, writeConversionRecord } from "./conversions.mjs";
 
 export const LIVE_DECK_UNSUPPORTED =
   "conversion of live presentations requires the add-in path in v1 — " +
@@ -176,15 +176,19 @@ export function adoptDeckFromPptx({ pptxPath, deckDir, converted = null, source
 
   // Fold in ONE pass: foldPickedSlides unzips and prunes the whole source
   // package per call, so folding slide by slide redid that work for the entire
-  // deck on every native slide. Two kinds of pick share the pass — a slide that
-  // stays native, and a CONVERTED slide whose preserved natives (chart / OLE /
-  // SmartArt) need their verbatim source package kept for the render-time
-  // splice (design D4/D6).
+  // deck on every native slide. Three kinds of pick share the pass — a slide
+  // that stays native, a CONVERTED slide whose preserved natives (OLE /
+  // SmartArt / unsupported chart kinds) need their verbatim source package kept
+  // for the render-time splice (design D4/D6), and a converted slide carrying
+  // the deck's own chart as `<Chart data-sm-source-id>`, which the render
+  // patches against that same package (native-charts 5.4a).
   const picks = [];
   decodedByIndex.forEach((decoded, index) => {
     if (decoded) return;
     const conv = convertedSlides.get(index + 1);
-    if (!conv || conv.preserved?.length > 0) picks.push(index + 1);
+    if (!conv || conv.preserved?.length > 0 || hasSourcedChart(conv.jsx)) {
+      picks.push(index + 1);
+    }
   });
   const foldByPick = new Map(
     (picks.length

package/src/lib/conversions.mjs

@@ -42,8 +42,18 @@ function stemOf(slideFileName) {
 }
 
 /**
- * Write one converted slide's record (+ its source package when the slide
- * carries preserved natives). `sourcePackage` is a Uint8Array/Buffer or null.
+ * Does this converted jsx carry the deck's own chart (`<Chart data-sm-source-id>`)?
+ * Such a chart is PATCHED against its original part at push, so the slide needs
+ * its source package exactly like a slide with preserved natives does.
+ */
+export function hasSourcedChart(jsx) {
+  return /<Chart\b[^>]*\bdata-sm-source-id=/.test(String(jsx ?? ""));
+}
+
+/**
+ * Write one converted slide's record (+ its source package when the caller
+ * folded one — adopt does so for slides with preserved natives or a sourced
+ * chart). `sourcePackage` is a Uint8Array/Buffer or null.
  */
 export function writeConversionRecord(
   deckDir,
@@ -54,8 +64,7 @@ export function writeConversionRecord(
   const stem = stemOf(slideFileName);
   const dir = conversionsDir(deckDir);
   fs.mkdirSync(dir, { recursive: true });
-  const packageName =
-    sourcePackage && record.preserved?.length ? `${stem}.slide.pptx` : null;
+  const packageName = sourcePackage ? `${stem}.slide.pptx` : null;
   if (packageName) {
     fs.writeFileSync(path.join(dir, packageName), Buffer.from(sourcePackage));
   }
@@ -256,8 +265,19 @@ function stampFirstReplace(deckDir, slideFileName, gate) {
 }
 
 /** Conversion records whose preserved natives have no source package to splice. */
-export function conversionsMissingPreserveSource(conversions) {
+export function conversionsMissingPreserveSource(conversions, deckDir = null) {
+  const needsPackage = (file, c) => {
+    if (c.preserved?.length > 0) return true;
+    if (!deckDir) return false;
+    try {
+      return hasSourcedChart(
+        fs.readFileSync(path.join(deckDir, "slides", file), "utf8"),
+      );
+    } catch {
+      return false;
+    }
+  };
   return Object.entries(conversions)
-    .filter(([, c]) => c.preserved?.length > 0 && !c.preserveSource)
+    .filter(([file, c]) => needsPackage(file, c) && !c.preserveSource)
     .map(([file]) => file);
 }

package/src/lib/overwrite-guard.mjs

@@ -23,6 +23,7 @@ import {
   computeProjection,
   decodeSourceTags,
   readSlideTags,
+  withoutChartHashes,
 } from "../pptx/tags.mjs";
 import { unzip } from "../pptx/zip.mjs";
 
@@ -58,8 +59,20 @@ export function detectManualEdits(outPath) {
     if (!decoded?.baseline) return;
     // Both sides are produced by the SAME emitter, so key order matches and a
     // string compare is a stable structural compare.
+    //
+    // …with the chart hash dropped from BOTH sides: this repo has no chart
+    // reader, so it always projects `chart: null` (see the CHART HASH note in
+    // pptx/tags.mjs). Comparing an add-in baseline's real hash against that null
+    // would refuse EVERY rebuild of a deck that holds a chart, which is a
+    // certain harm; missing a chart-ONLY manual edit is the bounded one, and the
+    // add-in's own drift check still catches it on the next push.
     const current = computeProjection(files, slidePath);
-    if (JSON.stringify(current) === JSON.stringify(decoded.baseline)) return;
+    if (
+      JSON.stringify(withoutChartHashes(current)) ===
+      JSON.stringify(withoutChartHashes(decoded.baseline))
+    ) {
+      return;
+    }
     edited.push({
       slideIndex: i + 1,
       slidePath,

package/src/lib/reconcile.mjs

@@ -20,7 +20,11 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { computeProjection, decodeSourceTags } from "../pptx/tags.mjs";
+import {
+  computeProjection,
+  decodeSourceTags,
+  withoutChartHashes,
+} from "../pptx/tags.mjs";
 import { unzip } from "../pptx/zip.mjs";
 import { loadConversions } from "./conversions.mjs";
 import { detectManualEdits, manualEditsError } from "./overwrite-guard.mjs";
@@ -198,10 +202,17 @@ export async function collectLiveReconcileInputs({
     if (!baseline) continue;
     // The BYTES carry the current state; the TAGS carry the baseline. Never the
     // other way round — exportAsBase64 strips tags (office-js #6104).
-    const current = computeProjection(unzip(Buffer.from(slide.base64, "base64")));
-    if (JSON.stringify(current) === JSON.stringify(baseline)) continue;
+    // Chart hashes are dropped from BOTH sides — this repo cannot produce one
+    // (CHART HASH note in pptx/tags.mjs), and sending a null against the
+    // baseline's real hash would make the SERVER report a chart edit that never
+    // happened.
+    const current = withoutChartHashes(
+      computeProjection(unzip(Buffer.from(slide.base64, "base64"))),
+    );
+    const comparable = withoutChartHashes(baseline);
+    if (JSON.stringify(current) === JSON.stringify(comparable)) continue;
     reconcile[fileName] = {
-      baseline,
+      baseline: comparable,
       current,
       ...(acks[fileName] ? { ack: acks[fileName] } : {}),
     };