@sellable/mcp 0.1.309 → 0.1.310

package/dist/tools/campaigns.d.ts

@@ -11,7 +11,7 @@ type LeadSourceProvider = (typeof LEAD_SOURCE_PROVIDERS)[keyof typeof LEAD_SOURC
 export declare function buildWatchUrl(config: Pick<ReturnType<typeof getConfig>, "apiUrl" | "token" | "activeWorkspaceId" | "workspaceId">, path: string): string;
 export type CampaignBuilderWatchMode = "claude" | "codex";
 export declare function getCampaignBuilderWatchModeParam(): CampaignBuilderWatchMode;
-export declare function getCampaignBuilderWatchModeDriverLabel(mode?: CampaignBuilderWatchMode): "Claude Code" | "Codex";
+export declare function getCampaignBuilderWatchModeDriverLabel(mode?: CampaignBuilderWatchMode): "Codex" | "Claude Code";
 export declare function buildCampaignWatchHandoffMarkdown(watchUrl: string, mode?: CampaignBuilderWatchMode): string;
 export interface Campaign {
     id: string;
@@ -416,6 +416,90 @@ export declare const campaignToolDefinitions: ({
                     };
                     workerStatuses: {
                         type: string;
+                        description: string;
+                        properties: {
+                            leadFitBuilder: {
+                                type: string[];
+                                enum: (string | null)[];
+                            };
+                            messageDraftBuilder: {
+                                type: string[];
+                                enum: (string | null)[];
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
+                    workerDetails: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            messageDraftBuilder: {
+                                type: string[];
+                                description: string;
+                                properties: {
+                                    statusSource: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    status: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    runId: {
+                                        type: string[];
+                                    };
+                                    fallbackId: {
+                                        type: string[];
+                                    };
+                                    startedAt: {
+                                        type: string;
+                                    };
+                                    updatedAt: {
+                                        type: string;
+                                    };
+                                    basisToken: {
+                                        type: string[];
+                                    };
+                                    basis: {
+                                        type: string;
+                                        properties: {
+                                            campaignId: {
+                                                type: string[];
+                                            };
+                                            selectedLeadListId: {
+                                                type: string[];
+                                            };
+                                            workflowTableId: {
+                                                type: string[];
+                                            };
+                                            reviewBatchRowHash: {
+                                                type: string[];
+                                            };
+                                            reviewBatchRowIds: {
+                                                type: string[];
+                                                items: {
+                                                    type: string;
+                                                };
+                                            };
+                                            filterChoice: {
+                                                type: string[];
+                                            };
+                                        };
+                                    };
+                                    messageDraftOutputRef: {
+                                        type: string[];
+                                    };
+                                    messageDraftOutput: {
+                                        type: string[];
+                                    };
+                                    error: {
+                                        type: string[];
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        additionalProperties: boolean;
                     };
                 };
                 required: string[];
@@ -531,6 +615,90 @@ export declare const campaignToolDefinitions: ({
                     };
                     workerStatuses: {
                         type: string;
+                        description: string;
+                        properties: {
+                            leadFitBuilder: {
+                                type: string[];
+                                enum: (string | null)[];
+                            };
+                            messageDraftBuilder: {
+                                type: string[];
+                                enum: (string | null)[];
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
+                    workerDetails: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            messageDraftBuilder: {
+                                type: string[];
+                                description: string;
+                                properties: {
+                                    statusSource: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    status: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    runId: {
+                                        type: string[];
+                                    };
+                                    fallbackId: {
+                                        type: string[];
+                                    };
+                                    startedAt: {
+                                        type: string;
+                                    };
+                                    updatedAt: {
+                                        type: string;
+                                    };
+                                    basisToken: {
+                                        type: string[];
+                                    };
+                                    basis: {
+                                        type: string;
+                                        properties: {
+                                            campaignId: {
+                                                type: string[];
+                                            };
+                                            selectedLeadListId: {
+                                                type: string[];
+                                            };
+                                            workflowTableId: {
+                                                type: string[];
+                                            };
+                                            reviewBatchRowHash: {
+                                                type: string[];
+                                            };
+                                            reviewBatchRowIds: {
+                                                type: string[];
+                                                items: {
+                                                    type: string;
+                                                };
+                                            };
+                                            filterChoice: {
+                                                type: string[];
+                                            };
+                                        };
+                                    };
+                                    messageDraftOutputRef: {
+                                        type: string[];
+                                    };
+                                    messageDraftOutput: {
+                                        type: string[];
+                                    };
+                                    error: {
+                                        type: string[];
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        additionalProperties: boolean;
                     };
                 };
                 required: string[];

package/dist/tools/campaigns.js

@@ -10,6 +10,99 @@ const LEAD_SOURCE_PROVIDERS = {
     PROSPEO: "prospeo",
     SIGNAL_DISCOVERY: "signal-discovery",
 };
+const WATCH_NARRATION_TOOL_SCHEMA = {
+    type: "object",
+    description: "Single structured watch-guide narration object to send with currentStep changes. Include what just happened, what the browser is showing now, what Codex is doing next, and nextAction so the browser guide mirrors Codex progress. Do not send separate guideHeadline/guideBody fields. Use workerStatuses only for simple string badges; put Message Drafting runtime proof under workerDetails.messageDraftBuilder.",
+    properties: {
+        stage: {
+            type: "string",
+            enum: [
+                "brief-review",
+                "find-leads",
+                "review-batch",
+                "fit-message",
+                "review-ready",
+            ],
+        },
+        headline: { type: "string" },
+        visibleState: { type: "string" },
+        agentIntent: { type: "string" },
+        nextAction: { type: ["string", "null"] },
+        safety: { type: ["string", "null"] },
+        progressLabel: { type: ["string", "null"] },
+        blockedReason: { type: ["string", "null"] },
+        workerStatuses: {
+            type: "object",
+            description: 'Simple display badges only. Allowed keys are leadFitBuilder and messageDraftBuilder; values are "idle", "running", "ready", "blocked", or null. Do not put runId, statusSource, basis, or rich worker proof here.',
+            properties: {
+                leadFitBuilder: {
+                    type: ["string", "null"],
+                    enum: ["idle", "running", "ready", "blocked", null],
+                },
+                messageDraftBuilder: {
+                    type: ["string", "null"],
+                    enum: ["idle", "running", "ready", "blocked", null],
+                },
+            },
+            additionalProperties: false,
+        },
+        workerDetails: {
+            type: "object",
+            description: "Rich runtime proof for background workers. Message Drafting proof must use workerDetails.messageDraftBuilder, not workerStatuses.messageDrafting.",
+            properties: {
+                messageDraftBuilder: {
+                    type: ["object", "null"],
+                    description: 'Runtime proof that Message Drafting actually started or fell back inline. For a spawned background worker use statusSource "branch" and status "branch-running"; for inline fallback use statusSource "parent-thread-fallback" and status "fallback-active". The basis must include selectedLeadListId, workflowTableId, and either reviewBatchRowHash or reviewBatchRowIds so the watched UI can trust the current execution slice.',
+                    properties: {
+                        statusSource: {
+                            type: "string",
+                            enum: ["branch", "parent-thread-fallback"],
+                        },
+                        status: {
+                            type: "string",
+                            enum: [
+                                "branch-running",
+                                "fallback-active",
+                                "spawn-failed",
+                                "fallback-superseded",
+                                "branch-superseded",
+                                "ready",
+                                "blocked",
+                                "retry-needed",
+                                "stale",
+                            ],
+                        },
+                        runId: { type: ["string", "null"] },
+                        fallbackId: { type: ["string", "null"] },
+                        startedAt: { type: "string" },
+                        updatedAt: { type: "string" },
+                        basisToken: { type: ["string", "null"] },
+                        basis: {
+                            type: "object",
+                            properties: {
+                                campaignId: { type: ["string", "null"] },
+                                selectedLeadListId: { type: ["string", "null"] },
+                                workflowTableId: { type: ["string", "null"] },
+                                reviewBatchRowHash: { type: ["string", "null"] },
+                                reviewBatchRowIds: {
+                                    type: ["array", "null"],
+                                    items: { type: "string" },
+                                },
+                                filterChoice: { type: ["string", "null"] },
+                            },
+                        },
+                        messageDraftOutputRef: { type: ["string", "null"] },
+                        messageDraftOutput: { type: ["object", "null"] },
+                        error: { type: ["string", "null"] },
+                    },
+                    required: ["statusSource", "status", "startedAt", "updatedAt", "basis"],
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    required: ["stage", "headline", "visibleState", "agentIntent", "nextAction"],
+};
 function normalizeLeadSourceProvider(input) {
     if (!input)
         return null;
@@ -236,37 +329,7 @@ export const campaignToolDefinitions = [
                     type: ["string", "null"],
                     description: "Workflow step ID (headless or UI step ID such as filter-rules)",
                 },
-                watchNarration: {
-                    type: "object",
-                    description: "Single structured watch-guide narration object to send with currentStep changes. Include what just happened, what the browser is showing now, what Codex is doing next, and nextAction so the browser guide mirrors Codex progress.",
-                    properties: {
-                        stage: {
-                            type: "string",
-                            enum: [
-                                "brief-review",
-                                "find-leads",
-                                "review-batch",
-                                "fit-message",
-                                "review-ready",
-                            ],
-                        },
-                        headline: { type: "string" },
-                        visibleState: { type: "string" },
-                        agentIntent: { type: "string" },
-                        nextAction: { type: ["string", "null"] },
-                        safety: { type: ["string", "null"] },
-                        progressLabel: { type: ["string", "null"] },
-                        blockedReason: { type: ["string", "null"] },
-                        workerStatuses: { type: "object" },
-                    },
-                    required: [
-                        "stage",
-                        "headline",
-                        "visibleState",
-                        "agentIntent",
-                        "nextAction",
-                    ],
-                },
+                watchNarration: WATCH_NARRATION_TOOL_SCHEMA,
                 leadSourceType: {
                     type: ["string", "null"],
                     description: "Lead source type (existing | new)",
@@ -344,37 +407,7 @@ export const campaignToolDefinitions = [
                     type: "string",
                     description: "Guarded manual recovery clear. currentStep:null is accepted only when this matches the durable step being cleared.",
                 },
-                watchNarration: {
-                    type: "object",
-                    description: "Single structured watch-guide narration object to send with currentStep changes. Include what just happened, what the browser is showing now, what Codex is doing next, and nextAction so the browser guide mirrors Codex progress. Do not send separate guideHeadline/guideBody fields.",
-                    properties: {
-                        stage: {
-                            type: "string",
-                            enum: [
-                                "brief-review",
-                                "find-leads",
-                                "review-batch",
-                                "fit-message",
-                                "review-ready",
-                            ],
-                        },
-                        headline: { type: "string" },
-                        visibleState: { type: "string" },
-                        agentIntent: { type: "string" },
-                        nextAction: { type: ["string", "null"] },
-                        safety: { type: ["string", "null"] },
-                        progressLabel: { type: ["string", "null"] },
-                        blockedReason: { type: ["string", "null"] },
-                        workerStatuses: { type: "object" },
-                    },
-                    required: [
-                        "stage",
-                        "headline",
-                        "visibleState",
-                        "agentIntent",
-                        "nextAction",
-                    ],
-                },
+                watchNarration: WATCH_NARRATION_TOOL_SCHEMA,
                 interactionMode: {
                     type: "string",
                     enum: ["step-by-step", "autonomous", "ask-when-needed"],

package/dist/tools/model-quality.d.ts

@@ -12,31 +12,7 @@ export type CampaignModelQualityResult = {
     reasoningEffort: string | null;
     recommendedModel: string;
     recommendedReasoningEffort: string;
-    minimumSummary: string;
     confirmationRequired: boolean;
     message: string;
 };
-export type CampaignModelQualityHostConfig = {
-    label: string;
-    minimumModel: string;
-    familyKeywords: string[];
-    minimumVersion: string;
-    minimumReasoningEffort: string;
-    acceptedReasoningEfforts: string[];
-    recommendedReasoningEffort: string;
-};
-export type CampaignModelQualityConfig = {
-    version: number;
-    hosts: {
-        claude: CampaignModelQualityHostConfig;
-        codex: CampaignModelQualityHostConfig;
-    };
-    warningCopy: {
-        ok: string;
-        unknownSettings: string;
-        belowMinimum: string;
-    };
-};
-export declare function getCampaignModelQualityConfig(): CampaignModelQualityConfig;
-export declare function getCampaignModelMinimumSummary(config?: CampaignModelQualityConfig): string;
 export declare function evaluateCampaignModelQuality(input?: CampaignModelQualityInput): CampaignModelQualityResult;

package/dist/tools/model-quality.js

@@ -1,57 +1,9 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { resolveSkillsDir } from "../skills.js";
-const DEFAULT_MODEL_QUALITY_CONFIG = {
-    version: 1,
-    hosts: {
-        claude: {
-            label: "Claude Code",
-            minimumModel: "Claude Opus 4.8",
-            familyKeywords: ["opus"],
-            minimumVersion: "4.8",
-            minimumReasoningEffort: "high",
-            acceptedReasoningEfforts: [
-                "high",
-                "extra high",
-                "extra-high",
-                "xhigh",
-                "extra_high",
-            ],
-            recommendedReasoningEffort: "high or better",
-        },
-        codex: {
-            label: "Codex",
-            minimumModel: "GPT 5.5",
-            familyKeywords: ["gpt"],
-            minimumVersion: "5.5",
-            minimumReasoningEffort: "high",
-            acceptedReasoningEfforts: [
-                "high",
-                "extra high",
-                "extra-high",
-                "xhigh",
-                "extra_high",
-            ],
-            recommendedReasoningEffort: "high or better",
-        },
-    },
-    warningCopy: {
-        ok: "Campaign model settings meet the configured minimum: {minimumSummary}.",
-        unknownSettings: "Model settings were not provided by the host. Best campaigns need at least {minimumSummary}. Confirm the user is on one of those settings, or ask them to switch before continuing.",
-        belowMinimum: "Best campaigns need at least {minimumSummary}. Current settings look below that: {currentSettings}. Please switch before continuing, or explicitly say to continue anyway.",
-    },
-};
-let cachedConfig = null;
 const normalize = (value) => String(value ?? "")
     .trim()
     .toLowerCase();
 const normalizeHost = (host) => {
     const normalized = normalize(host);
-    if (normalized.includes("claude") ||
-        normalized.includes("clod") ||
-        normalized.includes("opus") ||
-        normalized.includes("sonnet") ||
-        normalized.includes("haiku")) {
+    if (normalized.includes("claude") || normalized.includes("clod")) {
         return "claude";
     }
     if (normalized.includes("codex") ||
@@ -61,101 +13,20 @@ const normalizeHost = (host) => {
     }
     return "unknown";
 };
-const normalizeReasoning = (reasoning) => normalize(reasoning).replace(/[_\s-]+/g, "");
-const compareVersion = (candidate, minimum) => {
-    const candidateParts = candidate.split(".").map((part) => Number(part));
-    const minimumParts = minimum.split(".").map((part) => Number(part));
-    const length = Math.max(candidateParts.length, minimumParts.length);
-    for (let index = 0; index < length; index += 1) {
-        const candidatePart = candidateParts[index] ?? 0;
-        const minimumPart = minimumParts[index] ?? 0;
-        if (candidatePart > minimumPart)
-            return 1;
-        if (candidatePart < minimumPart)
-            return -1;
-    }
-    return 0;
+const isHighClaudeReasoning = (reasoning) => {
+    const normalized = normalize(reasoning).replace(/[_\s-]+/g, "");
+    return ["high", "xhigh", "extrahigh"].includes(normalized);
+};
+const isExtraHighCodexReasoning = (reasoning) => {
+    const normalized = normalize(reasoning).replace(/[_\s-]+/g, "");
+    return ["xhigh", "extrahigh"].includes(normalized);
 };
-const extractModelVersions = (model) => Array.from(normalize(model).matchAll(/\b(\d+(?:\.\d+){0,2})\b/g)).map((match) => match[1]);
-function mergeConfig(rawConfig) {
-    return {
-        ...DEFAULT_MODEL_QUALITY_CONFIG,
-        ...rawConfig,
-        hosts: {
-            claude: {
-                ...DEFAULT_MODEL_QUALITY_CONFIG.hosts.claude,
-                ...(rawConfig.hosts?.claude || {}),
-            },
-            codex: {
-                ...DEFAULT_MODEL_QUALITY_CONFIG.hosts.codex,
-                ...(rawConfig.hosts?.codex || {}),
-            },
-        },
-        warningCopy: {
-            ...DEFAULT_MODEL_QUALITY_CONFIG.warningCopy,
-            ...(rawConfig.warningCopy || {}),
-        },
-    };
-}
-export function getCampaignModelQualityConfig() {
-    if (cachedConfig)
-        return cachedConfig;
-    const configPath = join(resolveSkillsDir(), "create-campaign", "core", "model-quality.json");
-    if (!existsSync(configPath)) {
-        cachedConfig = DEFAULT_MODEL_QUALITY_CONFIG;
-        return cachedConfig;
-    }
-    try {
-        cachedConfig = mergeConfig(JSON.parse(readFileSync(configPath, "utf-8")));
-    }
-    catch {
-        cachedConfig = DEFAULT_MODEL_QUALITY_CONFIG;
-    }
-    return cachedConfig;
-}
-export function getCampaignModelMinimumSummary(config = getCampaignModelQualityConfig()) {
-    return `${config.hosts.claude.minimumModel} with ${config.hosts.claude.minimumReasoningEffort} reasoning or ${config.hosts.codex.minimumModel} with ${config.hosts.codex.minimumReasoningEffort} reasoning`;
-}
-function formatCopy(template, values) {
-    return Object.entries(values).reduce((text, [key, value]) => text.replaceAll(`{${key}}`, value), template);
-}
-function acceptsReasoning(reasoning, hostConfig) {
-    const normalized = normalizeReasoning(reasoning);
-    return hostConfig.acceptedReasoningEfforts
-        .map((value) => normalizeReasoning(value))
-        .includes(normalized);
-}
-function modelMeetsMinimum(model, hostConfig) {
-    const normalizedModel = normalize(model).replace(/[_-]+/g, " ");
-    if (!normalizedModel)
-        return false;
-    const familyMatches = hostConfig.familyKeywords.every((keyword) => normalizedModel.includes(normalize(keyword)));
-    if (!familyMatches)
-        return false;
-    const versions = extractModelVersions(normalizedModel);
-    if (!hostConfig.minimumVersion)
-        return true;
-    return versions.some((version) => compareVersion(version, hostConfig.minimumVersion) >= 0);
-}
-function findAcceptedHostConfig(host, model, config) {
-    const candidates = host === "unknown"
-        ? [
-            ["claude", config.hosts.claude],
-            ["codex", config.hosts.codex],
-        ]
-        : [[host, config.hosts[host]]];
-    return candidates.find(([, hostConfig]) => modelMeetsMinimum(model, hostConfig));
-}
 export function evaluateCampaignModelQuality(input = {}) {
-    const config = getCampaignModelQualityConfig();
-    const host = normalizeHost([input.host, input.model].filter(Boolean).join(" "));
+    const host = normalizeHost(input.host);
     const model = input.model?.trim() || null;
     const reasoningEffort = input.reasoningEffort?.trim() || null;
-    const recommendationHost = host === "claude" ? "claude" : "codex";
-    const recommendedHostConfig = config.hosts[recommendationHost];
-    const minimumSummary = getCampaignModelMinimumSummary(config);
-    const recommendedModel = recommendedHostConfig.minimumModel;
-    const recommendedReasoningEffort = recommendedHostConfig.recommendedReasoningEffort;
+    const recommendedModel = host === "claude" ? "Opus 4.8" : "GPT 5.5";
+    const recommendedReasoningEffort = host === "claude" ? "high or extra high" : "extra high";
     if (!model && !reasoningEffort) {
         return {
             status: "unknown",
@@ -164,37 +35,30 @@ export function evaluateCampaignModelQuality(input = {}) {
             reasoningEffort,
             recommendedModel,
             recommendedReasoningEffort,
-            minimumSummary,
             confirmationRequired: true,
-            message: formatCopy(config.warningCopy.unknownSettings, {
-                minimumSummary,
-                currentSettings: "unknown",
-            }),
+            message: "Model settings were not provided by the host. Before campaign-critical generation, confirm the user is using Claude Opus 4.8 at high/extra high or Codex GPT 5.5 at extra high.",
         };
     }
-    const acceptedHostConfig = findAcceptedHostConfig(host, model, config);
-    const ok = Boolean(acceptedHostConfig && acceptsReasoning(reasoningEffort, acceptedHostConfig[1]));
+    const normalizedModel = normalize(model);
+    const ok = host === "claude"
+        ? normalizedModel.includes("opus") &&
+            normalizedModel.includes("4.8") &&
+            isHighClaudeReasoning(reasoningEffort)
+        : normalizedModel.includes("gpt") &&
+            normalizedModel.includes("5.5") &&
+            isExtraHighCodexReasoning(reasoningEffort);
     if (ok) {
         return {
             status: "ok",
-            host: acceptedHostConfig?.[0] ?? host,
+            host,
             model,
             reasoningEffort,
-            recommendedModel: acceptedHostConfig?.[1].minimumModel ?? recommendedModel,
-            recommendedReasoningEffort: acceptedHostConfig?.[1].recommendedReasoningEffort ??
-                recommendedReasoningEffort,
-            minimumSummary,
+            recommendedModel,
+            recommendedReasoningEffort,
             confirmationRequired: false,
-            message: formatCopy(config.warningCopy.ok, {
-                minimumSummary,
-                currentSettings: "current settings",
-            }),
+            message: "Recommended campaign-quality model settings are active.",
         };
     }
-    const currentSettings = [
-        model ? `model "${model}"` : "unknown model",
-        reasoningEffort ? `reasoning "${reasoningEffort}"` : "unknown reasoning",
-    ].join(", ");
     return {
         status: "warn",
         host,
@@ -202,11 +66,7 @@ export function evaluateCampaignModelQuality(input = {}) {
         reasoningEffort,
         recommendedModel,
         recommendedReasoningEffort,
-        minimumSummary,
         confirmationRequired: true,
-        message: formatCopy(config.warningCopy.belowMinimum, {
-            minimumSummary,
-            currentSettings,
-        }),
+        message: `For best campaign quality, switch to ${recommendedModel} with ${recommendedReasoningEffort} reasoning before lead filtering, message generation, or launch review.`,
     };
 }