@graph8/sdk 0.362.0 → 0.373.0

package/blocks/campaigns/components/persona-detail.tsx

@@ -0,0 +1,181 @@
+"use client";
+
+/**
+ * PersonaDetail: one buyer persona, complete. Every field, the campaigns that target it, and every action:
+ * edit, pin or unpin, archive.
+ *
+ * SDK operations, in order:
+ *   1. getPersona     GET   /personas/{persona_id}     (read; all fields)
+ *   2. listCampaigns  GET   /campaigns                 (read; campaigns whose target persona is this title)
+ *   3. updatePersona  PATCH /personas/{persona_id}     (write)
+ *   4. pinPersona / unpinPersona  POST /personas/{persona_id}/pin|unpin  (write)
+ *   5. archivePersona POST  /personas/{persona_id}/archive (destructive: confirmed)
+ */
+
+import { useState } from "react";
+import type { ReactNode } from "react";
+import { Button, Input, Skeleton, Textarea } from "@graph8/sdk/ui";
+import { ApiError } from "@/g8/components/api-error";
+import { useAllPages } from "@/g8/hooks/use-all-pages";
+import { hasNextOf } from "@/g8/lib/paging";
+import { ConfirmSpendDialog } from "@/g8/components/confirm-spend-dialog";
+import { DetailPanel } from "@/g8/components/screen/detail-panel";
+import { FormSheet } from "@/g8/components/screen/form-sheet";
+import { KeyValueList } from "@/g8/components/screen/key-value-list";
+import { SectionCard } from "@/g8/components/screen/section-card";
+import { StatusPill } from "@/g8/components/screen/status-pill";
+import { useG8Mutation } from "@/g8/hooks/use-g8-mutation";
+import { useG8Query } from "@/g8/hooks/use-g8-query";
+import { g8Get, g8Patch, g8Post } from "@/g8/lib/g8-client";
+import { fieldItems, listOf, objectOf, personaFormOf, personaPatch, text } from "../lib/campaigns-utils";
+import type { CampaignRow } from "../lib/campaigns-utils";
+import { FormField } from "./form-field";
+
+export interface PersonaDetailProps {
+  personaId: string;
+  onClose?: () => void;
+  /** Full-page mode: show an "Open full page" (onExpand) or "Back to split view" (onCollapse) button. */
+  onExpand?: () => void;
+  onCollapse?: () => void;
+  onChanged?: () => void;
+  /** Open a campaign that targets this persona. */
+  onOpenCampaign?: (campaign: CampaignRow) => void;
+  renderActions?: (persona: Record<string, unknown>) => ReactNode;
+  className?: string;
+}
+
+interface Form { title: string; why: string; signals: string; approach: string; goal: string; priority: string; confidence: string }
+
+/** The API returns `pinned` (`is_pinned` is accepted too, for older payloads). */
+function isPinned(r: Record<string, unknown> | undefined): boolean {
+  return Boolean(r && (r.pinned ?? r.is_pinned));
+}
+
+/** Campaigns per read: every page is read, so no targeting campaign is missed. */
+const CAMPAIGN_PAGE = 100;
+
+export function PersonaDetail({ personaId, onClose, onExpand, onCollapse, onChanged, onOpenCampaign, renderActions, className }: PersonaDetailProps) {
+  const [form, setForm] = useState<Form | null>(null);
+  const [archiving, setArchiving] = useState(false);
+  const q = useG8Query((signal) => g8Get(`/personas/${personaId}`, undefined, { signal }), [personaId]);
+  const campaigns = useAllPages<CampaignRow>(async (page, signal) => {
+    const env = await g8Get("/campaigns", { page, limit: CAMPAIGN_PAGE }, { signal });
+    const rows = listOf<CampaignRow>(env);
+    return { rows, hasNext: hasNextOf(env, CAMPAIGN_PAGE, rows.length) };
+  }, [personaId]);
+  const p = objectOf(q.data) as Record<string, any>;
+
+  const save = useG8Mutation(async (f: Form) => {
+    const patch = personaPatch(p, f);
+    if (Object.keys(patch).length > 0) await g8Patch(`/personas/${personaId}`, patch); // nothing changed: no request
+    setForm(null);
+    await q.refetch();
+    onChanged?.();
+  });
+  const pin = useG8Mutation(async () => {
+    await g8Post(`/personas/${personaId}/${isPinned(p) ? "unpin" : "pin"}`, {});
+    await q.refetch();
+    onChanged?.();
+  });
+  const archive = useG8Mutation(async () => {
+    await g8Post(`/personas/${personaId}/archive`, {});
+    setArchiving(false);
+    onChanged?.();
+    onClose?.();
+  }, { onError: () => setArchiving(false) });
+
+  if (q.error) return <ApiError error={q.error} title="Could not load the persona" onRetry={() => void q.refetch()} className={className} />;
+  if (q.loading && !q.data) return <Skeleton className={`h-48 w-full ${className ?? ""}`} />;
+
+  const title = text(p.title) || `Persona ${personaId}`;
+  const targeting = campaigns.items.filter((c) => (c.target_persona ?? "").trim().toLowerCase() === title.trim().toLowerCase());
+  const startEdit = () => {
+    save.reset();
+    setForm(personaFormOf(p));
+  };
+  const set = (k: keyof Form) => (e: { target: { value: string } }) => setForm((cur) => (cur ? { ...cur, [k]: e.target.value } : cur));
+  return (
+    <DetailPanel
+      className={className}
+      title={title}
+      subtitle={p.why_target ?? undefined}
+      badges={<><StatusPill tone={p.status && p.status !== "active" ? "neutral" : "positive"} dot>{p.status ?? "active"}</StatusPill>{isPinned(p) ? <StatusPill tone="info">pinned</StatusPill> : null}</>}
+      actions={
+        <>
+          <Button size="sm" variant="outline" onClick={startEdit}>Edit persona</Button>
+          <Button size="sm" variant="outline" loading={pin.loading} onClick={() => void pin.mutate(undefined)}>{isPinned(p) ? "Unpin persona" : "Pin persona"}</Button>
+          <Button size="sm" variant="outline" onClick={() => setArchiving(true)}>Archive persona</Button>
+          {renderActions?.(p)}
+          <FormSheet
+            open={form !== null}
+            onOpenChange={(o) => !o && setForm(null)}
+            title="Edit persona"
+            footer={<><Button variant="outline" onClick={() => setForm(null)}>Cancel</Button><Button loading={save.loading} disabled={!form?.title.trim()} onClick={() => form && void save.mutate(form)}>Save persona</Button></>}
+          >
+            {form ? (
+              <>
+                <FormField label="Title" htmlFor="pd-title"><Input id="pd-title" value={form.title} onChange={set("title")} /></FormField>
+                <FormField label="Why target" htmlFor="pd-why"><Textarea id="pd-why" value={form.why} onChange={set("why")} /></FormField>
+                <FormField label="Key signals" htmlFor="pd-sig" hint="One per line."><Textarea id="pd-sig" value={form.signals} onChange={set("signals")} /></FormField>
+                <FormField label="Campaign approach" htmlFor="pd-app"><Textarea id="pd-app" value={form.approach} onChange={set("approach")} /></FormField>
+                <FormField label="Recommended goal" htmlFor="pd-goal"><Input id="pd-goal" value={form.goal} onChange={set("goal")} /></FormField>
+                <FormField label="Priority" htmlFor="pd-pri"><Input id="pd-pri" type="number" min={1} value={form.priority} onChange={set("priority")} /></FormField>
+                <FormField label="Confidence" htmlFor="pd-conf">
+                  <select id="pd-conf" className="h-9 rounded-md border bg-background px-2" value={form.confidence} onChange={set("confidence")}>{["low", "medium", "high"].map((c) => <option key={c} value={c}>{c}</option>)}</select>
+                </FormField>
+                {save.error ? <ApiError error={save.error} title="Could not save the persona" /> : null}
+              </>
+            ) : null}
+          </FormSheet>
+          <ConfirmSpendDialog
+            open={archiving}
+            tier="destructive"
+            title={`Archive ${title}`}
+            description="It drops out of the default list. Existing campaigns keep the persona text."
+            affected={1}
+            confirmLabel="Archive persona"
+            confirming={archive.loading}
+            onCancel={() => setArchiving(false)}
+            onConfirm={() => void archive.mutate(undefined)}
+          />
+        </>
+      }
+      onClose={onClose}
+      onExpand={onExpand}
+      onCollapse={onCollapse}
+      tabs={[
+        {
+          id: "details",
+          label: "Details",
+          content: (
+            <div className="space-y-4">
+              {[pin.error, archive.error].map((e, i) => (e ? <ApiError key={i} error={e} /> : null))}
+              <KeyValueList columns={2} items={fieldItems(p)} />
+            </div>
+          ),
+        },
+        {
+          id: "campaigns",
+          label: "Campaigns",
+          count: targeting.length,
+          content: (
+            <SectionCard title="Campaigns targeting this persona">
+              {targeting.length === 0 ? (
+                <p className="text-sm text-muted-foreground">No campaign targets this persona yet.</p>
+              ) : (
+                <ul className="divide-y">
+                  {targeting.map((c) => (
+                    <li key={c.id} className="flex items-center justify-between py-2 text-sm">
+                      <Button size="sm" variant="ghost" disabled={!onOpenCampaign} onClick={() => onOpenCampaign?.(c)}>{c.name}</Button>
+                      <StatusPill tone="neutral">{c.status ?? "draft"}</StatusPill>
+                    </li>
+                  ))}
+                </ul>
+              )}
+            </SectionCard>
+          ),
+        },
+      ]}
+    />
+  );
+}

package/blocks/campaigns/components/persona-editor.tsx

@@ -19,13 +19,14 @@
 import { useState } from "react";
 import { Button, Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle, Input, Skeleton, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, 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 { EmptyState } from "@/g8/components/empty-state";
 import { useG8Mutation } from "@/g8/hooks/use-g8-mutation";
 import { useG8Query } from "@/g8/hooks/use-g8-query";
 import { g8Get, g8Patch, g8Post } from "@/g8/lib/g8-client";
 import { useCompanyProfile } from "../hooks/use-company-profile";
-import { CREDIT_ESTIMATES, lines, listOf, statusClass, text } from "../lib/campaigns-utils";
+import { CREDIT_ESTIMATES, lines, listOf, personaFormOf, personaPatch, statusClass, text } from "../lib/campaigns-utils";
 import { FormField } from "./form-field";
 
 export interface PersonaEditorProps {
@@ -33,6 +34,10 @@ export interface PersonaEditorProps {
   websiteUrl?: string;
   /** Called after any change, so a wizard can refresh its persona choices. */
   onChange?: () => void;
+  /** Called when a persona's title is clicked (a screen opens its detail). Without it the title is plain text. */
+  onOpen?: (persona: { id: string; title?: string | null }) => void;
+  /** Change it to reload the list (the detail edited or archived a persona). */
+  refreshKey?: number;
   className?: string;
 }
 
@@ -61,16 +66,14 @@ interface Suggestion {
 interface PersonaForm { title: string; why: string; signals: string; approach: string; goal: string; priority: string; confidence: string }
 const emptyForm: PersonaForm = { title: "", why: "", signals: "", approach: "", goal: "", priority: "1", confidence: "medium" };
 
-function formOf(p: PersonaRow): PersonaForm {
-  return {
-    title: p.title ?? "", why: p.why_target ?? "", approach: p.campaign_approach ?? "", goal: p.recommended_goal ?? "",
-    priority: String(p.priority ?? 1), confidence: p.confidence ?? "medium", signals: (p.key_signals ?? []).map((s) => text(s)).filter(Boolean).join("\n"),
-  };
-}
+const formOf = (p: PersonaRow): PersonaForm => personaFormOf(p as Record<string, any>);
+
+/** The persona API has no paging: a full read is announced under the table. */
+const PERSONA_LIMIT = 100;
 
-export function PersonaEditor({ websiteUrl, onChange, className }: PersonaEditorProps) {
+export function PersonaEditor({ websiteUrl, onChange, onOpen, refreshKey, className }: PersonaEditorProps) {
   const profile = useCompanyProfile(websiteUrl);
-  const personas = useG8Query((signal) => g8Get("/personas", { limit: 100 }, { signal }), []);
+  const personas = useG8Query((signal) => g8Get("/personas", { limit: PERSONA_LIMIT }, { signal }), [refreshKey]);
   const [editing, setEditing] = useState<PersonaRow | "new" | null>(null);
   const [form, setForm] = useState<PersonaForm>(emptyForm);
   const [archiving, setArchiving] = useState<PersonaRow | null>(null);
@@ -81,11 +84,15 @@ export function PersonaEditor({ websiteUrl, onChange, className }: PersonaEditor
 
   const done = () => { void personas.refetch(); onChange?.(); };
   const save = useG8Mutation(async () => {
+    if (editing && editing !== "new") {
+      const patch = personaPatch(editing as Record<string, any>, form);
+      return Object.keys(patch).length > 0 ? g8Patch(`/personas/${editing.id}`, patch) : undefined; // nothing changed: no request
+    }
     const body = {
       title: form.title.trim(), why_target: form.why, key_signals: lines(form.signals), campaign_approach: form.approach,
       recommended_goal: form.goal, priority: Number(form.priority) || 1, confidence: form.confidence,
     };
-    return editing && editing !== "new" ? g8Patch(`/personas/${editing.id}`, body) : g8Post("/personas", { ...body, website_url: profile.websiteUrl });
+    return g8Post("/personas", { ...body, website_url: profile.websiteUrl });
   }, { onSuccess: () => { setEditing(null); done(); } });
   const archive = useG8Mutation(async (p: PersonaRow) => {
     setBusyId(p.id);
@@ -143,7 +150,7 @@ export function PersonaEditor({ websiteUrl, onChange, className }: PersonaEditor
           {personas.loading && !personas.data ? <TableRow><TableCell colSpan={5}><Skeleton className="h-6 w-full" /></TableCell></TableRow> : null}
           {rows.map((p) => (
             <TableRow key={p.id}>
-              <TableCell className="font-medium">{p.title}</TableCell>
+              <TableCell className="font-medium">{onOpen ? <button type="button" className="text-left hover:underline" aria-label={`Open ${p.title}`} onClick={() => onOpen(p)}>{p.title}</button> : p.title}</TableCell>
               <TableCell className="max-w-md truncate text-muted-foreground">{p.why_target}</TableCell>
               <TableCell>{p.confidence}</TableCell>
               <TableCell><span className={`rounded px-2 py-0.5 text-xs ${statusClass(p.status)}`}>{p.status ?? "active"}</span></TableCell>
@@ -155,6 +162,7 @@ export function PersonaEditor({ websiteUrl, onChange, className }: PersonaEditor
           ))}
         </TableBody>
       </Table>
+      <FirstNotice shown={rows.length} limit={PERSONA_LIMIT} noun="personas" />
       {!personas.loading && !personas.error && rows.length === 0 ? <EmptyState title="No personas yet" description="Add the roles you sell to, or let AI recommend them." /> : null}
 
       <Dialog open={editing !== null} onOpenChange={(o) => { if (!o) setEditing(null); }}>

package/blocks/campaigns/lib/campaigns-utils.ts

@@ -2,8 +2,13 @@
 
 /** Types and helpers shared by the campaign components. Payloads are open-shaped: every field is optional. */
 
+import { DEFAULT_BRAND } from "@/g8/hooks/use-brand";
+
 /** Where the person manages mailboxes. Google and Microsoft OAuth consent can only run in the graph8 app. */
-export const GRAPH8_APP_MAILBOXES_URL = "https://app.graph8.com/studio/settings?tab=purchase&view=mailboxes";
+/** The path on the platform's web app; components resolve it against the brand (`brandUrl(useBrand(), ...)`). */
+export const GRAPH8_APP_MAILBOXES_PATH = "/studio/settings?tab=purchase&view=mailboxes";
+/** The default (graph8) URL. Kept for existing imports; prefer GRAPH8_APP_MAILBOXES_PATH with useBrand. */
+export const GRAPH8_APP_MAILBOXES_URL = `${DEFAULT_BRAND.appUrl}${GRAPH8_APP_MAILBOXES_PATH}`;
 
 /**
  * Rough credit estimates shown in ConfirmSpendDialog. The API has no price read and no balance read, so these
@@ -93,10 +98,10 @@ export function commaList(value: string): string[] {
 
 export function statusClass(status: string | null | undefined): string {
   const s = (status ?? "").toLowerCase();
-  if (["active", "live", "completed", "approved", "complete", "done"].includes(s)) return "bg-green-100 text-green-800";
-  if (["draft", "pending", "running", "generating", "in_progress", "copy_in_progress", "scheduling"].includes(s)) return "bg-amber-100 text-amber-800";
-  if (s) return "bg-red-100 text-red-800";
-  return "bg-gray-100 text-gray-700";
+  if (["active", "live", "completed", "approved", "complete", "done"].includes(s)) return "bg-positive text-positive-foreground";
+  if (["draft", "pending", "running", "generating", "in_progress", "copy_in_progress", "scheduling"].includes(s)) return "bg-warning text-warning-foreground";
+  if (s) return "bg-error text-error-foreground";
+  return "bg-muted text-foreground";
 }
 
 /** Timestamps are shown in UTC so the same value reads the same everywhere. */
@@ -150,6 +155,134 @@ export function audienceOf(envelope: unknown): { listId: string | null; name: st
   return { listId: id == null || id === "" ? null : String(id), name: text(a.name) || text(a.title), size };
 }
 
+/** Document types that hold the sequence itself, not copy. The launch counts every other completed document as copy. */
+export const NON_COPY_FILE_TYPES = new Set(["sequence", "step_catalog"]);
+
+/** The email copy document a launch reads, and where the generator files it. */
+export const EMAILS_DOCUMENT = { file_type: "emails", display_name: "Emails", folder_path: "campaign_copy/channels/email" } as const;
+
+const GENERATING = new Set(["generating", "pending", "running", "in_progress", "queued", "processing", "regenerating"]);
+
+export interface CopyState {
+  /** False when the payload has no `documents` list (an older API): readiness is then unknown, not missing. */
+  known: boolean;
+  /** At least one completed copy document: the launch's server-side check passes. */
+  ready: boolean;
+  /** A copy document is still being written, or the campaign is still in `copy_in_progress`. */
+  generating: boolean;
+  /** The existing email copy document, so writing the copy reuses it instead of creating a second one. */
+  emailsDocId: string | null;
+}
+
+/**
+ * Copy readiness from a GET /campaigns/{id}/full payload. Mirrors the launch's own check: a launch is refused
+ * (400 "no completed copy documents") unless some document other than the sequence and step catalog is completed.
+ */
+export function copyStateOf(envelope: unknown): CopyState {
+  const d = objectOf(envelope);
+  if (!Array.isArray(d.documents)) return { known: false, ready: false, generating: false, emailsDocId: null };
+  const copy = (d.documents as CampaignDocRow[]).filter((doc) => doc && !NON_COPY_FILE_TYPES.has(text(doc.file_type)));
+  const ready = copy.some((doc) => text(doc.status).toLowerCase() === "completed");
+  const generating = !ready && (copy.some((doc) => GENERATING.has(text(doc.status).toLowerCase())) || text(d.status) === "copy_in_progress");
+  const emails = copy.find((doc) => doc.file_type === EMAILS_DOCUMENT.file_type);
+  return { known: true, ready, generating, emailsDocId: emails ? String(emails.id) : null };
+}
+
+/** New mailboxes send nothing for their first 14 days (the sequencer's warm-up hold, on by default). */
+export const WARMUP_HOLD_DAYS = 14;
+
+/** When a mailbox added less than 14 days ago may start sending, or null when it is past the hold (or unknown). */
+export function warmupHoldUntil(createdAt: string | null | undefined, now: Date = new Date()): Date | null {
+  if (!createdAt) return null;
+  const created = new Date(createdAt.includes("T") ? createdAt : createdAt.replace(" ", "T"));
+  if (Number.isNaN(created.getTime())) return null;
+  const until = new Date(created.getTime() + WARMUP_HOLD_DAYS * 24 * 60 * 60 * 1000);
+  return until > now ? until : null;
+}
+
 export function byteLength(s: string): number {
   return typeof Blob !== "undefined" ? new Blob([s]).size : s.length;
 }
+
+const HIDDEN_FIELDS = /password|secret|token|credential/i;
+
+/** Every readable field of an open-shaped record as label/value pairs (secrets are never shown). */
+export function fieldItems(obj: Record<string, unknown>): Array<{ label: string; value: string }> {
+  return Object.entries(obj)
+    .filter(([k, v]) => !HIDDEN_FIELDS.test(k) && v !== null && v !== undefined && v !== "")
+    .map(([k, v]) => {
+      const label = k.replace(/_/g, " ").replace(/^./, (c) => c.toUpperCase());
+      if (typeof v === "string" && /_at$|date$/.test(k) && !Number.isNaN(new Date(v).getTime())) return { label, value: formatDate(v) };
+      if (typeof v === "boolean") return { label, value: v ? "Yes" : "No" };
+      if (Array.isArray(v) && v.every((x) => typeof x === "string")) return { label, value: v.join(", ") };
+      if (typeof v === "object") return { label, value: JSON.stringify(v) };
+      return { label, value: String(v) };
+    });
+}
+
+const isTextItem = (s: unknown): boolean => typeof s === "string" || typeof s === "number";
+
+/**
+ * The stored list after the person edited its text lines: items the text box cannot show or edit (objects, nested
+ * lists) stay exactly where they were; the text items take the edited lines in order; extra lines go at the end.
+ */
+function mergeList(original: unknown, edited: string[]): unknown[] {
+  const out: unknown[] = [];
+  let next = 0;
+  for (const item of Array.isArray(original) ? original : []) {
+    if (!isTextItem(item)) out.push(item);
+    else if (next < edited.length) out.push(edited[next++]);
+  }
+  return [...out, ...edited.slice(next)];
+}
+
+export interface IcpFormValues { name: string; description: string; industries: string; size: string; regions: string; signals: string }
+export interface PersonaFormValues { title: string; why: string; signals: string; approach: string; goal: string; priority: string; confidence: string }
+
+const csv = (v: unknown): string => (Array.isArray(v) ? v.join(", ") : text(v));
+const textLines = (list: unknown): string => (Array.isArray(list) ? list.map((s) => text(s)).filter(Boolean).join("\n") : "");
+
+/** The edit form for a stored ICP. */
+export function icpFormOf(icp: Record<string, any>): IcpFormValues {
+  const f = (icp.firmographics ?? {}) as Record<string, unknown>;
+  return { name: icp.name ?? "", description: icp.description ?? "", industries: csv(f.industries), size: text(f.company_size), regions: csv(f.regions), signals: textLines(icp.buying_signals) };
+}
+
+/**
+ * PATCH body for an ICP edit: only what the person changed. The API replaces each key it receives, so an untouched
+ * list or object is never re-sent (structured buying signals or firmographics the form cannot show survive), and
+ * an edited signals list keeps the items the text box could not show.
+ */
+export function icpPatch(icp: Record<string, any>, form: IcpFormValues): Record<string, unknown> {
+  const before = icpFormOf(icp);
+  const out: Record<string, unknown> = {};
+  if (form.name.trim() !== before.name.trim()) out.name = form.name.trim();
+  if (form.description !== before.description) out.description = form.description;
+  const firmographics: Record<string, unknown> = { ...(icp.firmographics ?? {}) };
+  let touched = false;
+  if (form.industries !== before.industries) { firmographics.industries = commaList(form.industries); touched = true; }
+  if (form.size !== before.size) { firmographics.company_size = form.size; touched = true; }
+  if (form.regions !== before.regions) { firmographics.regions = commaList(form.regions); touched = true; }
+  if (touched) out.firmographics = firmographics;
+  if (form.signals !== before.signals) out.buying_signals = mergeList(icp.buying_signals, lines(form.signals));
+  return out;
+}
+
+/** The edit form for a stored persona. */
+export function personaFormOf(p: Record<string, any>): PersonaFormValues {
+  return { title: p.title ?? "", why: p.why_target ?? "", approach: p.campaign_approach ?? "", goal: p.recommended_goal ?? "", priority: String(p.priority ?? 1), confidence: p.confidence ?? "medium", signals: textLines(p.key_signals) };
+}
+
+/** PATCH body for a persona edit: only the changed keys (an untouched `key_signals` list is never re-sent). */
+export function personaPatch(p: Record<string, any>, form: PersonaFormValues): Record<string, unknown> {
+  const before = personaFormOf(p);
+  const out: Record<string, unknown> = {};
+  if (form.title.trim() !== before.title.trim()) out.title = form.title.trim();
+  if (form.why !== before.why) out.why_target = form.why;
+  if (form.signals !== before.signals) out.key_signals = mergeList(p.key_signals, lines(form.signals));
+  if (form.approach !== before.approach) out.campaign_approach = form.approach;
+  if (form.goal !== before.goal) out.recommended_goal = form.goal;
+  if (form.priority !== before.priority) out.priority = Number(form.priority) || 1;
+  if (form.confidence !== before.confidence) out.confidence = form.confidence;
+  return out;
+}

package/blocks/campaigns/recipes/attach-audience-and-launch.ts

@@ -5,7 +5,10 @@
  * first. Readiness needs a non-empty audience, completed copy, at least one complete step and an ACTIVE
  * email mailbox (Google and Microsoft mailboxes are connected by the person in the graph8 app). An empty body
  * auto-picks the first active mailbox; pass `sender_mailbox_ids` to choose. Read the state with
- * `getCampaignFull` (plain `getCampaign` omits the audience): `is_launched` means do not launch again. If
+ * `getCampaignFull` (plain `getCampaign` omits the audience): `is_launched` (true only for a live launch, not a
+ * failed attempt) means do not launch again; copy is ready when a document other than `sequence` and
+ * `step_catalog` has `status: "completed"` (the launch refuses with 400 otherwise). The deliverability verdict is
+ * `safe` (older responses: `safe_to_send`). If
  * launch fails with 502 `draft_created_activation_failed` or `activation_state_uncertain`, a sequence may
  * exist: check it before retrying, never repeat blindly.
  */
@@ -17,13 +20,23 @@ export async function attachAndLaunch(campaignId: string, listId: number, sender
   await g8.api.gtmCampaigns.attachAudienceToCampaign({ path: { campaign_id: campaignId }, body: { list_id: String(listId) } });
 
   const verdict = await g8.api.deliverability.getSafeToSend();
-  const safe = ((verdict.data ?? {}) as { safe_to_send?: boolean }).safe_to_send;
+  const v = (verdict.data ?? {}) as { safe?: boolean; safe_to_send?: boolean };
+  const safe = v.safe ?? v.safe_to_send;
   if (safe === false) return { launched: false as const, reason: "deliverability says do not send" };
 
   const full = await g8.api.gtmCampaigns.getCampaignFull({ path: { campaign_id: campaignId } });
-  const state = (full.data ?? {}) as { is_launched?: boolean; audience?: { item_count?: number }; sequence?: { steps?: unknown[] } };
+  const state = (full.data ?? {}) as {
+    is_launched?: boolean;
+    audience?: { item_count?: number };
+    sequence?: { steps?: unknown[] };
+    documents?: Array<{ file_type?: string | null; status?: string | null }>;
+  };
   if (state.is_launched) return { launched: false as const, reason: "already launched" };
   if (!state.sequence?.steps?.length) return { launched: false as const, reason: "the campaign has no steps" };
+  const copyReady = (state.documents ?? []).some(
+    (d) => d.status === "completed" && !["sequence", "step_catalog"].includes(String(d.file_type)),
+  );
+  if (!copyReady) return { launched: false as const, reason: "the campaign has no completed copy yet" };
 
   const launched = await g8.api.gtmCampaigns.launchCampaign({
     path: { campaign_id: campaignId },

package/blocks/campaigns/recipes/generate-ideas-and-create-campaign.ts

@@ -3,8 +3,12 @@
  * @when Starting a campaign from the company profile. `generateCampaignIdeasAsync` is BILLABLE (it scales with
  * `num_ideas`): a human approves the spend first. It returns a `task_id`; there are no streams, so poll
  * `getCampaignIdeasTaskStatus` every 2 to 3 seconds until `completed` or `failed`. `createCampaign` is tier
- * `external` in the contract but contacts nobody; with `auto_generate_documents: true` it also spends credits
- * writing the documents. Store the returned campaign id at once: a retry after a later failure must reuse it.
+ * `external` in the contract but contacts nobody; with `auto_generate_documents: true` (the default here) it also
+ * spends credits writing the documents. Keep it on: a campaign with no completed copy document is refused at launch
+ * (400 "no completed copy documents"). Pass `autoGenerateDocuments: false` only when you write the copy yourself
+ * (`createCampaignDocument` with `status: "completed"`). `generation_status: "failed_to_dispatch"` in the response
+ * means the writing never started: regenerate the documents before launching. Store the returned campaign id at
+ * once: a retry after a later failure must reuse it.
  */
 import { g8 } from "@graph8/sdk";
 
@@ -34,7 +38,7 @@ export async function generateIdeas(websiteUrl: string, goal: "awareness" | "con
   throw new Error(`idea task ${taskId} did not finish in time`);
 }
 
-export async function createCampaignFromIdea(idea: Idea, listId?: number) {
+export async function createCampaignFromIdea(idea: Idea, listId?: number, autoGenerateDocuments = true) {
   const created = await g8.api.gtmCampaigns.createCampaign({
     body: {
       name: idea.campaign_name ?? "New campaign",
@@ -44,7 +48,7 @@ export async function createCampaignFromIdea(idea: Idea, listId?: number) {
       brief: idea.why_this_works,
       target_channels: ["email"],
       audience_list_id: listId == null ? undefined : String(listId),
-      auto_generate_documents: false,
+      auto_generate_documents: autoGenerateDocuments,
     },
   });
   return String(created.data?.id);

package/blocks/coach/README.md

@@ -5,6 +5,14 @@ the `dialer` block (the optional "Real calls" tab reuses its `CallLog`).
 
 Install: `npx @graph8/sdk add coach` (installs `foundation`, `lists`, `crm` and `dialer` first).
 
+## Screens
+
+`CoachScreen` (`components/coach-screen.tsx`) needs no props. **Practice calls**: stats (calls, average and best score,
+weakest stage), a feed with the first tip per call, scorecard / recording / transcript detail (`?id=`), delete (confirmed,
+hide with `allowDelete={false}`), and a New practice call form (adds the row; the live conversation runs in graph8).
+**Leaderboard** ranks reps. **Real calls** shows the rep's dialer calls once a rep email is set; managers type a rep
+email in the toolbar (needs a manager key). Slots: `toolbarActions`, `renderRowActions`, `renderDetailActions`, `extraDetailTabs`.
+
 ## What you get
 
 | Component | Use it for | Embed props |
@@ -12,6 +20,8 @@ Install: `npx @graph8/sdk add coach` (installs `foundation`, `lists`, `crm` and
 | `CallScorecard` | One graded call: overall score, stages with checklist verdicts, strengths, improvements, recording, transcript | `callId`, `allowDelete`, `onDeleted` |
 | `CoachingFeed` | Practice calls newest first with the first tip, a leaderboard tab, optional real-calls tab | `userEmail`, `onOpenCall`, `allowCreate`, `showDialerCalls`, `allowDelete`, `pageSize` |
 
+Every detail opens as a full page with `&view=full` (the Open full page button).
+
 ## The flow, with the ids that pass between steps
 
 1. **Feed**: `GET /sales-coach/calls?email=` returns the calls (newest first) with `scores` and transcript

package/blocks/coach/block.json

@@ -55,6 +55,20 @@
         "read",
         "write"
       ]
+    },
+    {
+      "name": "CoachScreen",
+      "file": "components/coach-screen.tsx",
+      "purpose": "Finished sales coach page: practice calls with scorecards, leaderboard, real calls and a new-call form.",
+      "operations": [
+        "create_call_sales_coach_calls_post",
+        "get_sales_coach_leaderboard_sales_coach_leaderboard_get",
+        "list_calls_sales_coach_calls_get"
+      ],
+      "tiers": [
+        "read",
+        "write"
+      ]
     }
   ],
   "hooks": [],
@@ -120,6 +134,7 @@
     }
   ],
   "peerDependencies": {
-    "react": ">=18"
+    "react": ">=18",
+    "lucide-react": ">=0.400.0"
   }
 }

package/blocks/coach/components/call-scorecard.tsx

@@ -34,7 +34,7 @@ export interface CallScorecardProps {
   className?: string;
 }
 
-const VERDICT_STYLE: Record<string, string> = { met: "text-green-700", partial: "text-amber-600", missed: "text-destructive" };
+const VERDICT_STYLE: Record<string, string> = { met: "text-positive-foreground", partial: "text-warning-foreground", missed: "text-destructive" };
 
 export function CallScorecard({ callId, onDeleted, allowDelete = true, className }: CallScorecardProps) {
   const [audio, setAudio] = useState<{ callId: string; url: string } | null>(null);
@@ -67,13 +67,13 @@ export function CallScorecard({ callId, onDeleted, allowDelete = true, className
     <div className={`flex flex-col gap-4 ${className ?? ""}`}>
       <header className="flex flex-wrap items-start justify-between gap-3">
         <div>
-          <h2 className="text-lg font-semibold">{row.prospect_name || "Practice call"}{row.prospect_company ? ` at ${row.prospect_company}` : ""}</h2>
+          <h2 className="text-lg font-medium">{row.prospect_name || "Practice call"}{row.prospect_company ? ` at ${row.prospect_company}` : ""}</h2>
           <p className="text-sm text-muted-foreground">
             {[row.user_email, row.call_mode, row.call_status, row.duration_ms ? clock(row.duration_ms) : null, row.date_of_call ? new Date(row.date_of_call).toLocaleDateString() : null].filter(Boolean).join(" - ")}
           </p>
         </div>
         <div className="text-right">
-          <div data-testid="overall-score" className="text-3xl font-semibold">{card?.scorePct != null ? `${Math.round(card.scorePct)}%` : "-"}</div>
+          <div data-testid="overall-score" className="text-3xl font-medium">{card?.scorePct != null ? `${Math.round(card.scorePct)}%` : "-"}</div>
           <div className="text-xs text-muted-foreground">{card ? "overall" : "not graded yet"}</div>
         </div>
       </header>
@@ -94,20 +94,20 @@ export function CallScorecard({ callId, onDeleted, allowDelete = true, className
             ))}
           </ul>
           <div className="grid gap-3 sm:grid-cols-2">
-            <div><h3 className="mb-1 text-sm font-semibold">Strengths</h3><ul className="list-disc pl-5 text-sm">{card.strengths.map((t, i) => <li key={i}>{t}</li>)}</ul></div>
-            <div><h3 className="mb-1 text-sm font-semibold">To improve</h3><ul className="list-disc pl-5 text-sm">{card.improvements.map((t, i) => <li key={i}>{t}</li>)}</ul></div>
+            <div><h3 className="mb-1 text-sm font-medium">Strengths</h3><ul className="list-disc pl-5 text-sm">{card.strengths.map((t, i) => <li key={i}>{t}</li>)}</ul></div>
+            <div><h3 className="mb-1 text-sm font-medium">To improve</h3><ul className="list-disc pl-5 text-sm">{card.improvements.map((t, i) => <li key={i}>{t}</li>)}</ul></div>
           </div>
         </>
       )}
 
       <div className="flex flex-col gap-2">
-        <h3 className="text-sm font-semibold">Recording</h3>
+        <h3 className="text-sm font-medium">Recording</h3>
         {row.audio_url ? (shownAudio ? <audio controls src={shownAudio} className="w-full" /> : <div><Button size="sm" variant="outline" loading={loadAudio.loading} onClick={() => void loadAudio.mutate(callId)}>Load recording</Button></div>) : <p className="text-sm text-muted-foreground">No recording.</p>}
         {loadAudio.error ? <ApiError error={loadAudio.error} title="Could not load the recording" /> : null}
       </div>
 
       <div className="flex flex-col gap-2">
-        <h3 className="text-sm font-semibold">Transcript</h3>
+        <h3 className="text-sm font-medium">Transcript</h3>
         {transcript.error ? <ApiError error={transcript.error} title="Could not load the transcript" onRetry={() => void transcript.refetch()} /> : null}
         <ul className="flex max-h-96 flex-col gap-1 overflow-y-auto" data-testid="transcript">
           {segments.map((s, i) => (