@sellable/mcp 0.1.643 → 0.1.644

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;

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",
@@ -520,118 +525,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 +565,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 +599,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;
@@ -1878,7 +1730,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)
@@ -1890,7 +1741,6 @@ export async function executeRefillSendsCommand(input = {}) {
                 : [];
             const nextSelection = await selectWorkspaceExactTarget(scopedInput, undefined, {
                 excludeTargets: excludedTargets,
-                preferredSenderId: stringValue(laneExhaustion?.senderId) ?? undefined,
             });
             if (nextSelection.status === "complete") {
                 return {

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.644",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",