@sellable/mcp 0.1.556 → 0.1.557

package/dist/tools/registry.js

@@ -25,6 +25,7 @@ import { engageStateToolDefinitions } from "./engage-state.js";
 import { enrichmentToolDefinitions } from "./enrichment.js";
 import { refillPlanV2ToolDefinitions } from "./evergreen-refill-plan.js";
 import { frameworkToolDefinitions } from "./framework.js";
+import { findLeadsRunToolDefinitions } from "./find-leads-runs.js";
 import { harvestJobToolDefinitions } from "./harvest-jobs.js";
 import { inboxToolDefinitions } from "./inbox.js";
 import { leadToolDefinitions } from "./leads.js";
@@ -32,11 +33,13 @@ import { linkedinToolDefinitions } from "./linkedin.js";
 import { navigationToolDefinitions } from "./navigation.js";
 import { onDemandToolDefinitions } from "./one-off.js";
 import { processingToolDefinitions } from "./processing.js";
+import { findLeadsProviderPreflightToolDefinitions } from "./provider-preflight.js";
 import { promptToolDefinitions } from "./prompts.js";
 import { readinessToolDefinitions } from "./readiness.js";
+import { refreshSenderEngagementToolDefinitions } from "./refresh-sender-engagement.js";
+import { refillSendsV2ToolDefinitions } from "./refill-sends-v2.js";
 import { refillSendsToolDefinitions } from "./refill-sends.js";
 import { refillTargetPlanToolDefinitions } from "./refill-target-plan.js";
-import { refreshSenderEngagementToolDefinitions } from "./refresh-sender-engagement.js";
 import { rowToolDefinitions } from "./rows.js";
 import { rubricToolDefinitions } from "./rubrics.js";
 import { schedulerFillCapacityToolDefinitions } from "./scheduler-fill-capacity.js";
@@ -60,6 +63,7 @@ export const allTools = [
     ...schedulerFillCapacityToolDefinitions,
     ...schedulerRunToolDefinitions,
     ...refillSendsToolDefinitions,
+    ...refillSendsV2ToolDefinitions,
     ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,
     ...campaignMessagePreparationToolDefinitions,
@@ -72,6 +76,8 @@ export const allTools = [
     ...engageDiscoveryToolDefinitions,
     ...workspaceToolDefinitions,
     ...frameworkToolDefinitions,
+    ...findLeadsRunToolDefinitions,
+    ...findLeadsProviderPreflightToolDefinitions,
     ...contextToolDefinitions,
     ...contentPostToolDefinitions,
     ...navigationToolDefinitions,

package/dist/tools/scheduler-fill-capacity.js

@@ -10,7 +10,7 @@ async function postSchedulerFillCapacity(body, workspaceId) {
 export const schedulerFillCapacityToolDefinitions = [
     {
         name: "get_scheduler_fill_capacity",
-        description: "read-only scheduler capacity query for refill-sends before any refill mutation. It asks the product scheduler model how many additional cells the scheduler will try to place for exact sender/action requests, using the default scheduler-forward horizon or one exact targetDate. It returns scheduler-fillable slots, occupied scheduled/processing slots, rolling-weekly candidate timing that shows when capacity frees later in the send window, sender sendability gates, cooldowns, Sales Navigator status for paid InMail, cached paid-InMail credit feasibility, threshold source, blockers, warnings, and explicit sideEffects false. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, does not refresh paid InMail credits, mutate thresholds, start campaigns, launch, or send. Use exact senderId values only; never pass sender names.",
+        description: "read-only scheduler capacity query for refill-sends before any refill mutation. It asks the product scheduler model how many additional cells the scheduler will try to place for exact sender/action requests, using the default scheduler-forward horizon or one exact targetDate. It returns scheduler-fillable slots, occupied scheduled/processing slots, sender sendability gates, cooldowns, Sales Navigator status for paid InMail, cached paid-InMail credit feasibility, threshold source, blockers, warnings, and explicit sideEffects false. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, does not refresh paid InMail credits, mutate thresholds, start campaigns, launch, or send. Use exact senderId values only; never pass sender names.",
         inputSchema: {
             type: "object",
             properties: {

package/dist/tools/scheduler-run.d.ts

@@ -1,23 +1,8 @@
 type SchedulerRunAction = "run" | "status";
-export declare const REFILL_SCHEDULER_EXPECTED_TARGET_LIMIT: 25;
-export declare const REFILL_SCHEDULER_EXPECTED_TARGET_SENDER_LIMIT: 100;
-export declare const REFILL_SCHEDULER_MAX_PLACEMENTS: 150;
-export type SchedulerExpectedTargetInput = {
-    campaignId: string;
-    tableId: string;
-    refillLaneKey: string;
-    branchActionTypes: Array<"send_invite" | "send_inmail_open" | "send_inmail_closed">;
-    senderIds: string[];
-};
 type RunSchedulerSweepInput = {
     workspaceId: string;
     action?: SchedulerRunAction;
     targetDate?: string;
-    requestKey?: string;
-    targetShapeRevision?: string;
-    expectedTargets?: SchedulerExpectedTargetInput[];
-    expectedTargetsHash?: string;
-    maxPlacements?: number;
 };
 export declare const schedulerRunToolDefinitions: {
     name: string;
@@ -38,62 +23,6 @@ export declare const schedulerRunToolDefinitions: {
                 type: string;
                 description: string;
             };
-            requestKey: {
-                type: string;
-                description: string;
-            };
-            targetShapeRevision: {
-                type: string;
-                description: string;
-            };
-            expectedTargets: {
-                type: string;
-                maxItems: 25;
-                items: {
-                    type: string;
-                    properties: {
-                        campaignId: {
-                            type: string;
-                        };
-                        tableId: {
-                            type: string;
-                        };
-                        refillLaneKey: {
-                            type: string;
-                        };
-                        branchActionTypes: {
-                            type: string;
-                            minItems: number;
-                            uniqueItems: boolean;
-                            items: {
-                                type: string;
-                                enum: string[];
-                            };
-                        };
-                        senderIds: {
-                            type: string;
-                            minItems: number;
-                            maxItems: 100;
-                            uniqueItems: boolean;
-                            items: {
-                                type: string;
-                            };
-                        };
-                    };
-                    required: string[];
-                    additionalProperties: boolean;
-                };
-            };
-            expectedTargetsHash: {
-                type: string;
-                description: string;
-            };
-            maxPlacements: {
-                type: string;
-                minimum: number;
-                maximum: 150;
-                description: string;
-            };
         };
         required: string[];
         additionalProperties: boolean;

package/dist/tools/scheduler-run.js

@@ -1,9 +1,5 @@
-import { createHash } from "crypto";
 import { getApi } from "../api.js";
 import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
-export const REFILL_SCHEDULER_EXPECTED_TARGET_LIMIT = 25;
-export const REFILL_SCHEDULER_EXPECTED_TARGET_SENDER_LIMIT = 100;
-export const REFILL_SCHEDULER_MAX_PLACEMENTS = 150;
 async function postSchedulerRun(body, workspaceId) {
     const api = getApi();
     const requestOptions = workspaceRequestOptions(workspaceId);
@@ -25,97 +21,10 @@ function normalizeTargetDate(value) {
     }
     return targetDate;
 }
-function normalizeOptionalScopeValue(value, field) {
-    if (value === undefined || value === null)
-        return null;
-    if (typeof value !== "string" || !value.trim()) {
-        throw new Error(`${field} must be a non-empty string when provided.`);
-    }
-    return value.trim();
-}
-function canonicalizeExpectedTargets(value) {
-    if (!Array.isArray(value) || value.length === 0) {
-        throw new Error("expectedTargets must be a non-empty array.");
-    }
-    if (value.length > REFILL_SCHEDULER_EXPECTED_TARGET_LIMIT) {
-        throw new Error(`expected_target_overflow: expectedTargets exceeds ${REFILL_SCHEDULER_EXPECTED_TARGET_LIMIT}.`);
-    }
-    const supportedActions = new Set([
-        "send_invite",
-        "send_inmail_open",
-        "send_inmail_closed",
-    ]);
-    const canonical = value.map((rawTarget, index) => {
-        if (!rawTarget ||
-            typeof rawTarget !== "object" ||
-            Array.isArray(rawTarget)) {
-            throw new Error(`expectedTargets[${index}] must be an object.`);
-        }
-        const target = rawTarget;
-        const allowedKeys = new Set([
-            "campaignId",
-            "tableId",
-            "refillLaneKey",
-            "branchActionTypes",
-            "senderIds",
-        ]);
-        if (Object.keys(target).some((key) => !allowedKeys.has(key))) {
-            throw new Error(`expectedTargets[${index}] contains unsupported fields.`);
-        }
-        const campaignId = normalizeOptionalScopeValue(target.campaignId, `expectedTargets[${index}].campaignId`);
-        const tableId = normalizeOptionalScopeValue(target.tableId, `expectedTargets[${index}].tableId`);
-        const refillLaneKey = normalizeOptionalScopeValue(target.refillLaneKey, `expectedTargets[${index}].refillLaneKey`);
-        if (!campaignId ||
-            !tableId ||
-            !refillLaneKey ||
-            !Array.isArray(target.branchActionTypes) ||
-            target.branchActionTypes.length === 0 ||
-            !Array.isArray(target.senderIds) ||
-            target.senderIds.length === 0) {
-            throw new Error(`expectedTargets[${index}] is incomplete.`);
-        }
-        if (target.senderIds.length > REFILL_SCHEDULER_EXPECTED_TARGET_SENDER_LIMIT) {
-            throw new Error(`expected_target_overflow: expectedTargets[${index}].senderIds exceeds ${REFILL_SCHEDULER_EXPECTED_TARGET_SENDER_LIMIT}.`);
-        }
-        const branchActionTypes = target.branchActionTypes.map((actionType) => {
-            if (typeof actionType !== "string" || !supportedActions.has(actionType)) {
-                throw new Error(`expectedTargets[${index}] contains an unsupported branch action.`);
-            }
-            return actionType;
-        });
-        const senderIds = target.senderIds.map((senderId) => {
-            const normalized = normalizeOptionalScopeValue(senderId, `expectedTargets[${index}].senderIds`);
-            if (!normalized) {
-                throw new Error(`expectedTargets[${index}].senderIds must be non-empty.`);
-            }
-            return normalized;
-        });
-        if (new Set(branchActionTypes).size !== branchActionTypes.length ||
-            new Set(senderIds).size !== senderIds.length) {
-            throw new Error(`expectedTargets[${index}] branchActionTypes and senderIds must be unique.`);
-        }
-        return {
-            campaignId,
-            tableId,
-            refillLaneKey,
-            branchActionTypes: branchActionTypes.sort(),
-            senderIds: senderIds.sort(),
-        };
-    });
-    canonical.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
-    const targetKeys = canonical.map((target) => JSON.stringify(target));
-    if (new Set(targetKeys).size !== targetKeys.length) {
-        throw new Error("expectedTargets contains duplicate canonical targets.");
-    }
-    return canonical;
-}
-function computeExpectedTargetsHash(targets) {
-    return createHash("sha256").update(JSON.stringify(targets)).digest("hex");
-}
 export const schedulerRunToolDefinitions = [
     {
         name: "run_scheduler_sweep",
-        description: 'Trigger the product scheduler placement sweep for one explicit workspace now, or read the last on-demand scheduler run status with action "status". A run is workspace-wide, not a scoped run for one campaign/table, and returns a synchronous envelope with status ran, attached, backoff, window_closed_noop, or failed; retryAfterMs for backoff replays; and a backward-compatible receipt. In v3 receipts, readyCellsFound is total scheduler-ready supply found before filters, cellsConsidered is the allocation-attempt count that survived prefilters, prefiltered means ready cells removed before allocation such as no capacity, stale paid InMail credit facts, or sender mismatch, skipped means considered cells rejected by hard scheduler gates, and deferred means considered cells waiting on windows/capacity/cooldown. campaignScopeSummary remains bounded display evidence, while expectedTargetSummary explains every hash-bound planner target exactly once without filtering placement. Expected targets require a frozen numeric total placement cap; unrelated eligible campaigns may consume that cap through normal workspace-wide gates, and changedCounts audits every actual placement by campaign, table, action, and sender. The receipt can include readyCellsByType, consideredCellsByType, prefilterReasons, skippedReasons, deferredReasons, summary, and nextAction. It places cells within existing scheduler gates only: it can move placement earlier, but it cannot bypass sending windows, daily limits, cooldowns, sender gates, billing, or credit thresholds, and it never sends messages directly. Repeated calls inside the backoff window replay the last receipt verbatim. Status is read-only and scoped to the last on-demand run only; cron sweeps are not recorded here.',
+        description: 'Trigger the product scheduler placement sweep for one explicit workspace now, or read the last on-demand scheduler run status with action "status". A run is workspace-wide, not a scoped run for one campaign/table, and returns a synchronous envelope with status ran, attached, backoff, window_closed_noop, or failed; retryAfterMs for backoff replays; and a backward-compatible receipt. In v2 receipts, readyCellsFound is total scheduler-ready supply found before filters, cellsConsidered is the allocation-attempt count that survived prefilters, prefiltered means ready cells removed before allocation such as no capacity, stale paid InMail credit facts, or sender mismatch, skipped means considered cells rejected by hard scheduler gates, and deferred means considered cells waiting on windows/capacity/cooldown. campaignScopeSummary lists bounded tables/campaigns the workspace-wide run inspected; absence there is not a scoped-run guarantee that the target was ready. The receipt can include readyCellsByType, consideredCellsByType, prefilterReasons, skippedReasons, deferredReasons, summary, and nextAction. It places cells within existing scheduler gates only: it can move placement earlier, but it cannot bypass sending windows, daily limits, cooldowns, sender gates, billing, or credit thresholds, and it never sends messages directly. Repeated calls inside the backoff window replay the last receipt verbatim. Status is read-only and scoped to the last on-demand run only; cron sweeps are not recorded here.',
         inputSchema: {
             type: "object",
             properties: {
@@ -132,64 +41,6 @@ export const schedulerRunToolDefinitions = [
                     type: "string",
                     description: "Optional one exact sender-local date (YYYY-MM-DD) to scope scheduler placement/status. The run remains workspace-wide inside that date.",
                 },
-                requestKey: {
-                    type: "string",
-                    description: "Optional deterministic planner action key used to attach to or replay the same exact scheduler attempt.",
-                },
-                targetShapeRevision: {
-                    type: "string",
-                    description: "Optional stable approved refill target-shape revision associated with requestKey.",
-                },
-                expectedTargets: {
-                    type: "array",
-                    maxItems: REFILL_SCHEDULER_EXPECTED_TARGET_LIMIT,
-                    items: {
-                        type: "object",
-                        properties: {
-                            campaignId: { type: "string" },
-                            tableId: { type: "string" },
-                            refillLaneKey: { type: "string" },
-                            branchActionTypes: {
-                                type: "array",
-                                minItems: 1,
-                                uniqueItems: true,
-                                items: {
-                                    type: "string",
-                                    enum: [
-                                        "send_invite",
-                                        "send_inmail_open",
-                                        "send_inmail_closed",
-                                    ],
-                                },
-                            },
-                            senderIds: {
-                                type: "array",
-                                minItems: 1,
-                                maxItems: REFILL_SCHEDULER_EXPECTED_TARGET_SENDER_LIMIT,
-                                uniqueItems: true,
-                                items: { type: "string" },
-                            },
-                        },
-                        required: [
-                            "campaignId",
-                            "tableId",
-                            "refillLaneKey",
-                            "branchActionTypes",
-                            "senderIds",
-                        ],
-                        additionalProperties: false,
-                    },
-                },
-                expectedTargetsHash: {
-                    type: "string",
-                    description: "Required SHA-256 of canonical expectedTargets for a target-aware run.",
-                },
-                maxPlacements: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: REFILL_SCHEDULER_MAX_PLACEMENTS,
-                    description: "Required frozen numeric total placement cap across the workspace-wide sweep when expectedTargets are present.",
-                },
             },
             required: ["workspaceId"],
             additionalProperties: false,
@@ -203,65 +54,12 @@ export async function runSchedulerSweep(input) {
     }
     const action = input.action ?? "run";
     const targetDate = normalizeTargetDate(input.targetDate);
-    const requestKey = normalizeOptionalScopeValue(input.requestKey, "requestKey");
-    const targetShapeRevision = normalizeOptionalScopeValue(input.targetShapeRevision, "targetShapeRevision");
     if (action !== "run" && action !== "status") {
         throw new Error('action must be "run" or "status" for run_scheduler_sweep.');
     }
-    const hasExpectedTargets = input.expectedTargets !== undefined;
-    const hasExpectedTargetScope = input.expectedTargetsHash !== undefined ||
-        input.maxPlacements !== undefined;
-    if (action === "status" && hasExpectedTargets) {
-        throw new Error("expectedTargets are only valid for action run.");
-    }
-    let expectedTargetRequest;
-    if (action === "run" && (hasExpectedTargets || hasExpectedTargetScope)) {
-        const expectedTargets = canonicalizeExpectedTargets(input.expectedTargets);
-        const expectedTargetsHash = normalizeOptionalScopeValue(input.expectedTargetsHash, "expectedTargetsHash");
-        if (!expectedTargetsHash ||
-            expectedTargetsHash !== computeExpectedTargetsHash(expectedTargets)) {
-            throw new Error("expectedTargetsHash must match the canonical expectedTargets payload.");
-        }
-        if (typeof input.maxPlacements !== "number" ||
-            !Number.isInteger(input.maxPlacements) ||
-            input.maxPlacements <= 0 ||
-            input.maxPlacements > REFILL_SCHEDULER_MAX_PLACEMENTS) {
-            throw new Error(`maxPlacements must be an integer from 1 to ${REFILL_SCHEDULER_MAX_PLACEMENTS}.`);
-        }
-        if (!targetDate || !requestKey || !targetShapeRevision) {
-            throw new Error("expectedTargets require targetDate, requestKey, and targetShapeRevision.");
-        }
-        expectedTargetRequest = {
-            expectedTargets,
-            expectedTargetsHash,
-            maxPlacements: input.maxPlacements,
-        };
-    }
-    let expectedStatusScope;
-    if (action === "status" && hasExpectedTargetScope) {
-        const expectedTargetsHash = normalizeOptionalScopeValue(input.expectedTargetsHash, "expectedTargetsHash");
-        if (!expectedTargetsHash ||
-            typeof input.maxPlacements !== "number" ||
-            !Number.isInteger(input.maxPlacements) ||
-            input.maxPlacements <= 0 ||
-            input.maxPlacements > REFILL_SCHEDULER_MAX_PLACEMENTS ||
-            !targetDate ||
-            !requestKey ||
-            !targetShapeRevision) {
-            throw new Error("hash-bound status requires expectedTargetsHash, maxPlacements, targetDate, requestKey, and targetShapeRevision.");
-        }
-        expectedStatusScope = {
-            expectedTargetsHash,
-            maxPlacements: input.maxPlacements,
-        };
-    }
     return postSchedulerRun({
         workspaceId,
         action,
         ...(targetDate ? { targetDate } : {}),
-        ...(requestKey ? { requestKey } : {}),
-        ...(targetShapeRevision ? { targetShapeRevision } : {}),
-        ...(expectedTargetRequest ?? {}),
-        ...(expectedStatusScope ?? {}),
     }, workspaceId);
 }

package/dist/tools/setup-evergreen-campaigns.js

@@ -6,7 +6,7 @@ async function postSetupEvergreenCampaigns(body, workspaceId) {
 export const setupEvergreenCampaignsToolDefinitions = [
     {
         name: "setup_evergreen_campaigns",
-        description: "Evergreen campaign setup plan/verify command. Use plan mode first to inspect exact workspace/sender/campaign/table/source state and receive immutable lane packets. `selectedSenderIds` is a legacy shorthand for both scopes; prefer `postEngagerSenderIds` for the Post Engagers sender scope and `sharedSenderIds` for the shared lane sender scope when they differ. `sharedSenderIds` must include every intended shared-lane sender, not only the named Post Engagers sender; when adding other senders to existing shared evergreen campaigns, resolve those sender ids with list_senders and pass the full shared set. If a protected existing Post Engagers campaign must stay unchanged and the operator requested only shared lane execution, pass postEngagerSenderIds:[] and sharedSenderIds; do not include the protected active Post Engagers lane as a reuse packet because it can make the yolo plan non-autoExecutable. The command plans one Post Engagers lane per post-engager sender plus shared Signal Discovery and Shared Cold Fallback lanes for the shared sender set. Non-archived PAUSED/ACTIVE/DRAFT shared campaigns/tables are the reusable targets; archived campaigns, archived tables, and archived waterfall bindings are stale inventory and must not be counted as valid evergreen slots. If an existing non-archived shared campaign is already attached to additional senders, plan reporting should count those attached senders as existing shared-lane membership rather than treating them as missing or duplicate slots. yolo is only a parent-skill auto-execution hint for safe lane packets; pass yolo only in plan mode and never include yolo on mode:\"verify\" calls. This backend command remains read-only in plan mode and verifies receipts in verify mode. Package-backed prompt authority: the installed public wrapper can be the local Codex skill entrypoint, but lane workers must use get_subskill_prompt and get_subskill_asset for nested `$sellable:create-campaign`, create-campaign-v2, generate-messages, validation, and assets; nested filesystem prompt fallback is a failed UAT. Use mcp__sellable only for workspace selection and product mutations/readbacks. Do not use mcp__sellable_admin, direct DB, Prisma, SQL, built-in web search, browser search, web.run, or any external browsing/search tool as execution or research proof; if Sellable MCP research tools are insufficient, write a blocked receipt instead of browsing externally. Worker-local replans are read-only drift checks and must preserve the exact parent sender scopes, including postEngagerSenderIds:[] when intentionally empty and the exact sharedSenderIds array; if scope, planRevision, actionId, or laneKey drifts, stop with blocked:worker_plan_scope_drift before mutation. Each lane packet includes workerDispatch with preferredRuntime, runtimeFallbackOrder, acceptedRuntimes, rejectedRuntimes, requiresVisibleThreadOrDurableReceipt, receiptArtifactHint, receiptRunId, and receiptMustBeWrittenAfter; pre-existing receipts at old deterministic paths are stale and must not be used, so stop with blocked:stale_receipt_artifact if the receipt was not freshly written for the current receiptRunId. `multi_agent_v1.spawn_agent`/opaque spawn_agent is not accepted for mutating command proof unless the parent has visible thread or durable receipt proof. In local Codex, default to `workerDispatch.preferredRuntime` (`visible-codex-app-thread`): discover Codex app thread tools if needed, then call `codex_app.list_projects` and `codex_app.create_thread` with a local project target; do not create a worktree for lane execution. If Codex app thread tools are unavailable but local Codex CLI is available, use durable streaming workers with `codex -a never -s danger-full-access -c model_reasoning_effort=high exec --skip-git-repo-check -m <worker-model> -C <repo> -o <worker-final-file> -` and include preferredRuntimeAttempt plus fallbackReason in createCampaignWorkflowReceipt; approval, sandbox, and reasoning-effort config flags must appear before `exec`, and current customer CLI installs reject `codex exec --ask-for-approval never` and `codex exec -a never`. Do not rely on default model or default reasoning effort: copy the parent model such as `gpt-5.6-sol` into `-m` and always pass `-c model_reasoning_effort=high`; a child worker that reports GPT 5.6-Sol with reasoning below high is a launcher bug to relaunch before mutation, not a user-continue path. Plan responses include approvalSummary; render approvalSummary when asking for bounded delegated approval because it explicitly lists campaignsToCreate, campaignsToUpdate, campaignsToVerifyOnly, campaignsLeftUntouched, attachedSenders, selectedActionIds, allowedSideEffects, forbiddenSideEffects, blockers, and approvalQuestion. When safe-yolo needs normal setup work, the parent skill may ask for bounded delegated approval: one approval over the current planRevision, selected action ids, caps, allowed side-effect classes, and stop conditions lets lane workers execute without per-substep approval while staying inside that packet. In exec/automation mode, do not call request_user_input; if yolo plan autoExecutable:false and no interactive approval can be received, stop with blocked:bounded_approval_unavailable_in_exec_mode before any mutation. Lane workers must explicitly load and use the installed `$sellable:create-campaign` wrapper as the nested workflow entrypoint, then load `create-campaign-v2` and `create-campaign-v2/core/flow.v2.json`; they must execute creation, source import, create-campaign workflow steps, generate-messages, sequence attachment, pause_campaign review-state transition when the current table is still DRAFT, and review readiness through that existing create-campaign workflow/subskills, then return receipts here for verification. Customer-visible verify receipts must set status:'succeeded' or status:'completed'; status:'passed', status:'pass', and status:'passed_with_warnings' are rejected as primary success statuses. Exception: a Post Engagers lane may write status:'blocked' with blocker:'post_engagers_no_sender_posts', 'post_engagers_no_recent_sender_posts', 'post_engagers_no_sender_owned_posts', or 'post_engagers_source_author_mismatch' when Sellable MCP readback proves no usable sender-authored posts/source exists; verify returns these as acceptedLaneBlockers so the parent can report the no-op instead of retrying invalid source repair. Any other blocked receipt, including model-quality/preflight or worker model availability blockers, is not a goal-complete success condition and must not let the parent report evergreen completion. Receipts must include createCampaignStepReceipt with setupPlanCall, createCampaignWorkflowReceipt, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall nested inside createCampaignStepReceipt; top-level-only copies of those objects are not enough and are not promoted by verify. setupPlanCall must use canonical keys: planRevision, actionId, laneKey, workspaceId, senderIds, campaignId, tableId, createIntent. Do not use laneActionId, lanePacketActionId, delegatedPlanRevision, delegatedActionId, or requestedCall text as a substitute for those canonical fields. createCampaignWorkflowReceipt must include skillCommand:'$sellable:create-campaign', skillName:'create-campaign', wrapperSkillLoaded:true, workflowPromptName:'create-campaign-v2', workflowPromptLoadedToHasMoreFalse:true, workflowAssetPath:'create-campaign-v2/core/flow.v2.json', workflowAssetLoaded:true, workerRuntime, workerThreadId or receiptArtifactPath, durableReceiptWritten when using a receipt file, and notAdHoc:true; CLI durable fallback runtimes must also include preferredRuntimeAttempt for visible-codex-app-thread and fallbackReason. messageDraftingReceipt must use exactly statusSource:'branch' or statusSource:'packaged-generate-messages-worker'; descriptive aliases such as statusSource:'package-readback-local-thread' are rejected. It must include proof that generate-messages was loaded, start_campaign_message_preparation/get_campaign_message_preparation_status ran when the packaged worker path is used, validationResult:'passed', a passed qualityReview, and at least 3 concrete sampleMessages with rowId, generatedMessageText, verdict, and issues; Do not substitute `message` for `generatedMessageText`; Do not substitute `passVerdict` for `verdict`. Before writing durable receipts, run a receipt self-check: top-level `planRevision`, `actionId`, `laneKey`, `laneType`, `workspaceId`, and `senderIds` must exist; if the self-check fails, fix the receipt before ending. Use start_campaign_message_preparation with approvalMode:\"mark_ready\" only for evergreen setup. Never call `start_campaign_message_preparation` with `approvalMode:\"approve\"`; approve exactly one semantic Approved cell through select_campaign_cells/update_cell and final proof must show approvedGeneratedMessageCount exactly 1. Shared Cold Fallback samples with a standalone name followed by 'Hey there' are rejected. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, does not raw-write campaign status, does not archive/delete cleanup targets, and does not spend paid credits.",
+        description: "Evergreen campaign setup plan/verify command. Use plan mode first to inspect exact workspace/sender/campaign/table/source state and receive immutable lane packets. `selectedSenderIds` is a legacy shorthand for both scopes; prefer `postEngagerSenderIds` for the Post Engagers sender scope and `sharedSenderIds` for the shared lane sender scope when they differ. `sharedSenderIds` must include every intended shared-lane sender, not only the named Post Engagers sender; when adding other senders to existing shared evergreen campaigns, resolve those sender ids with list_senders and pass the full shared set. If a protected existing Post Engagers campaign must stay unchanged and the operator requested only shared lane execution, pass postEngagerSenderIds:[] and sharedSenderIds; do not include the protected active Post Engagers lane as a reuse packet because it can make the yolo plan non-autoExecutable. The command plans one Post Engagers lane per post-engager sender plus shared Signal Discovery and Shared Cold Fallback lanes for the shared sender set. Non-archived PAUSED/ACTIVE/DRAFT shared campaigns/tables are the reusable targets; archived campaigns, archived tables, and archived waterfall bindings are stale inventory and must not be counted as valid evergreen slots. If an existing non-archived shared campaign is already attached to additional senders, plan reporting should count those attached senders as existing shared-lane membership rather than treating them as missing or duplicate slots. yolo is only a parent-skill auto-execution hint for safe lane packets; pass yolo only in plan mode and never include yolo on mode:\"verify\" calls. This backend command remains read-only in plan mode and verifies receipts in verify mode. Package-backed prompt authority: the installed public wrapper can be the local Codex skill entrypoint, but lane workers must use get_subskill_prompt and get_subskill_asset for nested `$sellable:create-campaign`, create-campaign-v2, generate-messages, validation, and assets; nested filesystem prompt fallback is a failed UAT. Use mcp__sellable only for workspace selection and product mutations/readbacks. Do not use mcp__sellable_admin, direct DB, Prisma, SQL, built-in web search, browser search, web.run, or any external browsing/search tool as execution or research proof; if Sellable MCP research tools are insufficient, write a blocked receipt instead of browsing externally. Worker-local replans are read-only drift checks and must preserve the exact parent sender scopes, including postEngagerSenderIds:[] when intentionally empty and the exact sharedSenderIds array; if scope, planRevision, actionId, or laneKey drifts, stop with blocked:worker_plan_scope_drift before mutation. Each lane packet includes workerDispatch with preferredRuntime, runtimeFallbackOrder, acceptedRuntimes, rejectedRuntimes, requiresVisibleThreadOrDurableReceipt, receiptArtifactHint, receiptRunId, and receiptMustBeWrittenAfter; pre-existing receipts at old deterministic paths are stale and must not be used, so stop with blocked:stale_receipt_artifact if the receipt was not freshly written for the current receiptRunId. `multi_agent_v1.spawn_agent`/opaque spawn_agent is not accepted for mutating command proof unless the parent has visible thread or durable receipt proof. In local Codex, default to `workerDispatch.preferredRuntime` (`visible-codex-app-thread`): discover Codex app thread tools if needed, then call `codex_app.list_projects` and `codex_app.create_thread` with a local project target; do not create a worktree for lane execution. If Codex app thread tools are unavailable but local Codex CLI is available, use durable streaming workers with `codex -a never -s danger-full-access -c model_reasoning_effort=xhigh exec --skip-git-repo-check -m <worker-model> -C <repo> -o <worker-final-file> -` and include preferredRuntimeAttempt plus fallbackReason in createCampaignWorkflowReceipt; approval, sandbox, and reasoning-effort config flags must appear before `exec`, and current customer CLI installs reject `codex exec --ask-for-approval never` and `codex exec -a never`. Do not rely on default model or default reasoning effort: copy the parent model such as `gpt-5.5` into `-m` and always pass `-c model_reasoning_effort=xhigh`; a child worker that reports GPT 5.5 with high reasoning is a launcher bug to relaunch before mutation, not a user-continue path. Plan responses include approvalSummary; render approvalSummary when asking for bounded delegated approval because it explicitly lists campaignsToCreate, campaignsToUpdate, campaignsToVerifyOnly, campaignsLeftUntouched, attachedSenders, selectedActionIds, allowedSideEffects, forbiddenSideEffects, blockers, and approvalQuestion. When safe-yolo needs normal setup work, the parent skill may ask for bounded delegated approval: one approval over the current planRevision, selected action ids, caps, allowed side-effect classes, and stop conditions lets lane workers execute without per-substep approval while staying inside that packet. In exec/automation mode, do not call request_user_input; if yolo plan autoExecutable:false and no interactive approval can be received, stop with blocked:bounded_approval_unavailable_in_exec_mode before any mutation. Lane workers must explicitly load and use the installed `$sellable:create-campaign` wrapper as the nested workflow entrypoint, then load `create-campaign-v2` and `create-campaign-v2/core/flow.v2.json`; they must execute creation, source import, create-campaign workflow steps, generate-messages, sequence attachment, pause_campaign review-state transition when the current table is still DRAFT, and review readiness through that existing create-campaign workflow/subskills, then return receipts here for verification. Customer-visible verify receipts must set status:'succeeded' or status:'completed'; status:'passed', status:'pass', and status:'passed_with_warnings' are rejected as primary success statuses. Exception: a Post Engagers lane may write status:'blocked' with blocker:'post_engagers_no_sender_posts', 'post_engagers_no_recent_sender_posts', 'post_engagers_no_sender_owned_posts', or 'post_engagers_source_author_mismatch' when Sellable MCP readback proves no usable sender-authored posts/source exists; verify returns these as acceptedLaneBlockers so the parent can report the no-op instead of retrying invalid source repair. Any other blocked receipt, including model-quality/preflight or worker model availability blockers, is not a goal-complete success condition and must not let the parent report evergreen completion. Receipts must include createCampaignStepReceipt with setupPlanCall, createCampaignWorkflowReceipt, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall nested inside createCampaignStepReceipt; top-level-only copies of those objects are not enough and are not promoted by verify. setupPlanCall must use canonical keys: planRevision, actionId, laneKey, workspaceId, senderIds, campaignId, tableId, createIntent. Do not use laneActionId, lanePacketActionId, delegatedPlanRevision, delegatedActionId, or requestedCall text as a substitute for those canonical fields. createCampaignWorkflowReceipt must include skillCommand:'$sellable:create-campaign', skillName:'create-campaign', wrapperSkillLoaded:true, workflowPromptName:'create-campaign-v2', workflowPromptLoadedToHasMoreFalse:true, workflowAssetPath:'create-campaign-v2/core/flow.v2.json', workflowAssetLoaded:true, workerRuntime, workerThreadId or receiptArtifactPath, durableReceiptWritten when using a receipt file, and notAdHoc:true; CLI durable fallback runtimes must also include preferredRuntimeAttempt for visible-codex-app-thread and fallbackReason. messageDraftingReceipt must use exactly statusSource:'branch' or statusSource:'packaged-generate-messages-worker'; descriptive aliases such as statusSource:'package-readback-local-thread' are rejected. It must include proof that generate-messages was loaded, start_campaign_message_preparation/get_campaign_message_preparation_status ran when the packaged worker path is used, validationResult:'passed', a passed qualityReview, and at least 3 concrete sampleMessages with rowId, generatedMessageText, verdict, and issues; Do not substitute `message` for `generatedMessageText`; Do not substitute `passVerdict` for `verdict`. Before writing durable receipts, run a receipt self-check: top-level `planRevision`, `actionId`, `laneKey`, `laneType`, `workspaceId`, and `senderIds` must exist; if the self-check fails, fix the receipt before ending. Use start_campaign_message_preparation with approvalMode:\"mark_ready\" only for evergreen setup. Never call `start_campaign_message_preparation` with `approvalMode:\"approve\"`; approve exactly one semantic Approved cell through select_campaign_cells/update_cell and final proof must show approvedGeneratedMessageCount exactly 1. Shared Cold Fallback samples with a standalone name followed by 'Hey there' are rejected. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, does not raw-write campaign status, does not archive/delete cleanup targets, and does not spend paid credits.",
         inputSchema: {
             type: "object",
             properties: {

package/dist/tools/workspace-context.d.ts

@@ -12,7 +12,7 @@ export interface WorkspaceContext {
     executionMode: WorkspaceExecutionMode;
     toolName?: string;
     runId: string;
-    workspaceResolution: "explicit" | "locked_profile";
+    workspaceResolution: "explicit";
 }
 export interface WorkspaceRequiredResult {
     ok: false;

package/dist/tools/workspace-context.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { getLockedWorkspaceId, resolveWorkspaceIdForRequest, } from "../auth.js";
 export function workspaceRequired(params) {
     const toolLabel = params.toolName ? ` for ${params.toolName}` : "";
     return {
@@ -16,13 +15,11 @@ export function normalizeExplicitWorkspaceId(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 export function workspaceRequestOptions(workspaceId) {
-    const normalized = resolveWorkspaceIdForRequest(normalizeExplicitWorkspaceId(workspaceId), "workspace request options");
+    const normalized = normalizeExplicitWorkspaceId(workspaceId);
     return normalized ? Object.freeze({ workspaceId: normalized }) : undefined;
 }
 export function createWorkspaceContext(input) {
-    const explicitWorkspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
-    const lockedWorkspaceId = getLockedWorkspaceId();
-    const workspaceId = resolveWorkspaceIdForRequest(explicitWorkspaceId, input.toolName || "workspace context");
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
     if (!workspaceId) {
         return workspaceRequired({
             executionMode: input.executionMode,
@@ -36,9 +33,7 @@ export function createWorkspaceContext(input) {
         executionMode: input.executionMode,
         toolName: input.toolName,
         runId: input.runId?.trim() || randomUUID(),
-        workspaceResolution: lockedWorkspaceId && !explicitWorkspaceId
-            ? "locked_profile"
-            : "explicit",
+        workspaceResolution: "explicit",
     });
     return { ok: true, context };
 }

package/dist/tools/workspace-export.js

@@ -4,7 +4,7 @@ import { lstat, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { getApi } from "../api.js";
-import { getConfig, getEffectiveConfiguredWorkspaceId } from "../auth.js";
+import { getConfig } from "../auth.js";
 const MAX_FILTER_IDS = 100;
 const MAX_QUERY_LENGTH = 8000;
 export const workspaceExportToolDefinitions = [
@@ -340,7 +340,7 @@ async function writeJsonAtomic(filePath, value) {
 }
 export async function exportWorkspaceCsv(input = {}) {
     const config = getConfig();
-    const workspaceId = getEffectiveConfiguredWorkspaceId(config);
+    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
     if (!workspaceId) {
         throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before export_workspace_csv.");
     }

package/dist/tools/workspaces.d.ts

@@ -140,56 +140,21 @@ export declare const workspaceToolDefinitions: ({
 })[];
 export declare function listWorkspaces(): Promise<{
     workspaces: WorkspaceSummary[];
-    workspaceLock: {
-        enabled: boolean;
-        workspaceId?: undefined;
-        hiddenWorkspaceCount?: undefined;
-    };
-} | {
-    workspaces: WorkspaceSummary[];
-    workspaceLock: {
-        enabled: boolean;
-        workspaceId: string;
-        hiddenWorkspaceCount: number;
-    };
 }>;
 export declare function getActiveWorkspace(): {
     activeWorkspaceId: string | null;
     activeWorkspaceName: string | null;
-    workspaceLock: {
-        enabled: boolean;
-        workspaceId: string;
-    } | {
-        enabled: boolean;
-        workspaceId?: undefined;
-    };
 };
 export declare function getWorkspace(workspaceId: string): Promise<{
-    ok: boolean;
-    error: string;
-    workspace?: undefined;
-} | {
     workspace: WorkspaceDetails;
-    ok?: undefined;
-    error?: undefined;
 }>;
 export declare function setActiveWorkspace(workspaceId: string, userConfirmed?: boolean): Promise<{
     ok: boolean;
-    code: string;
-    activeWorkspaceId: string;
-    requestedWorkspaceId: string;
     error: string;
     requiresConfirmation?: undefined;
-    activeWorkspaceName?: undefined;
-    requestedWorkspaceName?: undefined;
-} | {
-    ok: boolean;
-    error: string;
-    code?: undefined;
     activeWorkspaceId?: undefined;
-    requestedWorkspaceId?: undefined;
-    requiresConfirmation?: undefined;
     activeWorkspaceName?: undefined;
+    requestedWorkspaceId?: undefined;
     requestedWorkspaceName?: undefined;
 } | {
     ok: boolean;
@@ -199,33 +164,22 @@ export declare function setActiveWorkspace(workspaceId: string, userConfirmed?:
     requestedWorkspaceId: string;
     requestedWorkspaceName: string;
     error: string;
-    code?: undefined;
 } | {
     ok: boolean;
     activeWorkspaceId: string;
     activeWorkspaceName: string;
-    code?: undefined;
-    requestedWorkspaceId?: undefined;
     error?: undefined;
     requiresConfirmation?: undefined;
+    requestedWorkspaceId?: undefined;
     requestedWorkspaceName?: undefined;
 }>;
 export declare function createWorkspace(name: string): Promise<{
-    ok: boolean;
-    code: string;
-    activeWorkspaceId: string;
-    error: string;
-    workspace?: undefined;
-} | {
     workspace: {
         id: string;
         name: string;
         slug: string;
     };
     activeWorkspaceId: string;
-    ok?: undefined;
-    code?: undefined;
-    error?: undefined;
 }>;
 export declare function addTeammate(input: {
     workspaceId?: string;