@sellable/mcp 0.1.643 → 0.1.645-wip.refill-zero-shot.20260721153930

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

@@ -965,8 +965,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
 } | {
     ok: boolean;
     status: "blocked";
-    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";
+    code: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
+    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
     note: string;
     targetPlan: unknown;
     exactTargetPlan: {} | null;
@@ -1454,8 +1454,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
 } | {
     ok: boolean;
     status: "blocked";
-    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";
+    code: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
+    blocker: "workspace_exact_target_unavailable" | "workspace_exact_target_contract_missing" | "exact_target_config_unavailable" | "exact_target_config_mismatch" | "exact_target_projection_mismatch";
     note: string;
     targetPlan: unknown;
     exactTargetPlan: {} | null;
@@ -1722,6 +1722,135 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     workspaceId: string | null;
     workspaceResolution: string;
     intent: RefillSendsIntent;
+} | {
+    ok: boolean;
+    status: "blocked";
+    code: string;
+    blocker: string;
+    note: string;
+    targetPlan: unknown;
+    exactTargetPlan: unknown;
+    coordinator: {
+        scope: string;
+        status: string;
+        completedTarget: WorkspaceExactTarget | null;
+        selectedTarget: WorkspaceExactTarget;
+        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;
+        };
+        workspaceTargetPlan?: undefined;
+        exactTargetPlan?: undefined;
+        note?: 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: "in_progress";
     targetPlan: unknown;

package/dist/tools/refill-sends.js

@@ -1,12 +1,17 @@
 import { decodeRefillReadinessAuthority, refillReadinessFingerprint, } from "../refill-readiness.js";
 import { MESSAGE_TEMPLATE_REVISION_INPUT_SCHEMA, REFILL_REPORTING_CONTEXT_INPUT_SCHEMA, REFILL_RUN_HANDLE_INPUT_SCHEMA, REFILL_TARGET_CONFIG_INPUT_SCHEMA, normalizeMessageTemplateRevision, normalizeRefillRunHandle, normalizeRefillTargetConfig, } from "./campaign-processing.js";
-import { actionCampaignId, actionIds, actionSenderId, actionTableId, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, executeStartCampaignPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
+import { actionCampaignId, actionIds, actionSenderId, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, executeStartCampaignPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
 import { refillSendsV2Command } from "./refill-sends-v2.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { listSenders } from "./senders.js";
 import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const REFILL_SEND_ACTION_TYPES = ["send_invite", "send_inmail_closed"];
 const REFILL_SEND_ACTION_TYPE_SET = new Set(REFILL_SEND_ACTION_TYPES);
+const WORKSPACE_EXACT_BRANCH_ACTION_TYPE_SET = new Set([
+    "send_invite",
+    "send_inmail_open",
+    "send_inmail_closed",
+]);
 const REFILL_SEND_INTENT_SET = new Set([
     "plain",
     "active",
@@ -133,7 +138,7 @@ function normalizeRefillSendsInput(input) {
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
-        description: "Typed command entrypoint for Sellable refill sends. Workspace-wide --yolo reads globalActionQueue[0], preflights its exact campaign/table/sender/lane targetConfig, and executes one fenced checkpointed run slice before rereading workspace scope for the next exact target. An active_exact_run continuation carries targetConfig plus exact runId/fence; a next_exact_target continuation carries the next preflighted targetConfig and opens a new fence. When an exact run terminalizes as loaded_awaiting_scheduler and the fresh workspace queue reselects the same campaign/table/sender/lane, the coordinator returns that scheduler-owned workspace terminal instead of opening another identical fence. The packaged workflow must immediately invoke the returned continuation arguments until workspace projected coverage fills, the same-target scheduler terminal is returned, or a concrete blocker appears, without asking the user to continue. Every primitive records actionKey/requestId/effectId before mutation and rereads the fresh target plan afterward. It may refresh stale paid InMail facts once, prepare/approve bounded existing rows, reuse/import receipt-proven same-source rows, add more leads to an existing campaign from its SAME provider source once that campaign's eligible/prepared rows are receipt-proven exhausted (cold-outbound campaigns may source Sales Nav or Prospeo), start a route-resolver start-eligible PAUSED campaign-backed sequence campaign selected by the packet when starting is needed to fill the send window, run a request-scoped product scheduler sweep, and wait/reread. Each source add and campaign start is one bounded primitive, then a full replan. It never sends directly, lowers paid InMail thresholds/floors, creates NEW campaigns, archives/deletes, or switches an existing campaign's source family (same provider source only). Unselected PAUSED campaigns that are not start-eligible remain paused. Scheduler placement stays product-native; the command never raw-writes scheduler fields.",
+        description: "Typed command entrypoint for Sellable refill sends. Workspace-wide --yolo reads globalActionQueue[0], preflights its exact campaign/table/sender/lane targetConfig, and executes one fenced checkpointed run slice before rereading workspace scope for the next exact target. An active_exact_run continuation carries targetConfig plus exact runId/fence; a next_exact_target continuation carries the next preflighted targetConfig and opens a new fence. Exact target configs bind the issued semantic action and revisions. A terminal exact run may advance only when a fresh exact preflight selects a different semantic action; two fresh reads of the same terminal action fail closed instead of opening another identical fence. When an exact run terminalizes as loaded_awaiting_scheduler and the fresh workspace queue reselects the same campaign/table/sender/lane, the coordinator returns that scheduler-owned workspace terminal instead of opening another identical fence. The packaged workflow must immediately invoke the returned continuation arguments until workspace projected coverage fills, the same-target scheduler terminal is returned, or a concrete blocker appears, without asking the user to continue. Every primitive records actionKey/requestId/effectId before mutation and rereads the fresh target plan afterward. It may refresh stale paid InMail facts once, prepare/approve bounded existing rows, reuse/import receipt-proven same-source rows, add more leads to an existing campaign from its SAME provider source once that campaign's eligible/prepared rows are receipt-proven exhausted (cold-outbound campaigns may source Sales Nav or Prospeo), start a route-resolver start-eligible PAUSED campaign-backed sequence campaign selected by the packet when starting is needed to fill the send window, run a request-scoped product scheduler sweep, and wait/reread. Each source add and campaign start is one bounded primitive, then a full replan. It never sends directly, lowers paid InMail thresholds/floors, creates NEW campaigns, archives/deletes, or switches an existing campaign's source family (same provider source only). Unselected PAUSED campaigns that are not start-eligible remain paused. Scheduler placement stays product-native; the command never raw-writes scheduler fields.",
         inputSchema: {
             type: "object",
             properties: {
@@ -507,6 +512,11 @@ function sameWorkspaceExactTarget(left, right) {
         sameStringSet(left.senderIds, right.senderIds) &&
         sameStringSet(left.actionTypes, right.actionTypes));
 }
+function sameWorkspaceExactAction(left, right) {
+    return (sameWorkspaceExactTarget(left, right) &&
+        Boolean(left?.actionKey) &&
+        left?.actionKey === right.actionKey);
+}
 function workspaceCoordinatorInput(input) {
     const coordinatorInput = { ...input };
     delete coordinatorInput.campaignId;
@@ -520,118 +530,37 @@ function workspaceCoordinatorInput(input) {
     delete coordinatorInput.agentKeywords;
     return coordinatorInput;
 }
-function recordsWithExactTarget(value) {
-    return Array.isArray(value)
-        ? value
-            .map(recordValue)
-            .filter((candidate) => Boolean(candidate &&
-            stringValue(candidate.campaignId) &&
-            stringValue(candidate.tableId)))
-        : [];
-}
-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);
-        }
+function workspaceExactTargetsFromAction(action) {
+    if (!Array.isArray(action.exactTargets) || action.exactTargets.length === 0) {
+        return [];
     }
-    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 = 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) => {
-        const campaignId = stringValue(exactEdge?.campaignId) ??
-            actionCampaignId(action) ??
-            campaignIds[0];
-        const tableId = stringValue(exactEdge?.tableId) ?? actionTableId(action) ?? tableIds[0];
-        if (!campaignId || !tableId)
+    const targets = action.exactTargets.flatMap((value) => {
+        const exactTarget = recordValue(value);
+        const campaignId = stringValue(exactTarget?.campaignId);
+        const tableId = stringValue(exactTarget?.tableId);
+        const senderIds = normalizeStrings(exactTarget?.senderIds);
+        const refillLaneKey = stringValue(exactTarget?.refillLaneKey);
+        const branchActionTypes = normalizeStrings(exactTarget?.branchActionTypes);
+        if (!campaignId ||
+            !tableId ||
+            senderIds.length === 0 ||
+            !refillLaneKey ||
+            !REFILL_SEND_ACTION_TYPE_SET.has(refillLaneKey) ||
+            branchActionTypes.length === 0 ||
+            branchActionTypes.some((actionType) => !WORKSPACE_EXACT_BRANCH_ACTION_TYPE_SET.has(actionType))) {
             return [];
-        const exactEdgeSenderIds = normalizeStrings(exactEdge?.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);
-        const exactEdgeActionTypes = normalizeStrings(exactEdge?.branchActionTypes);
-        const actionTypes = directActionType && REFILL_SEND_ACTION_TYPE_SET.has(directActionType)
-            ? [directActionType]
-            : (exactEdgeActionTypes.length > 0
-                ? exactEdgeActionTypes
-                : normalizeStrings(toolInput.actionTypes)).filter((actionType) => REFILL_SEND_ACTION_TYPE_SET.has(actionType));
+        }
         return [
             {
                 campaignId,
                 tableId,
                 senderIds,
-                actionTypes,
+                actionTypes: [refillLaneKey],
                 actionKey: stringValue(action.actionKey) ?? null,
             },
         ];
     });
+    return targets.length === action.exactTargets.length ? targets : [];
 }
 function workspaceExactTargetKey(target) {
     return JSON.stringify([
@@ -641,55 +570,6 @@ function workspaceExactTargetKey(target) {
         [...new Set(target.actionTypes)].sort(),
     ]);
 }
-function evergreenExactTargetCandidates(workspacePlan, options) {
-    const root = recordValue(workspacePlan) ?? {};
-    const target = yoloTarget(workspacePlan) ?? {};
-    const evergreen = recordValue(root.evergreen) ??
-        recordValue(recordValue(root.packet)?.evergreen) ??
-        {};
-    const laneOrder = Array.isArray(evergreen.laneOrder)
-        ? evergreen.laneOrder.map(recordValue).filter(Boolean)
-        : [];
-    const laneByKey = new Map(laneOrder
-        .map((lane) => [stringValue(lane?.laneKey), lane])
-        .filter((entry) => Boolean(entry[0] && entry[1])));
-    const campaigns = Array.isArray(target.campaigns)
-        ? target.campaigns.map(recordValue).filter(Boolean)
-        : [];
-    const campaignById = new Map(campaigns
-        .map((campaign) => [stringValue(campaign?.campaignId), campaign])
-        .filter((entry) => Boolean(entry[0] && entry[1])));
-    const selections = Array.isArray(evergreen.senderLaneSelections)
-        ? evergreen.senderLaneSelections
-            .map(recordValue)
-            .filter(Boolean)
-        : [];
-    const selection = selections.find((candidate) => stringValue(candidate?.senderId) === options.preferredSenderId) ?? selections[0];
-    const senderId = stringValue(selection?.senderId);
-    const laneChain = Array.isArray(selection?.laneChain)
-        ? normalizeStrings(selection.laneChain)
-        : laneOrder
-            .map((lane) => stringValue(lane?.laneKey))
-            .filter((laneKey) => Boolean(laneKey));
-    return laneChain.flatMap((laneKey) => {
-        const lane = laneByKey.get(laneKey);
-        const campaignId = stringValue(lane?.campaignId) ??
-            (campaignById.has(laneKey) ? laneKey : null);
-        const campaign = campaignId ? campaignById.get(campaignId) : null;
-        const tableId = stringValue(campaign?.tableId) ?? stringValue(lane?.tableId);
-        if (!campaignId || !tableId)
-            return [];
-        return [
-            {
-                campaignId,
-                tableId,
-                senderIds: senderId ? [senderId] : [],
-                actionTypes: options.actionTypes ?? [],
-                actionKey: null,
-            },
-        ];
-    });
-}
 async function selectWorkspaceExactTarget(input, workspacePlanOverride, options = {}) {
     const workspaceInput = workspaceCoordinatorInput(input);
     let workspacePlan = workspacePlanOverride ??
@@ -724,41 +604,18 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             .filter((action) => Boolean(action))
         : [];
     const workspaceActions = [...globalActions, ...rankedCandidates];
-    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) {
+    const queueHead = globalActions[0] ?? rankedCandidates[0];
+    if (queueHead && workspaceExactTargetsFromAction(queueHead).length === 0) {
         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.",
+            code: "workspace_exact_target_contract_missing",
+            note: "The workspace planner's current action did not include a complete exactTargets contract. 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,
-    }).filter((candidate) => !actionTargets.some((actionTarget) => actionTarget.campaignId === candidate.campaignId &&
-        actionTarget.tableId === candidate.tableId));
+    const actionTargets = workspaceActions.flatMap((action) => workspaceExactTargetsFromAction(action));
     const seenTargetKeys = new Set();
-    const targetCandidates = [...actionTargets, ...evergreenTargets].filter((candidate) => {
+    const targetCandidates = actionTargets.filter((candidate) => {
         const key = workspaceExactTargetKey(candidate);
         if (seenTargetKeys.has(key))
             return false;
@@ -844,7 +701,13 @@ async function selectWorkspaceExactTarget(input, workspacePlanOverride, options
             status: "selected",
             workspacePlan,
             exactTargetPlan,
-            selectedTarget,
+            selectedTarget: {
+                ...selectedTarget,
+                // The workspace action chooses the structural target. The exact
+                // preflight owns the semantic action that the new fence is allowed to
+                // execute, so convergence comparisons must use its immutable binding.
+                actionKey: targetConfig.approvalInputs.expectedActionKey,
+            },
             targetConfig,
         };
     }
@@ -1878,7 +1741,6 @@ export async function executeRefillSendsCommand(input = {}) {
         if (isWorkspaceCoordinator && result.status === "terminal") {
             const resultReport = recordValue(result.report) ?? {};
             const coordinatorDirective = recordValue(resultReport.coordinatorDirective);
-            const laneExhaustion = recordValue(resultReport.laneExhaustion);
             const excludedTargets = Array.isArray(coordinatorDirective?.excludeTargets)
                 ? coordinatorDirective.excludeTargets
                     .map(recordValue)
@@ -1888,10 +1750,19 @@ export async function executeRefillSendsCommand(input = {}) {
                 }))
                     .filter((target) => Boolean(target.campaignId && target.tableId))
                 : [];
-            const nextSelection = await selectWorkspaceExactTarget(scopedInput, undefined, {
+            let nextSelection = await selectWorkspaceExactTarget(scopedInput, undefined, {
                 excludeTargets: excludedTargets,
-                preferredSenderId: stringValue(laneExhaustion?.senderId) ?? undefined,
             });
+            if (result.doneReason !== "loaded_awaiting_scheduler" &&
+                nextSelection.status === "selected" &&
+                sameWorkspaceExactAction(selectedCoordinatorTarget, nextSelection.selectedTarget)) {
+                // Avoid treating a single eventually-consistent reread as a blocker,
+                // but never create a new fence for the same action after it already
+                // terminalized. The second read is still mutation-free.
+                nextSelection = await selectWorkspaceExactTarget(scopedInput, undefined, {
+                    excludeTargets: excludedTargets,
+                });
+            }
             if (nextSelection.status === "complete") {
                 return {
                     ...command,
@@ -2019,6 +1890,29 @@ export async function executeRefillSendsCommand(input = {}) {
                     },
                 };
             }
+            if (sameWorkspaceExactAction(selectedCoordinatorTarget, nextSelection.selectedTarget)) {
+                return {
+                    ...command,
+                    ok: false,
+                    status: "blocked",
+                    code: "exact_target_terminal_no_progress",
+                    blocker: "exact_target_terminal_no_progress",
+                    note: "The exact run terminalized, but two fresh preflights selected the same campaign/table/sender/lane action. No identical fence was reopened.",
+                    targetPlan: nextSelection.workspacePlan,
+                    exactTargetPlan: nextSelection.exactTargetPlan,
+                    coordinator: {
+                        scope: "workspace",
+                        status: "blocked",
+                        completedTarget: selectedCoordinatorTarget,
+                        selectedTarget: nextSelection.selectedTarget,
+                        exactRunResult: result,
+                    },
+                    continuation: {
+                        required: false,
+                        userActionRequired: false,
+                    },
+                };
+            }
             return {
                 ...command,
                 status: "in_progress",

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

@@ -383,7 +383,7 @@ function sanitizeActionCandidates(candidates, selectedKeys, paidRefreshNeededSen
             const key = senderActionKey(item.senderId, allowed);
             return Boolean(key && selectedKeys.has(key));
         })
-            .map(sanitizeActionCandidate)
+            .map((candidate) => sanitizeActionCandidate(candidate, selectedKeys))
         : [];
     if (status === "awaiting_scheduler_after_ready_buffer" &&
         remainingProjectedGap > 0 &&
@@ -396,7 +396,7 @@ function sanitizeActionCandidates(candidates, selectedKeys, paidRefreshNeededSen
     }
     return filtered;
 }
-function sanitizeActionCandidate(candidate) {
+function sanitizeActionCandidate(candidate, selectedKeys) {
     const primary = decodeRefillReadinessIdentity(candidate.readinessIdentity);
     const readinessIdentities = Array.isArray(candidate.readinessIdentities)
         ? candidate.readinessIdentities.flatMap((identity) => {
@@ -404,14 +404,41 @@ function sanitizeActionCandidate(candidate) {
             return decoded.ok ? [decoded.value] : [];
         })
         : [];
+    const actionType = allowedActionType(candidate.actionType);
+    const campaignId = stringValue(candidate.campaignId);
+    const tableId = stringValue(candidate.tableId);
+    const sharedLane = isRecord(candidate.sharedLane)
+        ? candidate.sharedLane
+        : null;
+    const candidateSenderIds = [
+        ...new Set([
+            ...stringArray(sharedLane?.memberSenderIds),
+            ...(stringValue(candidate.senderId)
+                ? [stringValue(candidate.senderId)]
+                : []),
+        ]),
+    ]
+        .filter((senderId) => actionType && selectedKeys.has(`${senderId}:${actionType}`))
+        .sort();
+    const exactTargets = campaignId && tableId && actionType && candidateSenderIds.length > 0
+        ? [
+            {
+                campaignId,
+                tableId,
+                senderIds: candidateSenderIds,
+                refillLaneKey: actionType,
+                branchActionTypes: [actionType],
+            },
+        ]
+        : [];
     return {
         type: candidate.type,
         senderId: stringValue(candidate.senderId),
         senderName: stringValue(candidate.senderName),
-        actionType: stringValue(candidate.actionType),
-        campaignId: stringValue(candidate.campaignId),
+        actionType,
+        campaignId,
         campaignName: stringValue(candidate.campaignName),
-        tableId: stringValue(candidate.tableId),
+        tableId,
         tableName: stringValue(candidate.tableName) ?? null,
         columnId: stringValue(candidate.columnId) ?? null,
         sourceLeadListId: stringValue(candidate.sourceLeadListId) ?? null,
@@ -444,8 +471,40 @@ function sanitizeActionCandidate(candidate) {
         effectId: stringValue(candidate.effectId),
         targetShapeRevision: stringValue(candidate.targetShapeRevision),
         stateRevision: stringValue(candidate.stateRevision),
+        exactTargets,
     };
 }
+function sanitizeExactTargets(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .slice(0, REFILL_SCHEDULER_EXPECTED_TARGET_LIMIT)
+        .flatMap((raw) => {
+        if (!isRecord(raw))
+            return [];
+        const campaignId = stringValue(raw.campaignId)?.trim();
+        const tableId = stringValue(raw.tableId)?.trim();
+        const refillLaneKey = allowedActionType(raw.refillLaneKey ?? raw.actionType);
+        const senderIds = sortedUniqueStrings(raw.senderIds);
+        const branchActionTypes = sortedUniqueStrings(raw.branchActionTypes).filter((actionType) => SCHEDULER_EXPECTED_BRANCH_ACTION_TYPES.has(actionType));
+        if (!campaignId ||
+            !tableId ||
+            !refillLaneKey ||
+            senderIds.length === 0 ||
+            branchActionTypes.length === 0) {
+            return [];
+        }
+        return [
+            {
+                campaignId,
+                tableId,
+                senderIds,
+                refillLaneKey,
+                branchActionTypes,
+            },
+        ];
+    });
+}
 function sanitizeRowSelector(value) {
     if (!isRecord(value) || typeof value.type !== "string")
         return undefined;
@@ -840,6 +899,7 @@ function sanitizeStructuredAction(action, selectedBySender, mode, rank) {
             ...sanitizeToolInput(action.toolInput, authority),
             ...(providerSearchReference ? { providerSearchReference } : {}),
         },
+        exactTargets: sanitizeExactTargets(action.exactTargets),
         inputSummary: stringValue(action.inputSummary) ?? "",
         reason: stringValue(action.reason) ?? "",
         refillReceipt: sanitizeRefillReceipt(action.refillReceipt),
@@ -1182,13 +1242,78 @@ function sanitizeStructuredSenderPlans(value, selectedBySender) {
     });
 }
 function buildSanitizedGlobalActionQueue(senderRefillPlans) {
-    return senderRefillPlans
-        .flatMap((plan) => Array.isArray(plan.nextActions) ? plan.nextActions.slice(0, 1) : [])
-        .filter((action) => isRecord(action))
-        .map((action, index) => ({
-        ...action,
-        rank: index + 1,
-    }));
+    const entries = senderRefillPlans.flatMap((plan) => Array.isArray(plan.nextActions)
+        ? plan.nextActions
+            .slice(0, 1)
+            .filter((action) => isRecord(action))
+            .map((action) => ({ plan, action }))
+        : []);
+    const signatureFor = (action) => {
+        const ids = isRecord(action.ids) ? action.ids : {};
+        const campaignId = stringValue(ids.campaignId);
+        const tableId = stringValue(ids.tableId);
+        const actionType = allowedActionType(action.actionType);
+        const actionKey = stringValue(action.actionKey);
+        if (!campaignId || !tableId || !actionType || !actionKey)
+            return null;
+        return JSON.stringify([
+            action.type,
+            actionKey,
+            campaignId,
+            tableId,
+            actionType,
+        ]);
+    };
+    const senderIdsBySignature = new Map();
+    for (const { plan, action } of entries) {
+        const signature = signatureFor(action);
+        const senderId = stringValue(plan.senderId);
+        if (!signature || !senderId)
+            continue;
+        const senderIds = senderIdsBySignature.get(signature) ?? new Set();
+        senderIds.add(senderId);
+        senderIdsBySignature.set(signature, senderIds);
+    }
+    const seen = new Set();
+    return entries
+        .filter(({ action }) => {
+        const signature = signatureFor(action);
+        if (!signature)
+            return true;
+        if (seen.has(signature))
+            return false;
+        seen.add(signature);
+        return true;
+    })
+        .map(({ action }, index) => {
+        const signature = signatureFor(action);
+        const ids = isRecord(action.ids) ? action.ids : {};
+        const actionType = allowedActionType(action.actionType);
+        const senderIds = signature
+            ? [...(senderIdsBySignature.get(signature) ?? [])]
+            : [];
+        senderIds.sort();
+        const exactTargets = signature &&
+            actionType &&
+            stringValue(ids.campaignId) &&
+            stringValue(ids.tableId) &&
+            senderIds.length > 0
+            ? [
+                {
+                    campaignId: stringValue(ids.campaignId),
+                    tableId: stringValue(ids.tableId),
+                    senderIds,
+                    refillLaneKey: actionType,
+                    branchActionTypes: [actionType],
+                },
+            ]
+            : sanitizeExactTargets(action.exactTargets);
+        return {
+            ...action,
+            exactTargets,
+            rank: index + 1,
+        };
+    });
 }
 function sortedUniqueStrings(value) {
     return [...new Set(stringArray(value))].sort();
@@ -1387,6 +1512,7 @@ function sanitizeTargetSchedulerSweep(params) {
                     ? refillReadinessExpectationInput(authority)
                     : {}),
             },
+            exactTargets: expectedTargets,
             inputSummary: stringValue(rawAction.inputSummary) ?? "",
             reason: stringValue(rawAction.reason) ?? "",
             prerequisites: stringArray(rawAction.prerequisites),

package/package.json

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