@sellable/mcp 0.1.738 → 0.1.739

package/dist/refill-run-loop.d.ts

@@ -172,6 +172,21 @@ type SchedulerRefusalDisposition = {
 };
 declare function classifySchedulerRefusal(reason: string | null): SchedulerRefusalDisposition;
 declare function schedulerSweepNoOpBlocker(ctx: LoopContext, reportInput: Record<string, unknown>): Record<string, unknown> | null;
+declare function coverageOnlySignature(plan: Record<string, unknown>): {
+    sent: number;
+    scheduled: number;
+    ready: number;
+    goal: number;
+};
+declare function nextCoverageStallState(ctx: LoopContext, plan: Record<string, unknown>): {
+    signature: {
+        sent: number;
+        scheduled: number;
+        ready: number;
+        goal: number;
+    };
+    repeatCount: number;
+};
 export declare function packetCoherenceFailure(plan: Record<string, unknown>): string | null;
 export declare function terminalProjection(value: {
     targetConfig?: unknown;
@@ -190,5 +205,8 @@ export declare const refillRunLoopInternals: {
     schedulerSweepNoOpBlocker: typeof schedulerSweepNoOpBlocker;
     dominantSchedulerRefusalReason: typeof dominantSchedulerRefusalReason;
     classifySchedulerRefusal: typeof classifySchedulerRefusal;
+    coverageOnlySignature: typeof coverageOnlySignature;
+    nextCoverageStallState: typeof nextCoverageStallState;
+    COVERAGE_STALL_LIMIT: number;
 };
 export {};

package/dist/refill-run-loop.js

@@ -1864,6 +1864,46 @@ function nextNoProgressState(ctx, plan, action) {
         repeatCount,
     };
 }
+// fix(112an, UNIVERSAL progress-or-settle): 112aj's bound keys on
+// noProgressSignature, which includes actionFingerprint (type:campaign:table:
+// sender:actionKey:effectId). A loop that re-plans a DIFFERENT action each
+// iteration therefore resets the counter and never trips it, no matter how many
+// iterations produce zero coverage movement. Both expensive livelocks we hit
+// had exactly that shape:
+//   - Dotwork s3: 136 refill_sends calls, 21 exact_action_complete, coverage
+//     frozen at {sent:0, scheduled:0, ready:20, goal:50} throughout.
+//   - sellable FINAL: 6 of 7 exact runs returned byte-identical coverage
+//     {goal:180, ready:5, scheduled:9, sent:0}, each under a distinct
+//     next_exact_target, so 112aj saw six "different" actions.
+// This is the coverage-only companion: it ignores WHICH action ran and asks
+// only whether the world moved. A command that cannot move sent/scheduled/ready
+// across COVERAGE_STALL_LIMIT consecutive iterations is burning wall-clock and
+// credits for nothing and must settle with an honest terminal naming the frozen
+// counters and the last action it attempted.
+//
+// Threshold is deliberately looser than 112aj's 3: distinct actions legitimately
+// run in sequence before coverage moves (prepare -> approve -> sweep), so a tight
+// cap would cut off real ladders. Six is above the longest legitimate
+// zero-movement prefix observed across the 8-workspace matrix (the healthy rows
+// settle in 0-20 calls; only true stalls exceed it).
+const COVERAGE_STALL_LIMIT = 6;
+function coverageOnlySignature(plan) {
+    const coverage = coverageSnapshot(plan);
+    return {
+        sent: coverage.sent,
+        scheduled: coverage.scheduled,
+        ready: coverage.ready,
+        goal: coverage.goal,
+    };
+}
+function nextCoverageStallState(ctx, plan) {
+    const next = coverageOnlySignature(plan);
+    const prior = recordValue(runStateProgress(ctx).coverageStall) ?? {};
+    const priorSignature = recordValue(prior.signature);
+    const same = priorSignature !== undefined && safeJson(priorSignature) === safeJson(next);
+    const repeatCount = same ? (numberValue(prior.repeatCount) ?? 1) + 1 : 1;
+    return { signature: next, repeatCount };
+}
 function sourceHandoffText(action) {
     const campaignId = actionCampaignId(action) ?? "campaign";
     const toolInput = actionToolInput(action);
@@ -2601,6 +2641,11 @@ async function gatePlan(input, deps, ctx) {
         fallbackSummary: line.fallbackSummary,
     }));
     const fingerprint = fingerprintFromPlan(plan);
+    // fix(112an): universal coverage-only bound. Evaluated BEFORE 112aj's
+    // action-scoped bound only for its counter update, but enforced AFTER it so
+    // the more specific typed terminals (broaden keyword handoff, etc.) keep
+    // precedence when they apply. See COVERAGE_STALL_LIMIT.
+    const coverageStall = nextCoverageStallState(ctx, plan);
     const noProgress = nextNoProgressState(ctx, plan, action);
     if (noProgress.repeatCount >= 3) {
         // fix(111y, CloverL): when the stuck rung is a broaden whose derived tier
@@ -2665,14 +2710,33 @@ async function gatePlan(input, deps, ctx) {
             blocker: "no_forward_progress",
             stuckRung: stringValue(action.evergreenRung) ?? stringValue(action.type),
             repeatedHeadAction: action,
-            progress: { noProgress },
+            progress: { noProgress, coverageStall },
             guidance: "The same refill rung repeated three times with no coverage, frontier, or lane movement.",
         });
     }
+    // fix(112an): universal bound — the world did not move for
+    // COVERAGE_STALL_LIMIT consecutive iterations, regardless of which action ran
+    // each time. Settle with an honest terminal naming the frozen counters rather
+    // than burning further wall-clock and credits on a command that cannot advance.
+    if (coverageStall.repeatCount >= COVERAGE_STALL_LIMIT) {
+        const frozen = coverageStall.signature;
+        return completeTerminal(input, deps, ctx, "blocked", {
+            blocker: "no_coverage_movement",
+            stuckRung: stringValue(action.evergreenRung) ?? stringValue(action.type),
+            repeatedHeadAction: action,
+            progress: { coverageStall },
+            coverage: frozen,
+            guidance: `Coverage did not move across ${COVERAGE_STALL_LIMIT} consecutive refill iterations ` +
+                `(sent ${frozen.sent}, scheduled ${frozen.scheduled}, ready ${frozen.ready}, ` +
+                `goal ${frozen.goal}); the actions differed each time, so this is a workspace-level ` +
+                "stall rather than one repeated rung. Settling instead of continuing to spend. " +
+                "Re-run after the underlying blocker changes; the last attempted action is reported above.",
+        });
+    }
     const nextRunState = mergeRunState(ctx.runState, {
         lastPlan: fingerprint,
         headAction: action,
-        progress: mergeProgress(ctx, { noProgress }),
+        progress: mergeProgress(ctx, { noProgress, coverageStall }),
     });
     const advanced = await deps.runClient.advanceRefillRunGateRemote({
         workspaceId: input.workspaceId,
@@ -4826,4 +4890,7 @@ export const refillRunLoopInternals = {
     schedulerSweepNoOpBlocker,
     dominantSchedulerRefusalReason,
     classifySchedulerRefusal,
+    coverageOnlySignature,
+    nextCoverageStallState,
+    COVERAGE_STALL_LIMIT,
 };

package/package.json

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

package/skills/research/config.json

@@ -1,9 +0,0 @@
-{
-  "parallelMode": "wide",
-  "agentCount": 6,
-  "maxToolCallsPerAgent": 2,
-  "senderMaxAgents": 2,
-  "senderMaxToolCallsPerAgent": 3,
-  "progressMode": true,
-  "debugMode": true
-}