@agent-native/core 0.131.5 → 0.131.7

package/corpus/templates/plan/actions/patch-visual-plan-source.ts

@@ -28,6 +28,73 @@ import {
 } from "../server/plans.js";
 import type { PlanContent } from "../shared/plan-content.js";
 
+const agentPlanMdxSourcePatchesSchema = z
+  .array(
+    z.discriminatedUnion("op", [
+      z.object({
+        op: z.literal("replace-markdown-block"),
+        blockId: z.string().min(1),
+        markdown: z.string().max(16_000),
+        title: z.string().optional(),
+      }),
+      z.object({
+        op: z.literal("update-component-prop"),
+        file: z.enum(["plan.mdx", "canvas.mdx", "prototype.mdx"]),
+        componentId: z.string().min(1),
+        prop: z.string().min(1),
+        value: z.unknown(),
+      }),
+      z.object({
+        op: z.literal("update-wireframe-node"),
+        nodeId: z.string().min(1),
+        patch: z.record(z.string(), z.unknown()),
+      }),
+      z.object({
+        op: z.literal("update-annotation"),
+        annotationId: z.string().min(1),
+        patch: z.object({
+          type: z.enum(["note", "text", "callout", "arrow"]).optional(),
+          title: z.string().optional(),
+          text: z.string().max(2_000).optional(),
+          points: z
+            .array(z.object({ x: z.number(), y: z.number() }))
+            .min(1)
+            .max(12)
+            .optional(),
+          style: z
+            .object({
+              tone: z
+                .enum(["default", "accent", "warn", "ok", "muted"])
+                .optional(),
+              stroke: z.enum(["solid", "dashed"]).optional(),
+              width: z.number().min(1).max(12).optional(),
+            })
+            .optional(),
+          targetId: z.string().optional(),
+          placement: z
+            .enum([
+              "top",
+              "right",
+              "bottom",
+              "left",
+              "top-left",
+              "top-right",
+              "bottom-left",
+              "bottom-right",
+            ])
+            .optional(),
+          x: z.number().optional(),
+          y: z.number().optional(),
+        }),
+      }),
+    ]),
+  )
+  .max(80)
+  .describe(
+    "Small exported-MDX patches only. Never send replace-file or replace-artboard " +
+      "from an agent; for a live plan use update-visual-plan contentPatches instead.",
+  );
+
 type PlanSurfaceCounts = {
   blocks: number;
   canvasFrames: number;
@@ -42,6 +109,28 @@ function planSurfaceCounts(content: PlanContent | null | undefined) {
   } satisfies PlanSurfaceCounts;
 }
 
+function compactAgentWriteResult(
+  bundle: Awaited<ReturnType<typeof loadPlanBundle>>,
+  changed: Record<string, unknown>,
+) {
+  return {
+    planId: bundle.plan.id,
+    plan: {
+      id: bundle.plan.id,
+      title: bundle.plan.title,
+      brief: bundle.plan.brief,
+      kind: bundle.plan.kind,
+      status: bundle.plan.status,
+      currentFocus: bundle.plan.currentFocus,
+      updatedAt: bundle.plan.updatedAt,
+      surfaces: planSurfaceCounts(bundle.plan.content),
+    },
+    changed,
+    path: planPath(bundle.plan.id, bundle.plan.kind),
+    url: planPath(bundle.plan.id, bundle.plan.kind),
+  };
+}
+
 function stableJson(value: unknown): string {
   if (value === null) return "null";
   if (value === undefined) return "undefined";
@@ -140,7 +229,7 @@ function assertNoUnexpectedSurfaceCollapse(
 
 export default defineAction({
   description:
-    "Patch the MDX source for an Agent-Native Plan by stable semantic IDs, then normalize it back into runtime JSON. Use ONLY when working with exported MDX source files (repo check-in workflows); for live plans prefer update-visual-plan with contentPatches. Suitable for tiny source-control friendly diffs: one markdown block, one artboard, one annotation, or one wireframe node.",
+    "Patch the MDX source for an Agent-Native Plan by stable semantic IDs, then normalize it back into runtime JSON. Use ONLY when working with exported MDX source files (repo check-in workflows); for live plans prefer update-visual-plan with contentPatches. For agent calls, use only small semantic patches and never resend replace-file or replace-artboard payloads.",
   schema: z.object({
     planId: z.string().describe("Plan ID"),
     expectedUpdatedAt: z
@@ -162,6 +251,21 @@ export default defineAction({
     ),
     note: z.string().optional().describe("Short audit note for plan history."),
   }),
+  agentInputSchema: z.object({
+    planId: z.string().describe("Plan ID"),
+    expectedUpdatedAt: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Revision from the latest plan read when required."),
+    allowDestructive: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe("Allow an intentional nonempty-to-empty collapse."),
+    patches: agentPlanMdxSourcePatchesSchema,
+    note: z.string().optional().describe("Short audit note for plan history."),
+  }),
   publicAgent: {
     expose: true,
     readOnly: false,
@@ -321,6 +425,18 @@ export default defineAction({
           ),
         })
       : null;
+    if (isAgentCaller) {
+      return {
+        ...compactAgentWriteResult(updated, {
+          patchOps: args.patches.map((patch) => patch.op),
+          counts: {
+            before: beforeCounts,
+            after: afterCounts,
+          },
+        }),
+        ...(local?.written ? { localFiles: local } : {}),
+      };
+    }
     return {
       ...updated,
       planId: updated.plan.id,

package/corpus/templates/plan/actions/update-visual-plan.ts

@@ -49,8 +49,7 @@ import {
   sectionInputSchema,
 } from "../server/plans.js";
 import {
-  agentPlanContentPatchesSchema,
-  agentPlanContentSchema,
+  agentPlanIncrementalContentPatchesSchema,
   applyPlanContentPatches,
   planContentPatchesSchema,
   planContentSchema,
@@ -454,6 +453,32 @@ const CONTENT_DESCRIPTION =
 const CONTENT_PATCHES_DESCRIPTION =
   "Targeted structured content edits addressed by stable id. Prefer granular operations for live plans. The destructive replace-blocks operation requires expectedUpdatedAt from a fresh read. patch-visual-plan-source is only for exported MDX folders. Supported ops: set-metadata for title/brief; set-visual-render-mode to persist `design` (high fidelity, authored CSS, no rough.js for any viewer) or `wireframe` across canvas, linked blocks, and prototype screens; set-prototype / remove-prototype / update-prototype-screen / patch-prototype-html for live prototype surfaces; update-block / replace-block, update-rich-text, patch-wireframe-html, patch-diagram-html, update-wireframe-node, replace-wireframe-screen, update-canvas-frame, update-canvas-annotation / append-canvas-annotation, append-block / remove-block, update-custom-html. A fidelity upgrade must also replace or patch the existing screen HTML/CSS with deliberate branded design; changing render mode alone only removes the sketch treatment.";
 
+function compactAgentWriteResult(
+  bundle: Awaited<ReturnType<typeof loadPlanBundle>>,
+  changed: Record<string, unknown>,
+) {
+  return {
+    planId: bundle.plan.id,
+    plan: {
+      id: bundle.plan.id,
+      title: bundle.plan.title,
+      brief: bundle.plan.brief,
+      kind: bundle.plan.kind,
+      status: bundle.plan.status,
+      currentFocus: bundle.plan.currentFocus,
+      updatedAt: bundle.plan.updatedAt,
+      surfaces: {
+        blocks: bundle.plan.content?.blocks.length ?? 0,
+        canvasFrames: bundle.plan.content?.canvas?.frames.length ?? 0,
+        prototypeScreens: bundle.plan.content?.prototype?.screens.length ?? 0,
+      },
+    },
+    changed,
+    path: planPath(bundle.plan.id, bundle.plan.kind),
+    url: planPath(bundle.plan.id, bundle.plan.kind),
+  };
+}
+
 // Named so `agentInputSchema` below can `.extend()` it with compact
 // `content`/`contentPatches` fields instead of duplicating every other key.
 const updateVisualPlanSchema = z.object({
@@ -527,21 +552,26 @@ const updateVisualPlanSchema = z.object({
     .describe("Short label saved as the version-history snapshot label."),
 });
 
+// ADVERTISED-ONLY: agent edits to an existing plan must stay incremental. The
+// runtime schema above still accepts full replacements for the browser editor
+// and explicit callers that have intentionally chosen that workflow.
+const agentUpdateVisualPlanSchema = updateVisualPlanSchema
+  .omit({ content: true, html: true, markdown: true, sections: true })
+  .extend({
+    contentPatches: agentPlanIncrementalContentPatchesSchema
+      .optional()
+      .default([])
+      .describe(
+        "Small targeted edits only. Do not send full content or replace-blocks; " +
+          "append or patch one existing block at a time.",
+      ),
+  });
+
 export default defineAction({
   description:
-    "Update an Agent-Native Plan's structured content blocks, prototype screens, visual fidelity, sections, comments, or status. Prefer contentPatches for targeted edits. When a user asks for higher fidelity on an existing plan, update that same plan in place: use set-visual-render-mode with design and provide polished screen HTML/CSS in the same call instead of creating a duplicate plan or only toggling the viewer-local clean style. Use full content only for broad restructuring. Works on plans and recaps alike when you have editor access; with viewer access (common on PR recaps published by CI) only comment-only calls succeed — to change a recap you cannot edit, publish a replacement with create-visual-recap instead of retrying this call.",
+    "Update an Agent-Native Plan's structured content blocks, prototype screens, visual fidelity, sections, comments, or status. For an existing plan, use small contentPatches such as append-block, update-rich-text, or a text patch; do not resend the full document for an incremental edit. When a user asks for higher fidelity on an existing plan, update that same plan in place: use set-visual-render-mode with design and provide polished screen HTML/CSS in the same call instead of creating a duplicate plan or only toggling the viewer-local clean style. Use a full replacement only for an explicit broad rebuild. Works on plans and recaps alike when you have editor access; with viewer access (common on PR recaps published by CI) only comment-only calls succeed - to change a recap you cannot edit, publish a replacement with create-visual-recap instead of retrying this call.",
   schema: updateVisualPlanSchema,
-  // ADVERTISED-ONLY: same top-level shape, but `content`/`contentPatches`
-  // swap the deep per-block-type union for a compact `type`-enum stand-in.
-  // Runtime validation always runs the full schema above — see the `actions`
-  // skill.
-  agentInputSchema: updateVisualPlanSchema.extend({
-    content: agentPlanContentSchema.optional().describe(CONTENT_DESCRIPTION),
-    contentPatches: agentPlanContentPatchesSchema
-      .optional()
-      .default([])
-      .describe(CONTENT_PATCHES_DESCRIPTION),
-  }),
+  agentInputSchema: agentUpdateVisualPlanSchema,
   publicAgent: {
     expose: true,
     readOnly: false,
@@ -1173,6 +1203,18 @@ export default defineAction({
           ),
         })
       : null;
+    if (isAgentCaller) {
+      return {
+        ...compactAgentWriteResult(bundle, {
+          titleChanged: args.title !== undefined,
+          briefChanged: args.brief !== undefined,
+          statusChanged: args.status !== undefined,
+          contentPatchOps: args.contentPatches.map((patch) => patch.op),
+          commentCount: insertedCommentIds.length,
+        }),
+        ...(local?.written ? { localFiles: local } : {}),
+      };
+    }
     return {
       ...bundle,
       planId: bundle.plan.id,

package/corpus/templates/plan/app/pages/PlansPage.tsx

@@ -1602,7 +1602,7 @@ export function buildPlanAgentContext(input: {
       : [
           "Fast iteration workflow:",
           "1. Call get-visual-plan with this plan ID to read structured content, exported HTML, sections, comments, and activity.",
-          '2. Prefer update-visual-plan contentPatches for targeted edits. Examples: update-rich-text for copy, patch-prototype-html / update-prototype-screen for live prototype states, update-wireframe-node for one kit-tree node, update-canvas-frame for frame layout, append-canvas-annotation / update-canvas-annotation for canvas markup, append-block/remove-block for document changes, or replace-block for a single block. When the user asks for higher fidelity, polished mockups, production-like UI, real design, or anything "not sketchy," update this same plan in place: rewrite the relevant screen HTML/CSS and include set-visual-render-mode with renderMode design. Do not create a second plan, put CSS in style tags, or treat the viewer-local Clean toggle as a fidelity upgrade. Use full content only for broad restructuring. Use html only when preserving or importing a legacy standalone HTML artifact.',
+          '2. Prefer small update-visual-plan contentPatches for every edit to an existing plan. Examples: append-block for new tasks, update-rich-text for a bounded copy change, patch-prototype-html / update-prototype-screen for live prototype states, update-wireframe-node for one kit-tree node, update-canvas-frame for frame layout, append-canvas-annotation / update-canvas-annotation for canvas markup, or remove-block for one block. Never resend the full plan, use replace-blocks, or use patch-visual-plan-source replace-file for an incremental change - those payloads can be truncated before the tool receives them. When the user asks for higher fidelity, polished mockups, production-like UI, real design, or anything "not sketchy," update this same plan in place: rewrite the relevant screen HTML/CSS and include set-visual-render-mode with renderMode design. Do not create a second plan, put CSS in style tags, or treat the viewer-local Clean toggle as a fidelity upgrade. Use a full replacement only for an explicit broad rebuild. Use html only when preserving or importing a legacy standalone HTML artifact.',
           "3. Preserve the user's existing annotation comments and intent unless the user asks to remove or resolve them.",
           "4. Match the requested fidelity: ordinary UI planning can use sketch diagrams and wireframes; high-fidelity requests need the persisted Design surface with deliberate branded HTML/CSS and stable data-design-id targets.",
           "5. After applying feedback, keep the plan scannable, editable, and serious instead of turning it into a marketing page.",

package/corpus/templates/plan/changelog/2026-07-30-plan-agents-recover-with-targeted-writes.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-30
+---
+
+Plan agents now recover interrupted edits with small targeted writes.

package/corpus/templates/plan/shared/plan-content.ts

@@ -2944,6 +2944,41 @@ export const agentPlanContentPatchesSchema = z
       "replace-block / replace-blocks / append-block.",
   );
 
+/**
+ * Model-facing patch vocabulary for edits to an existing hosted plan. Full
+ * block/content replacement remains valid at runtime for the browser editor
+ * and explicit callers, but advertising it to an agent makes it too easy to
+ * resend the whole document and hit the provider's streamed-JSON limit.
+ */
+const AGENT_INCREMENTAL_PATCH_EXCLUDED_OPS = new Set([
+  "set-prototype",
+  "replace-block",
+  "replace-blocks",
+  "replace-wireframe-screen",
+]);
+
+const agentIncrementalPlanContentPatchOptions =
+  agentPlanContentPatchOptions.filter((option) => {
+    const op = (option.shape as { op: { value: string } }).op.value;
+    return !AGENT_INCREMENTAL_PATCH_EXCLUDED_OPS.has(op);
+  });
+
+export const agentPlanIncrementalContentPatchesSchema = z
+  .array(
+    z.discriminatedUnion(
+      "op",
+      agentIncrementalPlanContentPatchOptions as unknown as Parameters<
+        typeof z.discriminatedUnion
+      >[1],
+    ),
+  )
+  .max(80)
+  .describe(
+    "Small targeted edits to an existing plan. Prefer append-block, update-rich-text, " +
+      "patch-wireframe-html, patch-prototype-html, or update-block. Do not " +
+      "resend the full plan; use get-visual-plan for context and keep each call incremental.",
+  );
+
 export function applyPlanContentPatches(
   content: PlanContent,
   patches: PlanContentPatch[],

package/corpus/templates/slides/.agents/skills/analytics-data-for-decks/SKILL.md

@@ -17,18 +17,14 @@ other analytics data.
 
 ## Delegation
 
-- For a known, read-only operation, use `call-agent` with `agent: "analytics"`,
-  the exact `action`, and complete `input`. This invokes Analytics directly
-  without starting a second model loop.
-- For ambiguous, multi-source, or narrative questions, use `call-agent` with a
-  natural-language `message` and let Analytics decide which source or sources
-  to use.
-- Useful Analytics operations include `hubspot-records` for bounded CRM
-  records and `hubspot-deals` for pipeline and deal metrics,
-  `account-deep-dive` for a named account or renewal/risk review, `gong-calls`
-  for quotes/counts/transcripts and coverage, and `gong-native-insights` for
-  bounded narrative synthesis. For first-party product activity, send a
-  natural-language message and let Analytics choose its query.
+- Use `call-agent` with `agent: "analytics"` and a natural-language `message`
+  by default. Describe the business question, requested window or cohort, and
+  the concise result shape the deck needs. Analytics decides which sources,
+  tools, queries, and joins answer it.
+- A direct `action` + `input` call is optional only when an exact bounded
+  semantic read and its complete schema are already known. It is not a fallback
+  for slow, failed, or unavailable agent delegation. Never invent an Analytics
+  action contract to make a demo pass.
 - Slides must not write SQL, choose a warehouse or provider, call HubSpot/Gong
   directly, or interpret a provider schema itself. Analytics owns source
   selection, data dictionary interpretation, filters, joins, and query

package/corpus/templates/slides/AGENTS.md

@@ -41,10 +41,10 @@ ladder.
 - Use image-generation and image-selection actions only when the deck genuinely
   needs imagery; keep citations/asset provenance when available.
 - Use framework sharing actions for deck visibility and grants.
-- For a known, read-only sibling-app operation, use `call-agent` with `action`
-  and `input` (or `invokeAgentAction`) instead of starting the sibling agent's
-  model loop. In Analytics, use `gong-native-insights` for provider-synthesized
-  briefs and `gong-calls` for quotes, counts, transcripts, and coverage claims.
+- Ask a sibling app's agent with a natural-language `call-agent` message by
+  default. Let that specialist use its own instructions, skills, sources, and
+  tools. Direct action invocation is only for an exact bounded read with a
+  fully known schema; never use it as a workaround for slow or failed A2A.
 - For data requests, read `.agents/skills/analytics-data-for-decks/SKILL.md` and
   delegate via Analytics over A2A; do not write SQL or call providers directly.
 - When the user names no reference deck or design system, call

package/corpus/templates/slides/actions/create-deck.ts

@@ -75,7 +75,7 @@ const SlideSchema = z.object({
 
 // Accept either a parsed array (HTTP/agent) or a JSON string (CLI)
 const SlidesSchema = z.preprocess(
-  (v) => (typeof v === "string" ? JSON.parse(v) : v),
+  (v) => (v === undefined ? [] : typeof v === "string" ? JSON.parse(v) : v),
   z.array(SlideSchema),
 );
 

package/corpus/templates/slides/actions/duplicate-deck.ts

@@ -26,8 +26,15 @@ export default defineAction({
       .describe(
         "Optional client-supplied id for the new deck. Lets the UI pick the id ahead of time so it can navigate optimistically before the server responds.",
       ),
+    slideIds: z
+      .array(z.string().min(1).max(64))
+      .max(1000)
+      .optional()
+      .describe(
+        "Optional client-supplied ids for the copied slides, in slide order. Same purpose as `newId`: when the UI opens an optimistic copy the user can edit immediately, its slide ids must match the persisted copy or those edits address slides the server never had.",
+      ),
   }),
-  run: async ({ deckId, title, newId: clientNewId }) => {
+  run: async ({ deckId, title, newId: clientNewId, slideIds }) => {
     const access = await resolveAccess("deck", deckId);
     if (!access) throw new Error(`Deck not found: ${deckId}`);
 
@@ -37,9 +44,17 @@ export default defineAction({
     const now = new Date().toISOString();
     const deckData = JSON.parse(source.data);
 
-    // Generate new IDs for all slides so edits to the copy don't collide
-    for (const slide of deckData.slides || []) {
-      slide.id = `slide-${nanoid(8)}`;
+    // New IDs for all slides so edits to the copy don't collide with the
+    // original. A caller that already rendered an optimistic copy supplies the
+    // ids it used; anything it did not cover still gets a fresh one.
+    const slides = deckData.slides || [];
+    for (const [index, slide] of slides.entries()) {
+      slide.id = slideIds?.[index] ?? `slide-${nanoid(8)}`;
+    }
+    if (
+      new Set(slides.map((s: { id: string }) => s.id)).size !== slides.length
+    ) {
+      throw new Error("slideIds must be unique");
     }
 
     const newTitle = title || `Copy of ${source.title}`;

package/corpus/templates/slides/app/components/deck/DeckCard.tsx

@@ -32,7 +32,6 @@ interface DeckCardProps {
   onRename: (id: string, newTitle: string) => void;
   onDuplicate: (id: string) => void;
   onToggleStar: (id: string, starred: boolean) => void;
-  isDuplicating?: boolean;
   designSystemTitle?: string | null;
   isWorkspaceDefault?: boolean;
   canSetWorkspaceDefault?: boolean;
@@ -45,7 +44,6 @@ export default function DeckCard({
   onRename,
   onDuplicate,
   onToggleStar,
-  isDuplicating = false,
   designSystemTitle,
   isWorkspaceDefault = false,
   canSetWorkspaceDefault = false,
@@ -230,15 +228,9 @@ export default function DeckCard({
               <IconPencil className="w-3.5 h-3.5 me-2" />
               Rename
             </DropdownMenuItem>
-            <DropdownMenuItem
-              onSelect={() => {
-                if (isDuplicating) return;
-                onDuplicate(deck.id);
-              }}
-              disabled={isDuplicating}
-            >
+            <DropdownMenuItem onSelect={() => onDuplicate(deck.id)}>
               <IconCopy className="w-3.5 h-3.5 me-2" />
-              {isDuplicating ? "Duplicating..." : "Duplicate"}
+              Duplicate
             </DropdownMenuItem>
             <DropdownMenuItem
               onSelect={(event) => {

package/corpus/templates/slides/app/components/deck/MermaidRenderer.tsx

@@ -46,11 +46,13 @@ let idCounter = 0;
 interface MermaidRendererProps {
   definition: string;
   className?: string;
+  index?: number;
 }
 
 export function MermaidRenderer({
   definition,
   className,
+  index,
 }: MermaidRendererProps) {
   const containerRef = useRef<HTMLDivElement>(null);
   const [svg, setSvg] = useState<string>("");
@@ -98,6 +100,7 @@ export function MermaidRenderer({
   if (error) {
     return (
       <div
+        data-mermaid-index={index}
         className={`flex items-center justify-center p-4 text-xs text-red-400/70 ${className || ""}`}
       >
         <pre className="whitespace-pre-wrap">{error}</pre>
@@ -105,11 +108,19 @@ export function MermaidRenderer({
     );
   }
 
-  if (!svg) return null;
+  if (!svg) {
+    // Mermaid's import + render is async, so this placeholder is the only
+    // thing in the DOM until it resolves. Without it, an edit to another
+    // element on the same slide made while the diagram is still loading
+    // would see zero `[data-mermaid-index]` nodes when serializing the
+    // slide, and silently drop the diagram from the saved content.
+    return <div data-mermaid-index={index} className={className} />;
+  }
 
   return (
     <div
       ref={containerRef}
+      data-mermaid-index={index}
       className={`flex items-center justify-center [&_svg]:max-w-full [&_svg]:max-h-full ${className || ""}`}
       dangerouslySetInnerHTML={{ __html: svg }}
     />

package/corpus/templates/slides/app/components/deck/SlideRenderer.tsx

@@ -14,6 +14,7 @@ import rehypeRaw from "rehype-raw";
 import { Skeleton } from "@/components/ui/skeleton";
 import type { Slide } from "@/context/DeckContext";
 import { type AspectRatio, getAspectRatioDims } from "@/lib/aspect-ratios";
+import { extractMermaidBlocks } from "@/lib/mermaid-blocks";
 import {
   sanitizeCssValue,
   sanitizeSlideHtml,
@@ -37,6 +38,8 @@ interface SlideRendererProps {
    * The renderer no longer shrinks slides for vertical overflow — instead the
    * editor surfaces this so the agent can rewrite the slide to fit. */
   onOverflowChange?: (info: SlideOverflowInfo) => void;
+  /** Fires after AutoFit has applied its final transform for this render. */
+  onAutofitSettled?: () => void;
 }
 
 export const layoutClasses: Record<string, string> = {
@@ -311,9 +314,12 @@ function useSlideAutofit(
   canvasHeight: number,
   fitKey: string,
   onOverflowChange?: (info: SlideOverflowInfo) => void,
+  onAutofitSettled?: () => void,
 ) {
   const overflowCallbackRef = useRef(onOverflowChange);
   overflowCallbackRef.current = onOverflowChange;
+  const autofitSettledRef = useRef(onAutofitSettled);
+  autofitSettledRef.current = onAutofitSettled;
 
   useIsomorphicLayoutEffect(() => {
     const root = ref.current;
@@ -395,6 +401,7 @@ function useSlideAutofit(
             viewportHeight: 0,
           },
         );
+        autofitSettledRef.current?.();
       }
     };
 
@@ -437,6 +444,7 @@ function AutoFitContent({
   className = "",
   children,
   onOverflowChange,
+  onAutofitSettled,
 }: {
   canvasWidth: number;
   canvasHeight: number;
@@ -444,9 +452,17 @@ function AutoFitContent({
   className?: string;
   children: ReactNode;
   onOverflowChange?: (info: SlideOverflowInfo) => void;
+  onAutofitSettled?: () => void;
 }) {
   const ref = useRef<HTMLDivElement>(null);
-  useSlideAutofit(ref, canvasWidth, canvasHeight, fitKey, onOverflowChange);
+  useSlideAutofit(
+    ref,
+    canvasWidth,
+    canvasHeight,
+    fitKey,
+    onOverflowChange,
+    onAutofitSettled,
+  );
 
   return (
     <div
@@ -469,18 +485,9 @@ function BlankSlideContent({ content }: { content: string }) {
   // includes the per-block `contentEditable="true"` set by SlideEditor's
   // double-click-to-edit flow, which made inline text editing appear to do nothing.
   const { mermaidBlocks, htmlWithPlaceholders, dangerousHtml } = useMemo(() => {
-    // Extract mermaid blocks BEFORE sanitization. The sanitizer round-trips
-    // HTML through DOMParser + innerHTML, which HTML-escapes `>` in text
-    // nodes to `&gt;` — that mangles diagram arrows like `A --> B` into
-    // `A --&gt; B` and breaks the mermaid parser.
-    const blocks: string[] = [];
-    const contentWithPlaceholders = content.replace(
-      /<div\s+class="mermaid"[^>]*>([\s\S]*?)<\/div>/gi,
-      (_, definition) => {
-        blocks.push(String(definition).trim());
-        return `<div data-mermaid-index="${blocks.length - 1}"></div>`;
-      },
-    );
+    // Extract mermaid blocks BEFORE sanitization — see mermaid-blocks.ts for
+    // why (sanitizer HTML-escaping breaks the mermaid parser).
+    const { blocks, contentWithPlaceholders } = extractMermaidBlocks(content);
 
     // Apply white filter to all logo images (brandfetch, logo.dev, etc.) for dark backgrounds
     const processed = sanitizeSlideHtml(
@@ -547,6 +554,7 @@ function MermaidHtmlContent({
             <MermaidRenderer
               key={`mermaid-${i}`}
               definition={mermaidBlocks[idx]}
+              index={idx}
               className="my-4 w-full"
             />
           );
@@ -564,11 +572,13 @@ export function SlideInner({
   designSystem,
   aspectRatio,
   onOverflowChange,
+  onAutofitSettled,
 }: {
   slide: Slide;
   designSystem?: DesignSystemData;
   aspectRatio?: AspectRatio;
   onOverflowChange?: (info: SlideOverflowInfo) => void;
+  onAutofitSettled?: () => void;
 }) {
   const t = useT();
   const dims = getAspectRatioDims(aspectRatio);
@@ -651,6 +661,7 @@ export function SlideInner({
           fitKey={left}
           className="slide-content text-white/90"
           onOverflowChange={onOverflowChange}
+          onAutofitSettled={onAutofitSettled}
         >
           <ReactMarkdown
             components={markdownComponents}
@@ -664,6 +675,7 @@ export function SlideInner({
           canvasHeight={dims.height}
           fitKey={right}
           className="slide-content text-white/90"
+          onAutofitSettled={onAutofitSettled}
         >
           <ReactMarkdown
             components={markdownComponents}
@@ -689,6 +701,7 @@ export function SlideInner({
           fitKey={content}
           className="h-full w-full"
           onOverflowChange={onOverflowChange}
+          onAutofitSettled={onAutofitSettled}
         >
           <BlankSlideContent content={content} />
         </AutoFitContent>
@@ -714,6 +727,7 @@ export function SlideInner({
         fitKey={content}
         className="slide-content text-white/90 w-full"
         onOverflowChange={onOverflowChange}
+        onAutofitSettled={onAutofitSettled}
       >
         <ReactMarkdown
           components={markdownComponents}
@@ -733,6 +747,7 @@ export default function SlideRenderer({
   designSystem,
   aspectRatio,
   onOverflowChange,
+  onAutofitSettled,
 }: SlideRendererProps) {
   const dims = getAspectRatioDims(aspectRatio);
 
@@ -753,6 +768,7 @@ export default function SlideRenderer({
             designSystem={designSystem}
             aspectRatio={aspectRatio}
             onOverflowChange={onOverflowChange}
+            onAutofitSettled={onAutofitSettled}
           />
         </div>
         <ScaleHelper
@@ -783,6 +799,7 @@ export default function SlideRenderer({
           designSystem={designSystem}
           aspectRatio={aspectRatio}
           onOverflowChange={onOverflowChange}
+          onAutofitSettled={onAutofitSettled}
         />
       </div>
       <ScaleHelper targetWidth={dims.width} />