@sellable/mcp 0.1.559 → 0.1.560

package/dist/refill-run-loop.js

@@ -1027,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"];
@@ -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.559",
+  "version": "0.1.560",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",