@graph8/sdk 0.308.1 → 0.357.0

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

@@ -0,0 +1,95 @@
+"use client";
+
+/**
+ * Small helpers shared by the intent components: pull rows out of the API
+ * envelope (the intent endpoints return `{data: [...]}`, `{data: {items}}`, `{data: {rows}}` or a bare
+ * `{rows}` depending on the route), and the row types the screens read.
+ * Every field is optional: intent payloads are open-shaped and grow with the corpus.
+ */
+
+export interface IntentKeywordRow {
+  id: string;
+  keyword: string;
+  total_resolved_contacts?: number;
+  total_resolved_companies?: number;
+  total_urls?: number;
+  auto_sync_enabled?: boolean;
+  signal_type?: string;
+  is_active?: boolean;
+}
+
+export interface PersonaCoverage {
+  category?: string;
+  barometer?: string;
+  signal_count?: number;
+  contact_count?: number;
+}
+
+export interface KeywordSignal {
+  keyword_id?: string;
+  keyword?: string;
+  signal_count?: number;
+}
+
+/** One scored account from `GET /intent/abm/companies` and `POST /intent/abm/rollup`. */
+export interface AbmAccount {
+  company_id?: number | null;
+  global_company_id?: string | null;
+  company_name?: string | null;
+  company_domain?: string | null;
+  industry?: string | null;
+  employee_count?: number | string | null;
+  logo_url?: string | null;
+  account_strength?: string | null;
+  is_high_intent?: boolean;
+  persona_coverage?: Record<string, PersonaCoverage>;
+  top_keywords?: KeywordSignal[];
+  trend_pct?: number | null;
+  total_signal_count?: number;
+  latest_signal_date?: string | null;
+}
+
+/** Rows of a list response, whichever way the route wraps them. */
+export function rowsOf<T>(envelope: unknown): T[] {
+  const env = envelope as Record<string, unknown> | null | undefined;
+  const data = (env?.data ?? env) as unknown;
+  if (Array.isArray(data)) return data as T[];
+  const obj = data as Record<string, unknown> | null | undefined;
+  for (const key of ["items", "rows", "keywords", "companies", "data"]) {
+    if (Array.isArray(obj?.[key])) return obj![key] as T[];
+  }
+  return [];
+}
+
+/** The total the API reports for a list, when it reports one. */
+export function totalOf(envelope: unknown): number | undefined {
+  const env = envelope as Record<string, unknown> | null | undefined;
+  const data = env?.data as Record<string, unknown> | undefined;
+  const pagination = env?.pagination as { total?: number } | undefined;
+  const candidates = [data?.total, pagination?.total, env?.total];
+  return candidates.find((v): v is number => typeof v === "number");
+}
+
+/** `{ "<company id>": rollup }` out of the rollup response (`data.rollups`). */
+export function rollupsOf(envelope: unknown): Record<string, AbmAccount> {
+  const data = (envelope as { data?: { rollups?: Record<string, AbmAccount> } } | null)?.data;
+  return data?.rollups ?? {};
+}
+
+export function formatDate(value: string | null | undefined): string {
+  if (!value) return "-";
+  // A date-only value is a calendar day, not an instant: read and show it in UTC so no zone shifts it.
+  const dateOnly = /^\d{4}-\d{2}-\d{2}$/.test(value);
+  const date = new Date(dateOnly ? `${value}T00:00:00Z` : value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleDateString(undefined, dateOnly ? { timeZone: "UTC" } : undefined);
+}
+
+/** Tailwind classes for an account-strength label. Unknown labels stay neutral. */
+export function strengthClass(strength: string | null | undefined): string {
+  const s = (strength ?? "").toLowerCase();
+  if (s.includes("strong") || s === "high") return "bg-green-100 text-green-800";
+  if (s.includes("moderate") || s === "medium") return "bg-amber-100 text-amber-800";
+  if (s.includes("weak") || s === "low") return "bg-gray-100 text-gray-700";
+  return "bg-gray-100 text-gray-700";
+}

package/blocks/intent/recipes/rank-intent-accounts.ts

@@ -0,0 +1,36 @@
+/**
+ * @title Rank accounts by buying intent
+ * @when Building a "who to call today" list. Reads only (no spend). The ABM feed returns one scored row per
+ * company; `company_id` is the global id the rollup endpoint takes. Needs the ABM feature on for the org.
+ */
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+
+interface AbmRow {
+  company_id?: number | null;
+  company_name?: string | null;
+  company_domain?: string | null;
+  is_high_intent?: boolean;
+  total_signal_count?: number;
+}
+
+export async function topIntentAccounts(days = 30, limit = 50) {
+  // The feed returns at most 500 rows a page, and the rollup takes at most 500 ids.
+  limit = Math.min(Math.max(1, limit), 500);
+  const feed = await g8.api.signals.listAbmCompanies({ query: { days, limit } });
+  const payload = feed.data as { items?: AbmRow[] } | undefined;
+  const rows = payload?.items ?? [];
+  const ids = rows.map((r) => r.company_id).filter((id): id is number => typeof id === "number");
+
+  if (ids.length === 0) return [];
+
+  // Fresh rollup for exactly these companies (up to 500 per call; an empty list is rejected, hence the guard above).
+  const rollup = await g8.api.signals.rollupAbmCompanies({ body: { company_ids: ids, days } });
+  const rollups = (rollup.data as { rollups?: Record<string, AbmRow> } | undefined)?.rollups ?? {};
+
+  return rows
+    .map((r) => ({ ...r, ...(r.company_id != null ? rollups[String(r.company_id)] : {}) }))
+    .filter((r) => r.is_high_intent)
+    .sort((a, b) => (b.total_signal_count ?? 0) - (a.total_signal_count ?? 0));
+}

package/blocks/intent/recipes/track-competitor-domain.ts

@@ -0,0 +1,23 @@
+/**
+ * @title Track a competitor's website and read who visits it
+ * @when Starting competitor intent. Preview first (nothing saved), show the counts to a human, then save.
+ * Both calls are tier `billable`: confirm before the second one. The saved keyword's `keyword_id` feeds the
+ * companies lookup.
+ */
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+
+export async function trackCompetitor(domain: string, humanApproved: boolean) {
+  const preview = await g8.api.intent.keywordsCreateFromDomain({ body: { domain, dry_run: true } });
+  console.log("Would seed", preview.data?.pages_seeded, "pages and", preview.data?.contacts_seeded, "people");
+  if (!humanApproved) return { saved: false as const, preview: preview.data };
+
+  const saved = await g8.api.intent.keywordsCreateFromDomain({ body: { domain, dry_run: false } });
+  const keywordId = saved.data?.keyword_id;
+  if (!keywordId) throw new Error(`Nothing was saved: ${saved.data?.message ?? "no keyword_id returned"}`);
+
+  // This route's response is open-shaped (no typed schema), so narrow it yourself.
+  const companies = (await g8.api.intent.keywordCompanies({ path: { keyword_id: keywordId }, body: { limit: 50 } })) as { data?: unknown };
+  return { saved: true as const, keywordId, companies: companies.data };
+}

package/blocks/intent/recipes/who-visited-url.ts

@@ -0,0 +1,18 @@
+/**
+ * @title List the companies whose people visited one URL
+ * @when Checking interest in a single page (a competitor pricing page, your own landing page). Read tier,
+ * free. The route answers with a bare aggregate rather than a `{ data }` envelope, so read `companies` off
+ * the result directly.
+ */
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+
+export async function whoVisited(url: string, days = 30) {
+  const res = await g8.intent.urlCompanies(url, { days, limit: 50 });
+  return {
+    total: res.total_companies,
+    b2b: res.b2b_count,
+    companies: res.companies.map((c) => ({ name: c.name, domain: c.domain, visits: c.visit_count, people: c.contacts_seen })),
+  };
+}

package/blocks/lifecycle/README.md

@@ -0,0 +1,79 @@
+# lifecycle: revenue lifecycle
+
+Suspects, Leads, Trial, Customers and Churned as editable React screens. Install with `npx @graph8/sdk add lifecycle`.
+These five are ONE parametrised view keyed by stage, not five features: the stages come from `GET /lifecycle-stages`
+(custom stages work too).
+
+| Component | What it is |
+|---|---|
+| `LifecycleBoard` | One column per stage with counts, the companies in it, and Move. |
+| `StageMoveDialog` | Move a company (dry run first) or a contact to another stage. Used by the others. |
+| `LeadQueue` | Contacts in one stage (Leads by default): search, masked details, billable unlock, move. |
+| `CustomerTable` | Customers with MRR, headline counts, and an AI account brief. |
+| `ChurnList` | Churned companies, last MRR, on-demand activity check, win-back to Leads. |
+| `useLifecycleStages` (hook) | Stages and their counts. |
+
+## Flow, in order (and the ids passed between steps)
+
+1. `GET /lifecycle-stages` -> each stage has `id` (entry id) and `slug` (`suspects`, `leads`, `trials`, `customers`, `churned`).
+2. `GET /lifecycle-stages/counts` -> `{ <stage id>: count }`. **Keyed by entry id, not slug**; `lib/lifecycle.ts countFor` joins them.
+3. `GET /lifecycle-stages/{slug}/records?page&limit` -> companies: `company_id` (= `mashup_companies.id`, the id `GET /companies/{id}` takes), name, domain, `mrr_cents`, `subscription_status`.
+4. Move: `POST /companies/{company_id}/lifecycle-stage` with `{ target_slug, dry_run: true }` first, then without `dry_run`. Contacts: `POST /contacts/{id}/lifecycle-stage` (no dry run).
+   The API refuses Customers without an active subscription and Churned for a company that never was a customer; the dry run shows that before the click.
+5. Contacts of a stage: `GET /lifecycle-contacts?lifecycle_id=<stage entry id>` -> `contacts[]`. Locked emails are `"***"`.
+   `POST /lifecycle-contacts/unlock { lifecycle_id, contact_ids }` **charges credits per newly unlocked contact** (billable, confirmed).
+6. Customer brief: `GET /customer-success/companies/{company_id}/brief` (free); `POST .../brief/synthesize` runs a model (billable, confirmed).
+
+Money is cents. Contact-level stage membership has no counts endpoint, so the contact queue shows `total` from the list call.
+
+## Mounting
+
+```tsx
+import { LifecycleBoard } from "@/components/g8/lifecycle/components/lifecycle-board";
+export default function Board() { return <LifecycleBoard onOpenCompany={(id) => router.push(`/companies/${id}`)} />; }
+```
+
+Link `onOpenCompany` / `onOpenContact` to the crm block's CompanyDetail / ContactDetail routes.
+
+## Prerequisites
+
+- `foundation` installed (and `crm` for the detail routes); proxy `allowedPrefixes` include `lifecycle-stages`, `lifecycle-contacts`, `companies`, `contacts`, `accounts`, `customer-success`.
+- `where: "api"`: lifecycle stages exist (the five ship seeded).
+- `where: "app"`: a billing source (Stripe) connected if Customers and MRR should fill in.
+
+## Defaults the agent should use without asking
+
+- Win-back moves a company to **Leads**. 25 rows per column or page. Always dry-run company moves.
+
+## Ask the person first
+
+- **Unlocking contacts** (credits) and **rewriting a customer brief** (credits).
+
+## Known limits
+
+- `leads.*` operations (`generateLeadContent`, `removeLeads`) take lead ids from list membership, not company ids from stage records, so they are not wired into these screens.
+- Stage configuration (renaming or adding stages) is not in the API; it is edited in the graph8 app.
+- `CustomerTable` shows MRR for the current page only: there is no total-MRR field on the records route.
+
+## Operations
+
+| SDK method (`g8.api.*`) | Route | Tier | Scope |
+|---|---|---|---|
+| `listLifecycleStages` | GET `/api/v1/lifecycle-stages` | read | `deals:read` |
+| `getLifecycleStageCounts` | GET `/api/v1/lifecycle-stages/counts` | read | `deals:read` |
+| `listLifecycleStageRecords` | GET `/api/v1/lifecycle-stages/{stage}/records` | read | `deals:read` |
+| `moveCompanyLifecycleStage` | POST `/api/v1/companies/{company_id}/lifecycle-stage` | write | `deals:write` |
+| `moveContactLifecycleStage` | POST `/api/v1/contacts/{contact_id}/lifecycle-stage` | write | `deals:write` |
+| `listLifecycleContacts` | GET `/api/v1/lifecycle-contacts` | read | `deals:read` |
+| `unlockLifecycleContacts` | POST `/api/v1/lifecycle-contacts/unlock` | billable | `deals:run` |
+| `getRevenueSummary` | GET `/api/v1/accounts/revenue-summary` | read | `companies:read` |
+| `getBrief` | GET `/api/v1/customer-success/companies/{company_id}/brief` | read | `companies:read` |
+| `synthesizeBrief` | POST `/api/v1/customer-success/companies/{company_id}/brief/synthesize` | billable | `knowledge:run` |
+| `getAccountIntentSignals` | GET `/api/v1/accounts/{account_id}/intent-signals` | read | `companies:read` |
+
+## Recipes
+
+- `recipes/read-lifecycle-board.ts`: Read the lifecycle board: stages, counts and who is in each
+- `recipes/move-company-stage.ts`: Move a company to another lifecycle stage, checking first
+- `recipes/unlock-stage-contacts.ts`: List a stage's contacts and unlock their details
+- `recipes/customer-brief.ts`: Read a customer's brief, and rewrite it when it is stale

package/blocks/lifecycle/block.json

@@ -0,0 +1,198 @@
+{
+  "$schema": "../block.schema.json",
+  "id": "lifecycle",
+  "title": "Revenue lifecycle",
+  "summary": "Suspects, leads, trial, customers and churned as a stage board, a contact queue, a customer book and a win-back list.",
+  "features": [
+    "stage board with counts and a checked stage move",
+    "contact queue with masked details and billable unlock",
+    "customer table with MRR and AI account briefs",
+    "churn list with win-back"
+  ],
+  "dependsOn": [
+    "crm"
+  ],
+  "operations": [
+    "list_lifecycle_stages_lifecycle_stages_get",
+    "get_lifecycle_stage_counts_lifecycle_stages_counts_get",
+    "list_lifecycle_stage_records_lifecycle_stages__stage__records_get",
+    "move_company_lifecycle_stage_companies__company_id__lifecycle_stage_post",
+    "move_contact_lifecycle_stage_contacts__contact_id__lifecycle_stage_post",
+    "list_lifecycle_contacts_lifecycle_contacts_get",
+    "unlock_lifecycle_contacts_lifecycle_contacts_unlock_post",
+    "get_revenue_summary_accounts_revenue_summary_get",
+    "get_brief_customer_success_companies__company_id__brief_get",
+    "synthesize_brief_customer_success_companies__company_id__brief_synthesize_post",
+    "get_account_intent_signals_accounts__account_id__intent_signals_get"
+  ],
+  "components": [
+    {
+      "name": "LifecycleBoard",
+      "file": "components/lifecycle-board.tsx",
+      "purpose": "One column per lifecycle stage with counts, the companies in each, and a Move action on every card.",
+      "operations": [
+        "list_lifecycle_stages_lifecycle_stages_get",
+        "get_lifecycle_stage_counts_lifecycle_stages_counts_get",
+        "list_lifecycle_stage_records_lifecycle_stages__stage__records_get",
+        "move_company_lifecycle_stage_companies__company_id__lifecycle_stage_post"
+      ],
+      "tiers": [
+        "read",
+        "write"
+      ]
+    },
+    {
+      "name": "StageMoveDialog",
+      "file": "components/stage-move-dialog.tsx",
+      "purpose": "Move a company (dry run first) or a contact to another lifecycle stage.",
+      "operations": [
+        "move_company_lifecycle_stage_companies__company_id__lifecycle_stage_post",
+        "move_contact_lifecycle_stage_contacts__contact_id__lifecycle_stage_post"
+      ],
+      "tiers": [
+        "write"
+      ]
+    },
+    {
+      "name": "LeadQueue",
+      "file": "components/lead-queue.tsx",
+      "purpose": "Contacts in one stage as a work queue: search, masked details, billable unlock behind a confirm, and move.",
+      "operations": [
+        "list_lifecycle_stages_lifecycle_stages_get",
+        "list_lifecycle_contacts_lifecycle_contacts_get",
+        "unlock_lifecycle_contacts_lifecycle_contacts_unlock_post",
+        "move_contact_lifecycle_stage_contacts__contact_id__lifecycle_stage_post"
+      ],
+      "tiers": [
+        "read",
+        "write",
+        "billable"
+      ]
+    },
+    {
+      "name": "CustomerTable",
+      "file": "components/customer-table.tsx",
+      "purpose": "Customers with MRR, headline counts, and an account brief that can be rewritten with AI behind a confirm.",
+      "operations": [
+        "get_revenue_summary_accounts_revenue_summary_get",
+        "list_lifecycle_stage_records_lifecycle_stages__stage__records_get",
+        "get_brief_customer_success_companies__company_id__brief_get",
+        "synthesize_brief_customer_success_companies__company_id__brief_synthesize_post"
+      ],
+      "tiers": [
+        "read",
+        "billable"
+      ]
+    },
+    {
+      "name": "ChurnList",
+      "file": "components/churn-list.tsx",
+      "purpose": "Churned companies with last MRR, an on-demand activity check, and a win-back move to Leads.",
+      "operations": [
+        "list_lifecycle_stages_lifecycle_stages_get",
+        "list_lifecycle_stage_records_lifecycle_stages__stage__records_get",
+        "get_account_intent_signals_accounts__account_id__intent_signals_get",
+        "move_company_lifecycle_stage_companies__company_id__lifecycle_stage_post"
+      ],
+      "tiers": [
+        "read",
+        "write"
+      ]
+    }
+  ],
+  "hooks": [
+    {
+      "name": "useLifecycleStages",
+      "file": "hooks/use-lifecycle-stages.ts",
+      "purpose": "The configured lifecycle stages and their company counts (counts are keyed by stage id).",
+      "operations": [
+        "list_lifecycle_stages_lifecycle_stages_get",
+        "get_lifecycle_stage_counts_lifecycle_stages_counts_get"
+      ]
+    },
+    {
+      "name": "useDebounced",
+      "file": "hooks/use-debounced.ts",
+      "purpose": "Debounce a fast-changing value (search boxes)."
+    }
+  ],
+  "lib": [
+    {
+      "file": "lib/lifecycle.ts",
+      "purpose": "Types and helpers: stage and record shapes, counts by stage id, money in cents, masked-value check."
+    }
+  ],
+  "recipes": [
+    {
+      "file": "recipes/read-lifecycle-board.ts",
+      "title": "Read the lifecycle board: stages, counts and who is in each",
+      "when": "A stage overview or report is needed; free, counts are keyed by stage id."
+    },
+    {
+      "file": "recipes/move-company-stage.ts",
+      "title": "Move a company to another lifecycle stage, checking first",
+      "when": "A company changes stage; dry run first because some moves are refused."
+    },
+    {
+      "file": "recipes/unlock-stage-contacts.ts",
+      "title": "List a stage's locked contacts, then unlock the ones the person chose",
+      "when": "Real emails and phones are needed; billable per newly unlocked contact."
+    },
+    {
+      "file": "recipes/customer-brief.ts",
+      "title": "Read a customer's brief, and rewrite it when it is stale",
+      "when": "Before a renewal or check-in; rewriting runs a model and spends credits."
+    }
+  ],
+  "prerequisites": [
+    {
+      "id": "stages-configured",
+      "description": "The workspace has its lifecycle stages configured (Suspects, Leads, Trial, Customers, Churned ship by default).",
+      "where": "api",
+      "verify": "GET /lifecycle-stages returns the five seeded stages."
+    },
+    {
+      "id": "billing-connected",
+      "description": "Customers and MRR come from a connected billing source (Stripe); without one the Customers stage stays empty and moves to Customers are refused.",
+      "where": "app",
+      "verify": "GET /lifecycle-stages/customers/records returns companies with subscription_status."
+    }
+  ],
+  "scopes": [
+    "companies:read",
+    "deals:read",
+    "deals:run",
+    "deals:write",
+    "knowledge:run"
+  ],
+  "defaults": [
+    {
+      "decision": "Which stage a win-back moves a company to",
+      "default": "Leads",
+      "askHuman": false
+    },
+    {
+      "decision": "Unlock contact details",
+      "default": "Never unlock automatically; list first, show how many are locked, unlock only what the person selected",
+      "askHuman": true
+    },
+    {
+      "decision": "Rewrite a customer brief with AI",
+      "default": "Only when missing or older than the person's threshold; the UI always confirms",
+      "askHuman": true
+    },
+    {
+      "decision": "Rows per column or page",
+      "default": "25",
+      "askHuman": false
+    },
+    {
+      "decision": "Where a company or contact click goes",
+      "default": "The crm block's CompanyDetail / ContactDetail routes",
+      "askHuman": false
+    }
+  ],
+  "peerDependencies": {
+    "react": ">=18"
+  }
+}

package/blocks/lifecycle/components/churn-list.tsx

@@ -0,0 +1,92 @@
+"use client";
+
+/**
+ * ChurnList: companies in the Churned stage, what they were worth, and a win-back action.
+ *
+ * SDK operations, in the order the screen uses them:
+ *   1. listLifecycleStages        GET  /lifecycle-stages                                 (read)
+ *   2. listLifecycleStageRecords  GET  /lifecycle-stages/churned/records?page&limit      (read)
+ *   3. getAccountIntentSignals    GET  /accounts/{account_id}/intent-signals?limit        (read; on click: is the account active again?)
+ *   4. moveCompanyLifecycleStage  POST /companies/{company_id}/lifecycle-stage           (write; win back = move to Leads)
+ *
+ * "Win back" is only a stage change: it puts the company back in front of the team. It sends nothing. Starting a
+ * win-back sequence is a separate step with the sequencer block (enrolling is `external` tier there).
+ * The intent lookup uses the company id as the account id, which is how the revenue routes key accounts.
+ */
+
+import { useState } from "react";
+import { Button, Skeleton, Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@graph8/sdk/ui";
+import { g8Get } from "@/g8/lib/g8-client";
+import { useG8Query } from "@/g8/hooks/use-g8-query";
+import { ApiError } from "@/g8/components/api-error";
+import { EmptyState } from "@/g8/components/empty-state";
+import { useLifecycleStages } from "../hooks/use-lifecycle-stages";
+import { asRec, body, findStage, money, text } from "../lib/lifecycle";
+import type { CompanyRecord } from "../lib/lifecycle";
+import { StageMoveDialog } from "./stage-move-dialog";
+
+export interface ChurnListProps {
+  stageSlug?: string;
+  /** Slug a win-back moves a company to. Defaults to "leads". */
+  winBackSlug?: string;
+  onOpenCompany?: (companyId: number) => void;
+  pageSize?: number;
+  className?: string;
+}
+
+/** Loaded on click: one call per row up front would be 25 calls for a page the person may only skim. */
+function Intent({ companyId }: { companyId: number }) {
+  const [asked, setAsked] = useState(false);
+  const q = useG8Query((signal) => g8Get(`/accounts/${companyId}/intent-signals`, { limit: 20 }, { signal }), [companyId], { enabled: asked });
+  if (!asked) return <Button size="sm" variant="ghost" aria-label={`Check activity for ${companyId}`} onClick={() => setAsked(true)}>Check</Button>;
+  if (q.loading) return <Skeleton className="h-4 w-16" />;
+  if (q.error) return <span className="text-muted-foreground text-xs">n/a</span>;
+  const payload = body(q.data);
+  const signals = Array.isArray(payload) ? payload : Array.isArray(asRec(payload).signals) ? (asRec(payload).signals as unknown[]) : [];
+  return <span className="text-xs">{signals.length ? `${signals.length} recent signals` : "Quiet"}</span>;
+}
+
+export function ChurnList({ stageSlug = "churned", winBackSlug = "leads", onOpenCompany, pageSize = 25, className }: ChurnListProps) {
+  const { stages } = useLifecycleStages();
+  const [page, setPage] = useState(1);
+  const [winning, setWinning] = useState<CompanyRecord | null>(null);
+  const list = useG8Query((signal) => g8Get(`/lifecycle-stages/${encodeURIComponent(stageSlug)}/records`, { page, limit: pageSize }, { signal }), [stageSlug, page, pageSize]);
+  const rows = (Array.isArray(body(list.data)) ? body(list.data) : []) as CompanyRecord[];
+  const total = (asRec(asRec(list.data).pagination).total as number | undefined) ?? rows.length;
+  const lost = rows.reduce((sum, r) => sum + (r.mrr_cents ?? 0), 0);
+  const target = findStage(stages, winBackSlug);
+
+  return (
+    <div className={className}>
+      {list.error ? <ApiError error={list.error} onRetry={() => void list.refetch()} /> : null}
+      {list.loading && !list.data ? <div className="space-y-2" aria-busy="true">{[0, 1, 2].map((i) => <Skeleton key={i} className="h-10 w-full" />)}</div> : !list.error && rows.length === 0 ? (
+        <EmptyState title="No churned accounts" description="Companies that cancel move here, with what they were paying." />
+      ) : (
+        <Table>
+          <TableHeader><TableRow><TableHead>Company</TableHead><TableHead className="text-right">Last MRR</TableHead><TableHead>Activity</TableHead><TableHead className="text-right">Actions</TableHead></TableRow></TableHeader>
+          <TableBody>
+            {rows.map((r) => (
+              <TableRow key={r.company_id}>
+                <TableCell><button type="button" className="font-medium hover:underline" onClick={() => onOpenCompany?.(r.company_id)}>{r.name || r.domain || `Company ${r.company_id}`}</button><div className="text-muted-foreground text-xs">{text(r.industry)}</div></TableCell>
+                <TableCell className="text-right">{money(r.mrr_cents)}</TableCell>
+                <TableCell><Intent companyId={r.company_id} /></TableCell>
+                <TableCell className="text-right"><Button size="sm" variant="outline" disabled={!target} onClick={() => setWinning(r)}>Win back</Button></TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      )}
+      <div className="mt-3 flex items-center justify-between text-sm">
+        <span className="text-muted-foreground">{total.toLocaleString()} churned · {money(lost)} MRR lost on this page</span>
+        <div className="flex gap-2">
+          <Button size="sm" variant="outline" disabled={page === 1} onClick={() => setPage(page - 1)}>Previous</Button>
+          <Button size="sm" variant="outline" disabled={page * pageSize >= total} onClick={() => setPage(page + 1)}>Next</Button>
+        </div>
+      </div>
+      {winning && target ? (
+        <StageMoveDialog kind="company" recordId={winning.company_id} recordName={winning.name ?? `company ${winning.company_id}`} currentSlug={stageSlug} stages={stages}
+          defaultTargetSlug={target.slug} onClose={() => setWinning(null)} onMoved={() => { setWinning(null); void list.refetch(); }} />
+      ) : null}
+    </div>
+  );
+}