@graph8/sdk 0.362.0 → 0.373.0

package/blocks/campaigns/components/campaign-launch-step.tsx

@@ -2,31 +2,47 @@
 
 /**
  * CampaignLaunchStep: the last check before a campaign starts messaging real people. Shows what is missing
- * (audience, steps, a sender), warns when deliverability is poor, lets the person choose the sending
- * mailboxes, and launches behind a confirmation that states the recipient count.
+ * (audience, steps, written copy, a sender), warns when deliverability is poor or a chosen mailbox is still in
+ * its warm-up hold, lets the person write missing copy with AI, choose the sending mailboxes, and launches
+ * behind a confirmation that states the recipient count.
  *
  * SDK operations, in order:
- *   1. getCampaignFull         GET  /campaigns/{campaign_id}/full           (read; audience attached and its size, steps, is_launched)
- *   3. listMailboxes           GET  /mailboxes                              (read; active senders to choose from)
- *   4. getSafeToSend           GET  /deliverability/safe-to-send            (read; a warning, never a block)
- *   5. launchCampaign          POST /campaigns/{campaign_id}/launch  { sender_mailbox_ids }
- *                              (external, ConfirmSpendDialog with the recipient count)
+ *   1. getCampaignFull             GET  /campaigns/{campaign_id}/full     (read; audience and size, steps, documents, is_launched;
+ *                                                                         POLLED while copy is being written)
+ *   2. getCampaignGenerationStatus GET  /campaigns/{campaign_id}/status   (read; `generation_error` when document generation failed)
+ *   3. listMailboxes               GET  /mailboxes                        (read; active senders to choose from, `created_at` for the hold)
+ *   4. getSafeToSend               GET  /deliverability/safe-to-send      (read; a warning, never a block)
+ *   5. createCampaignDocument      POST /campaigns/{campaign_id}/documents
+ *                                  (external; only when no email copy document exists, part of "Write the email copy")
+ *      regenerateCampaignDocument  POST /campaigns/{campaign_id}/documents/{document_id}/regenerate
+ *                                  (billable, ConfirmSpendDialog; writes the email copy with AI)
+ *   6. launchCampaign              POST /campaigns/{campaign_id}/launch  { sender_mailbox_ids }
+ *                                  (external, ConfirmSpendDialog with the recipient count)
  *
- * Tiers: 5 begins REAL outreach and cannot be recalled. The result is kept in state, so the button is
+ * Copy: the launch is refused (400 "no completed copy documents") unless a document other than the sequence and
+ * step catalog is completed, so Launch stays disabled until one is. A campaign created without AI documents has
+ * none; "Write the email copy with AI" creates the email document (once: its id is kept, and an existing one is
+ * reused, so a retry never makes a second) and has AI write it.
+ *
+ * Tiers: 6 begins REAL outreach and cannot be recalled. The result is kept in state, so the button is
  * gone after a success and a double click cannot launch twice. After an error, do not blindly retry: a 502
  * `draft_created_activation_failed` or `activation_state_uncertain` means a sequence may exist; check the
- * campaign in the sequencer block first. `is_launched` from /full also refuses a second launch after a reload. Google and Microsoft mailboxes are connected in the graph8 app.
+ * campaign in the sequencer block first. `is_launched` from /full (true only for a live launch, not a failed
+ * attempt) also refuses a second launch after a reload. Google and Microsoft mailboxes are connected in the graph8 app.
  */
 
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { Button, Skeleton } from "@graph8/sdk/ui";
 import { ApiError } from "@/g8/components/api-error";
+import { FirstNotice } from "@/g8/components/paging-notices";
 import { ConfirmSpendDialog } from "@/g8/components/confirm-spend-dialog";
 import { useG8Mutation } from "@/g8/hooks/use-g8-mutation";
 import { useG8Query } from "@/g8/hooks/use-g8-query";
+import { useJobPoll } from "@/g8/hooks/use-job-poll";
 import { g8Get, g8Post } from "@/g8/lib/g8-client";
-import { GRAPH8_APP_MAILBOXES_URL } from "@/g8/mailboxes/lib/mailboxes-utils";
-import { audienceOf, listOf, objectOf, stepsOf } from "../lib/campaigns-utils";
+import { GRAPH8_APP_MAILBOXES_PATH } from "@/g8/mailboxes/lib/mailboxes-utils";
+import { CREDIT_ESTIMATES, EMAILS_DOCUMENT, WARMUP_HOLD_DAYS, audienceOf, copyStateOf, listOf, objectOf, stepsOf, text, warmupHoldUntil } from "../lib/campaigns-utils";
+import { brandUrl, useBrand } from "@/g8/hooks/use-brand";
 
 export interface CampaignLaunchStepProps {
   campaignId: string;
@@ -36,24 +52,46 @@ export interface CampaignLaunchStepProps {
   className?: string;
 }
 
-interface Mailbox { id: string | number; email?: string | null; connection_status?: string | null; is_archived?: boolean | null }
+interface Mailbox { id: string | number; email?: string | null; connection_status?: string | null; is_archived?: boolean | null; created_at?: string | null }
 
-function Check({ ok, children }: { ok: boolean | undefined; children: string }) {
+function Check({ ok, children, detail }: { ok: boolean | undefined; children: string; detail?: string }) {
   return (
-    <li className={ok ? "text-green-700" : "text-amber-800"}>
+    <li className={ok ? "text-positive-foreground" : "text-warning-foreground"}>
       <span aria-hidden>{ok ? "Ready: " : "Missing: "}</span>{children}
+      {!ok && detail ? <span className="block pl-4 text-xs text-muted-foreground">{detail}</span> : null}
     </li>
   );
 }
 
+const day = (d: Date) => d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric", timeZone: "UTC" });
+
+/** The mailboxes API has no paging: a full read is announced under the sender list. */
+const MAILBOX_LIMIT = 200;
+
 export function CampaignLaunchStep({ campaignId, audienceSize, onLaunched, className }: CampaignLaunchStepProps) {
+  const brand = useBrand();
   const campaign = useG8Query((signal) => g8Get(`/campaigns/${campaignId}/full`, undefined, { signal }), [campaignId]);
-  const mailboxes = useG8Query((signal) => g8Get("/mailboxes", { limit: 200 }, { signal }), []);
+  const generation = useG8Query((signal) => g8Get(`/campaigns/${campaignId}/status`, undefined, { signal }), [campaignId]);
+  const mailboxes = useG8Query((signal) => g8Get("/mailboxes", { limit: MAILBOX_LIMIT }, { signal }), []);
   const verdict = useG8Query((signal) => g8Get("/deliverability/safe-to-send", undefined, { signal }), []);
   const [chosen, setChosen] = useState<Set<string> | null>(null);
   const [confirm, setConfirm] = useState(false);
+  const [confirmCopy, setConfirmCopy] = useState(false);
+  const [emailsDocId, setEmailsDocId] = useState<string | null>(null);
   const [result, setResult] = useState<Record<string, unknown> | null>(null);
 
+  // Copy being written (by the create-time generator or by "Write the email copy"): re-read /full until it settles.
+  const copyPoll = useJobPoll((signal) => g8Get(`/campaigns/${campaignId}/full`, undefined, { signal }), {
+    enabled: false, isTerminal: (s) => !copyStateOf(s).generating, intervalMs: 3000, maxAttempts: 60,
+  });
+  const full = copyPoll.status ?? campaign.data;
+  const copy = copyStateOf(full);
+  const genError = text(objectOf(generation.data).generation_error);
+  // Auto-follow only once: after the poll gives up, "Still writing" asks the person to check back.
+  const shouldPoll = copy.generating && !genError && copyPoll.attempts === 0 && !copyPoll.polling;
+  useEffect(() => { if (shouldPoll) copyPoll.start(); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [shouldPoll]);
+
   const active = listOf<Mailbox>(mailboxes.data).filter((m) => m.connection_status === "active" && !m.is_archived);
   const senders = chosen ?? new Set(active.slice(0, 1).map((m) => String(m.id)));
   const launch = useG8Mutation(
@@ -63,54 +101,92 @@ export function CampaignLaunchStep({ campaignId, audienceSize, onLaunched, class
       onError: () => setConfirm(false),
     },
   );
+  const writeCopy = useG8Mutation(async () => {
+    let docId = emailsDocId ?? copy.emailsDocId;
+    if (!docId) {
+      const created = await g8Post(`/campaigns/${campaignId}/documents`, { ...EMAILS_DOCUMENT, content: "", status: "draft" });
+      docId = text(objectOf(created).id);
+      setEmailsDocId(docId); // stored at once: a failed regenerate is retried on this document, never a second one
+    }
+    return g8Post(`/campaigns/${campaignId}/documents/${docId}/regenerate`, {});
+  }, {
+    onSuccess: () => { setConfirmCopy(false); copyPoll.start(); },
+    onError: () => setConfirmCopy(false),
+  });
 
   const loading = [campaign, mailboxes].some((q) => q.loading && !q.data);
   const failedQuery = [campaign, mailboxes].find((q) => q.error);
   if (failedQuery) return <ApiError error={failedQuery.error} title="Could not check launch readiness" onRetry={() => { void campaign.refetch(); void mailboxes.refetch(); }} />;
   if (loading) return <Skeleton className="h-40 w-full" />;
 
-  const c = objectOf(campaign.data);
-  const audience = audienceOf(campaign.data);
+  const c = objectOf(full);
+  const audience = audienceOf(full);
   const hasAudience = audience.listId != null;
-  const hasSteps = stepsOf(campaign.data).length > 0;
+  const hasSteps = stepsOf(full).length > 0;
+  // An older API without `documents` cannot be checked here: the server still checks at launch.
+  const copyOk = !copy.known || copy.ready;
   const alreadyLaunched = c.is_launched === true;
   const recipients = audienceSize ?? audience.size;
   const v = objectOf(verdict.data);
   const unsafe = !verdict.error && (v.safe_to_send ?? v.safe) === false;
-  const ready = hasAudience && hasSteps && senders.size > 0 && !result && !alreadyLaunched;
+  const ready = hasAudience && hasSteps && copyOk && senders.size > 0 && !result && !alreadyLaunched;
+  // Once the follow-up poll gives up, the person may write the copy again rather than wait forever.
+  const writingCopy = writeCopy.loading || copyPoll.polling || (copy.generating && !genError && copyPoll.attempts === 0);
+  const held = active.filter((m) => senders.has(String(m.id))).map((m) => ({ m, until: warmupHoldUntil(m.created_at) })).filter((h) => h.until);
+  const copyDetail = writingCopy
+    ? "The copy is being written. This usually takes a minute or two."
+    : "The launch is refused until the campaign has written copy. Write it with AI below, or add it in Campaign assets.";
 
   if (result) {
     const channels = (result.channels_attached as Array<{ email?: string }> | undefined) ?? [];
     return (
-      <section aria-label="Launch result" className={`space-y-2 rounded-md border border-green-200 bg-green-50 p-4 ${className ?? ""}`}>
+      <section aria-label="Launch result" className={`space-y-2 rounded-md border border-positive-foreground/25 bg-positive p-4 ${className ?? ""}`}>
         <h3 className="font-medium">Campaign {String(result.status ?? "launched")}</h3>
         <p className="text-sm">{String(result.message ?? "")}</p>
         <p className="text-sm text-muted-foreground">
           Sequence {String(result.sequence_id ?? "")} with {String(result.steps_created ?? 0)} steps, sending from {channels.map((m) => m.email).join(", ") || "the chosen mailboxes"}.
         </p>
-        {Array.isArray(result.warnings) && result.warnings.length > 0 ? <ul className="list-disc pl-5 text-sm text-amber-900">{result.warnings.map((w) => <li key={String(w)}>{String(w)}</li>)}</ul> : null}
+        {Array.isArray(result.warnings) && result.warnings.length > 0 ? <ul className="list-disc pl-5 text-sm text-warning-foreground">{result.warnings.map((w) => <li key={String(w)}>{String(w)}</li>)}</ul> : null}
       </section>
     );
   }
   return (
     <section aria-label="Launch" className={`space-y-3 ${className ?? ""}`}>
       <h3 className="font-medium">Ready to launch {String(c.name ?? "")}</h3>
-      {alreadyLaunched ? <p role="status" className="rounded bg-green-50 p-2 text-sm text-green-900">This campaign has already been launched. Manage it in the sequencer.</p> : null}
+      {alreadyLaunched ? <p role="status" className="rounded bg-positive p-2 text-sm text-positive-foreground">This campaign has already been launched. Manage it in the sequencer.</p> : null}
       <ul className="space-y-1 text-sm">
         <Check ok={hasAudience}>An audience list is attached</Check>
         <Check ok={hasSteps}>The sequence has at least one step</Check>
+        {copy.known ? <Check ok={copy.ready} detail={copyDetail}>The campaign copy is written</Check> : null}
         <Check ok={senders.size > 0}>At least one active sending mailbox is selected</Check>
       </ul>
+      {genError && !copy.ready ? (
+        <p role="alert" className="rounded bg-error p-2 text-sm text-error-foreground">Writing the campaign documents failed: {genError}</p>
+      ) : null}
+      {copy.known && !copy.ready ? (
+        <div className="space-y-1">
+          {writeCopy.error ? <ApiError error={writeCopy.error} title="Could not write the copy" /> : null}
+          {copyPoll.done && !copyStateOf(copyPoll.status).ready && !writeCopy.loading ? <p role="status" className="text-sm text-warning-foreground">The copy did not finish. Try again, or write it in Campaign assets.</p> : null}
+          {!copyPoll.polling && !copyPoll.done && copyPoll.attempts > 0 ? <p role="status" className="text-sm text-warning-foreground">Still writing. Check back in a minute.</p> : null}
+          <Button variant="outline" loading={writeCopy.loading} disabled={writingCopy} onClick={() => setConfirmCopy(true)}>Write the email copy with AI</Button>
+        </div>
+      ) : null}
       {unsafe ? (
-        <p role="alert" className="rounded bg-amber-50 p-2 text-sm text-amber-900">
+        <p role="alert" className="rounded bg-warning p-2 text-sm text-warning-foreground">
           Deliverability warning: {typeof v.reason === "string" ? v.reason : "sending is not recommended right now."}
         </p>
       ) : null}
+      {held.length > 0 ? (
+        <div role="status" className="rounded bg-warning p-2 text-sm text-warning-foreground">
+          <p>New mailboxes send nothing for their first {WARMUP_HOLD_DAYS} days while they warm up. The campaign goes live, but no email goes out from:</p>
+          <ul className="list-disc pl-5">{held.map(({ m, until }) => <li key={m.id}>{m.email ?? `Mailbox ${m.id}`} until {day(until as Date)}</li>)}</ul>
+        </div>
+      ) : null}
       <fieldset className="space-y-1">
         <legend className="text-sm font-medium">Send from</legend>
         {active.length === 0 ? (
           <p className="text-sm text-muted-foreground">
-            No active mailbox. <a className="underline" href={GRAPH8_APP_MAILBOXES_URL} target="_blank" rel="noreferrer">Connect one in graph8</a>, or use the mailboxes block.
+            No active mailbox. <a className="underline" href={brandUrl(brand, GRAPH8_APP_MAILBOXES_PATH)} target="_blank" rel="noreferrer">Connect one in {brand.linkLabel}</a>, or use the mailboxes block.
           </p>
         ) : null}
         {active.map((m) => (
@@ -123,11 +199,12 @@ export function CampaignLaunchStep({ campaignId, audienceSize, onLaunched, class
             {m.email ?? `Mailbox ${m.id}`}
           </label>
         ))}
+        <FirstNotice shown={listOf<Mailbox>(mailboxes.data).length} limit={MAILBOX_LIMIT} noun="mailboxes" />
       </fieldset>
       {launch.error ? (
         <div className="space-y-1">
           <ApiError error={launch.error} title="The launch did not complete" />
-          <p className="text-sm text-amber-900">Do not retry blindly. A sequence may already exist; check the campaign before launching again.</p>
+          <p className="text-sm text-warning-foreground">Do not retry blindly. A sequence may already exist; check the campaign before launching again.</p>
         </div>
       ) : null}
       <Button disabled={!ready} loading={launch.loading} onClick={() => setConfirm(true)}>Launch campaign</Button>
@@ -142,6 +219,17 @@ export function CampaignLaunchStep({ campaignId, audienceSize, onLaunched, class
         onConfirm={() => void launch.mutate(undefined)}
         onCancel={() => setConfirm(false)}
       />
+      <ConfirmSpendDialog
+        open={confirmCopy}
+        tier="billable"
+        title={`Write the email copy for "${String(c.name ?? "this campaign")}" with AI`}
+        description="AI writes the emails from the campaign brief and its steps. Nothing is sent. Estimate only."
+        estimatedCredits={CREDIT_ESTIMATES.documentRegenerate}
+        confirmLabel="Write copy"
+        confirming={writeCopy.loading}
+        onConfirm={() => void writeCopy.mutate(undefined)}
+        onCancel={() => setConfirmCopy(false)}
+      />
     </section>
   );
 }

package/blocks/campaigns/components/campaign-list.tsx

@@ -25,8 +25,12 @@ import { formatDate, listOf, statusClass } from "../lib/campaigns-utils";
 import type { CampaignRow } from "../lib/campaigns-utils";
 import { CampaignAssets } from "./campaign-assets";
 import { CampaignMetrics } from "./campaign-metrics";
+import { rowActivationProps } from "@/g8/hooks/use-row-activation";
+import { RecordLink } from "@/g8/components/screen/record-link";
 
 export interface CampaignListProps {
+  /** URL param the host screen reads for this record type. With it the name is a real link (Cmd-click opens it in a new tab); without it a plain button. */
+  linkParam?: string;
   pageSize?: number;
   /** Called when a row is opened. Without it the row opens metrics and documents below the table. */
   onOpen?: (campaign: CampaignRow) => void;
@@ -37,7 +41,7 @@ export interface CampaignListProps {
 
 const COLUMNS = 6;
 
-export function CampaignList({ pageSize = 25, onOpen, emptyAction, className }: CampaignListProps) {
+export function CampaignList({ linkParam, pageSize = 25, onOpen, emptyAction, className }: CampaignListProps) {
   const [page, setPage] = useState(1);
   const [openId, setOpenId] = useState<string | null>(null);
   const [deleting, setDeleting] = useState<CampaignRow | null>(null);
@@ -74,8 +78,8 @@ export function CampaignList({ pageSize = 25, onOpen, emptyAction, className }:
         <TableBody>
           {list.loading && !list.data ? <TableRow><TableCell colSpan={COLUMNS}><Skeleton className="h-6 w-full" /></TableCell></TableRow> : null}
           {rows.map((c) => (
-            <TableRow key={c.id} data-state={c.id === openId ? "selected" : undefined}>
-              <TableCell className="font-medium">{c.name}</TableCell>
+            <TableRow key={c.id} data-state={c.id === openId ? "selected" : undefined} {...rowActivationProps(() => open(c))}>
+              <TableCell className="font-medium"><RecordLink param={linkParam} id={c.id} onOpen={() => open(c)}>{c.name}</RecordLink></TableCell>
               <TableCell><span className={`rounded px-2 py-0.5 text-xs ${statusClass(c.status)}`}>{c.status}</span></TableCell>
               <TableCell>{c.category}</TableCell>
               <TableCell className="max-w-xs truncate text-muted-foreground">{c.goal}</TableCell>

package/blocks/campaigns/components/campaign-metrics.tsx

@@ -40,7 +40,7 @@ function Tiles({ data }: { data: Record<string, unknown> }) {
           {tiles.map(([k, v]) => (
             <div key={k} className="rounded-md border p-3">
               <dt className="text-xs capitalize text-muted-foreground">{k}</dt>
-              <dd className="text-xl font-semibold">{v}</dd>
+              <dd className="text-xl font-medium">{v}</dd>
             </div>
           ))}
         </dl>

package/blocks/campaigns/components/campaign-wizard.tsx

@@ -13,14 +13,20 @@
  *      getCampaignGenerationStatus       GET  /campaigns/{campaign_id}/status  (read; POLLED while documents generate)
  *   4. attach audience, steps/content, launch: see the three step components.
  *
+ * Copy: AI writes the campaign documents by default (`autoGenerateDocuments`, default true). The launch is refused
+ * without written copy, so a campaign created without them needs its copy written before launch; the Launch step
+ * offers that. If the server could not queue the generation (`generation_status: "failed_to_dispatch"`), the
+ * wizard says so and the Launch step offers to write the copy.
+ *
  * Retry safety: the campaign id is stored the moment create succeeds, so a failure in a later step never
  * creates a second campaign; "Create" turns into "Save changes". "Start over" clears every field, the idea
  * results and the campaign id (the campaign already created stays in graph8; delete it in CampaignList).
  */
 
 import { useEffect, useState } from "react";
-import { Button, Input, Textarea } from "@graph8/sdk/ui";
+import { Button, Input, Skeleton, Textarea } from "@graph8/sdk/ui";
 import { ApiError } from "@/g8/components/api-error";
+import { FirstNotice } from "@/g8/components/paging-notices";
 import { ConfirmSpendDialog } from "@/g8/components/confirm-spend-dialog";
 import { useG8Mutation } from "@/g8/hooks/use-g8-mutation";
 import { useG8Query } from "@/g8/hooks/use-g8-query";
@@ -40,6 +46,11 @@ export interface CampaignWizardProps {
   /** Overrides the website from the saved profile. */
   websiteUrl?: string;
   onLaunched?: (result: Record<string, unknown>) => void;
+  /**
+   * Whether "Write the campaign documents with AI" starts checked. Default true: a campaign without written copy
+   * cannot launch. Pass false to start with it unchecked (the person writes the copy, or the Launch step does).
+   */
+  autoGenerateDocuments?: boolean;
   className?: string;
 }
 
@@ -48,12 +59,15 @@ const GOALS = ["awareness", "consideration", "decision"];
 const CHANNELS = ["email", "linkedin", "phone"];
 
 interface Draft { name: string; category: string; goal: string; brief: string; core_concept: string; primary_hook: string; target_persona: string; channels: string[]; autoGenerate: boolean }
-const emptyDraft: Draft = { name: "", category: "Outbound", goal: "", brief: "", core_concept: "", primary_hook: "", target_persona: "", channels: ["email"], autoGenerate: false };
+const emptyDraft: Draft = { name: "", category: "Outbound", goal: "", brief: "", core_concept: "", primary_hook: "", target_persona: "", channels: ["email"], autoGenerate: true };
 
 interface Idea { id?: string; campaign_name?: string; campaign_category?: string; core_concept?: string; why_this_works?: string; primary_hook?: string; target_channels?: string[] }
 
+/** The persona API has no paging: a full read is announced under the checkboxes. */
+const PERSONA_LIMIT = 50;
+
 function IdeaStep({ websiteUrl, onPick, onSkip }: { websiteUrl: string; onPick: (i: Idea) => void; onSkip: () => void }) {
-  const personas = useG8Query((signal) => g8Get("/personas", { limit: 50 }, { signal }), []);
+  const personas = useG8Query((signal) => g8Get("/personas", { limit: PERSONA_LIMIT }, { signal }), []);
   const [goal, setGoal] = useState(GOALS[0]);
   const [count, setCount] = useState(5);
   const [direction, setDirection] = useState("");
@@ -63,7 +77,7 @@ function IdeaStep({ websiteUrl, onPick, onSkip }: { websiteUrl: string; onPick:
   const start = useG8Mutation(
     () => g8Post("/campaigns/generate-ideas-async", {
       organization_id: "current", website_url: websiteUrl, campaign_goal: goal, num_ideas: count, user_direction: direction || null,
-      target_personas: selected, persona_mode: selected.length ? "selected" : "auto",
+      target_personas: selected, persona_mode: selected.length ? "selected" : "ai_pick", // the server's AI-picks-the-persona mode
     }),
     { onSuccess: (res) => { setConfirm(false); setTaskId(text(objectOf(res).task_id) || null); }, onError: () => setConfirm(false) },
   );
@@ -94,6 +108,7 @@ function IdeaStep({ websiteUrl, onPick, onSkip }: { websiteUrl: string; onPick:
               <input type="checkbox" checked={selected.includes(p.title ?? "")} onChange={(e) => setSelected(e.target.checked ? [...selected, p.title ?? ""] : selected.filter((t) => t !== p.title))} />{p.title}
             </label>
           ))}
+          <FirstNotice shown={personaRows.length} limit={PERSONA_LIMIT} noun="personas" />
         </fieldset>
       ) : null}
       {[start.error, poll.error].map((e, i) => (e ? <ApiError key={i} error={e} title="Idea generation failed" /> : null))}
@@ -101,10 +116,10 @@ function IdeaStep({ websiteUrl, onPick, onSkip }: { websiteUrl: string; onPick:
         <Button disabled={!websiteUrl || poll.polling} loading={start.loading} onClick={() => setConfirm(true)}>Generate ideas</Button>
         <Button variant="outline" onClick={onSkip}>Skip, write my own</Button>
       </div>
-      {!websiteUrl ? <p className="text-sm text-amber-800">Save the company website in IcpEditor first; ideas are generated from it.</p> : null}
+      {!websiteUrl ? <p className="text-sm text-warning-foreground">Save the company website in IcpEditor first; ideas are generated from it.</p> : null}
       {poll.polling ? <p role="status" className="text-sm text-muted-foreground">Generating ideas. This takes 10 to 20 seconds.</p> : null}
-      {!poll.polling && !poll.done && poll.attempts > 0 && !poll.error ? <p role="status" className="text-sm text-amber-800">Still running. Check back in a minute and generate again if nothing appears.</p> : null}
-      {failed ? <p role="alert" className="text-sm text-red-700">Generation failed: {text(poll.status?.error) || "try again"}.</p> : null}
+      {!poll.polling && !poll.done && poll.attempts > 0 && !poll.error ? <p role="status" className="text-sm text-warning-foreground">Still running. Check back in a minute and generate again if nothing appears.</p> : null}
+      {failed ? <p role="alert" className="text-sm text-error-foreground">Generation failed: {text(poll.status?.error) || "try again"}.</p> : null}
       {poll.done && !failed && ideas.length === 0 ? <p className="text-sm text-muted-foreground">No ideas came back. Try a different goal or direction.</p> : null}
       <ul className="space-y-2">
         {ideas.map((idea, i) => (
@@ -132,19 +147,32 @@ function IdeaStep({ websiteUrl, onPick, onSkip }: { websiteUrl: string; onPick:
 }
 
 function GenerationStatus({ campaignId }: { campaignId: string }) {
-  const poll = useJobPoll(async (signal) => objectOf(await g8Get(`/campaigns/${campaignId}/status`, undefined, { signal })), { isTerminal: settled, maxAttempts: 90 });
-  const label = poll.polling ? "generating documents" : text(poll.status?.status) || "ready";
-  return <span role="status" className={`rounded px-2 py-0.5 text-xs ${statusClass(poll.polling ? "generating" : "completed")}`}>Documents: {label}</span>;
+  const poll = useJobPoll(async (signal) => objectOf(await g8Get(`/campaigns/${campaignId}/status`, undefined, { signal })), { isTerminal: (s) => Boolean(text(s.generation_error)) || settled(s), maxAttempts: 90 });
+  const failed = text(poll.status?.generation_error);
+  const label = failed ? "failed" : poll.polling ? "generating documents" : text(poll.status?.status) || "ready";
+  return <span role="status" title={failed || undefined} className={`rounded px-2 py-0.5 text-xs ${statusClass(failed ? "failed" : poll.polling ? "generating" : "completed")}`}>Documents: {label}</span>;
 }
 
-export function CampaignWizard({ initialCampaignId, websiteUrl, onLaunched, className }: CampaignWizardProps) {
+export function CampaignWizard({ initialCampaignId, websiteUrl, onLaunched, autoGenerateDocuments = true, className }: CampaignWizardProps) {
   const profile = useCompanyProfile(websiteUrl);
+  const initialDraft: Draft = { ...emptyDraft, autoGenerate: autoGenerateDocuments };
   const [step, setStep] = useState(initialCampaignId ? 2 : 0);
-  const [draft, setDraft] = useState<Draft>(emptyDraft);
+  const [draft, setDraft] = useState<Draft>(initialDraft);
+  const [dispatchFailed, setDispatchFailed] = useState(false);
   const [campaignId, setCampaignId] = useState<string | null>(initialCampaignId ?? null);
   const [audience, setAudience] = useState<ListSummary | null>(null);
   const [confirm, setConfirm] = useState(false);
   const [resetKey, setResetKey] = useState(0);
+  // Resuming a saved campaign: the form shows (and can save) nothing until the campaign itself has loaded, otherwise
+  // Save would PATCH the blank defaults over the real name, goal and brief.
+  const resume = useG8Query((signal) => g8Get(`/campaigns/${initialCampaignId}`, undefined, { signal }), [initialCampaignId], { enabled: Boolean(initialCampaignId) });
+  const [seeded, setSeeded] = useState(!initialCampaignId);
+  useEffect(() => {
+    if (seeded || !resume.data) return;
+    const c = objectOf(resume.data);
+    setDraft((d) => ({ ...d, name: text(c.name), category: text(c.category) || d.category, goal: text(c.goal), brief: text(c.brief), core_concept: text(c.core_concept), primary_hook: text(c.primary_hook), target_persona: text(c.target_persona) }));
+    setSeeded(true);
+  }, [resume.data, seeded]);
 
   const save = useG8Mutation(async () => {
     const fields = { name: draft.name.trim(), category: draft.category, goal: draft.goal || null, brief: draft.brief || null, core_concept: draft.core_concept || null, primary_hook: draft.primary_hook || null, target_persona: draft.target_persona || null };
@@ -155,6 +183,7 @@ export function CampaignWizard({ initialCampaignId, websiteUrl, onLaunched, clas
       setConfirm(false);
       const id = text(objectOf(res).id);
       if (!campaignId && id) setCampaignId(id); // stored at once: a later failure never re-creates the campaign
+      if (!campaignId && objectOf(res).generation_status === "failed_to_dispatch") setDispatchFailed(true);
       setStep(2);
     },
     onError: () => setConfirm(false),
@@ -165,7 +194,7 @@ export function CampaignWizard({ initialCampaignId, websiteUrl, onLaunched, clas
     setDraft({ ...draft, name: i.campaign_name ?? "", category: i.campaign_category ?? draft.category, core_concept: i.core_concept ?? "", primary_hook: i.primary_hook ?? "", brief: i.why_this_works ?? "", channels: i.target_channels?.length ? i.target_channels : draft.channels });
     setStep(1);
   };
-  const reset = () => { setStep(0); setDraft(emptyDraft); setCampaignId(null); setAudience(null); setConfirm(false); save.reset(); setResetKey((k) => k + 1); };
+  const reset = () => { setSeeded(true); setStep(0); setDraft(initialDraft); setDispatchFailed(false); setCampaignId(null); setAudience(null); setConfirm(false); save.reset(); setResetKey((k) => k + 1); };
   const autoGen = !campaignId && draft.autoGenerate;
 
   return (
@@ -181,8 +210,14 @@ export function CampaignWizard({ initialCampaignId, websiteUrl, onLaunched, clas
         <Button size="sm" variant="outline" className="ml-auto" onClick={reset}>Start over</Button>
       </nav>
 
+      {dispatchFailed ? (
+        <p role="alert" className="rounded bg-warning p-2 text-sm text-warning-foreground">
+          The campaign was created, but writing its documents could not be started. Write the email copy from the Launch step before launching.
+        </p>
+      ) : null}
       {step === 0 ? <IdeaStep key={resetKey} websiteUrl={profile.websiteUrl} onPick={pickIdea} onSkip={() => setStep(1)} /> : null}
-      {step === 1 ? (
+      {step === 1 && !seeded ? (resume.error ? <ApiError error={resume.error} title="Could not load this campaign" onRetry={() => void resume.refetch()} /> : <Skeleton className="h-48 w-full" aria-label="Loading campaign" />) : null}
+      {step === 1 && seeded ? (
         <section aria-label="Campaign" className="space-y-3">
           <FormField label="Campaign name" htmlFor="cw-name"><Input id="cw-name" value={draft.name} onChange={set("name")} /></FormField>
           <div className="grid gap-3 sm:grid-cols-2">
@@ -206,6 +241,9 @@ export function CampaignWizard({ initialCampaignId, websiteUrl, onLaunched, clas
                 <input type="checkbox" checked={draft.autoGenerate} onChange={(e) => setDraft({ ...draft, autoGenerate: e.target.checked })} />
                 Write the campaign documents with AI after creating it (uses credits)
               </label>
+              {!draft.autoGenerate && draft.channels.includes("email") ? (
+                <p className="text-sm text-muted-foreground">Without them the campaign has no email copy, and it cannot launch until the copy is written. The Launch step can write it with AI.</p>
+              ) : null}
             </>
           ) : null}
           {save.error ? <ApiError error={save.error} title={campaignId ? "Could not save the campaign" : "Could not create the campaign"} /> : null}