@sellable/mcp 0.1.730 → 0.1.732

package/dist/tools/refill-sends.d.ts

@@ -3232,6 +3232,123 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     workspaceId: string | null;
     workspaceResolution: string;
     intent: RefillSendsIntent;
+} | {
+    ok: boolean;
+    status: string;
+    blocker: string;
+    note: string;
+    coordinator: {
+        scope: "workspace";
+        status: "blocked";
+        backgroundJob?: undefined;
+        workspaceTargetPlan?: undefined;
+        selectedTarget?: undefined;
+        waitAction?: undefined;
+        exactTargetPlan?: undefined;
+        note?: undefined;
+        completedTarget?: undefined;
+        exactRunResult?: undefined;
+        handBack?: undefined;
+    };
+    continuation: {
+        required: boolean;
+        userActionRequired: boolean;
+        renderBeforeInvoke?: undefined;
+        kind?: undefined;
+        tool?: undefined;
+        arguments?: undefined;
+        owner?: undefined;
+        retryAfterMs?: undefined;
+        stopCondition?: undefined;
+    };
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+    fillWindow: {
+        mode: string;
+        targetDate: string;
+        description: string;
+        untilDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        untilDate: string;
+        description: string;
+        targetDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        horizonSendDays: number | null;
+        horizonHours: number | null;
+        description: string;
+        targetDate?: undefined;
+        untilDate?: undefined;
+    };
+    approvalMode: RefillSendsApprovalMode;
+    campaignId: string | null;
+    tableId: string | null;
+    targetConfig: RefillTargetConfigV1 | null;
+    runHandle: RefillRunHandleV1 | null;
+    reportingContext: RefillReportingContextV2 | null;
+    messageTemplateRevision: MessageTemplateRevisionV1 | null;
+    senderScope: string;
+    senderSelectors: {
+        senders: string[];
+        senderIds: string[];
+        senderNames: string[];
+    };
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    hostExamples: {
+        claude: string[];
+        codex: string[];
+        mcpTool: {
+            name: string;
+            arguments: {
+                workspaceRunState?: Record<string, unknown> | undefined;
+                workspaceCoordinator?: boolean | undefined;
+                messageTemplateRevision?: MessageTemplateRevisionV1 | undefined;
+                reportingContext?: RefillReportingContextV2 | undefined;
+                targetConfig?: RefillTargetConfigV1 | undefined;
+                runHandle?: RefillRunHandleV1 | undefined;
+                fence?: number | undefined;
+                runId?: string | undefined;
+                expectedActionKey?: string | undefined;
+                expectedTargetShapeRevision?: string | undefined;
+                targetDate: string | null;
+                untilDate: string | null;
+                horizonSendDays: number | null;
+                campaignId: string | undefined;
+                tableId: string | undefined;
+                intent: RefillSendsIntent;
+                approvalMode: RefillSendsApprovalMode;
+                workspaceId: string | null;
+                actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+                yolo: boolean;
+                senders: string[];
+                senderIds: string[];
+                senderNames: string[];
+            };
+        };
+    };
+    actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+    command: string;
+    tool: string;
+    promptName: string;
+    workflowPromptName: string;
+    workflowAsset: {
+        subskillName: string;
+        assetPath: string;
+        expectedVersion: string;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
 } | {
     targetPlan: unknown;
     orchestration: {
@@ -8397,6 +8514,273 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     workspaceId: string | null;
     workspaceResolution: string;
     intent: RefillSendsIntent;
+} | {
+    status: "in_progress";
+    note: string;
+    targetPlan: unknown;
+    exactTargetPlan: {} | null;
+    orchestration: {
+        mode: string;
+        scope: string;
+        phase: string;
+        checkpointedFields?: undefined;
+        transportBudgetMs?: undefined;
+    };
+    coordinator: {
+        scope: string;
+        status: string;
+        completedTarget: WorkspaceExactTarget;
+        selectedTarget: WorkspaceExactTarget;
+        workspaceTargetPlan: unknown;
+        exactRunResult: {
+            status: "blocked";
+            blocker: string;
+            guidance: string;
+            conflicts: string[];
+            runId: string | undefined;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+        } | {
+            readOnly: boolean;
+            mode: string;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            blocker: string;
+            workspaceId: string;
+            guidance: string;
+            warnings: string[];
+            journalPath: string | null;
+            text: string;
+            workspaceResolution: string;
+            status?: undefined;
+            conflicts?: undefined;
+            runId?: undefined;
+        } | {
+            readOnly: boolean;
+            mode: string;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            warnings: any[];
+            journalPath: string | null;
+            text: string;
+            workspaceId: string;
+            workspaceResolution: string;
+            blocker?: undefined;
+            guidance?: undefined;
+            status?: undefined;
+            conflicts?: undefined;
+            runId?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "dry_run";
+            plan: Record<string, unknown>;
+            blocker?: undefined;
+            guidance?: undefined;
+            conflicts?: undefined;
+            runId?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "in_progress";
+            runId: string;
+            fence: number;
+            gate: import("../refill-run-loop.js").RefillLoopGate;
+            guidance: string;
+            journalPath?: string | null;
+            targetConfig?: RefillTargetConfigV1;
+            runHandle?: RefillRunHandleV1;
+            refillReporting?: Record<string, unknown>;
+            blocker?: undefined;
+            conflicts?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "blocked";
+            blocker: string;
+            runId?: string;
+            fence?: number;
+            gate?: import("../refill-run-loop.js").RefillLoopGate;
+            guidance: string;
+            holderRunId?: string;
+            report?: Record<string, unknown>;
+            journalPath?: string | null;
+            targetConfig?: RefillTargetConfigV1;
+            runHandle?: RefillRunHandleV1;
+            refillReporting?: Record<string, unknown>;
+            conflicts?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "terminal";
+            doneReason: string;
+            report: Record<string, unknown>;
+            runId: string;
+            guidance?: string;
+            journalPath?: string | null;
+            targetConfig?: RefillTargetConfigV1;
+            runHandle?: RefillRunHandleV1;
+            refillReporting?: Record<string, unknown>;
+            runState?: Record<string, unknown>;
+            blocker?: undefined;
+            conflicts?: undefined;
+        };
+        backgroundJob: {
+            jobId: string;
+            status?: undefined;
+            activityState?: undefined;
+            checkedRows?: undefined;
+            preparedMessages?: undefined;
+            activeCellCount?: undefined;
+        };
+        waitAction?: undefined;
+        exactTargetPlan?: undefined;
+        note?: undefined;
+        handBack?: undefined;
+    };
+    continuation: {
+        required: boolean;
+        kind: string;
+        owner: string;
+        userActionRequired: boolean;
+        tool: string;
+        retryAfterMs: number;
+        arguments: {
+            workspaceRunState?: Record<string, unknown> | {
+                coordinatorBlockedExactTargets: (Record<string, unknown> | null)[];
+            } | undefined;
+            yolo: boolean;
+            executionMode: "yolo";
+            requireWorkspace: boolean;
+            workspaceId: string;
+            workspaceCoordinator: boolean;
+            backgroundWait: {
+                jobId: string;
+                campaignId: string;
+                tableId: string;
+                deadlineAt: string;
+            };
+            senders?: string[];
+            senderIds?: string[];
+            senderNames?: string[];
+            horizonSendDays?: number;
+            untilDate?: string;
+            targetDate?: string;
+            campaignId?: string;
+            tableId?: string;
+            intent?: RefillSendsIntent;
+            approvalMode?: RefillSendsApprovalMode;
+            actionTypes?: RefillSendsActionType[];
+            expectedTargetShapeRevision?: string;
+            expectedActionKey?: string;
+            runId?: string;
+            fence?: number;
+            runHandle?: RefillRunHandleV1;
+            targetConfig?: RefillTargetConfigV1;
+            reportingContext?: RefillReportingContextV2;
+            messageTemplateRevision?: MessageTemplateRevisionV1;
+            agentKeywords?: string[];
+        };
+        stopCondition: string;
+        renderBeforeInvoke?: undefined;
+    };
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+    fillWindow: {
+        mode: string;
+        targetDate: string;
+        description: string;
+        untilDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        untilDate: string;
+        description: string;
+        targetDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        horizonSendDays: number | null;
+        horizonHours: number | null;
+        description: string;
+        targetDate?: undefined;
+        untilDate?: undefined;
+    };
+    approvalMode: RefillSendsApprovalMode;
+    campaignId: string | null;
+    tableId: string | null;
+    targetConfig: RefillTargetConfigV1 | null;
+    runHandle: RefillRunHandleV1 | null;
+    reportingContext: RefillReportingContextV2 | null;
+    messageTemplateRevision: MessageTemplateRevisionV1 | null;
+    senderScope: string;
+    senderSelectors: {
+        senders: string[];
+        senderIds: string[];
+        senderNames: string[];
+    };
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    hostExamples: {
+        claude: string[];
+        codex: string[];
+        mcpTool: {
+            name: string;
+            arguments: {
+                workspaceRunState?: Record<string, unknown> | undefined;
+                workspaceCoordinator?: boolean | undefined;
+                messageTemplateRevision?: MessageTemplateRevisionV1 | undefined;
+                reportingContext?: RefillReportingContextV2 | undefined;
+                targetConfig?: RefillTargetConfigV1 | undefined;
+                runHandle?: RefillRunHandleV1 | undefined;
+                fence?: number | undefined;
+                runId?: string | undefined;
+                expectedActionKey?: string | undefined;
+                expectedTargetShapeRevision?: string | undefined;
+                targetDate: string | null;
+                untilDate: string | null;
+                horizonSendDays: number | null;
+                campaignId: string | undefined;
+                tableId: string | undefined;
+                intent: RefillSendsIntent;
+                approvalMode: RefillSendsApprovalMode;
+                workspaceId: string | null;
+                actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+                yolo: boolean;
+                senders: string[];
+                senderIds: string[];
+                senderNames: string[];
+            };
+        };
+    };
+    actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+    command: string;
+    tool: string;
+    promptName: string;
+    workflowPromptName: string;
+    workflowAsset: {
+        subskillName: string;
+        assetPath: string;
+        expectedVersion: string;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
 } | {
     status: "terminal";
     doneReason: "loaded_awaiting_scheduler";

package/dist/tools/refill-sends.js

@@ -219,6 +219,13 @@ function normalizeWorkspaceRunState(value) {
         if (entries.length > 0)
             attemptLedgers[key] = entries;
     }
+    // fix(112aj): preserve the continuation-level progress-or-settle counter across
+    // coordinator calls. Like the attempt ledgers above, stripping it here would
+    // reset the identical-active_exact_run replay count to 1 on every resume and the
+    // cap could never trip.
+    const activeExactRunProgress = recordValue(root.activeExactRunProgress);
+    const activeExactRunFingerprint = stringValue(activeExactRunProgress?.fingerprint);
+    const activeExactRunCount = numberValue(activeExactRunProgress?.count);
     return {
         version: 1,
         senderCursors,
@@ -226,6 +233,14 @@ function normalizeWorkspaceRunState(value) {
         passRates: [],
         coordinatorBlockedExactTargets,
         ...attemptLedgers,
+        ...(activeExactRunFingerprint && typeof activeExactRunCount === "number"
+            ? {
+                activeExactRunProgress: {
+                    fingerprint: activeExactRunFingerprint,
+                    count: activeExactRunCount,
+                },
+            }
+            : {}),
     };
 }
 const WORKSPACE_ATTEMPT_LEDGER_KEYS = [
@@ -813,6 +828,36 @@ function withKeywordsHandoffScope(result, scopedInput) {
 }
 const BACKGROUND_WAIT_FAST_PATH_TTL_MS = 10 * 60 * 1000;
 const BACKGROUND_WAIT_MIN_RETRY_MS = 5_000;
+// fix(112aj): the continuation-level progress-or-settle contract (the same
+// principle as the ag/af-c bypasses, applied one layer up). An identical
+// active_exact_run continuation — the SAME fence resumed at the same gate /
+// gateSeq / state / plan / shape revision with no observable coverage or effect
+// advance — may not be re-invoked unboundedly. Clover t4 (fence 109, run
+// cmrz49lii) resumed a broaden fence stuck at g2_execute 20× with a byte-stable
+// runSnapshot (gate g2_execute, gateSeq 2, stateRev 36a1de45) — no product effect,
+// no fresh handoff, no no_forward_progress — because the broaden's own attempt
+// bookkeeping wobbles the run-loop's mortality signature. This coordinator bound
+// counts identical active_exact_run resumes and, past the cap, returns an honest
+// no_forward_progress terminal and settles the fence (no continuation, not
+// re-spawned). A fence that IS advancing (any fingerprint field changes) resets
+// the counter and resumes normally, unbounded.
+const ACTIVE_EXACT_RUN_REPLAY_CAP = 3;
+function activeExactRunProgressFingerprint(result) {
+    const snapshot = recordValue(result.runSnapshot);
+    const runId = stringValue(result.runId) ?? stringValue(snapshot?.runId);
+    const fence = numberValue(result.fence);
+    if (!runId || typeof fence !== "number" || !snapshot)
+        return null;
+    return [
+        runId,
+        String(fence),
+        stringValue(snapshot.gate) ?? "",
+        String(numberValue(snapshot.gateSeq) ?? ""),
+        stringValue(snapshot.stateRevision) ?? "",
+        stringValue(snapshot.planRevision) ?? "",
+        stringValue(snapshot.targetShapeRevision) ?? "",
+    ].join("|");
+}
 // Action families whose successful exact terminal means NEW ROWS landed on
 // the campaign — invalidating any earlier complete/capped defer for it.
 const WORKSPACE_SUPPLY_ACTION_FAMILIES = new Set([
@@ -895,6 +940,51 @@ function backgroundWaitFromSelection(selection, now) {
         retryAfterMs,
     };
 }
+// fix(112ai): extract a still-running bounded prep/approve job receipt from a
+// just-completed exact run. When the census bypass admits a masked prepare/
+// approve edge, the coordinator dispatches a bounded job and the exact run
+// returns exact_action_complete with a preparationReceipt that is still RUNNING
+// (terminal:false) — the job drains the lane ASYNC, so the actionable census is
+// non-empty only because scanning has not finished. That in-flight job IS the
+// queued supply behind a non-empty census, so the coordinator must wait on it
+// (self-heal) rather than false-terminal actionable_supply_not_queued
+// (sellable-t4 7-29: prepare_messages:7fc0766d dispatched job cmrz555uc scanning
+// while 681 enrich rows sat in the census). A terminal:true receipt means the
+// job already drained; that is NOT a wait case, and the normal terminal logic
+// (which may legitimately block on residual, correctly-named conditions) runs.
+function dispatchedRunningPrepReceipt(result, completedFamily) {
+    if (completedFamily !== "prepare_messages" &&
+        completedFamily !== "approve_messages") {
+        return null;
+    }
+    const r = recordValue(result);
+    if (stringValue(r?.status) !== "terminal")
+        return null;
+    if (stringValue(r?.doneReason) !== "exact_action_complete")
+        return null;
+    const receipt = recordValue(recordValue(r?.report)?.preparationReceipt);
+    if (!receipt)
+        return null;
+    // Only a still-running durable receipt is draining work. terminal:true means
+    // the job finished (residual census is a different, correctly-named case); a
+    // failed/blocked/errored receipt is a real condition the terminal must surface.
+    if (receipt.terminal === true)
+        return null;
+    const status = stringValue(receipt.status);
+    if (status === "failed" ||
+        status === "error" ||
+        status === "blocked" ||
+        status === "cancelled") {
+        return null;
+    }
+    const jobId = stringValue(receipt.jobId);
+    if (!jobId)
+        return null;
+    return {
+        jobId,
+        retryAfterMs: Math.max(BACKGROUND_WAIT_MIN_RETRY_MS, numberValue(receipt.retryAfterMs) ?? 15_000),
+    };
+}
 function workspaceExactTargetsFromAction(action) {
     if (!Array.isArray(action.exactTargets) || action.exactTargets.length === 0) {
         return [];
@@ -1394,6 +1484,12 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
                 workspacePlan,
             };
         }
+        // fix(112ak): empty-candidate terminal path — a ready-surplus gap resolves to
+        // the truthful loaded terminal instead of the actionable_supply_not_queued
+        // defect class (see readySurplusLoadedSelection).
+        const readyLoadedSelection = readySurplusLoadedSelection(workspacePlan);
+        if (readyLoadedSelection)
+            return readyLoadedSelection;
         return {
             status: "blocked",
             ...classifyWorkspaceUnavailableTerminal(workspacePlan, (excludedTargets.length > 0 ||
@@ -1458,17 +1554,23 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             selectedActionFamily === "continue_prospeo_source" ||
             selectedActionFamily === "broaden_provider_search" ||
             selectedActionFamily === "refresh_sender_post_engagers";
-        // fix(112af-c): a prepare_messages edge suffers the same pooled-cascade
-        // masking as sources/sweeps/waits — its exact scope can read scheduler-loaded
-        // or complete via the shared ready buffer while the lane still holds genuine
-        // never-run supply (sellable.dev 7-29: cmrcd4x4a send_invite prepare skipped
-        // while 69 enrich + 1 generate never-run rows sat behind it). Unlike those
-        // families a prepare is not unconditionally bindable — a genuinely-complete
-        // prepare must stay deferred to avoid a re-prepare loop. So bind ONLY when the
-        // LANE-SCOPED actionable census (per-sender existingRowFrontier stageCounts,
-        // never the pooled coverage) proves a real frontier; an empty census keeps the
-        // settled skip, and the bounded job consumes the frontier so the census drains.
-        const isMaskedPrepareTarget = selectedActionFamily === "prepare_messages" &&
+        // fix(112af-c/112ai): a prepare_messages OR approve_messages edge suffers the
+        // same pooled-cascade masking as sources/sweeps/waits — its exact scope can
+        // read scheduler-loaded or complete via the shared ready buffer while the lane
+        // still holds genuine actionable supply (sellable.dev 7-29: cmrcd4x4a
+        // send_invite prepare skipped while 69 enrich + 1 generate never-run rows sat
+        // behind it; Amplify t3 Sadhna + Dotwork cmqbt8b8: approve_messages skipped
+        // while a real approval frontier — needsApproval > 0 — sat behind it). This
+        // closes the masked-supply family (sweep→112ag, prepare→112af-c, approve→112ai)
+        // with ONE census-conditional bypass. Unlike sources/sweeps/waits these are not
+        // unconditionally bindable — a genuinely-complete prepare/approve must stay
+        // deferred to avoid a re-prepare loop. So bind ONLY when the LANE-SCOPED
+        // actionable census (per-sender existingRowFrontier stageCounts —
+        // needsApproval/needsGenerate/needsEnrich/needsRubric, never the pooled
+        // coverage) proves a real frontier; an empty census keeps the settled skip, and
+        // the bounded job consumes the frontier so the census drains.
+        const isMaskedSupplyTarget = (selectedActionFamily === "prepare_messages" ||
+            selectedActionFamily === "approve_messages") &&
             exactPlanHasLaneScopedActionableFrontier(exactTargetPlan);
         // fix(111f, OWNER DIRECTIVE — dispatch-first): a settled preflight read
         // may only skip a target when its exact plan exposes NO unresolved
@@ -1482,7 +1584,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
         const bypassSettledSkips = isSchedulerSweepTarget ||
             isBackgroundWaitTarget ||
             isSourceSupplyTarget ||
-            isMaskedPrepareTarget ||
+            isMaskedSupplyTarget ||
             yoloPlanHasUnresolvedCoordinatorAction(exactTargetPlan);
         if (!bypassSettledSkips && yoloPlanIsComplete(exactTargetPlan)) {
             completedExactTargetCount += 1;
@@ -1678,6 +1780,12 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             workspacePlan,
         };
     }
+    // fix(112ak): filtered-candidate terminal path — a ready-surplus gap resolves to
+    // the truthful loaded terminal instead of the actionable_supply_not_queued defect
+    // class (see readySurplusLoadedSelection).
+    const readyLoadedSelection = readySurplusLoadedSelection(workspacePlan);
+    if (readyLoadedSelection)
+        return readyLoadedSelection;
     return {
         status: "blocked",
         ...classifyWorkspaceUnavailableTerminal(workspacePlan, (workspaceCoverage.remainingReadyOrProjectedGap !== 0
@@ -1763,18 +1871,115 @@ function workspaceActionableSupplyCensus(plan) {
         senderPlanCount: senderPlans.length,
     };
 }
+// fix(112ak, OWNER closing invariant): the workspace terminal classifier must
+// only count actionable supply / frontier signal from senders that still OWE
+// coverage. A COVERED sender (remainingProjectedGap 0) can carry surplus
+// hasMoreFrontierRows or surplus stage rows; that surplus must never be read as
+// "unexposed actionable supply" for a DIFFERENT sender's gap (Amplify t5:
+// Ali/Victor gap 0 but hasMoreFrontierRows true masked Sadhna's gap-10 lane
+// whose own stage census was empty and whose 10 rows were paid-InMail
+// ready_to_schedule surplus — so the workspace false-terminaled
+// actionable_supply_not_queued while every gap-bearing lane was actually
+// scheduler/pacing-bound). This re-derives the census over ONLY gap-bearing
+// senders and buckets each gap lane: real actionable supply, ready-surplus
+// (prepared rows awaiting the scheduler), or opaque (no ready/actionable/frontier
+// residue). A missing gap is treated as gap-bearing (conservative) so plans
+// without gap accounting keep the loud actionable classification.
+function workspaceGapBearingActionableSupply(plan) {
+    const target = yoloTarget(plan);
+    const senderPlansRaw = target?.senderPlans;
+    const senderPlans = Array.isArray(senderPlansRaw) ? senderPlansRaw : [];
+    let approvalFrontier = 0;
+    let generateFrontier = 0;
+    let enrichFrontier = 0;
+    let rubricFrontier = 0;
+    let frontierHasMoreRows = false;
+    let gapSenderCount = 0;
+    let readySurplusGapSenders = 0;
+    let opaqueGapSenders = 0;
+    for (const senderPlan of senderPlans) {
+        const rec = recordValue(senderPlan);
+        const gap = numberValue(rec?.remainingProjectedGap);
+        // Only lanes that still owe coverage classify the workspace gap. A gap-0
+        // (covered) sender's surplus never contributes; a missing gap is included.
+        if (typeof gap === "number" && gap <= 0)
+            continue;
+        gapSenderCount += 1;
+        const receipt = recordValue(rec?.refillReceipt);
+        const frontier = recordValue(receipt?.existingRowFrontier);
+        const stageCounts = recordValue(frontier?.stageCounts);
+        const approval = Math.max(numberValue(receipt?.approvalCandidates) ?? 0, numberValue(stageCounts?.needsApproval) ?? 0);
+        const generate = numberValue(stageCounts?.needsGenerate) ?? 0;
+        const enrich = numberValue(stageCounts?.needsEnrich) ?? 0;
+        const rubric = numberValue(stageCounts?.needsRubric) ?? 0;
+        const laneActionable = approval + generate + enrich + rubric;
+        const laneFrontier = frontier?.hasMoreFrontierRows === true;
+        const laneReady = numberValue(stageCounts?.ready) ?? 0;
+        approvalFrontier += approval;
+        generateFrontier += generate;
+        enrichFrontier += enrich;
+        rubricFrontier += rubric;
+        if (laneFrontier)
+            frontierHasMoreRows = true;
+        if (laneActionable === 0 && !laneFrontier) {
+            if (laneReady > 0)
+                readySurplusGapSenders += 1;
+            else
+                opaqueGapSenders += 1;
+        }
+    }
+    const actionableRows = approvalFrontier + generateFrontier + enrichFrontier + rubricFrontier;
+    return {
+        approvalFrontier,
+        generateFrontier,
+        enrichFrontier,
+        rubricFrontier,
+        frontierHasMoreRows,
+        actionableRows,
+        gapSenderCount,
+        readySurplusGapSenders,
+        opaqueGapSenders,
+    };
+}
+// fix(112ak): when the workspace gap is owed entirely by gap-bearing lanes whose
+// residue is ready-surplus (prepared rows in stageCounts.ready, zero actionable
+// stage supply, no own frontier), the gap is scheduler/pacing-bound — the rows
+// are ready and the scheduler places them as capacity frees — NOT a
+// planner-exposure defect. Return the truthful loaded terminal instead of
+// actionable_supply_not_queued (Amplify t5: Sadhna's gap-10 lane was 10 paid-InMail
+// ready_to_schedule rows on a fully-scheduled day while COVERED senders carried
+// the only frontier signal). Gated on the gap-bearing census being empty-actionable
+// AND every gap lane ready-surplus (no opaque residue), so a genuinely-stuck or
+// genuinely-actionable gap still classifies honestly. Applied at BOTH selection
+// terminal sites (empty-candidate early path and the filtered-candidate path).
+function readySurplusLoadedSelection(workspacePlan) {
+    const gapSupply = workspaceGapBearingActionableSupply(workspacePlan);
+    if (gapSupply.gapSenderCount > 0 &&
+        gapSupply.actionableRows === 0 &&
+        !gapSupply.frontierHasMoreRows &&
+        gapSupply.opaqueGapSenders === 0 &&
+        gapSupply.readySurplusGapSenders > 0) {
+        return {
+            status: "loaded_awaiting_scheduler",
+            note: "Every gap-bearing sender lane is already prepared and ready to schedule; the remaining workspace gap is scheduler/pacing-bound (ready rows awaiting placement), not unexposed actionable supply. No refill run or mutation was started." +
+                workspaceTypedBlockersNote(workspacePlan),
+            workspacePlan,
+        };
+    }
+    return null;
+}
 function classifyWorkspaceUnavailableTerminal(plan, contextNote) {
-    const census = workspaceActionableSupplyCensus(plan);
-    const actionableRows = census.approvalFrontier +
-        census.generateFrontier +
-        census.enrichFrontier +
-        census.rubricFrontier;
+    // fix(112ak): gap-gate the actionable_supply signal — only supply behind a
+    // gap-bearing lane proves the planner failed to expose actionable work. A
+    // covered sender's surplus frontier/stage rows do NOT justify the defect class.
+    const census = workspaceGapBearingActionableSupply(plan);
+    const actionableRows = census.actionableRows;
     if (actionableRows > 0 || census.frontierHasMoreRows) {
         return {
             code: "actionable_supply_not_queued",
             note: `Actionable existing-row supply remains (${census.approvalFrontier} approval, ` +
                 `${census.generateFrontier} generate, ${census.enrichFrontier} enrich, ` +
-                `${census.rubricFrontier} rubric candidates across sender lanes` +
+                `${census.rubricFrontier} rubric candidates across gap-bearing sender lanes` +
                 `${census.frontierHasMoreRows ? ", plus unprocessed frontier rows" : ""}) ` +
                 "but the fresh workspace queue exposed no executable exact edge for it. " +
                 "This is retryable: re-run refill_sends with a fresh command; if it repeats, " +
@@ -1786,7 +1991,8 @@ function classifyWorkspaceUnavailableTerminal(plan, contextNote) {
     const gap = coverage.remainingReadyOrProjectedGap ?? coverage.remainingProjectedGap;
     // Claim receipt-proven exhaustion only when sender receipts were actually
     // present in the plan; a plan without senderPlans keeps the generic code.
-    if (census.senderPlanCount > 0 && typeof gap === "number" && gap > 0) {
+    const senderPlanCount = workspaceActionableSupplyCensus(plan).senderPlanCount;
+    if (senderPlanCount > 0 && typeof gap === "number" && gap > 0) {
         return {
             code: "new_campaign_required",
             note: `Receipts prove every existing planner-ranked campaign/lane/source family is ` +
@@ -1799,17 +2005,19 @@ function classifyWorkspaceUnavailableTerminal(plan, contextNote) {
     }
     return { code: "workspace_exact_target_unavailable", note: contextNote };
 }
-// fix(112af-c): a prepare_messages edge on a cascade can read scheduler-loaded
-// or complete at the pooled campaign scope (the shared ready buffer routed to
-// Open/paid InMail or the connection fallback covers the aggregate gap) while a
-// specific lane still holds genuine never-run supply the pooled coverage masks
-// (sellable.dev 7-29: cmrcd4x4a send_invite prepare skipped as "complete or
-// scheduler-loaded" while 69 enrich + 1 generate never-run rows sat behind it).
-// The lane-scoped signal is the per-sender existingRowFrontier stageCounts summed
-// by workspaceActionableSupplyCensus — NEVER the pooled readyBuffer/coverage. When
-// that census is non-empty the prepare edge is a masked-gap prepare and must bind
-// so the bounded job consumes the frontier; when the census is empty the edge is
-// genuinely settled and stays deferred (no re-prepare loop).
+// fix(112af-c/112ai): a prepare_messages OR approve_messages edge on a cascade can
+// read scheduler-loaded or complete at the pooled campaign scope (the shared ready
+// buffer routed to Open/paid InMail or the connection fallback covers the aggregate
+// gap) while a specific lane still holds genuine actionable supply the pooled
+// coverage masks (sellable.dev 7-29: cmrcd4x4a send_invite prepare skipped as
+// "complete or scheduler-loaded" while 69 enrich + 1 generate never-run rows sat
+// behind it; Dotwork cmqbt8b8 + Amplify t3 Sadhna: approve skipped while a real
+// needsApproval frontier sat behind it). The lane-scoped signal is the per-sender
+// existingRowFrontier stageCounts summed by workspaceActionableSupplyCensus — NEVER
+// the pooled readyBuffer/coverage. When that census is non-empty the edge is a
+// masked-gap prep/approve and must bind so the bounded job consumes the frontier;
+// when the census is empty the edge is genuinely settled and stays deferred (no
+// re-prepare / re-approve loop).
 function exactPlanHasLaneScopedActionableFrontier(plan) {
     const census = workspaceActionableSupplyCensus(plan);
     return (census.approvalFrontier > 0 ||
@@ -3413,6 +3621,49 @@ export async function executeRefillSendsCommand(input = {}) {
             : supplyLandedOnCampaign
                 ? clearCompleteDefersForCampaign(deferredCoordinatorWorkspaceRunState, selectedCoordinatorTarget?.campaignId ?? null)
                 : deferredCoordinatorWorkspaceRunState;
+        // fix(112aj): continuation-level progress-or-settle. When this dispatch is an
+        // active_exact_run resume (continuationHandle set, in_progress), fingerprint
+        // the fence's observable state; if the SAME fence has been re-invoked
+        // ACTIVE_EXACT_RUN_REPLAY_CAP times with a byte-identical fingerprint (no
+        // coverage/effect advance), settle it honestly instead of re-inviting an
+        // identical continuation. A fence that advanced (any fingerprint field moved)
+        // resets the counter and resumes normally.
+        let progressBoundedWorkspaceRunState = coordinatorWorkspaceRunState;
+        if (yolo && continuationHandle) {
+            const fingerprint = activeExactRunProgressFingerprint(result);
+            const priorProgress = recordValue(recordValue(scopedInput.workspaceRunState)?.activeExactRunProgress);
+            const replayCount = fingerprint && stringValue(priorProgress?.fingerprint) === fingerprint
+                ? (numberValue(priorProgress?.count) ?? 0) + 1
+                : 1;
+            if (fingerprint && replayCount >= ACTIVE_EXACT_RUN_REPLAY_CAP) {
+                return {
+                    ...command,
+                    ok: false,
+                    status: "blocked",
+                    blocker: "no_forward_progress",
+                    note: `The active exact run (${continuationHandle.runId} fence ${continuationHandle.fence}) was resumed ${replayCount} times with no observable coverage or effect advance ` +
+                        "(identical gate/state fingerprint). Settling the fence instead of re-inviting an identical continuation; a fresh refill_sends command reconciles it. No run or mutation was started.",
+                    coordinator: {
+                        scope: "workspace",
+                        status: "blocked",
+                    },
+                    continuation: { required: false, userActionRequired: false },
+                };
+            }
+            progressBoundedWorkspaceRunState = fingerprint
+                ? {
+                    ...(recordValue(coordinatorWorkspaceRunState) ?? {}),
+                    activeExactRunProgress: { fingerprint, count: replayCount },
+                }
+                : coordinatorWorkspaceRunState;
+        }
+        else {
+            const base = recordValue(coordinatorWorkspaceRunState);
+            if (base && "activeExactRunProgress" in base) {
+                const { activeExactRunProgress: _cleared, ...rest } = base;
+                progressBoundedWorkspaceRunState = rest;
+            }
+        }
         const workspaceContinuationArguments = {
             yolo: true,
             executionMode: "yolo",
@@ -3432,8 +3683,8 @@ export async function executeRefillSendsCommand(input = {}) {
                 : {}),
             approvalMode: scopedInput.approvalMode ?? "approve",
             ...(isWorkspaceCoordinator ? { workspaceCoordinator: true } : {}),
-            ...(coordinatorWorkspaceRunState
-                ? { workspaceRunState: coordinatorWorkspaceRunState }
+            ...(progressBoundedWorkspaceRunState
+                ? { workspaceRunState: progressBoundedWorkspaceRunState }
                 : {}),
         };
         if (isWorkspaceCoordinator &&
@@ -3659,6 +3910,79 @@ export async function executeRefillSendsCommand(input = {}) {
                 };
             }
             if (nextSelection.status === "blocked") {
+                // fix(112ai, OWNER closing invariant): actionable_supply_not_queued is a
+                // planner-exposure DEFECT terminal and is legal ONLY when no bounded
+                // prep/approve job dispatched THIS command is still draining the census.
+                // The af-c/ai census bypass admits the masked prepare/approve edge and
+                // the coordinator dispatches a bounded job, but that job drains ASYNC:
+                // the exact run returns exact_action_complete with a still-running
+                // receipt (terminal:false) while the census still shows the un-drained
+                // rows. Emitting actionable_supply_not_queued here (continuation
+                // required:false) HALTS the yolo loop before the job drains — the exact
+                // false-terminal the owner ruled unacceptable on sellable-t4
+                // (prepare_messages:7fc0766d dispatched job cmrz555uc scanning while 681
+                // enrich rows sat in the census). Recognize the in-flight job as the
+                // queued supply: emit a healthy background-wait so the loop re-invokes,
+                // the fast path probes the job by id (sidestepping the planner-exposure
+                // gap that starved the reread), and the census drains (self-heal). This
+                // makes "non-empty census + dispatched running job + halting defect
+                // terminal" unrepresentable.
+                const runningPrepReceipt = dispatchedRunningPrepReceipt(result, completedPrepFamily);
+                if (nextSelection.code === "actionable_supply_not_queued" &&
+                    runningPrepReceipt &&
+                    selectedCoordinatorTarget) {
+                    const backgroundContinuationInput = workspaceCoordinatorInput(scopedInput);
+                    delete backgroundContinuationInput.expectedTargetShapeRevision;
+                    delete backgroundContinuationInput.expectedActionKey;
+                    const backgroundWait = {
+                        jobId: runningPrepReceipt.jobId,
+                        campaignId: selectedCoordinatorTarget.campaignId ?? null,
+                        tableId: selectedCoordinatorTarget.tableId ?? null,
+                        deadlineAt: new Date(Date.now() + BACKGROUND_WAIT_FAST_PATH_TTL_MS).toISOString(),
+                    };
+                    return {
+                        ...command,
+                        status: "in_progress",
+                        note: `The exact ${completedPrepFamily} edge dispatched a bounded preparation job (${runningPrepReceipt.jobId}) that is still draining the lane; the actionable census remains non-empty only because that job has not finished scanning. Waiting on the in-flight job instead of false-terminaling actionable_supply_not_queued — the loop re-invokes, the job drains the frontier, and coverage advances.`,
+                        targetPlan: nextSelection.workspacePlan,
+                        exactTargetPlan: nextSelection.exactTargetPlan ?? null,
+                        orchestration: {
+                            mode: "fenced_bounded_yolo",
+                            scope: "workspace_exact_target_coordinator",
+                            phase: "read_only_background_wait",
+                        },
+                        coordinator: {
+                            scope: "workspace",
+                            status: "waiting_background",
+                            completedTarget: selectedCoordinatorTarget,
+                            selectedTarget: selectedCoordinatorTarget,
+                            workspaceTargetPlan: nextSelection.workspacePlan,
+                            exactRunResult: result,
+                            backgroundJob: { jobId: runningPrepReceipt.jobId },
+                        },
+                        continuation: {
+                            required: true,
+                            kind: "workspace_background_wait",
+                            owner: "packaged_workflow",
+                            userActionRequired: false,
+                            tool: "refill_sends",
+                            retryAfterMs: runningPrepReceipt.retryAfterMs,
+                            arguments: {
+                                ...backgroundContinuationInput,
+                                yolo: true,
+                                executionMode: "yolo",
+                                requireWorkspace: true,
+                                workspaceId,
+                                workspaceCoordinator: true,
+                                backgroundWait,
+                                ...(coordinatorWorkspaceRunState
+                                    ? { workspaceRunState: coordinatorWorkspaceRunState }
+                                    : {}),
+                            },
+                            stopCondition: "A bounded preparation job dispatched this command is still draining the actionable census. After the bounded wait, replan the whole workspace; do not open or resume an exact fence solely to poll background work.",
+                        },
+                    };
+                }
                 const persistedDeferredBlocker = coordinatorDeferredBlocker(coordinatorWorkspaceRunState);
                 const workspaceCoverage = yoloCoverage(nextSelection.workspacePlan);
                 if (persistedDeferredBlocker === "loaded_awaiting_scheduler" &&

package/package.json

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