@sellable/mcp 0.1.757 → 0.1.758

package/dist/refill-run-loop.js

@@ -893,6 +893,39 @@ function runScopedSignalDiscoveryAttemptUpdate(action, runState, now) {
         ],
     };
 }
+function runScopedSignalSourceValidationUpdate(action, runState, now) {
+    const toolInput = actionToolInput(action);
+    const provider = stringValue(toolInput.leadSourceProvider);
+    if (provider !== "signal-discovery" && provider !== "campaign-tracked-post") {
+        return {};
+    }
+    const campaignId = actionCampaignId(action);
+    const payload = resultPayload(runState.lastOutcome);
+    const reviewBatch = recordValue(payload.reviewBatch);
+    const reviewBatchBasisHash = stringValue(reviewBatch?.basisHash);
+    const reviewBatchRowCount = numberValue(reviewBatch?.rowCount);
+    if (!campaignId || !reviewBatchBasisHash || !reviewBatchRowCount)
+        return {};
+    const attempts = arrayValue(runState.signalSourceValidationAttempts).filter(isRecord);
+    return {
+        signalSourceValidationAttempts: [
+            ...attempts.filter((attempt) => stringValue(attempt.campaignId) !== campaignId),
+            {
+                campaignId,
+                tableId: actionTableId(action),
+                senderId: actionSenderId(action),
+                sourceLeadListId: stringValue(toolInput.sourceLeadListId),
+                sourceFingerprint: actionSourceFingerprint(action),
+                reviewBatchBasisHash,
+                reviewBatchRowCount,
+                threshold: 0.1,
+                status: "pending",
+                copiedAt: now.toISOString(),
+                scope: "refill_run",
+            },
+        ],
+    };
+}
 // Phase 110-05: Sales Nav / Prospeo same-source continuation gets exactly one
 // bounded add per (campaign, sender) per run, mirroring the Signal Discovery
 // run-scoped attempt bound so the loop never repeats an unchanged failed
@@ -4513,6 +4546,14 @@ async function gateVerify(input, deps, ctx, budgets) {
     // keep going — instead of terminalizing the invite lane with confirmed-fillable
     // slots still open. Once a broadening round proves the universe dry this run, this
     // no longer intercepts and the refusal terminalizes typed below.
+    if (actionType === "copy_selected_source_rows" &&
+        stringValue(recordValue(ctx.runState.lastOutcome)?.status) ===
+            "executed_and_reread") {
+        return advanceBackToPlan(input, deps, ctx, {
+            ...runScopedSignalSourceValidationUpdate(action, ctx.runState, deps.now?.() ?? new Date()),
+            ...clearRunScopedDrySourcePrepAttempts(actionCampaignId(action), ctx.runState),
+        });
+    }
     if (actionType === "continue_signal_discovery_source" &&
         isSignalSelectionBroadenableRefusal(ctx.runState.lastOutcome) &&
         !hasRunScopedSignalUniverseExhausted(action, ctx.runState)) {

package/dist/tools/campaign-message-preparation.d.ts

@@ -12,6 +12,7 @@ type RowSelector = {
 } | {
     type: "reviewBatch";
     limit?: number;
+    basisHash?: string;
 } | {
     type: "staleGeneratedMessages";
     limit?: number;
@@ -121,6 +122,11 @@ export declare const campaignMessagePreparationToolDefinitions: ({
                         minimum: number;
                         maximum: number;
                     };
+                    basisHash: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
                     rowIds: {
                         type: string;
                         items: {

package/dist/tools/campaign-message-preparation.js

@@ -75,6 +75,7 @@ export const campaignMessagePreparationToolDefinitions = [
                             ],
                         },
                         limit: { type: "number", minimum: 1, maximum: 500 },
+                        basisHash: { type: "string", minLength: 1, maxLength: 200 },
                         rowIds: {
                             type: "array",
                             items: { type: "string", minLength: 1 },

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

@@ -120,6 +120,7 @@ export type PrepareRowSelector = {
 } | {
     type: "reviewBatch";
     limit?: number;
+    basisHash?: string;
 } | {
     type: "staleGeneratedMessages";
     limit?: number;

package/dist/tools/refill-executors.js

@@ -450,9 +450,11 @@ export function prepareRowSelectorValue(value) {
         return undefined;
     }
     const limit = numberValue(selector?.limit);
+    const basisHash = type === "reviewBatch" ? stringValue(selector?.basisHash) : null;
     return {
         type,
         ...(limit && limit > 0 ? { limit: Math.floor(limit) } : {}),
+        ...(type === "reviewBatch" && basisHash ? { basisHash } : {}),
     };
 }
 export function uniqueStrings(values) {
@@ -1052,7 +1054,9 @@ export function refillPrepareRequestHash(params) {
             ? `rowIds:${createHash("sha256")
                 .update(JSON.stringify([...params.rowSelector.rowIds].sort()))
                 .digest("hex")}`
-            : `${params.rowSelector.type}:${params.rowSelector.limit ?? "no-limit"}`
+            : params.rowSelector.type === "reviewBatch"
+                ? `reviewBatch:${params.rowSelector.limit ?? "no-limit"}:${params.rowSelector.basisHash ?? "no-basis"}`
+                : `${params.rowSelector.type}:${params.rowSelector.limit ?? "no-limit"}`
         : "no-row-selector";
     // Request hashes are persisted in the preparation job's normalized config.
     // Keep the public identity fixed-width: the former concatenated form could
@@ -3221,6 +3225,16 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
             const allowPartialSourceList = toolInput.allowPartialSourceList === true;
             const sourceFingerprint = stringValue(toolInput.sourceFingerprint) ??
                 stringValue(actionIds(action).sourceFingerprint);
+            const signalSource = actionLeadSourceProvider(action) === "signal-discovery" ||
+                actionLeadSourceProvider(action) === "campaign-tracked-post";
+            const requestedReviewBatchLimit = sourceRowIds.length > 0
+                ? sourceRowIds.length
+                : (sourceRowLimit ?? undefined);
+            const reviewBatchLimit = requestedReviewBatchLimit
+                ? signalSource
+                    ? Math.min(15, requestedReviewBatchLimit)
+                    : requestedReviewBatchLimit
+                : undefined;
             if (!campaignOfferId || !sourceLeadListId || !sourceFingerprint) {
                 return {
                     status: "refused",
@@ -3248,9 +3262,7 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 ...(workspaceId ? { workspaceId } : {}),
                 sourceRowIds: sourceRowIds.length > 0 ? sourceRowIds : undefined,
                 sourceRowLimit: sourceRowIds.length > 0 ? undefined : (sourceRowLimit ?? undefined),
-                reviewBatchLimit: sourceRowIds.length > 0
-                    ? sourceRowIds.length
-                    : (sourceRowLimit ?? undefined),
+                reviewBatchLimit,
                 ...(allowPartialSourceList ? { allowPartialSourceList: true } : {}),
             };
             let result;
@@ -3288,16 +3300,19 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 const retrySourceRowLimit = retrySourceRowIds.length > 0
                     ? undefined
                     : Math.min(sourceRowLimit ?? remainingRows, remainingRows);
-                const retryReviewBatchLimit = retrySourceRowIds.length > 0
+                const retryCopyLimit = retrySourceRowIds.length > 0
                     ? retrySourceRowIds.length
                     : retrySourceRowLimit;
-                if (!retryReviewBatchLimit || retryReviewBatchLimit <= 0) {
+                if (!retryCopyLimit || retryCopyLimit <= 0) {
                     return {
                         status: "refused",
                         refusalReason: rowLimitPayload.error ??
                             "selected campaign table cannot accept more workflow rows",
                     };
                 }
+                const retryReviewBatchLimit = signalSource
+                    ? Math.min(15, retryCopyLimit)
+                    : retryCopyLimit;
                 const retryResult = await confirmLeadList({
                     ...copyInput,
                     sourceRowIds: retrySourceRowIds.length > 0 ? retrySourceRowIds : undefined,

package/dist/tools/refill-sends.js

@@ -247,6 +247,7 @@ const WORKSPACE_ATTEMPT_LEDGER_KEYS = [
     "signalDiscoveryAttempts",
     "providerSourceAttempts",
     "broadenSignalSearchAttempts",
+    "signalSourceValidationAttempts",
     "broadenProviderSearchAttempts",
     "rubricRelaxationAttempts",
     "senderPostRefreshAttempts",
@@ -790,8 +791,29 @@ function sameWorkspaceExactAction(left, right) {
         Boolean(left?.actionKey) &&
         left?.actionKey === right.actionKey);
 }
+function coordinatorSenderIds(input) {
+    const explicit = normalizeStrings(input.senderIds);
+    if (explicit.length > 0)
+        return explicit;
+    const targetConfigSenderIds = normalizeStrings(input.targetConfig?.senderScope.senderIds);
+    if (targetConfigSenderIds.length > 0)
+        return targetConfigSenderIds;
+    const runState = recordValue(input.workspaceRunState);
+    const senderCursors = Array.isArray(runState?.senderCursors)
+        ? runState.senderCursors
+        : [];
+    return normalizeStrings(senderCursors
+        .map((entry) => stringValue(recordValue(entry)?.senderId))
+        .filter((senderId) => Boolean(senderId)));
+}
 function workspaceCoordinatorInput(input) {
     const coordinatorInput = { ...input };
+    const senderIds = coordinatorSenderIds(input);
+    if (senderIds.length > 0) {
+        coordinatorInput.senderIds = senderIds;
+        coordinatorInput.senders = [];
+        coordinatorInput.senderNames = [];
+    }
     delete coordinatorInput.campaignId;
     delete coordinatorInput.tableId;
     delete coordinatorInput.runId;
@@ -843,7 +865,9 @@ function withKeywordsHandoffScope(result, scopedInput) {
         (handleRunId && typeof handleFence === "number"
             ? { runId: handleRunId, fence: handleFence }
             : null);
+    const senderIds = coordinatorSenderIds(scopedInput);
     const scopeAdditions = {
+        ...(senderIds.length > 0 ? { senderIds } : {}),
         ...(scopedInput.targetDate ? { targetDate: scopedInput.targetDate } : {}),
         ...(scopedInput.untilDate ? { untilDate: scopedInput.untilDate } : {}),
         ...(typeof scopedInput.horizonSendDays === "number"
@@ -4150,7 +4174,7 @@ export async function executeRefillSendsCommand(input = {}) {
             intent: targetConfigIntent(continuationTargetConfig) ??
                 scopedInput.intent ??
                 "auto",
-            senderIds: normalizeStrings(scopedInput.senderIds),
+            senderIds: coordinatorSenderIds(scopedInput),
             ...(scopedInput.actionTypes
                 ? { actionTypes: scopedInput.actionTypes }
                 : {}),

package/dist/tools/registry.d.ts

@@ -6453,6 +6453,11 @@ export declare const allTools: ({
                         minimum: number;
                         maximum: number;
                     };
+                    basisHash: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
                     rowIds: {
                         type: string;
                         items: {

package/package.json

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