@sellable/mcp 0.1.614 → 0.1.615-wip.121.2

package/dist/refill-run-loop.js

@@ -470,8 +470,67 @@ function selectedLaneAuthority(plan, action) {
         planRevision: stringValue(plan.planRevision),
     };
 }
+const PROVIDER_SAVED_SEARCH_OUTCOME_CLASSES = new Set([
+    "stale_packet_replan",
+    "source_terminal",
+    "authorization_blocker",
+    "capacity",
+    "transient",
+    "uncertain_effect",
+    "executed",
+]);
+function providerSavedSearchOutcome(value) {
+    const envelope = recordValue(value) ?? {};
+    const result = recordValue(envelope.result) ?? {};
+    const typedCandidate = recordValue(envelope.providerOutcome) ??
+        recordValue(result.providerOutcome) ??
+        (PROVIDER_SAVED_SEARCH_OUTCOME_CLASSES.has(stringValue(envelope.class) ?? "")
+            ? envelope
+            : null);
+    const legacyJobId = stringValue(recordValue(result.importResult)?.jobId) ??
+        stringValue(result.jobId);
+    const candidate = typedCandidate ??
+        (stringValue(envelope.status) === "executed_and_reread" && legacyJobId
+            ? {
+                class: "executed",
+                code: "provider_job_started",
+                detail: "Compatibility-normalized confirmed provider job receipt.",
+                jobId: legacyJobId,
+                facts: { jobId: legacyJobId },
+            }
+            : null);
+    const outcomeClass = stringValue(candidate?.class);
+    return outcomeClass && PROVIDER_SAVED_SEARCH_OUTCOME_CLASSES.has(outcomeClass)
+        ? candidate
+        : null;
+}
+function providerPreExecutorOutcome(action) {
+    return providerSavedSearchOutcome(action.preExecutorOutcome);
+}
+function providerActionIdentity(action) {
+    return {
+        actionKey: stringValue(action.actionKey),
+        effectId: stringValue(action.effectId) ??
+            stringValue(actionToolInput(action).effectId),
+    };
+}
+function providerAttemptMatchesAction(attempt, action) {
+    const identity = providerActionIdentity(action);
+    return Boolean(identity.actionKey &&
+        identity.effectId &&
+        stringValue(attempt.actionKey) === identity.actionKey &&
+        stringValue(attempt.effectId) === identity.effectId);
+}
 function laneExhaustionReason(action, outcome) {
     const type = stringValue(action.type);
+    if (type &&
+        (PROVIDER_SOURCE_CONTINUATION_TYPES.has(type) ||
+            BROADEN_PROVIDER_SEARCH_TYPES.has(type))) {
+        const providerOutcome = providerSavedSearchOutcome(outcome);
+        return stringValue(providerOutcome?.class) === "source_terminal"
+            ? (stringValue(providerOutcome?.code) ?? "provider_source_terminal")
+            : null;
+    }
     if (type === "next_campaign") {
         return (stringValue(recordValue(actionToolInput(action).laneAdvance)?.reason) ??
             "fresh_planner_requested_lane_advance");
@@ -553,30 +612,27 @@ const PROVIDER_SOURCE_CONTINUATION_TYPES = new Set([
     "continue_prospeo_source",
 ]);
 function hasRunScopedProviderSourceAttempt(action, runState) {
-    const campaignId = actionCampaignId(action);
-    const senderId = actionSenderId(action);
-    if (!campaignId)
-        return false;
     return arrayValue(runState.providerSourceAttempts)
         .filter(isRecord)
-        .some((attempt) => stringValue(attempt.campaignId) === campaignId &&
-        stringValue(attempt.senderId) === senderId);
+        .some((attempt) => providerAttemptMatchesAction(attempt, action));
 }
 function runScopedProviderSourceAttemptUpdate(action, runState, now) {
     const campaignId = actionCampaignId(action);
     const senderId = actionSenderId(action);
-    if (!campaignId)
+    const identity = providerActionIdentity(action);
+    if (!campaignId || !identity.actionKey || !identity.effectId)
         return {};
     const attempts = arrayValue(runState.providerSourceAttempts).filter(isRecord);
     return {
         providerSourceAttempts: [
-            ...attempts.filter((attempt) => stringValue(attempt.campaignId) !== campaignId ||
-                stringValue(attempt.senderId) !== senderId),
+            ...attempts.filter((attempt) => !providerAttemptMatchesAction(attempt, action)),
             {
+                ...identity,
                 campaignId,
                 senderId,
                 provider: stringValue(actionToolInput(action).provider),
                 sourceFingerprint: actionSourceFingerprint(action),
+                outcomeClass: stringValue(providerSavedSearchOutcome(runState.lastOutcome)?.class) ?? stringValue(providerPreExecutorOutcome(action)?.class),
                 attemptedAt: now.toISOString(),
                 scope: "refill_run",
             },
@@ -589,26 +645,26 @@ function runScopedProviderSourceAttemptUpdate(action, runState, now) {
 // second executor dispatch, mirroring the cold-continuation one-attempt bound.
 const BROADEN_PROVIDER_SEARCH_TYPES = new Set(["broaden_provider_search"]);
 function hasRunScopedBroadenProviderSearchAttempt(action, runState) {
-    const campaignId = actionCampaignId(action);
-    if (!campaignId)
-        return false;
     return arrayValue(runState.broadenProviderSearchAttempts)
         .filter(isRecord)
-        .some((attempt) => stringValue(attempt.campaignId) === campaignId);
+        .some((attempt) => providerAttemptMatchesAction(attempt, action));
 }
 function runScopedBroadenProviderSearchAttemptUpdate(action, runState, now) {
     const campaignId = actionCampaignId(action);
-    if (!campaignId)
+    const identity = providerActionIdentity(action);
+    if (!campaignId || !identity.actionKey || !identity.effectId)
         return {};
     const attempts = arrayValue(runState.broadenProviderSearchAttempts).filter(isRecord);
     return {
         broadenProviderSearchAttempts: [
-            ...attempts.filter((attempt) => stringValue(attempt.campaignId) !== campaignId),
+            ...attempts.filter((attempt) => !providerAttemptMatchesAction(attempt, action)),
             {
+                ...identity,
                 campaignId,
                 senderId: actionSenderId(action),
                 provider: stringValue(actionToolInput(action).provider),
                 sourceFingerprint: actionSourceFingerprint(action),
+                outcomeClass: stringValue(providerSavedSearchOutcome(runState.lastOutcome)?.class) ?? stringValue(providerPreExecutorOutcome(action)?.class),
                 attemptedAt: now.toISOString(),
                 scope: "refill_run",
             },
@@ -1263,6 +1319,9 @@ function noProgressSignature(plan, action) {
             actionCampaignId(action),
             actionTableId(action),
             actionSenderId(action),
+            stringValue(action.actionKey),
+            stringValue(action.effectId) ??
+                stringValue(actionToolInput(action).effectId),
         ]
             .filter(Boolean)
             .join(":"),
@@ -1963,7 +2022,42 @@ async function gateExecute(input, deps, ctx) {
         `${ctx.runId}:${ctx.gateSeq}`;
     let did;
     let outcome;
-    if (action.type === "continue_signal_discovery_source" &&
+    const preExecutorProviderOutcome = providerPreExecutorOutcome(action);
+    const repeatedProviderAttempt = (typeof action.type === "string" &&
+        PROVIDER_SOURCE_CONTINUATION_TYPES.has(action.type) &&
+        hasRunScopedProviderSourceAttempt(action, ctx.runState)) ||
+        (typeof action.type === "string" &&
+            BROADEN_PROVIDER_SEARCH_TYPES.has(action.type) &&
+            hasRunScopedBroadenProviderSearchAttempt(action, ctx.runState));
+    if (preExecutorProviderOutcome && repeatedProviderAttempt) {
+        const providerOutcome = {
+            class: "stale_packet_replan",
+            code: "provider_action_effect_already_attempted",
+            detail: "This actionKey/effectId already owns a recorded provider attempt in the fenced run.",
+            facts: {
+                ...providerActionIdentity(action),
+                campaignId: actionCampaignId(action),
+                senderId: actionSenderId(action),
+            },
+        };
+        did = {
+            status: "refused",
+            refusalReason: `${providerOutcome.code}: ${providerOutcome.detail}`,
+            providerOutcome,
+            result: { providerOutcome },
+        };
+        outcome = did;
+    }
+    else if (preExecutorProviderOutcome) {
+        did = {
+            status: "refused",
+            refusalReason: `${String(preExecutorProviderOutcome.code)}: ${String(preExecutorProviderOutcome.detail)}`,
+            providerOutcome: preExecutorProviderOutcome,
+            result: { providerOutcome: preExecutorProviderOutcome },
+        };
+        outcome = did;
+    }
+    else if (action.type === "continue_signal_discovery_source" &&
         hasRunScopedSignalDiscoveryAttempt(action, ctx.runState)) {
         did = {
             status: "refused",
@@ -1985,6 +2079,12 @@ async function gateExecute(input, deps, ctx) {
         did = {
             status: "refused",
             refusalReason: "same-provider-source continuation already used its bounded run-scoped add without closing projected coverage",
+            providerOutcome: {
+                class: "stale_packet_replan",
+                code: "provider_action_effect_already_attempted",
+                detail: "This actionKey/effectId already owns a recorded provider continuation attempt.",
+                facts: providerActionIdentity(action),
+            },
             result: {
                 scope: "refill_run",
                 campaignId: actionCampaignId(action),
@@ -2002,6 +2102,12 @@ async function gateExecute(input, deps, ctx) {
         did = {
             status: "refused",
             refusalReason: "provider search broadening already used its bounded run-scoped notch for this campaign without closing projected coverage",
+            providerOutcome: {
+                class: "stale_packet_replan",
+                code: "provider_action_effect_already_attempted",
+                detail: "This actionKey/effectId already owns a recorded provider broadening attempt.",
+                facts: providerActionIdentity(action),
+            },
             result: {
                 scope: "refill_run",
                 blocker: "broaden_provider_search_refused",
@@ -3157,20 +3263,32 @@ async function gateVerify(input, deps, ctx, budgets) {
         // the universeExhausted marker alongside the lane advance so any later broaden
         // emission this run is fenced and the planner reads a receipt-proven terminal.
         const runStateForExhaustion = typeof actionType === "string" &&
-            BROADEN_SIGNAL_SEARCH_TYPES.has(actionType)
+            PROVIDER_SOURCE_CONTINUATION_TYPES.has(actionType)
             ? {
                 ...ctx.runState,
-                ...runScopedBroadenSignalSearchAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date(), {
-                    newPostCount: 0,
-                    universeExhausted: true,
-                    // feat(110-23d): a below-floor round at ANY tier proves the 45-day
-                    // universe cannot fill the gap — carry its keywordSource onto the
-                    // terminal marker.
-                    keywordSource: broadenSignalSearchKeywordSource(ctx.runState.lastOutcome),
-                    searchedKeywords: broadenSignalSearchKeywordsTried(ctx.runState.lastOutcome),
-                }),
+                ...runScopedProviderSourceAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date()),
             }
-            : ctx.runState;
+            : typeof actionType === "string" &&
+                BROADEN_PROVIDER_SEARCH_TYPES.has(actionType)
+                ? {
+                    ...ctx.runState,
+                    ...runScopedBroadenProviderSearchAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date()),
+                }
+                : typeof actionType === "string" &&
+                    BROADEN_SIGNAL_SEARCH_TYPES.has(actionType)
+                    ? {
+                        ...ctx.runState,
+                        ...runScopedBroadenSignalSearchAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date(), {
+                            newPostCount: 0,
+                            universeExhausted: true,
+                            // feat(110-23d): a below-floor round at ANY tier proves the 45-day
+                            // universe cannot fill the gap — carry its keywordSource onto the
+                            // terminal marker.
+                            keywordSource: broadenSignalSearchKeywordSource(ctx.runState.lastOutcome),
+                            searchedKeywords: broadenSignalSearchKeywordsTried(ctx.runState.lastOutcome),
+                        }),
+                    }
+                    : ctx.runState;
         const nextRunState = laneExhaustionRunState(exhaustionPlan, action, runStateForExhaustion, exhaustionReason, deps.now?.() ?? new Date());
         if (!nextRunState) {
             return {
@@ -3201,6 +3319,39 @@ async function gateVerify(input, deps, ctx, budgets) {
         });
         return advanceBackToPlan(input, deps, ctx, nextRunState);
     }
+    const typedProviderOutcome = typeof actionType === "string" &&
+        (PROVIDER_SOURCE_CONTINUATION_TYPES.has(actionType) ||
+            BROADEN_PROVIDER_SEARCH_TYPES.has(actionType))
+        ? providerSavedSearchOutcome(ctx.runState.lastOutcome)
+        : null;
+    const typedProviderClass = stringValue(typedProviderOutcome?.class);
+    if (typedProviderOutcome &&
+        typedProviderClass !== "executed" &&
+        typedProviderClass !== "source_terminal") {
+        const attemptUpdate = PROVIDER_SOURCE_CONTINUATION_TYPES.has(actionType ?? "")
+            ? runScopedProviderSourceAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date())
+            : runScopedBroadenProviderSearchAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date());
+        const advanced = await advanceBackToPlan(input, deps, ctx, attemptUpdate);
+        if (advanced)
+            return advanced;
+        if (typedProviderClass === "stale_packet_replan")
+            return null;
+        return {
+            status: "blocked",
+            blocker: `provider_${typedProviderClass ?? "unknown"}`,
+            runId: ctx.runId,
+            fence: ctx.fence,
+            gate: ctx.gate,
+            guidance: "The provider attempt did not prove a consumable source terminal. Preserve the same fenced run and resolve or replan from the typed outcome before any new effect identity is dispatched.",
+            report: {
+                actionKey: stringValue(action.actionKey),
+                effectId: stringValue(action.effectId) ??
+                    stringValue(actionToolInput(action).effectId),
+                providerOutcome: typedProviderOutcome,
+            },
+            journalPath: ctx.journalPath,
+        };
+    }
     if (actionType === "prepare_messages") {
         return verifyPrepareAction(input, deps, ctx, action, budgets);
     }
@@ -3222,8 +3373,8 @@ async function gateVerify(input, deps, ctx, budgets) {
     }
     if (typeof actionType === "string" &&
         PROVIDER_SOURCE_CONTINUATION_TYPES.has(actionType) &&
-        stringValue(recordValue(ctx.runState.lastOutcome)?.status) ===
-            "executed_and_reread") {
+        stringValue(providerSavedSearchOutcome(ctx.runState.lastOutcome)?.class) ===
+            "executed") {
         // Phase 110-05: record the bounded same-source add so the run does not
         // repeat it for this (campaign, sender) before replanning.
         return advanceBackToPlan(input, deps, ctx, {
@@ -3235,8 +3386,8 @@ async function gateVerify(input, deps, ctx, budgets) {
     }
     if (typeof actionType === "string" &&
         BROADEN_PROVIDER_SEARCH_TYPES.has(actionType) &&
-        stringValue(recordValue(ctx.runState.lastOutcome)?.status) ===
-            "executed_and_reread") {
+        stringValue(providerSavedSearchOutcome(ctx.runState.lastOutcome)?.class) ===
+            "executed") {
         // feat(110-23a): record the bounded one-notch broaden so the run does not
         // repeat it for this campaign, and clear the dry-source prep bound so a
         // genuine re-prep against the wider search's new rows can run on replan.

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

@@ -41,7 +41,50 @@ export type YoloPrimitiveAttempt = {
     status: "no_action" | "read_only_reread" | "executed_and_reread" | "refused";
     result?: unknown;
     refusalReason?: string;
+    providerOutcome?: ProviderSavedSearchOutcome;
 };
+export type ProviderSearchReference = {
+    workspaceId: string;
+    provider: "sales-nav" | "prospeo";
+    sourceTableId: string;
+    searchId: string;
+    resolutionOrigin: "config_import_job" | "exact_table_job" | "find_leads_run";
+    owner: {
+        kind: "campaign" | "find_leads_run";
+        id: string;
+    };
+    basisFingerprint: string;
+};
+type ProviderOutcomeBase = {
+    code: string;
+    detail: string;
+    facts: Record<string, unknown>;
+};
+export type ProviderSavedSearchOutcome = (ProviderOutcomeBase & {
+    class: "stale_packet_replan";
+}) | (ProviderOutcomeBase & {
+    class: "source_terminal";
+}) | (ProviderOutcomeBase & {
+    class: "authorization_blocker";
+    scope: "global" | "workspace";
+    status: 401 | 403;
+}) | (ProviderOutcomeBase & {
+    class: "capacity";
+}) | (ProviderOutcomeBase & {
+    class: "transient";
+    retryable: true;
+}) | (ProviderOutcomeBase & {
+    class: "uncertain_effect";
+}) | (ProviderOutcomeBase & {
+    class: "executed";
+    jobId: string;
+});
+/**
+ * The sole compact provider-lineage decoder used at both the MCP packet and
+ * executor boundaries. Legacy loose searchId/provider fields never satisfy
+ * this contract.
+ */
+export declare function sanitizeProviderSearchReference(value: unknown): ProviderSearchReference | null;
 export type UserAddedRowsLimitPayload = {
     error?: string;
     code: "USER_ADDED_ROWS_LIMIT_EXCEEDED";
@@ -297,32 +340,10 @@ export declare function continueSignalDiscoverySource(action: Record<string, unk
  * going until capacity fills.
  */
 export declare function broadenSignalSearch(action: Record<string, unknown>, workspaceId?: string): Promise<YoloPrimitiveAttempt>;
-/**
- * Phase 110-05: bounded SAME-provider-source continuation for cold-outbound
- * Sales Nav / Prospeo campaigns. Mirrors continueSignalDiscoverySource's
- * guardrails (campaign + provider + selected-source match) and reuses the
- * EXISTING import_leads tool to add leads from the campaign's own saved
- * provider search (mode "add") once eligible/prepared rows are receipt-proven
- * exhausted. It never switches source families and never creates a campaign.
- * The add is bounded by the packet's existing sourceRowLimit cap; when the
- * packet carries no reusable provider search reference the add cannot start
- * autonomously and the executor refuses with a bounded reason so the run
- * records the attempt instead of looping on an unchanged mutation.
- */
+type ProviderSavedSearchMode = "continuation" | "broadening";
+/** Shared continuation/broadening saved-search executor and classifier. */
+export declare function executeProviderSavedSearch(action: Record<string, unknown>, workspaceId: string | undefined, mode: ProviderSavedSearchMode): Promise<YoloPrimitiveAttempt>;
 export declare function continueProviderSource(action: Record<string, unknown>, workspaceId?: string): Promise<YoloPrimitiveAttempt>;
-/**
- * feat(110-23a): rung 3 of the automatic escalation ladder — bounded provider
- * search broadening. When rungs 1-2 (same-source refill + cold continuation) are
- * receipt-proven exhausted at the current search depth and schedulable capacity
- * remains, this re-runs the campaign's EXISTING provider saved search one bounded
- * notch wider. It does NOT invent provider filter semantics: the "notch" is a
- * deeper page/depth window on the SAME searchId, expressed as a larger bounded
- * targetLeadCount into the same saved search via the EXISTING import_leads path
- * continueProviderSource already uses (mode "add"). One notch per campaign per run
- * (the loop enforces the run-scoped bound). The receipt records prior depth, new
- * depth, and the widened window; the actual rows gained surface on the next replan.
- * Never switches source families, never creates a campaign, never sends.
- */
 export declare function broadenProviderSearch(action: Record<string, unknown>, workspaceId?: string): Promise<YoloPrimitiveAttempt>;
 /**
  * feat(110-23b): rung 4 of the automatic escalation ladder — bounded, reversible