@sellable/mcp 0.1.750 → 0.1.752

package/dist/refill-run-loop.js

@@ -2105,6 +2105,10 @@ const INHERITED_ATTEMPT_LEDGER_KEYS = [
     "drySourcePrepAttempts",
     "approvalCohortAttempts",
     "erroredCellRepairAttempts",
+    // fix(112aw): mirrors WORKSPACE_ATTEMPT_LEDGER_KEYS — census fingerprints of
+    // confirmed completeness-claim releases must survive the fence inherit or a
+    // continuation would re-authorize the same release and reopen the livelock.
+    "confirmedClaimReleaseAttempts",
 ];
 function inheritAttemptLedgers(base, incoming) {
     if (!incoming)

package/dist/tools/refill-sends.js

@@ -253,6 +253,10 @@ const WORKSPACE_ATTEMPT_LEDGER_KEYS = [
     "drySourcePrepAttempts",
     "approvalCohortAttempts",
     "erroredCellRepairAttempts",
+    // fix(112aw): census fingerprints at which a CONFIRMED completeness claim was
+    // released. Stripping this would re-authorize a confirmed release on every
+    // coordinator call and reopen the 112as livelock.
+    "confirmedClaimReleaseAttempts",
 ];
 // A fenced exact run records its bounded attempt receipts on ITS OWN
 // runState; the workspace loop replans from workspaceRunState. Without this
@@ -1499,12 +1503,17 @@ 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 waiveCompleteClaims = options.waiveCompleteClaims === true ||
+        options.waiveCompleteClaims === "include_confirmed";
+    const waiveConfirmedClaims = options.waiveCompleteClaims === "include_confirmed";
     const prefilterBlockedTargets = blockedExactTargets.filter((blocked) => blocked.blocker !== "complete" &&
         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"));
+        !(waiveCompleteClaims && blocked.blocker === "exact_action_complete") &&
+        // fix(112aw): a census-authorized release also waives CONFIRMED claims.
+        !(waiveConfirmedClaims &&
+            blocked.blocker === EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER));
     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.
@@ -1544,16 +1553,61 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             return null;
         if (coordinatorExcludedEdges.length === 0)
             return null;
-        if (!coordinatorExcludedEdges.every((edge) => edge.blocker === "exact_action_complete")) {
+        if (!coordinatorExcludedEdges.every((edge) => edge.blocker === EXACT_ACTION_COMPLETE_BLOCKER ||
+            edge.blocker === EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER)) {
             return null;
         }
         const census = workspaceGapBearingActionableSupply(workspacePlan);
         if (census.actionableRows <= 0 && !census.frontierHasMoreRows) {
             return null;
         }
-        const released = await selectWorkspaceExactTarget(input, workspacePlan, {
+        // fix(112aw): a CONFIRMED claim is a bounded batch receipt, not proof the
+        // edge is done — prepare/approve run in bounded cohorts, so a 50-send day
+        // legitimately needs the SAME edge many times (Dotwork td7-28 run 1:
+        // approve_messages + prepare_messages hardened to confirmed after two
+        // productive batches, then refused the remaining 40-send fill against a
+        // census of 6 approval candidates). Release confirmed claims too, but
+        // only when the gap-bearing census MOVED since the last confirmed
+        // release: a productive batch always changes the census (rows advance
+        // stages), while a dispatch that moved nothing leaves it identical and
+        // the claim stands. That keeps the 112as-b livelock kill, re-keyed on
+        // progress instead of receipt count.
+        const hasConfirmedClaims = coordinatorExcludedEdges.some((edge) => edge.blocker === EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER);
+        let releaseInput = input;
+        if (hasConfirmedClaims) {
+            const fingerprint = [
+                census.approvalFrontier,
+                census.generateFrontier,
+                census.enrichFrontier,
+                census.rubricFrontier,
+                census.frontierHasMoreRows ? 1 : 0,
+            ].join(":");
+            const priorReleases = Array.isArray(workspaceRunState?.confirmedClaimReleaseAttempts)
+                ? workspaceRunState.confirmedClaimReleaseAttempts
+                : [];
+            if (priorReleases.some((entry) => stringValue(recordValue(entry)?.fingerprint) === fingerprint)) {
+                return null;
+            }
+            releaseInput = {
+                ...input,
+                workspaceRunState: {
+                    ...(workspaceRunState ?? {
+                        version: 1,
+                        senderCursors: [],
+                        laneCooldowns: [],
+                        passRates: [],
+                        coordinatorBlockedExactTargets: [],
+                    }),
+                    confirmedClaimReleaseAttempts: [
+                        ...priorReleases.filter((entry) => Boolean(recordValue(entry))),
+                        { fingerprint, decidedAt: new Date().toISOString() },
+                    ],
+                },
+            };
+        }
+        const released = await selectWorkspaceExactTarget(releaseInput, workspacePlan, {
             ...options,
-            waiveCompleteClaims: true,
+            waiveCompleteClaims: hasConfirmedClaims ? "include_confirmed" : true,
             seedExcludedEdges: [...coordinatorExcludedEdges],
         });
         // The release may only ADD a dispatch. If it fails to bind an edge, fall
@@ -1846,6 +1900,11 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
                 blocked.blocker === "exact_action_complete") {
                 return false;
             }
+            // fix(112aw): mirror the confirmed-claim waiver after the exact rebind.
+            if (waiveConfirmedClaims &&
+                blocked.blocker === EXACT_ACTION_COMPLETE_CONFIRMED_BLOCKER) {
+                return false;
+            }
             recordExcludedEdge(exactSelectedTarget, blocked, "post_rebind");
             return true;
         })) {
@@ -2025,6 +2084,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.
@@ -2099,7 +2187,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;
         }
@@ -2185,7 +2274,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;

package/package.json

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