@sellable/mcp 0.1.734 → 0.1.736

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

@@ -133,6 +133,40 @@ 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;
+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 +181,8 @@ 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;
+};
+export {};

package/dist/refill-run-loop.js

@@ -405,6 +405,72 @@ 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;
+}
+// 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,
+            }
+            : {}),
+        ...(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 +2271,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 +4799,11 @@ 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,
+};

package/dist/tools/refill-target-plan.js

@@ -1876,6 +1876,25 @@ export function sanitizeRefillTargetPlanResult(result) {
     const paidRefreshNeededSenderIdSet = paidRefreshNeededSenderIds(senderRefillPlans);
     const blockers = sanitizeBlockers(result.blockers, selectedKeys, paidRefreshNeededSenderIdSet);
     const request = isRecord(result.request) ? result.request : {};
+    // fix(112ak-s2): this is the CLIENT mirror of the server's dated-sweep gate,
+    // and it silently discarded the server's valid sweep. sanitizeTargetSchedulerSweep
+    // derives its expected senders/actions from this map and returns null when the
+    // map is empty, so a stricter rule here vetoes the server outright: Dotwork
+    // 2026-07-29 (five lanes, remainingProjectedGap 10, readyBuffer 4, rrpg 6) had
+    // the server emit a 20-placement sweep across all five senders, this loop
+    // marked zero lanes eligible, and every served plan came back with
+    // approve_messages at globalActionQueue[0] and no sweep at any rank. Because
+    // the coordinator consumes the sanitized plan, that blocked execution, not just
+    // display. 112ak-s relaxed the same predicate server-side
+    // (refill-target-plan.ts buildExactDateSchedulerSweepAction): a lane earns a
+    // sweep by HOLDING ready rows against an open dated slot, not by its ready
+    // buffer fully covering its gap. No target-date condition is needed to mirror
+    // the server's scoping — sanitizeTargetSchedulerSweep already refuses to run
+    // without an expectedTargetDate matching ^\d{4}-\d{2}-\d{2}$, so this path is
+    // explicit-date-only by construction. Deliberately the ONLY relaxed occurrence:
+    // the wait_for_scheduler append and the status derivation below both keep
+    // `remainingReadyOrProjectedGap === 0`, where full ready coverage is the
+    // correct and intended meaning.
     const sweepEligibleBySender = new Map();
     for (const plan of senderPlans) {
         const senderId = stringValue(plan.senderId);
@@ -1883,7 +1902,6 @@ export function sanitizeRefillTargetPlanResult(result) {
         if (senderId &&
             actionType &&
             numberValue(plan.remainingProjectedGap) > 0 &&
-            numberValue(plan.remainingReadyOrProjectedGap) === 0 &&
             numberValue(plan.readyBuffer) > 0) {
             const lanes = sweepEligibleBySender.get(senderId) ?? new Set();
             lanes.add(actionType);

package/package.json

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