@sellable/mcp 0.1.741 → 0.1.743

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

@@ -176,14 +176,12 @@ 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;
 };

package/dist/refill-run-loop.js

@@ -1889,11 +1889,17 @@ function nextNoProgressState(ctx, plan, action) {
 const COVERAGE_STALL_LIMIT = 6;
 function coverageOnlySignature(plan) {
     const coverage = coverageSnapshot(plan);
+    // fix(112an-b): PROGRESS counters only — deliberately NOT `goal`.
+    // Live Dotwork on 0.1.740 ran 28 exact runs with sent/scheduled/ready frozen at
+    // 0/0/20 while `goal` alternated 50 <-> 40 as the planner rescoped its sender
+    // set. Including goal made the signature change every iteration, reset the
+    // streak, and the bound never reached COVERAGE_STALL_LIMIT — 61 calls and
+    // still going. goal is a TARGET, not progress: if sent/scheduled/ready are
+    // frozen the command is stalled no matter what the target says.
     return {
         sent: coverage.sent,
         scheduled: coverage.scheduled,
         ready: coverage.ready,
-        goal: coverage.goal,
     };
 }
 function nextCoverageStallState(ctx, plan) {
@@ -2727,8 +2733,8 @@ async function gatePlan(input, deps, ctx) {
             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 ` +
+                `(sent ${frozen.sent}, scheduled ${frozen.scheduled}, ready ${frozen.ready}); ` +
+                "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.",
         });

package/dist/tools/refill-executors.d.ts

@@ -214,7 +214,7 @@ export type SchedulerChangedCounts = {
     }>;
 };
 export declare function normalizeSchedulerChangedCounts(value: unknown): SchedulerChangedCounts | null;
-export declare function schedulerEnvelopeIsTerminal(schedulerStatus: string): boolean;
+export declare function schedulerEnvelopeIsTerminal(schedulerStatus: string, receipt?: Record<string, unknown> | null): boolean;
 export declare function normalizeSchedulerPrimitiveResult(value: unknown, expected?: {
     expectedTargets: SchedulerExpectedTargetInput[];
     expectedTargetsHash: string;
@@ -223,7 +223,7 @@ export declare function normalizeSchedulerPrimitiveResult(value: unknown, expect
     retryAfterMs: number;
     changedCounts: null;
     auditComplete: false;
-    replayedReceipt?: Record<string, unknown> | undefined;
+    unsettledReceipt?: Record<string, unknown> | undefined;
     status: "matching_scheduler_active";
     schedulerStatus: string;
     terminal: false;

package/dist/tools/refill-executors.js

@@ -274,50 +274,71 @@ function completeExpectedTargetSummary(value, expectedTargets, maxPlacements) {
             JSON.stringify(accounted) === JSON.stringify(target?.senderIds));
     });
 }
-// fix(112ao-2): the scheduler's in-flight envelope statuses. A response with
-// one of these describes a job that is still running — it never describes an
-// outcome of this dispatch, no matter what it carries alongside.
-const SCHEDULER_IN_FLIGHT_ENVELOPE_STATUSES = new Set(["accepted", "attached"]);
-// The envelope statuses that report a real outcome for this dispatch and are
-// therefore eligible for the receipt audit below.
+// fix(112ao-2): the scheduler's ATTACHING envelope statuses. These describe a
+// dispatch that joined an existing run rather than producing its own outcome.
+// They are terminal ONLY when the attach actually yielded a terminal receipt.
+const SCHEDULER_ATTACHING_ENVELOPE_STATUSES = new Set(["accepted", "attached"]);
+// The envelope statuses that report an outcome of this dispatch directly.
 const SCHEDULER_TERMINAL_ENVELOPE_STATUSES = new Set([
     "ran",
     "window_closed_noop",
 ]);
-export function schedulerEnvelopeIsTerminal(schedulerStatus) {
-    return SCHEDULER_TERMINAL_ENVELOPE_STATUSES.has(schedulerStatus);
+// The only receipt statuses that constitute a settled outcome. A receipt
+// without one of these is not evidence that anything finished.
+const SCHEDULER_TERMINAL_RECEIPT_STATUSES = new Set([
+    "ran",
+    "window_closed_noop",
+    "failed",
+]);
+function hasTerminalSchedulerReceipt(receipt) {
+    const status = receipt ? stringValue(receipt.status) : null;
+    return Boolean(status && SCHEDULER_TERMINAL_RECEIPT_STATUSES.has(status));
+}
+export function schedulerEnvelopeIsTerminal(schedulerStatus, receipt = null) {
+    if (SCHEDULER_TERMINAL_ENVELOPE_STATUSES.has(schedulerStatus))
+        return true;
+    return (SCHEDULER_ATTACHING_ENVELOPE_STATUSES.has(schedulerStatus) &&
+        hasTerminalSchedulerReceipt(receipt));
 }
 export function normalizeSchedulerPrimitiveResult(value, expected) {
     const response = recordValue(value);
     const receipt = recordValue(response?.receipt);
     const schedulerStatus = stringValue(response?.status) ?? stringValue(receipt?.status) ?? "unknown";
     const errorCode = stringValue(recordValue(response?.error)?.code);
-    // fix(112ao-2): whether this dispatch finished is a total function of the
-    // ENVELOPE status, decided here before any receipt is read. The previous
-    // guard was `!receipt && (accepted || attached)`, which made completion
-    // depend on whether a field happened to be present: the scheduler may attach
-    // an in-flight response to an already-running job and replay THAT job's
-    // receipt, so an `attached` envelope arrived carrying complete, v3-auditable
-    // counters from a prior run. It skipped this branch, passed the audit on
-    // that stale evidence, and returned auditComplete: true — the coordinator
-    // read a finished sweep and redispatched the run it should have awaited
-    // (Dotwork 2026-07-29: 21 exact runs, coverage frozen at sent:0/scheduled:0).
+    // fix(112ao-2): whether this dispatch finished is decided explicitly from the
+    // envelope status plus the RECEIPT'S OWN STATUS — never from the bare
+    // presence of a receipt field.
     //
-    // `accepted`/`attached` are IN-FLIGHT; `ran`/`window_closed_noop` are
-    // TERMINAL and continue to the audit below. `backoff` and `failed` keep their
+    // The previous guard was `!receipt && (accepted || attached)`. Truthiness is
+    // the wrong test: an attach that carries a receipt with no terminal status is
+    // not evidence that anything settled, yet it skipped this branch, ran the v3
+    // audit on that non-evidence, and could return auditComplete: true — a
+    // completion claim for a run still in flight, which the coordinator then
+    // treats as done rather than awaiting (Dotwork 2026-07-29: 21 exact runs,
+    // coverage frozen at sent:0/scheduled:0).
+    //
+    // The attach is NOT always in flight, and this deliberately does not treat it
+    // so: scheduler-run.ts:466-483 only returns a receipt from
+    // waitForSchedulerRunReceipt when it is scope-matched to THIS request, so an
+    // attach carrying a terminal receipt is a legitimate idempotent completion of
+    // this exact operation and must keep its counters. Discarding it would report
+    // zero placements for a sweep that really placed cells.
+    //
+    // `ran`/`window_closed_noop` remain terminal. `backoff`/`failed` keep their
     // existing handling — the run loop already unwraps a backoff envelope's
     // replayed receipt deliberately (schedulerRunReceiptIsFreshZeroScheduled).
-    if (SCHEDULER_IN_FLIGHT_ENVELOPE_STATUSES.has(schedulerStatus)) {
+    if (SCHEDULER_ATTACHING_ENVELOPE_STATUSES.has(schedulerStatus) &&
+        !hasTerminalSchedulerReceipt(receipt)) {
         return {
             status: "matching_scheduler_active",
             schedulerStatus,
             terminal: false,
             disposition: "bounded_reread_wait",
             receipt: null,
-            // A prior run's counters are never this dispatch's effect. Surfaced
-            // under a distinct name so it can be read for diagnostics but can never
-            // be mistaken for a fresh outcome.
-            ...(receipt ? { replayedReceipt: receipt } : {}),
+            // A non-terminal receipt is not this dispatch's effect. Surfaced under a
+            // distinct name so it stays readable for diagnostics but can never be
+            // mistaken for a settled outcome.
+            ...(receipt ? { unsettledReceipt: receipt } : {}),
             retryAfterMs: numberValue(response?.retryAfterMs) ?? 30_000,
             changedCounts: null,
             auditComplete: false,
@@ -363,7 +384,7 @@ export function normalizeSchedulerPrimitiveResult(value, expected) {
         status: schedulerStatus,
         // fix(112ao-2): the completion decision, carried explicitly instead of
         // leaving each consumer to re-infer it from the status string.
-        terminal: schedulerEnvelopeIsTerminal(schedulerStatus),
+        terminal: schedulerEnvelopeIsTerminal(schedulerStatus, receipt),
         receipt: response?.receipt ?? null,
         retryAfterMs: numberValue(response?.retryAfterMs),
         changedCounts,
@@ -2967,14 +2988,19 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                     refusalReason: "run_scheduler_sweep action is missing exact workspace/date/revision scope or complete receipt requirements",
                 };
             }
+            // fix(112ao-1): poll by RUN IDENTITY. requestKey is already unique per
+            // sweep, so requestKey + targetDate names this exact dispatch. Sending
+            // targetShapeRevision/expectedTargetsHash/maxPlacements here made the
+            // probe assert that the PLANNER's revision had not moved — but it is
+            // state-fresh by design (112q D2), so it always had, scopeMatches came
+            // back false, and every wait branch below fell through to the
+            // action:"run" redispatch at the end of this block. The dispatch below
+            // still carries the full write scope.
             const statusResult = recordValue(await runSchedulerSweep({
                 workspaceId,
                 action: "status",
                 targetDate,
                 requestKey,
-                targetShapeRevision,
-                expectedTargetsHash,
-                maxPlacements,
             }));
             const statusErrorCode = stringValue(recordValue(statusResult?.lastError)?.code);
             if (statusResult?.scopeMatches === true &&

package/package.json

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