@sellable/mcp 0.1.641 → 0.1.643

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

@@ -745,9 +745,127 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         status: string;
         workspaceTargetPlan: unknown;
         selectedTarget?: undefined;
+        exactTargetPlan?: undefined;
+        note?: undefined;
+        completedTarget?: undefined;
+        exactRunResult?: undefined;
+    };
+    continuation: {
+        required: boolean;
+        userActionRequired: boolean;
+        kind?: undefined;
+        owner?: undefined;
+        tool?: undefined;
+        arguments?: 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: {
+                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;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
+} | {
+    status: "terminal";
+    doneReason: "loaded_awaiting_scheduler";
+    note: string;
+    targetPlan: unknown;
+    exactTargetPlan: unknown;
+    orchestration: {
+        mode: string;
+        scope: string;
+        checkpointedFields: string[];
+        transportBudgetMs: number;
+    };
+    coordinator: {
+        scope: string;
+        status: string;
+        selectedTarget: WorkspaceExactTarget;
+        workspaceTargetPlan: unknown;
+        exactTargetPlan: unknown;
+        note: string;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     };
     continuation: {
         required: boolean;
@@ -847,8 +965,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
 } | {
     ok: boolean;
     status: "blocked";
-    code: "workspace_exact_target_unavailable" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
-    blocker: "workspace_exact_target_unavailable" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
+    code: "workspace_exact_target_unavailable" | "workspace_exact_target_ambiguous" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
+    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_ambiguous" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
     note: string;
     targetPlan: unknown;
     exactTargetPlan: {} | null;
@@ -857,9 +975,10 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         status: string;
         selectedTarget: WorkspaceExactTarget | null;
         workspaceTargetPlan?: undefined;
+        exactTargetPlan?: undefined;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     };
     continuation: {
         required: boolean;
@@ -1079,6 +1198,7 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
             conflicts?: undefined;
         };
         selectedTarget?: undefined;
+        exactTargetPlan?: undefined;
         note?: undefined;
     };
     continuation: {
@@ -1188,11 +1308,154 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     workspaceId: string | null;
     workspaceResolution: string;
     intent: RefillSendsIntent;
+} | {
+    status: "terminal";
+    doneReason: "loaded_awaiting_scheduler";
+    note: string;
+    targetPlan: unknown;
+    exactTargetPlan: unknown;
+    orchestration: {
+        mode: string;
+        scope: string;
+        checkpointedFields: string[];
+        transportBudgetMs: number;
+    };
+    coordinator: {
+        scope: string;
+        status: string;
+        completedTarget: WorkspaceExactTarget | null;
+        selectedTarget: WorkspaceExactTarget;
+        workspaceTargetPlan: unknown;
+        exactTargetPlan: unknown;
+        exactRunResult: {
+            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>;
+            blocker?: undefined;
+            conflicts?: undefined;
+        };
+        note: string;
+    };
+    continuation: {
+        required: boolean;
+        userActionRequired: boolean;
+        kind?: undefined;
+        owner?: undefined;
+        tool?: undefined;
+        arguments?: undefined;
+        stopCondition?: undefined;
+    };
+    runSnapshot: unknown;
+    readOnly: boolean;
+    forbiddenActions: string[];
+    boundedAuthority: string;
+    report: Record<string, unknown>;
+    runId: string;
+    guidance?: string;
+    journalPath?: string | null;
+    targetConfig: RefillTargetConfigV1 | null;
+    runHandle: RefillRunHandleV1 | null;
+    refillReporting?: Record<string, unknown>;
+    blocker?: undefined;
+    conflicts?: 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;
+    reportingContext: RefillReportingContextV2 | null;
+    messageTemplateRevision: MessageTemplateRevisionV1 | null;
+    senderScope: string;
+    senderSelectors: {
+        senders: string[];
+        senderIds: string[];
+        senderNames: string[];
+    };
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    hostExamples: {
+        claude: string[];
+        codex: string[];
+        mcpTool: {
+            name: string;
+            arguments: {
+                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;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
 } | {
     ok: boolean;
     status: "blocked";
-    code: "workspace_exact_target_unavailable" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
-    blocker: "workspace_exact_target_unavailable" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
+    code: "workspace_exact_target_unavailable" | "workspace_exact_target_ambiguous" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
+    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_ambiguous" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
     note: string;
     targetPlan: unknown;
     exactTargetPlan: {} | null;
@@ -1219,6 +1482,7 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
             conflicts?: undefined;
         };
         workspaceTargetPlan?: undefined;
+        exactTargetPlan?: undefined;
         note?: undefined;
     };
     continuation: {
@@ -1349,6 +1613,7 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
             conflicts?: undefined;
         };
         note: string;
+        exactTargetPlan?: undefined;
     };
     continuation: {
         required: boolean;
@@ -1490,6 +1755,7 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
             conflicts?: undefined;
         };
         workspaceTargetPlan?: undefined;
+        exactTargetPlan?: undefined;
         note?: undefined;
     };
     continuation: {
@@ -1647,9 +1913,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];
@@ -1796,9 +2062,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];
@@ -1949,9 +2215,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];
@@ -2102,9 +2368,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];
@@ -2253,9 +2519,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];
@@ -2407,9 +2673,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];
@@ -2563,9 +2829,9 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         scope: string;
         status: string | undefined;
         selectedTarget: WorkspaceExactTarget | null;
+        note?: undefined;
         completedTarget?: undefined;
         exactRunResult?: undefined;
-        note?: undefined;
     } | undefined;
     orchestration: {
         checkpointedFields: string[];

package/dist/tools/refill-sends.js

@@ -529,15 +529,60 @@ function recordsWithExactTarget(value) {
             stringValue(candidate.tableId)))
         : [];
 }
-function workspaceExactTargetsFromAction(action) {
+function workspaceExactActionSignature(action) {
+    const campaignId = actionCampaignId(action);
+    const tableId = actionTableId(action);
+    const actionKey = stringValue(action.actionKey);
+    const actionType = stringValue(action.actionType);
+    if (!campaignId || !tableId || !actionKey || !actionType)
+        return null;
+    return JSON.stringify([campaignId, tableId, actionKey, actionType]);
+}
+function workspaceAggregateActionSenderIds(workspacePlan) {
+    const target = yoloTarget(workspacePlan);
+    const senderPlans = Array.isArray(target?.senderRefillPlans)
+        ? target.senderRefillPlans
+            .map(recordValue)
+            .filter((plan) => Boolean(plan))
+        : [];
+    const senderIdsByAction = new Map();
+    for (const senderPlan of senderPlans) {
+        const senderId = stringValue(senderPlan.senderId);
+        const nextActions = Array.isArray(senderPlan.nextActions)
+            ? senderPlan.nextActions
+                .map(recordValue)
+                .filter((action) => Boolean(action))
+            : [];
+        if (!senderId)
+            continue;
+        for (const action of nextActions) {
+            const signature = workspaceExactActionSignature(action);
+            if (!signature)
+                continue;
+            const senderIds = senderIdsByAction.get(signature) ?? new Set();
+            senderIds.add(senderId);
+            senderIdsByAction.set(signature, senderIds);
+        }
+    }
+    return new Map([...senderIdsByAction.entries()]
+        .filter(([, senderIds]) => senderIds.size > 1)
+        .map(([signature, senderIds]) => [
+        signature,
+        [...senderIds],
+    ]));
+}
+function workspaceExactTargetsFromAction(action, aggregateSenderIdsByAction = new Map()) {
     const toolInput = recordValue(action.toolInput) ?? {};
+    const exactTargets = recordsWithExactTarget(toolInput.exactTargets);
     const expectedTargets = recordsWithExactTarget(toolInput.expectedTargets);
     const sourceScopes = recordsWithExactTarget(toolInput.sourceScopes);
-    const exactEdges = expectedTargets.length > 0
-        ? expectedTargets
-        : sourceScopes.length > 0
-            ? sourceScopes
-            : [null];
+    const exactEdges = exactTargets.length > 0
+        ? exactTargets
+        : expectedTargets.length > 0
+            ? expectedTargets
+            : sourceScopes.length > 0
+                ? sourceScopes
+                : [null];
     const campaignIds = normalizeStrings(toolInput.campaignIds);
     const tableIds = normalizeStrings(toolInput.tableIds);
     return exactEdges.flatMap((exactEdge) => {
@@ -548,12 +593,26 @@ function workspaceExactTargetsFromAction(action) {
         if (!campaignId || !tableId)
             return [];
         const exactEdgeSenderIds = normalizeStrings(exactEdge?.senderIds);
-        const senderId = stringValue(exactEdge?.senderId) ?? actionSenderId(action) ?? null;
-        const senderIds = senderId
-            ? [senderId]
-            : exactEdgeSenderIds.length > 0
-                ? exactEdgeSenderIds
-                : normalizeStrings(toolInput.senderIds);
+        const exactEdgeSenderId = stringValue(exactEdge?.senderId);
+        const toolInputSenderIds = normalizeStrings(toolInput.senderIds);
+        const aggregateSenderIds = aggregateSenderIdsByAction.get(workspaceExactActionSignature(action) ?? "") ?? [];
+        const actionSenderIdValue = actionSenderId(action);
+        // Explicit edge/list scope is authoritative. Legacy shared campaign
+        // actions predate expectedTargets and can repeat the same representative
+        // sender action across several senderRefillPlans. Preserve that recovered
+        // member set instead of narrowing the exact coordinator to the complete
+        // representative sender and hiding another member's actionable gap.
+        const senderIds = exactEdgeSenderIds.length > 0
+            ? exactEdgeSenderIds
+            : exactEdgeSenderId
+                ? [exactEdgeSenderId]
+                : toolInputSenderIds.length > 0
+                    ? toolInputSenderIds
+                    : aggregateSenderIds.length > 0
+                        ? aggregateSenderIds
+                        : actionSenderIdValue
+                            ? [actionSenderIdValue]
+                            : [];
         const directActionType = stringValue(exactEdge?.actionType) ??
             stringValue(exactEdge?.refillLaneKey) ??
             stringValue(action.actionType);
@@ -665,7 +724,34 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             .filter((action) => Boolean(action))
         : [];
     const workspaceActions = [...globalActions, ...rankedCandidates];
-    const actionTargets = workspaceActions.flatMap(workspaceExactTargetsFromAction);
+    const aggregateSenderIdsByAction = workspaceAggregateActionSenderIds(workspacePlan);
+    const legacyGlobalActionCounts = new Map();
+    for (const action of globalActions) {
+        const signature = workspaceExactActionSignature(action);
+        if (!signature)
+            continue;
+        legacyGlobalActionCounts.set(signature, (legacyGlobalActionCounts.get(signature) ?? 0) + 1);
+    }
+    const ambiguousLegacyAction = globalActions.find((action) => {
+        const signature = workspaceExactActionSignature(action);
+        if (!signature || (legacyGlobalActionCounts.get(signature) ?? 0) < 2) {
+            return false;
+        }
+        const toolInput = recordValue(action.toolInput) ?? {};
+        const hasExplicitTargets = recordsWithExactTarget(toolInput.exactTargets).length > 0 ||
+            recordsWithExactTarget(toolInput.expectedTargets).length > 0 ||
+            recordsWithExactTarget(toolInput.sourceScopes).length > 0;
+        return !hasExplicitTargets && !aggregateSenderIdsByAction.has(signature);
+    });
+    if (ambiguousLegacyAction) {
+        return {
+            status: "blocked",
+            code: "workspace_exact_target_ambiguous",
+            note: "The workspace planner repeated one legacy aggregate action without explicit exact targets or recoverable sender membership. No refill run or mutation was started.",
+            workspacePlan,
+        };
+    }
+    const actionTargets = workspaceActions.flatMap((action) => workspaceExactTargetsFromAction(action, aggregateSenderIdsByAction));
     const evergreenTargets = evergreenExactTargetCandidates(workspacePlan, {
         preferredSenderId: options.preferredSenderId,
         actionTypes: input.actionTypes,
@@ -691,6 +777,9 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
         };
     }
     let completedExactTargetCount = 0;
+    let schedulerLoadedExactTargetCount = 0;
+    let lastSchedulerLoadedTarget = null;
+    let lastSchedulerLoadedPlan = null;
     for (const selectedTarget of targetCandidates) {
         const exactInput = {
             ...workspaceInput,
@@ -708,6 +797,12 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             completedExactTargetCount += 1;
             continue;
         }
+        if (yoloPlanIsSchedulerLoaded(exactTargetPlan)) {
+            schedulerLoadedExactTargetCount += 1;
+            lastSchedulerLoadedTarget = selectedTarget;
+            lastSchedulerLoadedPlan = exactTargetPlan;
+            continue;
+        }
         let targetConfig;
         try {
             targetConfig = normalizeRefillTargetConfig(recordValue(exactTargetPlan)?.targetConfig);
@@ -753,6 +848,15 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             targetConfig,
         };
     }
+    if (lastSchedulerLoadedTarget && lastSchedulerLoadedPlan) {
+        return {
+            status: "awaiting_scheduler",
+            note: `All exposed exact targets were already complete or scheduler-loaded; ${schedulerLoadedExactTargetCount} exact targets have enough ready inventory to cover their projected gaps. No identical refill fence was reopened.`,
+            workspacePlan,
+            exactTargetPlan: lastSchedulerLoadedPlan,
+            selectedTarget: lastSchedulerLoadedTarget,
+        };
+    }
     return {
         status: "blocked",
         code: "workspace_exact_target_unavailable",
@@ -781,6 +885,16 @@ function yoloPlanIsComplete(plan) {
             coverage.grossTarget > 0 &&
             coverage.remainingProjectedGap === 0));
 }
+function yoloPlanIsSchedulerLoaded(plan) {
+    const coverage = yoloCoverage(plan);
+    return (coverage.status === "awaiting_scheduler_after_ready_buffer" ||
+        (coverage.status !== "blocked" &&
+            typeof coverage.grossTarget === "number" &&
+            coverage.grossTarget > 0 &&
+            typeof coverage.remainingProjectedGap === "number" &&
+            coverage.remainingProjectedGap > 0 &&
+            coverage.remainingReadyOrProjectedGap === 0));
+}
 function workspaceConnectivityEmptyState(plan) {
     const target = yoloTarget(plan);
     const emptyState = recordValue(target?.emptyState);
@@ -1550,6 +1664,41 @@ export async function executeRefillSendsCommand(input = {}) {
                     },
                 };
             }
+            if (coordinatorSelection.status === "awaiting_scheduler") {
+                return {
+                    ...command,
+                    status: "terminal",
+                    doneReason: "loaded_awaiting_scheduler",
+                    note: coordinatorSelection.note,
+                    targetPlan: coordinatorSelection.workspacePlan,
+                    exactTargetPlan: coordinatorSelection.exactTargetPlan,
+                    orchestration: {
+                        mode: "fenced_bounded_yolo",
+                        scope: "workspace_exact_target_coordinator",
+                        checkpointedFields: [
+                            "runId",
+                            "fence",
+                            "runState",
+                            "actionKey",
+                            "requestId",
+                            "effectId",
+                        ],
+                        transportBudgetMs: 40_000,
+                    },
+                    coordinator: {
+                        scope: "workspace",
+                        status: "loaded_awaiting_scheduler",
+                        selectedTarget: coordinatorSelection.selectedTarget,
+                        workspaceTargetPlan: coordinatorSelection.workspacePlan,
+                        exactTargetPlan: coordinatorSelection.exactTargetPlan,
+                        note: coordinatorSelection.note,
+                    },
+                    continuation: {
+                        required: false,
+                        userActionRequired: false,
+                    },
+                };
+            }
             if (coordinatorSelection.status === "blocked") {
                 return {
                     ...command,
@@ -1774,6 +1923,44 @@ export async function executeRefillSendsCommand(input = {}) {
                     },
                 };
             }
+            if (nextSelection.status === "awaiting_scheduler") {
+                return {
+                    ...command,
+                    ...result,
+                    status: "terminal",
+                    doneReason: "loaded_awaiting_scheduler",
+                    note: nextSelection.note,
+                    targetPlan: nextSelection.workspacePlan,
+                    exactTargetPlan: nextSelection.exactTargetPlan,
+                    orchestration: {
+                        mode: "fenced_bounded_yolo",
+                        scope: "workspace_exact_target_coordinator",
+                        checkpointedFields: [
+                            "runId",
+                            "fence",
+                            "runState",
+                            "actionKey",
+                            "requestId",
+                            "effectId",
+                        ],
+                        transportBudgetMs: 40_000,
+                    },
+                    coordinator: {
+                        scope: "workspace",
+                        status: "loaded_awaiting_scheduler",
+                        completedTarget: selectedCoordinatorTarget,
+                        selectedTarget: nextSelection.selectedTarget,
+                        workspaceTargetPlan: nextSelection.workspacePlan,
+                        exactTargetPlan: nextSelection.exactTargetPlan,
+                        exactRunResult: result,
+                        note: nextSelection.note,
+                    },
+                    continuation: {
+                        required: false,
+                        userActionRequired: false,
+                    },
+                };
+            }
             if (nextSelection.status === "blocked") {
                 return {
                     ...command,

package/package.json

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