@sellable/mcp 0.1.749 → 0.1.751

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

@@ -689,6 +689,13 @@ type WorkspaceCoordinatorWaitAction = {
     reason: string | null;
 };
 declare function clearCompleteDefersForCampaign(runState: Record<string, unknown> | undefined, campaignId: string | null, preserveActionKey?: string | null): Record<string, unknown> | undefined;
+declare function deferWorkspaceExactTarget(params: {
+    runState: unknown;
+    target: WorkspaceExactTarget;
+    blocker: string;
+}): {
+    coordinatorBlockedExactTargets: (Record<string, unknown> | null)[];
+};
 export declare function approvedPacketComparison(input: RefillSendsCommandInput, targetPlan: unknown): {
     changed: boolean;
     expectedTargetShapeRevision: string | null;
@@ -732,6 +739,9 @@ type RefillSenderSelectorMiss = {
 export declare const refillSendsDeferInternals: {
     clearCompleteDefersForCampaign: typeof clearCompleteDefersForCampaign;
     SUPPLY_INVALIDATED_DEFER_BLOCKERS: Set<string>;
+    deferWorkspaceExactTarget: typeof deferWorkspaceExactTarget;
+    EXACT_ACTION_COMPLETE_BLOCKER: string;
+    EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER: string;
 };
 export declare function executeRefillSendsCommand(input?: RefillSendsCommandInput): Promise<import("./workspace-context.js").WorkspaceRequiredResult | {
     ok: boolean;

package/dist/tools/refill-sends.js

@@ -933,10 +933,17 @@ const WORKSPACE_SUPPLY_ACTION_FAMILIES = new Set([
 // stale proof, not by absent supply.
 //
 // Same shape as 112c: a bounded ATTEMPT must not harden into a standing claim.
+const EXACT_ACTION_COMPLETE_BLOCKER = "exact_action_complete";
+// fix(112as-b): a completeness claim RE-CONFIRMED by a second identical receipt.
+// The 112as release deliberately never waives this, which is what stops the
+// release from looping forever across continuations.
+const EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER = "exact_action_complete_confirmed";
 const SUPPLY_INVALIDATED_DEFER_BLOCKERS = new Set([
     "complete",
     "capped_by_scheduler",
     "exact_action_complete",
+    // new supply genuinely invalidates even a re-confirmed claim
+    "exact_action_complete_confirmed",
 ]);
 function clearCompleteDefersForCampaign(runState, campaignId, 
 // fix(112ar): the action that JUST landed keeps its own defer. Clearing it
@@ -1204,20 +1211,42 @@ function deferWorkspaceExactTarget(params) {
     const existing = Array.isArray(current.coordinatorBlockedExactTargets)
         ? current.coordinatorBlockedExactTargets.map(recordValue).filter(Boolean)
         : [];
+    const matchesTarget = (entry) => {
+        const candidate = coordinatorBlockedExactTargets({
+            version: 1,
+            coordinatorBlockedExactTargets: [entry],
+        })[0];
+        return Boolean(candidate &&
+            coordinatorBlockedExactTargetMatches(candidate, params.target));
+    };
+    // fix(112as-b): 112as bounds its release with `waiveCompleteClaims`, which is
+    // per SELECTION CALL. Every next_exact_target continuation starts a fresh
+    // selection, so the same completed edge was released over and over and the
+    // coordinator ping-ponged between two already-complete edges without
+    // executing either (Dotwork: alternating prepare_messages:e5fc49c5 and
+    // approve_messages:4bf8c1e1). That traded the invariant breach for a
+    // livelock.
+    //
+    // Bound the release PER EDGE instead: the first exact_action_complete is a
+    // bounded attempt and stays releasable, but if the SAME edge comes back
+    // complete a second time, the claim is CONFIRMED by its own re-receipt and is
+    // never waived again. Self-limiting, and it needs no new ledger — the entry
+    // already survives continuations inside workspaceRunState.
+    const alreadyCompleteClaim = params.blocker === EXACT_ACTION_COMPLETE_BLOCKER &&
+        existing.some((entry) => matchesTarget(entry) &&
+            (stringValue(recordValue(entry)?.blocker) ===
+                EXACT_ACTION_COMPLETE_BLOCKER ||
+                stringValue(recordValue(entry)?.blocker) ===
+                    EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER));
     return {
         ...current,
         coordinatorBlockedExactTargets: [
-            ...existing.filter((entry) => {
-                const candidate = coordinatorBlockedExactTargets({
-                    version: 1,
-                    coordinatorBlockedExactTargets: [entry],
-                })[0];
-                return (!candidate ||
-                    !coordinatorBlockedExactTargetMatches(candidate, params.target));
-            }),
+            ...existing.filter((entry) => !matchesTarget(entry)),
             {
                 ...params.target,
-                blocker: params.blocker,
+                blocker: alreadyCompleteClaim
+                    ? EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER
+                    : params.blocker,
                 decidedAt: new Date().toISOString(),
             },
         ],
@@ -1996,6 +2025,35 @@ function laneFrontierIsRubricTerminal(frontier) {
     const status = stringValue(diagnosis.status);
     return status === "zero_yield" || status === "low_yield";
 }
+// fix(112au): a lane can be receipt-proven spent WITHOUT the classifier having
+// labelled its stage `icp_or_rubric_rejection`. Dotwork's receipts carry
+// `retryable: false`, `status: "zero_yield"`, `activeCellCount: 0` and
+// `stage: "mixed_or_unknown"` (dominantReason legacy_progress_zero_yield), so
+// the lane stayed "convertible", kept its rows in the actionable census, and
+// the run terminaled `actionable_supply_not_queued` against supply it could
+// never convert — an owner-invariant breach caused by a MISSING stage label,
+// not by real actionable work.
+//
+// The substantive proof of exhaustion is: the preparation receipt is
+// NON-RETRYABLE, it yielded nothing, and there is no work still in flight.
+// The stage label is a classifier detail on top of that.
+//
+// activeCellCount === 0 is load-bearing: a lane with cells still processing is
+// mid-flight, not spent, and must keep its rows in the census so the
+// active-prep-job wait path wins instead of a false exhaustion terminal.
+function laneFrontierIsReceiptProvenSpent(frontier) {
+    const frontierRecord = recordValue(frontier);
+    const diagnosis = recordValue(frontierRecord?.failureDiagnosis);
+    if (!diagnosis)
+        return false;
+    if (diagnosis.retryable !== false)
+        return false;
+    const status = stringValue(diagnosis.status);
+    if (status !== "zero_yield" && status !== "low_yield")
+        return false;
+    const activeCells = numberValue(frontierRecord?.activeCellCount);
+    return activeCells === 0;
+}
 // 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.
@@ -2070,7 +2128,8 @@ function workspaceActionableSupplyCensus(plan) {
         const stageCounts = recordValue(frontier?.stageCounts);
         const lane = workspaceLaneFrontier(planRecord, receipt, frontier, stageCounts);
         const laneKey = workspaceLaneFrontierKey(lane);
-        if (laneFrontierIsRubricTerminal(frontier)) {
+        if (laneFrontierIsRubricTerminal(frontier) ||
+            laneFrontierIsReceiptProvenSpent(frontier)) {
             mergeNonConvertibleLane(nonConvertibleByLane, laneKey, lane);
             continue;
         }
@@ -2156,7 +2215,11 @@ function workspaceGapBearingActionableSupply(plan) {
         const frontier = recordValue(receipt?.existingRowFrontier);
         const stageCounts = recordValue(frontier?.stageCounts);
         const lane = workspaceLaneFrontier(rec, receipt, frontier, stageCounts);
-        const rubricTerminal = laneFrontierIsRubricTerminal(frontier);
+        // fix(112au): both convertibility splits must agree. This one feeds the
+        // TERMINAL classifier, so a lane spent-by-receipt but unlabelled here would
+        // still drive actionable_supply_not_queued.
+        const rubricTerminal = laneFrontierIsRubricTerminal(frontier) ||
+            laneFrontierIsReceiptProvenSpent(frontier);
         const laneActionable = rubricTerminal
             ? 0
             : lane.approval + lane.generate + lane.enrich + lane.rubric;
@@ -3115,6 +3178,9 @@ async function resolveRefillSenderSelectors(params) {
 export const refillSendsDeferInternals = {
     clearCompleteDefersForCampaign,
     SUPPLY_INVALIDATED_DEFER_BLOCKERS,
+    deferWorkspaceExactTarget,
+    EXACT_ACTION_COMPLETE_BLOCKER,
+    EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER,
 };
 export async function executeRefillSendsCommand(input = {}) {
     const normalizedInput = normalizeRefillSendsInput(input);

package/package.json

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