@agent-native/core 0.96.0 → 0.97.0

package/corpus/templates/plan/actions/restore-plan-version.ts

@@ -38,6 +38,13 @@ export default defineAction({
   run: async ({ planId, versionId }) => {
     const access = await assertPlanEditor(planId);
     const ownerEmail = access.resource.ownerEmail as string;
+    // Optimistic-concurrency fence, mirroring the versionAtLoad/updatedAt
+    // pattern in update-visual-plan.ts: captured before any restore work
+    // starts, then used to guard the leading `plans` UPDATE below so a
+    // restore racing a concurrent edit fails cleanly instead of silently
+    // clobbering it or interleaving writes.
+    const versionAtLoad = (access.resource as typeof schema.plans.$inferSelect)
+      .updatedAt;
     const db = getDb();
 
     const [version] = await db
@@ -63,114 +70,137 @@ export default defineAction({
     const snapshot = parsePlanVersionSnapshot(version.snapshotJson);
     const now = nowIso();
 
-    await db
-      .update(schema.plans)
-      .set({
-        title: snapshot.plan.title,
-        brief: snapshot.plan.brief,
-        status: snapshot.plan.status,
-        source: snapshot.plan.source,
-        repoPath: snapshot.plan.repoPath ?? null,
-        currentFocus: snapshot.plan.currentFocus ?? null,
-        html: snapshot.plan.html ?? null,
-        markdown: snapshot.plan.markdown ?? null,
-        content: snapshot.plan.content
-          ? serializePlanContent(snapshot.plan.content)
-          : null,
-        approvedAt: snapshot.plan.approvedAt ?? null,
-        updatedAt: now,
-      })
-      .where(eq(schema.plans.id, planId));
-
-    // Preserve comment anchors for sections whose ids survive in the snapshot.
-    // Strategy: capture comment→sectionId pairs for surviving sections first,
-    // then null ALL sectionIds (required to satisfy FK before section deletion),
-    // delete and re-insert sections, then re-anchor the surviving comments.
-    const survivingSectionIds = new Set(snapshot.sections.map((s) => s.id));
-    const commentAnchorMap = new Map<string, string>(); // commentId → sectionId
-    if (survivingSectionIds.size > 0) {
-      const anchored = await db
-        .select({
-          id: schema.planComments.id,
-          sectionId: schema.planComments.sectionId,
+    // The destructive part of the restore (plans update, comment sectionId
+    // nulling, section delete/re-insert, comment re-anchor, and the restore
+    // event) runs as a single atomic transaction. Without this, a
+    // mid-sequence failure could leave the plan with zero sections and
+    // permanently detached comments. better-sqlite3's normally-sync-only
+    // transaction() is patched to support async callbacks in
+    // packages/core/src/db/create-get-db.ts (patchBetterSqliteTransactions,
+    // wired into createGetDb for local sqlite urls), so this is safe on the
+    // local driver as well as libsql/Postgres.
+    await db.transaction(async (tx) => {
+      const updatedRows = await tx
+        .update(schema.plans)
+        .set({
+          title: snapshot.plan.title,
+          brief: snapshot.plan.brief,
+          status: snapshot.plan.status,
+          source: snapshot.plan.source,
+          repoPath: snapshot.plan.repoPath ?? null,
+          currentFocus: snapshot.plan.currentFocus ?? null,
+          html: snapshot.plan.html ?? null,
+          markdown: snapshot.plan.markdown ?? null,
+          content: snapshot.plan.content
+            ? serializePlanContent(snapshot.plan.content)
+            : null,
+          approvedAt: snapshot.plan.approvedAt ?? null,
+          updatedAt: now,
         })
-        .from(schema.planComments)
         .where(
           and(
-            eq(schema.planComments.planId, planId),
-            inArray(
-              schema.planComments.sectionId,
-              Array.from(survivingSectionIds),
-            ),
+            eq(schema.plans.id, planId),
+            eq(schema.plans.updatedAt, versionAtLoad),
           ),
+        )
+        .returning({ id: schema.plans.id });
+
+      if (updatedRows.length === 0) {
+        throw new Error(
+          "This plan was updated by someone else while the restore was being prepared. Reload the plan and try restoring again.",
         );
-      for (const row of anchored) {
-        if (row.sectionId) commentAnchorMap.set(row.id, row.sectionId);
       }
-    }
-
-    // Null ALL comment anchors so the section delete below doesn't violate FK.
-    await db
-      .update(schema.planComments)
-      .set({ sectionId: null, updatedAt: now })
-      .where(eq(schema.planComments.planId, planId));
-
-    await db
-      .delete(schema.planSections)
-      .where(eq(schema.planSections.planId, planId));
-
-    if (snapshot.sections.length > 0) {
-      await db.insert(schema.planSections).values(
-        snapshot.sections.map((section, index) => ({
-          id: section.id,
-          planId,
-          type: section.type,
-          title: section.title,
-          body: section.body,
-          html: section.html ?? null,
-          order: section.order ?? index,
-          createdBy: section.createdBy,
-          createdAt: section.createdAt || now,
-          updatedAt: section.updatedAt || now,
-        })),
-      );
-    }
-
-    // Re-anchor comments that were pointing to sections present in the snapshot.
-    // These sections now exist again, so the FK is satisfied and the comment
-    // threads remain navigable. Comments on sections that did not survive stay
-    // detached (sectionId = null).
-    if (commentAnchorMap.size > 0) {
-      const anchorGroups = new Map<string, string[]>(); // sectionId → commentIds
-      for (const [commentId, sectionId] of commentAnchorMap) {
-        const ids = anchorGroups.get(sectionId) ?? [];
-        ids.push(commentId);
-        anchorGroups.set(sectionId, ids);
-      }
-      for (const [sectionId, commentIds] of anchorGroups) {
-        await db
-          .update(schema.planComments)
-          .set({ sectionId, updatedAt: now })
+
+      // Preserve comment anchors for sections whose ids survive in the snapshot.
+      // Strategy: capture comment→sectionId pairs for surviving sections first,
+      // then null ALL sectionIds (required to satisfy FK before section deletion),
+      // delete and re-insert sections, then re-anchor the surviving comments.
+      const survivingSectionIds = new Set(snapshot.sections.map((s) => s.id));
+      const commentAnchorMap = new Map<string, string>(); // commentId → sectionId
+      if (survivingSectionIds.size > 0) {
+        const anchored = await tx
+          .select({
+            id: schema.planComments.id,
+            sectionId: schema.planComments.sectionId,
+          })
+          .from(schema.planComments)
           .where(
             and(
               eq(schema.planComments.planId, planId),
-              inArray(schema.planComments.id, commentIds),
+              inArray(
+                schema.planComments.sectionId,
+                Array.from(survivingSectionIds),
+              ),
             ),
           );
+        for (const row of anchored) {
+          if (row.sectionId) commentAnchorMap.set(row.id, row.sectionId);
+        }
       }
-    }
-
-    await db.insert(schema.planEvents).values({
-      id: newId("evt"),
-      planId,
-      type: "plan.version.restored",
-      message: "Restored plan from version history.",
-      payload: JSON.stringify({
-        restoredVersionId: version.id,
-        restoredVersionCreatedAt: version.createdAt,
-      }),
-      createdBy: "agent",
-      createdAt: now,
+
+      // Null ALL comment anchors so the section delete below doesn't violate FK.
+      await tx
+        .update(schema.planComments)
+        .set({ sectionId: null, updatedAt: now })
+        .where(eq(schema.planComments.planId, planId));
+
+      await tx
+        .delete(schema.planSections)
+        .where(eq(schema.planSections.planId, planId));
+
+      if (snapshot.sections.length > 0) {
+        await tx.insert(schema.planSections).values(
+          snapshot.sections.map((section, index) => ({
+            id: section.id,
+            planId,
+            type: section.type,
+            title: section.title,
+            body: section.body,
+            html: section.html ?? null,
+            order: section.order ?? index,
+            createdBy: section.createdBy,
+            createdAt: section.createdAt || now,
+            updatedAt: section.updatedAt || now,
+          })),
+        );
+      }
+
+      // Re-anchor comments that were pointing to sections present in the snapshot.
+      // These sections now exist again, so the FK is satisfied and the comment
+      // threads remain navigable. Comments on sections that did not survive stay
+      // detached (sectionId = null).
+      if (commentAnchorMap.size > 0) {
+        const anchorGroups = new Map<string, string[]>(); // sectionId → commentIds
+        for (const [commentId, sectionId] of commentAnchorMap) {
+          const ids = anchorGroups.get(sectionId) ?? [];
+          ids.push(commentId);
+          anchorGroups.set(sectionId, ids);
+        }
+        for (const [sectionId, commentIds] of anchorGroups) {
+          await tx
+            .update(schema.planComments)
+            .set({ sectionId, updatedAt: now })
+            .where(
+              and(
+                eq(schema.planComments.planId, planId),
+                inArray(schema.planComments.id, commentIds),
+              ),
+            );
+        }
+      }
+
+      await tx.insert(schema.planEvents).values({
+        id: newId("evt"),
+        planId,
+        type: "plan.version.restored",
+        message: "Restored plan from version history.",
+        payload: JSON.stringify({
+          restoredVersionId: version.id,
+          restoredVersionCreatedAt: version.createdAt,
+        }),
+        createdBy: "agent",
+        createdAt: now,
+      });
     });
 
     const bundle = await loadPlanBundle(planId);

package/corpus/templates/plan/changelog/2026-07-10-restoring-a-plan-version-can-no-longer-leave-a-plan-half-res.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Restoring a plan version can no longer leave a plan half-restored if something fails mid-restore

package/corpus/templates/plan/package.json

@@ -28,7 +28,7 @@
     "diff": "9.0.0",
     "drizzle-orm": "^0.45.2",
     "gray-matter": "^4.0.3",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "html2canvas": "^1.4.1",
     "isbot": "^5",
     "jszip": "^3.10.1",
@@ -102,7 +102,6 @@
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "catalog:",
     "tsx": "^4.20.3",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vaul": "^1.1.2",
     "vite": "catalog:",

package/corpus/templates/plan/server/plans.ts

@@ -434,6 +434,11 @@ export function buildUpdatedPlanCommentRows(input: {
   return rows;
 }
 
+// Chunk size for batched comment inserts. Keeps a single INSERT well under
+// SQLite's default 999-bound-parameter limit and Postgres' practical
+// statement-size limits even for a wide comment row shape.
+const PLAN_COMMENT_INSERT_CHUNK_SIZE = 200;
+
 export async function insertInitialPlanComments(input: {
   planId: string;
   comments: PlanCommentInput[];
@@ -442,9 +447,11 @@ export async function insertInitialPlanComments(input: {
   now: string;
 }) {
   const rows = buildInitialPlanCommentRows(input);
+  if (rows.length === 0) return;
   const db = getDb();
-  for (const row of rows) {
-    await db.insert(schema.planComments).values(row);
+  for (let i = 0; i < rows.length; i += PLAN_COMMENT_INSERT_CHUNK_SIZE) {
+    const chunk = rows.slice(i, i + PLAN_COMMENT_INSERT_CHUNK_SIZE);
+    await db.insert(schema.planComments).values(chunk);
   }
 }
 

package/corpus/templates/slides/actions/list-decks.ts

@@ -23,6 +23,14 @@ export default defineAction({
       .enum(["true", "false"])
       .optional()
       .describe("Set to 'true' for full frontend deck payloads"),
+    light: z
+      .enum(["true", "false"])
+      .optional()
+      .describe(
+        "Set to 'true' for a minimal id/title/updatedAt/visibility listing " +
+          "used for cheap add/remove diffing (e.g. background polling). " +
+          "Never reads the deck body — no slides, no slideCount.",
+      ),
     createdBy: z
       .enum(["all", "me"])
       .optional()
@@ -56,6 +64,26 @@ export default defineAction({
       args.createdBy === "me" && ownerEmail
         ? and(visibleDecks, eq(schema.decks.ownerEmail, ownerEmail))
         : visibleDecks;
+
+    if (args.light === "true") {
+      // Column-projected listing for cheap add/remove diffing (the client's
+      // background poll and SSE-reconnect resync). The `data` column holds
+      // each deck's entire slide JSON and can be large — never select it
+      // here. Callers that need slide content use `includeSlides: "true"` or
+      // fetch the specific deck via `get-deck`.
+      const rows = await db
+        .select({
+          id: schema.decks.id,
+          title: schema.decks.title,
+          updatedAt: schema.decks.updatedAt,
+          visibility: schema.decks.visibility,
+        })
+        .from(schema.decks)
+        .where(where)
+        .orderBy(desc(schema.decks.updatedAt));
+      return { count: rows.length, decks: rows };
+    }
+
     const rows = await db
       .select()
       .from(schema.decks)

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

@@ -1,32 +1,48 @@
 import DOMPurify from "dompurify";
-import mermaid from "mermaid";
 import { useEffect, useRef, useState } from "react";
 
-let initialized = false;
-let idCounter = 0;
+// `mermaid` pulls in d3 and its layout engine, which is a heavy chunk that
+// every deck view would otherwise ship even when no slide has a diagram.
+// Load it lazily and only once, the first time a mermaid slide actually
+// renders — mirrors the shiki lazy-load pattern in
+// packages/core/src/client/blocks/library/HighlightedCode.tsx.
+type MermaidModule = typeof import("mermaid");
 
-function initMermaid() {
-  if (initialized) return;
-  initialized = true;
-  mermaid.initialize({
-    startOnLoad: false,
-    securityLevel: "strict",
-    theme: "dark",
-    themeVariables: {
-      darkMode: true,
-      background: "transparent",
-      primaryColor: "#1a1a2e",
-      primaryTextColor: "#e0e0e0",
-      primaryBorderColor: "#00E5FF",
-      lineColor: "#00E5FF",
-      secondaryColor: "#16213e",
-      tertiaryColor: "#0f3460",
-      fontFamily: "Poppins, sans-serif",
-    },
-    flowchart: { curve: "basis" },
-  });
+let mermaidLoader: Promise<MermaidModule["default"]> | null = null;
+function loadMermaid(): Promise<MermaidModule["default"]> {
+  if (!mermaidLoader) {
+    mermaidLoader = import("mermaid")
+      .then((mod) => {
+        const mermaid = mod.default;
+        mermaid.initialize({
+          startOnLoad: false,
+          securityLevel: "strict",
+          theme: "dark",
+          themeVariables: {
+            darkMode: true,
+            background: "transparent",
+            primaryColor: "#1a1a2e",
+            primaryTextColor: "#e0e0e0",
+            primaryBorderColor: "#00E5FF",
+            lineColor: "#00E5FF",
+            secondaryColor: "#16213e",
+            tertiaryColor: "#0f3460",
+            fontFamily: "Poppins, sans-serif",
+          },
+          flowchart: { curve: "basis" },
+        });
+        return mermaid;
+      })
+      .catch((error) => {
+        mermaidLoader = null;
+        throw error;
+      });
+  }
+  return mermaidLoader;
 }
 
+let idCounter = 0;
+
 interface MermaidRendererProps {
   definition: string;
   className?: string;
@@ -42,13 +58,12 @@ export function MermaidRenderer({
 
   useEffect(() => {
     if (!definition.trim()) return;
-    initMermaid();
 
     let cancelled = false;
     const id = `mermaid-${++idCounter}`;
 
-    mermaid
-      .render(id, definition.trim())
+    loadMermaid()
+      .then((mermaid) => mermaid.render(id, definition.trim()))
       .then(({ svg: renderedSvg }) => {
         if (cancelled) return;
         // Mermaid 11.x runs DOMPurify internally with `securityLevel:"strict"`,

package/corpus/templates/slides/app/components/design-system/DesignSystemSetup.tsx

@@ -20,6 +20,7 @@ import {
   IconExternalLink,
 } from "@tabler/icons-react";
 import { useState, useCallback, useEffect, useRef, useMemo } from "react";
+import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
 import {
@@ -33,7 +34,6 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { Textarea } from "@/components/ui/textarea";
-import { toast } from "@/hooks/use-toast";
 
 import {
   MAX_BUILDER_INDEX_UPLOAD_BYTES,
@@ -305,12 +305,9 @@ export function DesignSystemSetup({
         customInstructions,
       });
       onComplete();
-      toast({ title: t("designSystemSetup.updated") });
+      toast.success(t("designSystemSetup.updated"));
     } catch {
-      toast({
-        title: t("designSystemSetup.updateFailed"),
-        variant: "destructive",
-      });
+      toast.error(t("designSystemSetup.updateFailed"));
     } finally {
       setGenerating(false);
     }
@@ -446,8 +443,7 @@ export function DesignSystemSetup({
 
     openAgentSidebar();
     sendToAgentChat({ message: parts.join("\n"), submit: true });
-    toast({
-      title: t("designSystemSetup.generationStarted"),
+    toast(t("designSystemSetup.generationStarted"), {
       description: t("designSystemSetup.generationStartedDescription"),
     });
     onComplete();

package/corpus/templates/slides/app/components/editor/EditorSidebar.tsx

@@ -24,6 +24,7 @@ import {
 import { useState, useRef, useEffect } from "react";
 import { useCallback } from "react";
 import { createPortal } from "react-dom";
+import { toast } from "sonner";
 
 import SlideRenderer from "@/components/deck/SlideRenderer";
 import { GoogleDocImportHint } from "@/components/editor/GoogleDocImportHint";
@@ -35,7 +36,6 @@ import {
 } from "@/components/ui/tooltip";
 import type { Slide } from "@/context/DeckContext";
 import { useAgentGenerating } from "@/hooks/use-agent-generating";
-import { toast } from "@/hooks/use-toast";
 import type { AspectRatio } from "@/lib/aspect-ratios";
 
 interface EditorSidebarProps {
@@ -402,13 +402,11 @@ function AddSlidePopover({
           }
           uploaded = (await res.json()) as UploadedFile[];
         } catch (error) {
-          toast({
-            title: t("editorSidebar.uploadFailed"),
+          toast.error(t("editorSidebar.uploadFailed"), {
             description:
               error instanceof Error
                 ? error.message
                 : t("editorSidebar.uploadAttachedFileFailed"),
-            variant: "destructive",
           });
           return;
         }

package/corpus/templates/slides/app/components/editor/EditorToolbar.tsx

@@ -42,6 +42,7 @@ import { useTheme } from "next-themes";
 import { useState, useRef, useEffect } from "react";
 import { createPortal } from "react-dom";
 import { Link } from "react-router";
+import { toast } from "sonner";
 
 import {
   DropdownMenu,
@@ -58,7 +59,6 @@ import {
 import { SaveStatusIndicator } from "@/components/visual-editor";
 import type { Deck, Slide, SlideLayout } from "@/context/DeckContext";
 import { defaultSlideContent, useSaveState } from "@/context/DeckContext";
-import { toast } from "@/hooks/use-toast";
 import {
   ASPECT_RATIO_VALUES,
   type AspectRatio,
@@ -321,8 +321,7 @@ export default function EditorToolbar({
     const file = e.target.files?.[0];
     if (!file) return;
     setImporting(true);
-    toast({
-      title: t("editorToolbar.importingFile"),
+    toast(t("editorToolbar.importingFile"), {
       description: t("editorToolbar.readingFile", { fileName: file.name }),
     });
     const formData = new FormData();
@@ -369,8 +368,7 @@ export default function EditorToolbar({
       if (!importRes.ok || importData?.error) {
         throw new Error(importData?.error || t("editorToolbar.importFailed"));
       }
-      toast({
-        title: t("editorToolbar.importComplete"),
+      toast.success(t("editorToolbar.importComplete"), {
         description:
           typeof importData.slideCount === "number"
             ? t("editorToolbar.importCompleteSlides", {
@@ -383,13 +381,11 @@ export default function EditorToolbar({
       });
     } catch (err) {
       console.error("Import failed:", err);
-      toast({
-        title: t("editorToolbar.importFailed"),
+      toast.error(t("editorToolbar.importFailed"), {
         description:
           err instanceof Error
             ? err.message
             : t("editorToolbar.importFailedDescription"),
-        variant: "destructive",
       });
     } finally {
       setImporting(false);

package/corpus/templates/slides/app/components/editor/ExportMenu.tsx

@@ -7,6 +7,7 @@ import {
   IconShare2,
   IconBrandGoogle,
 } from "@tabler/icons-react";
+import { toast } from "sonner";
 
 import {
   DropdownMenu,
@@ -16,7 +17,6 @@ import {
   DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
-import { toast } from "@/hooks/use-toast";
 
 interface ExportMenuProps {
   deckId: string;
@@ -73,13 +73,11 @@ export function ExportMenu({
       await onExportPptx();
     } catch (err) {
       console.error("Export failed:", err);
-      toast({
-        title: t("editorExport.exportFailed"),
+      toast.error(t("editorExport.exportFailed"), {
         description:
           err instanceof Error
             ? err.message
             : t("editorExport.exportPptxError"),
-        variant: "destructive",
       });
     }
   };
@@ -87,19 +85,16 @@ export function ExportMenu({
   const handleExportGoogleSlides = async () => {
     try {
       await onExportPptx();
-      toast({
-        title: t("editorExport.googleSlidesDownloaded"),
+      toast.success(t("editorExport.googleSlidesDownloaded"), {
         description: t("editorExport.googleSlidesImportHint"),
       });
     } catch (err) {
       console.error("Export failed:", err);
-      toast({
-        title: t("editorExport.exportFailed"),
+      toast.error(t("editorExport.exportFailed"), {
         description:
           err instanceof Error
             ? err.message
             : t("editorExport.exportGoogleSlidesError"),
-        variant: "destructive",
       });
     }
   };
@@ -124,13 +119,11 @@ export function ExportMenu({
       triggerBlobDownload(blob, filename);
     } catch (err) {
       console.error("Export failed:", err);
-      toast({
-        title: t("editorExport.exportFailed"),
+      toast.error(t("editorExport.exportFailed"), {
         description:
           err instanceof Error
             ? err.message
             : t("editorExport.exportHtmlError"),
-        variant: "destructive",
       });
     }
   };

package/corpus/templates/slides/app/components/editor/HistoryPanel.tsx

@@ -6,6 +6,7 @@ import {
   IconRestore,
 } from "@tabler/icons-react";
 import { useMemo, useState, type RefObject } from "react";
+import { toast } from "sonner";
 
 import SlideRenderer from "@/components/deck/SlideRenderer";
 import { Button } from "@/components/ui/button";
@@ -25,7 +26,6 @@ import {
   useDeckVersions,
   useRestoreDeckVersion,
 } from "@/hooks/use-deck-versions";
-import { toast } from "@/hooks/use-toast";
 import type { AspectRatio } from "@/lib/aspect-ratios";
 
 import type { DeckVersionSummary } from "../../../shared/api";
@@ -107,19 +107,16 @@ export default function HistoryPanel({
         deckId,
         versionId: selectedVersionId,
       });
-      toast({
-        title: t("history.versionRestored"),
+      toast.success(t("history.versionRestored"), {
         description: t("history.versionRestoredDescription"),
       });
       handleClose(false);
     } catch (error) {
-      toast({
-        title: t("history.restoreFailed"),
+      toast.error(t("history.restoreFailed"), {
         description:
           error instanceof Error
             ? error.message
             : t("history.restoreFailedDescription"),
-        variant: "destructive",
       });
     }
   };