@sellable/mcp 0.1.466 → 0.1.468

package/dist/tools/refill-sends.js

@@ -150,6 +150,7 @@ export function refillSendsCommand(input = {}) {
                 ? `, untilDate: "${untilDate}"`
                 : `, horizonSendDays: ${horizonSendDays}`}, approvalMode: "${approvalMode}" }) before any import, prep, approval, start, or schedule-affecting action.`,
             "If get_refill_target_plan returns status complete, report eligible sender ledger, 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 only connection invites (send_invite) or paid InMails (send_inmail_closed). Do not count send_dm or send_inmail_open as horizon target capacity; they may exist in sequences, but the planner must pick the refill lane from the most recent active campaign-backed send evidence for each sender.",
             "If remainingReadyOrProjectedGap is 0 but remainingProjectedGap is positive, run only a bounded read-only scheduler settle/reread loop; do not ask for prep/import/approval.",
             `Resolve route with resolve_campaign_fill_route({ intent: "${intent}"${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""} }).`,
             'If the plain route shows stale managed waterfall evidence, archived/completed shared slots, or targets that do not cover the selected sender set, immediately call resolve_campaign_fill_route({ intent: "active" }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked.',

package/dist/tools/refill-target-plan.js

@@ -1,12 +1,238 @@
 import { getApi } from "../api.js";
+const REFILL_TARGET_ACTION_TYPES = [
+    "send_invite",
+    "send_inmail_closed",
+];
+const REFILL_TARGET_ACTION_SET = new Set(REFILL_TARGET_ACTION_TYPES);
 async function postRefillTargetPlan(body) {
     const api = getApi();
     return api.post("/api/v3/mcp/refill-target-plan", body);
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function allowedActionType(value) {
+    return typeof value === "string" && REFILL_TARGET_ACTION_SET.has(value)
+        ? value
+        : null;
+}
+function actionTypesFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(allowedActionType).filter(Boolean))];
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function evidenceLatestMs(evidence) {
+    const latestAt = evidence.latestAt;
+    if (typeof latestAt !== "string")
+        return 0;
+    const timestamp = new Date(latestAt).getTime();
+    return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function chooseEvidenceAction(evidence, fallback) {
+    const byAction = new Map();
+    for (const item of evidence) {
+        if (!isRecord(item))
+            continue;
+        const actionType = allowedActionType(item.actionType);
+        if (!actionType)
+            continue;
+        const current = byAction.get(actionType) ?? { count: 0, latestMs: 0 };
+        current.count += numberValue(item.count);
+        current.latestMs = Math.max(current.latestMs, evidenceLatestMs(item));
+        byAction.set(actionType, current);
+    }
+    const [best] = [...byAction.entries()].sort((a, b) => {
+        if (a[1].latestMs !== b[1].latestMs)
+            return b[1].latestMs - a[1].latestMs;
+        if (a[1].count !== b[1].count)
+            return b[1].count - a[1].count;
+        return (REFILL_TARGET_ACTION_TYPES.indexOf(a[0]) -
+            REFILL_TARGET_ACTION_TYPES.indexOf(b[0]));
+    });
+    return best?.[0] ?? fallback[0] ?? null;
+}
+function senderActionKey(senderId, actionType) {
+    return typeof senderId === "string" && typeof actionType === "string"
+        ? `${senderId}:${actionType}`
+        : null;
+}
+function sanitizeCounts(counts, selectedKeys) {
+    if (!Array.isArray(counts))
+        return [];
+    return counts.filter((item) => {
+        if (!isRecord(item))
+            return false;
+        const actionType = allowedActionType(item.actionType);
+        const key = senderActionKey(item.senderId, actionType);
+        return Boolean(key && selectedKeys.has(key));
+    });
+}
+function sanitizeActionCandidates(candidates, selectedKeys, status, remainingReadyOrProjectedGap, remainingProjectedGap) {
+    const filtered = Array.isArray(candidates)
+        ? candidates.filter((item) => {
+            if (!isRecord(item))
+                return false;
+            const actionType = item.actionType;
+            if (actionType === undefined)
+                return item.type === "wait_for_scheduler";
+            const allowed = allowedActionType(actionType);
+            const key = senderActionKey(item.senderId, allowed);
+            return Boolean(key && selectedKeys.has(key));
+        })
+        : [];
+    if (status === "awaiting_scheduler_after_ready_buffer" &&
+        remainingProjectedGap > 0 &&
+        remainingReadyOrProjectedGap === 0 &&
+        !filtered.some((item) => item.type === "wait_for_scheduler")) {
+        filtered.push({
+            type: "wait_for_scheduler",
+            reason: "ready buffer covers the projected target gap but scheduledFor coverage is still short",
+        });
+    }
+    return filtered;
+}
+function sanitizeBlockers(blockers, selectedKeys) {
+    if (!Array.isArray(blockers))
+        return [];
+    return blockers.filter((item) => {
+        if (!isRecord(item))
+            return false;
+        const detail = item.detail;
+        const code = String(item.code ?? "");
+        if (typeof detail !== "string")
+            return true;
+        const detailSenderId = detail.split(":")[0];
+        if (code.startsWith("paid_inmail_")) {
+            return selectedKeys.has(`${detailSenderId}:send_inmail_closed`);
+        }
+        if (detail.includes(":send_dm") || detail.includes(":send_inmail_open")) {
+            return false;
+        }
+        const parts = detail.split(":");
+        if (parts.length < 2)
+            return true;
+        const actionType = allowedActionType(parts[parts.length - 1]);
+        if (!actionType)
+            return true;
+        const senderId = parts[0];
+        return selectedKeys.size === 0 || selectedKeys.has(`${senderId}:${actionType}`);
+    });
+}
+function sanitizeRefillTargetPlanResult(result) {
+    if (!isRecord(result) || !isRecord(result.target))
+        return result;
+    const target = result.target;
+    const rawSelections = Array.isArray(target.actionSelections)
+        ? target.actionSelections
+        : [];
+    const rawSenderPlans = Array.isArray(target.senderPlans)
+        ? target.senderPlans
+        : [];
+    const selectedBySender = new Map();
+    for (const rawSelection of rawSelections) {
+        if (!isRecord(rawSelection) || typeof rawSelection.senderId !== "string") {
+            continue;
+        }
+        const fallback = actionTypesFrom(rawSelection.actionTypes);
+        const evidence = Array.isArray(rawSelection.evidence)
+            ? rawSelection.evidence
+            : [];
+        const chosen = chooseEvidenceAction(evidence, fallback);
+        if (chosen)
+            selectedBySender.set(rawSelection.senderId, chosen);
+    }
+    for (const rawPlan of rawSenderPlans) {
+        if (!isRecord(rawPlan) ||
+            typeof rawPlan.senderId !== "string" ||
+            selectedBySender.has(rawPlan.senderId)) {
+            continue;
+        }
+        const actionType = allowedActionType(rawPlan.actionType);
+        if (actionType)
+            selectedBySender.set(rawPlan.senderId, actionType);
+    }
+    const selectedKeys = new Set([...selectedBySender.entries()].map(([senderId, actionType]) => `${senderId}:${actionType}`));
+    const actionTypes = [...new Set(selectedBySender.values())];
+    if (selectedKeys.size === 0)
+        return result;
+    const senderPlans = rawSenderPlans.filter((plan) => isRecord(plan) &&
+        selectedKeys.has(`${String(plan.senderId)}:${String(plan.actionType)}`));
+    const selectedDays = Array.isArray(target.selectedDays)
+        ? target.selectedDays.filter((day) => isRecord(day) &&
+            selectedKeys.has(`${String(day.senderId)}:${String(day.actionType)}`))
+        : [];
+    const actionSelections = rawSelections
+        .filter((selection) => isRecord(selection) &&
+        typeof selection.senderId === "string" &&
+        selectedBySender.has(selection.senderId))
+        .map((selection) => {
+        const actionType = selectedBySender.get(selection.senderId);
+        const evidence = Array.isArray(selection.evidence)
+            ? selection.evidence.filter((item) => isRecord(item) && item.actionType === actionType)
+            : [];
+        return {
+            ...selection,
+            actionTypes: actionType ? [actionType] : [],
+            evidence,
+        };
+    });
+    const grossTarget = senderPlans.reduce((sum, plan) => sum + numberValue(plan.grossTarget), 0);
+    const sent = senderPlans.reduce((sum, plan) => sum + numberValue(plan.sent), 0);
+    const scheduled = senderPlans.reduce((sum, plan) => sum + numberValue(plan.scheduled), 0);
+    const projected = sent + scheduled;
+    const readyBuffer = senderPlans.reduce((sum, plan) => sum + numberValue(plan.readyBuffer), 0);
+    const remainingScheduledGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingScheduledGap), 0);
+    const remainingProjectedGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingProjectedGap), 0);
+    const remainingReadyOrProjectedGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingReadyOrProjectedGap), 0);
+    const blockers = sanitizeBlockers(result.blockers, selectedKeys);
+    const status = blockers.some((blocker) => ["sender_disconnected", "sender_sales_nav_disconnected"].includes(String(blocker.code))) || grossTarget <= 0
+        ? "blocked"
+        : remainingProjectedGap === 0
+            ? "complete"
+            : remainingReadyOrProjectedGap === 0
+                ? "awaiting_scheduler_after_ready_buffer"
+                : "needs_refill";
+    return {
+        ...result,
+        status,
+        request: isRecord(result.request)
+            ? { ...result.request, actionTypes }
+            : result.request,
+        target: {
+            ...target,
+            actionSelections,
+            selectedDays,
+            senderPlans,
+            grossTarget,
+            sent,
+            scheduled,
+            projected,
+            readyBuffer,
+            remainingScheduledGap,
+            remainingProjectedGap,
+            remainingReadyOrProjectedGap,
+            remainingReadyOrScheduledGap: remainingReadyOrProjectedGap,
+        },
+        coverage: isRecord(result.coverage)
+            ? {
+                ...result.coverage,
+                sentCounts: sanitizeCounts(result.coverage.sentCounts, selectedKeys),
+                scheduledCounts: sanitizeCounts(result.coverage.scheduledCounts, selectedKeys),
+                readyCounts: sanitizeCounts(result.coverage.readyCounts, selectedKeys),
+            }
+            : result.coverage,
+        actionCandidates: sanitizeActionCandidates(result.actionCandidates, selectedKeys, status, remainingReadyOrProjectedGap, remainingProjectedGap),
+        blockers,
+        mcpSanitizedRefillLanes: true,
+    };
+}
 export const refillTargetPlanToolDefinitions = [
     {
         name: "get_refill_target_plan",
-        description: "read-only refill target planner to call before any refill mutation. It identifies eligible senders, infers implicit per-sender send lanes from future scheduled, ready-to-schedule, and recent scheduled evidence before falling back to campaign sequences, then computes selected sender-local days, gross target, actual sent coverage, scheduler-owned scheduled coverage, projected coverage (sent + scheduled), ready buffer, remaining projected gap, paid InMail credit/threshold feasibility, bounded action candidates, and targetRevision drift proof. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, lower paid InMail thresholds, create campaigns, launch, spend InMail credits, or write scheduler fields. Complete projected targets no-op without approval; incomplete targets must be followed by a bounded approval packet.",
+        description: "read-only refill target planner to call before any refill mutation. It identifies eligible senders and infers one implicit refill lane per sender: connection invites or paid InMails, chosen from future scheduled, recent scheduled, and ready-to-schedule evidence in active campaign-backed sequence campaigns before falling back to campaign sequences. DMs and open-profile InMails are follow-up sequence actions, not refill target lanes. The planner computes selected sender-local days, gross target, actual sent coverage, scheduler-owned scheduled coverage, projected coverage (sent + scheduled), ready buffer, remaining projected gap, paid InMail credit/threshold feasibility, bounded action candidates, and targetRevision drift proof. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, lower paid InMail thresholds, create campaigns, launch, spend InMail credits, or write scheduler fields. Complete projected targets no-op without approval; incomplete targets must be followed by a bounded approval packet.",
         inputSchema: {
             type: "object",
             properties: {
@@ -53,15 +279,9 @@ export const refillTargetPlanToolDefinitions = [
                     type: "array",
                     items: {
                         type: "string",
-                        enum: [
-                            "send_invite",
-                            "send_dm",
-                            "send_inmail_open",
-                            "send_inmail_closed",
-                            "react_and_comment",
-                        ],
+                        enum: ["send_invite", "send_inmail_closed"],
                     },
-                    description: "Optional workflow send column/action types. If omitted, the planner infers per-sender lanes from future scheduled, ready-to-schedule, and recent scheduled evidence before falling back to selected active campaign sequences.",
+                    description: "Optional refill target lane override. Supported refill lanes are connection invites (send_invite) and paid InMails (send_inmail_closed) only. If omitted, the planner infers one per-sender lane from active campaign future scheduled, recent scheduled, and ready-to-schedule evidence before falling back to selected active campaign sequences.",
                 },
                 approvalMode: {
                     type: "string",
@@ -74,8 +294,8 @@ export const refillTargetPlanToolDefinitions = [
         },
     },
 ];
-export function getRefillTargetPlan(input = {}) {
-    return postRefillTargetPlan({
+export async function getRefillTargetPlan(input = {}) {
+    const result = await postRefillTargetPlan({
         intent: input.intent,
         horizonSendDays: input.horizonSendDays,
         untilDate: input.untilDate,
@@ -87,4 +307,5 @@ export function getRefillTargetPlan(input = {}) {
         actionTypes: input.actionTypes,
         approvalMode: input.approvalMode,
     });
+    return sanitizeRefillTargetPlanResult(result);
 }

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -117,21 +117,30 @@ eligible senders, selected sender-local days, gross target, actual sent
 coverage, scheduler-owned scheduled coverage across active enrolled campaigns,
 projected coverage (`sent + scheduled`), inferred per-sender send lane/action
 selections, ready buffer, remaining projected gap, paid-InMail credit/threshold
-feasibility, `targetShapeRevision`, and `stateRevision`. When `actionTypes` are
-omitted, trust the target plan's inferred lane rather than asking whether to
-fill connections, DMs, or InMails. If the target plan is complete by projected
-coverage, report that the selected target is already filled and no-op without
-asking for approval. If the ready buffer covers the projected gap but scheduled
-coverage is still short, run only a bounded read-only scheduler settle/reread
-loop and report `awaiting_scheduler_after_ready_buffer` if it does not settle.
+feasibility, `targetShapeRevision`, and `stateRevision`. Refill target lanes
+are only connection invites (`send_invite`) or paid InMails
+(`send_inmail_closed`), chosen per sender from the most recent current
+dashboard-active campaign-backed send evidence. DMs (`send_dm`) and
+open-profile InMails (`send_inmail_open`) may exist in sequences, but they are
+not refill horizon target capacity and must not be counted as refill sent,
+scheduled, or ready coverage. When `actionTypes` are omitted, trust the target
+plan's inferred connection-or-paid-InMail lane rather than asking which of those
+two lanes to fill. If a stale target plan selects `send_dm` or
+`send_inmail_open`, stop and re-plan with the current planner before mutation.
+Short form: trust the target plan's inferred lane only when it is a
+connection-invite or paid-InMail refill lane.
+If the target plan is complete by projected coverage, report that the selected
+target is already filled and no-op without asking for approval. If the ready
+buffer covers the projected gap but scheduled coverage is still short, run only
+a bounded read-only scheduler settle/reread loop and report
+`awaiting_scheduler_after_ready_buffer` if it does not settle.
 If paid InMail credit facts are stale or missing and the target plan returns a
 `refresh_paid_inmail_credits` action candidate, include the exact sender id,
 campaign/table/column proof, expected sender-credit-cache writes, and rerun plan
 step in the bounded packet. After `refresh_paid_inmail_credits`, rerun
 `get_refill_target_plan` before any prep/import/approval/start action. If paid
 InMail is below threshold after a fresh credit read, report the exact
-campaign/table/column threshold action or connection fallback; `--yolo` does not
-lower paid-InMail thresholds or create campaigns.
+campaign/table/column threshold action or connection fallback; `--yolo` does not lower paid-InMail thresholds or create campaigns.
 
 If the plain route's managed waterfall targets are stale, for example skipped
 targets show archived/completed shared slots or the returned targets do not cover

package/skills/refill-sends-workflow/SKILL.md

@@ -67,10 +67,20 @@ campaign.
    campaigns, projected coverage (`sent + scheduled`), ready buffer, remaining
    projected gap, paid-InMail credit/threshold feasibility, bounded action
    candidates, `targetShapeRevision`, and `stateRevision`.
-   When `actionTypes` are omitted, trust the target plan's inferred lane; do not
-   ask the operator whether to fill connections, DMs, or InMails after the plan
-   has already inferred that from future scheduled, ready, and recent scheduled
-   evidence.
+   Refill target lanes are binary per sender: connection invites
+   (`send_invite`) or paid InMails (`send_inmail_closed`). DMs
+   (`send_dm`) and open-profile InMails (`send_inmail_open`) can remain in the
+   sequence, but they are follow-up actions, not refill horizon capacity. Do not
+   count their sent, scheduled, or ready cells when deciding whether a sender
+   needs refill. When `actionTypes` are omitted, trust the target plan's
+   inferred connection-or-paid-InMail lane; do not ask the operator which of
+   those two lanes to fill after the plan has inferred that from active
+   campaign future scheduled, recent scheduled, and ready evidence. If a stale
+   planner/tool response selects `send_dm` or `send_inmail_open`, treat that as
+   unsupported stale refill state and re-plan with a current planner before any
+   mutation.
+   Short form: trust the target plan's inferred lane only when it is a
+   connection-invite or paid-InMail refill lane.
    If `status:"complete"`, report the target, selected dates, sent count,
    scheduled count, projected count, campaign ids, and no-op proof without
    asking for approval or mutating.
@@ -84,8 +94,7 @@ campaign.
    step in the bounded packet. After `refresh_paid_inmail_credits`, rerun
    `get_refill_target_plan` before any prep/import/approval/start action. If paid
    InMail is below threshold after a fresh credit read, report the exact
-   campaign/table/column threshold action or connection fallback; `--yolo` does not
-   lower paid-InMail thresholds or create campaigns.
+   campaign/table/column threshold action or connection fallback; `--yolo` does not lower paid-InMail thresholds or create campaigns.
 2. Call `resolve_campaign_fill_route`. Use `intent:"plain"` for generic
    fill/load language, `intent:"active"` only when the user explicitly narrowed
    to active regular campaigns or when the plain route has stale managed
@@ -161,7 +170,9 @@ Use the refill-state response as the current facts receipt:
   approved, ready to schedule, scheduled;
 - active message prep job;
 - scheduler-owned scheduled counts by date/action from cells with non-null
-  `scheduledFor`; treat these as the last sends/continuation signal;
+  `scheduledFor`; treat connection-invite and paid-InMail cells as the refill
+  lane continuation signal and the last sends/continuation signal, and ignore
+  DM/open-InMail cells for refill target capacity;
 - latest scheduled send date, latest scheduled-cell update when present,
   sender overlap with the requested or inferred sender set, and whether future
   scheduled sends already exist;
@@ -210,6 +221,19 @@ in the best same-sender campaign and keep all source-copy/prep caps tied to that
 two-day packet.
 Short form: default `--yolo refill senders` target is each eligible sender's two-send-day gap.
 
+Lane selection must choose one refill lane per sender from current
+dashboard-active campaign-backed sequence evidence:
+
+1. Prefer the sender's most recent future scheduled refill action, then the most
+   recent recent scheduled refill action, then ready refill rows.
+2. Refill actions are only `send_invite` and `send_inmail_closed`.
+3. If the most recent active campaign evidence is DM or open InMail, ignore it
+   for refill lane selection and use the nearest connection-invite or paid-InMail
+   evidence instead.
+4. If no connection/paid-InMail evidence exists, fall back to the selected
+   active campaign sequence, still choosing only one of `send_invite` or
+   `send_inmail_closed` for that sender.
+
 For `--yolo` fill/schedule requests, do not treat "ready" as completion. Build
 and maintain a horizon saturation ledger for every selected sender from
 `get_refill_target_plan`. A sender is complete only when a final target-plan or