@sellable/mcp 0.1.742 → 0.1.744

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.
+    //
+    // 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.
     //
-    // `accepted`/`attached` are IN-FLIGHT; `ran`/`window_closed_noop` are
-    // TERMINAL and continue to the audit below. `backoff` and `failed` keep their
+    // `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,11 +2988,26 @@ 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,
+                // fix(112ao-1-revert): the identity-only probe REQUIRES the FIX 1
+                // server half (route isStatusReadScope). It shipped in 0.1.743 while
+                // the deployed route still demanded the full triple, so every probe
+                // 400'd invalid_scheduler_scope, api.ts threw, and the sweep primitive
+                // died before its action:"run" dispatch — no sweep could place in ANY
+                // workspace. Restored to the full scope until the server half is
+                // deployed. Re-remove these three ONLY after that deploy is live.
                 targetShapeRevision,
                 expectedTargetsHash,
                 maxPlacements,

package/package.json

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