salesprompter-cli 0.1.70 → 0.1.72

package/README.md

@@ -112,6 +112,7 @@ salesprompter affiliate:grow \
 # Verify live campaign state, lead safety, and contact activity, then activate explicitly
 salesprompter affiliate:list
 salesprompter affiliate:status "$AFFILIATE_RUN_ID"
+salesprompter affiliate:finish "$AFFILIATE_RUN_ID"
 salesprompter affiliate:analytics "$AFFILIATE_RUN_ID"
 salesprompter affiliate:regenerate-sequence "$AFFILIATE_RUN_ID"
 salesprompter affiliate:enrich "$AFFILIATE_RUN_ID"
@@ -174,11 +175,12 @@ the app's CLI imports view.
 - Respect provider terms and customer data boundaries.
 - `affiliate:grow` is an alias for `affiliate:run`. It excludes repeated `--seed-profile` customers, removes profiles already stored in prior workspace affiliate audiences, and verifies the final persisted count before preparing Instantly.
 - If every collected profile is known or excluded, no audience or Instantly campaign is created. A stale Sales Navigator session also fails before persistence with a safe retry instruction.
-- Affiliate outreach uses direct email enrichment first, then Phantombuster Email Finder for unresolved people before creating a draft Instantly campaign.
+- Affiliate outreach uses Hunter first, requires Hunter's `valid` verdict before import, and sends recovered addresses through Hunter Email Verifier before creating a draft Instantly campaign. Catch-all, disposable, webmail, invalid, unknown, claimed, and unresolved addresses are excluded. Instantly verification remains enabled as a second gate.
 - Affiliate preparation uses exactly three emails with three observable variants per step; `affiliate:regenerate-sequence` rebuilds and syncs them through the Salesprompter app.
 - `affiliate:list` shows safe workspace summaries. `affiliate:analytics` shows aggregate and step/variant outcomes without exposing lead data; unsupported per-step meeting and won fields render as `n/a`.
 - `affiliate:run` defaults to `--timing-mode custom`, so its daily limit and weekday sending window are honored. Use `--timing-mode auto` only when capacity-derived scheduling is intended.
 - `affiliate:enrich` starts durable email recovery and adds only newly found addresses to an existing campaign. It returns a background-processing status for large audiences instead of blocking the terminal. Pass `--source-audience-run-id` to merge a newer compatible audience into that campaign without creating a duplicate campaign.
+- `affiliate:finish` closes the loop: it requires persisted Hunter-valid evidence for new campaigns, repairs stalled Instantly verification in 1,000-lead batches, quarantines stale pending or invalid leads outside the sending campaign, accepts an explicitly audited recovery fallback, activates only a fully verified campaign, and reads the live state back. Use `--requeue-pending` only after restoring Instantly verification capacity.
 - A draft campaign does not send until `affiliate:activate` is run.
 - The CLI is designed for interactive users and agent-assisted workflows.
 - A repo-local Chrome extension compatibility copy is available in `chrome-extension/` for local LinkedIn session sync and popup copy/debug flows.

package/dist/cli.js

@@ -283,6 +283,8 @@ const AffiliateOutreachHealthSchema = z.object({
         pendingVerification: z.number().int().nonnegative(),
         invalid: z.number().int().nonnegative(),
         unsafe: z.number().int().nonnegative(),
+        hunterVerified: z.number().int().nonnegative().default(0),
+        hunterEvidenceMissing: z.number().int().nonnegative().default(0),
         contacted: z.number().int().nonnegative(),
         replied: z.number().int().nonnegative(),
         statusCounts: z.record(z.string(), z.number().int().nonnegative()),
@@ -298,6 +300,21 @@ const AffiliateOutreachHealthSchema = z.object({
 const AffiliateOutreachLiveStatusResponseSchema = AffiliateOutreachResponseSchema.extend({
     health: AffiliateOutreachHealthSchema
 });
+const AffiliateVerificationRepairResponseSchema = AffiliateOutreachResponseSchema.extend({
+    repair: z.object({
+        checkedAt: DatabaseTimestampSchema,
+        beforeCount: z.number().int().nonnegative(),
+        afterCount: z.number().int().nonnegative(),
+        restoredMissing: z.number().int().nonnegative(),
+        requeuedPending: z.number().int().nonnegative(),
+        quarantinedPending: z.number().int().nonnegative(),
+        prunedInvalid: z.number().int().nonnegative(),
+        pendingAfter: z.number().int().nonnegative(),
+        invalidAfter: z.number().int().nonnegative(),
+        verifiedAfter: z.number().int().nonnegative(),
+        dataPreparationAccepted: z.boolean()
+    })
+});
 const AffiliateOutreachSummarySchema = AffiliateOutreachRunBaseSchema;
 const AffiliateAudienceSummarySchema = z.object({
     public_token: z.string().min(1),
@@ -710,6 +727,7 @@ const cliPacks = [
             "affiliate:run",
             "affiliate:list",
             "affiliate:status",
+            "affiliate:finish",
             "affiliate:analytics",
             "affiliate:regenerate-sequence",
             "affiliate:enrich",
@@ -770,6 +788,7 @@ const helpVisibleCommandNames = new Set([
     "affiliate:run",
     "affiliate:list",
     "affiliate:status",
+    "affiliate:finish",
     "affiliate:analytics",
     "affiliate:regenerate-sequence",
     "affiliate:enrich",
@@ -6828,20 +6847,81 @@ async function getAffiliateOutreachLiveStatusViaApp(session, audienceRunId) {
     }, AffiliateOutreachLiveStatusResponseSchema);
     return value;
 }
+async function repairAffiliateOutreachVerificationViaApp(session, audienceRunId, options) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/repair-verification`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({
+            ...options,
+            pruneInvalid: true
+        })
+    }), AffiliateVerificationRepairResponseSchema);
+    return value;
+}
+async function finishAffiliateOutreachViaApp(session, audienceRunId, options) {
+    let live = await getAffiliateOutreachLiveStatusViaApp(session, audienceRunId);
+    const repairs = [];
+    for (let batch = 0; batch < options.maxRepairBatches; batch += 1) {
+        if (live.outreach.status === "active" || live.health.activationReady) {
+            break;
+        }
+        if (live.outreach.status !== "ready" || !live.health.liveChecked || !live.health.leads) {
+            throw new Error(describeAffiliateOutreachHealth(live.health));
+        }
+        const beforeUnsafe = live.health.leads.unsafe;
+        const needsRepair = beforeUnsafe > 0 || !live.health.dataPreparationComplete;
+        if (!needsRepair) {
+            break;
+        }
+        const repaired = await repairAffiliateOutreachVerificationViaApp(session, audienceRunId, {
+            staleAfterMinutes: options.staleAfterMinutes,
+            maxPendingRequeues: 1_000,
+            quarantinePending: !options.requeuePending,
+            acceptIncompleteRecovery: true
+        });
+        repairs.push(repaired.repair);
+        live = await getAffiliateOutreachLiveStatusViaApp(session, audienceRunId);
+        const afterUnsafe = live.health.leads?.unsafe ?? beforeUnsafe;
+        if (!live.health.activationReady &&
+            afterUnsafe >= beforeUnsafe &&
+            live.health.dataPreparationComplete) {
+            throw new Error(`${describeAffiliateOutreachHealth(live.health)} Pending leads may not be old enough for safe automatic repair yet.`);
+        }
+    }
+    if (live.outreach.status !== "active") {
+        if (!live.health.activationReady) {
+            throw new Error(`${describeAffiliateOutreachHealth(live.health)} The safe activation gate remains closed.`);
+        }
+        await activateAffiliateOutreachViaApp(session, audienceRunId);
+        live = await getAffiliateOutreachLiveStatusViaApp(session, audienceRunId);
+    }
+    if (!live.health.running || !live.health.safeToSend) {
+        throw new Error(`Activation could not be verified safely. ${describeAffiliateOutreachHealth(live.health)}`);
+    }
+    return { live, repairs };
+}
 function describeAffiliateOutreachHealth(health) {
     const leads = health.leads;
+    const hunterSummary = leads
+        ? leads.hunterEvidenceMissing > 0
+            ? `Hunter evidence recorded for ${leads.hunterVerified}/${leads.total} leads (${leads.hunterEvidenceMissing} legacy or missing)`
+            : `${leads.hunterVerified}/${leads.total} Hunter-valid`
+        : null;
     if (health.done && leads) {
-        return `Done: the campaign is running with ${leads.verified}/${leads.total} verified leads.`;
+        return `Done: the campaign is running with ${leads.verified}/${leads.total} Instantly-verified leads; ${hunterSummary}.`;
     }
     if (health.verdict === "unsafe_running" && leads) {
         return `Attention: the campaign is running with ${leads.unsafe} unsafe leads.`;
     }
     if (health.verdict === "ready_to_activate" && leads) {
-        return `Ready to activate: ${leads.verified}/${leads.total} leads are verified.`;
+        return `Ready to activate: ${leads.verified}/${leads.total} Instantly-verified; ${hunterSummary}.`;
     }
     if (health.liveChecked && leads) {
         const campaignState = health.campaign?.statusLabel ?? "unknown";
-        return `Not done: the campaign is ${campaignState}; ${leads.verified}/${leads.total} leads are verified; ${leads.contacted} contacted.`;
+        return `Not done: the campaign is ${campaignState}; ${leads.verified}/${leads.total} Instantly-verified; ${hunterSummary}; ${leads.contacted} contacted.`;
     }
     return health.blockers[0]?.message ?? "Live campaign status could not be verified.";
 }
@@ -13912,6 +13992,9 @@ function parseAffiliateOutreachCommandOptions(options) {
     if (!parsedTimingMode.success) {
         throw new Error("--timing-mode must be either auto or custom.");
     }
+    if (options.allowAcceptAll) {
+        throw new Error("--allow-accept-all is no longer supported. Affiliate outreach requires Hunter status valid.");
+    }
     const trimmedCampaignName = options.campaignName?.trim();
     const campaignName = trimmedCampaignName
         ? z.string().max(120, "--campaign-name must be 120 characters or fewer.").parse(trimmedCampaignName)
@@ -13921,7 +14004,7 @@ function parseAffiliateOutreachCommandOptions(options) {
         language: z.string().trim().min(1).max(40).parse(options.language),
         numberOfSteps: 3,
         minEmailScore: z.coerce.number().int().min(0).max(100).parse(options.minEmailScore),
-        allowAcceptAll: Boolean(options.allowAcceptAll),
+        allowAcceptAll: false,
         timingMode: parsedTimingMode.data,
         dailyLimit: z.coerce.number().int().min(1).max(1000).parse(options.dailyLimit),
         timezone: z.string().trim().min(1).max(100).parse(options.timezone),
@@ -15096,7 +15179,7 @@ addAffiliateAudienceOptions(program
     .option("--language <language>", "Sequence language", "English")
     .option("--steps <number>", "Exactly 3 sequence emails (fixed)", "3")
     .option("--min-email-score <number>", "Minimum Hunter confidence score", "80")
-    .option("--allow-accept-all", "Include catch-all domains that meet the score threshold", false)
+    .option("--allow-accept-all", "Deprecated: catch-all emails are rejected", false)
     .option("--timing-mode <mode>", "Schedule mode: custom honors the daily limit and sending window; auto derives them from capacity", "custom")
     .option("--daily-limit <number>", "Maximum new leads contacted per day", "25")
     .option("--timezone <timezone>", "Instantly sending timezone", "America/Detroit")
@@ -15170,6 +15253,13 @@ addAffiliateAudienceOptions(program
                 ? "complete"
                 : "not_reported",
             persistence: "verified",
+            emailVerification: {
+                provider: "hunter",
+                policy: "valid_only",
+                verified: Number(finalOutreach.stats.hunterVerifiedEmails ?? 0),
+                rejected: Number(finalOutreach.stats.hunterRejectedEmails ?? 0),
+                secondaryProvider: "instantly"
+            },
             outreach: finalOutreach.status,
             activation: finalOutreach.status === "active" ? "complete" : "not_requested",
         },
@@ -15201,6 +15291,34 @@ program
         outreach: result.outreach
     });
 });
+program
+    .command("affiliate:finish <run-id>")
+    .description("Repair stalled verification, activate safely, and verify the live campaign.")
+    .option("--stale-after-minutes <number>", "Age before a pending verification can be repaired or quarantined", "15")
+    .option("--max-repair-batches <number>", "Maximum 1,000-lead repair batches", "125")
+    .option("--requeue-pending", "Retry stalled verification instead of quarantining it outside the sending campaign", false)
+    .action(async (runId, options) => {
+    const session = await requireAuthSession();
+    const audienceRunId = z.string().uuid().parse(runId);
+    const result = await finishAffiliateOutreachViaApp(session, audienceRunId, {
+        staleAfterMinutes: z.coerce.number().int().min(15).max(30 * 24 * 60).parse(options.staleAfterMinutes),
+        maxRepairBatches: z.coerce.number().int().min(1).max(250).parse(options.maxRepairBatches),
+        requeuePending: Boolean(options.requeuePending)
+    });
+    const leads = result.live.health.leads;
+    printOutput({
+        status: "ok",
+        running: result.live.health.running,
+        safeToSend: result.live.health.safeToSend,
+        done: result.live.health.done,
+        repairs: result.repairs,
+        health: result.live.health,
+        outreach: result.live.outreach,
+        message: result.live.health.done
+            ? describeAffiliateOutreachHealth(result.live.health)
+            : `The campaign is active and safe with ${leads?.verified ?? 0}/${leads?.total ?? 0} verified leads; sending will begin in its configured schedule.`
+    });
+});
 program
     .command("affiliate:analytics <run-id>")
     .description("Show safe campaign and step/variant performance metrics for an affiliate run.")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesprompter-cli",
-  "version": "0.1.70",
+  "version": "0.1.72",
   "description": "Sales workflow CLI for guided lead generation, enrichment, scoring, and sync.",
   "author": "Daniel Sinewe <hello@danielsinewe.com>",
   "type": "module",