@sellable/mcp 0.1.556 → 0.1.557

package/README.md

@@ -16,8 +16,9 @@ Each message gets 5+ minutes of Claude attention with deep research - no other t
 
 ### Prompt Source Of Truth
 
-There are eight public Sellable entrypoints shared across hosts:
+There are nine public Sellable entrypoints shared across hosts:
 
+- `sellable:find-leads`
 - `sellable:create-campaign`
 - `sellable:create-ab-test`
 - `sellable:create-evergreen-campaigns`
@@ -33,6 +34,11 @@ the approval-gated workflow from:
 
 - `mcp/sellable/skills/create-campaign-v2/SKILL.md`
 
+The find-leads public wrapper builds a live exportable source list without a
+campaign and loads its durable approval-gated workflow from:
+
+- `mcp/sellable/skills/find-leads-v2/SKILL.md`
+
 The create-ab-test public wrapper prepares clean A/B split lead lists and
 review-copy campaigns from:
 
@@ -205,7 +211,7 @@ thread and select `Sellable Create Campaign`, `Sellable Create A/B Test`,
 `Sellable Create Evergreen Campaigns`, `Sellable Foundation`,
 `Sellable Content`, `Sellable Create Post`, `Sellable Refresh Sender Engagement`,
 or `Sellable Refill Sends`; or invoke
-`$sellable:create-campaign`, `$sellable:create-ab-test`,
+`$sellable:find-leads`, `$sellable:create-campaign`, `$sellable:create-ab-test`,
 `$sellable:create-evergreen-campaigns`, `$sellable:foundation`,
 `$sellable:content`, `$sellable:create-post`,
 `$sellable:refresh-sender-engagement`, or `$sellable:refill-sends`. If the app still says
@@ -220,6 +226,7 @@ the Sellable MCP tools for Codex Desktop.
 Use these names consistently:
 
 - Claude Code command: `/sellable:create-campaign`
+- Claude Code command: `/sellable:find-leads`
 - Claude Code command: `/sellable:create-ab-test`
 - Claude Code command: `/sellable:create-evergreen-campaigns`
 - Claude Code command: `/sellable:foundation`
@@ -228,6 +235,7 @@ Use these names consistently:
 - Claude Code command: `/sellable:refresh-sender-engagement`
 - Claude Code command: `/sellable:refill-sends`
 - Codex command: `$sellable:create-campaign`
+- Codex command: `$sellable:find-leads`
 - Codex command: `$sellable:create-ab-test`
 - Codex command: `$sellable:create-evergreen-campaigns`
 - Codex command: `$sellable:foundation`
@@ -237,6 +245,7 @@ Use these names consistently:
 - Codex command: `$sellable:refill-sends`
 - Codex Desktop plugin: `sellable@sellable`
 - Codex visible skill: `Sellable Create Campaign`
+- Codex visible skill: `Sellable Find Leads`
 - Codex visible skill: `Sellable Create A/B Test`
 - Codex visible skill: `Sellable Create Evergreen Campaigns`
 - Codex visible skill: `Sellable Foundation`
@@ -245,6 +254,7 @@ Use these names consistently:
 - Codex visible skill: `Sellable Refresh Sender Engagement`
 - Codex visible skill: `Sellable Refill Sends`
 - Codex skill frontmatter name: `create-campaign`
+- Codex skill frontmatter name: `find-leads`
 - Codex skill frontmatter name: `create-ab-test`
 - Codex skill frontmatter name: `create-evergreen-campaigns`
 - Codex skill frontmatter name: `foundation`
@@ -254,6 +264,7 @@ Use these names consistently:
 - Codex skill frontmatter name: `refill-sends`
 - MCP server name: `sellable`
 - Internal workflow prompt: `create-campaign-v2`
+- Internal workflow prompt: `find-leads-v2`
 - Internal workflow prompt: `refill-sends-workflow`
 - Internal/backward-compatible memory prompt: `interview`
 

package/agents/registry.json

@@ -26,8 +26,8 @@
       "ownership": "message strategy, proof inventory, token rules, skeptical-prospect review, and selected winner only",
       "codex": {
         "description": "Message Drafting worker for campaign-backed template proposals after confirm_lead_list imports a non-empty bounded review batch.",
-        "model": "gpt-5.6-sol",
-        "modelReasoningEffort": "high",
+        "model": "gpt-5.5",
+        "modelReasoningEffort": "xhigh",
         "sandboxMode": "read-only",
         "nicknameCandidates": [
           "Message Drafting",

package/dist/api.js

@@ -3,7 +3,7 @@ import { mkdir, rename, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { getConfig, getConfigPath, getEffectiveConfiguredWorkspaceId, resolveWorkspaceIdForRequest, } from "./auth.js";
+import { getConfig, getConfigPath } from "./auth.js";
 export class SellableApiError extends Error {
     status;
     body;
@@ -42,12 +42,9 @@ export class SellableApi {
         // Re-read config on every request so workspace switches take effect immediately
         const config = getConfig();
         const url = `${config.apiUrl}${path}`;
-        const requestedWorkspaceId = options && Object.prototype.hasOwnProperty.call(options, "workspaceId")
-            ? options.workspaceId
-            : getEffectiveConfiguredWorkspaceId(config);
         const workspaceId = options && Object.prototype.hasOwnProperty.call(options, "workspaceId")
-            ? resolveWorkspaceIdForRequest(requestedWorkspaceId, `${method} ${path}`)
-            : requestedWorkspaceId;
+            ? options.workspaceId
+            : config.activeWorkspaceId || config.workspaceId || null;
         const response = await fetch(url, {
             method,
             headers: {

package/dist/auth.d.ts

@@ -40,12 +40,6 @@ export type SkillState = {
 export declare function setConfigFile(fileName: string): void;
 export declare function getResolvedConfigsDir(): string | null;
 export declare function getConfigPath(): string;
-export declare function getLockedWorkspaceId(): string | null;
-export declare function isWorkspaceLockRequired(): boolean;
-export declare function workspaceLockRequiredMessage(action?: string): string;
-export declare function assertWorkspaceLockSatisfied(action?: string): void;
-export declare function getEffectiveConfiguredWorkspaceId(config: Pick<SellableConfig, "activeWorkspaceId" | "workspaceId">): string | null;
-export declare function resolveWorkspaceIdForRequest(requestedWorkspaceId: string | null | undefined, action?: string): string | null;
 export declare function getConfig(): SellableConfig;
 export declare function updateActiveWorkspace(params: {
     workspaceId: string;

package/dist/auth.js

@@ -2,8 +2,6 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 const DEFAULT_API_URL = "https://app.sellable.dev";
-const WORKSPACE_LOCK_ENV = "SELLABLE_LOCK_WORKSPACE_ID";
-const REQUIRE_WORKSPACE_LOCK_ENV = "SELLABLE_REQUIRE_WORKSPACE_LOCK";
 // No caching — re-read config on every call so token/workspace changes
 // made by the LLM (editing sellable.json) take effect immediately
 // without requiring an MCP server restart.
@@ -87,44 +85,6 @@ function normalizeConfig(raw) {
         apiUrl: raw.apiUrl || DEFAULT_API_URL,
     };
 }
-export function getLockedWorkspaceId() {
-    const value = process.env[WORKSPACE_LOCK_ENV]?.trim();
-    return value || null;
-}
-export function isWorkspaceLockRequired() {
-    const value = process.env[REQUIRE_WORKSPACE_LOCK_ENV]?.trim().toLowerCase();
-    return value === "1" || value === "true" || value === "yes";
-}
-export function workspaceLockRequiredMessage(action = "Sellable request") {
-    return (`Workspace lock required: ${action} cannot run because ` +
-        `${REQUIRE_WORKSPACE_LOCK_ENV}=1 but ${WORKSPACE_LOCK_ENV} is missing. ` +
-        "Ask the sellable-admin profile to provision this customer profile with an approved customer workspace.");
-}
-export function assertWorkspaceLockSatisfied(action = "Sellable request") {
-    if (isWorkspaceLockRequired() && !getLockedWorkspaceId()) {
-        throw new Error(workspaceLockRequiredMessage(action));
-    }
-}
-function normalizeWorkspaceId(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-export function getEffectiveConfiguredWorkspaceId(config) {
-    assertWorkspaceLockSatisfied("workspace resolution");
-    return (getLockedWorkspaceId() ||
-        normalizeWorkspaceId(config.activeWorkspaceId) ||
-        normalizeWorkspaceId(config.workspaceId));
-}
-export function resolveWorkspaceIdForRequest(requestedWorkspaceId, action = "Sellable request") {
-    assertWorkspaceLockSatisfied(action);
-    const lockedWorkspaceId = getLockedWorkspaceId();
-    const requested = normalizeWorkspaceId(requestedWorkspaceId);
-    if (!lockedWorkspaceId)
-        return requested;
-    if (requested && requested !== lockedWorkspaceId) {
-        throw new Error(`Workspace lock violation: ${action} requested workspace ${requested}, but this profile is locked to ${lockedWorkspaceId}.`);
-    }
-    return lockedWorkspaceId;
-}
 export function getConfig() {
     // Config cache removed 2026-05-04: we always re-read from disk so
     // workspace switches (set_active_workspace) take effect immediately
@@ -179,7 +139,6 @@ export function getConfig() {
     }
 }
 export function updateActiveWorkspace(params) {
-    resolveWorkspaceIdForRequest(params.workspaceId, "set_active_workspace");
     const configPath = getConfigPath();
     const configDir = path.dirname(configPath);
     if (!fs.existsSync(configDir)) {
@@ -267,7 +226,6 @@ function writeRawConfigFile(configPath, raw) {
  * new config without an MCP server restart.
  */
 export function writeNewConfig(opts) {
-    resolveWorkspaceIdForRequest(opts.activeWorkspaceId, "write Sellable auth config");
     const configPath = getConfigWritePath();
     let raw = {};
     if (fs.existsSync(configPath)) {
@@ -325,7 +283,7 @@ function getActiveEnvConfigRef(raw) {
 }
 export function getEngageState() {
     const config = getConfig();
-    const workspaceId = getEffectiveConfiguredWorkspaceId(config);
+    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
     if (!workspaceId) {
         return { activeWorkspaceId: null, state: null };
     }
@@ -336,7 +294,7 @@ export function updateEngageState(patch) {
     const { configPath, raw } = readRawConfigFile();
     const { envConfig, set } = getActiveEnvConfigRef(raw);
     const normalized = normalizeConfig(envConfig);
-    const workspaceId = getEffectiveConfiguredWorkspaceId(normalized);
+    const workspaceId = normalized.activeWorkspaceId || normalized.workspaceId || null;
     if (!workspaceId) {
         throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace.");
     }

package/dist/refill-run-client.d.ts

@@ -5,11 +5,6 @@ export type RefillRunBlockerResult = {
     runId: string;
     gate?: string;
     gateSeq?: number;
-} | {
-    blocker: "scope_drift" | "approval_expired" | "approval_fingerprint_mismatch";
-    runId: string;
-    expectedScopeHash: string | null;
-    receivedScopeHash: string | null;
 };
 export declare function startRefillRunRemote(input: {
     workspaceId?: string;

package/dist/refill-run-client.js

@@ -15,21 +15,6 @@ function parseBlockerBody(body) {
                 gateSeq: typeof parsed.gateSeq === "number" ? parsed.gateSeq : undefined,
             };
         }
-        if ((parsed.blocker === "scope_drift" ||
-            parsed.blocker === "approval_expired" ||
-            parsed.blocker === "approval_fingerprint_mismatch") &&
-            typeof parsed.runId === "string") {
-            return {
-                blocker: parsed.blocker,
-                runId: parsed.runId,
-                expectedScopeHash: typeof parsed.expectedScopeHash === "string"
-                    ? parsed.expectedScopeHash
-                    : null,
-                receivedScopeHash: typeof parsed.receivedScopeHash === "string"
-                    ? parsed.receivedScopeHash
-                    : null,
-            };
-        }
     }
     catch {
         return null;

package/dist/refill-run-loop.d.ts

@@ -1,6 +1,6 @@
 import type { appendIndexLine, appendJournalEvent, createRunJournal, renderBootstrapSection, renderCrashedAbandonedSection, renderExecutionEventSection, renderPlanSection, renderTerminalSection } from "./refill-journal.js";
 import type { advanceRefillRunGateRemote, completeRefillRun, heartbeatRefillRun, recordRunOutcome, recordRunPlanned, refillRunStatus, startRefillRunRemote } from "./refill-run-client.js";
-import type { getPrepareCampaignMessagesStatus, stopSatisfiedPrepareCampaignMessages } from "./tools/campaign-message-preparation.js";
+import type { getPrepareCampaignMessagesStatus } from "./tools/campaign-message-preparation.js";
 import type { executeOneYoloPrimitive, executeStartCampaignPrimitive, prepareRowSelectorValue, refillPrepareRequestHash, refreshPaidInmailCreditsWithRetry } from "./tools/refill-executors.js";
 export type RefillLoopGate = "g0_bootstrap" | "g1_plan" | "g2_execute" | "g3_verify" | "g4_terminal";
 export interface RefillV2LoopInput {
@@ -13,12 +13,6 @@ export interface RefillV2LoopInput {
     };
     approvalMode?: "approve" | "mark_ready";
     dryRun?: boolean;
-    targetDate?: string;
-    untilDate?: string;
-    horizonSendDays?: number;
-    scope?: Record<string, unknown>;
-    scopeHash?: string;
-    approval?: Record<string, unknown>;
 }
 export interface RefillV2LoopBudgets {
     maxGateCyclesPerInvocation: number;
@@ -42,7 +36,6 @@ export interface RefillV2Executors {
     executeStartCampaignPrimitive: typeof executeStartCampaignPrimitive;
     refreshPaidInmailCreditsWithRetry: typeof refreshPaidInmailCreditsWithRetry;
     getPrepareCampaignMessagesStatus?: typeof getPrepareCampaignMessagesStatus;
-    stopSatisfiedPrepareCampaignMessages?: typeof stopSatisfiedPrepareCampaignMessages;
     refillPrepareRequestHash?: typeof refillPrepareRequestHash;
     prepareRowSelectorValue?: typeof prepareRowSelectorValue;
 }
@@ -68,10 +61,6 @@ export interface RefillV2LoopDeps {
         senderIds?: string[];
         runState?: Record<string, unknown>;
         journal?: boolean;
-        targetDate?: string;
-        untilDate?: string;
-        horizonSendDays?: number;
-        scopeHash?: string;
     }) => Promise<Record<string, unknown>>;
     executors: RefillV2Executors;
     journal: RefillV2JournalDeps;

package/dist/refill-run-loop.js

@@ -59,16 +59,6 @@ const SCHEDULER_RUN_NEXT_ACTIONS = new Set([
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function planScopeInput(input) {
-    return {
-        ...(input.targetDate ? { targetDate: input.targetDate } : {}),
-        ...(input.untilDate ? { untilDate: input.untilDate } : {}),
-        ...(input.horizonSendDays !== undefined
-            ? { horizonSendDays: input.horizonSendDays }
-            : {}),
-        ...(input.scopeHash ? { scopeHash: input.scopeHash } : {}),
-    };
-}
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -266,8 +256,10 @@ function sanitizeSchedulerRunReceipt(raw) {
         const prefilteredCells = numberValue(rawReceipt.prefilteredCells) ?? 0;
         const tablesFilteredForSenderMismatch = numberValue(rawReceipt.tablesFilteredForSenderMismatch) ?? 0;
         dominantSkipReason = dominantSchedulerRunSkipReason(skipReasons);
-        dominantPrefilterReason = dominantSchedulerRunCountReason(prefilterReasons);
-        dominantDeferredReason = dominantSchedulerRunSkipReason(deferredReasons);
+        dominantPrefilterReason =
+            dominantSchedulerRunCountReason(prefilterReasons);
+        dominantDeferredReason =
+            dominantSchedulerRunSkipReason(deferredReasons);
         recommendedNextAction = schedulerRunRecommendedAction({
             rawAction: stringValue(rawReceipt.nextAction),
             readyCellsFound,
@@ -437,43 +429,6 @@ function normalizeDoneReason(value) {
 function runStateProgress(ctx) {
     return recordValue(ctx.runState.progress) ?? {};
 }
-function prepCircuitFrom(value) {
-    const root = recordValue(value);
-    const result = recordValue(root?.result);
-    const progress = recordValue(root?.progress);
-    return (recordValue(root?.circuit) ??
-        recordValue(result?.circuit) ??
-        recordValue(progress?.circuit) ??
-        null);
-}
-function openCircuitWaits(circuit, now) {
-    if (stringValue(circuit?.state) !== "open")
-        return false;
-    const nextProbeAt = stringValue(circuit?.nextProbeAt);
-    return Boolean(nextProbeAt && Date.parse(nextProbeAt) > now.getTime());
-}
-function activePreparationScopeSatisfied(plan, action) {
-    const packet = recordValue(plan.packet) ?? plan;
-    const target = recordValue(packet.target) ?? recordValue(plan.target) ?? {};
-    const senderId = actionSenderId(action);
-    const toolInput = actionToolInput(action);
-    const targetDate = stringValue(toolInput.targetDate);
-    const refillLaneKey = stringValue(toolInput.refillLaneKey);
-    const senderPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
-    const ledgers = senderPlans
-        .filter((senderPlan) => !senderId || stringValue(senderPlan.senderId) === senderId)
-        .flatMap((senderPlan) => arrayValue(senderPlan.laneLedgers).filter(isRecord));
-    const matching = ledgers.filter((ledger) => (!senderId || stringValue(ledger.senderId) === senderId) &&
-        (!targetDate || stringValue(ledger.targetDate) === targetDate) &&
-        (!refillLaneKey || stringValue(ledger.refillLaneKey) === refillLaneKey));
-    return (matching.length > 0 &&
-        matching.every((ledger) => {
-            const checks = recordValue(ledger.identityChecks);
-            return (numberValue(ledger.initialAllocatablePrepDeficit) === 0 &&
-                checks != null &&
-                Object.values(checks).every((value) => value === true));
-        }));
-}
 function mergeProgress(ctx, updates) {
     return {
         ...runStateProgress(ctx),
@@ -717,28 +672,14 @@ async function createJournal(input, deps, runId) {
 }
 async function startOrResume(input, deps) {
     const initialRunState = buildRunStateFromLocalHints(input.workspaceId);
-    const scopedInitialRunState = input.scope
-        ? {
-            ...initialRunState,
-            scope: input.scope,
-            scopeHash: input.scopeHash,
-            approval: input.approval,
-        }
-        : initialRunState;
     const started = await deps.runClient.startRefillRunRemote({
         workspaceId: input.workspaceId,
-        config: input.scope
-            ? {
-                scope: input.scope,
-                scopeHash: input.scopeHash,
-                approval: input.approval,
-            }
-            : {
-                intent: input.intent ?? "auto",
-                senderIds: input.senderIds,
-                approvalMode: input.approvalMode ?? "approve",
-            },
-        runState: scopedInitialRunState,
+        config: {
+            intent: input.intent ?? "auto",
+            senderIds: input.senderIds,
+            approvalMode: input.approvalMode ?? "approve",
+        },
+        runState: initialRunState,
         resume: input.resume,
     });
     if (isLeaseLost(started)) {
@@ -771,7 +712,7 @@ async function startOrResume(input, deps) {
     const gate = (stringValue(result.gate) ?? "g0_bootstrap");
     const gateSeq = numberValue(result.gateSeq) ?? 0;
     const runState = recordValue(result.runState) ??
-        recordValue(scopedInitialRunState) ??
+        recordValue(initialRunState) ??
         {
             version: 1,
             senderCursors: [],
@@ -814,7 +755,6 @@ async function gateBootstrap(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
-        ...planScopeInput(input),
     });
     const paidCredit = arrayValue(recordValue(plan.bootstrap)?.paidCredit).filter(isRecord);
     const refreshedSenderIds = new Set(arrayValue(recordValue(ctx.runState.creditTrust)?.senderIds)
@@ -961,7 +901,6 @@ async function gatePlan(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
-        ...planScopeInput(input),
     });
     if (plan.blocker === "workspace_access") {
         return {
@@ -1021,17 +960,6 @@ async function gatePlan(input, deps, ctx) {
         fallbackSummary: line.fallbackSummary,
     }));
     const fingerprint = fingerprintFromPlan(plan);
-    const persistedCircuit = recordValue(runStateProgress(ctx).prepCircuit);
-    if (stringValue(action.type) === "prepare_messages" &&
-        openCircuitWaits(persistedCircuit, deps.now?.() ?? new Date())) {
-        const heartbeat = await heartbeatAndContinue(input, deps, ctx);
-        if (heartbeat.status !== "in_progress")
-            return heartbeat;
-        return {
-            ...heartbeat,
-            guidance: `Preparation circuit remains open until ${String(persistedCircuit?.nextProbeAt)}; re-invoke with this handle after the probe deadline.`,
-        };
-    }
     const noProgress = nextNoProgressState(ctx, plan, action);
     if (noProgress.repeatCount >= 3) {
         return completeTerminal(input, deps, ctx, "blocked", {
@@ -1042,17 +970,10 @@ async function gatePlan(input, deps, ctx) {
             guidance: "The same refill rung repeated three times with no coverage, frontier, or lane movement.",
         });
     }
-    const circuitProgress = stringValue(action.type) === "prepare_messages" &&
-        stringValue(persistedCircuit?.state) === "open"
-        ? { ...persistedCircuit, state: "half_open" }
-        : persistedCircuit;
     const nextRunState = mergeRunState(ctx.runState, {
         lastPlan: fingerprint,
         headAction: action,
-        progress: mergeProgress(ctx, {
-            noProgress,
-            ...(circuitProgress ? { prepCircuit: circuitProgress } : {}),
-        }),
+        progress: mergeProgress(ctx, { noProgress }),
     });
     const advanced = await deps.runClient.advanceRefillRunGateRemote({
         workspaceId: input.workspaceId,
@@ -1089,7 +1010,6 @@ async function verifyRecoveryPoint(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
-        ...planScopeInput(input),
     });
     const changed = fingerprintChanged(expected, fingerprintFromPlan(fresh));
     if (changed.length > 0) {
@@ -1159,9 +1079,6 @@ async function gateExecute(input, deps, ctx) {
         dispatchKey: stringValue(action.type),
         evergreenRung: stringValue(action.evergreenRung),
         sideEffectClass: stringValue(action.sideEffectClass),
-        scopeHash: input.scopeHash ?? null,
-        expectedTargetsHash: stringValue(input.scope?.expectedTargetsHash) ?? null,
-        dateSelector: recordValue(input.scope?.dateSelector),
     };
     const plannedResult = await deps.runClient.recordRunPlanned({
         workspaceId: input.workspaceId,
@@ -1255,12 +1172,6 @@ async function advanceBackToPlan(input, deps, ctx, runStateUpdates = {}) {
 async function verifyPrepareAction(input, deps, ctx, action, budgets) {
     const getStatus = deps.executors.getPrepareCampaignMessagesStatus;
     const jobId = activeJobIdFromOutcome(ctx.runState.lastOutcome);
-    const executionCircuit = prepCircuitFrom(ctx.runState.lastOutcome);
-    if (!jobId && executionCircuit) {
-        return advanceBackToPlan(input, deps, ctx, {
-            progress: mergeProgress(ctx, { prepCircuit: executionCircuit }),
-        });
-    }
     if (!getStatus || !jobId) {
         return {
             status: "in_progress",
@@ -1300,58 +1211,6 @@ async function verifyPrepareAction(input, deps, ctx, action, budgets) {
                 }),
             });
         }
-        if (ownJob &&
-            !isTerminalJobStatus(latestStatus) &&
-            deps.executors.stopSatisfiedPrepareCampaignMessages) {
-            const fresh = await deps.readPlan({
-                workspaceId: input.workspaceId,
-                intent: input.intent,
-                senderIds: input.senderIds,
-                runState: ctx.runState,
-                journal: false,
-                ...planScopeInput(input),
-            });
-            ctx.plan = fresh;
-            if (activePreparationScopeSatisfied(fresh, action)) {
-                const plannedStop = await deps.runClient.recordRunPlanned({
-                    workspaceId: input.workspaceId,
-                    runId: ctx.runId,
-                    fence: ctx.fence,
-                    gate: ctx.gate,
-                    gateSeq: ctx.gateSeq,
-                    planned: {
-                        toolName: "stop_satisfied_campaign_message_preparation",
-                        toolInput: { jobId },
-                        dispatchKey: `stop_satisfied:${jobId}`,
-                        sideEffectClass: "message_preparation_stop",
-                        scopeHash: input.scopeHash ?? null,
-                    },
-                });
-                if (isLeaseLost(plannedStop))
-                    return leaseLostResult(ctx);
-                const stopEventId = stringValue(recordValue(plannedStop)?.eventId) ??
-                    `${ctx.runId}:${ctx.gateSeq}:stop`;
-                const stopReceipt = await deps.executors.stopSatisfiedPrepareCampaignMessages({
-                    workspaceId: input.workspaceId,
-                    jobId,
-                    expectedUpdatedAt: stringValue(statusRecord.updatedAt) ?? undefined,
-                });
-                await deps.runClient.recordRunOutcome({
-                    workspaceId: input.workspaceId,
-                    runId: ctx.runId,
-                    fence: ctx.fence,
-                    eventId: stopEventId,
-                    did: { jobId },
-                    outcome: stopReceipt,
-                });
-                return advanceBackToPlan(input, deps, ctx, {
-                    progress: mergeProgress(ctx, {
-                        prepStopReceipt: stopReceipt,
-                        prepStoppedAt: (deps.now?.() ?? new Date()).toISOString(),
-                    }),
-                });
-            }
-        }
         if (isTerminalJobStatus(latestStatus)) {
             const preparedCount = preparedCountFromStatus(latestStatus);
             const checkedRows = checkedRowsFromStatus(latestStatus);
@@ -1419,7 +1278,6 @@ async function verifyReadOnlyWait(input, deps, ctx, budgets, waitKind) {
             senderIds: input.senderIds,
             runState: ctx.runState,
             journal: false,
-            ...planScopeInput(input),
         });
         ctx.plan = fresh;
         const doneReason = doneReasonFromPlan(fresh);
@@ -1502,7 +1360,6 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
             senderIds: input.senderIds,
             runState: ctx.runState,
             journal: false,
-            ...planScopeInput(input),
         });
         ctx.plan = fresh;
         const doneReason = normalizeDoneReason(doneReasonFromPlan(fresh));
@@ -1565,7 +1422,6 @@ async function gateVerify(input, deps, ctx, budgets) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
-        ...planScopeInput(input),
     });
     ctx.plan = fresh;
     const doneReason = doneReasonFromPlan(fresh);
@@ -1630,7 +1486,7 @@ async function heartbeatAndContinue(input, deps, ctx) {
         runId: ctx.runId,
         fence: ctx.fence,
         gate: ctx.gate,
-        guidance: "Per-invocation gate budget reached. Re-invoke public refill_sends with this durable run handle to continue.",
+        guidance: "Per-invocation gate budget reached. Re-invoke refill_sends_v2 with this runId/fence to continue.",
         journalPath: ctx.journalPath,
     };
 }
@@ -1644,7 +1500,6 @@ export async function runRefillV2Loop(input, deps) {
                 intent: input.intent,
                 senderIds: input.senderIds,
                 journal: true,
-                ...planScopeInput(input),
             });
             return { status: "dry_run", plan };
         }

package/dist/server.js

@@ -29,6 +29,7 @@ import { getEngageStateTool, setEngageStateTool, } from "./tools/engage-state.js
 import { bulkEnrichWithProspeo, enrichWithProspeo, getProspeoCredits, } from "./tools/enrichment.js";
 import { getRefillPlanV2 } from "./tools/evergreen-refill-plan.js";
 import { getCampaignFramework } from "./tools/framework.js";
+import { bootstrapFindLeads, cancelFindLeads, getFindLeadsRun, reissueFindLeadsWatchLink, updateFindLeadsRun, waitForFindLeadsRun, } from "./tools/find-leads-runs.js";
 import { confirmHarvestJobCompanies, searchHarvestJobs, } from "./tools/harvest-jobs.js";
 import { checkInboxReplyEligibility, getInboxThread, searchInboxThreads, sendInboxDraft, sendInboxManualReply, updateInboxDraft, } from "./tools/inbox.js";
 import { cancelLeadImport, confirmLeadList, confirmProspeoCompanyAccounts, getProviderPrompt, importLeads, listDncEntriesTool, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchProspeoCompanies, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
@@ -36,6 +37,7 @@ import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfi
 import { getCampaignNavigationState } from "./tools/navigation.js";
 import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDemandSequence, pauseOnDemandCampaign, startOnDemandCampaign, } from "./tools/one-off.js";
 import { upsertRubric } from "./tools/processing.js";
+import { preflightFindLeadsProvider } from "./tools/provider-preflight.js";
 import { completeSenderResearch, getPostFindLeadsScoutRegistry, getSourceScoutRegistry, getSubskillAsset, getSubskillPrompt, listSubskillPrompts, searchSubskillPrompts, } from "./tools/prompts.js";
 import { waitForCampaignTableReady, waitForLeadListReady, } from "./tools/readiness.js";
 import { refreshSenderEngagementCommand } from "./tools/refresh-sender-engagement.js";
@@ -146,6 +148,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "wait_for_cli_login":
                 result = await handleWaitForCliLogin(args);
                 break;
+            case "bootstrap_find_leads":
+                result = await bootstrapFindLeads(args);
+                break;
+            case "get_find_leads_run":
+                result = await getFindLeadsRun(args);
+                break;
+            case "update_find_leads_run":
+                result = await updateFindLeadsRun(args);
+                break;
+            case "wait_for_find_leads_run":
+                result = await waitForFindLeadsRun(args);
+                break;
+            case "cancel_find_leads":
+                result = await cancelFindLeads(args);
+                break;
+            case "reissue_find_leads_watch_link":
+                result = await reissueFindLeadsWatchLink(args);
+                break;
+            case "preflight_find_leads_provider":
+                result = await preflightFindLeadsProvider(args);
+                break;
             case "bootstrap_engage":
                 result = await bootstrapEngage(args);
                 break;

package/dist/tools/auth.d.ts

@@ -11,11 +11,6 @@ export type AuthStatus = {
     tokenPresent: boolean;
     tokenPrefix: string | null;
     workspacesCount: number | null;
-    workspaceLock: {
-        enabled: boolean;
-        workspaceId: string | null;
-        required: boolean;
-    };
     checkedAt: string;
     /** Short message the LLM MUST show the user after auth succeeds. */
     _userNotice: string | null;