@graph8/sdk 0.373.0 → 0.374.0

package/blocks/enrichment/components/pipeline-templates.tsx

@@ -0,0 +1,90 @@
+"use client";
+
+/**
+ * PipelineTemplates: pick a ready-made pipeline for a list (for example "Find + verify missing emails") and add it.
+ * The catalog is filtered by the API to the recipes that fit this list's kind (people or companies).
+ *
+ * SDK operations, in order:
+ *   1. listPipelineTemplates          GET  /enrichment/lists/pipeline-templates?list_id   (read, free)  recipes + whether the workspace has a
+ *        qualification template (recipes that score records first need one)
+ *   2. createListPipelineFromTemplate POST /enrichment/lists/{list_id}/pipelines/from-template { template_key }   (write, free)
+ *        saves the recipe TURNED OFF and creates any columns it needs. Adding a recipe the list already has REPLACES that
+ *        pipeline's steps with the recipe's (it is saved by name), so that case goes through ConfirmSpendDialog (destructive).
+ *
+ * Nothing runs or charges here: open the new pipeline to price and run it.
+ */
+
+import { useState } from "react";
+import { Button } from "@graph8/sdk/ui";
+import { ApiError } from "@/g8/components/api-error";
+import { ConfirmSpendDialog } from "@/g8/components/confirm-spend-dialog";
+import { EmptyState } from "@/g8/components/empty-state";
+import { FormSheet } from "@/g8/components/screen/form-sheet";
+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, g8Post } from "@/g8/lib/g8-client";
+import { itemsOf, templateExists } from "../lib/pipeline-types";
+import type { ListPipeline, PipelineTemplate } from "../lib/pipeline-types";
+
+export interface PipelineTemplatesProps {
+  listId: number;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  /** The pipelines already on the list, to warn before a recipe replaces one. */
+  existing: ListPipeline[];
+  /** Called with the saved pipeline. */
+  onAdded: (pipeline: ListPipeline) => void;
+}
+
+interface Catalog { items?: PipelineTemplate[]; has_qualification_templates?: boolean }
+
+export function PipelineTemplates({ listId, open, onOpenChange, existing, onAdded }: PipelineTemplatesProps) {
+  const [replacing, setReplacing] = useState<PipelineTemplate | null>(null);
+  const [working, setWorking] = useState<string | null>(null);
+  const catalog = useG8Query(async (signal) => (await g8Get<Catalog>("/enrichment/lists/pipeline-templates", { list_id: listId }, { signal })).data, [listId], { enabled: open });
+  const add = useG8Mutation(
+    async (t: PipelineTemplate) => (await g8Post<ListPipeline>(`/enrichment/lists/${listId}/pipelines/from-template`, { template_key: t.key })).data,
+    { onSuccess: (p) => { setReplacing(null); setWorking(null); onAdded(p); onOpenChange(false); }, onError: () => { setWorking(null); setReplacing(null); } },
+  );
+  const templates = itemsOf<PipelineTemplate>(catalog.data);
+  const hasQualification = catalog.data?.has_qualification_templates === true;
+  const choose = (t: PipelineTemplate) => {
+    if (templateExists(t, existing)) { setReplacing(t); return; }
+    setWorking(t.key);
+    void add.mutate(t);
+  };
+
+  return (
+    <FormSheet open={open} onOpenChange={onOpenChange} title="Start from a template" description="Ready-made pipelines for this list. They are saved turned off; nothing runs until you run one." width="lg"
+      footer={<Button type="button" variant="outline" onClick={() => onOpenChange(false)}>Close</Button>}>
+      {catalog.error ? <ApiError error={catalog.error} title="Could not load templates" onRetry={() => void catalog.refetch()} /> : null}
+      {catalog.loading && !catalog.data ? <p className="text-sm text-muted-foreground">Loading templates...</p> : null}
+      {!catalog.loading && !catalog.error && templates.length === 0 ? <EmptyState title="No templates for this list" description="The API has no ready-made pipeline for this kind of list." /> : null}
+      {add.error ? <ApiError error={add.error} title="Could not add the template" /> : null}
+      <ul className="flex flex-col gap-3">
+        {templates.map((t) => {
+          const needsQualification = t.requires_qualification && !hasQualification;
+          return (
+            <li key={t.key} className="rounded-md border p-3" data-testid="template">
+              <div className="flex items-start justify-between gap-3">
+                <div className="min-w-0">
+                  <p className="text-sm font-medium">{t.name}</p>
+                  <p className="text-xs text-muted-foreground">{t.description}</p>
+                  <ol className="mt-2 flex flex-wrap gap-1" aria-label={`${t.name} steps`}>{t.step_names.map((n, i) => <li key={`${n}-${i}`}><StatusPill tone="neutral">{i + 1}. {n}</StatusPill></li>)}</ol>
+                  {needsQualification ? <p className="mt-2 text-xs text-warning-foreground">Needs a qualification template, and this workspace has none yet.</p> : null}
+                  {templateExists(t, existing) ? <p className="mt-2 text-xs text-muted-foreground">This list already has it. Adding it again resets its steps to the recipe.</p> : null}
+                </div>
+                <Button type="button" size="sm" variant="outline" disabled={needsQualification || working != null} loading={working === t.key} aria-label={`Add ${t.name}`} onClick={() => choose(t)}>{templateExists(t, existing) ? "Reset" : "Add"}</Button>
+              </div>
+            </li>
+          );
+        })}
+      </ul>
+      <ConfirmSpendDialog open={replacing != null} tier="destructive" title={`Reset "${replacing?.name ?? ""}" to the template`}
+        description="The pipeline's steps are replaced with the template's. Any edits you made to its steps are lost. Values it already wrote stay on the records."
+        affected={1} confirmLabel="Reset pipeline" confirming={add.loading}
+        onConfirm={() => replacing && void add.mutate(replacing)} onCancel={() => setReplacing(null)} />
+    </FormSheet>
+  );
+}

package/blocks/enrichment/lib/enrichment-types.ts

@@ -104,6 +104,7 @@ export interface EnrichJob {
   successful_enrichments?: number | null;
   failed_enrichments?: number | null;
   total_credits_used?: number | null;
+  paused_at?: string | null;
   warnings?: string[] | null;
   provider_errors?: Array<{ record_id?: number; provider?: string; error?: string }> | null;
 }
@@ -129,6 +130,17 @@ export function isJobTerminal(status: string | undefined | null): boolean {
 }
 
 /**
+ * The API's own quote for a run (`max_total_credits` from the preflight), or null when it could not price it. Null means
+ * "no total": callers show that, never a made-up number.
+ */
+export function quotedCredits(preflight: Pick<Preflight, "max_total_credits"> | undefined): number | null {
+  return preflight?.max_total_credits ?? null;
+}
+
+/**
+ * @deprecated Guesses 2 credits per record when the preflight cannot price a run, which is an invented price. The bulk panel
+ * no longer uses it (see `quotedCredits`); kept exported so existing imports keep working.
+ *
  * What to show as the cost of a run: the API's own quote when the preflight priced it, otherwise the flat
  * per-record estimate times the contacts that are really on the list. Never a balance.
  */

package/blocks/enrichment/lib/pipeline-types.ts

@@ -0,0 +1,234 @@
+"use client";
+
+/**
+ * Shapes and pure helpers for list pipelines, auto-enrichment and the enrichment activity view.
+ *
+ * Everything here is read off the API's own responses (enrichment/interfaces/fastapi/list_pipelines_router.py,
+ * auto_enrichment_router.py, router.py). The contract types these payloads as open objects, so the shapes below are the
+ * handlers' documented fields; a field the API leaves out is `undefined`/`null` here and the UI shows a dash, never a
+ * guessed default.
+ *
+ * No prices live here: the cost of a pipeline run is whatever `POST .../estimate` answers for that exact list and
+ * pipeline (`required_credits`, an upper bound that ignores run conditions).
+ */
+
+/** The step kinds a saved pipeline step can have. */
+export type StepType = "ai" | "waterfall";
+
+export interface PipelineStep {
+  id: string;
+  name?: string;
+  type: StepType;
+  config_ref: string;
+  run_condition?: string | null;
+  skip_existing_values?: boolean;
+  skip_recently_enriched?: boolean;
+  enabled?: boolean;
+  ui_meta?: Record<string, unknown> | null;
+  [extra: string]: unknown;
+}
+
+export interface StepProgress {
+  step_index: number;
+  step_id?: string | null;
+  name?: string | null;
+  job_id?: string | null;
+  status?: string | null;
+  total_records?: number;
+  processed_records?: number;
+  successful?: number;
+  failed?: number;
+  skipped_by_reason?: Record<string, number>;
+  note?: string | null;
+}
+
+export interface PipelineRun {
+  run_id: string;
+  status: string;
+  current_index: number;
+  total_steps: number;
+  started_at?: string | null;
+  error?: string | null;
+  cancelled_by?: string | null;
+  step_progress?: StepProgress[];
+  /** Present on a run read by id (GET .../pipeline-runs/{run_id}). */
+  pipeline_id?: string;
+  pipeline_name?: string;
+  list_id?: number;
+  current_job_id?: string | null;
+}
+
+export interface ListPipeline {
+  id: string;
+  list_id: number;
+  name: string;
+  steps: PipelineStep[];
+  enabled: boolean;
+  created_at?: string | null;
+  last_run?: PipelineRun | null;
+}
+
+export interface PipelineEstimate {
+  can_run: boolean;
+  subscription_valid?: boolean;
+  estimated_evaluations: number;
+  required_credits: number;
+  available_credits: number;
+  reason?: string | null;
+  steps: Array<{ step_id: string; name: string; type: string; estimated_records: number; required_credits: number }>;
+}
+
+export interface StepOption {
+  type: StepType;
+  config_ref: string;
+  name: string;
+  is_qualification?: boolean;
+  qualification_entity?: string | null;
+  uses_existing_field?: boolean;
+  target_column_name?: string | null;
+}
+
+export interface PipelineTemplate {
+  key: string;
+  name: string;
+  description: string;
+  target_type: string;
+  requires_qualification: boolean;
+  step_names: string[];
+}
+
+export interface AutoConfig {
+  id: string;
+  audience_id: number;
+  enrichment_type: StepType;
+  column_id: string;
+  trigger_on_insert: boolean;
+  created_at?: string | null;
+  created_by?: string | null;
+}
+
+export const MERGE_RULES = ["sticky", "user_wins", "mashup_wins"] as const;
+export type MergeRule = (typeof MERGE_RULES)[number];
+
+/** What each merge rule does, from enrichment/usecases/apply_mashup_merge/handler.py. */
+export const MERGE_RULE_COPY: Record<MergeRule, { label: string; help: string }> = {
+  sticky: { label: "Keep edits, fill the rest", help: "Fields a person edited are left alone; every other field takes the matched value." },
+  user_wins: { label: "Never overwrite", help: "No matched value is copied onto the record." },
+  mashup_wins: { label: "Matched data wins", help: "Every field takes the matched value, including fields a person edited." },
+};
+
+export interface AutoSettings {
+  entity_type: "contact" | "company";
+  enabled: boolean;
+  default_rule: MergeRule;
+  per_field_overrides: Record<string, MergeRule>;
+  sync_policy_version?: number;
+}
+
+export interface JobControlResult {
+  job_id?: string;
+  success?: boolean;
+  message?: string;
+  previous_status?: string;
+  paused_at?: string;
+  resumed_at?: string;
+}
+
+/** The analytics windows the API accepts (anything else is a 422). */
+export const PERIODS = [
+  { value: "last_7_days", label: "Last 7 days" },
+  { value: "last_30_days", label: "Last 30 days" },
+  { value: "last_90_days", label: "Last 90 days" },
+  { value: "current_month", label: "This month" },
+  { value: "last_month", label: "Last month" },
+] as const;
+export type Period = (typeof PERIODS)[number]["value"];
+
+export const GRANULARITIES = ["day", "week", "month"] as const;
+export type Granularity = (typeof GRANULARITIES)[number];
+
+/** Rows of an open `{ items }` payload, or of a bare array; anything else is an empty list. */
+export function itemsOf<T>(data: unknown, key = "items"): T[] {
+  if (Array.isArray(data)) return data as T[];
+  const v = (data as Record<string, unknown> | null | undefined)?.[key];
+  return Array.isArray(v) ? (v as T[]) : [];
+}
+
+/** The only states a run never leaves (the app's useListPipelines treats everything else as in progress). */
+export const RUN_TERMINAL = ["completed", "failed", "cancelled"] as const;
+
+/**
+ * A run that can still change: poll it, offer Stop, block another Run. The backend creates every run as "pending", so
+ * "active" is "has a status and it is not terminal", never "equals running": a second run priced and confirmed while the
+ * first is pending would charge twice.
+ */
+export function runIsActive(status: string | null | undefined): boolean {
+  const s = String(status ?? "").toLowerCase();
+  return s !== "" && !(RUN_TERMINAL as readonly string[]).includes(s);
+}
+
+/** The pipeline's steps that will run (a disabled step is skipped). */
+export function enabledSteps(p: Pick<ListPipeline, "steps">): PipelineStep[] {
+  return p.steps.filter((s) => s.enabled !== false);
+}
+
+/** A unique, stable step id (1 to 64 characters) for a step added in the editor. */
+export function newStepId(taken: readonly string[]): string {
+  let n = taken.length + 1;
+  while (taken.includes(`step-${n}`)) n += 1;
+  return `step-${n}`;
+}
+
+/** A step for a picked config. Defaults mirror the API's own: fill only empty values, skip recently enriched records. */
+export function stepFromOption(option: StepOption, taken: readonly string[]): PipelineStep {
+  return { id: newStepId(taken), name: option.name, type: option.type, config_ref: option.config_ref, skip_existing_values: true, skip_recently_enriched: true, enabled: true };
+}
+
+/** Move the item at `index` by `delta` (clamped), returning a new array. */
+export function moveItem<T>(items: readonly T[], index: number, delta: number): T[] {
+  const to = index + delta;
+  if (to < 0 || to >= items.length) return [...items];
+  const next = [...items];
+  [next[index], next[to]] = [next[to], next[index]];
+  return next;
+}
+
+/** The body of a save: the name and the FULL step list (the API replaces steps), keeping every field of an edited step. */
+export function savePayload(name: string, steps: readonly PipelineStep[]): { name: string; steps: PipelineStep[] } {
+  return { name: name.trim(), steps: steps.map((s) => ({ ...s })) };
+}
+
+/** Did the editor change anything the API would store? */
+export function pipelineChanged(original: Pick<ListPipeline, "name" | "steps">, name: string, steps: readonly PipelineStep[]): boolean {
+  return original.name !== name.trim() || JSON.stringify(original.steps) !== JSON.stringify(steps);
+}
+
+/** The label of a step: its own name, else the name of the config it points at, else its kind. Never the raw id. */
+export function stepLabel(step: PipelineStep, options: readonly StepOption[]): string {
+  const hit = options.find((o) => o.config_ref === step.config_ref && o.type === step.type);
+  return step.name?.trim() || hit?.name || (step.type === "ai" ? "AI step" : "Provider waterfall step");
+}
+
+/** `n / total` as a whole percent, or null when there is nothing to divide by (shown as a dash, never 0%). */
+export function percentOf(part: number | null | undefined, total: number | null | undefined): number | null {
+  if (part == null || !total) return null;
+  return Math.min(100, Math.round((part / total) * 100));
+}
+
+/** The reason a run reads as "skipped" in plain words. */
+export function skipReasonLabel(reason: string): string {
+  if (reason === "run_condition_not_met") return "skipped by the step condition";
+  return reason.replace(/_/g, " ");
+}
+
+/** True when the pipeline named like this template already exists on the list (re-adding it replaces that pipeline's steps). */
+export function templateExists(template: Pick<PipelineTemplate, "name">, pipelines: readonly Pick<ListPipeline, "name">[]): boolean {
+  return pipelines.some((p) => p.name === template.name);
+}
+
+/** The most useful single sentence about why a pipeline cannot be run right now, or null when it can. */
+export function runBlockedReason(p: Pick<ListPipeline, "steps" | "last_run">): string | null {
+  if (enabledSteps(p).length === 0) return "Every step is turned off, so there is nothing to run.";
+  if (runIsActive(p.last_run?.status)) return "A run is already in progress.";
+  return null;
+}

package/blocks/forms/README.md

@@ -130,3 +130,5 @@ graph8 captures forms from your site; there is **no create-form operation in the
 New on `FormsScreen`: a **Groups** tab (`FormGroups`: create, rename, re-type, add and remove forms, delete), saved views (`FormSavedViews`), "Load more" past the first 100 forms, and on an open form: a **Routing** tab (`FormBackfill`: preview, then a confirmed delivery; `FormRouteHistory`: restore the previous route or stop routing, both destructive confirms that send the version they read), an **Activity** tab (`FormActivity`: audit trail and pages), and **Export CSV** on Submissions (`SubmissionsExport`, formula-safe, says when the file is not the whole set).
 
 Not covered (and why): `saveFormRoute` (the mapping editor's save already writes the route); `captureFormPreview` and `getFormPreview` return untyped image data; unidentified-form grouping (`previewUnidentifiedGrouping`, `setUnidentifiedGrouping`, `syncUnidentifiedGroup`) needs a list picker (owned by the pickers PR). The mapping editor's list select keeps its existing cap until that PR lands.
+
+Slot prop `renderSubmissionActions(submission, form)`: extra buttons on an opened submission, next to its delivery state. The submission carries no contact id, so the stack pages look the submitter up by the email in `form_data` (`ContactLookupLink`) and offer "Add to contacts" when nobody has it.

package/blocks/forms/components/forms-screen.tsx

@@ -66,6 +66,8 @@ import { useBrand } from "@/g8/hooks/use-brand";
 export interface FormsScreenProps {
   renderRowActions?: (form: FormListItem) => ReactNode;
   renderDetailActions?: (form: FormListItem) => ReactNode;
+  /** Extra buttons on an opened submission, next to its delivery state (open or add the person who submitted it). */
+  renderSubmissionActions?: (submission: FormSubmission, form: FormListItem) => ReactNode;
   extraDetailTabs?: { id: string; label: string; render: (form: FormListItem) => ReactNode }[];
   toolbarActions?: ReactNode;
   className?: string;
@@ -164,7 +166,7 @@ function SubmissionNotFound({ form, submissionId }: { form: FormRef; submissionI
 }
 
 /** One submission in full: every submitted field, where it came from, its delivery, and the trace. */
-function SubmissionDetail({ form, submission, onChanged }: { form: FormRef; submission: FormSubmission; onChanged: () => void }) {
+function SubmissionDetail({ form, submission, onChanged, actions }: { form: FormRef; submission: FormSubmission; onChanged: () => void; actions?: ReactNode }) {
   const [retrying, setRetrying] = useState(false);
   const trace = useG8Query(
     (signal) => g8Get<{ capture_state?: string; receipts?: unknown[] }>(`/forms/${encodeURIComponent(form.form_key)}/submissions/${encodeURIComponent(submission.id)}/trace`, { source_id: form.source_id }, { signal }).then((r) => r.data),
@@ -180,6 +182,7 @@ function SubmissionDetail({ form, submission, onChanged }: { form: FormRef; subm
         <StatusPill tone={failed ? "negative" : submissionState(submission) === "delivered" ? "positive" : "neutral"}>{submissionState(submission)}</StatusPill>
         {submission.is_test ? <StatusPill tone="info">Test</StatusPill> : null}
         {failed && submission.delivery?.receipt_id ? <Button size="sm" variant="outline" onClick={() => { retry.reset(); setRetrying(true); }}>Retry delivery</Button> : null}
+        {actions}
       </div>
       <SectionCard title="Submitted fields">
         {fields.length === 0 ? <p className="text-muted-foreground text-sm">No fields were captured. Identifying fields may be redacted for your key.</p> : (
@@ -218,7 +221,7 @@ function SubmissionDetail({ form, submission, onChanged }: { form: FormRef; subm
   );
 }
 
-export function FormsScreen({ renderRowActions, renderDetailActions, extraDetailTabs, toolbarActions, className }: FormsScreenProps) {
+export function FormsScreen({ renderRowActions, renderDetailActions, renderSubmissionActions, extraDetailTabs, toolbarActions, className }: FormsScreenProps) {
   const brand = useBrand();
   const [tabParam, setTabParam] = useUrlState("tab", "forms");
   const tab: Tab = tabParam === "install" || tabParam === "audit" || tabParam === "groups" ? tabParam : "forms";
@@ -369,7 +372,7 @@ export function FormsScreen({ renderRowActions, renderDetailActions, extraDetail
       >
         {selected && submissionId ? (
           linkedSubmission ? (
-            <SubmissionDetail key={submissionId} form={selected} submission={linkedSubmission} onChanged={() => setSubsRefresh((n) => n + 1)} />
+            <SubmissionDetail key={submissionId} form={selected} submission={linkedSubmission} onChanged={() => setSubsRefresh((n) => n + 1)} actions={renderSubmissionActions?.(linkedSubmission, selected)} />
           ) : lookup.error ? (
             <ApiError error={lookup.error} title="Could not load this submission" onRetry={() => void lookup.refetch()} />
           ) : lookup.loading || !lookup.data ? (

package/blocks/inbox/README.md

@@ -24,6 +24,21 @@ Defaults are unchanged from this release: both are on.
 
 Every detail opens as a full page with `&view=full` (the Open full page button).
 
+**Management (new, on by default; `showManagement={false}` hides the three buttons).** The toolbar gains:
+
+- **New message** (`ComposeMessage`): write a NEW email or text. The sender is never defaulted: you choose a mailbox
+  (from `GET /inbox/mailboxes/paginated`; ones you may not send as are listed disabled with the reason) or an SMS number,
+  and the confirm dialog names it ("from hamza@acme.com to maya@northwind.io, 2 recipients"). Sending is **external**.
+- **Search all** (`InboxSearch`): server-side search of every email thread (across all your mailboxes) or LinkedIn
+  conversation, beyond the page the list loaded; pick a result to open it. SMS has no search route in the API. A LinkedIn result opens by the row's conversation id (`conversation_id`, else `id`); that this equals the unified inbox's LinkedIn thread id has not been checked against a live HeyReach payload, so if a result opens as "Conversation not found", the id differs.
+- **Manage**: the tag library (`TagManager`: create, rename or recolour, delete; built-in tags follow the API's policy) and
+  `BlockedSenders` (block per mailbox, unblock). The tag list it loads also feeds the Tag filter and the tag picker.
+- In an open conversation, **Manage conversation** (`ThreadActions`): mark read (and unread on LinkedIn), remove a tag,
+  unassign a teammate, block the sender.
+
+A conversation this key cannot see (an org key sees shared threads only) or that was removed answers a uniform 404; the
+conversation view says "Conversation not found" instead of showing a generic failure.
+
 ## The flow, in order
 
 1. **List** `GET /inbox?channel=&status=&page=&page_size=` (`InboxList`). Each row has `id` and `channel`.
@@ -52,7 +67,8 @@ IDs passed between steps: `thread.id` + `thread.channel` (list -> view -> draft/
 
 - Connect a mailbox in the graph8 app (Google / Microsoft OAuth exists only there; see the `mailboxes` block).
   Until then the inbox has no email threads. `where: "app"`.
-- Give the proxy's API key `inbox:read`, `inbox:write` and `inbox:run` (and `campaigns:read` for the SMS sender picker).
+- Give the proxy's API key `inbox:read`, `inbox:write` and `inbox:run` (and `campaigns:read` for the SMS sender picker,
+  `inbox:delete` to delete a tag, remove a tag or teammate from a conversation or unblock a sender, `workflows:read` to list tags).
 - Credits for AI drafts (402 when none; there is no balance read, so the confirm dialog shows no estimate).
 
 ## Defaults (the agent does not need to ask)
@@ -62,9 +78,13 @@ IDs passed between steps: `thread.id` + `thread.channel` (list -> view -> draft/
 - A reply leaves from the thread's own mailbox, number or LinkedIn account and goes to the thread's contact.
 - No assignee filter: the API cannot filter by an arbitrary assignee email (an org key owns no threads), so
   filter `thread.assignees` client-side if you need it.
-- Ask the human only about **tags**: there is no list-tags operation. Pass `availableTags` from your own
-  state (collect them from `thread.tags` of loaded rows, or keep a list); tags created in the panel are
-  offered for the session.
+- Tags: `TagManager` lists them (`GET /workflows/inbox-tags`, scope `workflows:read`), so no input is needed. Pass
+  `availableTags` only to seed the pickers before the Manage sheet is opened; tags on loaded threads are always offered.
+- A NEW message is never sent without an explicit sender; the API refuses a compose without `from_mailbox` or
+  `from_number`, and this block does not guess one.
+- Not offered, because the API has no such operation: snooze, archive, mark an email or SMS unread. Not offered by
+  choice (see the PR): composing a NEW LinkedIn message (`/inbox/linkedin/compose` only continues an existing
+  conversation, which `ReplyComposer` already does), starring chats, internal comments, saving compose drafts.
 
 ## Gotchas
 
@@ -88,6 +108,22 @@ IDs passed between steps: `thread.id` + `thread.channel` (list -> view -> draft/
 | `aiInbox.createInboxTag` | POST /inbox/tags | write | TagAndAssign |
 | `inbox.tagReply` | POST /inbox/{reply_id}/tag | external | TagAndAssign |
 | `inbox.assignReply` | POST /inbox/{reply_id}/assign | external | TagAndAssign |
+| `aiInbox.listInboxMailboxesPaginated` | GET /inbox/mailboxes/paginated | read | ComposeMessage, InboxSearch, BlockedSenders |
+| `aiInbox.composeInboxEmail` | POST /inbox/emails/compose | external | ComposeMessage |
+| `aiInbox.composeInboxSms` | POST /inbox/sms/compose | external | ComposeMessage |
+| `inbox.searchInboxEmails` | POST /inbox/emails/search | read | InboxSearch |
+| `aiInbox.searchInboxLinkedinConversations` | POST /inbox/linkedin/conversations/search | read | InboxSearch |
+| `workflows.listInboxTags` | GET /workflows/inbox-tags | read | TagManager |
+| `aiInbox.updateInboxTag` | PUT /inbox/tags/{tag_id} | write | TagManager (changed fields only) |
+| `aiInbox.deleteInboxTag` | DELETE /inbox/tags/{tag_id} | destructive | TagManager |
+| `aiInbox.markInboxEmailRead` | POST /inbox/emails/{email_id}/mark-read | write | ThreadActions |
+| `aiInbox.markInboxSmsRead` | POST /inbox/sms/{thread_id}/mark-read | write | ThreadActions |
+| `aiInbox.markInboxLinkedinConversationRead` / `Unread` | POST /inbox/linkedin/accounts/{account_id}/conversations/{id}/read, /unread | write | ThreadActions |
+| `aiInbox.removeChannelTag` | DELETE /inbox/channels/{channel_id}/tags | destructive | ThreadActions |
+| `aiInbox.unassignChannel` | DELETE /inbox/channels/{channel_id}/assign | destructive | ThreadActions |
+| `aiInbox.blockInboxSender` | POST /inbox/blocked-senders | write | ThreadActions, BlockedSenders |
+| `aiInbox.listInboxBlockedSenders` | GET /inbox/blocked-senders | read | BlockedSenders |
+| `aiInbox.unblockInboxSender` | DELETE /inbox/blocked-senders/{blocked_sender_id} | destructive | BlockedSenders |
 
 ## Recipes (server side)