@sellable/mcp 0.1.735 → 0.1.737

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

@@ -133,6 +133,45 @@ export type RefillV2LoopResult = {
     refillReporting?: Record<string, unknown>;
     runState?: Record<string, unknown>;
 };
+interface LoopContext {
+    workspaceId: string;
+    runId: string;
+    fence: number;
+    runHandle: RefillRunHandleV1;
+    targetConfig: RefillTargetConfigV1 | null;
+    gate: RefillLoopGate;
+    gateSeq: number;
+    runState: Record<string, unknown>;
+    journalPath: string | null;
+    plan: Record<string, unknown> | null;
+    headAction: Record<string, unknown> | null;
+    lastFingerprint: Fingerprint | null;
+    recoveryPoint: Record<string, unknown> | null;
+    gateCycles: number;
+    sleptMs: number;
+    blockedContinuations: unknown[];
+    lanesStarted: string[];
+    lanesTouched: string[];
+    invocationStartedAtMs: number;
+    agentKeywordsConsumed?: boolean;
+}
+interface Fingerprint {
+    planRevision: string | null;
+    stateRevision: string | null;
+    targetShapeRevision: string | null;
+    actionReadinessFingerprint: string | null;
+}
+declare function dominantSchedulerRefusalReason(receipt: Record<string, unknown> | null): {
+    source: string;
+    reason: string;
+    count: number;
+} | null;
+type SchedulerRefusalDisposition = {
+    retryable: boolean | null;
+    blockerClass: "transient_or_refreshable" | "time_bound_capacity" | "operator_action_required" | "unknown";
+};
+declare function classifySchedulerRefusal(reason: string | null): SchedulerRefusalDisposition;
+declare function schedulerSweepNoOpBlocker(ctx: LoopContext, reportInput: Record<string, unknown>): Record<string, unknown> | null;
 export declare function packetCoherenceFailure(plan: Record<string, unknown>): string | null;
 export declare function terminalProjection(value: {
     targetConfig?: unknown;
@@ -147,3 +186,9 @@ export declare function terminalProjection(value: {
     targetConfig?: RefillTargetConfigV1 | undefined;
 };
 export declare function runRefillV2Loop(input: RefillV2LoopInput, deps: RefillV2LoopDeps): Promise<RefillV2LoopResult>;
+export declare const refillRunLoopInternals: {
+    schedulerSweepNoOpBlocker: typeof schedulerSweepNoOpBlocker;
+    dominantSchedulerRefusalReason: typeof dominantSchedulerRefusalReason;
+    classifySchedulerRefusal: typeof classifySchedulerRefusal;
+};
+export {};

package/dist/refill-run-loop.js

@@ -405,6 +405,91 @@ function schedulerRunReceiptIsFreshZeroScheduled(schedulerRunReceipt) {
     return (effectiveStatus === "window_closed_noop" ||
         numberValue(receipt?.cellsScheduled) === 0);
 }
+// fix(112al): the receipt's own dominant refusal reason, preferred in the order
+// the scheduler applies its gates: prefilters drop ready cells before allocation
+// (stale/invalid paid-InMail credit facts land here), skips are hard gate
+// rejections of considered cells, defers are window/capacity/cooldown waits.
+function dominantSchedulerRefusalReason(receipt) {
+    const sources = [
+        ["prefilterReasons", receipt?.prefilterReasons],
+        ["skippedReasons", receipt?.skippedReasons],
+        ["deferredReasons", receipt?.deferredReasons],
+    ];
+    for (const [source, value] of sources) {
+        const counts = recordValue(value);
+        if (!counts)
+            continue;
+        let best = null;
+        for (const [reason, rawCount] of Object.entries(counts)) {
+            const count = numberValue(rawCount) ?? 0;
+            if (count <= 0)
+                continue;
+            if (!best || count > best.count)
+                best = { reason, count };
+        }
+        if (best)
+            return { source, reason: best.reason, count: best.count };
+    }
+    return null;
+}
+function classifySchedulerRefusal(reason) {
+    if (!reason)
+        return { retryable: null, blockerClass: "unknown" };
+    // Infrastructure or freshness failures: the underlying facts can be re-read
+    // and the same sweep can then succeed without anyone changing configuration.
+    if (/(pool|timeout|timed[_ -]?out|connection|transient|unavailable|receipt[_ -]?invalid|stale|refresh)/i.test(reason)) {
+        return { retryable: true, blockerClass: "transient_or_refreshable" };
+    }
+    // Time-bound capacity: nothing is broken, the slot simply is not open yet.
+    if (/(window|capacity|daily[_ -]?limit|cooldown|rate[_ -]?limit)/i.test(reason)) {
+        return { retryable: true, blockerClass: "time_bound_capacity" };
+    }
+    // Standing gates: re-running cannot clear these; a human must act.
+    if (/(billing|credit[_ -]?threshold|disconnected|sender[_ -]?mismatch|not[_ -]?scheduler[_ -]?eligible|suspended|unauthor)/i.test(reason)) {
+        return { retryable: false, blockerClass: "operator_action_required" };
+    }
+    return { retryable: null, blockerClass: "unknown" };
+}
+// fix(112al): a sweep whose own receipt proves it placed zero while ready
+// inventory existed. Gated on the executed action actually being a scheduler
+// sweep and on a FRESH terminal receipt (ran / window_closed_noop), so an
+// attached/backoff envelope with no outcome of its own never manufactures a
+// blocker. readyCellsFound > 0 is required: a sweep that found no ready supply
+// placed zero honestly and still completes.
+function schedulerSweepNoOpBlocker(ctx, reportInput) {
+    const completedType = stringValue(reportInput.completedActionType) ??
+        stringValue(reportInput.nextActionType) ??
+        stringValue(recordValue(ctx.runState.lastExecutedAction)?.type);
+    if (completedType !== "run_scheduler_sweep")
+        return null;
+    const envelope = recordValue(runStateProgress(ctx).schedulerRunReceipt) ?? null;
+    if (!schedulerRunReceiptIsFreshZeroScheduled(envelope))
+        return null;
+    const receipt = recordValue(envelope?.receipt) ?? envelope;
+    const readyCellsFound = numberValue(receipt?.readyCellsFound) ?? 0;
+    if (readyCellsFound <= 0)
+        return null;
+    const dominant = dominantSchedulerRefusalReason(receipt);
+    return {
+        readyCellsFound,
+        cellsScheduled: numberValue(receipt?.cellsScheduled) ?? 0,
+        cellsConsidered: numberValue(receipt?.cellsConsidered) ?? 0,
+        ...(dominant
+            ? {
+                dominantReason: dominant.reason,
+                dominantReasonSource: dominant.source,
+                dominantReasonCount: dominant.count,
+                ...classifySchedulerRefusal(dominant.reason),
+            }
+            : classifySchedulerRefusal(null)),
+        ...(stringValue(receipt?.nextAction)
+            ? { recommendedAction: stringValue(receipt?.nextAction) }
+            : {}),
+        guidance: "The scheduler sweep executed and placed zero cells while ready inventory was present. " +
+            "Report the named reason above rather than re-running the identical sweep; re-running " +
+            "cannot place these rows until that gate clears.",
+    };
+}
 // The settled nested receipt of a scheduler status read or a persisted
 // scheduler-run envelope: a receipt whose status is a terminal run outcome
 // (ran/window_closed_noop/failed). A status read nests it under `.receipt`; a
@@ -2205,7 +2290,31 @@ async function gateBootstrap(input, deps, ctx) {
     return null;
 }
 async function completeTerminal(input, deps, ctx, doneReasonInput, reportInput = {}) {
-    const doneReason = normalizeDoneReason(doneReasonInput);
+    // fix(112al, intent-vs-effect): a scheduler sweep that placed NOTHING while
+    // ready inventory existed must never report exact_action_complete. Dotwork
+    // 2026-07-29 ran 68 consecutive refill_sends calls in which every executed
+    // sweep returned exact_action_complete with cellsScheduled 0 against 20 ready
+    // rows; the coordinator advanced next_exact_target and re-issued, and the
+    // concrete blocker — paid_inmail_credit_receipt_invalid, present 460 times in
+    // that run's own receipts — stayed invisible for the entire hour. The receipt
+    // already carried the answer; nothing read it. Convert the terminal to the
+    // documented blocked_retryable class and NAME the dominant receipt reason so
+    // the next run reports the blocker instead of re-running the same no-op. The
+    // scheduler action family is already deferred for the command by
+    // coordinatorDeferredBlocker, so this only changes truthfulness, not routing.
+    const sweepNoOp = normalizeDoneReason(doneReasonInput) === "exact_action_complete"
+        ? schedulerSweepNoOpBlocker(ctx, reportInput)
+        : null;
+    const doneReason = sweepNoOp
+        ? "blocked"
+        : normalizeDoneReason(doneReasonInput);
+    if (sweepNoOp) {
+        reportInput = {
+            ...reportInput,
+            blocker: "scheduler_placed_zero_with_ready_supply",
+            schedulerBlocker: sweepNoOp,
+        };
+    }
     // A lanes-exhausted terminal can still hold staged ready inventory whose
     // window days were never swept: the JIT walk only runs on the
     // scheduler-wait path, and the exhausted path went straight to terminal
@@ -4709,3 +4818,12 @@ export async function runRefillV2Loop(input, deps) {
         return classifyCaughtError(error, ctx);
     }
 }
+// fix(112al): exported for the intent-vs-effect pins. The wiring into
+// completeTerminal is covered by the existing run-loop suites staying green;
+// these expose the receipt-reading decision itself so each branch of the
+// contract is pinned directly against real receipt shapes.
+export const refillRunLoopInternals = {
+    schedulerSweepNoOpBlocker,
+    dominantSchedulerRefusalReason,
+    classifySchedulerRefusal,
+};

package/package.json

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