@sellable/mcp 0.1.510 → 0.1.512

package/dist/refill-journal.d.ts

@@ -0,0 +1,49 @@
+export declare const DRY_RUN_MARKER = "**DRY RUN \u2014 no mutations performed**";
+export declare const JOURNAL_SECTION_HEADINGS: {
+    readonly bootstrap: "## Bootstrap";
+    readonly plan: "## Plan";
+    readonly terminal: "## Terminal";
+};
+export declare function resolveRefillRunsRoot(): string;
+/**
+ * Throws on path-safety and permission failures. Callers must wrap the entire
+ * journal block and degrade to journalPath: null; journal failure must never
+ * abort a plan response.
+ */
+export declare function createRunJournal(params: {
+    workspaceId: string;
+    runId?: string;
+    dryRun: boolean;
+    now?: Date;
+}): {
+    filePath: string;
+    runId: string;
+};
+export declare function appendJournalEvent(filePath: string, block: string): void;
+/**
+ * The index is a rebuildable cache. Directory listing is the source of truth;
+ * Phase 85 appends dry-run lines, Phase 86 maintains real-run entries.
+ */
+export declare function appendIndexLine(entry: {
+    runId: string;
+    fileName: string;
+    workspaceId: string;
+    dryRun: boolean;
+    summary: string;
+}): void;
+export declare function renderBootstrapSection(params: {
+    summary: string;
+    senderSummary?: string;
+    laneSummary?: string;
+    targetSummary?: string;
+    creditSummary?: string;
+}): string;
+export declare function renderPlanSection(params: {
+    chosenSummary: string;
+    itinerarySummaries?: string[];
+    fallbackSummary?: string;
+}): string;
+export declare function renderTerminalSection(params: {
+    summary: string;
+    finalNumbers?: string;
+}): string;

package/dist/refill-journal.js

@@ -0,0 +1,134 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const REFILL_RUNS_ROOT_ENV = "SELLABLE_REFILL_RUNS_DIR";
+export const DRY_RUN_MARKER = "**DRY RUN — no mutations performed**";
+export const JOURNAL_SECTION_HEADINGS = {
+    bootstrap: "## Bootstrap",
+    plan: "## Plan",
+    terminal: "## Terminal",
+};
+function expandLeadingTilde(value) {
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return path.join(os.homedir(), value.slice(2));
+    }
+    return value;
+}
+function normalizeConfiguredRoot(value, label) {
+    const expanded = expandLeadingTilde(value);
+    if (!path.isAbsolute(expanded)) {
+        throw new Error(`${label} must be an absolute path.`);
+    }
+    return path.resolve(expanded);
+}
+export function resolveRefillRunsRoot() {
+    const envValue = process.env[REFILL_RUNS_ROOT_ENV]?.trim();
+    if (envValue) {
+        return normalizeConfiguredRoot(envValue, REFILL_RUNS_ROOT_ENV);
+    }
+    const home = os.homedir();
+    if (!home || !path.isAbsolute(home)) {
+        throw new Error(`Unable to resolve Sellable refill runs root: ${REFILL_RUNS_ROOT_ENV} is unset and home directory is unavailable.`);
+    }
+    return path.resolve(home, ".sellable/refill/runs");
+}
+function isPathInside(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return (Boolean(relative) &&
+        !relative.startsWith("..") &&
+        !path.isAbsolute(relative));
+}
+function assertSafeRunId(runId) {
+    if (!/^[A-Za-z0-9_-]+$/.test(runId) ||
+        runId.includes("..") ||
+        runId.includes("/") ||
+        runId.includes("\\") ||
+        runId.includes("\0")) {
+        throw new Error("runId must be a safe filename segment.");
+    }
+}
+function utcBasicTimestamp(now) {
+    return `${now.toISOString().slice(0, 19).replace(/[-:]/g, "")}Z`;
+}
+function normalizeBlock(block) {
+    return block.endsWith("\n") ? block : `${block}\n`;
+}
+/**
+ * Throws on path-safety and permission failures. Callers must wrap the entire
+ * journal block and degrade to journalPath: null; journal failure must never
+ * abort a plan response.
+ */
+export function createRunJournal(params) {
+    const runId = params.runId ?? randomBytes(4).toString("hex");
+    assertSafeRunId(runId);
+    const root = resolveRefillRunsRoot();
+    fs.mkdirSync(root, { recursive: true });
+    const normalizedRoot = path.resolve(root);
+    const fileName = `${utcBasicTimestamp(params.now ?? new Date())}-${runId}${params.dryRun ? "-dry" : ""}.md`;
+    const filePath = path.resolve(normalizedRoot, fileName);
+    if (!isPathInside(filePath, normalizedRoot)) {
+        throw new Error("Resolved journal path escapes refill runs root.");
+    }
+    const startedAt = (params.now ?? new Date()).toISOString();
+    const header = [
+        `# Refill Sends Evergreen Run ${runId}`,
+        "",
+        `- Run ID: ${runId}`,
+        `- Workspace ID: ${params.workspaceId}`,
+        `- Started at: ${startedAt}`,
+        params.dryRun ? `- ${DRY_RUN_MARKER}` : null,
+        "",
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+    fs.appendFileSync(filePath, normalizeBlock(header), "utf8");
+    return { filePath, runId };
+}
+export function appendJournalEvent(filePath, block) {
+    try {
+        fs.appendFileSync(filePath, normalizeBlock(block), "utf8");
+    }
+    catch {
+        // Best effort by design.
+    }
+}
+/**
+ * The index is a rebuildable cache. Directory listing is the source of truth;
+ * Phase 85 appends dry-run lines, Phase 86 maintains real-run entries.
+ */
+export function appendIndexLine(entry) {
+    try {
+        const root = resolveRefillRunsRoot();
+        fs.mkdirSync(root, { recursive: true });
+        const marker = entry.dryRun ? " (dry)" : "";
+        fs.appendFileSync(path.join(root, "index.md"), `- ${entry.runId}${marker} [${entry.workspaceId}] ${entry.fileName} — ${entry.summary}\n`, "utf8");
+    }
+    catch {
+        // Best effort by design.
+    }
+}
+function renderLines(heading, lines) {
+    return normalizeBlock([heading, "", ...lines, ""].join("\n"));
+}
+export function renderBootstrapSection(params) {
+    return renderLines(JOURNAL_SECTION_HEADINGS.bootstrap, [
+        params.summary,
+        params.senderSummary,
+        params.laneSummary,
+        params.targetSummary,
+        params.creditSummary,
+    ].filter((line) => Boolean(line)));
+}
+export function renderPlanSection(params) {
+    return renderLines(JOURNAL_SECTION_HEADINGS.plan, [
+        `Chosen: ${params.chosenSummary}`,
+        ...(params.itinerarySummaries ?? []).map((summary) => `Next: ${summary}`),
+        params.fallbackSummary ? `Fallback: ${params.fallbackSummary}` : null,
+    ].filter((line) => Boolean(line)));
+}
+export function renderTerminalSection(params) {
+    return renderLines(JOURNAL_SECTION_HEADINGS.terminal, [params.summary, params.finalNumbers].filter((line) => Boolean(line)));
+}

package/dist/refill-local-state.d.ts

@@ -0,0 +1,31 @@
+export interface RefillLaneMemoryEntry {
+    senderId: string;
+    laneKey: string;
+    outcome: string;
+    cooldownUntil: string;
+    reason: string;
+}
+export interface RefillPassRateObservation {
+    campaignId: string;
+    enrichedCount: number;
+    passedCount: number;
+    observedAt: string;
+}
+export interface RefillRunSummaryEntry {
+    runId: string;
+    endedAt: string;
+    terminalState: string;
+    sendsLoaded: number;
+    lanesTouched: string[];
+}
+export interface RefillWorkspaceState {
+    laneMemory: RefillLaneMemoryEntry[];
+    passRates: RefillPassRateObservation[];
+    recentRuns: RefillRunSummaryEntry[];
+}
+/**
+ * Advisory hints only. A missing, stale, corrupt, or malformed file means no
+ * hints; live planner reads remain the source of correctness. Phase 85 reads
+ * this section only. Phase 86 adds the writer plus writeJsonAtomic.
+ */
+export declare function readRefillWorkspaceState(workspaceId: string): RefillWorkspaceState | null;

package/dist/refill-local-state.js

@@ -0,0 +1,96 @@
+import { getConfig } from "./auth.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((entry) => typeof entry === "string"));
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : null;
+}
+function readNumber(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function parseLaneMemoryEntry(value) {
+    if (!isRecord(value))
+        return null;
+    const senderId = readString(value, "senderId");
+    const laneKey = readString(value, "laneKey");
+    const outcome = readString(value, "outcome");
+    const cooldownUntil = readString(value, "cooldownUntil");
+    const reason = readString(value, "reason");
+    if (!senderId || !laneKey || !outcome || !cooldownUntil || !reason) {
+        return null;
+    }
+    return { senderId, laneKey, outcome, cooldownUntil, reason };
+}
+function parsePassRateObservation(value) {
+    if (!isRecord(value))
+        return null;
+    const campaignId = readString(value, "campaignId");
+    const enrichedCount = readNumber(value, "enrichedCount");
+    const passedCount = readNumber(value, "passedCount");
+    const observedAt = readString(value, "observedAt");
+    if (!campaignId ||
+        enrichedCount === null ||
+        passedCount === null ||
+        !observedAt) {
+        return null;
+    }
+    return { campaignId, enrichedCount, passedCount, observedAt };
+}
+function parseRunSummaryEntry(value) {
+    if (!isRecord(value))
+        return null;
+    const runId = readString(value, "runId");
+    const endedAt = readString(value, "endedAt");
+    const terminalState = readString(value, "terminalState");
+    const sendsLoaded = readNumber(value, "sendsLoaded");
+    const lanesTouched = value.lanesTouched;
+    if (!runId ||
+        !endedAt ||
+        !terminalState ||
+        sendsLoaded === null ||
+        !isStringArray(lanesTouched)) {
+        return null;
+    }
+    return { runId, endedAt, terminalState, sendsLoaded, lanesTouched };
+}
+function parseArray(value, parser) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const parsed = parser(entry);
+        return parsed ? [parsed] : [];
+    });
+}
+/**
+ * Advisory hints only. A missing, stale, corrupt, or malformed file means no
+ * hints; live planner reads remain the source of correctness. Phase 85 reads
+ * this section only. Phase 86 adds the writer plus writeJsonAtomic.
+ */
+export function readRefillWorkspaceState(workspaceId) {
+    try {
+        const config = getConfig();
+        const refill = config.skillState
+            ?.refill;
+        if (!isRecord(refill) || refill.version !== 1)
+            return null;
+        const byWorkspace = refill.byWorkspace;
+        if (!isRecord(byWorkspace))
+            return null;
+        const workspaceState = byWorkspace[workspaceId];
+        if (!isRecord(workspaceState))
+            return null;
+        return {
+            laneMemory: parseArray(workspaceState.laneMemory, parseLaneMemoryEntry),
+            passRates: parseArray(workspaceState.passRates, parsePassRateObservation),
+            recentRuns: parseArray(workspaceState.recentRuns, parseRunSummaryEntry),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server.js

@@ -10,7 +10,9 @@ import { resolveCampaignFillRoute } from "./tools/campaign-fill-routing.js";
 import { fillCampaignHorizon } from "./tools/campaign-horizon-fill.js";
 import { cancelPrepareCampaignMessages, getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./tools/campaign-message-preparation.js";
 import { getCampaignRefillState } from "./tools/campaign-refill-state.js";
+import { getEvergreenRefillPlan } from "./tools/evergreen-refill-plan.js";
 import { getRefillTargetPlan } from "./tools/refill-target-plan.js";
+import { refillSendsEvergreenCommand } from "./tools/refill-sends-evergreen.js";
 import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
 import { getCampaignTableSchema, queueCampaignCells, recordCampaignReviewBatch, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
 import { archiveCampaign, createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
@@ -223,6 +225,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_refill_state":
                 result = await getCampaignRefillState(args);
                 break;
+            case "get_evergreen_refill_plan":
+                result = await getEvergreenRefillPlan(args);
+                break;
             case "get_refill_target_plan":
                 result = await getRefillTargetPlan(args);
                 break;
@@ -232,6 +237,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "refill_sends":
                 result = await executeRefillSendsCommand(args);
                 break;
+            case "refill_sends_evergreen":
+                result = refillSendsEvergreenCommand(args);
+                break;
             case "setup_evergreen_campaigns":
                 result = await setupEvergreenCampaigns(args);
                 markEvergreenSetupCampaignsDirty(args);
@@ -305,10 +313,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 break;
             case "start_campaign":
-                result = await startCampaign({
-                    campaignId: args?.campaignId,
-                    workspaceId: args?.workspaceId,
-                });
+                result = await startCampaign(args?.campaignId);
                 if (args?.campaignId && result?.success) {
                     markCampaignContextDirty(args.campaignId, "start_campaign");
                 }

package/dist/tools/campaigns.d.ts

@@ -185,7 +185,6 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
-            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -224,7 +223,6 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
-            workspaceId?: undefined;
         };
         required: never[];
         additionalProperties?: undefined;
@@ -263,7 +261,6 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
-            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties?: undefined;
@@ -345,7 +342,6 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
-            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -540,7 +536,6 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
-            workspaceId?: undefined;
         };
         required: never[];
         additionalProperties?: undefined;
@@ -746,49 +741,6 @@ export declare const campaignToolDefinitions: ({
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             messageGenerationMode?: undefined;
-            workspaceId?: undefined;
-        };
-        required: string[];
-        additionalProperties?: undefined;
-    };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            campaignId: {
-                type: string;
-                description: string;
-            };
-            workspaceId: {
-                type: string;
-                description: string;
-            };
-            limit?: undefined;
-            tableId?: undefined;
-            leadLimit?: undefined;
-            page?: undefined;
-            filters?: undefined;
-            name?: undefined;
-            clientProspectId?: undefined;
-            senderLinkedinUrl?: undefined;
-            offerPositioning?: undefined;
-            campaignBrief?: undefined;
-            messageGenerationMode?: undefined;
-            currentStep?: undefined;
-            watchNarration?: undefined;
-            leadSourceType?: undefined;
-            leadSourceProvider?: undefined;
-            selectedLeadListId?: undefined;
-            senderIds?: undefined;
-            currentStepTransition?: undefined;
-            clearCurrentStepIfMatches?: undefined;
-            interactionMode?: undefined;
-            enableICPFilters?: undefined;
-            useMessagingTemplate?: undefined;
-            rubric?: undefined;
-            flowVersion?: undefined;
         };
         required: string[];
         additionalProperties?: undefined;
@@ -830,7 +782,6 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
-            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties?: undefined;
@@ -870,11 +821,7 @@ export interface UpdateCampaignResult {
     _campaign?: CampaignOfferNavigation;
 }
 export declare function updateCampaign(campaignId: string, input: UpdateCampaignInput): Promise<UpdateCampaignResult>;
-type StartCampaignInput = string | {
-    campaignId?: string | null;
-    workspaceId?: string | null;
-};
-export declare function startCampaign(input: StartCampaignInput): Promise<{
+export declare function startCampaign(campaignId: string): Promise<{
     success: boolean;
 }>;
 export declare function pauseCampaign(campaignId: string): Promise<{

package/dist/tools/campaigns.js

@@ -4,7 +4,6 @@ import { assertCreateCampaignPromptLoaded, assertNetNewCreateCampaignResearchRea
 import { setCampaignInteractionMode, } from "./interaction-mode.js";
 import { isLinkedInProfileInput, normalizeLinkedInProfileInput, } from "./linkedin-url.js";
 import { fetchCampaignRubrics } from "./processing.js";
-import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
 const LEAD_SOURCE_PROVIDERS = {
     APOLLO: "apollo-ai",
     SALES_NAV: "sales-nav",
@@ -457,7 +456,7 @@ export const campaignToolDefinitions = [
     },
     {
         name: "start_campaign",
-        description: "Start a paused campaign, enabling the sweeper to send messages. This is an explicit human launch/start action. It is also allowed as the exact selected start_paused_campaign primitive from a bounded refill_sends target packet, using request-scoped workspaceId.",
+        description: "Start a paused campaign, enabling the sweeper to send messages. This is an explicit human launch/start action and must not be used as part of fill-send-horizon, message preparation, or scheduling-proof flows.",
         inputSchema: {
             type: "object",
             properties: {
@@ -465,10 +464,6 @@ export const campaignToolDefinitions = [
                     type: "string",
                     description: "Campaign ID to start",
                 },
-                workspaceId: {
-                    type: "string",
-                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation.",
-                },
             },
             required: ["campaignId"],
         },
@@ -1019,19 +1014,9 @@ export async function updateCampaign(campaignId, input) {
         _campaign: result,
     };
 }
-export async function startCampaign(input) {
-    const campaignId = typeof input === "string" ? input : input.campaignId?.trim();
-    if (!campaignId) {
-        throw new Error("start_campaign requires campaignId");
-    }
-    const workspaceId = typeof input === "string"
-        ? null
-        : normalizeExplicitWorkspaceId(input.workspaceId);
-    const requestOptions = workspaceRequestOptions(workspaceId);
+export async function startCampaign(campaignId) {
     const api = getApi();
-    return requestOptions
-        ? api.post(`/api/v3/campaigns/${campaignId}/start`, { workspaceId }, requestOptions)
-        : api.post(`/api/v3/campaigns/${campaignId}/start`);
+    return api.post(`/api/v3/campaigns/${campaignId}/start`);
 }
 export async function pauseCampaign(campaignId) {
     const api = getApi();

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

@@ -0,0 +1,49 @@
+type GetEvergreenRefillPlanInput = {
+    workspaceId?: string;
+    senderIds?: string[];
+    runState?: Record<string, unknown>;
+    journal?: boolean;
+    journalNote?: string;
+};
+export declare function sanitizeEvergreenRefillPlanResult(value: unknown): Record<string, unknown>;
+export declare const evergreenRefillPlanToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+            senderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            runState: {
+                type: string;
+                description: string;
+            };
+            journal: {
+                type: string;
+                description: string;
+            };
+            journalNote: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function getEvergreenRefillPlan(input: GetEvergreenRefillPlanInput): Promise<{
+    warnings: any[];
+    journalPath: string | null;
+    text: string;
+    workspaceId: string;
+    workspaceResolution: string;
+}>;
+export {};