@sellable/mcp 0.1.520 → 0.1.521

package/dist/tools/refill-executors.js

@@ -365,6 +365,79 @@ export function refillPrepareRequestHash(params) {
             : "no-row-selector",
     ].join(":");
 }
+function prepReceiptFromResult(result) {
+    const root = recordValue(result);
+    if (!root)
+        return null;
+    const status = recordValue(root.status);
+    const progress = recordValue(root.progress) ?? recordValue(status?.progress);
+    return (recordValue(root.prepReceipt) ??
+        recordValue(progress?.receipt) ??
+        recordValue(root.receipt));
+}
+function normalizePrepareMessagesResult(result) {
+    const receipt = prepReceiptFromResult(result);
+    const root = recordValue(result);
+    if (!receipt || !root)
+        return result;
+    const world = recordValue(receipt.world);
+    const batchStop = stringValue(receipt.batchStop);
+    const brokenByReason = recordValue(world?.brokenByReason) ?? {};
+    const approvalCandidates = numberValue(world?.approvalCandidates) ?? 0;
+    const hasMoreFrontierRows = world?.hasMoreFrontierRows === true;
+    const stuckActiveCells = Array.isArray(world?.stuckActiveCells)
+        ? world.stuckActiveCells
+        : [];
+    const approvedNotDispatched = Array.isArray(world?.approvedNotDispatched)
+        ? world.approvedNotDispatched
+        : [];
+    return {
+        ...root,
+        prepReceipt: receipt,
+        exhaustionEvidence: {
+            clean: batchStop === "frontier_exhausted" &&
+                hasMoreFrontierRows === false &&
+                stuckActiveCells.length === 0 &&
+                approvedNotDispatched.every((entry) => {
+                    const row = recordValue(entry);
+                    return row?.terminal === true || approvedNotDispatched.length === 0;
+                }),
+            batchStop,
+            hasMoreFrontierRows,
+            approvalCandidates,
+            brokenByReason,
+            stuckActiveCells,
+            approvedNotDispatched,
+        },
+    };
+}
+function waitReceiptFromAction(action) {
+    const toolInput = actionToolInput(action);
+    const wait = recordValue(toolInput.wait) ??
+        recordValue(action.wait) ??
+        recordValue(recordValue(toolInput.refillReceipt)?.wait);
+    if (!wait)
+        return null;
+    const deadlineAt = stringValue(wait.deadlineAt);
+    const onExpiry = stringValue(wait.onExpiry);
+    if (!deadlineAt || !onExpiry)
+        return null;
+    return { deadlineAt, onExpiry };
+}
+function waitResultForAction(action) {
+    const wait = waitReceiptFromAction(action);
+    if (!wait)
+        return { waited: true };
+    const deadlineMs = Date.parse(wait.deadlineAt);
+    if (Number.isFinite(deadlineMs) && deadlineMs <= Date.now()) {
+        return {
+            waited: false,
+            reason: "wait_deadline_expired",
+            wait,
+        };
+    }
+    return { waited: true, wait };
+}
 export function boundedApprovalLimit(action) {
     const toolInput = actionToolInput(action);
     const rowSelector = recordValue(toolInput.rowSelector);
@@ -673,7 +746,7 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
         case "wait_for_scheduler":
         case "wait_for_active_work":
         case "wait_for_source_import":
-            return { status: "read_only_reread", result: { waited: true } };
+            return { status: "read_only_reread", result: waitResultForAction(action) };
         case "prepare_messages": {
             const campaignId = actionCampaignId(action);
             const tableId = actionTableId(action) ?? undefined;
@@ -712,7 +785,10 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 }),
                 requestSource: "refill_sends",
             });
-            return { status: "executed_and_reread", result };
+            return {
+                status: "executed_and_reread",
+                result: normalizePrepareMessagesResult(result),
+            };
         }
         case "copy_selected_source_rows": {
             const campaignOfferId = actionCampaignId(action);

package/dist/tools/refill-sends.js

@@ -50,7 +50,7 @@ function normalizeTargetDate(value) {
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
-        description: "Typed command entrypoint for Sellable refill sends. Accepts --yolo semantics and optional sender selectors, then returns the bounded execution contract for the skill-led refill workflow. In --yolo, it may refresh stale paid InMail credit cache facts once, or execute exactly one safe primitive from target.globalActionQueue[0] (bounded existing-row preparation, bounded same-source copy, bounded generated-message approval, or read-only wait) and reread. It does not run unbounded approval, lower paid InMail thresholds, switch source families, create campaigns, schedule sends, launch, archive, delete, or write scheduler rows.",
+        description: "Typed command entrypoint for Sellable refill sends. Accepts --yolo semantics and optional sender selectors, then returns the bounded execution contract for the skill-led refill workflow. In --yolo, it may refresh stale paid InMail credit cache facts once, or execute exactly one safe primitive from target.globalActionQueue[0] (bounded existing-row preparation, bounded generated-message approval, receipt-proven same-source copy, or read-only wait) and reread. Same-source copy/source fallback is only safe after receipt-proven exhaustion: hasMoreFrontierRows:false, zero approvalCandidates, no stuckActiveCells, and no non-terminal approvedNotDispatched work. Wait primitives are gates, not competing goals, and carry absolute wait.deadlineAt when present. It does not run unbounded approval, lower paid InMail thresholds, switch source families, create campaigns, schedule sends, launch, archive, delete, or write scheduler rows.",
         inputSchema: {
             type: "object",
             properties: {
@@ -209,6 +209,7 @@ export function refillSendsCommand(input = {}) {
                         : `, horizonSendDays: ${horizonSendDays}`}, approvalMode: "${approvalMode}" }) before any import, prep, approval, start, or schedule-affecting action.`,
             "Render target.eligibleSenderLedger and target.senderRefillPlans before mutation. Preserve the coverage labels Need to prepare, Goal, Already sent, Scheduled, Ready and waiting to be scheduled, and Still need.",
             "Use target.globalActionQueue as the only cross-sender yolo queue: execute only target.globalActionQueue[0], one globally ranked primitive, then rerun get_refill_target_plan before choosing another action.",
+            "Read target.senderRefillPlans[].refillReceipt as the public ladder receipt: it carries the selected campaign/sender/lane summary, skippedRungs, existingRowFrontier, and any absolute wait.deadlineAt. Do not choose source/copy/fallback work until that receipt proves the earlier ready/prep/approval rungs are exhausted.",
             "If get_refill_target_plan returns status complete, report eligible sender ledger, target.senderRefillPlans, gross target, selected days, sent count, scheduled count, projected count, campaign ids, targetShapeRevision, and no-op proof without asking for approval.",
             "Refill target lanes are connection invites (send_invite), standalone paid InMails (send_inmail_closed), or unified Sales Nav cascades represented publicly as send_inmail_closed with campaign classification sales_nav_cascade. For a Sales Nav cascade, refill the selected campaign first; its sequence can route prospects to Open InMail, paid InMail while fresh credits are >= 5, or same-campaign connection fallback without asking for separate open/paid/connection campaigns. Do not count send_dm as horizon target capacity.",
             "If remainingReadyOrProjectedGap is 0 but remainingProjectedGap is positive, run only a persistent read-only scheduler wait/reread loop; do not ask for prep/import/approval and do not close out while scheduler pickup is the only remaining state.",
@@ -228,15 +229,17 @@ export function refillSendsCommand(input = {}) {
             "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 target-window saturation ledger per selected sender from get_refill_target_plan: selected days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected counts, ready-to-schedule buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision, stateRevision, and next MCP primitive.",
+            "Source/fallback primitives require receipt-proven exhaustion: existingRowFrontier.hasMoreFrontierRows:false, approvalCandidates:0, no fresh active prep, no stuckActiveCells, and no non-terminal approvedNotDispatched rows. Treat anomalies, stuckActiveCells, and non-terminal approvedNotDispatched as diagnose-and-report gates, not exhaustion. Terminal approvedNotDispatched blockers may be reported and then the ladder can proceed.",
             "In --yolo, this tool automatically maintains a run-local refreshedPaidInmailSenderIds set: when the first target plan returns refresh_paid_inmail_credits candidates for selected paid-InMail lanes, it refreshes each exact sender at most once, reruns get_refill_target_plan, and returns the post-refresh targetPlan before any prep/source-copy/bounded-approval/read-only wait action is chosen.",
             "Freshness gate precedes scheduler wait: if any selected target.senderRefillPlans[].paidInmail.status is missing_credit_facts or stale_credit_facts, or the target plan contains refresh_paid_inmail_credits, do not enter wait_for_scheduler even when remainingReadyOrProjectedGap is 0; refresh exact sender credit facts once, reread get_refill_target_plan, then choose scheduler wait only if freshness is clean.",
+            "For wait_for_active_work and wait_for_scheduler, honor the receipt's absolute wait.deadlineAt when present. If the deadline is expired on this call, escalate to diagnostics with the receipt evidence instead of issuing another blind wait.",
             "Do not present paid-credit refresh as the next operator action after refill_sends returns autoPaidInmailRefresh and the post-refresh targetPlan.",
             "If paid InMail feasibility remains below threshold after that automatic refresh, report the exact sender/campaign/table/column threshold action or same-campaign connection fallback; --yolo must not lower paid InMail thresholds or create campaigns.",
             "In --yolo or after one Accept, continue through every safe selected sender/campaign action covered by the rendered target packet; sent/scheduled-count progress changes stateRevision and should continue while targetShapeRevision is stable.",
             "Do not complete a fill/schedule request until a final get_refill_target_plan or refill-state reread proves projected coverage (sent + scheduled) fills the scheduler-forward target window. Treat awaiting_scheduler_after_ready_buffer as loaded, awaiting scheduler when ready buffer covers the gap; do not import/prep more rows in that state, and keep polling unless Christian stops/statuses the run or a concrete non-scheduler blocker such as paid_inmail_below_threshold appears.",
         ],
         approvalContract: yolo
-            ? "Auto-accept only the rendered bounded refill target packet after get_refill_target_plan and fresh reread. Execute one globally ranked primitive from target.globalActionQueue at a time, then rerun get_refill_target_plan before taking another action. Continue through every safe prep/source-copy/bounded-approval/read-only wait action inside that packet. Unbounded approval, start_campaign, source-family switches, threshold changes, and campaign creation require their own explicit gates. After each safe action, rerun get_refill_target_plan; keep going while targetShapeRevision is stable and projected coverage (sent + scheduled) progresses toward the target, even though stateRevision changes. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap, use only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Stop immediately if targetShapeRevision changes because sender set, route, ids, caps, dates, blockers, action class, paid InMail threshold feasibility, or side-effect class drifts. --yolo does not authorize lowering paid InMail thresholds or creating connection campaigns."
+            ? "Auto-accept only the rendered bounded refill target packet after get_refill_target_plan and fresh reread. Execute one globally ranked primitive from target.globalActionQueue at a time, then rerun get_refill_target_plan before taking another action. Continue through every safe prep/source-copy/bounded-approval/read-only wait action inside that packet, but source-copy/fallback requires receipt-proven exhaustion of earlier ready/prep/approval rungs. Unbounded approval, start_campaign, source-family switches, threshold changes, and campaign creation require their own explicit gates. After each safe action, rerun get_refill_target_plan; keep going while targetShapeRevision is stable and projected coverage (sent + scheduled) progresses toward the target, even though stateRevision changes. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap, use only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Stop immediately if targetShapeRevision changes because sender set, route, ids, caps, dates, blockers, action class, paid InMail threshold feasibility, side-effect class, or receipt exhaustion proof drifts. --yolo does not authorize lowering paid InMail thresholds or creating connection campaigns."
             : hasSenderSelectors
                 ? "Before mutation, post the full bounded refill packet in normal chat as Markdown, including workspace, sender scope, campaign table, exact ids, caps/dates, gross target, sent count, scheduled count, projected count, ready buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision/stateRevision, side effects, forbidden actions, and stop condition. Then ask the final Accept/Decline structured approval question with a compact body that refers back to the posted packet instead of duplicating it. Only ask when get_refill_target_plan reports a positive remaining projected/ready gap. If target is complete by projected coverage, no-op without approval. If ready buffer covers the projected gap, run only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Threshold changes and campaign creation need separate explicit approval."
                 : "Ask which eligible enrolled senders to refill first, then, before mutation, post the full bounded refill packet in normal chat as Markdown and ask the final Accept/Decline structured approval question with a compact body that refers back to the posted packet.",
@@ -249,7 +252,7 @@ export function refillSendsCommand(input = {}) {
             "direct scheduler writes",
             "sender reassignment",
             "campaigns outside the rendered eligible sender packet",
-            "on-demand or unrelated active-campaign fallback unless the refill workflow proves the selected same-sender lane is blocked or exhausted",
+            "on-demand or unrelated active-campaign fallback unless the refill workflow shows receipt-proven exhaustion for the selected same-sender lane",
         ],
         hostExamples: {
             claude: [

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

@@ -79,6 +79,11 @@ function stringValue(value) {
 function booleanValue(value) {
     return typeof value === "boolean" ? value : undefined;
 }
+function numericRecord(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "number" && Number.isFinite(entry[1])));
+}
 function campaignClassificationValue(value) {
     return value === "sales_nav_cascade" ? "sales_nav_cascade" : undefined;
 }
@@ -190,6 +195,8 @@ function sanitizeActionCandidate(candidate) {
         columnRole: stringValue(candidate.columnRole),
         rowSelector: sanitizeRowSelector(candidate.rowSelector),
         actionKey: stringValue(candidate.actionKey),
+        wait: sanitizeWait(candidate.wait),
+        refillReceipt: sanitizeRefillReceipt(candidate.refillReceipt),
         rereadAfter: candidate.rereadAfter === "get_refill_target_plan"
             ? "get_refill_target_plan"
             : undefined,
@@ -217,6 +224,98 @@ function sanitizeRowSelector(value) {
             : {}),
     };
 }
+function sanitizeWait(value) {
+    if (!isRecord(value))
+        return undefined;
+    const deadlineAt = stringValue(value.deadlineAt);
+    const onExpiry = stringValue(value.onExpiry);
+    if (!deadlineAt && !onExpiry)
+        return undefined;
+    return { deadlineAt, onExpiry };
+}
+function sanitizeStuckActiveCells(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((cell) => isRecord(cell))
+        .map((cell) => ({
+        cellId: stringValue(cell.cellId),
+        rowId: stringValue(cell.rowId),
+        status: stringValue(cell.status),
+        ageMs: typeof cell.ageMs === "number" ? cell.ageMs : undefined,
+    }));
+}
+function sanitizeApprovedNotDispatched(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((row) => isRecord(row))
+        .map((row) => ({
+        rowId: stringValue(row.rowId),
+        attempts: typeof row.attempts === "number" ? row.attempts : undefined,
+        reason: stringValue(row.reason),
+        terminal: booleanValue(row.terminal),
+    }));
+}
+function sanitizeExistingRowFrontier(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        proof: stringValue(value.proof),
+        batchStop: stringValue(value.batchStop),
+        hasMoreFrontierRows: booleanValue(value.hasMoreFrontierRows),
+        stageCounts: numericRecord(value.stageCounts),
+        activeCellCount: typeof value.activeCellCount === "number"
+            ? value.activeCellCount
+            : undefined,
+        approvalCandidates: typeof value.approvalCandidates === "number"
+            ? value.approvalCandidates
+            : undefined,
+        brokenByReason: numericRecord(value.brokenByReason),
+        stuckActiveCells: sanitizeStuckActiveCells(value.stuckActiveCells),
+        approvedNotDispatched: sanitizeApprovedNotDispatched(value.approvedNotDispatched),
+        wait: sanitizeWait(value.wait),
+    };
+}
+function sanitizeSkippedRungs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((rung) => isRecord(rung))
+        .map((rung) => ({
+        rung: stringValue(rung.rung),
+        reason: stringValue(rung.reason),
+        detail: stringValue(rung.detail),
+    }));
+}
+function sanitizeRefillReceipt(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        summary: stringValue(value.summary),
+        schedulableGap: typeof value.schedulableGap === "number"
+            ? value.schedulableGap
+            : undefined,
+        schedulerFillableGap: typeof value.schedulerFillableGap === "number"
+            ? value.schedulerFillableGap
+            : undefined,
+        selectedCampaignId: stringValue(value.selectedCampaignId),
+        selectedCampaignName: stringValue(value.selectedCampaignName),
+        selectedTableId: stringValue(value.selectedTableId),
+        senderId: stringValue(value.senderId),
+        senderName: stringValue(value.senderName),
+        actionType: allowedActionType(value.actionType),
+        dateWindow: isRecord(value.dateWindow)
+            ? { selectedDates: stringArray(value.dateWindow.selectedDates) }
+            : undefined,
+        readyBuffer: typeof value.readyBuffer === "number" ? value.readyBuffer : undefined,
+        approvalCandidates: typeof value.approvalCandidates === "number"
+            ? value.approvalCandidates
+            : undefined,
+        existingRowFrontier: sanitizeExistingRowFrontier(value.existingRowFrontier),
+        skippedRungs: sanitizeSkippedRungs(value.skippedRungs),
+    };
+}
 function sanitizeRerunErroredCellsOperations(value) {
     if (!Array.isArray(value))
         return [];
@@ -285,6 +384,8 @@ function sanitizeToolInput(value) {
             : undefined,
         threshold: typeof value.threshold === "number" ? value.threshold : undefined,
         operations: sanitizeRerunErroredCellsOperations(value.operations),
+        wait: sanitizeWait(value.wait),
+        refillReceipt: sanitizeRefillReceipt(value.refillReceipt),
     };
 }
 function sanitizePacketIds(value) {
@@ -328,6 +429,7 @@ function sanitizeStructuredAction(action, selectedBySender, mode, rank) {
         toolInput: sanitizeToolInput(action.toolInput),
         inputSummary: stringValue(action.inputSummary) ?? "",
         reason: stringValue(action.reason) ?? "",
+        refillReceipt: sanitizeRefillReceipt(action.refillReceipt),
         prerequisites: stringArray(action.prerequisites),
         rereadAfter: action.rereadAfter === "get_refill_target_plan"
             ? "get_refill_target_plan"
@@ -514,6 +616,7 @@ function sanitizeStructuredSenderPlans(value, selectedBySender) {
             campaignRanking: sanitizeCampaignRanking(plan.campaignRanking),
             paidInmail: sanitizePaidInmail(plan.paidInmail),
             sourcePlan: sanitizeSourcePlan(plan.sourcePlan),
+            refillReceipt: sanitizeRefillReceipt(plan.refillReceipt),
             nextActions,
             manualAlternates,
             ...(isRecord(plan.emptyState)

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -97,8 +97,11 @@ That command helper normalizes arguments and returns the execution contract. In
 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, same-source row copy, and read-only wait
-rereads. It does not run unbounded approval, lower
+existing-row message preparation, generated-message approval, receipt-proven
+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, send,
 or write scheduler rows. Continue with the workflow below for route selection,
 state rereads, approval gating, source import, preparation, and bounded
@@ -198,7 +201,10 @@ Structured planner packet:
 - `target.senderRefillPlans[]` is the canonical sender-level packet; read and
   display it before mutation.
 - Each sender packet includes `campaignRanking.options`, `sourcePlan`,
-  `nextActions`, and `manualAlternates`.
+  `refillReceipt`, `nextActions`, and `manualAlternates`.
+- `refillReceipt` is the public ladder receipt. It carries the selected
+  campaign/sender/lane summary, skipped rungs, existing-row frontier proof, and
+  any absolute `wait.deadlineAt`.
 - Preserve these coverage labels exactly: `Need to prepare`, `Goal`,
   `Already sent`, `Scheduled`, `Ready and waiting to be scheduled`, and
   `Still need`.
@@ -217,6 +223,13 @@ from the selected source (`selectedLeadListId`, provider, and source
 fingerprint preserved), then use provider-aligned source-more. A new source or
 provider switch changes the reply-rate baseline and is a manual alternate, not a
 `--yolo` side effect.
+Source/copy/fallback requires receipt-proven exhaustion of earlier rungs:
+`existingRowFrontier.hasMoreFrontierRows:false`, zero `approvalCandidates`, no
+fresh active prep, no `stuckActiveCells`, and no non-terminal
+`approvedNotDispatched` rows. Treat anomalies, `stuckActiveCells`, and
+non-terminal `approvedNotDispatched` as diagnose-and-report gates, not
+exhaustion. Terminal `approvedNotDispatched` blockers may be reported, then the
+ladder can proceed.
 
 Run-local paid-credit guard: in `--yolo`, the `refill_sends` MCP command
 automatically maintains a `refreshedPaidInmailSenderIds` set for the current
@@ -266,6 +279,10 @@ interval, until projected coverage fills the target, a concrete non-scheduler
 blocker appears, or Christian explicitly asks to stop or only receive a status
 report. Treat `awaiting_scheduler_after_ready_buffer` as an in-progress wait
 state, not a close-out condition.
+Wait actions are gates, not competing goals. When `wait_for_active_work` or
+`wait_for_scheduler` includes receipt `wait.deadlineAt`, honor that absolute
+deadline; if it is expired on this call, escalate to diagnostics with the
+receipt evidence instead of issuing another blind wait.
 If paid InMail credit facts are stale or missing and the first target plan
 contains `refresh_paid_inmail_credits`, do not present that as the operator's
 next action in `--yolo`. Do not present paid-credit refresh as the next operator

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

@@ -119,7 +119,10 @@ files or memory.
    - `target.senderRefillPlans[]` is the canonical sender-level packet; read and
      display it before mutation.
    - Each sender packet includes `campaignRanking.options`, `sourcePlan`,
-     `nextActions`, and `manualAlternates`.
+     `refillReceipt`, `nextActions`, and `manualAlternates`.
+   - `refillReceipt` is the public ladder receipt. It carries the selected
+     campaign/sender/lane summary, skipped rungs, existing-row frontier proof,
+     and any absolute `wait.deadlineAt`.
    - Preserve these coverage labels exactly: `Need to prepare`, `Goal`,
      `Already sent`, `Scheduled`, `Ready and waiting to be scheduled`, and
      `Still need`.
@@ -138,6 +141,14 @@ files or memory.
    provider, and source fingerprint preserved), then use provider-aligned
    source-more. A new source or provider switch changes the reply-rate baseline
    and is a manual alternate, not a `--yolo` side effect.
+   Source/copy/fallback requires receipt-proven exhaustion of earlier rungs:
+   `existingRowFrontier.hasMoreFrontierRows:false`, zero
+   `approvalCandidates`, no fresh active prep, no `stuckActiveCells`, and no
+   non-terminal `approvedNotDispatched` rows. Treat anomalies,
+   `stuckActiveCells`, and non-terminal `approvedNotDispatched` as
+   diagnose-and-report gates, not exhaustion. Terminal
+   `approvedNotDispatched` blockers may be reported, then the ladder can
+   proceed.
    Run-local paid-credit guard: in `--yolo`, the `refill_sends` MCP command
    automatically maintains a `refreshedPaidInmailSenderIds` set for the current
    command call. If its first target plan has stale/missing paid-InMail credit
@@ -187,6 +198,10 @@ files or memory.
    stop or only receive a status report. Treat
    `awaiting_scheduler_after_ready_buffer` as an in-progress wait state, not a
    close-out condition.
+   Wait actions are gates, not competing goals. When `wait_for_active_work` or
+   `wait_for_scheduler` includes receipt `wait.deadlineAt`, honor that absolute
+   deadline; if it is expired on this call, escalate to diagnostics with the
+   receipt evidence instead of issuing another blind wait.
    If paid InMail credit facts are stale or missing and the first target plan
    contains `refresh_paid_inmail_credits`, do not present that as the operator's
    next action in `--yolo`. Do not present paid-credit refresh as the next