@sellable/mcp 0.1.728 → 0.1.730

package/dist/tools/refill-sends.js

@@ -1313,7 +1313,29 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
         return (!excludedTargets.some((excluded) => excluded.campaignId === candidate.campaignId &&
             excluded.tableId === candidate.tableId) &&
             !excludedExactTargetKeys.has(key) &&
-            !prefilterBlockedTargets.some((blocked) => coordinatorBlockedExactTargetMatches(blocked, candidate)));
+            !prefilterBlockedTargets.some((blocked) => {
+                if (!coordinatorBlockedExactTargetMatches(blocked, candidate)) {
+                    return false;
+                }
+                // fix(112ag): a run_scheduler_sweep is the scheduler PLACEMENT action that
+                // RESOLVES a loaded_awaiting_scheduler state — the loaded blocker is set by
+                // the prepare/approve fence that produced the ready rows, not by the sweep.
+                // prefilterBlockedTargets excludes every blocker EXCEPT complete/capped, so
+                // a loaded edge lands here and would drop its own sweep BEFORE the in-loop
+                // "sweeps always bind" bypass can act (Amplify t2: cascade cmrk6nihu loaded
+                // 8x, the dated 2026-07-29 sweep — required because that date is beyond the
+                // 48h ambient window — was prefilter-dropped, 0 sweep dispatches, 37 ready
+                // rows stranded at scheduled 0). Waive ONLY the loaded_awaiting_scheduler
+                // blocker and ONLY for the sweep candidate: every other blocker still
+                // excludes it, prep/approve candidates on a loaded edge are still excluded,
+                // and complete/capped edges (never in prefilterBlockedTargets) still bar
+                // prep re-dispatch via completeDeferredTargets in the loop below.
+                if (blocked.blocker === "loaded_awaiting_scheduler" &&
+                    workspaceActionFamily(candidate.actionKey) === "run_scheduler_sweep") {
+                    return false;
+                }
+                return true;
+            }));
     });
     if (targetCandidates.length === 0) {
         const pendingWaitAction = workspaceActiveWorkWaitAction(workspaceActions) ??
@@ -1436,6 +1458,18 @@ 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" &&
+            exactPlanHasLaneScopedActionableFrontier(exactTargetPlan);
         // fix(111f, OWNER DIRECTIVE — dispatch-first): a settled preflight read
         // may only skip a target when its exact plan exposes NO unresolved
         // coordinator action — any bindable head (source supply, sweeps,
@@ -1448,6 +1482,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
         const bypassSettledSkips = isSchedulerSweepTarget ||
             isBackgroundWaitTarget ||
             isSourceSupplyTarget ||
+            isMaskedPrepareTarget ||
             yoloPlanHasUnresolvedCoordinatorAction(exactTargetPlan);
         if (!bypassSettledSkips && yoloPlanIsComplete(exactTargetPlan)) {
             completedExactTargetCount += 1;
@@ -1519,7 +1554,20 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             // must be enforced again after the exact binding is known.
             actionKey: targetConfig.approvalInputs.expectedActionKey,
         };
-        if (blockedExactTargets.some((blocked) => coordinatorBlockedExactTargetMatches(blocked, exactSelectedTarget))) {
+        if (blockedExactTargets.some((blocked) => {
+            if (!coordinatorBlockedExactTargetMatches(blocked, exactSelectedTarget)) {
+                return false;
+            }
+            // fix(112ag): mirror the prefilter waiver after the exact rebind — a
+            // run_scheduler_sweep is the placement action that resolves a
+            // loaded_awaiting_scheduler state, so a loaded blocker on its own edge
+            // must not re-skip it here. Every other blocker still excludes it.
+            if (isSchedulerSweepTarget &&
+                blocked.blocker === "loaded_awaiting_scheduler") {
+                return false;
+            }
+            return true;
+        })) {
             continue;
         }
         const selection = {
@@ -1751,6 +1799,25 @@ 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).
+function exactPlanHasLaneScopedActionableFrontier(plan) {
+    const census = workspaceActionableSupplyCensus(plan);
+    return (census.approvalFrontier > 0 ||
+        census.generateFrontier > 0 ||
+        census.enrichFrontier > 0 ||
+        census.rubricFrontier > 0 ||
+        census.frontierHasMoreRows);
+}
 function yoloPlanIsComplete(plan) {
     const coverage = yoloCoverage(plan);
     return (coverage.status === "complete" ||

package/package.json

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