@sellable/mcp 0.1.748 → 0.1.750

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(),
             },
         ],
@@ -1470,12 +1499,18 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
     // opening is barred for those targets (in the selection loop below).
     const completeDeferredTargets = blockedExactTargets.filter((blocked) => blocked.blocker === "complete" ||
         blocked.blocker === "capped_by_scheduler");
+    const waiveCompleteClaims = options.waiveCompleteClaims === true;
     const prefilterBlockedTargets = blockedExactTargets.filter((blocked) => blocked.blocker !== "complete" &&
-        blocked.blocker !== "capped_by_scheduler");
+        blocked.blocker !== "capped_by_scheduler" &&
+        // fix(112as): on the bounded release pass, a self-issued
+        // exact_action_complete claim no longer bars its own edge.
+        !(waiveCompleteClaims && blocked.blocker === "exact_action_complete"));
     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 coordinatorExcludedEdges = [
+        ...(options.seedExcludedEdges ?? []),
+    ];
     const recordExcludedEdge = (candidate, blocked, stage) => {
         coordinatorExcludedEdges.push({
             campaignId: candidate.campaignId,
@@ -1487,6 +1522,46 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             stage,
         });
     };
+    // fix(112as): a self-issued `exact_action_complete` claim is a BOUNDED
+    // ATTEMPT, not a standing proof — the same principle as 112c.
+    //
+    // The claim is dropped at BOTH refusal points (prefilter and post_rebind),
+    // and 112ar only clears it when a prepare/supply action LANDS on that
+    // campaign. When every edge the planner exposed for the campaign is already
+    // held by such a claim, nothing can land, so nothing ever clears it: a closed
+    // loop that terminals `actionable_supply_not_queued` against visible supply
+    // (Dotwork 2026-07-30/31: 100 enrichment candidates, approve_messages
+    // refused at post_rebind on every run). 112ak made that terminal NAME the
+    // refusal, which is honest but does not fill the day.
+    //
+    // So: if the ONLY reason we have no selection is our own completeness
+    // claims, and the census still shows actionable supply, waive them and
+    // re-select ONCE. Bounded by waiveCompleteClaims so it can never livelock,
+    // and it reuses the SAME workspacePlan so no extra planner call is made and
+    // the census stays consistent with the decision.
+    const completeClaimReleaseRetry = async () => {
+        if (waiveCompleteClaims)
+            return null;
+        if (coordinatorExcludedEdges.length === 0)
+            return null;
+        if (!coordinatorExcludedEdges.every((edge) => edge.blocker === "exact_action_complete")) {
+            return null;
+        }
+        const census = workspaceGapBearingActionableSupply(workspacePlan);
+        if (census.actionableRows <= 0 && !census.frontierHasMoreRows) {
+            return null;
+        }
+        const released = await selectWorkspaceExactTarget(input, workspacePlan, {
+            ...options,
+            waiveCompleteClaims: true,
+            seedExcludedEdges: [...coordinatorExcludedEdges],
+        });
+        // The release may only ADD a dispatch. If it fails to bind an edge, fall
+        // back to this pass's terminal, which already NAMES the refused edges —
+        // 112ak's honesty guarantee must not be traded away for an optimistic
+        // retry that lands on a vaguer blocker.
+        return released.status === "selected" ? released : null;
+    };
     const targetCandidates = actionTargets.filter((candidate) => {
         const key = workspaceExactTargetKey(candidate);
         if (seenTargetKeys.has(key))
@@ -1583,6 +1658,9 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
         const readyLoadedSelection = readySurplusLoadedSelection(workspacePlan);
         if (readyLoadedSelection)
             return readyLoadedSelection;
+        const releasedEmptyCandidates = await completeClaimReleaseRetry();
+        if (releasedEmptyCandidates)
+            return releasedEmptyCandidates;
         return {
             status: "blocked",
             ...classifyWorkspaceUnavailableTerminal(workspacePlan, (excludedTargets.length > 0 ||
@@ -1761,6 +1839,13 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
                 blocked.blocker === "loaded_awaiting_scheduler") {
                 return false;
             }
+            // fix(112as): the release pass must waive here too. post_rebind
+            // re-matches AFTER the exact preflight re-issues the semantic
+            // actionKey, so waiving only at prefilter would leave the edge blocked.
+            if (waiveCompleteClaims &&
+                blocked.blocker === "exact_action_complete") {
+                return false;
+            }
             recordExcludedEdge(exactSelectedTarget, blocked, "post_rebind");
             return true;
         })) {
@@ -1880,6 +1965,9 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
     const readyLoadedSelection = readySurplusLoadedSelection(workspacePlan);
     if (readyLoadedSelection)
         return readyLoadedSelection;
+    const releasedFilteredCandidates = await completeClaimReleaseRetry();
+    if (releasedFilteredCandidates)
+        return releasedFilteredCandidates;
     return {
         status: "blocked",
         ...classifyWorkspaceUnavailableTerminal(workspacePlan, (workspaceCoverage.remainingReadyOrProjectedGap !== 0
@@ -3056,6 +3144,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.748",
+  "version": "0.1.750",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",