@sellable/mcp 0.1.731 → 0.1.732

package/dist/tools/refill-sends.js

@@ -1484,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 ||
@@ -1774,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
@@ -1859,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, " +
@@ -1882,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 ` +

package/package.json

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