@sellable/mcp 0.1.553 → 0.1.554

package/dist/tools/refill-target-plan.js

@@ -10,7 +10,6 @@ const SAFE_PACKET_ACTION_TYPES = new Set([
     "approve_messages",
     "start_paused_campaign",
     "rerun_errored_cells",
-    "run_scheduler_sweep",
     "wait_for_scheduler",
     "wait_for_active_work",
     "wait_for_source_import",
@@ -74,21 +73,6 @@ const PREP_FAILURE_RECOMMENDED_ACTIONS = new Set([
     "approve_or_repair_approval_cells",
     "inspect_rows",
 ]);
-const SCHEDULER_SWEEP_ALLOWED_SIDE_EFFECTS = [
-    "schedule any eligible workspace cells on the approved date within scheduler gates",
-];
-const SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS = [
-    "send directly",
-    "write scheduler fields directly",
-    "change campaign state",
-    "change sender limits",
-    "change source selection",
-];
-const SCHEDULER_SWEEP_RECEIPT_GROUPS = [
-    "campaignId",
-    "tableId",
-    "actionType",
-];
 async function postRefillTargetPlan(body, workspaceId) {
     const api = getApi();
     const requestOptions = workspaceRequestOptions(workspaceId);
@@ -531,7 +515,6 @@ function sanitizeStructuredAction(action, selectedBySender, mode, rank) {
             : null,
         stopCondition: stringValue(action.stopCondition) ?? "",
         yoloEligible,
-        actionKey: stringValue(action.actionKey),
         capSaturated: booleanValue(action.capSaturated) === true ? true : undefined,
         prepFailureDiagnosis: sanitizePrepFailureDiagnosis(action.prepFailureDiagnosis),
     };
@@ -831,154 +814,6 @@ function buildSanitizedGlobalActionQueue(senderRefillPlans) {
         rank: index + 1,
     }));
 }
-function sortedUniqueStrings(value) {
-    return [...new Set(stringArray(value))].sort();
-}
-function sameStrings(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}
-function sanitizeSchedulerSweepSourceScopes(value) {
-    if (!Array.isArray(value))
-        return [];
-    const scopes = value.flatMap((entry) => {
-        if (!isRecord(entry))
-            return [];
-        const campaignId = stringValue(entry.campaignId)?.trim();
-        const tableId = stringValue(entry.tableId)?.trim();
-        const sourceLeadListId = stringValue(entry.sourceLeadListId)?.trim();
-        const leadSourceProvider = stringValue(entry.leadSourceProvider)?.trim();
-        if (!campaignId ||
-            !tableId ||
-            !sourceLeadListId ||
-            !leadSourceProvider) {
-            return [];
-        }
-        return [
-            { campaignId, tableId, sourceLeadListId, leadSourceProvider },
-        ];
-    });
-    const unique = new Map(scopes.map((scope) => [
-        [
-            scope.campaignId,
-            scope.tableId,
-            scope.sourceLeadListId,
-            scope.leadSourceProvider,
-        ].join(":"),
-        scope,
-    ]));
-    return [...unique.values()].sort((a, b) => {
-        if (a.campaignId !== b.campaignId) {
-            return a.campaignId.localeCompare(b.campaignId);
-        }
-        return a.tableId.localeCompare(b.tableId);
-    });
-}
-function sanitizeTargetSchedulerSweep(params) {
-    if (!Array.isArray(params.value) ||
-        !params.expectedWorkspaceId ||
-        !params.expectedTargetDate ||
-        !/^\d{4}-\d{2}-\d{2}$/.test(params.expectedTargetDate) ||
-        !params.expectedTargetShapeRevision ||
-        !params.expectedStateRevision ||
-        params.remainingProjectedGap <= 0 ||
-        params.remainingReadyOrProjectedGap !== 0) {
-        return null;
-    }
-    const expectedSenderIds = [...params.selectedBySender.keys()].sort();
-    const expectedActionTypes = [
-        ...new Set(params.selectedBySender.values()),
-    ].sort();
-    if (expectedSenderIds.length === 0 || expectedActionTypes.length === 0) {
-        return null;
-    }
-    for (const rawAction of params.value) {
-        if (!isRecord(rawAction) || rawAction.type !== "run_scheduler_sweep") {
-            continue;
-        }
-        const input = isRecord(rawAction.toolInput) ? rawAction.toolInput : {};
-        const actionKey = stringValue(rawAction.actionKey)?.trim();
-        const requestKey = stringValue(input.requestKey)?.trim();
-        const senderIds = sortedUniqueStrings(input.senderIds);
-        const actionTypes = sortedUniqueStrings(input.actionTypes).filter((actionType) => allowedActionType(actionType) === actionType);
-        const campaignIds = sortedUniqueStrings(input.campaignIds);
-        const tableIds = sortedUniqueStrings(input.tableIds);
-        const sourceScopes = sanitizeSchedulerSweepSourceScopes(input.sourceScopes);
-        const receiptRequirements = isRecord(rawAction.receiptRequirements)
-            ? rawAction.receiptRequirements
-            : {};
-        const groupBy = stringArray(receiptRequirements.groupBy);
-        const allowedSideEffects = stringArray(rawAction.allowedSideEffects);
-        const forbiddenSideEffects = stringArray(rawAction.forbiddenSideEffects);
-        const rawActionType = allowedActionType(rawAction.actionType);
-        if (input.action !== "run" ||
-            input.workspaceId !== params.expectedWorkspaceId ||
-            input.targetDate !== params.expectedTargetDate ||
-            input.targetDateKey !== params.expectedTargetDate ||
-            input.targetShapeRevision !== params.expectedTargetShapeRevision ||
-            input.stateRevision !== params.expectedStateRevision ||
-            !actionKey ||
-            requestKey !== actionKey ||
-            !sameStrings(senderIds, expectedSenderIds) ||
-            !sameStrings(actionTypes, expectedActionTypes) ||
-            (expectedActionTypes.length === 1 &&
-                rawActionType !== expectedActionTypes[0]) ||
-            campaignIds.length === 0 ||
-            tableIds.length === 0 ||
-            sourceScopes.length === 0 ||
-            sourceScopes.some((scope) => !campaignIds.includes(scope.campaignId) ||
-                !tableIds.includes(scope.tableId)) ||
-            rawAction.toolName !== "run_scheduler_sweep" ||
-            rawAction.sideEffectClass !== "scheduler_placement" ||
-            rawAction.workspaceWide !== true ||
-            rawAction.yoloEligible !== true ||
-            receiptRequirements.nonTruncated !== true ||
-            !sameStrings(groupBy, SCHEDULER_SWEEP_RECEIPT_GROUPS) ||
-            !sameStrings(allowedSideEffects, SCHEDULER_SWEEP_ALLOWED_SIDE_EFFECTS) ||
-            !sameStrings(forbiddenSideEffects, SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS)) {
-            continue;
-        }
-        return {
-            rank: 1,
-            type: "run_scheduler_sweep",
-            actionType: rawActionType,
-            toolName: "run_scheduler_sweep",
-            sideEffectClass: "scheduler_placement",
-            ids: {},
-            toolInput: {
-                action: "run",
-                workspaceId: params.expectedWorkspaceId,
-                targetDate: params.expectedTargetDate,
-                targetDateKey: params.expectedTargetDate,
-                senderIds,
-                actionTypes,
-                campaignIds,
-                tableIds,
-                sourceScopes,
-                targetShapeRevision: params.expectedTargetShapeRevision,
-                stateRevision: params.expectedStateRevision,
-                requestKey,
-            },
-            inputSummary: stringValue(rawAction.inputSummary) ?? "",
-            reason: stringValue(rawAction.reason) ?? "",
-            prerequisites: stringArray(rawAction.prerequisites),
-            rereadAfter: rawAction.rereadAfter === "get_refill_target_plan"
-                ? "get_refill_target_plan"
-                : null,
-            stopCondition: stringValue(rawAction.stopCondition) ?? "",
-            yoloEligible: true,
-            workspaceWide: true,
-            allowedSideEffects: [...SCHEDULER_SWEEP_ALLOWED_SIDE_EFFECTS],
-            forbiddenSideEffects: [...SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS],
-            receiptRequirements: {
-                nonTruncated: true,
-                groupBy: [...SCHEDULER_SWEEP_RECEIPT_GROUPS],
-            },
-            actionKey,
-        };
-    }
-    return null;
-}
 function paidRefreshNeededSenderIds(senderRefillPlans) {
     const senderIds = new Set();
     for (const plan of senderRefillPlans) {
@@ -1124,8 +959,8 @@ function sanitizeRefillTargetPlanResult(result) {
     const grossTarget = senderPlans.reduce((sum, plan) => sum + numberValue(plan.grossTarget), 0);
     const requestedTarget = senderPlans.reduce((sum, plan) => sum + numberValue(plan.requestedTarget), 0);
     const effectiveTarget = senderPlans.reduce((sum, plan) => {
-        const target = typeof plan.effectiveTarget === "number"
-            ? plan.effectiveTarget
+        const target = typeof plan.schedulerCapacityTarget === "number"
+            ? plan.schedulerCapacityTarget
             : numberValue(plan.grossTarget);
         return sum + target;
     }, 0);
@@ -1140,20 +975,7 @@ function sanitizeRefillTargetPlanResult(result) {
     const senderRefillPlans = sanitizeStructuredSenderPlans(target.senderRefillPlans, selectedBySender);
     const paidRefreshNeededSenderIdSet = paidRefreshNeededSenderIds(senderRefillPlans);
     const blockers = sanitizeBlockers(result.blockers, selectedKeys, paidRefreshNeededSenderIdSet);
-    const request = isRecord(result.request) ? result.request : {};
-    const schedulerSweepAction = sanitizeTargetSchedulerSweep({
-        value: target.globalActionQueue,
-        selectedBySender,
-        expectedWorkspaceId: stringValue(target.workspaceId),
-        expectedTargetDate: stringValue(request.targetDate),
-        expectedTargetShapeRevision: stringValue(result.targetShapeRevision),
-        expectedStateRevision: stringValue(result.stateRevision),
-        remainingProjectedGap,
-        remainingReadyOrProjectedGap,
-    });
-    const globalActionQueue = schedulerSweepAction
-        ? [schedulerSweepAction]
-        : buildSanitizedGlobalActionQueue(senderRefillPlans);
+    const globalActionQueue = buildSanitizedGlobalActionQueue(senderRefillPlans);
     const hasTerminalNoActionBlocker = globalActionQueue.length === 0 &&
         blockers.some((blocker) => TERMINAL_NO_ACTION_BLOCKER_CODES.has(String(blocker.code)));
     const status = remainingProjectedGap === 0

package/dist/tools/registry.d.ts

@@ -7546,14 +7546,6 @@ export declare const allTools: ({
                 type: string;
                 description: string;
             };
-            requestKey: {
-                type: string;
-                description: string;
-            };
-            targetShapeRevision: {
-                type: string;
-                description: string;
-            };
         };
         required: string[];
         additionalProperties: boolean;

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

@@ -3,8 +3,6 @@ type RunSchedulerSweepInput = {
     workspaceId: string;
     action?: SchedulerRunAction;
     targetDate?: string;
-    requestKey?: string;
-    targetShapeRevision?: string;
 };
 export declare const schedulerRunToolDefinitions: {
     name: string;
@@ -25,14 +23,6 @@ export declare const schedulerRunToolDefinitions: {
                 type: string;
                 description: string;
             };
-            requestKey: {
-                type: string;
-                description: string;
-            };
-            targetShapeRevision: {
-                type: string;
-                description: string;
-            };
         };
         required: string[];
         additionalProperties: boolean;

package/dist/tools/scheduler-run.js

@@ -21,14 +21,6 @@ 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();
-}
 export const schedulerRunToolDefinitions = [
     {
         name: "run_scheduler_sweep",
@@ -49,14 +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.",
-                },
             },
             required: ["workspaceId"],
             additionalProperties: false,
@@ -70,8 +54,6 @@ 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.');
     }
@@ -79,7 +61,5 @@ export async function runSchedulerSweep(input) {
         workspaceId,
         action,
         ...(targetDate ? { targetDate } : {}),
-        ...(requestKey ? { requestKey } : {}),
-        ...(targetShapeRevision ? { targetShapeRevision } : {}),
     }, workspaceId);
 }

package/dist/tools/workspaces.d.ts

@@ -142,15 +142,17 @@ export declare function listWorkspaces(): Promise<{
     workspaces: WorkspaceSummary[];
     workspaceLock: {
         enabled: boolean;
-        workspaceId?: undefined;
-        hiddenWorkspaceCount?: undefined;
+        workspaceId: string;
+        hiddenWorkspaceCount: number;
+        siblingInventoryFetched: boolean;
     };
 } | {
     workspaces: WorkspaceSummary[];
     workspaceLock: {
         enabled: boolean;
-        workspaceId: string;
-        hiddenWorkspaceCount: number;
+        workspaceId?: undefined;
+        hiddenWorkspaceCount?: undefined;
+        siblingInventoryFetched?: undefined;
     };
 }>;
 export declare function getActiveWorkspace(): {

package/dist/tools/workspaces.js

@@ -80,19 +80,21 @@ export const workspaceToolDefinitions = [
 ];
 export async function listWorkspaces() {
     const api = getApi();
-    const { workspaces } = await api.get("/api/v3/workspaces");
     const lockedWorkspaceId = getLockedWorkspaceId();
-    if (!lockedWorkspaceId) {
-        return { workspaces, workspaceLock: { enabled: false } };
+    if (lockedWorkspaceId) {
+        const { workspace } = await api.get(`/api/v3/workspaces/${encodeURIComponent(lockedWorkspaceId)}`);
+        return {
+            workspaces: [workspace],
+            workspaceLock: {
+                enabled: true,
+                workspaceId: lockedWorkspaceId,
+                hiddenWorkspaceCount: 0,
+                siblingInventoryFetched: false,
+            },
+        };
     }
-    return {
-        workspaces: workspaces.filter((ws) => ws.id === lockedWorkspaceId),
-        workspaceLock: {
-            enabled: true,
-            workspaceId: lockedWorkspaceId,
-            hiddenWorkspaceCount: workspaces.filter((ws) => ws.id !== lockedWorkspaceId).length,
-        },
-    };
+    const { workspaces } = await api.get("/api/v3/workspaces");
+    return { workspaces, workspaceLock: { enabled: false } };
 }
 export function getActiveWorkspace() {
     const config = getConfig();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.553",
+  "version": "0.1.554",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",

package/skills/refill-sends/SKILL.md

@@ -83,8 +83,6 @@ Accepted invocation flags in the same user request:
 - `senderIds: <id>, <id>` or `senderNames: <name>, <name>`: explicit selector
   alternatives when the host preserves natural-language arguments better than
   shell-style flags.
-- `actionTypes: send_invite, send_inmail_closed`: optional lane selector. Omit
-  `actionTypes` to preserve the target planner's lane inference.
 - `untilDate: YYYY-MM-DD`: explicit date selector alternative when the host
   preserves natural-language arguments better than shell-style flags.
 - `targetDate: YYYY-MM-DD`: exact-date selector alternative when the host
@@ -93,7 +91,7 @@ Accepted invocation flags in the same user request:
 When the host can call typed MCP tools, start with:
 
 ```text
-refill_sends({ yolo?: boolean, executionMode?: "manual" | "scheduled" | "yolo", requireWorkspace?: boolean, workspaceId?: string, senders?: string[], senderIds?: string[], senderNames?: string[], actionTypes?: ("send_invite" | "send_inmail_closed")[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD", targetDate?: "YYYY-MM-DD" })
+refill_sends({ yolo?: boolean, executionMode?: "manual" | "scheduled" | "yolo", requireWorkspace?: boolean, workspaceId?: string, senders?: string[], senderIds?: string[], senderNames?: string[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD", targetDate?: "YYYY-MM-DD" })
 ```
 
 That command helper normalizes arguments and returns the execution contract. In
@@ -101,22 +99,14 @@ non-yolo mode it does not mutate. In `--yolo`, it may execute exactly one safe
 bounded primitive from the fresh `target.globalActionQueue[0]`, then reread and
 return the new target plan; currently safe primitives are paid-credit refresh,
 existing-row message preparation, generated-message approval, receipt-proven
-same-source row copy, a request-scoped exact-date product scheduler sweep, and
-read-only wait rereads. Same-source copy/source
+same-source row copy, and read-only wait rereads. Same-source copy/source
 fallback is safe only after receipt-proven exhaustion:
 `hasMoreFrontierRows:false`, zero `approvalCandidates`, no `stuckActiveCells`,
-and no non-terminal `approvedNotDispatched` work. It does not run unbounded
-approval, lower paid-InMail thresholds, switch source families, create
-campaigns, launch, or send directly; it never raw-writes scheduler fields.
-Continue with the workflow below for route selection, state rereads, approval
-gating, source import, preparation, and bounded approval.
-
-The approval scope is the exact `workspaceId`, `targetDate`, sender ids, action
-types, campaign/table/source ids, `targetShapeRevision`, and `actionKey` in the
-rendered packet. `stateRevision` and sent/scheduled/ready counts are mutable
-progress, not approval-scope drift. Execute only
-`target.globalActionQueue[0]`, then perform a full authoritative reread before
-deciding any next action.
+and no non-terminal `approvedNotDispatched` work. It does not run unbounded approval, lower
+paid-InMail thresholds, switch source families, create campaigns, launch, send,
+or write scheduler rows. Continue with the workflow below for route selection,
+state rereads, approval gating, source import, preparation, and bounded
+approval.
 
 ## Workspace Contract
 
@@ -286,27 +276,10 @@ need raw proof, call the read-only `get_scheduler_fill_capacity` query for the
 same sender/action/date; it tells the MCP how many cells the product scheduler
 will try to place and does not import, approve, schedule, refresh credits, or
 mutate.
-Treat `rollingWeeklyInvite.capacityFreedDuringWindow:true` as proof that
-rolling-weekly capacity frees later in the send window and remains schedulable;
-use its timing fields instead of treating the window-start gate as a permanent
-full-day blocker.
 When the refill loop has ready rows and needs scheduler pickup now, use
 `run_scheduler_sweep` with the same explicit `workspaceId`; it can place cells
 within existing scheduler gates and returns the receipt, but it never sends or
 bypasses limits.
-A scheduler sweep is a visible workspace-wide scheduling side effect. The
-request packet limits the expected target changes to its exact date, senders,
-action types, campaigns, tables, and stable sources, but the product scheduler
-may also place unrelated eligible workspace work; disclose that possibility in
-the approval packet and receipt. For an exact-date sweep action, execute it
-once, then reread the full target plan before taking or presenting another
-action.
-The exact-date `run_scheduler_sweep` may schedule eligible workspace cells
-through existing product gates; it never sends directly or raw-writes scheduler
-fields. Only non-exact or no-sweep scheduler waits are read-only.
-On resume, reconcile the current target plan and matching sweep status/receipt
-before retrying. A matching same-key terminal receipt replays; an
-`uncertain_outcome` stops for reconciliation and must not schedule again.
 Scheduler-run receipt interpretation: `cellsConsidered is allocation-attempt
 count`, not total ready supply, while `readyCellsFound` is ready inventory found
 before prefilters. Inspect `campaignScopeSummary` before assuming the selected
@@ -419,14 +392,6 @@ scheduler wait loop. Do not finish the refill goal, mark it complete, or mark it
 blocked only because it is still `awaiting_scheduler_after_ready_buffer`; keep
 waiting unless Christian stops the run or the host cannot continue.
 
-Future scheduled coverage and already sent actions are distinct; only
-scheduler-owned future scheduled actions count as scheduled coverage. For
-multiple target dates, finish D1 execution and the full D1 reread before
-planning D2. Completion proof is product-native Sellable MCP evidence only:
-target plan, campaign refill state, scheduler capacity, sweep/status, and
-bounded receipts. Never use individual cell ids, Prisma, SQL, direct database
-access, or production-environment scripts as completion proof.
-
 In `--yolo`, the default fill target is the scheduler-forward 48-hour window
 unless `--target-date`/`targetDate`, `--until`/`untilDate`, or an explicit
 compatibility `horizonSendDays` is provided. If a target date is provided,

package/skills/refill-sends-workflow/SKILL.md

@@ -75,20 +75,6 @@ calls, preparation calls, approval calls, and campaign start calls. Missing
 interactive workspace switching is diagnostic setup only and is not an
 automation control path.
 
-Typed command scope:
-
-```text
-refill_sends({ yolo?: boolean, executionMode?: "manual" | "scheduled" | "yolo", requireWorkspace?: boolean, workspaceId?: string, senders?: string[], senderIds?: string[], senderNames?: string[], actionTypes?: ("send_invite" | "send_inmail_closed")[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD", targetDate?: "YYYY-MM-DD" })
-```
-
-Omit `actionTypes` to preserve the target planner's lane inference. The
-approval scope is the exact `workspaceId`, `targetDate`, sender ids, action
-types, campaign/table/source ids, `targetShapeRevision`, and `actionKey` in the
-rendered packet. `stateRevision` and sent/scheduled/ready counts are mutable
-progress, not approval-scope drift. Execute only
-`target.globalActionQueue[0]`, then perform a full authoritative reread before
-deciding any next action.
-
 Goal-mode continuation: a skill cannot create or invoke `/goal` by itself. When
 this workflow is already running inside an active Codex goal, keep that goal
 open until every selected sender lane is horizon-filled by projected coverage
@@ -206,19 +192,6 @@ files or memory.
    `run_scheduler_sweep` with the same explicit `workspaceId` to request the
    product scheduler placement pass now and read its receipt. This may place
    cells within existing gates, never sends messages, and never bypasses limits.
-   A scheduler sweep is a visible workspace-wide scheduling side effect. The
-   request packet limits expected target changes to the exact date, senders,
-   action types, campaigns, tables, and stable sources, but unrelated eligible
-   workspace work may also be scheduled by the product scheduler and must be
-   disclosed. For an exact-date sweep action, execute it once and perform the
-   full target-plan reread before taking or presenting another action.
-   The exact-date `run_scheduler_sweep` may schedule eligible workspace cells
-   through existing product gates; it never sends directly or raw-writes
-   scheduler fields. Only non-exact or no-sweep scheduler waits are read-only.
-   On resume, reconcile the current target plan and matching sweep
-   status/receipt before retrying. A matching same-key terminal receipt
-   replays; an `uncertain_outcome` stops for reconciliation and must not
-   schedule again.
    Scheduler-run receipt interpretation: `cellsConsidered is
    allocation-attempt count`, not total ready supply, while `readyCellsFound`
    is ready inventory found before prefilters. Inspect `campaignScopeSummary`
@@ -237,10 +210,8 @@ files or memory.
    scheduled count, projected count, campaign ids, and no-op proof without
    asking for approval or mutating.
    If `remainingReadyOrProjectedGap:0` but `remainingProjectedGap>0`, and paid
-   InMail credit freshness is clean for every selected paid-InMail lane,
-   execute an exact-date `run_scheduler_sweep` action once when it is
-   `target.globalActionQueue[0]`, then fully reread. Otherwise, run only a
-   persistent read-only scheduler wait/reread loop; do not ask for
+   InMail credit freshness is clean for every selected paid-InMail lane, run
+   only a persistent read-only scheduler wait/reread loop; do not ask for
    prep/import/approval. Poll `get_refill_target_plan` every 60-120 seconds, or
    on the host's next continuation interval, until projected coverage fills,
    a concrete non-scheduler blocker appears, or Christian explicitly asks to
@@ -413,11 +384,10 @@ exceeds the sender's capacity for the selected target window. Put another way:
 complete when the same daily-limit/readback model would show no remaining
 send-day capacity for that selected lane. Ready-to-schedule rows are only buffer
 for the product scheduler. If ready plus projected coverage covers the target
-window but scheduled cells do not yet, execute the exact-date sweep when the
-planner emits it; otherwise run a persistent read-only scheduler wait loop:
-wait, reread, recompute the ledger, and continue until projected coverage is
-proved, a concrete non-scheduler blocker appears, or Christian explicitly stops
-or asks for status only. `awaiting_scheduler_after_ready_buffer` is not
+window but scheduled cells do not yet, run a persistent read-only scheduler wait
+loop: wait, reread, recompute the ledger, and continue until projected coverage
+is proved, a concrete non-scheduler blocker appears, or Christian explicitly
+stops or asks for status only. `awaiting_scheduler_after_ready_buffer` is not
 success and is not a terminal blocker for an active refill goal; it is the
 loaded, awaiting scheduler poll state that keeps the thread waiting. It does not
 need a prep/import/approval packet.
@@ -750,14 +720,6 @@ with non-null `scheduledFor`. Prepared, approved, and ready-to-schedule rows are
 intermediate states; report them as awaiting scheduler unless scheduled cells
 are present.
 
-Future scheduled coverage and already sent actions are distinct; only
-scheduler-owned future scheduled actions count as scheduled coverage. For
-multiple target dates, finish D1 execution and the full D1 reread before
-planning D2. Completion proof is product-native Sellable MCP evidence only:
-target plan, campaign refill state, scheduler capacity, sweep/status, and
-bounded receipts. Never use individual cell ids, Prisma, SQL, direct database
-access, or production-environment scripts as completion proof.
-
 preparedMessages can remain 0 while scheduler-ready state changes downstream.
 After a prep job reaches a terminal state, run `wait_for_campaign_processing`
 when generated/pass counts are still settling, then poll `get_campaign_refill_state` until `readyToSchedule` drops, scheduled counts increase, or the state clearly