fullstackgtm 0.49.0 → 0.50.1

package/src/cli/schedule.ts

@@ -9,6 +9,7 @@ import { computeMissedFirings, createFileScheduleRunStore, createFileScheduleSto
 import { runCli } from "../cli.ts";
 import { isOptionValue, numericOption, option } from "./shared.ts";
 import { unknownSubcommandError } from "./suggest.ts";
+import { colorEnabled, paint, table } from "./ui.ts";
 
 
 /**
@@ -120,12 +121,19 @@ trigger: manual. status shows next firing and surfaces missed firings
       console.log('No schedules. Add one with `fullstackgtm schedule add "<command>" --cron "<expr>"`.');
       return;
     }
-    for (const entry of withNext) {
-      console.log(
-        `${entry.id}  ${entry.enabled ? "on " : "off"}  ${entry.cron.padEnd(14)} next ${entry.nextFiring ?? "—"}  ${entry.label}: ${entry.argv.join(" ")}`,
-      );
-    }
-    console.log("\nEntries are declarative — `schedule install` materializes enabled ones into the crontab.");
+    const p = paint(colorEnabled(process.stdout));
+    const verbose = rest.includes("--verbose");
+    const rows = [
+      ["STATE", "SCHEDULE", "NEXT", ...(verbose ? ["CRON", "COMMAND"] : [])],
+      ...withNext.map((entry) => [
+        entry.enabled ? "on" : "off",
+        `${entry.label} · ${entry.id}`,
+        entry.nextFiring ?? "—",
+        ...(verbose ? [entry.cron, entry.argv.join(" ")] : []),
+      ]),
+    ];
+    console.log(table(rows, [p.dim, null, null]).join("\n"));
+    console.log("\nDeclarative only · run `fullstackgtm schedule install` after changes.");
     return;
   }
 
@@ -272,21 +280,19 @@ trigger: manual. status shows next firing and surfaces missed firings
       const last = entry.lastRun as { firedAt: string; trigger: string; exitCode: number; noopReason?: string; artifacts: { planIds: string[]; runLabels: string[] } } | null;
       const streak = entry.streak as { outcome: string; length: number } | null;
       const missed = entry.missedFirings as string[];
-      console.log(`${entry.id}  ${entry.enabled ? "on " : "off"}  ${entry.cron}  ${entry.label}: ${(entry.argv as string[]).join(" ")}`);
-      console.log(`  next: ${entry.nextFiring ?? "— (disabled)"}`);
+      const verbose = rest.includes("--verbose");
+      const outcome = !last ? "never run" : last.exitCode === 0 ? (last.noopReason ? `no-op · ${last.noopReason}` : "healthy") : `failed · exit ${last.exitCode}`;
+      console.log(`${entry.enabled ? "●" : "○"} ${entry.label} · ${outcome}`);
+      console.log(`  ${entry.id} · next ${entry.nextFiring ?? "— (disabled)"}`);
+      if (verbose) console.log(`  ${(entry.argv as string[]).join(" ")} · cron ${entry.cron}`);
       if (last) {
         const artifacts = [
           ...last.artifacts.planIds.map((planId) => `plan ${planId}`),
           ...last.artifacts.runLabels.map((runLabel) => `run ${runLabel}`),
         ];
-        console.log(
-          `  last: ${last.firedAt} (${last.trigger}) exit ${last.exitCode}` +
-            (last.noopReason ? ` — no-op: ${last.noopReason}` : "") +
-            (artifacts.length ? ` — ${artifacts.join(", ")}` : ""),
-        );
-        console.log(`  streak: ${streak!.length} ${streak!.outcome}(s)`);
+        console.log(`  last ${last.firedAt} · ${last.trigger} · ${streak!.length} ${streak!.outcome}${streak!.length === 1 ? "" : "s"}${artifacts.length ? ` · ${artifacts.join(", ")}` : ""}`);
       } else {
-        console.log("  last: never fired");
+        console.log("  last never fired");
       }
       if (missed.length > 0) {
         console.log(

package/src/cli/shared.ts

@@ -164,6 +164,7 @@ export async function connectorFor(
 export async function readSnapshot(
   args: string[],
   progress?: ProgressEmitter,
+  options: { persistProgress?: boolean } = {},
 ): Promise<CanonicalGtmSnapshot> {
   const provider = option(args, "--provider");
   if (provider) {
@@ -189,7 +190,7 @@ export async function readSnapshot(
     try {
       return await connector.fetchSnapshot();
     } finally {
-      renderer.done();
+      renderer.done({ persist: options.persistProgress });
     }
   }
   if (args.includes("--demo")) {

package/src/cli/signals.ts

@@ -27,6 +27,21 @@ function resolveSignalsConfig(args: string[]): SignalsConfig {
 /** A watchlist entry: an account domain plus optional per-source board tokens. */
 type WatchlistAccount = { domain: string; boards?: Partial<Record<AtsBoardSource, string>> };
 
+function concise(value: string, max = 72): string {
+  const oneLine = value.replace(/\s+/g, " ").trim();
+  return oneLine.length <= max ? oneLine : `${oneLine.slice(0, max - 1)}…`;
+}
+
+function renderSignals(signals: Signal[]): string {
+  if (signals.length === 0) return "No signals matched.";
+  const lines = [`Fresh signals (${signals.length})`, ""];
+  for (const signal of signals) {
+    lines.push(`${signal.weight.toFixed(2).padStart(5)}  ${signal.accountDomain}  · ${signal.bucket}`);
+    lines.push(`       ${concise(signal.trigger)}`);
+  }
+  return lines.join("\n");
+}
+
 /**
  * Resolve the watchlist of accounts to scan. Sources, in precedence order:
  *  - a --watchlist file (JSON array of {domain, boards?} or bare domain strings),
@@ -228,7 +243,7 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
     const ranked = [...fresh].sort((a, b) => b.weight - a.weight || a.accountDomain.localeCompare(b.accountDomain));
 
     // Ranked fresh signals to stdout; guidance to stderr.
-    console.log(JSON.stringify(ranked, null, 2));
+    console.log(rest.includes("--json") || rest.includes("--verbose") ? JSON.stringify(ranked, null, 2) : renderSignals(ranked));
     console.error(
       `Fetched ${fetched} candidate signal(s); ${fresh.length} fresh, ${deduped.length} deduped ` +
         `(window ${config.dedupWindowDays}d). NO plan emitted — signals are read-only re: CRM.`,
@@ -275,7 +290,7 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
       return true;
     });
     const ranked = filtered.sort((a, b) => b.weight - a.weight || a.accountDomain.localeCompare(b.accountDomain));
-    console.log(JSON.stringify(ranked, null, 2));
+    console.log(rest.includes("--json") || rest.includes("--verbose") ? JSON.stringify(ranked, null, 2) : renderSignals(ranked));
     console.error(`${ranked.length} signal(s)${unjudgedOnly ? " (unjudged)" : ""}.`);
     return;
   }
@@ -305,7 +320,11 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
     const outcomes = await store.listOutcomes();
     const signalsById = new Map((await store.allSignals()).map((s) => [s.id, s]));
     const weights = computeWeights(config, outcomes, signalsById);
-    console.log(JSON.stringify(weights, null, 2));
+    if (rest.includes("--json") || rest.includes("--verbose")) {
+      console.log(JSON.stringify(weights, null, 2));
+    } else {
+      console.log(["Learned signal weights", "", ...SIGNAL_BUCKETS.map((bucket) => `${bucket.padEnd(10)} ${weights[bucket].toFixed(4)}`)].join("\n"));
+    }
     if (rest.includes("--explain")) {
       // Per-bucket config default vs learned + booked/total over credited signals.
       const booked = new Map<SignalBucket, number>();

package/src/cli/tam.ts

@@ -275,8 +275,15 @@ RevOps universe, with real names. --source explorium is a firmographic count onl
     if (out) {
       writeFileSync(resolve(process.cwd(), out), md);
       console.log(`Wrote ${out}.`);
-    } else {
+    } else if (rest.includes("--verbose")) {
       console.log(md);
+    } else if (timeline.length > 0) {
+      console.log(coverageToText(model, timeline.at(-1)!, eta));
+      console.log("\nUse --verbose for assumptions, cross-checks, and the full coverage history.");
+    } else {
+      console.log(`TAM "${model.name}" · ${model.universe.accounts.toLocaleString()} accounts · ${model.universe.contacts.toLocaleString()} buyers · $${Math.round(model.tamUsd).toLocaleString()}`);
+      console.log(`ICP ${model.icpName} · ${model.acv.basis}-basis ACV $${Math.round(model.acv.valueUsd).toLocaleString()} (${model.acv.source})`);
+      console.log("No coverage readings yet. Run `fullstackgtm tam status --save` to establish one; use --verbose for the full assumptions report.");
     }
     return;
   }

package/src/cli/ui.ts

@@ -286,8 +286,8 @@ export function startElapsedStatus(
 
 export type Checklist = {
   update(id: string, state: "pending" | "running" | "ok" | "warn" | "fail", note?: string): void;
-  /** Stop animating and erase the board (callers print their own summary). */
-  done(): void;
+  /** Stop animating; optionally leave the final board in the terminal history. */
+  done(options?: { persist?: boolean }): void;
   readonly active: boolean;
 };
 
@@ -296,7 +296,8 @@ const NOOP_CHECKLIST: Checklist = { update() {}, done() {}, active: false };
 /**
  * A multi-line live board — one line per item, each flipping ○ → ⠹ → ✓ as work
  * progresses (the audit rule registry renders through this). Repaints with
- * cursor-up; erases itself on done() so the verb's real output owns stdout.
+ * cursor-up; done() normally erases it, while done({ persist: true }) leaves a
+ * final static history for multi-phase human workflows.
  */
 export function createChecklist(
   items: Array<{ id: string; label: string }>,
@@ -323,8 +324,12 @@ export function createChecklist(
       const label = entry.state === "pending" ? p.dim(item.label.padEnd(labelWidth)) : item.label.padEnd(labelWidth);
       return `  ${glyph} ${label}${note}`;
     });
-    const up = painted > 0 ? `\u001b[${painted}A` : "";
-    stream.write(`${up}${lines.map((line) => `\u001b[2K${line}`).join("\n")}\n`);
+    // Keep the cursor on the board's last row while it is live. A trailing
+    // newline on every repaint can scroll the old top row into permanent
+    // history when the board sits at the bottom of the terminal, producing
+    // apparent duplicate/errored frames in terminal captures.
+    const up = painted > 1 ? `\u001b[${painted - 1}A` : "";
+    stream.write(`${up}${lines.map((line) => `\u001b[2K${line}`).join("\n")}`);
     painted = lines.length;
   };
 
@@ -343,16 +348,28 @@ export function createChecklist(
       const entry = states.get(id);
       if (!entry) return;
       entry.state = state;
-      entry.note = note;
+      if (note !== undefined) entry.note = note;
       start();
       render();
     },
-    done() {
+    done(options = {}) {
       if (timer) clearInterval(timer);
       timer = null;
+      if (options.persist) {
+        // The caller's final state update already painted the completed board.
+        // Advance exactly once so subsequent output begins below it.
+        if (painted > 0) stream.write("\n");
+        painted = 0;
+        return;
+      }
       if (painted > 0) {
-        // Erase the board: cursor up over every painted line, clear each.
-        stream.write(`\u001b[${painted}A${"\u001b[2K\n".repeat(painted)}\u001b[${painted}A`);
+        // Erase in place without linefeeds, which could themselves scroll.
+        const up = painted > 1 ? `\u001b[${painted - 1}A` : "";
+        const clear = Array.from({ length: painted }, (_, index) =>
+          `\u001b[2K${index < painted - 1 ? "\u001b[1B" : ""}`,
+        ).join("");
+        const restore = painted > 1 ? `\u001b[${painted - 1}A` : "";
+        stream.write(`${up}${clear}${restore}`);
         painted = 0;
       }
     },
@@ -366,8 +383,8 @@ export type ProgressRenderer = {
    * listener via `composeListeners` when the run should also heartbeat).
    */
   listener: ProgressListener;
-  /** Stop animating and erase the board (callers print their own summary). */
-  done(): void;
+  /** Stop animating; optionally leave the completed board in terminal history. */
+  done(options?: { persist?: boolean }): void;
   readonly active: boolean;
 };
 
@@ -423,8 +440,9 @@ export function createProgressRenderer(
       // larger flow) are ignored by createChecklist's unknown-id no-op.
       if (current) board.update(current, "running", noteFor(event, snapshot));
     },
-    done() {
-      board.done();
+    done(options) {
+      if (current) board.update(current, "ok");
+      board.done(options);
     },
     active: true,
   };

package/src/connectors/hubspot.ts

@@ -42,6 +42,10 @@ export type HubspotConnectorOptions = {
    * alongside the legacy `onProgress` callback; both are presentation-only.
    */
   progress?: ProgressEmitter;
+  /** Maximum retries for HubSpot 429/5xx responses (default 5). */
+  maxRetries?: number;
+  /** Injectable delay for deterministic retry tests. */
+  sleep?: (milliseconds: number) => Promise<void>;
 };
 
 const OBJECT_PATHS: Partial<Record<GtmObjectType, string>> = {
@@ -76,6 +80,8 @@ const PULL_STAGE_BY_TYPE: Record<SnapshotProgress["objectType"], (typeof SNAPSHO
 export function createHubspotConnector(options: HubspotConnectorOptions): HubspotWritableConnector {
   const baseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
   const fetchImpl = options.fetchImpl ?? fetch;
+  const maxRetries = options.maxRetries ?? 5;
+  const sleep = options.sleep ?? ((milliseconds: number) => new Promise<void>((resolve) => setTimeout(resolve, milliseconds)));
   const mappings = options.fieldMappings;
   // create:<Name> dedup within one connector lifetime (one apply run): the
   // search API is eventually consistent, so a just-created company is
@@ -113,27 +119,45 @@ export function createHubspotConnector(options: HubspotConnectorOptions): Hubspo
   };
 
   async function request(path: string, init: RequestInit = {}): Promise<any> {
-    const token = await options.getAccessToken();
-    let response: Response;
-    try {
-      response = await fetchImpl(`${baseUrl}${path}`, {
-        ...init,
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json",
-          ...(init.headers ?? {}),
-        },
-      });
-    } catch (error) {
-      const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
-      throw new Error(`Cannot reach HubSpot at ${baseUrl}${cause}. Check network access.`);
+    let response: Response | undefined;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+      const token = await options.getAccessToken();
+      try {
+        response = await fetchImpl(`${baseUrl}${path}`, {
+          ...init,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            ...(init.headers ?? {}),
+          },
+        });
+      } catch (error) {
+        const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
+        throw new Error(`Cannot reach HubSpot at ${baseUrl}${cause}. Check network access.`);
+      }
+      const retryable = response.status === 429 || response.status >= 500;
+      if (!retryable || attempt === maxRetries) break;
+      await response.text().catch(() => undefined);
+      const retryAfter = response.headers.get("Retry-After");
+      const seconds = retryAfter === null ? NaN : Number(retryAfter);
+      const dateDelay = retryAfter && !Number.isFinite(seconds) ? Date.parse(retryAfter) - Date.now() : NaN;
+      const delayMs = Math.min(
+        30_000,
+        Math.max(0, Number.isFinite(seconds) ? seconds * 1_000 : Number.isFinite(dateDelay) ? dateDelay : 1_000 * 2 ** attempt),
+      );
+      const reason = response.status === 429 ? "rate limited" : `temporarily unavailable (${response.status})`;
+      options.progress?.note(`HubSpot ${reason}; retrying in ${Math.ceil(delayMs / 1_000)}s (${attempt + 1}/${maxRetries})`);
+      await sleep(delayMs);
     }
-    if (!response.ok) {
+    if (!response || !response.ok) {
       // Status line only — HubSpot 4xx bodies echo submitted property values
       // (contact emails, company domains) and the request payload, and these
       // errors are persisted into scheduled-run records. Never interpolate it.
-      await response.text().catch(() => undefined);
-      throw new Error(`HubSpot API error ${response.status}. Check the token scopes and request.`);
+      await response?.text().catch(() => undefined);
+      if (response?.status === 429) {
+        throw new Error(`HubSpot rate limit (429) persisted after ${maxRetries} retries. Wait for the portal limit to reset, then retry; no CRM writes were made.`);
+      }
+      throw new Error(`HubSpot API error ${response?.status ?? "unknown"}. Check the token scopes and request.`);
     }
     // DELETE and some association writes return 204 with an empty body.
     const text = await response.text();

package/src/connectors/linkedin.ts

@@ -41,6 +41,8 @@ export type FetchProspectsOptions = {
   sourceId?: string;
   /** Hard cap on prospects returned; also bounds pagination. */
   max?: number;
+  /** Opaque continuation cursor. HeyReach uses the decimal list offset. */
+  cursor?: string;
 };
 
 export type ConnectionStatus = { ok: boolean; detail: string };
@@ -152,6 +154,10 @@ export function createHeyReachProvider(options: HeyReachProviderOptions): Linked
       const max = opts.max ?? Number.POSITIVE_INFINITY;
       const out: LinkedInProspect[] = [];
       let offset = 0;
+      if (opts.cursor !== undefined) {
+        if (!/^\d+$/.test(opts.cursor)) throw new Error(`Invalid HeyReach cursor: ${opts.cursor}`);
+        offset = Number(opts.cursor);
+      }
       while (out.length < max) {
         const data = await call("/list/GetLeadsFromList", "POST", { listId, offset, limit: pageSize });
         const items = toArray(data);

package/src/connectors/prospectSources.ts

@@ -68,6 +68,8 @@ export async function fetchExploriumProspects(opts: {
   apiKey: string;
   filters: ExploriumFilters;
   size?: number;
+  /** One-based result page. */
+  page?: number;
   apiBaseUrl?: string;
   fetchImpl?: FetchImpl;
 }): Promise<Prospect[]> {
@@ -77,7 +79,7 @@ export async function fetchExploriumProspects(opts: {
   const response = await fetchImpl(`${base}/v1/prospects`, {
     method: "POST",
     headers: { "api_key": opts.apiKey, "Content-Type": "application/json" },
-    body: JSON.stringify({ mode: "full", size, page_size: size, page: 1, filters: opts.filters }),
+    body: JSON.stringify({ mode: "full", size, page_size: size, page: opts.page ?? 1, filters: opts.filters }),
   });
   if (!response.ok) {
     throw new ProviderHttpError("Explorium", "prospect search", response.status);
@@ -119,17 +121,44 @@ export async function fetchPipe0CrustdataProspects(opts: {
   apiKey: string;
   filters: Record<string, unknown>;
   limit?: number;
+  /** Opaque cursor returned by a previous page. */
+  cursor?: string;
   apiBaseUrl?: string;
   fetchImpl?: FetchImpl;
 }): Promise<Prospect[]> {
+  return (await fetchPipe0CrustdataProspectPage(opts)).prospects;
+}
+
+/** A page from pipe0/Crustdata's cursor-based people search. */
+export type Pipe0CrustdataProspectPage = {
+  prospects: Prospect[];
+  /** Opaque cursor for the next page, or null when the search is exhausted. */
+  nextCursor: string | null;
+};
+
+/**
+ * Fetch one page and expose its continuation cursor. The array-returning
+ * `fetchPipe0CrustdataProspects` remains available for existing consumers.
+ */
+export async function fetchPipe0CrustdataProspectPage(opts: {
+  apiKey: string;
+  filters: Record<string, unknown>;
+  limit?: number;
+  /** Opaque cursor returned by a previous page. */
+  cursor?: string;
+  apiBaseUrl?: string;
+  fetchImpl?: FetchImpl;
+}): Promise<Pipe0CrustdataProspectPage> {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const base = (opts.apiBaseUrl ?? "https://api.pipe0.com").replace(/\/$/, "");
   const limit = Math.min(opts.limit ?? 25, 100);
+  const config: Record<string, unknown> = { limit, filters: opts.filters };
+  if (opts.cursor !== undefined) config.cursor = opts.cursor;
   const response = await fetchImpl(`${base}/v1/searches/run/sync`, {
     method: "POST",
     headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
     body: JSON.stringify({
-      searches: [{ search_id: "people:profiles:crustdata@1", config: { limit, filters: opts.filters } }],
+      searches: [{ search_id: "people:profiles:crustdata@1", config }],
     }),
   });
   if (!response.ok) {
@@ -137,7 +166,12 @@ export async function fetchPipe0CrustdataProspects(opts: {
   }
   const body = (await response.json()) as {
     results?: Array<Record<string, { value?: unknown }>>;
-    search_statuses?: Array<{ errors?: Array<{ code?: string; message?: string }> }>;
+    next_cursor?: unknown;
+    search_statuses?: Array<{
+      errors?: Array<{ code?: string; message?: string }>;
+      next_cursor?: unknown;
+      cursor?: unknown;
+    }>;
   };
   // Surface upstream provider errors (e.g. CreditBalanceInsufficient) instead of
   // silently returning [] — a throttle/credit failure must not look like "no ICP matches".
@@ -147,7 +181,7 @@ export async function fetchPipe0CrustdataProspects(opts: {
       `pipe0/Crustdata search error: ${upstreamErrors.map((e) => `${e.code ?? "error"}: ${e.message ?? ""}`).join("; ")}`,
     );
   }
-  return (body.results ?? []).map((row) => {
+  const prospects = (body.results ?? []).map((row) => {
     const fullName = strField(row.name);
     const { firstName, lastName } = splitName(fullName);
     return {
@@ -160,6 +194,14 @@ export async function fetchPipe0CrustdataProspects(opts: {
       sourceId: strField(row.profile_url) ?? fullName,
     };
   });
+  // Current pipe0 responses expose `next_cursor` at the top level. Accept the
+  // status-envelope variants too so older deployments remain usable.
+  const status = body.search_statuses?.[0];
+  const rawCursor = body.next_cursor ?? status?.next_cursor ?? status?.cursor;
+  return {
+    prospects,
+    nextCursor: typeof rawCursor === "string" && rawCursor.length > 0 ? rawCursor : null,
+  };
 }
 
 function strField(field: { value?: unknown } | undefined): string | undefined {

package/src/enrich.ts

@@ -111,6 +111,8 @@ export type AcquireDiscoveryConfig = {
   provider: "explorium" | "pipe0" | "linkedin" | "heyreach";
   filters?: Record<string, unknown>;
   size?: number;
+  /** Maximum raw provider candidates scanned per run while seeking fresh leads. */
+  scanLimit?: number;
   resolveEmailsWith?: "pipe0";
   /** LinkedIn sources only: the provider-native list id to read (HeyReach lead-list id). */
   listId?: string;
@@ -1326,7 +1328,49 @@ export function selectStaleWork(
 // Checkpoint (cursor), staleness ledger (stamps), and observability surface
 // (enrich status) in one structure — mirrors the market observations store.
 
-export type EnrichRunMode = EnrichMode | "ingest";
+export type EnrichRunMode = EnrichMode | "ingest" | "acquire";
+
+/**
+ * Provider continuation state for an acquisition query. The fingerprint binds
+ * a cursor/offset to the ICP + provider filters that produced it, preventing a
+ * changed query from accidentally resuming in the middle of the old audience.
+ */
+export type AcquireDiscoveryCheckpoint = {
+  queryFingerprint: string;
+  /** Opaque provider cursor (Pipe0 and other cursor-based sources). */
+  cursor?: string | null;
+  /** Zero-based provider offset (LinkedIn/HeyReach and other offset sources). */
+  offset?: number | null;
+  /** True only when the provider has positively reported no next page. */
+  exhausted: boolean;
+};
+
+/**
+ * Truthful acquisition funnel for one run. Each field counts candidates, not
+ * provider requests, making duplicate saturation and resolution loss visible
+ * instead of reporting every run as zero.
+ */
+export type AcquireRunFunnel = {
+  /** Raw candidates returned across all discovery pages scanned this run. */
+  discovered: number;
+  /** Candidates that met the configured ICP threshold. */
+  qualified: number;
+  /** Qualified candidates removed by the CRM pre-email dedupe. */
+  skippedCrm: number;
+  /** Qualified candidates removed by the cross-run seen ledger. */
+  skippedSeen: number;
+  /** Fresh candidates carrying the configured resolve-first key. */
+  resolved: number;
+  /** Governed create operations emitted into the saved/dry-run plan. */
+  proposed: number;
+  /** Otherwise-proposable candidates held back by the acquire meter. */
+  withheldByMeter: number;
+};
+
+export type AcquireRunTelemetry = {
+  funnel: AcquireRunFunnel;
+  discovery: AcquireDiscoveryCheckpoint;
+};
 
 export type EnrichRun = {
   id: string;
@@ -1339,6 +1383,8 @@ export type EnrichRun = {
   /** Resume point for an interrupted pull (last processed pull key). */
   cursor: string | null;
   counts: EnrichCounts;
+  /** Acquisition-only funnel + provider continuation state (absent on legacy runs). */
+  acquireTelemetry?: AcquireRunTelemetry;
   planIds: string[];
   stamps: EnrichStamp[];
   /** Staged source rows (ingest mode only), consumed by append/refresh. */