@sellable/mcp 0.1.558 → 0.1.560

package/dist/refill-run-loop.js

@@ -361,11 +361,17 @@ function actionSenderId(action) {
 }
 function fingerprintFromPlan(plan) {
     const packet = recordValue(plan.packet) ?? {};
+    const targetShapeRevision = stringValue(packet.targetShapeRevision) ??
+        stringValue(packet.targetRevision) ??
+        stringValue(plan.targetShapeRevision) ??
+        stringValue(plan.targetRevision);
     return {
-        planRevision: stringValue(plan.planRevision),
+        // Evergreen packets carry their own semantic plan revision. Regular
+        // active-campaign packets intentionally do not, so their immutable target
+        // shape is the durable planning revision for fencing and recovery.
+        planRevision: stringValue(plan.planRevision) ?? targetShapeRevision,
         stateRevision: stringValue(plan.stateRevision) ?? stringValue(packet.stateRevision),
-        targetShapeRevision: stringValue(packet.targetShapeRevision) ??
-            stringValue(packet.targetRevision),
+        targetShapeRevision,
     };
 }
 function fingerprintChanged(expected, actual) {
@@ -1021,6 +1027,23 @@ async function gatePlan(input, deps, ctx) {
         fallbackSummary: line.fallbackSummary,
     }));
     const fingerprint = fingerprintFromPlan(plan);
+    const approvedTargetShapeRevision = stringValue(input.approval?.targetShapeRevision);
+    if (approvedTargetShapeRevision &&
+        approvedTargetShapeRevision !== fingerprint.targetShapeRevision) {
+        return {
+            status: "blocked",
+            blocker: "scope_drift",
+            runId: ctx.runId,
+            fence: ctx.fence,
+            gate: ctx.gate,
+            guidance: "The canonical refill target shape changed after approval; render a new packet before another primitive.",
+            report: {
+                approvedTargetShapeRevision,
+                freshTargetShapeRevision: fingerprint.targetShapeRevision,
+            },
+            journalPath: ctx.journalPath,
+        };
+    }
     const persistedCircuit = recordValue(runStateProgress(ctx).prepCircuit);
     if (stringValue(action.type) === "prepare_messages" &&
         openCircuitWaits(persistedCircuit, deps.now?.() ?? new Date())) {

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

@@ -167,6 +167,17 @@ export declare function prepareRefillSendsV2Approval(input: RefillV2ApprovalPrep
     response?: undefined;
 }>;
 export declare function refillSendsV2Command(input: RefillSendsV2Input): Promise<{
+    status: "blocked";
+    blocker: "approval_expired" | "approval_fingerprint_mismatch";
+    guidance: string;
+    report: {
+        fresh?: {} | null | undefined;
+        changed: string[];
+    };
+    readOnly: boolean;
+    forbiddenActions: string[];
+    boundedAuthority: string;
+} | {
     readOnly: boolean;
     mode: string;
     forbiddenActions: string[];

package/dist/tools/refill-sends-v2.js

@@ -325,7 +325,11 @@ function validateApprovalEcho(envelope, echo, now = new Date()) {
     ];
     const changed = fields.filter((field) => echo[field] !== envelope.approval[field]);
     if (Date.parse(envelope.approval.approvalExpiresAt) <= now.getTime()) {
-        return { ok: false, blocker: "approval_expired", changed };
+        return {
+            ok: false,
+            blocker: "approval_expired",
+            changed,
+        };
     }
     return changed.length === 0
         ? { ok: true }
@@ -335,6 +339,85 @@ function validateApprovalEcho(envelope, echo, now = new Date()) {
             changed,
         };
 }
+function blockedApprovalResult(params) {
+    return {
+        status: "blocked",
+        blocker: params.blocker,
+        guidance: "The durable refill approval no longer matches its persisted scope; render and approve a new packet before mutation.",
+        report: {
+            changed: params.changed,
+            ...(params.fresh === undefined ? {} : { fresh: params.fresh }),
+        },
+        readOnly: false,
+        forbiddenActions: FORBIDDEN_ACTIONS,
+        boundedAuthority: BOUNDED_AUTHORITY,
+    };
+}
+function storedApprovalFromStatus(value) {
+    const status = record(value) ?? {};
+    const config = record(status.config);
+    const scope = record(config?.scope);
+    const approval = record(config?.approval);
+    const scopeHash = text(config?.scopeHash);
+    if (!config || !scope || !approval || !scopeHash)
+        return null;
+    return {
+        config,
+        scope,
+        scopeHash,
+        approval,
+        hasDispatched: status.hasDispatched === true,
+    };
+}
+function validateStoredApprovalEcho(params) {
+    const fields = [
+        "scopeHash",
+        "targetShapeRevision",
+        "actionFingerprint",
+        "expectedTargetsHash",
+        "approvalExpiresAt",
+        "approvalFingerprint",
+    ];
+    const changed = fields.filter((field) => text(params.approval[field]) !== params.echo[field]);
+    const expiresAt = text(params.approval.approvalExpiresAt);
+    if (!params.allowExpired &&
+        (!expiresAt ||
+            Date.parse(expiresAt) <= (params.now ?? new Date()).getTime())) {
+        return {
+            ok: false,
+            blocker: "approval_expired",
+            changed,
+        };
+    }
+    return changed.length === 0
+        ? { ok: true }
+        : {
+            ok: false,
+            blocker: "approval_fingerprint_mismatch",
+            changed,
+        };
+}
+function executionScopeFromStored(scope, fallback) {
+    const dateSelector = record(scope.dateSelector) ?? {};
+    const kind = text(dateSelector.kind);
+    const senderIds = list(scope.senderIds)
+        .map((value) => text(value))
+        .filter((value) => value != null);
+    const approvalMode = scope.approvalMode === "mark_ready" ? "mark_ready" : "approve";
+    return {
+        intent: text(scope.intent) ?? fallback.intent,
+        senderIds,
+        approvalMode,
+        ...(kind === "target_date" && text(dateSelector.targetDate)
+            ? { targetDate: text(dateSelector.targetDate) }
+            : kind === "until_date" && text(dateSelector.untilDate)
+                ? { untilDate: text(dateSelector.untilDate) }
+                : kind === "horizon_send_days" &&
+                    typeof dateSelector.horizonSendDays === "number"
+                    ? { horizonSendDays: dateSelector.horizonSendDays }
+                    : {}),
+    };
+}
 async function maybeAddLostFenceGuidance(result, input) {
     if (result.status !== "blocked" ||
         result.blocker !== "lease_lost" ||
@@ -365,7 +448,53 @@ export async function refillSendsV2Command(input) {
     let resolvedScope = input.scope;
     let resolvedScopeHash = input.scopeHash;
     let resolvedApproval = input.approval;
-    if (input.targetPlan && input.approvalEcho) {
+    if (input.runId && input.approvalEcho) {
+        const status = await refillRunStatus({ workspaceId, runId: input.runId });
+        const stored = storedApprovalFromStatus(status);
+        if (!stored) {
+            return {
+                status: "blocked",
+                blocker: "approval_run_unavailable",
+                guidance: "The durable refill run no longer exposes a valid persisted approval packet.",
+                report: { status },
+                readOnly: false,
+                forbiddenActions: FORBIDDEN_ACTIONS,
+                boundedAuthority: BOUNDED_AUTHORITY,
+            };
+        }
+        const validation = validateStoredApprovalEcho({
+            approval: stored.approval,
+            echo: input.approvalEcho,
+            allowExpired: stored.hasDispatched,
+        });
+        if (!validation.ok) {
+            return blockedApprovalResult({
+                blocker: validation.blocker,
+                changed: validation.changed,
+                fresh: stored.approval,
+            });
+        }
+        const freshTargetShapeRevision = input.targetPlan
+            ? (text(input.targetPlan.targetShapeRevision) ??
+                text(record(input.targetPlan.target)?.targetShapeRevision))
+            : null;
+        const storedTargetShapeRevision = text(stored.approval.targetShapeRevision);
+        if (freshTargetShapeRevision &&
+            freshTargetShapeRevision !== storedTargetShapeRevision) {
+            return blockedApprovalResult({
+                blocker: "approval_fingerprint_mismatch",
+                changed: ["targetShapeRevision"],
+                fresh: {
+                    storedTargetShapeRevision,
+                    freshTargetShapeRevision,
+                },
+            });
+        }
+        resolvedScope = stored.scope;
+        resolvedScopeHash = stored.scopeHash;
+        resolvedApproval = stored.approval;
+    }
+    else if (input.targetPlan && input.approvalEcho) {
         const envelope = buildApprovalEnvelope({
             workspaceId,
             intent: input.intent,
@@ -379,15 +508,11 @@ export async function refillSendsV2Command(input) {
         });
         const validation = validateApprovalEcho(envelope, input.approvalEcho);
         if (!validation.ok) {
-            return {
-                status: "blocked",
+            return blockedApprovalResult({
                 blocker: validation.blocker,
-                guidance: "The durable refill approval no longer matches fresh scope; render and approve a new packet before mutation.",
-                report: { changed: validation.changed, fresh: envelope.approval },
-                readOnly: false,
-                forbiddenActions: FORBIDDEN_ACTIONS,
-                boundedAuthority: BOUNDED_AUTHORITY,
-            };
+                changed: validation.changed,
+                fresh: envelope.approval,
+            });
         }
         resolvedScope = envelope.scope;
         resolvedScopeHash = envelope.scopeHash;
@@ -409,13 +534,18 @@ export async function refillSendsV2Command(input) {
             boundedAuthority: BOUNDED_AUTHORITY,
         };
     }
+    const executionScope = resolvedScope
+        ? executionScopeFromStored(resolvedScope, input)
+        : {
+            intent: input.intent,
+            senderIds: input.senderIds,
+            approvalMode: input.approvalMode ?? "approve",
+            ...date,
+        };
     const result = await runRefillV2Loop({
         workspaceId,
-        intent: input.intent,
-        senderIds: input.senderIds,
-        approvalMode: input.approvalMode ?? "approve",
+        ...executionScope,
         resume: resumeHandle(input),
-        ...date,
         scope: resolvedScope,
         scopeHash: resolvedScopeHash,
         approval: resolvedApproval,

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

@@ -725,6 +725,23 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     intent: RefillSendsIntent;
 } | {
     yoloExecution: {
+        selectedAction: Record<string, unknown> | null;
+        targetPlanReread: boolean;
+        status: "blocked";
+        blocker: "approval_expired" | "approval_fingerprint_mismatch";
+        guidance: string;
+        report: {
+            fresh?: {} | null | undefined;
+            changed: string[];
+        };
+        readOnly: boolean;
+        forbiddenActions: string[];
+        boundedAuthority: string;
+        enabled: boolean;
+        result?: undefined;
+        refusalReason?: undefined;
+        postActionFirstAction?: undefined;
+    } | {
         selectedAction: Record<string, unknown> | null;
         targetPlanReread: boolean;
         readOnly: boolean;

package/dist/tools/refill-sends.js

@@ -1,6 +1,6 @@
+import { REFILL_CONTRACT_CACHE_VERSION, REFILL_CONTRACT_HASH, REFILL_CONTRACT_VERSION, renderRefillBootstrapGuidance, renderRefillSafetyGuidance, renderRefillTerminalGuidance, } from "../refill-contract.js";
 import { actionIds, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
 import { prepareRefillSendsV2Approval, refillSendsV2Command, } from "./refill-sends-v2.js";
-import { REFILL_CONTRACT_CACHE_VERSION, REFILL_CONTRACT_HASH, REFILL_CONTRACT_VERSION, renderRefillBootstrapGuidance, renderRefillSafetyGuidance, renderRefillTerminalGuidance, } from "../refill-contract.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const REFILL_SEND_ACTION_TYPES = ["send_invite", "send_inmail_closed"];
@@ -189,7 +189,7 @@ export const refillSendsToolDefinitions = [
                 },
                 expectedActionKey: {
                     type: "string",
-                    description: "Optional actionKey from the approved packet's first global action. A mismatch returns approval_scope_changed before any refresh or mutation.",
+                    description: "Optional actual non-empty actionKey from the approved packet's first global action. Never infer it from type, toolName, or actionFingerprint. A mismatch returns approval_scope_changed before any refresh or mutation.",
                 },
                 runId: { type: "string" },
                 fence: { type: "number" },
@@ -293,7 +293,7 @@ function buildRefillSendsCommand(input) {
                         : `, horizonSendDays: ${horizonSendDays}`}, approvalMode: "${approvalMode}" }) before any import, prep, approval, start, or schedule-affecting action.`,
             "Render target.eligibleSenderLedger and target.senderRefillPlans before mutation. Preserve the coverage labels Need to prepare, Goal, Already sent, Scheduled, Ready and waiting to be scheduled, and Still need.",
             "Use target.globalActionQueue as the only cross-sender yolo queue: execute only target.globalActionQueue[0], one globally ranked primitive, then rerun get_refill_target_plan before choosing another action.",
-            "When expectedTargetShapeRevision or expectedActionKey is supplied from an already rendered packet, compare both against the first fresh target plan before paid-credit refresh or any primitive. Return approval_scope_changed with the fresh packet on mismatch.",
+            "When expectedTargetShapeRevision or expectedActionKey is supplied from an already rendered packet, compare both against the first fresh target plan before paid-credit refresh or any primitive. Pass expectedActionKey only when the rendered action has an actual non-empty actionKey; never infer it from type, toolName, or actionFingerprint. Return approval_scope_changed with the fresh packet on mismatch.",
             "Read target.senderRefillPlans[].refillReceipt as the public ladder receipt: it carries the selected campaign/sender/lane summary, skippedRungs, existingRowFrontier, and any absolute wait.deadlineAt. Do not choose source/copy/fallback work until that receipt proves the earlier ready/prep/approval rungs are exhausted.",
             "If get_refill_target_plan returns status complete, report eligible sender ledger, target.senderRefillPlans, gross target, selected days, sent count, scheduled count, projected count, campaign ids, targetShapeRevision, and no-op proof without asking for approval.",
             "Refill target lanes are connection invites (send_invite), standalone paid InMails (send_inmail_closed), or unified Sales Nav cascades represented publicly as send_inmail_closed with campaign classification sales_nav_cascade. For a Sales Nav cascade, refill the selected campaign first; its sequence can route prospects to Open InMail, paid InMail while fresh credits are >= 5, or same-campaign connection fallback without asking for separate open/paid/connection campaigns. Do not count send_dm as horizon target capacity.",
@@ -563,8 +563,13 @@ export async function executeRefillSendsCommand(input = {}) {
     }
     const targetPlanInput = targetPlanInputFor(scopedInput);
     const targetPlanBeforePaidRefresh = await getRefillTargetPlan(targetPlanInput);
+    const durableResumeRequested = Boolean(yolo &&
+        workspaceId &&
+        scopedInput.runId &&
+        typeof scopedInput.fence === "number" &&
+        scopedInput.approvalFingerprint);
     const approvedPacket = approvedPacketComparison(scopedInput, targetPlanBeforePaidRefresh);
-    if (approvedPacket.changed) {
+    if (!durableResumeRequested && approvedPacket.changed) {
         return {
             ...command,
             ok: false,
@@ -595,7 +600,8 @@ export async function executeRefillSendsCommand(input = {}) {
     }
     if (yolo &&
         workspaceId &&
-        durableV2PlanEligible(targetPlanBeforePaidRefresh)) {
+        (durableResumeRequested ||
+            durableV2PlanEligible(targetPlanBeforePaidRefresh))) {
         const base = durableYoloBaseResult({
             command,
             targetPlan: targetPlanBeforePaidRefresh,

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -101,6 +101,9 @@ Claude Code uses `/sellable:refill-sends`. Optional selectors are `--sender`,
 6. Invoke only the public durable entrypoint:
    `mcp__sellable__refill_sends({ workspaceId, targetDate, untilDate, horizonSendDays, senderIds, senderNames, actionTypes, yolo, executionMode, requireWorkspace:true })`.
    Preserve the exact scope and approval echo returned by the tool on resume.
+   Pass `expectedActionKey` only when the rendered first global action contains
+   an actual non-empty `actionKey`; never infer it from `type`, `toolName`, or
+   `actionFingerprint`.
 
 ## Operator packet