@agent-native/core 0.144.0 → 0.144.2

package/corpus/templates/slides/app/lib/create-deck-generation.ts

@@ -6,6 +6,10 @@ import type { NewDeckReferenceSelection } from "@/components/editor/NewDeckRefer
 import type { UploadedFile } from "@/components/editor/PromptDialog";
 import type { Deck, DeckPersistenceResult } from "@/context/DeckContext";
 import { createDeckAgentMessage } from "@/lib/agent-visible-message";
+import {
+  importUploadedDeckIntoDeck,
+  type ImportedSourceDeck,
+} from "@/lib/import-uploaded-deck";
 
 interface DesignSystemGenerationContextResult {
   agentContext?: string;
@@ -85,6 +89,7 @@ async function loadReferenceDeckGenerationContext(
 function describeUploadedFilesForAgent(
   files: UploadedFile[],
   deckId: string,
+  importedSourceDeck?: ImportedSourceDeck | null,
 ): string {
   if (files.length === 0) return "";
   const fileList = files
@@ -93,14 +98,21 @@ function describeUploadedFilesForAgent(
         `- ${file.originalName} (${file.type}, ${(file.size / 1024).toFixed(1)}KB) at path: ${file.path}${file.url ? `; embeddable URL: ${file.url}` : ""}`,
     )
     .join("\n");
+  const sourceFile = importedSourceDeck?.file;
   return [
     "",
-    `The user uploaded ${files.length} file(s). These paths are real uploaded files; process them with import actions before using their contents:`,
+    importedSourceDeck
+      ? `The user uploaded ${files.length} file(s). The ${sourceFile?.originalName ?? importedSourceDeck.format.toUpperCase()} source deck has already been imported into target deck ${deckId} with ${importedSourceDeck.slideCount} source slide(s); do not import it again.`
+      : `The user uploaded ${files.length} file(s). These paths are real uploaded files; process them with import actions before using their contents:`,
     fileList,
     "",
     "File handling rules:",
-    `- PPTX files: call \`import-pptx --filePath \"<path>\" --deckId ${deckId}\` before adding or editing slides.`,
-    `- PDF and DOCX files: call \`import-file --filePath \"<path>\" --format auto --deckId ${deckId}\` and use the returned extracted text as source material. For a visual PDF whose original layout should be preserved, pass \`--importIntoDeck true\` instead of rebuilding the pages from extracted text.`,
+    importedSourceDeck
+      ? "- The imported source deck is the canonical source. Preserve its slide count, order, IDs, factual copy, notes, imagery, charts, tables, diagrams, and freeform objects while improving styling. Use update-slide on existing slide IDs; do not rebuild it with add-slide."
+      : `- PPTX files: call \`import-pptx --filePath \"<path>\" --deckId ${deckId}\` before adding or editing slides.`,
+    importedSourceDeck
+      ? "- For a PDF source, keep the original full-page image in every slide and add restrained design-system chrome around it without obscuring source content. Never OCR-reconstruct a source-faithful page from extracted text."
+      : `- PDF and DOCX files: call \`import-file --filePath \"<path>\" --format auto --deckId ${deckId}\` and use the returned extracted text as source material. For a visual PDF whose original layout should be preserved, pass \`--importIntoDeck true\` instead of rebuilding the pages from extracted text.`,
     "- Text-like files: use the uploaded-text-file blocks already included in the prompt; do not call import-file for them.",
     '- Image files with an embeddable URL can be inserted directly into slide HTML as `<img src="...">` or used as visual references.',
     "- Image files without a URL are visual/reference assets only; do not claim to have processed a PPTX/PDF/DOCX unless the relevant import action succeeds.",
@@ -161,6 +173,11 @@ export interface StartDeckGenerationOptions {
     files: UploadedFile[],
     failure: DeckPersistenceResult,
   ) => void;
+  onSetupFailure: (
+    prompt: string,
+    files: UploadedFile[],
+    failure: unknown,
+  ) => void;
 }
 
 /** Create the optimistic deck, hydrate references, and start the agent run. */
@@ -181,6 +198,7 @@ export async function startDeckGeneration({
   onPromptClosed,
   onUnauthenticated,
   onPersistenceFailure,
+  onSetupFailure,
 }: StartDeckGenerationOptions): Promise<
   "started" | "failed" | "unauthenticated"
 > {
@@ -215,7 +233,6 @@ export async function startDeckGeneration({
   });
   if (!deck) return "failed";
   const deckId = deck.id;
-  onPromptClosed();
 
   const persisted = await ensureDeckPersisted(deck.id);
   if (!persisted.persisted) {
@@ -224,6 +241,20 @@ export async function startDeckGeneration({
     return "failed";
   }
 
+  let importedSourceDeck: ImportedSourceDeck | null = null;
+  try {
+    importedSourceDeck = await importUploadedDeckIntoDeck(
+      filesForGeneration,
+      deckId,
+    );
+  } catch (error) {
+    deleteDeck(deckId);
+    onSetupFailure(prompt, filesForGeneration, error);
+    return "failed";
+  }
+
+  onPromptClosed();
+
   navigate(`/deck/${deck.id}`, { flushSync: true });
 
   const trimmedPrompt = prompt.trim();
@@ -231,7 +262,11 @@ export async function startDeckGeneration({
   const googleDocUrls = hasImportedGoogleDocContext
     ? []
     : extractGoogleDocUrls(trimmedPrompt);
-  const fileContext = describeUploadedFilesForAgent(filesForGeneration, deckId);
+  const fileContext = describeUploadedFilesForAgent(
+    filesForGeneration,
+    deckId,
+    importedSourceDeck,
+  );
   const googleDocContext =
     googleDocUrls.length > 0
       ? [
@@ -260,7 +295,9 @@ export async function startDeckGeneration({
     : [
         "",
         "Design system selection:",
-        "- None selected. Do not apply a design system unless the user asks for one.",
+        "- No design system was selected in the picker.",
+        "- Before generating a bare or on-brand deck, call `get-workspace-defaults`. If it returns a usable design system, patch this deck with that designSystemId, call `get-design-system`, and follow its exact tokens, assets, and custom instructions.",
+        "- If no workspace default exists, use the product's configured design-system action and report the missing configuration instead of inventing a generic Builder-like palette.",
       ].join("\n");
   const referenceSource = referenceSelection.referenceSource;
   const referenceSourceContext = referenceSource
@@ -275,21 +312,45 @@ export async function startDeckGeneration({
             : "Use the Figma source as the design reference. If Builder or Figma access is required, report the exact connection step instead of guessing.",
       ].join("\n")
     : "";
+  const sourceDeckContext = importedSourceDeck
+    ? [
+        "",
+        "Source-preserving improvement mode:",
+        `- The target deck already contains ${importedSourceDeck.slideCount} imported source slides. Treat those slides as the user's complete source, not as inspiration for a new deck.`,
+        "- Keep the exact source slide count, order, IDs, factual meaning, notes, images, charts, tables, diagrams, and freeform objects unless the user explicitly asks to change one of them.",
+        "- Read `get-deck` before editing, load the linked design system with `get-design-system`, then use one `update-slide` call per existing slide ID for bounded visual improvements. Keep every original `<img>` source and enough original factual copy for each slide; for PDF slides, use restrained design-system chrome around the page without obscuring it.",
+        "- Do not call `add-slide`, delete slides, reorder slides, or replace source images with generic cards. Do not claim success until `get-deck` verifies the same slide IDs and count after the edits.",
+        "- If `get-deck` reports partial source fidelity or skipped images, stop and report the exact warning instead of claiming a reliable restyle.",
+      ].join("\n")
+    : "";
+  const sourceModeInstructions = importedSourceDeck
+    ? [
+        "The request is an in-place visual improvement of an imported source deck. Make a coherent style pass across every existing slide while preserving all source content and media.",
+        "Do not use the new-deck add-slide workflow for this source-preserving request.",
+      ]
+    : [
+        "Start a `manage-progress` run so progress appears in the app header. Add the first slide as soon as it is ready, then continue one slide at a time so the editor visibly fills in.",
+        `After reading any requested or imported source material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Call \`patch-deck\` with \`deckId: \"${deckId}\"\` and \`operations: [{ \"op\": \"patch-deck-fields\", \"fields\": { \"title\": \"<generated title>\" } }]\`. Include only \`title\` in \`fields\`; omit all other optional fields. Never leave a generated deck named \"Untitled Deck\" or another placeholder.`,
+        "If the user asks for a standalone visual, diagram, hero, one-pager, poster, or a couple of visuals, create only the requested one/few polished visual slides. Do not pad the result into a full presentation.",
+        "If the request is for a presentation or deck and does not explicitly ask for one slide, infer a coherent multi-slide outline from the scope and keep adding slides until that outline is complete. Do not stop after the first slide just because the prompt has few explicit instructions.",
+        `Add slides ONE AT A TIME using the \`add-slide\` action with --deckId=${deckId}. Wait for each \`add-slide\` result before calling it again; do not batch or parallelize slide writes.`,
+        "Use create-deck and add-slide for this already-created deck. Do not call the legacy generate-slides-ai action: it returns Markdown drafts rather than persisted rendered slide HTML. Treat each successful add-slide result as confirmation to continue with the next planned slide.",
+      ].join("\n");
 
   const context = [
-    `The user just created a new empty deck (id: "${deckId}") and wants to create a presentation or standalone visual.`,
+    importedSourceDeck
+      ? `The user uploaded a source presentation into target deck (id: "${deckId}") and wants a reliable visual improvement.`
+      : `The user just created a new empty deck (id: "${deckId}") and wants to create a presentation or standalone visual.`,
     "The visible user message above contains the user's request and/or pasted source material for the deck. Treat pasted memo content as source material even if the user did not explicitly say they are pasting it.",
     googleDocContext,
     fileContext,
     referenceDeckContext,
     designSystemContext,
     referenceSourceContext,
+    sourceDeckContext,
     "",
     "Before generating, if the request or selected references leave a meaningful choice unresolved, use the `ask-question` tool to ask one concise, prompt-specific question in the inline guided-question flow. Generate the question wording and 2 to 4 options from the user's request and selected references, like Claude's design-question flow; do not use a fixed generic questionnaire. Ask only a choice that materially affects the deck, such as audience, tone, structure, or length. If the prompt already makes the choice clear, do not ask it again. Wait for the user's answer or skip before adding slides.",
-    "Start a `manage-progress` run so progress appears in the app header. Add the first slide as soon as it is ready, then continue one slide at a time so the editor visibly fills in.",
-    `After reading any requested or imported source material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Call \`patch-deck\` with \`deckId: \"${deckId}\"\` and \`operations: [{ \"op\": \"patch-deck-fields\", \"fields\": { \"title\": \"<generated title>\" } }]\`. Include only \`title\` in \`fields\`; omit all other optional fields. Never leave a generated deck named \"Untitled Deck\" or another placeholder.`,
-    "If the user asks for a standalone visual, diagram, hero, one-pager, poster, or a couple of visuals, create only the requested one/few polished visual slides. Do not pad the result into a full presentation.",
-    `Add slides ONE AT A TIME using the \`add-slide\` action with --deckId=${deckId}. Wait for each \`add-slide\` result before calling it again; do not batch or parallelize slide writes.`,
+    sourceModeInstructions,
     "If the user asked for a specific slide count, keep going sequentially until that count is reached unless a tool error blocks you.",
     "Every slide is rendered into a fixed native canvas (default 16:9 is 960x540 CSS pixels, with 740x380px available inside standard 80px 110px padding). Keep the main content within that fit budget; split dense source material across more slides instead of packing it tightly. Never use zoom, transform: scale(), clipping, or scroll overflow to hide content overflow, and keep body text at least 16px.",
     "Each slide's --content must be full HTML. Slide HTML templates are in your AGENTS.md.",

package/corpus/templates/slides/app/lib/import-uploaded-deck.ts

@@ -0,0 +1,89 @@
+import { callAction } from "@agent-native/core/client/hooks";
+
+import type { UploadedFile } from "@/components/editor/PromptDialog";
+
+export type ImportedSourceDeck = {
+  file: UploadedFile;
+  format: "pdf" | "pptx";
+  slideCount: number;
+  imagesSkipped: number;
+};
+
+function sourceFormat(file: UploadedFile): "pdf" | "pptx" | null {
+  const name = file.originalName.toLowerCase();
+  if (name.endsWith(".pptx")) return "pptx";
+  if (name.endsWith(".pdf")) return "pdf";
+  return null;
+}
+
+function actionResultRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The uploaded presentation import returned no result.");
+  }
+  return value as Record<string, unknown>;
+}
+
+/**
+ * Imports the user's source deck into the already-persisted target deck before
+ * the agent run starts. This keeps the agent on the source slide IDs and
+ * preserves source-native images instead of asking it to reconstruct a deck
+ * from extracted text.
+ */
+export async function importUploadedDeckIntoDeck(
+  files: UploadedFile[],
+  deckId: string,
+): Promise<ImportedSourceDeck | null> {
+  const deckFiles = files.filter((file) => sourceFormat(file));
+  if (deckFiles.length === 0) return null;
+  if (deckFiles.length > 1) {
+    throw new Error(
+      "Upload one presentation at a time when asking Slides to improve it. Multiple source decks cannot be merged safely without losing slide order or content.",
+    );
+  }
+
+  const file = deckFiles[0];
+  if (!file) return null;
+  const format = sourceFormat(file);
+  if (!format) return null;
+
+  const result = actionResultRecord(
+    await callAction(
+      format === "pptx" ? "import-pptx" : "import-file",
+      format === "pptx"
+        ? { filePath: file.path, deckId }
+        : {
+            filePath: file.path,
+            format: "pdf",
+            deckId,
+            importIntoDeck: true,
+          },
+    ),
+  );
+  if (result.imported !== true || result.deckId !== deckId) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck was not imported into the target deck, so no source-preserving improvement was started.`,
+    );
+  }
+
+  const slideCount = result.slideCount;
+  if (typeof slideCount !== "number" || !Number.isInteger(slideCount)) {
+    throw new Error(
+      `The ${format.toUpperCase()} import did not report a reliable slide count, so no source-preserving improvement was started.`,
+    );
+  }
+  if (slideCount < 1) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck contained no importable slides.`,
+    );
+  }
+
+  const imagesSkipped =
+    typeof result.imagesSkipped === "number" ? result.imagesSkipped : 0;
+  if (imagesSkipped > 0) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck could not preserve ${imagesSkipped} image(s), so Slides stopped before restyling it. Re-export the deck with browser-renderable images, or upload a PDF for source-faithful page preservation.`,
+    );
+  }
+
+  return { file, format, slideCount, imagesSkipped };
+}

package/corpus/templates/slides/app/pages/Index.tsx

@@ -52,6 +52,10 @@ import { useWorkspaceDefaults } from "@/hooks/use-workspace-defaults";
 import { createDeckAgentMessage } from "@/lib/agent-visible-message";
 import { savePromptToComposerDraft } from "@/lib/composer-draft";
 import { sortDecksByRecency } from "@/lib/deck-sorting";
+import {
+  importUploadedDeckIntoDeck,
+  type ImportedSourceDeck,
+} from "@/lib/import-uploaded-deck";
 import {
   readRecentReferences,
   rememberRecentReference,
@@ -181,6 +185,7 @@ async function loadReferenceDeckGenerationContext(
 function describeUploadedFilesForAgent(
   files: UploadedFile[],
   deckId: string,
+  importedSourceDeck?: ImportedSourceDeck | null,
 ): string {
   if (files.length === 0) return "";
   const fileList = files
@@ -191,12 +196,18 @@ function describeUploadedFilesForAgent(
     .join("\n");
   return [
     "",
-    `The user uploaded ${files.length} file(s). These paths are real uploaded files; process them with import actions before using their contents:`,
+    importedSourceDeck
+      ? `The user uploaded ${files.length} file(s). The ${importedSourceDeck.file.originalName} source deck has already been imported into target deck ${deckId} with ${importedSourceDeck.slideCount} source slide(s); do not import it again.`
+      : `The user uploaded ${files.length} file(s). These paths are real uploaded files; process them with import actions before using their contents:`,
     fileList,
     "",
     "File handling rules:",
-    `- PPTX files: call \`import-pptx --filePath "<path>" --deckId ${deckId}\` before adding or editing slides.`,
-    `- PDF and DOCX files: call \`import-file --filePath "<path>" --format auto --deckId ${deckId}\` and use the returned extracted text as source material. For a visual PDF whose original layout should be preserved, pass \`--importIntoDeck true\` instead of rebuilding the pages from extracted text.`,
+    importedSourceDeck
+      ? "- The imported source deck is the canonical source. Preserve its slide count, order, IDs, factual copy, notes, imagery, charts, tables, diagrams, and freeform objects while improving styling. Use update-slide on existing slide IDs; do not rebuild it with add-slide."
+      : `- PPTX files: call \`import-pptx --filePath "<path>" --deckId ${deckId}\` before adding or editing slides.`,
+    importedSourceDeck
+      ? "- For a PDF source, keep the original full-page image in every slide and add restrained design-system chrome around it without obscuring source content. Never OCR-reconstruct a source-faithful page from extracted text."
+      : `- PDF and DOCX files: call \`import-file --filePath "<path>" --format auto --deckId ${deckId}\` and use the returned extracted text as source material. For a visual PDF whose original layout should be preserved, pass \`--importIntoDeck true\` instead of rebuilding the pages from extracted text.`,
     "- Text-like files: use the uploaded-text-file blocks already included in the prompt; do not call import-file for them.",
     '- Image files with an embeddable URL can be inserted directly into slide HTML as `<img src="...">` or used as visual references.',
     "- Image files without a URL are visual/reference assets only; do not claim to have processed a PPTX/PDF/DOCX unless the relevant import action succeeds.",
@@ -555,11 +566,15 @@ export default function Index() {
     const designSystemId =
       referenceSelection.designSystemId !== undefined
         ? referenceSelection.designSystemId
-        : selectedDesignSystemId;
+        : selectedDesignSystemId && selectedDesignSystemId !== "none"
+          ? selectedDesignSystemId
+          : null;
     const referenceDeckId =
       referenceSelection.referenceDeckId !== undefined
         ? referenceSelection.referenceDeckId
-        : selectedReferenceDeckId;
+        : selectedReferenceDeckId && selectedReferenceDeckId !== "none"
+          ? selectedReferenceDeckId
+          : null;
     const selectedDesignSystem = designSystemId
       ? designSystems.find((ds) => ds.id === designSystemId)
       : undefined;
@@ -591,6 +606,28 @@ export default function Index() {
       return;
     }
 
+    let importedSourceDeck: ImportedSourceDeck | null = null;
+    try {
+      importedSourceDeck = await importUploadedDeckIntoDeck(
+        filesForGeneration,
+        deckId,
+      );
+    } catch (error) {
+      if (!savePromptForRetry(prompt)) {
+        setNewDeckInitialPrompt({ text: prompt, key: Date.now() });
+      }
+      setNewDeckRetryFiles(filesForGeneration);
+      deleteDeck(deckId);
+      toast.error(t("home.generationStartFailed"), {
+        description:
+          error instanceof Error
+            ? error.message
+            : t("home.generationStartFailedDescription"),
+      });
+      setShowNewDeckPrompt(true);
+      return;
+    }
+
     clearPendingPromptForRetry();
     setNewDeckInitialPrompt(null);
     setNewDeckRetryFiles([]);
@@ -604,6 +641,7 @@ export default function Index() {
     const fileContext = describeUploadedFilesForAgent(
       filesForGeneration,
       deckId,
+      importedSourceDeck,
     );
     const googleDocContext =
       googleDocUrls.length > 0
@@ -633,7 +671,9 @@ export default function Index() {
       : [
           "",
           "Design system selection:",
-          "- None selected. Do not apply a design system unless the user asks for one.",
+          "- No design system was selected in the picker.",
+          "- Before generating a bare or on-brand deck, call `get-workspace-defaults`. If it returns a usable design system, patch this deck with that designSystemId, call `get-design-system`, and follow its exact tokens, assets, and custom instructions.",
+          "- If no workspace default exists, report the missing configuration instead of inventing a generic Builder-like palette.",
         ].join("\n");
     const referenceSource = referenceSelection.referenceSource;
     const referenceSourceContext = referenceSource
@@ -648,27 +688,49 @@ export default function Index() {
               : "Use the Figma source as the design reference. If Builder or Figma access is required, report the exact connection step instead of guessing.",
         ].join("\n")
       : "";
+    const sourceDeckContext = importedSourceDeck
+      ? [
+          "",
+          "Source-preserving improvement mode:",
+          `- The target deck already contains ${importedSourceDeck.slideCount} imported source slides. Treat those slides as the user's complete source, not as inspiration for a new deck.`,
+          "- Keep the exact source slide count, order, IDs, factual meaning, notes, images, charts, tables, diagrams, and freeform objects unless the user explicitly asks to change one of them.",
+          "- Read `get-deck` before editing, load the linked design system with `get-design-system`, then use one `update-slide` call per existing slide ID for bounded visual improvements. Keep every original `<img>` source and enough original factual copy for each slide; for PDF slides, use restrained design-system chrome around the page without obscuring it.",
+          "- Do not call `add-slide`, delete slides, reorder slides, or replace source images with generic cards. Do not claim success until `get-deck` verifies the same slide IDs and count after the edits.",
+          "- If `get-deck` reports partial source fidelity or skipped images, stop and report the exact warning instead of claiming a reliable restyle.",
+        ].join("\n")
+      : "";
+    const sourceModeInstructions = importedSourceDeck
+      ? [
+          "The request is an in-place visual improvement of an imported source deck. Make a coherent style pass across every existing slide while preserving all source content and media.",
+          "Do not use the new-deck add-slide workflow for this source-preserving request.",
+        ].join("\n")
+      : [
+          "Start a `manage-progress` run so progress appears in the app header. Add the first slide as soon as it is ready, then continue one slide at a time so the editor visibly fills in.",
+          "After reading any requested or imported source material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Call `patch-deck` with `deckId: \"" +
+            deckId +
+            '\"` and `operations: [{ "op": "patch-deck-fields", "fields": { "title": "<generated title>" } }]`. Include only `title` in `fields`; omit all other optional fields. Never leave a generated deck named "Untitled Deck" or another placeholder.',
+          "If the user asks for a standalone visual, diagram, hero, one-pager, poster, or a couple of visuals, create only the requested one/few polished visual slides. Do not pad the result into a full presentation.",
+          "If the request is for a presentation or deck and does not explicitly ask for one slide, infer a coherent multi-slide outline from the scope and keep adding slides until that outline is complete. Do not stop after the first slide just because the prompt has few explicit instructions.",
+          "Add slides ONE AT A TIME using the `add-slide` action with --deckId=" +
+            deckId +
+            ". Wait for each `add-slide` result before calling it again; do not batch or parallelize slide writes.",
+          "Use create-deck and add-slide for this already-created deck. Do not call the legacy generate-slides-ai action: it returns Markdown drafts rather than persisted rendered slide HTML. Treat each successful add-slide result as confirmation to continue with the next planned slide.",
+        ].join("\n");
 
     const context = [
-      `The user just created a new empty deck (id: "${deckId}") and wants to create a presentation or standalone visual.`,
+      importedSourceDeck
+        ? `The user uploaded a source presentation into target deck (id: "${deckId}") and wants a reliable visual improvement.`
+        : `The user just created a new empty deck (id: "${deckId}") and wants to create a presentation or standalone visual.`,
       "The visible user message above contains the user's request and/or pasted source material for the deck. Treat pasted memo content as source material even if the user did not explicitly say they are pasting it.",
       googleDocContext,
       fileContext,
       referenceDeckContext,
       designSystemContext,
       referenceSourceContext,
+      sourceDeckContext,
       "",
       "Before generating, if the request or selected references leave a meaningful choice unresolved, use the `ask-question` tool to ask one concise, prompt-specific question in the inline guided-question flow. Generate the question wording and 2 to 4 options from the user's request and selected references, like Claude's design-question flow; do not use a fixed generic questionnaire. Ask only a choice that materially affects the deck, such as audience, tone, structure, or length. If the prompt already makes the choice clear, do not ask it again. Wait for the user's answer or skip before adding slides.",
-      "Start a `manage-progress` run so progress appears in the app header. Add the first slide as soon as it is ready, then continue one slide at a time so the editor visibly fills in.",
-      "After reading any requested or imported source material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Call `patch-deck` with `deckId: \"" +
-        deckId +
-        '"` and `operations: [{ "op": "patch-deck-fields", "fields": { "title": "<generated title>" } }]`. Include only `title` in `fields`; omit all other optional fields. Never leave a generated deck named "Untitled Deck" or another placeholder.',
-      "If the user asks for a standalone visual, diagram, hero, one-pager, poster, or a couple of visuals, create only the requested one/few polished visual slides. Do not pad the result into a full presentation.",
-      "If the request is for a presentation or deck and does not explicitly ask for one slide, infer a coherent multi-slide outline from the scope and keep adding slides until that outline is complete. Do not stop after the first slide just because the prompt has few explicit instructions.",
-      "Add slides ONE AT A TIME using the `add-slide` action with --deckId=" +
-        deckId +
-        ". Wait for each `add-slide` result before calling it again; do not batch or parallelize slide writes.",
-      "Use create-deck and add-slide for this already-created deck. Do not call the legacy generate-slides-ai action: it returns Markdown drafts rather than persisted rendered slide HTML. Treat each successful add-slide result as confirmation to continue with the next planned slide.",
+      sourceModeInstructions,
       "If the user asked for a specific slide count, keep going sequentially until that count is reached unless a tool error blocks you.",
       "Every slide is rendered into a fixed native canvas (default 16:9 is 960x540 CSS pixels, with 740x380px available inside standard 80px 110px padding). Keep the main content within that fit budget; split dense source material across more slides instead of packing it tightly. Never use zoom, transform: scale(), clipping, or scroll overflow to hide content overflow, and keep body text at least 16px.",
       "Each slide's --content must be full HTML. Slide HTML templates are in your AGENTS.md.",
@@ -724,6 +786,7 @@ export default function Index() {
       if (selection.kind === "pptx") {
         const imported = (await callAction("import-pptx", {
           filePath: file.path,
+          designSystemId: initialDesignSystemId,
         })) as { id?: unknown };
         if (typeof imported.id !== "string" || !imported.id) {
           throw new Error("The PowerPoint presentation did not create a deck.");
@@ -735,7 +798,10 @@ export default function Index() {
 
       let deck: ReturnType<typeof createDeck> | undefined;
       flushSync(() => {
-        deck = createDeck(undefined, { noDefaultSlides: true });
+        deck = createDeck(undefined, {
+          noDefaultSlides: true,
+          designSystemId: initialDesignSystemId,
+        });
       });
       if (!deck) throw new Error("The PDF deck could not be created.");
 
@@ -776,6 +842,7 @@ export default function Index() {
       navigate,
       reloadDecks,
       session,
+      initialDesignSystemId,
     ],
   );
 

package/corpus/templates/slides/changelog/2026-08-06-uploaded-decks-keep-their-slides-and-visuals-when-you-improv.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-06
+---
+
+Uploaded decks keep their slides and visuals when you improve and export them

package/corpus/templates/slides/server/handlers/import/html-converter.ts

@@ -53,8 +53,19 @@ export function buildFullBleedImageSlideHtml(
 }
 
 /** Render a rasterized source page without changing its layout or text. */
-export function buildFullPageImageSlideHtml(imageUrl: string): string {
-  return `<div class="fmd-slide" style="position: relative; width: 100%; height: 100%; overflow: hidden; background: hsl(var(--background));">
+export function buildFullPageImageSlideHtml(
+  imageUrl: string,
+  sourceWidth?: number,
+  sourceHeight?: number,
+): string {
+  const sourceDimensions =
+    Number.isFinite(sourceWidth) &&
+    Number.isFinite(sourceHeight) &&
+    sourceWidth! > 0 &&
+    sourceHeight! > 0
+      ? ` data-source-width="${sourceWidth}" data-source-height="${sourceHeight}"`
+      : "";
+  return `<div class="fmd-slide fmd-imported-pdf" data-imported-pdf="true"${sourceDimensions} style="position: relative; width: 100%; height: 100%; overflow: hidden; background: hsl(var(--background));">
     <img src="${esc(imageUrl)}" alt="" style="position: absolute; inset: 0; width: 100%; height: 100%; object-fit: contain;" />
 </div>`;
 }

package/corpus/templates/slides/server/lib/chat-attachments.ts

@@ -119,8 +119,8 @@ export async function prepareSlidesChatAttachments(args: {
           "",
           "File handling rules:",
           "- If the request refers to the current or visible deck, call `view-screen` first to confirm the active deckId, then pass that deckId to import or slide-edit actions.",
-          '- PPTX files: call `import-pptx --filePath "<path>" --deckId <deckId>` when updating the visible deck, or omit deckId only when the user explicitly wants a new deck.',
-          '- PDF and DOCX files: call `import-file --filePath "<path>" --format auto --deckId <deckId>` and use the returned extracted text as source material before creating editable slides. For a visual PDF that the user wants preserved, beautified, or restyled from its original layout, pass `--importIntoDeck true` so each page is imported source-faithfully first; the source text is persisted in slide notes for later inspection.',
+          '- PPTX files: when the user wants the visible deck improved, call `import-pptx --filePath "<path>" --deckId <deckId>` first, then edit those imported slide IDs in place with update-slide. Do not rebuild the source deck with add-slide.',
+          '- PDF and DOCX files: call `import-file --filePath "<path>" --format auto --deckId <deckId>` and use the returned extracted text as source material before creating editable slides. For a visual PDF that the user wants preserved, beautified, or restyled from its original layout, pass `--importIntoDeck true` so each page is imported source-faithfully first; keep the full-page image and style around it, with source text persisted in slide notes for inspection.',
           '- Figma `.fig` files: call `import-file --filePath "<path>" --format fig` to start Builder design-system indexing. Do not create a local design system directly from the upload.',
           "- For deck-generation requests, start mutating promptly: create or update the first slide as soon as source material is extracted, then continue slide-by-slide with add-slide/update-slide.",
           '- Image files with an embeddable URL can be inserted directly into slide HTML as `<img src="...">` or used as visual references.',