fullstackgtm 0.48.0 → 0.50.0

package/src/cli/plans.ts

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { auditSnapshot, defaultPolicy } from "../audit.ts";
-import { loadConfig, mergePolicy, resolveConfiguredRules } from "../config.ts";
+import { loadConfig, mergePolicy, resolveConfiguredRules, rulePackageTrustFromCli } from "../config.ts";
 import { applyPatchPlan } from "../connector.ts";
 import { diffFindings, diffSnapshots, diffToMarkdown } from "../diff.ts";
 import { createChannelConnector } from "../connectors/outboxChannel.ts";
@@ -15,6 +15,7 @@ import { createFilePlanStore } from "../planStore.ts";
 import { ENRICH_CONFIG_FILE_NAME, loadEnrichConfig, type EnrichConfig } from "../enrich.ts";
 import { loadMeter, recordConsumption, remaining } from "../acquireMeter.ts";
 import { progressReporter, reportCounts } from "../runReport.ts";
+import { claimHostedPlanApply, reconcileHostedPatchPlan, releaseHostedPlanApply, reportHostedPlanLifecycle, uploadHostedPatchPlan } from "../hostedPatchPlan.ts";
 import { APPLY_STAGES, composeListeners, createProgressEmitter } from "../progress.ts";
 import type { ValueSuggestion } from "../suggest.ts";
 import type { CanonicalGtmSnapshot, CreateRecordPayload, PatchOperation, PatchPlan, PatchPlanRun } from "../types.ts";
@@ -141,8 +142,18 @@ export async function apply(args: string[]) {
   const store = planId ? createFilePlanStore() : null;
 
   if (planId && store) {
-    const stored = await store.get(planId);
+    let stored = await store.get(planId);
     if (!stored) throw new Error(`No stored plan with id ${planId}.`);
+    const reconciliation = await reconcileHostedPatchPlan(store, stored);
+    if (reconciliation.status === "conflict") throw new Error(`Refusing to apply plan ${planId}: ${reconciliation.reason}.`);
+    if (reconciliation.status === "updated") {
+      stored = reconciliation.stored;
+      console.error(`Synced hosted ${reconciliation.remoteStatus} state for ${planId}.`);
+    }
+    if (stored.status === "applied") {
+      console.log(`Plan ${planId} was already applied by another replica; imported its execution receipt. No provider writes were attempted.`);
+      return;
+    }
     if (stored.status !== "approved") {
       throw new Error(
         `Plan ${planId} is ${stored.status}; approve operations first with \`fullstackgtm plans approve ${planId} --operations <ids|all>\`.`,
@@ -234,6 +245,58 @@ export async function apply(args: string[]) {
   // A channel (e.g. outbox) renders approved ops to a local artifact and
   // transmits nothing; a CRM provider writes records. Same governed apply path.
   const connector = channel ? createChannelConnector(channel) : await connectorFor(provider!, args);
+  let applyClaimId: string | undefined;
+  let hostedApplyClaimId: string | undefined;
+  if (planId && store) {
+    const claimed = await store.claimApply(planId, { provider: provider ?? `channel:${channel}`, source: "cli" });
+    applyClaimId = claimed.claimId;
+    const hostedClaim = await claimHostedPlanApply(claimed.stored);
+    if (hostedClaim.status === "applied") {
+      await store.abortApplyPreflight(planId, claimed.claimId, "Another replica completed apply before provider I/O.");
+      const refreshed = await store.get(planId);
+      if (refreshed) await reconcileHostedPatchPlan(store, refreshed);
+      console.log(`Plan ${planId} was already applied by another replica. No provider writes were attempted.`);
+      return;
+    }
+    if (hostedClaim.status === "conflict") {
+      await store.abortApplyPreflight(planId, claimed.claimId, `Hosted execution claim failed: ${hostedClaim.reason}`);
+      throw new Error(`Refusing to apply plan ${planId}: could not coordinate with its hosted replica (${hostedClaim.reason}).`);
+    }
+    if (hostedClaim.status === "unavailable") {
+      console.error(`Hosted replica is unavailable (${hostedClaim.reason}); continuing local-first. Resolve-before-create and provider conflict guards remain active, and the execution receipt will sync on a later check-in.`);
+    }
+    if (hostedClaim.status === "claimed") {
+      hostedApplyClaimId = hostedClaim.claimId;
+      await store.recordHostedClaim(planId, claimed.claimId, hostedClaim.claimId);
+    }
+    const claimedVerification = verifyApprovalDigests(
+      claimed.stored.plan.operations,
+      claimed.stored.approvedOperationIds,
+      claimed.stored.valueOverrides,
+      claimed.stored.approvalDigests,
+    );
+    if (!claimedVerification.ok) {
+      if (hostedApplyClaimId) {
+        const released = await releaseHostedPlanApply(
+          claimed.stored,
+          hostedApplyClaimId,
+          "Approval integrity verification failed after claim and before provider I/O.",
+        );
+        if (released.status === "conflict" || released.status === "unavailable") {
+          console.error(`Hosted apply claim may require recovery: ${released.reason}.`);
+        }
+      }
+      await store.abortApplyPreflight(
+        planId,
+        claimed.claimId,
+        "Approval integrity verification failed after the claim and before provider I/O.",
+      );
+      throw new Error(`Refusing to apply plan ${planId}: approval changed while acquiring the apply claim.`);
+    }
+    plan = claimed.stored.plan;
+    approvedOperationIds = claimed.stored.approvedOperationIds;
+    valueOverrides = claimed.stored.valueOverrides;
+  }
   // Interactive terminals get a live apply board on stderr while the run
   // executes (preflight → operations → results, with a per-op safety ticker);
   // piped runs render nothing. Either way the emitter streams heartbeats to
@@ -249,11 +312,21 @@ export async function apply(args: string[]) {
       valueOverrides,
       progress,
     });
+  } catch (error) {
+    // Once applyPatchPlan starts, an exception cannot prove that the provider
+    // performed no write. Keep the claim fail-closed for operator reconciliation.
+    if (planId && store && applyClaimId) await store.markApplyUncertain(planId, applyClaimId);
+    throw error;
   } finally {
     renderer.done();
   }
   if (planId && store) {
-    await store.recordRun(planId, run);
+    const recorded = await store.recordRun(planId, run, applyClaimId!);
+    const durableHostedClaimId = recorded.applyAttempts?.find((attempt) => attempt.id === applyClaimId)?.hostedClaimId;
+    const mirrored = await reportHostedPlanLifecycle(recorded, { claimId: durableHostedClaimId ?? hostedApplyClaimId });
+    if (mirrored.status === "unavailable" || mirrored.status === "conflict") {
+      console.error(`Hosted plan status is stale: ${mirrored.reason}. Local apply history remains authoritative.`);
+    }
   }
 
   // Charge the acquire meter for the creates that actually landed.
@@ -307,8 +380,9 @@ export async function diffCommand(args: string[]) {
     readFileSync(resolve(process.cwd(), afterPath), "utf8"),
   ) as CanonicalGtmSnapshot;
 
-  const loaded = loadConfig(option(args, "--config") ?? undefined);
-  const rules = selectedRules(args, await resolveConfiguredRules(loaded));
+  const explicitConfig = option(args, "--config") ?? undefined;
+  const loaded = loadConfig(explicitConfig);
+  const rules = selectedRules(args, await resolveConfiguredRules(loaded, undefined, rulePackageTrustFromCli(args, explicitConfig)));
   const policy = mergePolicy(defaultPolicy(), loaded?.config);
   const today = option(args, "--today");
   if (today) policy.today = today;
@@ -380,7 +454,13 @@ export async function plansCommand(args: string[]) {
     const status = option(rest, "--status") as
       | "draft" | "needs_approval" | "approved" | "rejected" | "applied"
       | null;
-    const plans = await store.list(status ?? undefined);
+    let plans = await store.list(status ?? undefined);
+    const synced = await Promise.all(plans.map(async (stored) => {
+      const result = await reconcileHostedPatchPlan(store, stored);
+      if (result.status === "updated") return result.stored;
+      return stored;
+    }));
+    plans = status ? synced.filter((stored) => stored.status === status) : synced;
     if (rest.includes("--json") || args.includes("--json")) {
       console.log(
         JSON.stringify(
@@ -445,8 +525,15 @@ export async function plansCommand(args: string[]) {
   if (subcommand === "show") {
     const planId = rest.find((arg) => !arg.startsWith("--"));
     if (!planId) throw new Error("Usage: fullstackgtm plans show <planId>");
-    const stored = await store.get(planId);
+    let stored = await store.get(planId);
     if (!stored) throw new Error(`No stored plan with id ${planId}.`);
+    const reconciliation = await reconcileHostedPatchPlan(store, stored);
+    if (reconciliation.status === "updated") {
+      stored = reconciliation.stored;
+      console.error(`Synced hosted ${reconciliation.remoteStatus} state for ${planId}.`);
+    } else if (reconciliation.status === "conflict") {
+      console.error(`Hosted sync conflict: ${reconciliation.reason}.`);
+    }
     if (rest.includes("--json")) {
       console.log(JSON.stringify(stored, null, 2));
       return;
@@ -455,6 +542,16 @@ export async function plansCommand(args: string[]) {
     console.log(`Status: ${planStatusWord(stored.status, showPaint)}`);
     console.log(`Approved operations: ${stored.approvedOperationIds.join(", ") || "none"}`);
     console.log(`Runs: ${stored.runs.length}`);
+    const mirror = await uploadHostedPatchPlan(stored);
+    if (mirror.status === "saved") console.log(`Hosted review: ${mirror.state.url}`);
+    else if (mirror.status === "unavailable" || mirror.status === "conflict") console.log(`Hosted review: sync pending (${mirror.reason})`);
+    if (stored.applyAttempts?.length) {
+      console.log("Apply attempts:");
+      for (const attempt of stored.applyAttempts) {
+        console.log(`  ${attempt.id}  ${attempt.status}  ${attempt.provider} via ${attempt.source}  ${attempt.claimedAt}`);
+        if (attempt.note) console.log(`    ${attempt.note}`);
+      }
+    }
     console.log("");
     console.log(stylizePlanMarkdown(patchPlanToMarkdown(stored.plan), showPaint));
     return;
@@ -506,6 +603,10 @@ export async function plansCommand(args: string[]) {
       ...fileOverrides,
       ...explicitOverrides,
     });
+    const mirror = await reportHostedPlanLifecycle(updated);
+    if (mirror.status === "unavailable" || mirror.status === "conflict") {
+      console.error(`Hosted plan status is stale: ${mirror.reason}. Local approval remains authoritative.`);
+    }
     console.log(
       `Approved ${updated.approvedOperationIds.length} operation(s) on ${planId}. Apply with \`fullstackgtm apply --plan-id ${planId} --provider <name>\`.`,
     );
@@ -515,10 +616,59 @@ export async function plansCommand(args: string[]) {
   if (subcommand === "reject") {
     const planId = rest.find((arg) => !arg.startsWith("--"));
     if (!planId) throw new Error("Usage: fullstackgtm plans reject <planId>");
-    await store.reject(planId);
+    const rejected = await store.reject(planId);
+    const mirror = await reportHostedPlanLifecycle(rejected);
+    if (mirror.status === "unavailable" || mirror.status === "conflict") {
+      console.error(`Hosted plan status is stale: ${mirror.reason}. Local rejection remains authoritative.`);
+    }
     console.log(`Rejected ${planId}.`);
     return;
   }
 
-  throw unknownSubcommandError("plans", subcommand, ["list", "show", "approve", "reject"]);
+  if (subcommand === "recover") {
+    const planId = rest.find((arg) => !arg.startsWith("--"));
+    if (!planId) {
+      throw new Error("Usage: fullstackgtm plans recover <planId> --acknowledge-uncertain-writes");
+    }
+    const stored = await store.get(planId);
+    if (!stored) throw new Error(`No stored plan with id ${planId}.`);
+    if (stored.status !== "applying" || !stored.applyClaim) {
+      throw new Error(`Plan ${planId} has no unresolved apply attempt.`);
+    }
+    const attempt = stored.applyAttempts?.find((entry) => entry.id === stored.applyClaim?.id);
+    if (!rest.includes("--acknowledge-uncertain-writes")) {
+      throw new Error(
+        `Plan ${planId} has an unresolved ${attempt?.provider ?? "provider"} apply attempt (${stored.applyClaim.id}). ` +
+          "Inspect the affected records in the provider; do not replay automatically. If you accept that some writes may already have landed, " +
+          `run \`fullstackgtm plans recover ${planId} --acknowledge-uncertain-writes\`. This clears every approval and requires a fresh review and approval before retrying.`,
+      );
+    }
+    await store.recoverApply(planId);
+    console.log(
+      `Released ${planId} to needs_approval after acknowledging uncertain provider state. ` +
+        `No writes were replayed. Re-audit provider state, review the plan, then approve operations again before any apply.`,
+    );
+    return;
+  }
+
+  if (subcommand === "sync") {
+    const plans = await store.list();
+    let updated = 0;
+    const warnings: string[] = [];
+    for (const stored of plans) {
+      const result = await reconcileHostedPatchPlan(store, stored);
+      if (result.status === "updated") updated += 1;
+      else if (result.status === "conflict" || result.status === "unavailable") warnings.push(`${stored.plan.id}: ${result.reason}`);
+      if (stored.status === "applied") {
+        const hostedClaimId = [...(stored.applyAttempts ?? [])].reverse().find((attempt) => attempt.hostedClaimId)?.hostedClaimId;
+        const pushed = await reportHostedPlanLifecycle(stored, { claimId: hostedClaimId });
+        if (pushed.status === "conflict" || pushed.status === "unavailable") warnings.push(`${stored.plan.id} receipt: ${pushed.reason}`);
+      }
+    }
+    console.log(`Plan replicas synchronized: ${updated} updated, ${plans.length - updated} unchanged.`);
+    for (const warning of warnings) console.error(`  ${warning}`);
+    return;
+  }
+
+  throw unknownSubcommandError("plans", subcommand, ["list", "show", "sync", "approve", "reject", "recover"]);
 }

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/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 }>,
@@ -343,13 +344,20 @@ 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.
+        // Freeze that frame in scrollback; repainting here can leave both the
+        // last live frame and the final frame visible in some terminals.
+        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`);
@@ -366,8 +374,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 +431,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,
   };
@@ -449,6 +458,7 @@ export function severityWord(word: string, p: Paint): string {
 export function planStatusWord(status: string, p: Paint): string {
   if (status === "needs_approval") return p.yellow(status);
   if (status === "approved" || status === "applied") return p.green(status);
+  if (status === "applying") return p.yellow(status);
   if (status === "rejected") return p.red(status);
   return status;
 }

package/src/cli.ts

@@ -91,7 +91,7 @@ export async function runCli(argv: string[]) {
   }
   // Commands without bespoke help get focused per-command help on --help
   // instead of executing (audit used to silently run the sample audit) or
-  // dumping the whole surface. call/market/enrich/bulk-update/schedule print
+  // dumping the whole surface. call/market/enrich/schedule print
   // their own richer help. `--full` always escapes to the complete reference.
   if (!BESPOKE_HELP.includes(command) && (args.includes("--help") || args.includes("-h"))) {
     console.log(args.includes("--full") ? usage() : commandHelp(command));

package/src/config.ts

@@ -35,6 +35,35 @@ export type LoadedConfig = {
   path: string;
 };
 
+export type RulePackageTrust = {
+  /** Execute rule-package modules. Only set after an explicit trust decision. */
+  allowRulePackages?: boolean;
+  /** Deliberately ignore rule packages while still applying declarative config. */
+  disableRulePackages?: boolean;
+};
+
+/**
+ * Translate the CLI's explicit trust flags into the library trust contract.
+ * Plugin execution requires both an explicit config path and --allow-plugins;
+ * discovering a config in the current directory is never a trust decision.
+ */
+export function rulePackageTrustFromCli(
+  args: string[],
+  explicitConfigPath?: string,
+): RulePackageTrust {
+  const allow = args.includes("--allow-plugins");
+  const disable = args.includes("--no-plugins");
+  if (allow && disable) {
+    throw new Error("--allow-plugins and --no-plugins cannot be used together.");
+  }
+  if (allow && !explicitConfigPath) {
+    throw new Error(
+      "--allow-plugins requires --config <path>. Plugin code is never trusted from an implicitly discovered config.",
+    );
+  }
+  return { allowRulePackages: allow, disableRulePackages: disable };
+}
+
 export function loadConfig(
   explicitPath?: string,
   cwd = process.cwd(),
@@ -73,10 +102,19 @@ export function mergePolicy(base: GtmPolicy, config?: FullstackgtmConfig): GtmPo
 export async function resolveConfiguredRules(
   loaded?: LoadedConfig | null,
   baseRules: GtmAuditRule[] = builtinAuditRules,
+  trust: RulePackageTrust = {},
 ): Promise<GtmAuditRule[]> {
   let rules = [...baseRules];
 
-  for (const specifier of loaded?.config.rulePackages ?? []) {
+  const packages = loaded?.config.rulePackages ?? [];
+  if (packages.length && !trust.allowRulePackages && !trust.disableRulePackages) {
+    throw new Error(
+      `Config ${loaded!.path} declares executable rulePackages. Refusing to load plugin code without explicit trust. ` +
+        "For the CLI, pass --config <path> --allow-plugins after reviewing the modules, or pass --no-plugins to use only declarative policy and built-in rules.",
+    );
+  }
+
+  for (const specifier of trust.disableRulePackages ? [] : packages) {
     const resolvedSpecifier =
       specifier.startsWith(".") || isAbsolute(specifier)
         ? pathToFileURL(resolve(dirname(loaded!.path), specifier)).href

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

@@ -14,6 +14,7 @@
  * env/credential store, never argv.
  */
 import type { CanonicalGtmSnapshot } from "../types.ts";
+import { ProviderHttpError } from "../providerError.ts";
 
 export type Prospect = {
   firstName?: string;
@@ -67,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[]> {
@@ -76,10 +79,10 @@ 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 Error(`Explorium /v1/prospects failed: HTTP ${response.status} ${await safeText(response)}`);
+    throw new ProviderHttpError("Explorium", "prospect search", response.status);
   }
   const data = (await response.json()) as { data?: ExploriumRow[] };
   return (data.data ?? []).map((row) => ({
@@ -118,25 +121,57 @@ 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) {
-    throw new Error(`pipe0 /v1/searches/run/sync failed: HTTP ${response.status} ${await safeText(response)}`);
+    throw new ProviderHttpError("pipe0", "prospect search", response.status);
   }
   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".
@@ -146,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 {
@@ -159,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 {
@@ -214,7 +257,7 @@ export async function probeExploriumBusinessCount(opts: {
     body: JSON.stringify({ mode: "full", page_size: 1, page: 1, filters: opts.filters }),
   });
   if (!response.ok) {
-    throw new Error(`Explorium /v1/businesses count failed: HTTP ${response.status} ${await safeText(response)}`);
+    throw new ProviderHttpError("Explorium", "business count", response.status);
   }
   const body = (await response.json()) as { total_results?: unknown };
   const total = body.total_results;
@@ -427,14 +470,6 @@ function fieldValue(field: Pipe0Field | undefined): string | undefined {
   return typeof v === "string" && v.trim() ? v : undefined;
 }
 
-async function safeText(response: Response): Promise<string> {
-  try {
-    return (await response.text()).slice(0, 300);
-  } catch {
-    return "";
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Pre-email dedup: identity keys shared between prospects and CRM contacts, so
 // we can drop already-in-CRM / already-seen people BEFORE paying for emails.

package/src/connectors/salesforce.ts

@@ -19,6 +19,7 @@ import type {
   PatchOperationResult,
   SnapshotProgress,
 } from "../types.ts";
+import { validateSalesforceOrigin } from "./salesforceAuth.ts";
 import { SNAPSHOT_PULL_STAGES, type ProgressEmitter } from "../progress.ts";
 
 const DEFAULT_API_VERSION = "v59.0";
@@ -152,13 +153,17 @@ export function createSalesforceConnector(
 
   async function request(path: string, init: RequestInit = {}): Promise<any> {
     const connection = await options.getConnection();
-    const url = path.startsWith("http")
-      ? path
-      : `${connection.instanceUrl.replace(/\/$/, "")}${path}`;
+    const instanceUrl = validateSalesforceOrigin(connection.instanceUrl, "Salesforce connection instance URL");
+    const resolved = new URL(path, `${instanceUrl}/`);
+    if (resolved.origin !== instanceUrl) {
+      throw new Error("Salesforce response attempted to send credentials to a different origin.");
+    }
+    const url = resolved.href;
     let response: Response;
     try {
       response = await fetchImpl(url, {
         ...init,
+        redirect: "manual",
         headers: {
           Authorization: `Bearer ${connection.accessToken}`,
           "Content-Type": "application/json",
@@ -168,7 +173,7 @@ export function createSalesforceConnector(
     } catch (error) {
       const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
       throw new Error(
-        `Cannot reach Salesforce at ${connection.instanceUrl}${cause}. Check SALESFORCE_INSTANCE_URL (your My Domain URL, e.g. https://yourco.my.salesforce.com) and network access.`,
+        `Cannot reach Salesforce at ${instanceUrl}${cause}. Check SALESFORCE_INSTANCE_URL (your My Domain URL, e.g. https://yourco.my.salesforce.com) and network access.`,
       );
     }
     if (!response.ok) {
@@ -644,8 +649,9 @@ export function createSalesforceConnector(
     loserIds: string[],
   ): Promise<{ ok: boolean; detail?: string }> {
     const connection = await options.getConnection();
+    const instanceUrl = validateSalesforceOrigin(connection.instanceUrl, "Salesforce connection instance URL");
     const version = apiVersion.replace(/^v/, ""); // SOAP path uses "59.0", not "v59.0"
-    const url = `${connection.instanceUrl.replace(/\/$/, "")}/services/Soap/u/${version}`;
+    const url = `${instanceUrl}/services/Soap/u/${version}`;
     const toMerge = loserIds.map((id) => `<urn:recordToMergeIds>${escapeXml(id)}</urn:recordToMergeIds>`).join("");
     const envelope =
       `<?xml version="1.0" encoding="UTF-8"?>` +
@@ -659,6 +665,7 @@ export function createSalesforceConnector(
     try {
       response = await fetchImpl(url, {
         method: "POST",
+        redirect: "manual",
         headers: { "Content-Type": "text/xml; charset=UTF-8", SOAPAction: '""' },
         body: envelope,
       });