@sellable/mcp 0.1.634 → 0.1.635

package/dist/refill-run-loop.js

@@ -480,7 +480,16 @@ function doneReasonFromPlan(plan) {
     const action = firstAction(plan);
     return (stringValue(action?.doneReason) ??
         stringValue(recordValue(plan.packet)?.doneReason) ??
-        stringValue(plan.doneReason));
+        stringValue(plan.doneReason) ??
+        (canonicalReportingCoverageComplete(plan) ? "complete" : null));
+}
+function canonicalReportingCoverageComplete(value) {
+    const reporting = reportingFrom(value);
+    const terminal = recordValue(reporting?.terminal);
+    return (reporting?.schemaVersion === "refill_reporting.v2" &&
+        terminal?.status === "complete" &&
+        terminal.complete === true &&
+        terminal.reason === "coverage_complete");
 }
 function selectedLaneAuthority(plan, action) {
     const senderId = actionSenderId(action);
@@ -538,8 +547,7 @@ function isSelectedSenderOwnedPostEngagersLane(plan, action) {
     const selections = arrayValue(evergreen.senderLaneSelections).filter(isRecord);
     const selection = selections.find((entry) => stringValue(entry.senderId) === senderId);
     const selectedLane = recordValue(selection?.selectedLane);
-    if (!selectedLane ||
-        stringValue(selectedLane.campaignId) !== campaignId) {
+    if (!selectedLane || stringValue(selectedLane.campaignId) !== campaignId) {
         return false;
     }
     const laneKey = stringValue(selectedLane.laneKey);
@@ -1988,6 +1996,13 @@ async function gatePlan(input, deps, ctx) {
             report: plan,
         };
     }
+    // Canonical reporting completion wins over a stale queue head. Check it
+    // before packet coherence so `terminal_with_action_queue` cannot turn a
+    // completed fenced run into a permanent blocker/continuation loop.
+    if (canonicalReportingCoverageComplete(plan)) {
+        ctx.plan = plan;
+        return completeTerminal(input, deps, ctx, "complete", { plan });
+    }
     const coherenceFailure = packetCoherenceFailure(plan);
     if (coherenceFailure) {
         await safeJournalAppend(ctx, deps, deps.journal.renderPlanSection({
@@ -3518,8 +3533,7 @@ async function gateVerify(input, deps, ctx, budgets) {
         // outer workspace coordinator can skip this target and preflight the next
         // ranked campaign behind a new fence. Trying to replan across campaigns
         // inside this fence would correctly fail target_config_mismatch.
-        if (exhaustionReason === "sender_owned_post_required" &&
-            ctx.targetConfig) {
+        if (exhaustionReason === "sender_owned_post_required" && ctx.targetConfig) {
             ctx.runState = nextRunState;
             return completeTerminal(input, deps, ctx, "lanes_exhausted", {
                 laneExhaustion: {
@@ -3758,7 +3772,25 @@ async function finalizeVerifyOrHeartbeat(input, deps, ctx, budgets) {
         if (verified)
             return verified;
         // gateVerify advanced the gate off g3_verify (typically to g1_plan); fall
-        // through and heartbeat at the clean, resumable re-entry point.
+        // through and heartbeat at the clean, resumable re-entry point. Before
+        // yielding, perform one read-only completion check: the verified primitive
+        // may have filled the final slots, and emitting an active continuation in
+        // that state was the Nick Bird coverage_complete loop.
+        if (ctx.gate === "g1_plan") {
+            try {
+                const fresh = await deps.readPlan(refillPlanReadInput(input, { ctx, journal: false }));
+                ctx.plan = fresh;
+                if (canonicalReportingCoverageComplete(fresh)) {
+                    return completeTerminal(input, deps, ctx, "complete", {
+                        plan: fresh,
+                    });
+                }
+            }
+            catch {
+                // The ordinary heartbeat remains the safe fallback when the optional
+                // terminal reread is temporarily unavailable.
+            }
+        }
     }
     return heartbeatAndContinue(input, deps, ctx);
 }

package/dist/tools/refill-sends.js

@@ -599,8 +599,17 @@ function evergreenExactTargetCandidates(workspacePlan, options) {
 }
 async function selectWorkspaceExactTarget(input, workspacePlanOverride, options = {}) {
     const workspaceInput = workspaceCoordinatorInput(input);
-    const workspacePlan = workspacePlanOverride ??
+    let workspacePlan = workspacePlanOverride ??
         (await getRefillTargetPlan(targetPlanInputFor(workspaceInput)));
+    // A workspace-wide inference read can briefly observe every enrolled sender
+    // as disconnected while the authoritative account status is converging. Do
+    // one fresh, read-only planner pass before turning that transient snapshot
+    // into a terminal blocker. A stable disconnection still blocks on the second
+    // receipt and no mutation is attempted.
+    if (workspaceConnectivityEmptyState(workspacePlan) &&
+        workspacePlanOverride === undefined) {
+        workspacePlan = await getRefillTargetPlan(targetPlanInputFor(workspaceInput));
+    }
     if (yoloPlanIsComplete(workspacePlan)) {
         return { status: "complete", workspacePlan };
     }
@@ -628,8 +637,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             preferredSenderId: options.preferredSenderId,
             actionTypes: input.actionTypes,
         }),
-    ]
-        .find((candidate) => Boolean(candidate) &&
+    ].find((candidate) => Boolean(candidate) &&
         !excludedTargets.some((excluded) => excluded.campaignId === candidate?.campaignId &&
             excluded.tableId === candidate?.tableId));
     if (!selectedTarget) {
@@ -714,7 +722,21 @@ function yoloCoverage(plan) {
 }
 function yoloPlanIsComplete(plan) {
     const coverage = yoloCoverage(plan);
-    return coverage.status === "complete" || coverage.remainingProjectedGap === 0;
+    return (coverage.status === "complete" ||
+        (coverage.status !== "blocked" &&
+            typeof coverage.grossTarget === "number" &&
+            coverage.grossTarget > 0 &&
+            coverage.remainingProjectedGap === 0));
+}
+function workspaceConnectivityEmptyState(plan) {
+    const target = yoloTarget(plan);
+    const emptyState = recordValue(target?.emptyState);
+    const blockerCodes = Array.isArray(emptyState?.blockerCodes)
+        ? normalizeStrings(emptyState.blockerCodes)
+        : [];
+    return (stringValue(recordValue(plan)?.status) === "blocked" &&
+        emptyState?.code === "no_connected_eligible_senders" &&
+        blockerCodes.includes("sender_disconnected"));
 }
 function yoloActionIdentity(action) {
     if (!action)

package/package.json

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