@agent-native/core-corpus 0.214.0 → 0.216.0

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

@@ -0,0 +1,938 @@
+import {
+  callAction,
+  deleteClientAppState,
+} from "@agent-native/core/client/hooks";
+import type { PromptComposerSubmitOptions } from "@agent-native/toolkit/app/chat/composer/index";
+import { appStateKey, appStateKeyForBrowserTab } from "@shared/app-state-tabs";
+import { extractGoogleDocUrls } from "@shared/google-docs";
+import { nanoid } from "nanoid";
+import { flushSync } from "react-dom";
+
+import type { NewDeckReferenceSelection } from "@/components/editor/NewDeckReferenceStep";
+import type { UploadedFile } from "@/components/editor/PromptDialog";
+import type { Deck, DeckPersistenceResult } from "@/context/DeckContext";
+import { createDeckAgentMessage } from "@/lib/agent-visible-message";
+import { canAddInlineImageToPayload } from "@/lib/image-drop-to-agent";
+import {
+  importUploadedDeckIntoDeck,
+  validateUploadedDeckImport,
+  type ImportedSourceDeck,
+} from "@/lib/import-uploaded-deck";
+import {
+  hydrateReferenceDocuments,
+  referenceDocumentFormat,
+} from "@/lib/reference-document-hydration";
+import { TAB_ID } from "@/lib/tab-id";
+
+export const WEBSITE_STYLE_REFERENCE_DIRECTIVE =
+  "When the user asks to use or match a website's styling or branding and provides a URL, call `import-from-url` for each URL before generating. Treat the returned design.md-style visual system as the source of truth for colors, typography, spacing, components, and imagery. If no URL is provided, ask for one instead of guessing the site's style from its name.";
+
+export const NO_UPLOADED_FILES_CONTEXT =
+  "No uploaded files are attached to this run. Use source text already present in the user message or supplied reference context. For a supplied URL, follow its dedicated import instructions. Never invent a local file path or call `import-file` for an unattached file. If the referenced content is not present or retrievable from a supplied reference, ask the user to upload the file or paste its contents.";
+
+export const BLANK_AND_FOLLOW_UP_SCOPE_INSTRUCTION =
+  'Scale the work to the request; this rule overrides the generation steps below. A blank or empty deck request needs no question, outline, progress run, retitle, or audit: add one empty slide with `add-slide` (layout "blank") and reply. These generation instructions govern only this generation and its guided-question answers; a later direct request in this thread, such as adding an empty slide, renaming, reordering, or deleting, is a targeted edit: make it with the one action it needs and reply.';
+
+export const SLIDE_COUNT_COMPLETION_INSTRUCTION =
+  "For a requested slide count, compare the realSlideCount returned by every add-slide result (slideCount only if realSlideCount is absent) with the persisted target; blank placeholder slides do not count. Once it matches, stop all slide writes and return a completion summary. If add-slide returns errorCode target_slide_count_reached, re-read get-deck once; if the target is already satisfied, stop without retrying and finish the response. Only add more slides if the user explicitly asks to extend the deck and targetSlideCountOverride is set to the new total of real slides.";
+
+interface DesignSystemGenerationContextResult {
+  agentContext?: string;
+}
+
+async function loadDesignSystemGenerationContext(
+  designSystemId?: string | null,
+): Promise<string> {
+  if (!designSystemId) return "";
+  try {
+    const result = (await callAction(
+      "get-design-system",
+      { id: designSystemId },
+      { method: "GET" },
+    )) as DesignSystemGenerationContextResult | undefined;
+    if (result?.agentContext?.trim()) {
+      return [
+        "",
+        result.agentContext.trim(),
+        "",
+        "The selected design system context above was hydrated before this agent run. Follow it directly; do not replace it with generic colors, fonts, spacing, imagery, or slide components.",
+      ].join("\n");
+    }
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "unknown loading error";
+    return [
+      "",
+      "## Selected Design System Context",
+      `The selected design system id "${designSystemId}" could not be loaded before generation: ${message}`,
+      "Before adding slides, call `get-design-system` for this id. If it still fails, stop and tell the user the selected design system is unavailable instead of improvising a generic style.",
+    ].join("\n");
+  }
+  return [
+    "",
+    "## Selected Design System Context",
+    `The selected design system id "${designSystemId}" returned no generation context.`,
+    "Call `get-design-system` for this id before adding slides. If it still has no usable tokens/docs, stop and ask the user to finish design-system indexing instead of improvising a generic style.",
+  ].join("\n");
+}
+
+interface ReferenceDeckContextResult {
+  agentContext?: string;
+  designSystemId?: string | null;
+  linkedDesignSystemStatus?: "available" | "unavailable" | "none";
+}
+
+interface LoadedReferenceDeckContext {
+  status: "none" | "loaded" | "unavailable";
+  agentContext: string;
+  designSystemId: string | null;
+}
+
+function getLinkedDesignSystemStatus(
+  result: ReferenceDeckContextResult,
+): "available" | "unavailable" | "none" | null {
+  const { designSystemId, linkedDesignSystemStatus } = result;
+  const normalizedId =
+    typeof designSystemId === "string" && designSystemId.trim()
+      ? designSystemId.trim()
+      : null;
+
+  if (linkedDesignSystemStatus === "none" && designSystemId === null) {
+    return "none";
+  }
+  if (
+    (linkedDesignSystemStatus === "available" ||
+      linkedDesignSystemStatus === "unavailable") &&
+    normalizedId
+  ) {
+    return linkedDesignSystemStatus;
+  }
+  return null;
+}
+
+async function loadReferenceDeckGenerationContext(
+  referenceDeckId?: string | null,
+): Promise<LoadedReferenceDeckContext> {
+  if (!referenceDeckId) {
+    return { status: "none", agentContext: "", designSystemId: null };
+  }
+  try {
+    const result = (await callAction(
+      "get-deck-reference-context",
+      { id: referenceDeckId },
+      { method: "GET" },
+    )) as ReferenceDeckContextResult | undefined;
+    if (result?.agentContext?.trim()) {
+      const linkedDesignSystemStatus = getLinkedDesignSystemStatus(result);
+      if (linkedDesignSystemStatus !== null) {
+        const designSystemId =
+          typeof result.designSystemId === "string"
+            ? result.designSystemId.trim()
+            : null;
+        return {
+          status: "loaded",
+          agentContext: `\n${result.agentContext.trim()}`,
+          designSystemId:
+            linkedDesignSystemStatus === "available" ? designSystemId : null,
+        };
+      }
+      return {
+        status: "unavailable",
+        agentContext: [
+          "",
+          "## Reference Deck",
+          `The user picked deck "${referenceDeckId}" as a style reference, but the reference action returned incomplete linked-system status.`,
+          "Retry `get-deck-reference-context`; if it still fails, stop instead of generating with an assumed style.",
+        ].join("\n"),
+        designSystemId: null,
+      };
+    }
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "unknown loading error";
+    return {
+      status: "unavailable",
+      agentContext: [
+        "",
+        "## Reference Deck",
+        `The user picked deck "${referenceDeckId}" as a style reference, but it could not be loaded before generation: ${message}`,
+        "Before adding slides, call `get-deck-reference-context` for this id. If it still fails, tell the user the reference deck is unavailable instead of inventing a style.",
+      ].join("\n"),
+      designSystemId: null,
+    };
+  }
+  return {
+    status: "unavailable",
+    agentContext: [
+      "",
+      "## Reference Deck",
+      `The user picked deck "${referenceDeckId}" as a style reference, but it returned no usable context.`,
+      `Call \`get-deck --id ${referenceDeckId}\` before generating. If that deck is empty, tell the user instead of silently generating without a reference.`,
+    ].join("\n"),
+    designSystemId: null,
+  };
+}
+
+export function isSourceImprovementRequest(
+  prompt: string,
+  files: UploadedFile[],
+): boolean {
+  const hasSourceDeck = files.some((file) =>
+    /\.(pptx|pdf)$/i.test(file.originalName),
+  );
+  if (!hasSourceDeck) return false;
+
+  const normalized = prompt.toLowerCase();
+  const asksToImprove =
+    /\b(restyl\w*|redesign\w*|rebrand\w*|revamp\w*|rework\w*|moderni[sz]\w*|refresh\w*|polish\w*|improv\w*|updat\w*|revis\w*|edit\w*)\b/.test(
+      normalized,
+    ) ||
+    /\bmake\b[\s\S]{0,40}\b(better|modern|professional|polished|prett\w*)\b/.test(
+      normalized,
+    );
+  const asksToConvertSource =
+    /(?:\b(turn|convert|transform|make|build|create|generate)\b[^\n.!?]{0,50}\b(into|to)\b[^\n.!?]{0,30}\b(deck|presentation|slides?)\b|\b(create|build|make|generate)\b[^\n.!?]{0,80}\b(deck|presentation|slides?)\b[^\n.!?]{0,80}\bfrom\b)/.test(
+      normalized,
+    );
+  const explicitlyReferenceOnly =
+    /\b(reference material|reference only|as a reference|for reference)\b/.test(
+      normalized,
+    );
+  if (explicitlyReferenceOnly) return false;
+
+  const asksToPreserveSource =
+    asksToConvertSource &&
+    /\b(copy|slide[- ]for[- ]slide|preserv\w*|same order|before\s*\/?\s*after|placeholder\w*|out of order)\b/.test(
+      normalized,
+    );
+  return asksToImprove || asksToPreserveSource || asksToConvertSource;
+}
+
+export function describeUploadedFilesForAgent(
+  files: UploadedFile[],
+  deckId: string,
+  importedSourceDeck: ImportedSourceDeck | null = null,
+): string {
+  if (files.length === 0) {
+    return ["", NO_UPLOADED_FILES_CONTEXT].join("\n");
+  }
+  const hasDocumentReferences = files.some((file) =>
+    referenceDocumentFormat(file),
+  );
+  const fileList = files
+    .map(
+      (file) =>
+        `- ${file.originalName} (${file.type}, ${(file.size / 1024).toFixed(1)}KB) at path: ${file.path}${file.url ? `; embeddable URL: ${file.url}` : ""}`,
+    )
+    .join("\n");
+  return [
+    "",
+    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 attached ${files.length} file(s) as reference material for this new deck. Attachments are context for the agent by default; do not import or append their slides to target deck ${deckId} merely because they were attached.`,
+    fileList,
+    "",
+    "File handling rules:",
+    importedSourceDeck
+      ? "- The imported source deck is canonical. Preserve its slide count, order, IDs, factual copy, notes, imagery, charts, tables, diagrams, and freeform objects while improving styling. For a deck-wide restyle, read the full deck once with get-deck compact=false; it returns sourceImport.slideIds, each slide's HTML and contentHash, and the linked design context. Call get-design-system once for full tokens, assets, and instructions, then use one patch-deck call with requireAllSourceSlides=true and the matching baseContentHash on every patch-slide. Verify once with get-deck using slideIds=sourceImport.slideIds and compact=false. Use update-slide only for a targeted one-slide edit. Do not rebuild it with add-slide."
+      : hasDocumentReferences
+        ? "- PDF, PPTX, and DOCX files were already read before this run. Their content and measured visual language are in the `Attached Reference Documents` section below, or in the reference deck they were imported into. Do not call `import-file` for them again unless the `Attached Reference Documents` section says a file was omitted for space, and never generate as if a reference were missing."
+        : "- No PDF, PPTX, or DOCX reference is attached to this run; do not invent one.",
+    importedSourceDeck
+      ? "- For a PDF source, keep the layers the import produced — positioned text boxes and images, or the page image where a page carried nothing else — and add restrained design-system chrome around them without obscuring source content. Never replace an imported slide with a retyped approximation of its text."
+      : "- Do not pass `importIntoDeck: true` for an attached file unless the user explicitly asks to import or preserve the source pages in the current deck. An attached reference is not an instruction to replace or seed the deck.",
+    "- 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 are mandatory assets: if the user specified where to use one (e.g. "on the first and last slide"), embed it there with `<img src="...">` exactly as requested. Do not omit a requested image and continue silently — if it truly cannot be placed, say why in your final chat response.',
+    '- Image files without a URL are sent as inline visual/reference assets for this run when available; on a follow-up, call `import-file --filePath "<path>" --format image` to reopen a persisted private raster before visual editing, and call `upload-image` if a durable embeddable URL is needed.',
+    "- When converting an attached image into a deck, inspect the complete visual source before adding slides. If it contains distinct source frames, represent them in order; do not repeatedly place the source image itself, stop after an arbitrary subset, or infer a fixed frame count.",
+    importedSourceDeck
+      ? "- Before your final response, verify the same source slide IDs and count with get-deck after the restyle. If source fidelity is partial or images were skipped, report the exact warning instead of claiming success."
+      : "- Before your final response, verify every uploaded file above was either used as reference or placed as explicitly requested. If any file's content or requested placement is missing from the deck, say so explicitly instead of reporting success.",
+  ].join("\n");
+}
+
+export interface UploadedImageAgentOptions {
+  referenceImagePaths?: string[];
+  images?: string[];
+}
+
+export function getUploadedImageAgentOptions(
+  files: UploadedFile[],
+): UploadedImageAgentOptions {
+  const referenceImagePaths: string[] = [];
+  const images: string[] = [];
+
+  for (const file of files) {
+    if (!file.type.startsWith("image/")) continue;
+    if (file.url) referenceImagePaths.push(file.url);
+    if (file.dataUrl && canAddInlineImageToPayload(images, file.dataUrl)) {
+      images.push(file.dataUrl);
+    }
+  }
+
+  return {
+    ...(referenceImagePaths.length > 0 ? { referenceImagePaths } : {}),
+    ...(images.length > 0 ? { images } : {}),
+  };
+}
+
+function mergeUploadedFilesForRetry(
+  savedFiles: UploadedFile[],
+  newFiles: UploadedFile[],
+): UploadedFile[] {
+  const seen = new Set<string>();
+  return [...savedFiles, ...newFiles].filter((file) => {
+    const key = file.path || file.url || file.filename;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+type Navigate = (
+  to: string,
+  options?: { flushSync?: boolean; replace?: boolean },
+) => void;
+
+type CreateDeck = (
+  title?: string,
+  options?: {
+    noDefaultSlides?: boolean;
+    designSystemId?: string | null;
+    creation?: { method: "generated" };
+  },
+) => Deck;
+
+type SubmitAgent = (
+  message: string,
+  context: string,
+  options: {
+    newTab: boolean;
+    reuseEmptyTab: boolean;
+    openSidebar: boolean;
+    referenceImagePaths?: string[];
+    images?: string[];
+    attachments?: ReadonlyArray<unknown>;
+    model?: PromptComposerSubmitOptions["model"];
+    engine?: PromptComposerSubmitOptions["engine"];
+    effort?: PromptComposerSubmitOptions["effort"];
+    submitMessageId: string;
+    generationAttemptId: string;
+    generationOutputId: string;
+  },
+) => Promise<{ delivered: boolean; reason?: string }>;
+
+type PromptModelSelection = Pick<
+  PromptComposerSubmitOptions,
+  "model" | "engine" | "effort"
+>;
+
+export interface StartDeckGenerationOptions {
+  session: unknown;
+  prompt: string;
+  files: UploadedFile[];
+  retryFiles?: UploadedFile[];
+  attachments?: ReadonlyArray<unknown>;
+  modelSelection?: PromptModelSelection;
+  referenceSelection?: NewDeckReferenceSelection;
+  selectedDesignSystemId?: string | null;
+  selectedReferenceDeckId?: string | null;
+  designSystems: Array<{ id: string; title: string }>;
+  createDeck: CreateDeck;
+  ensureDeckPersisted: (id: string) => Promise<DeckPersistenceResult>;
+  deleteDeck: (id: string) => void;
+  navigate: Navigate;
+  agentSubmit: SubmitAgent;
+  onPromptClosed: () => void;
+  onUnauthenticated: (prompt: string, hadFiles: boolean) => void;
+  onPersistenceFailure: (
+    prompt: string,
+    files: UploadedFile[],
+    failure: DeckPersistenceResult,
+  ) => void;
+  onSetupFailure?: (
+    prompt: string,
+    files: UploadedFile[],
+    failure: unknown,
+  ) => void;
+}
+
+export interface DeckGenerationContext {
+  originalPrompt: string;
+  additionalContext?: string;
+  files: Array<{
+    path: string;
+    url?: string;
+    originalName: string;
+    type: string;
+  }>;
+  designSystemId: string | null;
+  referenceDeckId: string | null;
+  referenceSource?: NewDeckReferenceSelection["referenceSource"];
+  composerContext?: NewDeckReferenceSelection["composerContext"];
+  contextItems?: NewDeckReferenceSelection["contextItems"];
+  mode: "new" | "source-preserving";
+  targetSlideCount?: number;
+  generationAttemptId?: string;
+  generationStartedAt?: number;
+}
+
+export async function persistDeckGenerationContext(
+  deckId: string,
+  context: DeckGenerationContext,
+): Promise<void> {
+  await callAction("patch-deck", {
+    deckId,
+    operations: [
+      {
+        op: "patch-deck-fields",
+        fields: {
+          generationContext: context as unknown as Record<string, unknown>,
+        },
+      },
+    ],
+  });
+}
+
+const NUMBER_WORDS =
+  "one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty".split(
+    " ",
+  );
+// Only one..twenty are counts; the larger words are matched so they can veto.
+const NUMBER = `${NUMBER_WORDS.join("|")}|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|dozen|couple|few|several|twice|double|triple|half|pair`;
+const CORE = "deck|presentation|pitch|slideshow|keynote|talk|powerpoint|ppt";
+const DECK = `${CORE}|summary|overview|explainer|proposal|report|briefing|update|demo|guide|tutorial|training|workshop|course|lesson|intro|introduction|plan|roadmap|strategy|recap|template|walkthrough|review|story|infographic|carousel|whitepaper|study|handout|primer|brief`;
+const BOUNDS =
+  "at most|at least|up to|than|under|over|fewer|less|more|min|max|minimum|maximum|most|least|tops|limit|cap|ceiling|budget|around|approximately|roughly|nearly|almost|circa|top|first|last|next|another|additional|as many|as few|minus|excluded";
+// A revision anywhere in the prompt withdraws the count.
+const REVISION =
+  "actually|instead|scratch that|on second thought|never mind|correction|change (?:it )?to|cut (?:it )?(?:down )?to|let's say|let’s say|works better|is better|too long|too short|disagree|cancel|disregard|update";
+const DRIFT = "maybe|perhaps|bump|raise|increase|reduce|trim|shrink|lower";
+// Words that make a count provisional, flexible, or additive.
+const SOFT =
+  "flexible|suggestion|guideline|judgment|exceed|separate|appendix|excluding|not counting|not including|besides|beyond|bonus|extra|in addition|on top|feel free|add more|more if|as needed|as necessary|if needed|if necessary|count|length|longer|shorter|then|followed|plus|later|initially|for now|starting|start|begin|now|extend|expand|revisit|iterate|revise|after|optional|stretch|backups?|hidden|if|unless|ideally|preferably|approximate|ballpark|estimate|guidelines|suggestions|give or take|aim|might|rough|tbd|open to|bigger|go over|unresolved";
+// "N slides", "N-slide", "N more slides". Every separator is a single bounded
+// run: a flood of whitespace has nothing to backtrack over.
+const MENTION = new RegExp(
+  `\\b(\\d+|${NUMBER})(?:[ –-]{1,3}([a-z]+))?[ –-]{0,3}slide(s?)\\b`,
+  "gi",
+);
+const OTHER_NUMBER = new RegExp(`\\b(?:\\d{1,2}|${NUMBER})\\b`, "i");
+// "Slide 3" and a "1." list marker name a slide inside the deck; only a number
+// past the count contradicts it.
+const SLIDE_REF =
+  /\bslides? (\d{1,2})(?: ?[-–] ?(\d{1,2}))?\b|\n ?(?:[-*•] )?(\d{1,2})[.)] /gi;
+const VERB =
+  /\b(?:create|make|build|generate|produce|draft|design|write|prepare|put together|crie|want|need|give|compose|craft|assemble|develop)\b/i;
+// An imperative that opens its own sentence or line is a separate ask; two of
+// them mean the count may size something other than the deck.
+const ASK_OPENER =
+  /^(?:(?:\d{1,2}[.)]|[-*•>]|please|also|then|now|and)\s+)*(?:create|make|build|generate|produce|draft|design|write|prepare|put together|crie|compose|craft|assemble|develop)\b/i;
+// A question, a hypothetical, someone else's or a cancelled task, a quoted UI
+// label, or a label/product number ("Windows 11", "Day 2") is not a deck-size ask.
+const FRAME =
+  "how|why|what|suppose|imagine|hypothetically|cannot|unable|impossible|cancel|ignore|disregard|forget|scrap|drop|skip|remind|ask|tell|schedule|probably|likely|optionally|guess|limited|capped|restricted|confined|held|kept|close|comparable|equivalent|related|relative|compared|according|akin|proportional|alternatively|option|worst|earlier|asked|wrote|said|told|day|week|phase|chapter|module|lesson|grade|round|level|stage|tier|step|part|section|version|release|season|episode|unit|page|figure|item|track|pod|call|called|named|titled|title|rename|label|button|chip";
+// Before the count: negation, a reference to another deck, a bound or a hedge,
+// or a frame that scopes the request to part of the deck ("For the intro,").
+const BEFORE = new RegExp(
+  `\\b(?:\\w+n['’]t|do not|never|avoid|except|but|not|like|similar|based|modell?ed|style of|better|shorter|half|my|our|your|their|his|her|its|this|that|these|those|existing|attached|current|source|previous|typical|competitor|per|each|every|apiece|keep|stick|restrict|confine|cut|within|try|aim|ideally|preferably|hopefully|possibly|should|whether|might|may|usually|normally|typically|often|always|generally|sometimes|yesterday|ago|already|tried|had|did|was|were|refuse|hate|stop|quit|${FRAME}|${BOUNDS}|${REVISION}|${DRIFT}|${SOFT})\\b|~|(?<!\\blet)['’]s\\b|^(?:for|in|on|under|at|during|across|inside|throughout|regarding|as|when|once|while|until|before|since|because|given)\\b`,
+  "i",
+);
+const REVISED = new RegExp(`\\b(?:${REVISION}|make (?:that|it))\\b`, "i");
+// Words in the request's own paragraph that bound or extend the count: a bound
+// or hedge word, "add a closing slide", or a sentence that continues the
+// request ("And a Q&A.").
+const INSTRUCTION_WORDS = new RegExp(
+  `\\b(?:${REVISION}|${DRIFT}|${BOUNDS}|${SOFT})\\b|\\badd\\b[^.!?\\n]{0,30}\\bslides?\\b|[.!?\\n] ?(?:and|also|with|along|together|as well|aside|apart|except|without|other than|bar)\\b`,
+  "i",
+);
+const AFTER = new RegExp(
+  `\\b(?:${REVISION}|${DRIFT}|${BOUNDS}|${SOFT}|or|though|but|rather|and|with|rest|remaining|others|per|each|every|long|total|minutes|hours|pages|words|depending|needed|necessary|possible|preferably|ideally)\\b|-ish|~`,
+  "i",
+);
+// "Create 10 slides": the count follows the verb directly.
+const DIRECT =
+  /^(?: (?:me|us|it|a|an|exactly|precisely|just|only|some|new|short|quick|brief)){0,3} $/i;
+// "Create a deck about X with 10 slides": a deck, a topic, then a connector.
+const DECK_OBJECT = new RegExp(`^ (?:\\S+ ){0,2}(?:(?:${DECK})\\b ?)+`, "i");
+// "of" only reaches the count from a deck: "a summary of 10 slides" is about
+// slides that already exist.
+const CONNECTOR =
+  /(?: (?:with|in|to)|\b(?:deck|presentation|pitch|slideshow|keynote|powerpoint|ppt) (?:of|de))(?: (?:exactly|precisely|just|only|a total of|an?))* $/i;
+// A document named after the deck ("a deck from a PDF with 40 slides") may be
+// the one that has the slides.
+const DOCUMENT = new RegExp(
+  `\\b(?:${DECK}|docs?|document|pdf|file|notes|article|paper|book|site|website|page|spreadsheet|sheet|transcript|email|thread|video|recording)\\b`,
+  "i",
+);
+const SOURCE_WORDS =
+  /\b(?:from|out|using|based|into|via|per|following|matching|mirroring|copying|reusing|resembling)\b/i;
+const CLEAN_TAIL = /^[ ,;:).!?]*(?:please)?[ ,;:).!?]*$/i;
+// The app's own pt-BR chip: "Crie um pitch de 10 slides a partir deste doc".
+const SOURCE_TAIL =
+  /^ (?:from|a partir) (?:this|these|deste|desta|este|esta) (?:doc|document|file|pdf|report|notes)$/i;
+// "a 10-slide deck": up to two modifiers, then the noun, which must end the
+// phrase: "a 10-slide deck review" reviews a deck. A preposition or a
+// conjunction is never a modifier, before the count or after it.
+const NOT_MODIFIER =
+  "the|for|about|on|of|from|with|in|to|into|at|by|as|that|who|which|and|or|so|if|when|where|plus|vs|no";
+const PHRASE_END =
+  "(?= (?:for|about|on|of|from|to|in|at|by|that|which|who|where|using|based|aimed|designed|built|focused|targeted)\\b| \\w+ing\\b|[,;:!?()]|$)";
+const COMPOUND = new RegExp(
+  `^(?: (?!(?:${NOT_MODIFIER}|${CORE})\\b)[^\\s,;:!?()]+){0,2} (?:${DECK})(?: (?:${CORE}))*\\b${PHRASE_END}`,
+  "i",
+);
+const COMPOUND_WINDOW = new RegExp(
+  `^(?: (?!(?:${NOT_MODIFIER})\\b)[\\w'’&-]+){0,3} $`,
+  "i",
+);
+
+// Only a short prompt is read at all: past a few sentences the ask is wrapped
+// in context, caveats, pasted source or later revisions that no word list
+// reads reliably, and a long brief is where the wrong counts came from.
+const MAX_REQUEST_CHARS = 500;
+// "a 10-slide deck": the word before the count is a plain lowercase word, not a
+// label or product ("Windows 11 slide", "Day 2 slide", "iPhone 16 slide").
+const PLAIN_LAST_WORD = /(?:^| )[a-z]+(?:['’-][a-z]+)* $|^ $/;
+
+function numberValue(token: string): number {
+  const word = token.toLowerCase();
+  if (/^\d/.test(word)) return /^[1-9]\d?$/.test(word) ? Number(word) : 0;
+  return NUMBER_WORDS.indexOf(word) + 1;
+}
+
+// The result is persisted as the deck's enforced slide target: a wrong one ends
+// a healthy run, while no target only skips the completion gate. So only the
+// opening sentence can size the deck, and only as one unhedged "create ... N
+// slides" ask. Widen what it rejects by adding words to the lists above, not
+// branches here.
+export function requestedSlideCount(prompt: string): number | undefined {
+  if (prompt.length > MAX_REQUEST_CHARS * 2) return undefined;
+  const text = (/[a-z]/.test(prompt) ? prompt : prompt.toLowerCase())
+    // Soft hyphens and zero-width characters from pasted PDFs split words.
+    .replace(/[\u00ad\u200b-\u200d\ufeff]/g, "")
+    .replace(/[^\S\n]+/g, " ")
+    .trim()
+    .replace(/^(?:#{1,6}|[-*•>]|\d{1,2}[.)]) /, "")
+    // "on one slide" places content; it neither sizes the deck nor clashes.
+    .replace(/ ?\b(?:on|in|onto|to|per|each) (?:1|one) slide\b/gi, "");
+  if (text.length > MAX_REQUEST_CHARS) return undefined;
+  if (
+    text.split(/[.!?\n]+/).filter((part) => ASK_OPENER.test(part.trim()))
+      .length > 1
+  ) {
+    return undefined;
+  }
+  const mentions = [...text.matchAll(MENTION)];
+  if (mentions.length !== 1) return undefined;
+  const [m] = mentions;
+  const value = numberValue(m[1]);
+  const end = text.search(/[.!?](?=[ \n]|$)|\n/);
+  const sentence = end === -1 ? text : text.slice(0, end);
+  const verb = VERB.exec(sentence);
+  const countEnd = m.index + m[0].length;
+  if (
+    m[2] ||
+    value === 0 ||
+    sentence.length > 600 ||
+    countEnd > sentence.length ||
+    !verb ||
+    verb.index + verb[0].length > m.index
+  ) {
+    return undefined;
+  }
+  const before = sentence.slice(0, m.index);
+  const window = before.slice(verb.index + verb[0].length);
+  const rest = sentence.slice(countEnd);
+  const later = text
+    .slice(countEnd)
+    .replace(SLIDE_REF, (_, a, b, c) =>
+      Math.max(Number(a ?? 0), Number(b ?? 0), Number(c ?? 0)) <= value
+        ? " "
+        : " 99 ",
+    );
+  if (
+    window.trim().split(" ").length > 8 ||
+    OTHER_NUMBER.test(before) ||
+    SOURCE_WORDS.test(window) ||
+    BEFORE.test(before) ||
+    REVISED.test(later) ||
+    INSTRUCTION_WORDS.test(later) ||
+    OTHER_NUMBER.test(later)
+  ) {
+    return undefined;
+  }
+  const object = DECK_OBJECT.exec(window);
+  const sizesDeck =
+    m[3] !== ""
+      ? (DIRECT.test(window) ||
+          (object !== null &&
+            CONNECTOR.test(window) &&
+            !DOCUMENT.test(window.slice(object[0].length)))) &&
+        (CLEAN_TAIL.test(rest) || SOURCE_TAIL.test(rest))
+      : COMPOUND.test(rest) &&
+        COMPOUND_WINDOW.test(window) &&
+        PLAIN_LAST_WORD.test(window) &&
+        !AFTER.test(rest);
+  return sizesDeck ? value : undefined;
+}
+
+export async function startDeckGeneration({
+  session,
+  prompt,
+  files,
+  retryFiles = [],
+  attachments,
+  modelSelection,
+  referenceSelection = {},
+  selectedDesignSystemId,
+  selectedReferenceDeckId,
+  designSystems,
+  createDeck,
+  ensureDeckPersisted,
+  deleteDeck,
+  navigate,
+  agentSubmit,
+  onPromptClosed,
+  onUnauthenticated,
+  onPersistenceFailure,
+  onSetupFailure,
+}: StartDeckGenerationOptions): Promise<
+  "started" | "failed" | "unauthenticated"
+> {
+  if (!session) {
+    onUnauthenticated(prompt, files.length > 0);
+    return "unauthenticated";
+  }
+  const generationAttemptId = nanoid();
+  const generationStartedAt = Date.now();
+
+  const filesForGeneration = mergeUploadedFilesForRetry(retryFiles, files);
+  const designSystemId =
+    referenceSelection.designSystemId !== undefined
+      ? referenceSelection.designSystemId
+      : selectedDesignSystemId && selectedDesignSystemId !== "none"
+        ? selectedDesignSystemId
+        : null;
+  const referenceDeckId =
+    referenceSelection.referenceDeckId !== undefined
+      ? referenceSelection.referenceDeckId
+      : selectedReferenceDeckId && selectedReferenceDeckId !== "none"
+        ? selectedReferenceDeckId
+        : null;
+  const referenceFilePaths = new Set(
+    referenceSelection.referenceFilePaths ?? [],
+  );
+  const filesForSourceImprovement = filesForGeneration.filter(
+    (file) => !referenceFilePaths.has(file.path),
+  );
+  const sourceImprovementRequest = isSourceImprovementRequest(
+    prompt,
+    filesForSourceImprovement,
+  );
+  let sourceDeckPaths: string[] = [];
+  if (sourceImprovementRequest) {
+    try {
+      sourceDeckPaths = validateUploadedDeckImport(
+        filesForSourceImprovement,
+      ).map((file) => file.path);
+    } catch (error) {
+      onSetupFailure?.(prompt, filesForGeneration, error);
+      return "failed";
+    }
+  }
+
+  let referenceHydration: Awaited<ReturnType<typeof hydrateReferenceDocuments>>;
+  try {
+    referenceHydration = await hydrateReferenceDocuments(filesForGeneration, {
+      excludePaths: [
+        ...(referenceSelection.importedReferenceFilePath
+          ? [referenceSelection.importedReferenceFilePath]
+          : []),
+        ...sourceDeckPaths,
+      ],
+    });
+  } catch (error) {
+    onSetupFailure?.(prompt, filesForGeneration, error);
+    return "failed";
+  }
+  if (referenceHydration.status === "unreadable") {
+    onSetupFailure?.(
+      prompt,
+      filesForGeneration,
+      new Error(referenceHydration.message),
+    );
+    return "failed";
+  }
+  const referenceDocumentContext =
+    referenceHydration.status === "hydrated" ? referenceHydration.context : "";
+  const hasHydratedReferenceDesign =
+    referenceHydration.status === "hydrated" &&
+    referenceHydration.measuredDesignCount > 0;
+  const selectedDesignSystem = designSystemId
+    ? designSystems.find((designSystem) => designSystem.id === designSystemId)
+    : undefined;
+
+  let deck: Deck | undefined;
+  flushSync(() => {
+    deck = createDeck(undefined, {
+      noDefaultSlides: true,
+      designSystemId,
+      creation: { method: "generated" },
+    });
+  });
+  if (!deck) return "failed";
+  const deckId = deck.id;
+
+  const persisted = await ensureDeckPersisted(deck.id);
+  if (!persisted.persisted) {
+    onPersistenceFailure(prompt, filesForGeneration, persisted);
+    deleteDeck(deckId);
+    return "failed";
+  }
+
+  let importedSourceDeck: ImportedSourceDeck | null = null;
+  let sourceImportMayHaveWrittenSlides = false;
+  if (sourceImprovementRequest) {
+    try {
+      importedSourceDeck = await importUploadedDeckIntoDeck(
+        filesForSourceImprovement,
+        deckId,
+        {
+          onImportStarted: () => {
+            sourceImportMayHaveWrittenSlides = true;
+          },
+          onImportCleanupSafe: () => {
+            sourceImportMayHaveWrittenSlides = false;
+          },
+        },
+      );
+    } catch (error) {
+      if (!sourceImportMayHaveWrittenSlides) deleteDeck(deckId);
+      onSetupFailure?.(prompt, filesForGeneration, error);
+      return "failed";
+    }
+  }
+
+  const trimmedPrompt = prompt.trim();
+  const hasImportedGoogleDocContext = trimmedPrompt.includes("<google-doc ");
+  const googleDocUrls = hasImportedGoogleDocContext
+    ? []
+    : extractGoogleDocUrls(trimmedPrompt);
+  const fileContext = describeUploadedFilesForAgent(
+    filesForGeneration,
+    deckId,
+    importedSourceDeck,
+  );
+  const googleDocContext =
+    googleDocUrls.length > 0
+      ? [
+          "",
+          "The request includes Google Docs URL(s):",
+          ...googleDocUrls.map((url) => `- ${url}`),
+          "Before adding slides, call `import-google-doc` for each URL and use the returned text as source material.",
+          "If the action cannot read a private document, tell the user the exact sharing step from the action error instead of generating from the URL alone.",
+        ].join("\n")
+      : "";
+  const [loadedReferenceDeckContext, hydratedDesignSystemContext] =
+    await Promise.all([
+      loadReferenceDeckGenerationContext(referenceDeckId),
+      loadDesignSystemGenerationContext(designSystemId),
+    ]);
+  const referenceDeckContext = loadedReferenceDeckContext.agentContext;
+  const referenceDeckStatus = loadedReferenceDeckContext.status;
+  const referenceDeckDesignSystemId = loadedReferenceDeckContext.designSystemId;
+  const designSystemContext = designSystemId
+    ? [
+        "",
+        "Design system selection:",
+        `- Use "${selectedDesignSystem?.title ?? designSystemId}" (id: ${designSystemId}).`,
+        "- The deck has already been linked to this design system.",
+        "- Use the hydrated design system context below for colors, typography, spacing, imagery, and slide defaults.",
+        hydratedDesignSystemContext,
+        "- Do not choose or apply a different design system.",
+      ].join("\n")
+    : [
+        "",
+        "Design system selection:",
+        "- No design system was selected in the picker.",
+        ...(referenceDeckId
+          ? referenceDeckStatus === "unavailable"
+            ? [
+                "- The selected reference deck could not be read. Retry `get-deck-reference-context`; if it still fails, stop and report that the reference is unavailable. Do not assume it has no linked system or use measured styling as a fallback.",
+              ]
+            : [
+                "- Use the reference deck's readable linked system if available; otherwise use its measured styling according to the visual-style precedence below. Do not call `get-workspace-defaults` or apply a workspace default.",
+              ]
+          : hasHydratedReferenceDesign
+            ? [
+                "- Use the attached reference's measured styling according to the visual-style precedence below. Do not call `get-workspace-defaults` or apply a workspace default.",
+              ]
+            : [
+                "- 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, establish one deliberate deck-level visual contract before the first slide: choose a background family, readable text and surface roles, one accent, a type pairing, spacing, radius, and image treatment that fit the subject. Record those choices as semantic --deck-* values on every fmd-slide wrapper and reuse them exactly; never alternate light and dark canvases, swap fonts, or invent a new palette per slide.",
+              ]),
+      ].join("\n");
+  const visualStylePrecedence = designSystemId
+    ? [
+        "## Visual style precedence",
+        `The design system explicitly selected for this new deck (id: ${designSystemId}) controls its tokens and slide defaults, overriding reference-deck linked systems and measured reference styling. Reference samples guide composition and markup only.`,
+      ].join("\n")
+    : referenceDeckId
+      ? [
+          "## Visual style precedence",
+          referenceDeckStatus === "unavailable"
+            ? "The selected reference deck could not be read, so its linked-system status and measured visual language are unknown. Retry get-deck-reference-context; if it still fails, stop instead of generating with an assumed style."
+            : referenceDeckDesignSystemId
+              ? "No separate system was selected for this new deck. The reference deck's readable linked design system controls tokens and slide defaults; use measured styling only where it does not conflict with that system. Reference samples guide composition and markup."
+              : "No target or readable linked design system was selected. Because the reference deck was read successfully, use its measured visual language for tokens and slide defaults; its samples guide composition and markup.",
+          "Do not call `get-workspace-defaults` or apply a workspace default.",
+        ].join("\n")
+      : hasHydratedReferenceDesign
+        ? [
+            "## Visual style precedence",
+            "No design system was selected. Use the attached reference's measured visual language for tokens and slide defaults.",
+          ].join("\n")
+        : [
+            "## Visual style precedence",
+            "When no reference deck or hydrated design system is available, choose a subject-appropriate editorial direction and lock it before authoring: one canvas/background family, text and surface roles, type pairing, spacing scale, radius, and accent treatment. Express the contract with semantic --deck-* values on every fmd-slide wrapper.",
+          ].join("\n");
+  const referenceSource = referenceSelection.referenceSource;
+  const referenceSourceContext = referenceSource
+    ? [
+        "",
+        "Additional reference source selected in the reference step:",
+        `- ${referenceSource.kind}: ${referenceSource.value}`,
+        referenceSource.kind === "google-docs"
+          ? "Call `import-google-doc` before generating and use the returned text as source material."
+          : referenceSource.kind === "website"
+            ? "Call `import-from-url` before generating and use the returned page context as a reference."
+            : "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 the full deck once with get-deck compact=false to get sourceImport.slideIds, every slide's HTML and contentHash, and the linked design context; call get-design-system once for its full tokens, assets, and instructions. Make the deck-wide restyle in one patch-deck call using requireAllSourceSlides=true, with each patch-slide's matching contentHash as baseContentHash. Do not split a full-deck restyle into arbitrary batches or fall back to one-by-one update-slide calls; use update-slide only for a targeted one-slide edit. Keep every original image source and enough original factual copy for each slide; for PDF slides, use restrained design-system chrome around the page without obscuring it.",
+        "- For this restyle, keep the source slide structure and do not replace source images with generic cards. If the user explicitly asks to add, delete, or reorder slides, use the corresponding operation normally; it clears source-import provenance, so verify the edited slide count and order instead of waiting for sourceCoverage.",
+        "- After a source-preserving patch that leaves sourceImport present, verify once with get-deck using slideIds=sourceImport.slideIds and compact=false. Confirm the full source reflects the request and sourceCoverage.complete is true with expectedSlideIds and actualSlideIds matching in order. If structural operations cleared sourceImport, verify the resulting slide count and order instead and do not require sourceCoverage.complete. Do not report an initial or partial pass, and do not leave any source slides for a later run.",
+        "- 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 restyle. Finish every source slide in this run; if the user explicitly requests structural changes, use the normal slide operations and verify the resulting deck instead of treating source coverage as a limit.",
+        "While sourceImport is present, the ordered source manifest and its full slide count are hard completion gates: do not declare success, switch to unrelated content, or start a different deck brief until every source slide ID has been patched and get-deck compact=true reports sourceCoverage.complete=true. After structural edits clear sourceImport, verify the resulting slide count and order instead.",
+      ].join("\n")
+    : [
+        "This is a new deck. Keep it empty until generation begins; attached reference files must not seed it with imported slides.",
+        "Start a `manage-progress` run so progress appears in the app header. First make a compact outline and deck-level visual contract in working context, then add slides with `add-slide` one at a time so every generated slide preserves its per-slide Creative Context provenance.",
+        `After reading any requested or attached reference material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Never use the deck id, run id, file id, uploaded filename, or another opaque alphanumeric token as the title. Do not reuse a generic placeholder like "Untitled scene" when the content or reference context gives you a better title. 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. Vary composition and information hierarchy while keeping the visual contract fixed across the deck.",
+        "When the user requests speaker notes, write presenter-only text into each slide's `notes` field and keep it out of the React component source.",
+        `Add every generated slide ONE AT A TIME using the add-slide action with --deckId=${deckId}; pass one self-contained default-export React component in sourceTsx for each page and wait for each result. Assign each planned page a distinct stable slideId before the first write and reuse its ID with the same sourceTsx and notes after an unclear result. If a retry returns duplicate_slide_id, call get-deck with slideIds=[slideId] and compact=false; treat it as saved only when sourceTsx and notes match, otherwise stop and report the conflict. Never content-dedupe distinct pages. After the first slide, call get-slide-source for canonical TSX and get-deck with its slideId and compact=false for the derived preview; inspect the semantic --deck-* declarations, canvas, type, spacing, and composition, then reuse that visual contract while varying composition. Do not use patch-deck to append generated slides because add-slide records per-slide Creative Context provenance; use patch-deck for deck fields, existing-slide edits, ordering, or source-preserving work. Never issue parallel writes to the same deck.`,
+        "Treat each successful write and compact readback as confirmation to continue with the next planned slides.",
+      ].join("\n");
+  const context = [
+    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.",
+    BLANK_AND_FOLLOW_UP_SCOPE_INSTRUCTION,
+    googleDocContext,
+    fileContext,
+    referenceDocumentContext,
+    referenceDeckContext,
+    designSystemContext,
+    referenceSourceContext,
+    WEBSITE_STYLE_REFERENCE_DIRECTIVE,
+    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; 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.",
+    sourceModeInstructions,
+    SLIDE_COUNT_COMPLETION_INSTRUCTION,
+    "Add each generated slide through sequential add-slide calls, preserving the established deck contract and using a targeted get-deck read with slideId and compact=false after the first slide to verify it.",
+    "If no explicit count was given (including when the guided slide-count question was skipped), infer the count from the distinct topics/sections implied by the request — one slide per section plus a title and closing slide — and add slides for every section before considering the deck done. Do not stop at an arbitrary round number (e.g. 10) if sections remain uncovered.",
+    "The original brief and uploaded/reference handles are persisted on the deck as generationContext. When continuing this generation (guided-question answers, or a request to keep going or finish the deck), call get-deck first and treat that context as the canonical brief. Continue the original slide sequence from the current slide count; do not replace it with a fresh topic inferred only from the follow-up message. A targeted edit is not a continuation.",
+    "An explicit theme or brand instruction in the original brief overrides the background, palette, and styling of an uploaded/reference image or source page. Preserve source content and imagery, but do not copy a white wireframe background when the requested theme is dark.",
+    "Do not report completion until the persisted generationContext targetSlideCount is reached, or, when sourceCoverage is present for source-preserving mode, get-deck compact=true reports it complete for the ordered source manifest. If the current deck is short, finish the missing requested slides before adding unrelated content.",
+    "Every slide is rendered into a fixed 1920×1080 canvas. Keep all content within those bounds; 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 32px at native canvas size.",
+    visualStylePrecedence,
+    "Each generated slide must use one default-export React page component in sourceTsx. The bounded React Worker runs inside an opaque-origin sandbox and derives rendered HTML from SQL source. Import only React or the named @open-slide/core primitives; static design, meta, and transition exports are allowed. Steps/Step, useSlidePageNumber(), and useIsActivePage() provide static page context and reveal state. React effects and event handlers do not run, and module transition metadata does not animate between pages. Use inline style objects or static CSS strings in local const names containing style, css, or keyframe; CSS is sanitized and scoped. Tailwind utility classes have no stylesheet in the frame. Do not use arbitrary imports, browser globals, CSS imports, remote fonts, network URLs, or scripts. Use uploaded asset:// handles for images. A static Page[] module may be submitted to create-deck for bulk generation; it is split into ordered SQL slides, with an index-aligned static notes[] export copied to presenter notes. Read the create-deck skill for exact source, CSS, size, and runtime limits.",
+    "Do NOT use create-deck (the deck already exists). Do NOT call db-schema, the resources tool, or search-files.",
+  ].join("\n");
+
+  try {
+    await persistDeckGenerationContext(deckId, {
+      originalPrompt: trimmedPrompt,
+      files: filesForGeneration.map((file) => ({
+        path: file.path,
+        ...(file.url ? { url: file.url } : {}),
+        originalName: file.originalName,
+        type: file.type,
+      })),
+      designSystemId,
+      referenceDeckId,
+      ...(referenceSource ? { referenceSource } : {}),
+      mode: importedSourceDeck ? "source-preserving" : "new",
+      targetSlideCount:
+        importedSourceDeck?.slideCount ?? requestedSlideCount(trimmedPrompt),
+      generationAttemptId,
+      generationStartedAt,
+    });
+  } catch (error) {
+    deleteDeck(deckId);
+    onSetupFailure?.(prompt, filesForGeneration, error);
+    return "failed";
+  }
+
+  const generationSubmitMessageId = nanoid();
+  let submission: { delivered: boolean; reason?: string };
+  try {
+    submission = await agentSubmit(createDeckAgentMessage(prompt), context, {
+      newTab: true,
+      reuseEmptyTab: true,
+      openSidebar: true,
+      submitMessageId: generationSubmitMessageId,
+      generationAttemptId,
+      generationOutputId: deckId,
+      ...getUploadedImageAgentOptions(filesForGeneration),
+      attachments,
+      ...modelSelection,
+    });
+  } catch (error) {
+    if (!sourceImportMayHaveWrittenSlides) deleteDeck(deckId);
+    onSetupFailure?.(prompt, filesForGeneration, error);
+    return "failed";
+  }
+  if (!submission?.delivered) {
+    if (!sourceImportMayHaveWrittenSlides) deleteDeck(deckId);
+    const error = new Error("Agent chat submission was not delivered.");
+    Object.assign(error, {
+      reason: submission?.reason ?? "delivery_unconfirmed",
+    });
+    onSetupFailure?.(prompt, filesForGeneration, error);
+    return "failed";
+  }
+
+  onPromptClosed();
+
+  deleteClientAppState(
+    appStateKeyForBrowserTab("guided-questions", TAB_ID),
+  ).catch(() => {});
+  deleteClientAppState(appStateKey("guided-questions")).catch(() => {});
+
+  navigate(
+    `/deck/${deck.id}?generating=1&generation_attempt_id=${encodeURIComponent(generationAttemptId)}&generationSubmitId=${encodeURIComponent(generationSubmitMessageId)}`,
+    {
+      replace: true,
+      flushSync: true,
+    },
+  );
+  return "started";
+}