@sellable/mcp 0.1.731 → 0.1.733

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

@@ -1712,8 +1712,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     readOnly: boolean;
     ok: boolean;
     status: "blocked";
-    code: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued";
-    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued";
+    code: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued" | "source_supply_exhausted_at_rubric";
+    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued" | "source_supply_exhausted_at_rubric";
     note: string;
     targetPlan: unknown;
     exactTargetPlan: {} | null;
@@ -2931,8 +2931,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
 } | {
     ok: boolean;
     status: "blocked";
-    code: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued";
-    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued";
+    code: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued" | "source_supply_exhausted_at_rubric";
+    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch" | "new_campaign_required" | "actionable_supply_not_queued" | "source_supply_exhausted_at_rubric";
     note: string;
     targetPlan: unknown;
     exactTargetPlan: {} | null;

package/dist/tools/refill-sends.js

@@ -454,7 +454,7 @@ function buildRefillSendsCommand(input) {
         workflowAsset: {
             subskillName: "refill-sends-workflow",
             assetPath: "core/flow.v1.json",
-            expectedVersion: "v1.8",
+            expectedVersion: "v1.9",
         },
         yolo,
         executionMode,
@@ -502,7 +502,7 @@ function buildRefillSendsCommand(input) {
         },
         firstOperationalSteps: [
             'Load get_subskill_prompt({ subskillName: "refill-sends-workflow" }) before any product operation.',
-            'Load get_subskill_asset({ subskillName: "refill-sends-workflow", assetPath: "core/flow.v1.json" }) before any product operation; continue chunks until hasMore is false, parse JSON, and require exactly workflow:"refill-sends-workflow" and version:"v1.8". Report the verified version before D1. Any other or unverified version is workflow_version_mismatch and must stop before get_refill_target_plan or mutation.',
+            'Load get_subskill_asset({ subskillName: "refill-sends-workflow", assetPath: "core/flow.v1.json" }) before any product operation; continue chunks until hasMore is false, parse JSON, and require exactly workflow:"refill-sends-workflow" and version:"v1.9". Report the verified version before D1. Any other or unverified version is workflow_version_mismatch and must stop before get_refill_target_plan or mutation.',
             "A skill cannot create or invoke /goal by itself. If this refill is already running inside an active Codex goal, keep that goal open until every selected sender lane is horizon-filled by projected coverage (sent + scheduled), Christian explicitly stops/statuses the run, or a concrete non-scheduler blocker appears.",
             `Call get_refill_target_plan({ intent: "${intent}"${workspaceId ? `, workspaceId: "${workspaceId}"` : ""}${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""}${senderIds.length > 0 ? `, senderIds: ${JSON.stringify(senderIds)}` : ""}${senderNames.length > 0
                 ? `, senderNames: ${JSON.stringify(senderNames)}`
@@ -1395,6 +1395,20 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
     const prefilterBlockedTargets = blockedExactTargets.filter((blocked) => blocked.blocker !== "complete" &&
         blocked.blocker !== "capped_by_scheduler");
     const seenTargetKeys = new Set();
+    // fix(112ak): every refusal is recorded so a non-empty-census terminal can
+    // name the concrete per-lane blocker instead of reporting a bare dead end.
+    const coordinatorExcludedEdges = [];
+    const recordExcludedEdge = (candidate, blocked, stage) => {
+        coordinatorExcludedEdges.push({
+            campaignId: candidate.campaignId,
+            tableId: candidate.tableId,
+            senderIds: candidate.senderIds,
+            actionTypes: candidate.actionTypes,
+            actionKey: blocked?.actionKey ?? candidate.actionKey ?? null,
+            blocker: blocked?.blocker ?? null,
+            stage,
+        });
+    };
     const targetCandidates = actionTargets.filter((candidate) => {
         const key = workspaceExactTargetKey(candidate);
         if (seenTargetKeys.has(key))
@@ -1424,6 +1438,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
                     workspaceActionFamily(candidate.actionKey) === "run_scheduler_sweep") {
                     return false;
                 }
+                recordExcludedEdge(candidate, blocked, "prefilter");
                 return true;
             }));
     });
@@ -1484,6 +1499,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 ||
@@ -1491,7 +1512,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
                 blockedExactTargets.length > 0
                 ? "The fresh workspace queue did not expose another exact campaign/table edge after excluding the structurally exhausted target. No refill run or mutation was started."
                 : "The fresh workspace queue did not expose one exact campaign/table edge at globalActionQueue[0]. No refill run or mutation was started.") +
-                workspaceTypedBlockersNote(workspacePlan)),
+                workspaceTypedBlockersNote(workspacePlan), coordinatorExcludedEdges),
             workspacePlan,
         };
     }
@@ -1662,6 +1683,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
                 blocked.blocker === "loaded_awaiting_scheduler") {
                 return false;
             }
+            recordExcludedEdge(exactSelectedTarget, blocked, "post_rebind");
             return true;
         })) {
             continue;
@@ -1774,12 +1796,18 @@ 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
             ? `The fresh workspace plan still has ${workspaceCoverage.remainingReadyOrProjectedGap ?? "an unknown number of"} rows to prepare, but its executable exact-target candidates were all complete or scheduler-loaded. Refusing a false loaded_awaiting_scheduler terminal; the planner must expose the remaining actionable lane or a concrete blocker.`
             : `The fresh workspace queue remained incomplete, but all ${completedExactTargetCount} exposed exact targets were already complete and no active preparation or import work was pending. No identical refill fence was reopened.`) +
-            workspaceTypedBlockersNote(workspacePlan)),
+            workspaceTypedBlockersNote(workspacePlan), coordinatorExcludedEdges),
         workspacePlan,
     };
 }
@@ -1820,17 +1848,126 @@ function yoloCoverage(plan) {
         targetShapeRevision: stringValue(recordValue(plan)?.targetShapeRevision),
     };
 }
-// fix(112n): two different failure classes were collapsing into the one
-// generic workspace_exact_target_unavailable terminal. (1) Receipts prove
-// every existing lane's supply is spent and only a new campaign can serve the
-// remaining gap — but new_campaign_required was reachable ONLY via a
-// planner-proposed create_connection_campaign head, which Signal Discovery
-// workspaces never get (no automatic cold rung), so Dotwork o112 ended
-// generic instead of actionable. (2) Actionable row frontiers still exist but
-// no executable edge surfaced (Amplify o112: 23 approval candidates behind a
-// starved queue) — a planner exposure defect that must be loud, typed, and
-// retryable, never a quiet dead-end.
+function laneFrontierIsRubricTerminal(frontier) {
+    const diagnosis = recordValue(recordValue(frontier)?.failureDiagnosis);
+    if (!diagnosis)
+        return false;
+    if (diagnosis.retryable !== false)
+        return false;
+    if (stringValue(diagnosis.stage) !== "icp_or_rubric_rejection")
+        return false;
+    const status = stringValue(diagnosis.status);
+    return status === "zero_yield" || status === "low_yield";
+}
+// One frontier receipt describes one campaign table's lane, however many senders
+// share it. Fall back to sender identity only when the receipt did not name the
+// table it measured, so independent lanes still sum.
+function workspaceLaneFrontierKey(lane) {
+    return lane.campaignId && lane.tableId
+        ? `table:${lane.campaignId}:${lane.tableId}:${lane.actionType ?? ""}`
+        : `sender:${lane.senderId ?? ""}:${lane.actionType ?? ""}`;
+}
+function workspaceLaneFrontier(planRecord, receipt, frontier, stageCounts) {
+    const senderId = stringValue(planRecord?.senderId) ?? stringValue(receipt?.senderId);
+    const diagnosis = recordValue(frontier?.failureDiagnosis);
+    const evidence = recordValue(diagnosis?.evidence);
+    const rejectionCounts = recordValue(evidence?.counts);
+    return {
+        senderId,
+        senderIds: senderId ? [senderId] : [],
+        actionType: stringValue(planRecord?.actionType) ?? stringValue(receipt?.actionType),
+        campaignId: stringValue(receipt?.selectedCampaignId),
+        tableId: stringValue(receipt?.selectedTableId),
+        approval: Math.max(numberValue(receipt?.approvalCandidates) ?? 0, numberValue(stageCounts?.needsApproval) ?? 0),
+        generate: numberValue(stageCounts?.needsGenerate) ?? 0,
+        enrich: numberValue(stageCounts?.needsEnrich) ?? 0,
+        rubric: numberValue(stageCounts?.needsRubric) ?? 0,
+        hasMoreFrontierRows: frontier?.hasMoreFrontierRows === true,
+        checkedRows: numberValue(evidence?.checkedRows) ?? null,
+        rubricRejections: numberValue(rejectionCounts?.rubric_rejection) ?? null,
+    };
+}
+// Keep the deepest observation of a shared table lane so a terminal quotes the
+// scan that actually proved exhaustion, not the shallowest — but carry EVERY
+// sender the lane covers so no enrolled sender is left unexplained.
+function mergeNonConvertibleLane(lanes, laneKey, lane) {
+    const seen = lanes.get(laneKey);
+    if (!seen) {
+        lanes.set(laneKey, lane);
+        return;
+    }
+    const senderIds = [...new Set([...seen.senderIds, ...lane.senderIds])];
+    if ((lane.checkedRows ?? 0) > (seen.checkedRows ?? 0)) {
+        lanes.set(laneKey, { ...lane, senderIds });
+    }
+    else {
+        seen.senderIds = senderIds;
+    }
+}
+// Same table lane observed twice: keep the richest observation rather than
+// summing duplicates of one frontier.
+function mergeConvertibleLane(lanes, laneKey, lane) {
+    const existing = lanes.get(laneKey);
+    if (!existing) {
+        lanes.set(laneKey, lane);
+        return;
+    }
+    existing.approval = Math.max(existing.approval, lane.approval);
+    existing.generate = Math.max(existing.generate, lane.generate);
+    existing.enrich = Math.max(existing.enrich, lane.enrich);
+    existing.rubric = Math.max(existing.rubric, lane.rubric);
+    existing.hasMoreFrontierRows =
+        existing.hasMoreFrontierRows || lane.hasMoreFrontierRows;
+    existing.senderIds = [...new Set([...existing.senderIds, ...lane.senderIds])];
+}
 function workspaceActionableSupplyCensus(plan) {
+    const target = yoloTarget(plan);
+    const senderPlansRaw = target?.senderPlans;
+    const senderPlans = Array.isArray(senderPlansRaw) ? senderPlansRaw : [];
+    const convertibleByLane = new Map();
+    const nonConvertibleByLane = new Map();
+    for (const senderPlan of senderPlans) {
+        const planRecord = recordValue(senderPlan);
+        const receipt = recordValue(planRecord?.refillReceipt);
+        const frontier = recordValue(receipt?.existingRowFrontier);
+        const stageCounts = recordValue(frontier?.stageCounts);
+        const lane = workspaceLaneFrontier(planRecord, receipt, frontier, stageCounts);
+        const laneKey = workspaceLaneFrontierKey(lane);
+        if (laneFrontierIsRubricTerminal(frontier)) {
+            mergeNonConvertibleLane(nonConvertibleByLane, laneKey, lane);
+            continue;
+        }
+        mergeConvertibleLane(convertibleByLane, laneKey, lane);
+    }
+    const convertibleLanes = [...convertibleByLane.values()];
+    const nonConvertibleLanes = [...nonConvertibleByLane.values()];
+    const sum = (pick) => convertibleLanes.reduce((total, lane) => total + pick(lane), 0);
+    return {
+        approvalFrontier: sum((lane) => lane.approval),
+        generateFrontier: sum((lane) => lane.generate),
+        enrichFrontier: sum((lane) => lane.enrich),
+        rubricFrontier: sum((lane) => lane.rubric),
+        frontierHasMoreRows: convertibleLanes.some((lane) => lane.hasMoreFrontierRows),
+        senderPlanCount: senderPlans.length,
+        convertibleLanes,
+        nonConvertibleLanes,
+    };
+}
+// 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 : [];
@@ -1839,50 +1976,229 @@ function workspaceActionableSupplyCensus(plan) {
     let enrichFrontier = 0;
     let rubricFrontier = 0;
     let frontierHasMoreRows = false;
+    let gapSenderCount = 0;
+    let readySurplusGapSenders = 0;
+    let opaqueGapSenders = 0;
+    // fix(112ak, supply validation + de-duplication): the gap-bearing census is the
+    // authority behind the OWNER closing invariant, so it must count CONVERTIBLE
+    // rows ONCE. Two live inflations broke that on the 2026-07-29 sweep.
+    //
+    //   1. Double counting. Every sender enrolled on a shared campaign reports the
+    //      SAME table frontier: sellable's "681 enrich" was one 68-row frontier on
+    //      campaign cmrcd4x4a counted 10x (nine send_invite lanes plus one
+    //      send_inmail_closed lane on the same table). Sums are now keyed by the
+    //      campaign/table/lane the receipt was actually measured on; plans without
+    //      table identity keep per-sender identity so independent lanes still sum.
+    //
+    //   2. Non-convertible rows counted as supply. Clover's lanes reported
+    //      stageCounts of ~0 with hasMoreFrontierRows true while their own receipts
+    //      carried failureDiagnosis {stage:"icp_or_rubric_rejection",
+    //      retryable:false} over the 4,993 rubric-rejected rows behind the scan
+    //      window. hasMoreFrontierRows is a SCAN-WINDOW flag, not evidence that
+    //      anything behind it can convert. Such a lane no longer inflates the
+    //      census; it is carried as non-convertible (with every sender it covers)
+    //      so the terminal can name a truthful exhaustion instead of the defect
+    //      class. Its bucket still counts honestly below, so a rubric-terminal lane
+    //      with no ready rows reads opaque and never fakes a loaded terminal.
+    //
+    // Only the receipt's own non-retryable rubric verdict disqualifies a lane.
+    // Retryable diagnoses (sellable's dependency_blocked/retryable:true) and other
+    // stages (Dotwork's approval_blocked over a real needsApproval row) stay
+    // convertible, so the 112af-c/112ai masked-supply admission is untouched.
+    const convertibleByLane = new Map();
+    const nonConvertibleByLane = new Map();
     for (const senderPlan of senderPlans) {
-        const receipt = recordValue(recordValue(senderPlan)?.refillReceipt);
+        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);
-        approvalFrontier += Math.max(numberValue(receipt?.approvalCandidates) ?? 0, numberValue(stageCounts?.needsApproval) ?? 0);
-        generateFrontier += numberValue(stageCounts?.needsGenerate) ?? 0;
-        enrichFrontier += numberValue(stageCounts?.needsEnrich) ?? 0;
-        rubricFrontier += numberValue(stageCounts?.needsRubric) ?? 0;
-        if (frontier?.hasMoreFrontierRows === true)
+        const lane = workspaceLaneFrontier(rec, receipt, frontier, stageCounts);
+        const rubricTerminal = laneFrontierIsRubricTerminal(frontier);
+        const laneActionable = rubricTerminal
+            ? 0
+            : lane.approval + lane.generate + lane.enrich + lane.rubric;
+        const laneFrontierFlag = rubricTerminal ? false : lane.hasMoreFrontierRows;
+        const laneReady = numberValue(stageCounts?.ready) ?? 0;
+        const laneKey = workspaceLaneFrontierKey(lane);
+        if (rubricTerminal) {
+            mergeNonConvertibleLane(nonConvertibleByLane, laneKey, lane);
+        }
+        else {
+            mergeConvertibleLane(convertibleByLane, laneKey, lane);
+        }
+        if (laneFrontierFlag)
             frontierHasMoreRows = true;
+        if (laneActionable === 0 && !laneFrontierFlag) {
+            if (laneReady > 0)
+                readySurplusGapSenders += 1;
+            else
+                opaqueGapSenders += 1;
+        }
+    }
+    const convertibleLanes = [...convertibleByLane.values()];
+    const nonConvertibleLanes = [...nonConvertibleByLane.values()];
+    for (const lane of convertibleLanes) {
+        approvalFrontier += lane.approval;
+        generateFrontier += lane.generate;
+        enrichFrontier += lane.enrich;
+        rubricFrontier += lane.rubric;
     }
+    const actionableRows = approvalFrontier + generateFrontier + enrichFrontier + rubricFrontier;
     return {
         approvalFrontier,
         generateFrontier,
         enrichFrontier,
         rubricFrontier,
         frontierHasMoreRows,
-        senderPlanCount: senderPlans.length,
+        actionableRows,
+        gapSenderCount,
+        readySurplusGapSenders,
+        opaqueGapSenders,
+        convertibleLanes,
+        nonConvertibleLanes,
     };
 }
-function classifyWorkspaceUnavailableTerminal(plan, contextNote) {
-    const census = workspaceActionableSupplyCensus(plan);
-    const actionableRows = census.approvalFrontier +
-        census.generateFrontier +
-        census.enrichFrontier +
-        census.rubricFrontier;
+// 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;
+}
+// fix(112ak): a receipt-proven rubric-terminal frontier is a truthful source
+// exhaustion, so name it per lane instead of leaving the terminal generic.
+function workspaceRubricExhaustionNote(lanes) {
+    const parts = lanes.slice(0, 12).map((lane) => {
+        const scope = [
+            lane.campaignId ?? lane.senderId,
+            lane.actionType,
+            lane.senderIds.length > 0 ? `${lane.senderIds.length} sender(s)` : null,
+        ]
+            .filter((part) => Boolean(part))
+            .join(":");
+        const detail = [
+            typeof lane.checkedRows === "number"
+                ? `${lane.checkedRows} checked`
+                : null,
+            typeof lane.rubricRejections === "number"
+                ? `${lane.rubricRejections} rubric-rejected`
+                : null,
+        ]
+            .filter((part) => Boolean(part))
+            .join(", ");
+        return detail
+            ? `${scope || "lane"} (${detail})`
+            : scope || "unnamed sender lane";
+    });
+    if (parts.length === 0)
+        return "";
+    const overflow = lanes.length - parts.length;
+    return ` Per-lane exhaustion evidence: ${parts.join("; ")}${overflow > 0 ? `; +${overflow} more lanes` : ""}.`;
+}
+function coordinatorExcludedEdgesNote(edges) {
+    if (edges.length === 0)
+        return "";
+    const seen = new Set();
+    const parts = [];
+    for (const edge of edges) {
+        const key = `${edge.campaignId}:${edge.tableId}:${edge.actionTypes.join(",")}:${edge.actionKey ?? ""}:${edge.blocker ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const lane = edge.actionTypes.join("/") || "lane";
+        const senders = edge.senderIds.length > 0
+            ? `${edge.senderIds.length} sender(s)`
+            : "no named sender";
+        parts.push(`${edge.campaignId}:${lane} (${senders}) refused as ${edge.blocker ?? "already-decided"}${edge.actionKey ? ` on ${edge.actionKey}` : ""} at ${edge.stage}`);
+        if (parts.length >= 8)
+            break;
+    }
+    const overflow = edges.length - parts.length;
+    return ` Exact edges this run refused: ${parts.join("; ")}${overflow > 0 ? `; +${overflow} more` : ""}.`;
+}
+function classifyWorkspaceUnavailableTerminal(plan, contextNote, excludedEdges = []) {
+    // 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) {
+        // fix(112ak, OWNER closing invariant): a non-empty census may never end as
+        // a bare defect terminal — the coordinator must dispatch an edge or NAME
+        // the concrete per-lane blocker. Every edge this run refused is already
+        // recorded with its sender/lane/actionKey and the receipt that refused it,
+        // so surface that instead of claiming no edge was exposed. On the live
+        // 2026-07-29 sellable run the planner DID expose a prepare edge; the
+        // coordinator dropped it because the exact preflight re-issued an
+        // actionKey already proven exact_action_complete, then reported "no
+        // executable exact edge" — true only of the coordinator, not the planner.
+        const exclusionNote = coordinatorExcludedEdgesNote(excludedEdges);
         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. " +
+                `${exclusionNote
+                    ? "and every exact edge the planner exposed for it was refused by this run."
+                    : "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, " +
                 "report it as a planner-exposure defect. " +
-                contextNote,
+                contextNote +
+                exclusionNote,
+        };
+    }
+    // fix(112ak): the convertible census is empty and the only frontier left is
+    // receipt-proven rubric-terminal (Clover 2026-07-29: nine lanes, all
+    // non-retryable icp_or_rubric_rejection, 4,993 rubric-rejected rows behind
+    // the scan window). That is a truthful source exhaustion, not the
+    // planner-exposure defect class and not a generic dead end.
+    if (census.nonConvertibleLanes.length > 0) {
+        return {
+            code: "source_supply_exhausted_at_rubric",
+            note: `Every remaining existing-row frontier is receipt-proven exhausted at the ICP/rubric ` +
+                `stage across ${census.nonConvertibleLanes.length} campaign/table lane(s): the preparation ` +
+                "receipts report a non-retryable zero/low-yield rubric rejection, so the rows behind " +
+                "the scan window cannot convert into sends. No campaign was created and no source was " +
+                "expanded — widening the rubric or adding fresh source rows is the only remaining fill " +
+                "path; surface this to the user. " +
+                contextNote +
+                workspaceRubricExhaustionNote(census.nonConvertibleLanes) +
+                coordinatorExcludedEdgesNote(excludedEdges),
         };
     }
     const coverage = yoloCoverage(plan);
     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.733",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",

package/skills/refill-sends/SKILL.md

@@ -75,7 +75,7 @@ get_subskill_asset({ subskillName: "refill-sends-workflow", assetPath: "core/flo
 ```
 
 Continue chunks until `hasMore:false`; require
-exactly `workflow:"refill-sends-workflow"` and `version:"v1.8"`, then report
+exactly `workflow:"refill-sends-workflow"` and `version:"v1.9"`, then report
 that verified version before D1. Any other or unverified version is
 `workflow_version_mismatch`: stop before `get_refill_target_plan` or mutation.
 Route intent is immutable:
@@ -484,9 +484,13 @@ flowchart TD
 
 One scheduler-loaded exact lane is not a workspace terminal: skip it and
 continue other planner-ranked lanes. Do not keep polling after the coordinator
-returns workspace `loaded_awaiting_scheduler`, which is valid only when every
-remaining exact target is complete or scheduler-owned and workspace
-`remainingReadyOrProjectedGap` is zero. It is not permission for a host-owned
+returns workspace `loaded_awaiting_scheduler`. That terminal is admissible by
+either path: every remaining exact target is complete or scheduler-owned and
+workspace `remainingReadyOrProjectedGap` is zero, OR every gap-bearing sender
+lane is already prepared and its residue is `ready_to_schedule` surplus, so the
+remaining gap is scheduler/pacing-bound rather than unexposed supply — on that
+second path `remainingReadyOrProjectedGap` is not necessarily zero. Neither path
+means unexposed actionable supply, and neither is permission for a host-owned
 loop. The sole refill-ladder expansion
 that asks the user in `--yolo` is `new_campaign_required`; refill itself never
 creates that campaign. `new_campaign_required` is also the truthful terminal
@@ -497,7 +501,17 @@ remaining gap and ask the user; a future handler may automate the creation. A
 (approval/generate/enrich/rubric or unprocessed frontier rows) still exist but
 no executable exact edge surfaced: retry once with a fresh command, and if it
 repeats report it as a planner-exposure defect instead of treating the
-workspace as exhausted.
+workspace as exhausted. That census counts CONVERTIBLE rows only, de-duplicated
+per campaign/table lane — a frontier whose own preparation receipt carries a
+non-retryable `icp_or_rubric_rejection` diagnosis is proven unable to convert,
+so it never inflates the census. When such receipts are all that remain, the
+terminal is `source_supply_exhausted_at_rubric`: a truthful source exhaustion,
+not a defect and not retryable. Report the per-lane evidence from the note and
+tell the user that widening the rubric or adding fresh source rows is the only
+remaining fill path. Whenever a terminal reports a non-empty census, it also
+names every exact edge the run refused (`Exact edges this run refused: ...`) —
+surface those named blockers rather than describing the workspace as having no
+available work.
 
 ## Non-negotiable authority and proof
 

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

@@ -24,7 +24,7 @@ In `--yolo`, the coordinator may
 perform every fresh planner-ranked safe transition among existing campaigns,
 lanes, and source families. It may not create a new campaign.
 
-The host must load the entire asset and verify exactly `version:"v1.8"` before
+The host must load the entire asset and verify exactly `version:"v1.9"` before
 D1. It reports that verified version explicitly. A different or unverified
 version is `workflow_version_mismatch` and stops before planner or mutation.
 
@@ -32,7 +32,7 @@ version is `workflow_version_mismatch` and stops before planner or mutation.
 
 ```mermaid
 flowchart TD
-    A["Receive exact workspace, sender/action selectors, and date envelope"] --> ASSET["Verify complete flow.v1.json, workflow refill-sends-workflow, exact version v1.8"]
+    A["Receive exact workspace, sender/action selectors, and date envelope"] --> ASSET["Verify complete flow.v1.json, workflow refill-sends-workflow, exact version v1.9"]
     ASSET --> D1["Call get_refill_target_plan read-only with immutable route intent"]
     D1 --> RENDER["Render sender/campaign waterfall, coverage ledger, bounded side effects, forbidden actions, and stop condition"]
     RENDER --> D2["Call refill_sends with workspaceCoordinator true and displayed revision/action pins"]

package/skills/refill-sends-workflow/core/flow.v1.json

@@ -1,5 +1,5 @@
 {
-  "version": "v1.8",
+  "version": "v1.9",
   "workflow": "refill-sends-workflow",
   "principle": "The planner chooses one exact next action and refill_sends alone executes it. Every bounded action is receipted and followed by a canonical replan. Yolo may traverse every planner-ranked existing campaign, lane, and source family; only new campaign creation requires the user.",
   "requiredBootstrap": [
@@ -17,7 +17,7 @@
       "mustReadUntil": { "hasMore": false },
       "validation": {
         "workflow": "refill-sends-workflow",
-        "exactVersion": "v1.8",
+        "exactVersion": "v1.9",
         "requiredTopLevelKeys": [
           "states",
           "gateOrder",
@@ -430,11 +430,12 @@
   ],
   "terminalContract": {
     "complete": "Projected sent plus scheduler-owned scheduled coverage meets the canonical target.",
-    "loaded_awaiting_scheduler": "Every remaining exact target is complete or scheduler-owned and workspace remainingReadyOrProjectedGap is zero after the bounded scheduler wait; stop without a host poll loop.",
-    "blocked_retryable": "Return the exact blocker, receipt identity, and safe retry condition.",
+    "loaded_awaiting_scheduler": "Terminal, no continuation. Admissible by EITHER path: (a) every remaining exact target is complete or scheduler-owned and workspace remainingReadyOrProjectedGap is zero after the bounded scheduler wait; or (b) every gap-bearing sender lane is already prepared and its residue is ready_to_schedule surplus, so the remaining gap is scheduler/pacing-bound (ready rows awaiting placement) rather than unexposed supply — remainingReadyOrProjectedGap is NOT necessarily zero on this path. Neither path means unexposed actionable supply. Report the ready inventory and stop without a host poll loop.",
+    "blocked_retryable": "Retryable. Return the exact blocker, receipt identity, and safe retry condition. Specific blockers (for example no_forward_progress, provider outages, lease_lost) are reported UNDER this class, not as their own terminal classes.",
     "lanes_exhausted": "Internal handoff only when another pinned existing target remains; continue with next_exact_target.",
     "new_campaign_required": "Every existing campaign, lane, and source family is spent or infeasible; ask whether to create the proposed campaign. Refill never creates it.",
-    "actionable_supply_not_queued": "Actionable existing-row supply (approval/generate/enrich/rubric candidates or unprocessed frontier rows) remains but the fresh workspace queue exposed no executable exact edge. Retry with a fresh command once; if it repeats, report a planner-exposure defect with the census from the note."
+    "source_supply_exhausted_at_rubric": "Terminal and NOT retryable — do not re-run and do not treat it as blocked_retryable. Every remaining existing-row frontier is receipt-proven exhausted at the ICP/rubric stage: the preparation receipts carry a non-retryable icp_or_rubric_rejection diagnosis, so the rows behind the scan window cannot convert into sends no matter how many times the command runs. Distinct from new_campaign_required: the source rows exist, they simply cannot pass the current rubric. Report the per-lane evidence from the note (campaign/table lane, senders covered, rows checked, rows rubric-rejected) and tell the user the only remaining fill paths are widening the rubric or adding fresh source supply. Refill changes neither on its own.",
+    "actionable_supply_not_queued": "Actionable existing-row supply (approval/generate/enrich/rubric candidates or unprocessed frontier rows) remains but no executable exact edge was dispatched for it. The census counts CONVERTIBLE rows only, de-duplicated per campaign/table lane; frontiers proven non-convertible by their own receipts are reported as source_supply_exhausted_at_rubric instead. When the run refused edges the planner did expose, the note NAMES each one (campaign:lane, sender count, actionKey, and the refusal point) — report those named blockers, not just the census. Retry with a fresh command once; if it repeats, report a planner-exposure defect with the census and the named refused edges from the note."
   },
   "yoloMode": {
     "approvalSource": "explicit_yolo_flag",