@sellable/mcp 0.1.536 → 0.1.537

package/skills/refill-sends-v2-workflow/core/flow.v1.json

@@ -1,7 +1,7 @@
 {
   "version": "v1.0",
   "workflow": "refill-sends-v2-workflow",
-  "principle": "Execute refill sends v2 through a fenced run record: bootstrap, plan, execute, verify, and report. Dry runs stay read-only; real runs execute only packet-named bounded work. Date selectors use targetDate > untilDate > horizonSendDays precedence.",
+  "principle": "Execute refill sends v2 through a fenced run record: bootstrap, plan, execute, verify, and report. Dry runs stay read-only; real runs execute only packet-named bounded work.",
   "laneSources": [
     "managed_waterfall",
     "dashboard_evergreen",
@@ -50,9 +50,6 @@
     "repair rungs come from the plan packet; the loop bounds and refuses, never self-emits repair actions",
     "capped_by_scheduler is complete, never poll",
     "awaiting scheduler is not an end state; window-closed reports name remaining-ready, expected pickup time, and resume handle",
-    "date selectors resolve by targetDate > untilDate > horizonSendDays; targetDate is one exact sender-local date, untilDate is an inclusive through-date, and horizonSendDays means next N sender-local send days",
-    "dateWindow is stored on the run record and conflicting resume input is blocked",
-    "exact-date scheduler pickup uses run_scheduler_sweep({ workspaceId, targetDate }); untilDate and horizonSendDays runs sweep each planner-selected exact targetDate",
     "honest-rubric-fail means a human updates the rubric or changes lead source",
     "source replenishment beyond same-source-automatic is a scoped create-campaign handoff, never refill-owned provider search",
     "no campaign creation, provider-family switch, threshold lowering, scheduler writes, sends, archives, deletes, or brief/filter/message/sequence/sender mutation without a separate approval packet"
@@ -146,16 +143,7 @@
         },
         {
           "tool": "refill_sends_v2",
-          "requiredFields": ["workspaceId"],
-          "optionalFields": [
-            "senderIds",
-            "approvalMode",
-            "targetDate",
-            "untilDate",
-            "horizonSendDays",
-            "runId",
-            "fence"
-          ]
+          "requiredFields": ["workspaceId"]
         },
         {
           "tool": "get_subskill_prompt",
@@ -188,9 +176,6 @@
           "optionalFields": [
             "intent",
             "senderIds",
-            "targetDate",
-            "untilDate",
-            "horizonSendDays",
             "runState",
             "journal",
             "journalNote"
@@ -326,7 +311,7 @@
     },
     {
       "id": "verify",
-      "description": "Verify whole-row outcomes before another plan read. Reattach to an own active prep job by requestSource/requestHash; never re-dispatch prep while a matching job is active. Foreign prep waits until clear or blocks foreign_prep_active. wait_for_active_work and wait_for_source_import reread the plan on bounded cadence. wait_for_scheduler is cross-invocation: each tool call polls briefly under the host guard, heartbeats the lease, and returns in_progress sweep guidance so the agent re-invokes refill_sends_v2 with {runId,fence}. Exact-date scheduler pickup uses run_scheduler_sweep({ workspaceId, targetDate }); untilDate and horizonSendDays runs sweep each planner-selected exact targetDate. The approximately five minute scheduler budget is cumulative at the run level.",
+      "description": "Verify whole-row outcomes before another plan read. Reattach to an own active prep job by requestSource/requestHash; never re-dispatch prep while a matching job is active. Foreign prep waits until clear or blocks foreign_prep_active. wait_for_active_work and wait_for_source_import reread the plan on bounded cadence. wait_for_scheduler is cross-invocation: each tool call polls briefly under the host guard, heartbeats the lease, and returns in_progress sweep guidance so the agent re-invokes refill_sends_v2 with {runId,fence}. The approximately five minute scheduler budget is cumulative at the run level.",
       "allowedTools": ["refill_sends_v2", "get_refill_plan_v2"],
       "onEnter": [
         {
@@ -337,7 +322,6 @@
       "hardRules": [
         "do not re-dispatch prep when an own active job exists; reattach and poll status",
         "capped_by_scheduler is complete",
-        "resume uses the stored dateWindow; conflicting resume input is blocked",
         "replan-driven repair: the planner names rerun_errored_cells, approve_messages, start_campaign, or source work; the loop bounds and refuses",
         "conversion verdict is journaled from packet facts after the first prep batch; the plan gate withholds a second unproven prep batch",
         "zero pickup after a confirmed sweep is debugged from pipelineDiagnosis, not waited out forever",

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

@@ -189,11 +189,9 @@ files or memory.
    does not create rows, import, approve, schedule, refresh paid-InMail credits,
    or mutate thresholds.
    When ready rows exist and the wait is for scheduler pickup, call
-   `run_scheduler_sweep({ workspaceId, targetDate })` for exact-date requests
-   to request the product scheduler placement pass now and read its receipt. For
-   `untilDate` or `horizonSendDays` requests, sweep each planner-selected
-   `targetDate` with the same explicit `workspaceId`. This may place cells
-   within existing gates, never sends messages, and never bypasses limits.
+   `run_scheduler_sweep` with the same explicit `workspaceId` to request the
+   product scheduler placement pass now and read its receipt. This may place
+   cells within existing gates, never sends messages, and never bypasses limits.
    Scheduler-run receipt interpretation: `cellsConsidered is
    allocation-attempt count`, not total ready supply, while `readyCellsFound`
    is ready inventory found before prefilters. Inspect `campaignScopeSummary`

package/skills/refill-sends-workflow/core/flow.v1.json

@@ -202,7 +202,7 @@
       ],
       "rules": [
         "Poll every 60-120 seconds or on the host continuation interval.",
-        "Use run_scheduler_sweep({ workspaceId, targetDate }) for exact-date scheduler pickup; for untilDate or horizonSendDays requests, sweep each planner-selected targetDate with the explicit workspaceId. It places cells only inside existing gates and never sends.",
+        "Use run_scheduler_sweep with the explicit workspaceId when ready rows need scheduler pickup now; it places cells only inside existing gates and never sends.",
         "cellsConsidered is allocation-attempt count; inspect campaignScopeSummary before assuming the selected refill campaign/table was included or ready-but-blocked.",
         "Read prefiltered, skipped, and deferred separately: prefiltered ready closed-InMail cells with stale paid-credit facts require refresh_paid_inmail_credits_then_rerun once, then rerun/status.",
         "wait_for_capacity_or_window means report loaded/capped/waiting and do not source or prep more rows; no_ready_cells_continue_refill_prep means return to the refill/prep ladder.",

package/dist/refill-date-window.d.ts

@@ -1,34 +0,0 @@
-export type RefillDateWindowSource = "default_scheduler_forward" | "horizon_send_days" | "until_date" | "target_date";
-export type NormalizedRefillDateSelector = {
-    source: RefillDateWindowSource;
-    targetDate: string | null;
-    untilDate: string | null;
-    horizonSendDays: number | null;
-};
-export type RefillRunDateWindow = NormalizedRefillDateSelector & {
-    version: 1;
-    selectedDates: string[];
-    senderWindows?: Array<{
-        senderId: string | null;
-        timeZone: string | null;
-        selectedDates: string[];
-    }>;
-};
-type DateSelectorInput = {
-    targetDate?: unknown;
-    untilDate?: unknown;
-    horizonSendDays?: unknown;
-};
-export declare function normalizeRefillDateSelector(input: DateSelectorInput): NormalizedRefillDateSelector;
-export declare function refillDateSelectorBody(selector: NormalizedRefillDateSelector): {
-    targetDate?: string;
-    untilDate?: string;
-    horizonSendDays?: number;
-};
-export declare function dateWindowFromSelector(selector: NormalizedRefillDateSelector): RefillRunDateWindow;
-export declare function dateWindowFromPlan(plan: Record<string, unknown>, selector: NormalizedRefillDateSelector): RefillRunDateWindow;
-export declare function dateWindowFromRunState(runState: unknown): RefillRunDateWindow | null;
-export declare function selectorFromDateWindow(window: RefillRunDateWindow): NormalizedRefillDateSelector;
-export declare function dateSelectorMatchesWindow(selector: NormalizedRefillDateSelector, window: RefillRunDateWindow): boolean;
-export declare function schedulerSweepTargetDates(window: RefillRunDateWindow): string[];
-export {};

package/dist/refill-date-window.js

@@ -1,210 +0,0 @@
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function stringValue(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function arrayValue(value) {
-    return Array.isArray(value) ? value : [];
-}
-function isValidDateKey(value) {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
-        return false;
-    const [year, month, day] = value.split("-").map(Number);
-    const date = new Date(Date.UTC(year, month - 1, day));
-    return (date.getUTCFullYear() === year &&
-        date.getUTCMonth() === month - 1 &&
-        date.getUTCDate() === day);
-}
-function normalizeDateKey(value, field) {
-    if (value === undefined || value === null || value === "")
-        return null;
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string in YYYY-MM-DD format.`);
-    }
-    const trimmed = value.trim();
-    if (!isValidDateKey(trimmed)) {
-        throw new Error(`${field} must be a valid YYYY-MM-DD calendar date.`);
-    }
-    return trimmed;
-}
-function normalizeHorizonSendDays(value) {
-    if (value === undefined)
-        return null;
-    if (typeof value !== "number" ||
-        !Number.isInteger(value) ||
-        value < 1 ||
-        value > 7) {
-        throw new Error("horizonSendDays must be an integer between 1 and 7.");
-    }
-    return value;
-}
-export function normalizeRefillDateSelector(input) {
-    const targetDate = normalizeDateKey(input.targetDate, "targetDate");
-    const untilDate = normalizeDateKey(input.untilDate, "untilDate");
-    const horizonSendDays = normalizeHorizonSendDays(input.horizonSendDays);
-    if (targetDate) {
-        return {
-            source: "target_date",
-            targetDate,
-            untilDate: null,
-            horizonSendDays: null,
-        };
-    }
-    if (untilDate) {
-        return {
-            source: "until_date",
-            targetDate: null,
-            untilDate,
-            horizonSendDays: null,
-        };
-    }
-    if (horizonSendDays !== null) {
-        return {
-            source: "horizon_send_days",
-            targetDate: null,
-            untilDate: null,
-            horizonSendDays,
-        };
-    }
-    return {
-        source: "default_scheduler_forward",
-        targetDate: null,
-        untilDate: null,
-        horizonSendDays: null,
-    };
-}
-export function refillDateSelectorBody(selector) {
-    if (selector.source === "target_date" && selector.targetDate) {
-        return { targetDate: selector.targetDate };
-    }
-    if (selector.source === "until_date" && selector.untilDate) {
-        return { untilDate: selector.untilDate };
-    }
-    if (selector.source === "horizon_send_days" &&
-        selector.horizonSendDays !== null) {
-        return { horizonSendDays: selector.horizonSendDays };
-    }
-    return {};
-}
-export function dateWindowFromSelector(selector) {
-    return {
-        version: 1,
-        ...selector,
-        selectedDates: selector.targetDate ? [selector.targetDate] : [],
-    };
-}
-function selectedDatesFromPlan(plan) {
-    const packet = isRecord(plan.packet) ? plan.packet : {};
-    const target = isRecord(packet.target) ? packet.target : {};
-    const window = isRecord(target.window) ? target.window : {};
-    const senderWindows = arrayValue(window.senderWindows).filter(isRecord);
-    const fromWindows = senderWindows.flatMap((senderWindow) => arrayValue(senderWindow.selectedDates)
-        .map((entry) => stringValue(entry))
-        .filter((entry) => Boolean(entry)));
-    if (fromWindows.length > 0)
-        return Array.from(new Set(fromWindows)).sort();
-    const senderRefillPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
-    return Array.from(new Set(senderRefillPlans.flatMap((senderPlan) => {
-        const horizon = isRecord(senderPlan.horizon) ? senderPlan.horizon : {};
-        return arrayValue(horizon.selectedDays)
-            .filter(isRecord)
-            .map((day) => stringValue(day.date))
-            .filter((entry) => Boolean(entry));
-    }))).sort();
-}
-function senderWindowsFromPlan(plan) {
-    const packet = isRecord(plan.packet) ? plan.packet : {};
-    const target = isRecord(packet.target) ? packet.target : {};
-    const window = isRecord(target.window) ? target.window : {};
-    return arrayValue(window.senderWindows)
-        .filter(isRecord)
-        .map((senderWindow) => ({
-        senderId: stringValue(senderWindow.senderId),
-        timeZone: stringValue(senderWindow.timeZone),
-        selectedDates: arrayValue(senderWindow.selectedDates)
-            .map((entry) => stringValue(entry))
-            .filter((entry) => Boolean(entry)),
-    }));
-}
-export function dateWindowFromPlan(plan, selector) {
-    const packet = isRecord(plan.packet) ? plan.packet : {};
-    const request = isRecord(packet.request) ? packet.request : {};
-    const targetDate = stringValue(request.targetDate) ?? selector.targetDate ?? null;
-    const untilDate = stringValue(request.untilDate) ?? selector.untilDate ?? null;
-    const horizonSendDays = numberValue(request.horizonSendDays) ?? selector.horizonSendDays ?? null;
-    const source = targetDate
-        ? "target_date"
-        : untilDate
-            ? "until_date"
-            : horizonSendDays !== null
-                ? "horizon_send_days"
-                : selector.source;
-    const selectedDates = selectedDatesFromPlan(plan);
-    return {
-        version: 1,
-        source,
-        targetDate: source === "target_date" ? targetDate : null,
-        untilDate: source === "until_date" ? untilDate : null,
-        horizonSendDays: source === "horizon_send_days" ? horizonSendDays : null,
-        selectedDates: selectedDates.length > 0
-            ? selectedDates
-            : targetDate
-                ? [targetDate]
-                : [],
-        senderWindows: senderWindowsFromPlan(plan),
-    };
-}
-export function dateWindowFromRunState(runState) {
-    const state = isRecord(runState) ? runState : {};
-    const raw = isRecord(state.dateWindow) ? state.dateWindow : null;
-    if (!raw || raw.version !== 1)
-        return null;
-    const source = raw.source === "target_date" ||
-        raw.source === "until_date" ||
-        raw.source === "horizon_send_days" ||
-        raw.source === "default_scheduler_forward"
-        ? raw.source
-        : null;
-    if (!source)
-        return null;
-    return {
-        version: 1,
-        source,
-        targetDate: source === "target_date" ? stringValue(raw.targetDate) : null,
-        untilDate: source === "until_date" ? stringValue(raw.untilDate) : null,
-        horizonSendDays: source === "horizon_send_days"
-            ? numberValue(raw.horizonSendDays)
-            : null,
-        selectedDates: arrayValue(raw.selectedDates)
-            .map((entry) => stringValue(entry))
-            .filter((entry) => Boolean(entry)),
-    };
-}
-export function selectorFromDateWindow(window) {
-    return {
-        source: window.source,
-        targetDate: window.targetDate,
-        untilDate: window.untilDate,
-        horizonSendDays: window.horizonSendDays,
-    };
-}
-export function dateSelectorMatchesWindow(selector, window) {
-    return (selector.source === window.source &&
-        selector.targetDate === window.targetDate &&
-        selector.untilDate === window.untilDate &&
-        selector.horizonSendDays === window.horizonSendDays);
-}
-export function schedulerSweepTargetDates(window) {
-    if (window.source === "target_date" && window.targetDate) {
-        return [window.targetDate];
-    }
-    if (window.source === "until_date" ||
-        window.source === "horizon_send_days") {
-        return window.selectedDates;
-    }
-    return [];
-}

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

@@ -1,28 +0,0 @@
-type RefillSendsEvergreenInput = {
-    workspaceId?: string;
-};
-export declare const refillSendsEvergreenToolDefinitions: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            workspaceId: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-}[];
-export declare function refillSendsEvergreenCommand(input: RefillSendsEvergreenInput): {
-    readOnly: boolean;
-    workspaceId: string | null;
-    firstOperationalSteps: string[];
-    approvalContract: string;
-    forbiddenActions: string[];
-    fillWindow: string;
-    hostExamples: string[];
-};
-export {};

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

@@ -1,47 +0,0 @@
-export const refillSendsEvergreenToolDefinitions = [
-    {
-        name: "refill_sends_evergreen",
-        description: "Read-only Phase 85 evergreen refill command contract. It performs no mutations and only tells the operator to call get_evergreen_refill_plan for a dry-run packet and journal.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                workspaceId: {
-                    type: "string",
-                    description: "Explicit request-scoped workspace id.",
-                },
-            },
-            required: ["workspaceId"],
-            additionalProperties: false,
-        },
-    },
-];
-export function refillSendsEvergreenCommand(input) {
-    return {
-        readOnly: true,
-        workspaceId: input.workspaceId ?? null,
-        firstOperationalSteps: [
-            "Call get_evergreen_refill_plan with the explicit workspaceId.",
-            "Read the returned packet, globalActionQueue, per-sender plans, and itinerary before taking any action.",
-            "Review the dry-run journal file path returned by get_evergreen_refill_plan.",
-            "Phase 85 is PLAN-ONLY; execution arrives in Phase 86.",
-        ],
-        approvalContract: "Nothing is approved or executable in Phase 85. The evergreen command is read-only; Phase 86 introduces execution approval.",
-        forbiddenActions: [
-            "Do not schedule sends.",
-            "Do not send messages.",
-            "Do not approve messages.",
-            "Do not prepare messages.",
-            "Do not start or launch campaigns.",
-            "Do not create campaigns.",
-            "Do not switch providers or source families.",
-            "Do not lower paid InMail thresholds.",
-            "Do not refresh paid InMail credits.",
-            "Do not write scheduler fields.",
-        ],
-        fillWindow: "Use only the target window and caps returned by get_evergreen_refill_plan.",
-        hostExamples: [
-            "refill_sends_evergreen({ workspaceId })",
-            "get_evergreen_refill_plan({ workspaceId })",
-        ],
-    };
-}