@sellable/mcp 0.1.451 → 0.1.453

package/dist/server.js

@@ -10,6 +10,7 @@ import { resolveCampaignFillRoute } from "./tools/campaign-fill-routing.js";
 import { fillCampaignHorizon } from "./tools/campaign-horizon-fill.js";
 import { cancelPrepareCampaignMessages, getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./tools/campaign-message-preparation.js";
 import { getCampaignRefillState } from "./tools/campaign-refill-state.js";
+import { getRefillTargetPlan } from "./tools/refill-target-plan.js";
 import { getCampaignTableSchema, queueCampaignCells, recordCampaignReviewBatch, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
 import { archiveCampaign, createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
@@ -221,6 +222,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_refill_state":
                 result = await getCampaignRefillState(args);
                 break;
+            case "get_refill_target_plan":
+                result = await getRefillTargetPlan(args);
+                break;
             case "refill_sends":
                 result = refillSendsCommand(args);
                 break;

package/dist/tools/refill-sends.js

@@ -142,6 +142,15 @@ export function refillSendsCommand(input = {}) {
         },
         firstOperationalSteps: [
             'Load get_subskill_prompt({ subskillName: "refill-sends-workflow" }) before any product operation.',
+            `Call get_refill_target_plan({ intent: "${intent}"${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""}${senderIds.length > 0
+                ? `, senderIds: ${JSON.stringify(senderIds)}`
+                : ""}${senderNames.length > 0
+                ? `, senderNames: ${JSON.stringify(senderNames)}`
+                : ""}${senders.length > 0 ? `, senders: ${JSON.stringify(senders)}` : ""}${untilDate
+                ? `, untilDate: "${untilDate}"`
+                : `, horizonSendDays: ${horizonSendDays}`}, approvalMode: "${approvalMode}" }) before any import, prep, approval, start, or schedule-affecting action.`,
+            "If get_refill_target_plan returns status complete, report gross target, selected days, scheduled count, campaign ids, targetShapeRevision, and no-op proof without asking for approval.",
+            "If remainingReadyOrScheduledGap is 0 but remainingScheduledGap is positive, run only a bounded read-only scheduler settle/reread loop; do not ask for prep/import/approval.",
             `Resolve route with resolve_campaign_fill_route({ intent: "${intent}"${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""} }).`,
             'If the plain route shows stale managed waterfall evidence, archived/completed shared slots, or targets that do not cover the selected sender set, immediately call resolve_campaign_fill_route({ intent: "active" }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked.',
             "Call list_senders and get_sender_routing, then resolve sender selectors against active enrolled campaign-backed sequence senders.",
@@ -151,15 +160,15 @@ export function refillSendsCommand(input = {}) {
             "Read get_campaign_refill_state for enough exact candidate campaigns to pick the best per-sender target by recent/future scheduler-owned sends, then recent result evidence, then source health.",
             "Treat current dashboard-active PAUSED campaign-backed sequence campaigns as start-eligible candidates: read refill state before deciding whether to prep, approve, start, or skip.",
             "Fresh reread get_campaign_refill_state immediately before any import, prep, approval, or horizon-fill mutation.",
-            "Maintain a horizon saturation ledger per selected sender: selected send days, gross capacity, future scheduler-owned scheduled counts, ready-to-schedule buffer, remaining scheduled gap, remaining ready-or-scheduled gap, and next MCP primitive.",
-            "In --yolo, continue through every safe selected sender/campaign action covered by the rendered packet; when no safe in-packet action remains, return concrete continuation options instead of silently stopping.",
+            "Maintain a target-led horizon saturation ledger per selected sender from get_refill_target_plan: selected days, gross capacity, future scheduler-owned scheduled counts, ready-to-schedule buffer, remaining scheduled gap, remaining ready-or-scheduled gap, targetShapeRevision, stateRevision, and next MCP primitive.",
+            "In --yolo or after one Accept, continue through every safe selected sender/campaign action covered by the rendered target packet; scheduled-count progress changes stateRevision and should continue while targetShapeRevision is stable.",
             "Do not complete a fill/schedule request until a final get_campaign_refill_state reread proves scheduler-owned scheduledFor cells fill the horizon, or report a concrete blocker such as awaiting_scheduler_after_ready_buffer.",
         ],
         approvalContract: yolo
-            ? "Auto-accept only the rendered bounded refill packet after fresh reread. Continue through every safe apply/prep/start action inside that packet, including start_campaign only for exact selected PAUSED campaign-backed sequence refill targets named in the packet. After each action, recompute the per-sender horizon saturation ledger and keep going until scheduler-owned scheduledFor cells fill the requested horizon or a concrete blocker/timeout is proven. Ready-to-schedule rows are buffer, not completion. If no safe in-packet action remains, return concrete continuation options and stop. Stop immediately if sender set, route, ids, caps, dates, blockers, or side-effect class drifts."
+            ? "Auto-accept only the rendered bounded refill target packet after get_refill_target_plan and fresh reread. Continue through every safe apply/prep/start action inside that packet, including start_campaign only for exact selected PAUSED campaign-backed sequence refill targets named in the packet. After each action, rerun get_refill_target_plan; keep going while targetShapeRevision is stable and scheduled counts progress toward the target, even though stateRevision changes. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the gap, use only read-only scheduler settle/reread. Stop immediately if targetShapeRevision changes because sender set, route, ids, caps, dates, blockers, action class, or side-effect class drifts."
             : hasSenderSelectors
-                ? "Ask the final Accept/Decline structured approval question before mutation, including workspace, sender scope, campaign table, exact ids, caps/dates, side effects, forbidden actions, and stop condition."
-                : "Ask which eligible enrolled senders to refill first, then ask the final Accept/Decline structured approval question before mutation.",
+                ? "Ask the final Accept/Decline structured approval question before mutation only when get_refill_target_plan reports a positive remaining ready-or-scheduled gap. Include workspace, sender scope, campaign table, exact ids, caps/dates, gross target, scheduled count, ready buffer, remaining scheduled gap, targetShapeRevision/stateRevision, side effects, forbidden actions, and stop condition. If target is complete, no-op without approval. If ready buffer covers the target, run only read-only scheduler settle/reread."
+                : "Ask which eligible enrolled senders to refill first, then ask the final Accept/Decline structured approval question before mutation only when get_refill_target_plan reports a positive remaining ready-or-scheduled gap.",
         forbiddenActions: [
             "start_campaign outside an exact selected PAUSED campaign-backed refill packet",
             "manual launch/send or direct sending outside product scheduler side effects",

package/dist/tools/refill-target-plan.d.ts

@@ -0,0 +1,85 @@
+type RefillTargetPlanIntent = "plain" | "active" | "evergreen";
+type RefillTargetPlanApprovalMode = "approve" | "mark_ready";
+type GetRefillTargetPlanInput = {
+    intent?: RefillTargetPlanIntent;
+    horizonSendDays?: number;
+    untilDate?: string;
+    campaignId?: string;
+    tableId?: string;
+    senderIds?: string[];
+    senderNames?: string[];
+    senders?: string[];
+    actionTypes?: string[];
+    approvalMode?: RefillTargetPlanApprovalMode;
+};
+export declare const refillTargetPlanToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            intent: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            tableId: {
+                type: string;
+                description: string;
+            };
+            senderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            senderNames: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            senders: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            actionTypes: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                description: string;
+            };
+            approvalMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function getRefillTargetPlan(input?: GetRefillTargetPlanInput): Promise<unknown>;
+export {};

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

@@ -0,0 +1,90 @@
+import { getApi } from "../api.js";
+async function postRefillTargetPlan(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/refill-target-plan", body);
+}
+export const refillTargetPlanToolDefinitions = [
+    {
+        name: "get_refill_target_plan",
+        description: "read-only refill target planner to call before any refill mutation. It computes selected sender-local days, gross scheduled-send target, scheduler-owned scheduled coverage across active enrolled campaigns, ready buffer, remaining scheduled gap, bounded action candidates, and targetRevision drift proof. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, launch, spend InMail credits, or write scheduler fields. Complete targets no-op without approval; incomplete targets must be followed by a bounded approval packet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                intent: {
+                    type: "string",
+                    enum: ["plain", "active", "evergreen"],
+                    description: 'Route intent. Use "plain" for normal refill requests unless the user explicitly narrows active or evergreen.',
+                },
+                horizonSendDays: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 7,
+                    description: "Calendar-day refill horizon to inspect from the sender-local current day. Defaults to 2 when untilDate is not provided; no-send days contribute zero target.",
+                },
+                untilDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional sender-local YYYY-MM-DD date to inspect through, inclusive.",
+                },
+                campaignId: {
+                    type: "string",
+                    description: "Optional exact CampaignOffer.id to narrow routing. Do not pass campaign names.",
+                },
+                tableId: {
+                    type: "string",
+                    description: "Optional exact WorkflowTable.id to narrow routing. Do not pass table names.",
+                },
+                senderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional exact Sender.id values to scope target planning.",
+                },
+                senderNames: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional sender display names to resolve before target planning.",
+                },
+                senders: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional sender selectors as names or ids.",
+                },
+                actionTypes: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: [
+                            "send_invite",
+                            "send_dm",
+                            "send_inmail_open",
+                            "send_inmail_closed",
+                            "react_and_comment",
+                        ],
+                    },
+                    description: "Optional workflow send column/action types. Defaults from selected active campaign sequences.",
+                },
+                approvalMode: {
+                    type: "string",
+                    enum: ["approve", "mark_ready"],
+                    description: 'Requested downstream approval mode. Use "approve" only for explicit fill/schedule requests.',
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+export function getRefillTargetPlan(input = {}) {
+    return postRefillTargetPlan({
+        intent: input.intent,
+        horizonSendDays: input.horizonSendDays,
+        untilDate: input.untilDate,
+        campaignId: input.campaignId,
+        tableId: input.tableId,
+        senderIds: input.senderIds,
+        senderNames: input.senderNames,
+        senders: input.senders,
+        actionTypes: input.actionTypes,
+        approvalMode: input.approvalMode,
+    });
+}

package/dist/tools/registry.js

@@ -33,6 +33,7 @@ import { onDemandToolDefinitions } from "./one-off.js";
 import { processingToolDefinitions } from "./processing.js";
 import { promptToolDefinitions } from "./prompts.js";
 import { readinessToolDefinitions } from "./readiness.js";
+import { refillTargetPlanToolDefinitions } from "./refill-target-plan.js";
 import { refillSendsToolDefinitions } from "./refill-sends.js";
 import { rowToolDefinitions } from "./rows.js";
 import { rubricToolDefinitions } from "./rubrics.js";
@@ -50,6 +51,7 @@ export const allTools = [
     ...campaignAbTestToolDefinitions,
     ...campaignFillRoutingToolDefinitions,
     ...campaignRefillStateToolDefinitions,
+    ...refillTargetPlanToolDefinitions,
     ...refillSendsToolDefinitions,
     ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -49,6 +49,7 @@ allowed-tools:
   - mcp__sellable__wait_for_campaign_processing
   - mcp__sellable__resolve_campaign_fill_route
   - mcp__sellable__get_campaign_refill_state
+  - mcp__sellable__get_refill_target_plan
   - mcp__sellable__fill_campaign_horizon
   - mcp__sellable__start_campaign_message_preparation
   - mcp__sellable__get_campaign_message_preparation_status

package/skills/create-campaign-v2/references/gold-standard-message-examples.md

@@ -474,6 +474,19 @@ Transfer rules:
   context, and the current offer category. The question should be easy to answer,
   closed-ended, and specific to that prospect. Do not reuse the same generic
   question across every row.
+- Good `{{custom_closed_question}}` examples:
+  - `Are you guys trying to make LinkedIn outbound a real founder-led channel, or is it still mostly ad hoc?`
+  - `Are you using LinkedIn to reach sales leaders directly, or is most pipeline still coming from intros and email?`
+  - `Are you actively testing outbound for growth teams right now, or is LinkedIn still more of a founder-network channel?`
+  - `Are you trying to turn customer feedback into account-risk signals, or is that still mostly manual check-ins?`
+  - `Are you looking at support conversations as a source of churn risk, or does that still mostly live in tickets and surveys?`
+  - `Are you building a repeatable sales motion yet, or is most of it still founder-led experimentation?`
+  - `Are you treating LinkedIn as a sales channel this year, or mostly as brand and founder content?`
+- Bad `{{custom_closed_question}}` examples:
+  - `Are you trying to avoid manual research + follow-up process?`
+  - `Are you interested in seeing Sellable?`
+  - `Open to seeing how this would work?`
+  - `Do you need more leads, filters, messages, and sequence setup?`
 - The product/category wording in the question should be plain and immediately
   legible, for example `LinkedIn outbound`, `customer success`, `CX operations`,
   `support`, or `post-sales`. Avoid feature-heavy phrasing such as `manual

package/skills/refill-sends/SKILL.md

@@ -4,6 +4,7 @@ description: Plan regular campaign and evergreen campaign send refill work throu
 visibility: public
 allowed-tools:
   - mcp__sellable__refill_sends
+  - mcp__sellable__get_refill_target_plan
   - mcp__sellable__get_auth_status
   - mcp__sellable__start_cli_login
   - mcp__sellable__wait_for_cli_login
@@ -102,11 +103,23 @@ get_subskill_prompt({ subskillName: "refill-sends-workflow" })
 ```
 
 Then follow that workflow exactly. The default path is read-only research:
-resolve the route, identify the sender-relevant campaign that most recently had
-scheduler-owned sends, read refill state for that target, report the next safe
-step using campaign names first, and stop before mutation unless the user has
-explicitly approved the exact workspace, campaign/table/source ids, caps/dates,
-approval mode, expected side effects, and stop/rollback condition.
+compute the refill target plan first, resolve the route, identify the
+sender-relevant campaign that most recently had scheduler-owned sends, read
+refill state for that target, report the next safe step using campaign names
+first, and stop before mutation unless the user has explicitly approved the
+exact workspace, campaign/table/source ids, caps/dates, approval mode, expected
+side effects, and stop/rollback condition.
+
+Immediately after loading the internal workflow, call
+`get_refill_target_plan`. The target plan is the canonical first fact receipt:
+selected sender-local days, gross scheduled-send target, scheduler-owned
+scheduled coverage across active enrolled campaigns, ready buffer, remaining
+scheduled gap, remaining ready-or-scheduled gap, `targetShapeRevision`, and
+`stateRevision`. If the target plan is complete, report that the selected target
+is already filled and no-op without asking for approval. If the ready buffer
+covers the target but scheduled coverage is still short, run only a bounded
+read-only scheduler settle/reread loop and report
+`awaiting_scheduler_after_ready_buffer` if it does not settle.
 
 If the plain route's managed waterfall targets are stale, for example skipped
 targets show archived/completed shared slots or the returned targets do not cover
@@ -147,7 +160,10 @@ packet. It does not authorize starting unrelated, archived, completed, draft, or
 direct campaigns, separate launch/send actions, archive or delete cleanup,
 direct scheduler writes, sender reassignment, or campaigns outside those
 selected for the eligible sender set. Stop and re-plan if the route, sender set,
-ids, caps, blockers, or side-effect class drift before mutation.
+ids, caps, blockers, action class, or side-effect class drift before mutation.
+Scheduled counts increasing toward the approved target are expected progress:
+they change `stateRevision`, not `targetShapeRevision`, and do not require a
+second approval.
 
 In `--yolo`, continue as far as the rendered packet safely allows. After each
 apply/prep/start result, reread state, settle processing when needed, and move to
@@ -162,7 +178,8 @@ saturation, not merely prepared/approved/ready rows. Maintain a horizon
 saturation ledger per selected sender: selected send days, gross capacity,
 future scheduler-owned scheduled cells with non-null `scheduledFor`,
 ready-to-schedule buffer, remaining scheduled gap, remaining ready-or-scheduled
-gap, and the next MCP primitive that can reduce the gap. After every
+gap, `targetShapeRevision`, `stateRevision`, and the next MCP primitive that can
+reduce the gap. After every
 apply/prep/start result, wait for processing, reread refill state, recompute the
 ledger, then keep applying safe bounded actions until the scheduled count fills
 the horizon or a concrete blocker/timeout is proven. If ready rows cover the

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

@@ -3,6 +3,7 @@ name: refill-sends-workflow
 description: Internal skill-led refill sends workflow for regular campaigns and evergreen campaigns.
 visibility: internal
 allowed-tools:
+  - mcp__sellable__get_refill_target_plan
   - mcp__sellable__list_senders
   - mcp__sellable__get_sender_routing
   - mcp__sellable__get_campaign_waterfall
@@ -58,7 +59,18 @@ senders", and "load everyone up". A sender-scoped request targets senders
 enrolled in active campaign-backed sequence campaigns, not one arbitrary active
 campaign.
 
-1. Call `resolve_campaign_fill_route` first. Use `intent:"plain"` for generic
+1. Call `get_refill_target_plan` first. This read-only target plan is the
+   canonical opening receipt: selected sender-local days, gross scheduled-send
+   target, scheduler-owned scheduled coverage across active enrolled campaigns,
+   ready buffer, remaining scheduled gap, remaining ready-or-scheduled gap,
+   bounded action candidates, `targetShapeRevision`, and `stateRevision`.
+   If `status:"complete"`, report the target, selected dates, scheduled count,
+   campaign ids, and no-op proof without asking for approval or mutating.
+   If `remainingReadyOrScheduledGap:0` but `remainingScheduledGap>0`, run only a
+   bounded read-only scheduler settle/reread loop; do not ask for
+   prep/import/approval. If the scheduler still does not fill, report
+   `awaiting_scheduler_after_ready_buffer`.
+2. Call `resolve_campaign_fill_route`. Use `intent:"plain"` for generic
    fill/load language, `intent:"active"` only when the user explicitly narrowed
    to active regular campaigns or when the plain route has stale managed
    waterfall evidence, and `intent:"evergreen"` only when the user explicitly
@@ -70,7 +82,7 @@ campaign.
    and inspect current dashboard-active `ACTIVE` and `PAUSED` campaign-backed
    sequence campaigns before declaring a sender blocked.
    Short form: stale waterfall bindings do not overrule current dashboard-active campaigns.
-2. Resolve sender context before choosing a target. Call `list_senders`; when a
+3. Resolve sender context before choosing a target. Call `list_senders`; when a
    managed program is involved, also call `get_campaign_waterfall`, and call
    `get_sender_routing` when territory rules may constrain sender eligibility.
    If the user named senders, map those names to exact sender ids. If the user
@@ -83,7 +95,7 @@ campaign.
    the relevant senders from the most recent scheduler-owned sends in
    refill-state readbacks and report that inference.
    Short form: `--yolo refill senders` means all eligible enrolled senders; non-yolo asks which enrolled senders.
-3. Read `get_campaign_refill_state` for candidate campaigns from the resolver
+4. Read `get_campaign_refill_state` for candidate campaigns from the resolver
    result and from the required active-route refetch when managed waterfall
    evidence looks stale. For a broad `active_campaigns` route, inspect enough
    candidates to identify the campaign or small campaign set that most recently
@@ -103,9 +115,9 @@ campaign.
    already has enough ready/scheduled rows across enrolled campaigns or that a
    different same-sender campaign is needed because the best lane is blocked.
    Short form: `--yolo refill senders` selects all eligible enrolled senders, then the best campaign per sender.
-4. Pick exact ids from the selected refill-state response. Do not use campaign
+5. Pick exact ids from the selected refill-state response. Do not use campaign
    names or table names as target identifiers for tool calls.
-5. Classify the target from refill state:
+6. Classify the target from refill state:
    - regular campaign: campaign-backed workflow table with normal source,
      sequence, senders, and send/refill stages.
    - evergreen campaign: managed always-on lane with current source evidence.
@@ -126,8 +138,8 @@ Use the refill-state response as the current facts receipt:
 - horizon saturation ledger per target sender: sender-local send days in scope,
   gross horizon capacity, future scheduler-owned scheduled counts in that
   window, ready-to-schedule buffer, remaining scheduled gap, remaining
-  ready-or-scheduled gap, and the next smallest MCP primitive that can reduce
-  the gap;
+  ready-or-scheduled gap, `targetShapeRevision`, `stateRevision`, and the next
+  smallest MCP primitive that can reduce the gap;
 - row/stage counts: source available, rows, enriched, passed, generated,
   approved, ready to schedule, scheduled;
 - active message prep job;
@@ -182,15 +194,20 @@ two-day packet.
 Short form: default `--yolo refill senders` target is each eligible sender's two-send-day gap.
 
 For `--yolo` fill/schedule requests, do not treat "ready" as completion. Build
-and maintain a horizon saturation ledger for every selected sender. A sender is
-complete only when a final `get_campaign_refill_state` reread proves
-scheduler-owned scheduled cells with non-null `scheduledFor` meet or exceed the
-sender's horizon capacity for the selected send days. Ready-to-schedule rows are
-only buffer for the product scheduler. If ready plus scheduled covers the
-horizon but scheduled cells do not yet, run a bounded scheduler settle loop:
-wait, reread, recompute the ledger, and continue until scheduled coverage is
-proved or the loop reaches an explicit timeout/blocker. Timeout is
-`awaiting_scheduler_after_ready_buffer`, not success.
+and maintain a horizon saturation ledger for every selected sender from
+`get_refill_target_plan`. A sender is complete only when a final target-plan or
+refill-state reread proves scheduler-owned scheduled cells with non-null
+`scheduledFor` meet or exceed the sender's horizon capacity for the selected
+send days. Put another way: complete only when a final
+`get_campaign_refill_state` reread proves the scheduler-owned non-null
+`scheduledFor` coverage. Ready-to-schedule rows are only buffer for the product scheduler. If
+ready plus scheduled covers the horizon but scheduled cells do not yet, run a
+bounded read-only scheduler settle loop: wait, reread, recompute the ledger, and
+continue until scheduled coverage is proved or the loop reaches an explicit
+timeout/blocker. Timeout is `awaiting_scheduler_after_ready_buffer`, not
+success, and it does not need a prep/import/approval packet. Short form: ready
+buffer is not success.
+Short form: use a bounded scheduler settle loop before calling it blocked.
 Short form: `--yolo refill senders` completes only on scheduled horizon saturation or a concrete blocker.
 
 Rank candidates in this order: