@sellable/mcp 0.1.307 → 0.1.309

package/dist/tools/model-quality.js

@@ -1,9 +1,57 @@
+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")) {
+    if (normalized.includes("claude") ||
+        normalized.includes("clod") ||
+        normalized.includes("opus") ||
+        normalized.includes("sonnet") ||
+        normalized.includes("haiku")) {
         return "claude";
     }
     if (normalized.includes("codex") ||
@@ -13,20 +61,101 @@ const normalizeHost = (host) => {
     }
     return "unknown";
 };
-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 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 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 host = normalizeHost(input.host);
+    const config = getCampaignModelQualityConfig();
+    const host = normalizeHost([input.host, input.model].filter(Boolean).join(" "));
     const model = input.model?.trim() || null;
     const reasoningEffort = input.reasoningEffort?.trim() || null;
-    const recommendedModel = host === "claude" ? "Opus 4.8" : "GPT 5.5";
-    const recommendedReasoningEffort = host === "claude" ? "high or extra high" : "extra high";
+    const recommendationHost = host === "claude" ? "claude" : "codex";
+    const recommendedHostConfig = config.hosts[recommendationHost];
+    const minimumSummary = getCampaignModelMinimumSummary(config);
+    const recommendedModel = recommendedHostConfig.minimumModel;
+    const recommendedReasoningEffort = recommendedHostConfig.recommendedReasoningEffort;
     if (!model && !reasoningEffort) {
         return {
             status: "unknown",
@@ -35,30 +164,37 @@ export function evaluateCampaignModelQuality(input = {}) {
             reasoningEffort,
             recommendedModel,
             recommendedReasoningEffort,
+            minimumSummary,
             confirmationRequired: true,
-            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.",
+            message: formatCopy(config.warningCopy.unknownSettings, {
+                minimumSummary,
+                currentSettings: "unknown",
+            }),
         };
     }
-    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);
+    const acceptedHostConfig = findAcceptedHostConfig(host, model, config);
+    const ok = Boolean(acceptedHostConfig && acceptsReasoning(reasoningEffort, acceptedHostConfig[1]));
     if (ok) {
         return {
             status: "ok",
-            host,
+            host: acceptedHostConfig?.[0] ?? host,
             model,
             reasoningEffort,
-            recommendedModel,
-            recommendedReasoningEffort,
+            recommendedModel: acceptedHostConfig?.[1].minimumModel ?? recommendedModel,
+            recommendedReasoningEffort: acceptedHostConfig?.[1].recommendedReasoningEffort ??
+                recommendedReasoningEffort,
+            minimumSummary,
             confirmationRequired: false,
-            message: "Recommended campaign-quality model settings are active.",
+            message: formatCopy(config.warningCopy.ok, {
+                minimumSummary,
+                currentSettings: "current settings",
+            }),
         };
     }
+    const currentSettings = [
+        model ? `model "${model}"` : "unknown model",
+        reasoningEffort ? `reasoning "${reasoningEffort}"` : "unknown reasoning",
+    ].join(", ");
     return {
         status: "warn",
         host,
@@ -66,7 +202,11 @@ export function evaluateCampaignModelQuality(input = {}) {
         reasoningEffort,
         recommendedModel,
         recommendedReasoningEffort,
+        minimumSummary,
         confirmationRequired: true,
-        message: `For best campaign quality, switch to ${recommendedModel} with ${recommendedReasoningEffort} reasoning before lead filtering, message generation, or launch review.`,
+        message: formatCopy(config.warningCopy.belowMinimum, {
+            minimumSummary,
+            currentSettings,
+        }),
     };
 }

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -114,6 +114,12 @@ sends", use `approvalMode:"approve"` to approve exactly the bounded X-message
 cohort during preparation, then continue through sender, sequence, and final
 launch greenlight; the launch path must verify that bounded cohort and must not
 broad approve-all.
+When approving reviewed draft rows in the campaign table, resolve the actual
+visible `Approved` cells with `select_campaign_cells({ columnRole: "approved",
+rowSelector: { type: "rowIds", rowIds } })` and `update_cell` those returned
+cell IDs. Do not rely on `approveCellId` from `get_rows` unless it matches the
+semantic selector result; it may be a row-level helper and leave the UI checkbox
+unchecked.
 Treat `campaignId` as `CampaignOffer.id`. Low level selector/queue tools are
 diagnostics and recovery only for this lane. If the user asks to stop
 preparation, the target is wrong, or status shows the wrong campaign/table, call
@@ -168,6 +174,12 @@ person/company this campaign is for, then I’ll turn that into a campaign brief
 before we move into lead sourcing.
 ```
 
+Exception: if `bootstrap_create_campaign.modelQuality.status === "warn"`,
+the first visible campaign message must be the model-quality warning from
+`modelQuality.message`. Ask the user to switch to the configured minimum model
+or explicitly continue anyway before identity setup, research, lead filtering,
+message generation, or launch review.
+
 If a linked/local skill file is stale or missing, silently use the installed
 `sellable@sellable` plugin copy. Do not tell the user about the stale link,
 the old version, or the replacement path.
@@ -912,8 +924,11 @@ updates.
    - Do not call `mcp__sellable__get_campaigns`.
    - Do not call `mcp__sellable__get_campaign` to hunt for IDs.
    - Do not call `mcp__sellable__create_campaign({ campaignId: ... })` unless the user supplied that id.
-6. Call `mcp__sellable__bootstrap_create_campaign({ flowVersion: "v2", campaignId? })`.
+6. Call `mcp__sellable__bootstrap_create_campaign({ flowVersion: "v2", campaignId?, host?, model?, reasoningEffort? })`.
+   Pass the current host, model, and reasoning when the host exposes them.
 7. If `safeToProceed !== true`, stop and show `blockingErrors` + `nextStep`.
+8. If `modelQuality.status === "warn"`, show `modelQuality.message` before any
+   setup/research and wait for the user to switch or explicitly continue.
 
 ## Execute Workflow
 

package/skills/create-campaign/core/model-quality.json

@@ -0,0 +1,28 @@
+{
+  "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."
+  }
+}