@sellable/mcp 0.1.729 → 0.1.731

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

@@ -3232,6 +3232,123 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     workspaceId: string | null;
     workspaceResolution: string;
     intent: RefillSendsIntent;
+} | {
+    ok: boolean;
+    status: string;
+    blocker: string;
+    note: string;
+    coordinator: {
+        scope: "workspace";
+        status: "blocked";
+        backgroundJob?: undefined;
+        workspaceTargetPlan?: undefined;
+        selectedTarget?: undefined;
+        waitAction?: undefined;
+        exactTargetPlan?: undefined;
+        note?: undefined;
+        completedTarget?: undefined;
+        exactRunResult?: undefined;
+        handBack?: undefined;
+    };
+    continuation: {
+        required: boolean;
+        userActionRequired: boolean;
+        renderBeforeInvoke?: undefined;
+        kind?: undefined;
+        tool?: undefined;
+        arguments?: undefined;
+        owner?: undefined;
+        retryAfterMs?: undefined;
+        stopCondition?: undefined;
+    };
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+    fillWindow: {
+        mode: string;
+        targetDate: string;
+        description: string;
+        untilDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        untilDate: string;
+        description: string;
+        targetDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        horizonSendDays: number | null;
+        horizonHours: number | null;
+        description: string;
+        targetDate?: undefined;
+        untilDate?: undefined;
+    };
+    approvalMode: RefillSendsApprovalMode;
+    campaignId: string | null;
+    tableId: string | null;
+    targetConfig: RefillTargetConfigV1 | null;
+    runHandle: RefillRunHandleV1 | null;
+    reportingContext: RefillReportingContextV2 | null;
+    messageTemplateRevision: MessageTemplateRevisionV1 | null;
+    senderScope: string;
+    senderSelectors: {
+        senders: string[];
+        senderIds: string[];
+        senderNames: string[];
+    };
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    hostExamples: {
+        claude: string[];
+        codex: string[];
+        mcpTool: {
+            name: string;
+            arguments: {
+                workspaceRunState?: Record<string, unknown> | undefined;
+                workspaceCoordinator?: boolean | undefined;
+                messageTemplateRevision?: MessageTemplateRevisionV1 | undefined;
+                reportingContext?: RefillReportingContextV2 | undefined;
+                targetConfig?: RefillTargetConfigV1 | undefined;
+                runHandle?: RefillRunHandleV1 | undefined;
+                fence?: number | undefined;
+                runId?: string | undefined;
+                expectedActionKey?: string | undefined;
+                expectedTargetShapeRevision?: string | undefined;
+                targetDate: string | null;
+                untilDate: string | null;
+                horizonSendDays: number | null;
+                campaignId: string | undefined;
+                tableId: string | undefined;
+                intent: RefillSendsIntent;
+                approvalMode: RefillSendsApprovalMode;
+                workspaceId: string | null;
+                actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+                yolo: boolean;
+                senders: string[];
+                senderIds: string[];
+                senderNames: string[];
+            };
+        };
+    };
+    actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+    command: string;
+    tool: string;
+    promptName: string;
+    workflowPromptName: string;
+    workflowAsset: {
+        subskillName: string;
+        assetPath: string;
+        expectedVersion: string;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
 } | {
     targetPlan: unknown;
     orchestration: {
@@ -8397,6 +8514,273 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     workspaceId: string | null;
     workspaceResolution: string;
     intent: RefillSendsIntent;
+} | {
+    status: "in_progress";
+    note: string;
+    targetPlan: unknown;
+    exactTargetPlan: {} | null;
+    orchestration: {
+        mode: string;
+        scope: string;
+        phase: string;
+        checkpointedFields?: undefined;
+        transportBudgetMs?: undefined;
+    };
+    coordinator: {
+        scope: string;
+        status: string;
+        completedTarget: WorkspaceExactTarget;
+        selectedTarget: WorkspaceExactTarget;
+        workspaceTargetPlan: unknown;
+        exactRunResult: {
+            status: "blocked";
+            blocker: string;
+            guidance: string;
+            conflicts: string[];
+            runId: string | undefined;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+        } | {
+            readOnly: boolean;
+            mode: string;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            blocker: string;
+            workspaceId: string;
+            guidance: string;
+            warnings: string[];
+            journalPath: string | null;
+            text: string;
+            workspaceResolution: string;
+            status?: undefined;
+            conflicts?: undefined;
+            runId?: undefined;
+        } | {
+            readOnly: boolean;
+            mode: string;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            warnings: any[];
+            journalPath: string | null;
+            text: string;
+            workspaceId: string;
+            workspaceResolution: string;
+            blocker?: undefined;
+            guidance?: undefined;
+            status?: undefined;
+            conflicts?: undefined;
+            runId?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "dry_run";
+            plan: Record<string, unknown>;
+            blocker?: undefined;
+            guidance?: undefined;
+            conflicts?: undefined;
+            runId?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "in_progress";
+            runId: string;
+            fence: number;
+            gate: import("../refill-run-loop.js").RefillLoopGate;
+            guidance: string;
+            journalPath?: string | null;
+            targetConfig?: RefillTargetConfigV1;
+            runHandle?: RefillRunHandleV1;
+            refillReporting?: Record<string, unknown>;
+            blocker?: undefined;
+            conflicts?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "blocked";
+            blocker: string;
+            runId?: string;
+            fence?: number;
+            gate?: import("../refill-run-loop.js").RefillLoopGate;
+            guidance: string;
+            holderRunId?: string;
+            report?: Record<string, unknown>;
+            journalPath?: string | null;
+            targetConfig?: RefillTargetConfigV1;
+            runHandle?: RefillRunHandleV1;
+            refillReporting?: Record<string, unknown>;
+            conflicts?: undefined;
+        } | {
+            runSnapshot: unknown;
+            readOnly: boolean;
+            forbiddenActions: string[];
+            boundedAuthority: string;
+            status: "terminal";
+            doneReason: string;
+            report: Record<string, unknown>;
+            runId: string;
+            guidance?: string;
+            journalPath?: string | null;
+            targetConfig?: RefillTargetConfigV1;
+            runHandle?: RefillRunHandleV1;
+            refillReporting?: Record<string, unknown>;
+            runState?: Record<string, unknown>;
+            blocker?: undefined;
+            conflicts?: undefined;
+        };
+        backgroundJob: {
+            jobId: string;
+            status?: undefined;
+            activityState?: undefined;
+            checkedRows?: undefined;
+            preparedMessages?: undefined;
+            activeCellCount?: undefined;
+        };
+        waitAction?: undefined;
+        exactTargetPlan?: undefined;
+        note?: undefined;
+        handBack?: undefined;
+    };
+    continuation: {
+        required: boolean;
+        kind: string;
+        owner: string;
+        userActionRequired: boolean;
+        tool: string;
+        retryAfterMs: number;
+        arguments: {
+            workspaceRunState?: Record<string, unknown> | {
+                coordinatorBlockedExactTargets: (Record<string, unknown> | null)[];
+            } | undefined;
+            yolo: boolean;
+            executionMode: "yolo";
+            requireWorkspace: boolean;
+            workspaceId: string;
+            workspaceCoordinator: boolean;
+            backgroundWait: {
+                jobId: string;
+                campaignId: string;
+                tableId: string;
+                deadlineAt: string;
+            };
+            senders?: string[];
+            senderIds?: string[];
+            senderNames?: string[];
+            horizonSendDays?: number;
+            untilDate?: string;
+            targetDate?: string;
+            campaignId?: string;
+            tableId?: string;
+            intent?: RefillSendsIntent;
+            approvalMode?: RefillSendsApprovalMode;
+            actionTypes?: RefillSendsActionType[];
+            expectedTargetShapeRevision?: string;
+            expectedActionKey?: string;
+            runId?: string;
+            fence?: number;
+            runHandle?: RefillRunHandleV1;
+            targetConfig?: RefillTargetConfigV1;
+            reportingContext?: RefillReportingContextV2;
+            messageTemplateRevision?: MessageTemplateRevisionV1;
+            agentKeywords?: string[];
+        };
+        stopCondition: string;
+        renderBeforeInvoke?: undefined;
+    };
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+    fillWindow: {
+        mode: string;
+        targetDate: string;
+        description: string;
+        untilDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        untilDate: string;
+        description: string;
+        targetDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        horizonSendDays: number | null;
+        horizonHours: number | null;
+        description: string;
+        targetDate?: undefined;
+        untilDate?: undefined;
+    };
+    approvalMode: RefillSendsApprovalMode;
+    campaignId: string | null;
+    tableId: string | null;
+    targetConfig: RefillTargetConfigV1 | null;
+    runHandle: RefillRunHandleV1 | null;
+    reportingContext: RefillReportingContextV2 | null;
+    messageTemplateRevision: MessageTemplateRevisionV1 | null;
+    senderScope: string;
+    senderSelectors: {
+        senders: string[];
+        senderIds: string[];
+        senderNames: string[];
+    };
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    hostExamples: {
+        claude: string[];
+        codex: string[];
+        mcpTool: {
+            name: string;
+            arguments: {
+                workspaceRunState?: Record<string, unknown> | undefined;
+                workspaceCoordinator?: boolean | undefined;
+                messageTemplateRevision?: MessageTemplateRevisionV1 | undefined;
+                reportingContext?: RefillReportingContextV2 | undefined;
+                targetConfig?: RefillTargetConfigV1 | undefined;
+                runHandle?: RefillRunHandleV1 | undefined;
+                fence?: number | undefined;
+                runId?: string | undefined;
+                expectedActionKey?: string | undefined;
+                expectedTargetShapeRevision?: string | undefined;
+                targetDate: string | null;
+                untilDate: string | null;
+                horizonSendDays: number | null;
+                campaignId: string | undefined;
+                tableId: string | undefined;
+                intent: RefillSendsIntent;
+                approvalMode: RefillSendsApprovalMode;
+                workspaceId: string | null;
+                actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+                yolo: boolean;
+                senders: string[];
+                senderIds: string[];
+                senderNames: string[];
+            };
+        };
+    };
+    actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+    command: string;
+    tool: string;
+    promptName: string;
+    workflowPromptName: string;
+    workflowAsset: {
+        subskillName: string;
+        assetPath: string;
+        expectedVersion: string;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
 } | {
     status: "terminal";
     doneReason: "loaded_awaiting_scheduler";

package/dist/tools/refill-sends.js

@@ -219,6 +219,13 @@ function normalizeWorkspaceRunState(value) {
         if (entries.length > 0)
             attemptLedgers[key] = entries;
     }
+    // fix(112aj): preserve the continuation-level progress-or-settle counter across
+    // coordinator calls. Like the attempt ledgers above, stripping it here would
+    // reset the identical-active_exact_run replay count to 1 on every resume and the
+    // cap could never trip.
+    const activeExactRunProgress = recordValue(root.activeExactRunProgress);
+    const activeExactRunFingerprint = stringValue(activeExactRunProgress?.fingerprint);
+    const activeExactRunCount = numberValue(activeExactRunProgress?.count);
     return {
         version: 1,
         senderCursors,
@@ -226,6 +233,14 @@ function normalizeWorkspaceRunState(value) {
         passRates: [],
         coordinatorBlockedExactTargets,
         ...attemptLedgers,
+        ...(activeExactRunFingerprint && typeof activeExactRunCount === "number"
+            ? {
+                activeExactRunProgress: {
+                    fingerprint: activeExactRunFingerprint,
+                    count: activeExactRunCount,
+                },
+            }
+            : {}),
     };
 }
 const WORKSPACE_ATTEMPT_LEDGER_KEYS = [
@@ -813,6 +828,36 @@ function withKeywordsHandoffScope(result, scopedInput) {
 }
 const BACKGROUND_WAIT_FAST_PATH_TTL_MS = 10 * 60 * 1000;
 const BACKGROUND_WAIT_MIN_RETRY_MS = 5_000;
+// fix(112aj): the continuation-level progress-or-settle contract (the same
+// principle as the ag/af-c bypasses, applied one layer up). An identical
+// active_exact_run continuation — the SAME fence resumed at the same gate /
+// gateSeq / state / plan / shape revision with no observable coverage or effect
+// advance — may not be re-invoked unboundedly. Clover t4 (fence 109, run
+// cmrz49lii) resumed a broaden fence stuck at g2_execute 20× with a byte-stable
+// runSnapshot (gate g2_execute, gateSeq 2, stateRev 36a1de45) — no product effect,
+// no fresh handoff, no no_forward_progress — because the broaden's own attempt
+// bookkeeping wobbles the run-loop's mortality signature. This coordinator bound
+// counts identical active_exact_run resumes and, past the cap, returns an honest
+// no_forward_progress terminal and settles the fence (no continuation, not
+// re-spawned). A fence that IS advancing (any fingerprint field changes) resets
+// the counter and resumes normally, unbounded.
+const ACTIVE_EXACT_RUN_REPLAY_CAP = 3;
+function activeExactRunProgressFingerprint(result) {
+    const snapshot = recordValue(result.runSnapshot);
+    const runId = stringValue(result.runId) ?? stringValue(snapshot?.runId);
+    const fence = numberValue(result.fence);
+    if (!runId || typeof fence !== "number" || !snapshot)
+        return null;
+    return [
+        runId,
+        String(fence),
+        stringValue(snapshot.gate) ?? "",
+        String(numberValue(snapshot.gateSeq) ?? ""),
+        stringValue(snapshot.stateRevision) ?? "",
+        stringValue(snapshot.planRevision) ?? "",
+        stringValue(snapshot.targetShapeRevision) ?? "",
+    ].join("|");
+}
 // Action families whose successful exact terminal means NEW ROWS landed on
 // the campaign — invalidating any earlier complete/capped defer for it.
 const WORKSPACE_SUPPLY_ACTION_FAMILIES = new Set([
@@ -895,6 +940,51 @@ function backgroundWaitFromSelection(selection, now) {
         retryAfterMs,
     };
 }
+// fix(112ai): extract a still-running bounded prep/approve job receipt from a
+// just-completed exact run. When the census bypass admits a masked prepare/
+// approve edge, the coordinator dispatches a bounded job and the exact run
+// returns exact_action_complete with a preparationReceipt that is still RUNNING
+// (terminal:false) — the job drains the lane ASYNC, so the actionable census is
+// non-empty only because scanning has not finished. That in-flight job IS the
+// queued supply behind a non-empty census, so the coordinator must wait on it
+// (self-heal) rather than false-terminal actionable_supply_not_queued
+// (sellable-t4 7-29: prepare_messages:7fc0766d dispatched job cmrz555uc scanning
+// while 681 enrich rows sat in the census). A terminal:true receipt means the
+// job already drained; that is NOT a wait case, and the normal terminal logic
+// (which may legitimately block on residual, correctly-named conditions) runs.
+function dispatchedRunningPrepReceipt(result, completedFamily) {
+    if (completedFamily !== "prepare_messages" &&
+        completedFamily !== "approve_messages") {
+        return null;
+    }
+    const r = recordValue(result);
+    if (stringValue(r?.status) !== "terminal")
+        return null;
+    if (stringValue(r?.doneReason) !== "exact_action_complete")
+        return null;
+    const receipt = recordValue(recordValue(r?.report)?.preparationReceipt);
+    if (!receipt)
+        return null;
+    // Only a still-running durable receipt is draining work. terminal:true means
+    // the job finished (residual census is a different, correctly-named case); a
+    // failed/blocked/errored receipt is a real condition the terminal must surface.
+    if (receipt.terminal === true)
+        return null;
+    const status = stringValue(receipt.status);
+    if (status === "failed" ||
+        status === "error" ||
+        status === "blocked" ||
+        status === "cancelled") {
+        return null;
+    }
+    const jobId = stringValue(receipt.jobId);
+    if (!jobId)
+        return null;
+    return {
+        jobId,
+        retryAfterMs: Math.max(BACKGROUND_WAIT_MIN_RETRY_MS, numberValue(receipt.retryAfterMs) ?? 15_000),
+    };
+}
 function workspaceExactTargetsFromAction(action) {
     if (!Array.isArray(action.exactTargets) || action.exactTargets.length === 0) {
         return [];
@@ -1458,6 +1548,24 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             selectedActionFamily === "continue_prospeo_source" ||
             selectedActionFamily === "broaden_provider_search" ||
             selectedActionFamily === "refresh_sender_post_engagers";
+        // fix(112af-c/112ai): a prepare_messages OR approve_messages edge suffers the
+        // same pooled-cascade masking as sources/sweeps/waits — its exact scope can
+        // read scheduler-loaded or complete via the shared ready buffer while the lane
+        // still holds genuine actionable supply (sellable.dev 7-29: cmrcd4x4a
+        // send_invite prepare skipped while 69 enrich + 1 generate never-run rows sat
+        // behind it; Amplify t3 Sadhna + Dotwork cmqbt8b8: approve_messages skipped
+        // while a real approval frontier — needsApproval > 0 — sat behind it). This
+        // closes the masked-supply family (sweep→112ag, prepare→112af-c, approve→112ai)
+        // with ONE census-conditional bypass. Unlike sources/sweeps/waits these are not
+        // unconditionally bindable — a genuinely-complete prepare/approve must stay
+        // deferred to avoid a re-prepare loop. So bind ONLY when the LANE-SCOPED
+        // actionable census (per-sender existingRowFrontier stageCounts —
+        // needsApproval/needsGenerate/needsEnrich/needsRubric, never the pooled
+        // coverage) proves a real frontier; an empty census keeps the settled skip, and
+        // the bounded job consumes the frontier so the census drains.
+        const isMaskedSupplyTarget = (selectedActionFamily === "prepare_messages" ||
+            selectedActionFamily === "approve_messages") &&
+            exactPlanHasLaneScopedActionableFrontier(exactTargetPlan);
         // fix(111f, OWNER DIRECTIVE — dispatch-first): a settled preflight read
         // may only skip a target when its exact plan exposes NO unresolved
         // coordinator action — any bindable head (source supply, sweeps,
@@ -1470,6 +1578,7 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
         const bypassSettledSkips = isSchedulerSweepTarget ||
             isBackgroundWaitTarget ||
             isSourceSupplyTarget ||
+            isMaskedSupplyTarget ||
             yoloPlanHasUnresolvedCoordinatorAction(exactTargetPlan);
         if (!bypassSettledSkips && yoloPlanIsComplete(exactTargetPlan)) {
             completedExactTargetCount += 1;
@@ -1786,6 +1895,27 @@ function classifyWorkspaceUnavailableTerminal(plan, contextNote) {
     }
     return { code: "workspace_exact_target_unavailable", note: contextNote };
 }
+// fix(112af-c/112ai): a prepare_messages OR approve_messages edge on a cascade can
+// read scheduler-loaded or complete at the pooled campaign scope (the shared ready
+// buffer routed to Open/paid InMail or the connection fallback covers the aggregate
+// gap) while a specific lane still holds genuine actionable supply the pooled
+// coverage masks (sellable.dev 7-29: cmrcd4x4a send_invite prepare skipped as
+// "complete or scheduler-loaded" while 69 enrich + 1 generate never-run rows sat
+// behind it; Dotwork cmqbt8b8 + Amplify t3 Sadhna: approve skipped while a real
+// needsApproval frontier sat behind it). The lane-scoped signal is the per-sender
+// existingRowFrontier stageCounts summed by workspaceActionableSupplyCensus — NEVER
+// the pooled readyBuffer/coverage. When that census is non-empty the edge is a
+// masked-gap prep/approve and must bind so the bounded job consumes the frontier;
+// when the census is empty the edge is genuinely settled and stays deferred (no
+// re-prepare / re-approve loop).
+function exactPlanHasLaneScopedActionableFrontier(plan) {
+    const census = workspaceActionableSupplyCensus(plan);
+    return (census.approvalFrontier > 0 ||
+        census.generateFrontier > 0 ||
+        census.enrichFrontier > 0 ||
+        census.rubricFrontier > 0 ||
+        census.frontierHasMoreRows);
+}
 function yoloPlanIsComplete(plan) {
     const coverage = yoloCoverage(plan);
     return (coverage.status === "complete" ||
@@ -3381,6 +3511,49 @@ export async function executeRefillSendsCommand(input = {}) {
             : supplyLandedOnCampaign
                 ? clearCompleteDefersForCampaign(deferredCoordinatorWorkspaceRunState, selectedCoordinatorTarget?.campaignId ?? null)
                 : deferredCoordinatorWorkspaceRunState;
+        // fix(112aj): continuation-level progress-or-settle. When this dispatch is an
+        // active_exact_run resume (continuationHandle set, in_progress), fingerprint
+        // the fence's observable state; if the SAME fence has been re-invoked
+        // ACTIVE_EXACT_RUN_REPLAY_CAP times with a byte-identical fingerprint (no
+        // coverage/effect advance), settle it honestly instead of re-inviting an
+        // identical continuation. A fence that advanced (any fingerprint field moved)
+        // resets the counter and resumes normally.
+        let progressBoundedWorkspaceRunState = coordinatorWorkspaceRunState;
+        if (yolo && continuationHandle) {
+            const fingerprint = activeExactRunProgressFingerprint(result);
+            const priorProgress = recordValue(recordValue(scopedInput.workspaceRunState)?.activeExactRunProgress);
+            const replayCount = fingerprint && stringValue(priorProgress?.fingerprint) === fingerprint
+                ? (numberValue(priorProgress?.count) ?? 0) + 1
+                : 1;
+            if (fingerprint && replayCount >= ACTIVE_EXACT_RUN_REPLAY_CAP) {
+                return {
+                    ...command,
+                    ok: false,
+                    status: "blocked",
+                    blocker: "no_forward_progress",
+                    note: `The active exact run (${continuationHandle.runId} fence ${continuationHandle.fence}) was resumed ${replayCount} times with no observable coverage or effect advance ` +
+                        "(identical gate/state fingerprint). Settling the fence instead of re-inviting an identical continuation; a fresh refill_sends command reconciles it. No run or mutation was started.",
+                    coordinator: {
+                        scope: "workspace",
+                        status: "blocked",
+                    },
+                    continuation: { required: false, userActionRequired: false },
+                };
+            }
+            progressBoundedWorkspaceRunState = fingerprint
+                ? {
+                    ...(recordValue(coordinatorWorkspaceRunState) ?? {}),
+                    activeExactRunProgress: { fingerprint, count: replayCount },
+                }
+                : coordinatorWorkspaceRunState;
+        }
+        else {
+            const base = recordValue(coordinatorWorkspaceRunState);
+            if (base && "activeExactRunProgress" in base) {
+                const { activeExactRunProgress: _cleared, ...rest } = base;
+                progressBoundedWorkspaceRunState = rest;
+            }
+        }
         const workspaceContinuationArguments = {
             yolo: true,
             executionMode: "yolo",
@@ -3400,8 +3573,8 @@ export async function executeRefillSendsCommand(input = {}) {
                 : {}),
             approvalMode: scopedInput.approvalMode ?? "approve",
             ...(isWorkspaceCoordinator ? { workspaceCoordinator: true } : {}),
-            ...(coordinatorWorkspaceRunState
-                ? { workspaceRunState: coordinatorWorkspaceRunState }
+            ...(progressBoundedWorkspaceRunState
+                ? { workspaceRunState: progressBoundedWorkspaceRunState }
                 : {}),
         };
         if (isWorkspaceCoordinator &&
@@ -3627,6 +3800,79 @@ export async function executeRefillSendsCommand(input = {}) {
                 };
             }
             if (nextSelection.status === "blocked") {
+                // fix(112ai, OWNER closing invariant): actionable_supply_not_queued is a
+                // planner-exposure DEFECT terminal and is legal ONLY when no bounded
+                // prep/approve job dispatched THIS command is still draining the census.
+                // The af-c/ai census bypass admits the masked prepare/approve edge and
+                // the coordinator dispatches a bounded job, but that job drains ASYNC:
+                // the exact run returns exact_action_complete with a still-running
+                // receipt (terminal:false) while the census still shows the un-drained
+                // rows. Emitting actionable_supply_not_queued here (continuation
+                // required:false) HALTS the yolo loop before the job drains — the exact
+                // false-terminal the owner ruled unacceptable on sellable-t4
+                // (prepare_messages:7fc0766d dispatched job cmrz555uc scanning while 681
+                // enrich rows sat in the census). Recognize the in-flight job as the
+                // queued supply: emit a healthy background-wait so the loop re-invokes,
+                // the fast path probes the job by id (sidestepping the planner-exposure
+                // gap that starved the reread), and the census drains (self-heal). This
+                // makes "non-empty census + dispatched running job + halting defect
+                // terminal" unrepresentable.
+                const runningPrepReceipt = dispatchedRunningPrepReceipt(result, completedPrepFamily);
+                if (nextSelection.code === "actionable_supply_not_queued" &&
+                    runningPrepReceipt &&
+                    selectedCoordinatorTarget) {
+                    const backgroundContinuationInput = workspaceCoordinatorInput(scopedInput);
+                    delete backgroundContinuationInput.expectedTargetShapeRevision;
+                    delete backgroundContinuationInput.expectedActionKey;
+                    const backgroundWait = {
+                        jobId: runningPrepReceipt.jobId,
+                        campaignId: selectedCoordinatorTarget.campaignId ?? null,
+                        tableId: selectedCoordinatorTarget.tableId ?? null,
+                        deadlineAt: new Date(Date.now() + BACKGROUND_WAIT_FAST_PATH_TTL_MS).toISOString(),
+                    };
+                    return {
+                        ...command,
+                        status: "in_progress",
+                        note: `The exact ${completedPrepFamily} edge dispatched a bounded preparation job (${runningPrepReceipt.jobId}) that is still draining the lane; the actionable census remains non-empty only because that job has not finished scanning. Waiting on the in-flight job instead of false-terminaling actionable_supply_not_queued — the loop re-invokes, the job drains the frontier, and coverage advances.`,
+                        targetPlan: nextSelection.workspacePlan,
+                        exactTargetPlan: nextSelection.exactTargetPlan ?? null,
+                        orchestration: {
+                            mode: "fenced_bounded_yolo",
+                            scope: "workspace_exact_target_coordinator",
+                            phase: "read_only_background_wait",
+                        },
+                        coordinator: {
+                            scope: "workspace",
+                            status: "waiting_background",
+                            completedTarget: selectedCoordinatorTarget,
+                            selectedTarget: selectedCoordinatorTarget,
+                            workspaceTargetPlan: nextSelection.workspacePlan,
+                            exactRunResult: result,
+                            backgroundJob: { jobId: runningPrepReceipt.jobId },
+                        },
+                        continuation: {
+                            required: true,
+                            kind: "workspace_background_wait",
+                            owner: "packaged_workflow",
+                            userActionRequired: false,
+                            tool: "refill_sends",
+                            retryAfterMs: runningPrepReceipt.retryAfterMs,
+                            arguments: {
+                                ...backgroundContinuationInput,
+                                yolo: true,
+                                executionMode: "yolo",
+                                requireWorkspace: true,
+                                workspaceId,
+                                workspaceCoordinator: true,
+                                backgroundWait,
+                                ...(coordinatorWorkspaceRunState
+                                    ? { workspaceRunState: coordinatorWorkspaceRunState }
+                                    : {}),
+                            },
+                            stopCondition: "A bounded preparation job dispatched this command is still draining the actionable census. After the bounded wait, replan the whole workspace; do not open or resume an exact fence solely to poll background work.",
+                        },
+                    };
+                }
                 const persistedDeferredBlocker = coordinatorDeferredBlocker(coordinatorWorkspaceRunState);
                 const workspaceCoverage = yoloCoverage(nextSelection.workspacePlan);
                 if (persistedDeferredBlocker === "loaded_awaiting_scheduler" &&

package/package.json

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