@sellable/mcp 0.1.315 → 0.1.318

package/README.md

@@ -302,11 +302,32 @@ Use the same MCP runtime preflight in both hosts:
 
 Canonical shortcut:
 
-- `bootstrap_create_campaign({ flowVersion: "v2", campaignId?, host?, model?, reasoningEffort? })`
+- `bootstrap_create_campaign({ flowVersion: "v2", campaignId?, host?, model?, reasoningEffort?, modelMetadataSource? })`
+
+Pass model/reasoning metadata only when it comes from active turn/runtime
+metadata or explicit user confirmation. For Codex, use
+`nodeRepl.requestMeta["x-codex-turn-metadata"]` and pass
+`modelMetadataSource: "codex_turn_metadata"`. Config files such as
+`~/.codex/config.toml` are fallback/cross-check evidence only and must not
+trigger model-switch warnings.
+
+For Claude Code, pass model metadata only when the current host exposes active
+runtime model and effort for the same session, or when the user explicitly
+confirms current `/status` or `/model` output that includes both model and effort.
+If the current Claude session context explicitly states both values, use
+`modelMetadataSource: "claude_session_context"`. Use
+`modelMetadataSource: "user_confirmed"` for explicit user confirmation. Do not
+use a nested `claude -p` run, `~/.claude/settings.json`, or CLI defaults as
+active-session evidence.
+
+Claude session-context self-report shape:
 
-Pass host/model/reasoning metadata when the host exposes it. The bootstrap
-model-quality check uses packaged config and warns before campaign setup when a
-known model is below the configured minimum.
+```text
+- Model (name): ...
+- Model (ID): ...
+- Reasoning effort: ...
+- Source: active Claude Code session context
+```
 
 If bootstrap returns blocking errors, fail fast and do not continue into provider
 search/import tools.

package/dist/tools/bootstrap.d.ts

@@ -11,6 +11,7 @@ type BootstrapCreateCampaignInput = {
     host?: string;
     model?: string;
     reasoningEffort?: string;
+    modelMetadataSource?: string;
 };
 type BootstrapCheck = {
     key: "auth" | "update" | "framework" | "model_quality" | "resume_context" | "subskill_catalog" | "create_campaign_subskill";
@@ -87,6 +88,10 @@ export declare const bootstrapToolDefinitions: {
                 type: string;
                 description: string;
             };
+            modelMetadataSource: {
+                type: string;
+                description: string;
+            };
         };
         additionalProperties: boolean;
     };

package/dist/tools/bootstrap.js

@@ -18,7 +18,7 @@ function toGuidance(check, message) {
         return "Fix framework files and rerun bootstrap_create_campaign.";
     }
     if (check === "model_quality") {
-        return `Use at least ${getCampaignModelMinimumSummary()} for campaign-critical generation.`;
+        return `Use trusted active-turn metadata before enforcing the campaign model floor: ${getCampaignModelMinimumSummary()}.`;
     }
     if (check === "resume_context") {
         return "Confirm the campaignId exists and is accessible, then retry bootstrap_create_campaign.";
@@ -98,15 +98,19 @@ export const bootstrapToolDefinitions = [
                 },
                 host: {
                     type: "string",
-                    description: "Optional host label for model-quality preflight, for example Claude Code or Codex.",
+                    description: "Optional host label for active model-quality preflight, for example Claude Code or Codex.",
                 },
                 model: {
                     type: "string",
-                    description: `Optional current host model name. Minimum campaign quality config: ${getCampaignModelMinimumSummary()}.`,
+                    description: "Optional active host model name from runtime metadata. Do not pass config defaults.",
                 },
                 reasoningEffort: {
                     type: "string",
-                    description: `Optional current reasoning setting. Minimum campaign quality config: ${getCampaignModelMinimumSummary()}.`,
+                    description: "Optional active reasoning setting from runtime metadata. Do not pass config defaults.",
+                },
+                modelMetadataSource: {
+                    type: "string",
+                    description: "Where active model metadata came from, for example codex_turn_metadata, claude_runtime_metadata, claude_session_context, active_turn_metadata, or user_confirmed.",
                 },
             },
             additionalProperties: false,
@@ -129,6 +133,7 @@ export async function bootstrapCreateCampaign(input = {}) {
         host: input.host,
         model: input.model,
         reasoningEffort: input.reasoningEffort,
+        metadataSource: input.modelMetadataSource,
     });
     const runAuthCheck = async () => {
         let status = await getAuthStatus();
@@ -188,7 +193,7 @@ export async function bootstrapCreateCampaign(input = {}) {
     }
     requiredChecks.push({
         key: "model_quality",
-        ok: modelQuality.status === "ok",
+        ok: modelQuality.status !== "warn",
         blocking: false,
         detail: modelQuality.message,
     });

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

@@ -3,6 +3,7 @@ export type CampaignModelQualityInput = {
     host?: string | null;
     model?: string | null;
     reasoningEffort?: string | null;
+    metadataSource?: string | null;
 };
 export type CampaignModelQualityStatus = "ok" | "warn" | "unknown";
 export type CampaignModelQualityResult = {
@@ -10,6 +11,7 @@ export type CampaignModelQualityResult = {
     host: CampaignModelHost;
     model: string | null;
     reasoningEffort: string | null;
+    metadataSource: string | null;
     recommendedModel: string;
     recommendedReasoningEffort: string;
     minimumSummary: string;
@@ -34,8 +36,7 @@ export type CampaignModelQualityConfig = {
     };
     warningCopy: {
         ok: string;
-        staleCodexMetadata: string;
-        unknownSettings: string;
+        skipped: string;
         belowMinimum: string;
     };
 };

package/dist/tools/model-quality.js

@@ -1,8 +1,5 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { resolveSkillsDir } from "../skills.js";
 const DEFAULT_MODEL_QUALITY_CONFIG = {
-    version: 1,
+    version: 2,
     hosts: {
         claude: {
             label: "Claude Code",
@@ -36,20 +33,24 @@ const DEFAULT_MODEL_QUALITY_CONFIG = {
         },
     },
     warningCopy: {
-        ok: "Campaign model settings meet the configured minimum: {minimumSummary}.",
-        staleCodexMetadata: "Codex host metadata appears stale: it can report GPT-5/default or GPT-5/high even when the UI is set to GPT 5.5 Extra High. Treating this as acceptable; continue without asking the user to switch.",
-        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.",
+        ok: "Active host model metadata meets the configured campaign floor: {currentSettings}.",
+        skipped: "Active host model metadata was not available from a trusted runtime source. Continue without asking the user to switch models.",
+        belowMinimum: "Active host metadata reports {currentSettings}, which is below the configured campaign floor: {minimumSummary}. Ask the user to switch before continuing, or explicitly say to continue anyway.",
     },
 };
-let cachedConfig = null;
+const TRUSTED_METADATA_SOURCE_KEYWORDS = [
+    "codex_turn_metadata",
+    "claude_runtime_metadata",
+    "claude_session_context",
+    "active_turn_metadata",
+    "user_confirmed",
+];
 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")) {
@@ -62,12 +63,6 @@ const normalizeHost = (host) => {
     }
     return "unknown";
 };
-const normalizeHostFromInput = (host, model) => {
-    const explicitHost = normalizeHost(host);
-    if (explicitHost !== "unknown")
-        return explicitHost;
-    return normalizeHost(model);
-};
 const normalizeReasoning = (reasoning) => normalize(reasoning).replace(/[_\s-]+/g, "");
 const compareVersion = (candidate, minimum) => {
     const candidateParts = candidate.split(".").map((part) => Number(part));
@@ -83,50 +78,12 @@ const compareVersion = (candidate, minimum) => {
     }
     return 0;
 };
-const extractModelVersions = (model) => Array.from(normalize(model).matchAll(/\b(\d+(?:\.\d+){0,2})\b/g)).map((match) => match[1]);
-function modelContainsOtherHostFamily(model, currentHostConfig, config) {
-    const normalizedModel = normalize(model).replace(/[_-]+/g, " ");
-    if (!normalizedModel)
-        return false;
-    return Object.values(config.hosts)
-        .filter((hostConfig) => hostConfig !== currentHostConfig)
-        .some((hostConfig) => hostConfig.familyKeywords.some((keyword) => normalizedModel.includes(normalize(keyword))));
-}
-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 || {}),
-        },
-    };
-}
+const extractModelVersions = (model) => {
+    const normalized = normalize(model).replace(/(?<=\d)[_-](?=\d)/g, ".");
+    return Array.from(normalized.matchAll(/\b(\d+(?:\.\d+){0,2})\b/g)).map((match) => match[1]);
+};
 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;
+    return DEFAULT_MODEL_QUALITY_CONFIG;
 }
 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`;
@@ -148,12 +105,12 @@ function modelMeetsMinimum(model, hostConfig, options = {}) {
         hostConfig.familyKeywords.every((keyword) => normalizedModel.includes(normalize(keyword)));
     if (!familyMatches)
         return false;
-    const versions = extractModelVersions(normalizedModel);
+    const versions = extractModelVersions(model);
     if (!hostConfig.minimumVersion)
         return true;
     return versions.some((version) => compareVersion(version, hostConfig.minimumVersion) >= 0);
 }
-function findAcceptedHostConfig(host, model, config) {
+function findHostConfig(host, model, config) {
     const candidates = host === "unknown"
         ? [
             ["claude", config.hosts.claude],
@@ -161,104 +118,66 @@ function findAcceptedHostConfig(host, model, config) {
         ]
         : [[host, config.hosts[host]]];
     return candidates.find(([, hostConfig]) => modelMeetsMinimum(model, hostConfig, {
-        familyKnownFromHost: host !== "unknown" &&
-            !modelContainsOtherHostFamily(model, hostConfig, config),
+        familyKnownFromHost: host !== "unknown",
     }));
 }
-function looksLikeCodexStaleMetadata(host, model, reasoningEffort, config) {
-    if (host !== "codex")
-        return false;
-    if (!model || !reasoningEffort)
-        return false;
-    const normalizedModel = normalize(model).replace(/[_-]+/g, " ");
-    const normalizedReasoning = normalizeReasoning(reasoningEffort);
-    if (!normalizedModel.includes("gpt"))
-        return false;
-    const versions = extractModelVersions(normalizedModel);
-    const looksLikeBaseGpt5 = versions.some((version) => version === "5" || version === "5.0");
-    if (!looksLikeBaseGpt5)
-        return false;
-    return (["default", "auto", "standard"].includes(normalizedReasoning) ||
-        acceptsReasoning(reasoningEffort, config.hosts.codex));
+function isTrustedMetadataSource(source) {
+    const normalized = normalize(source).replace(/[\s-]+/g, "_");
+    return TRUSTED_METADATA_SOURCE_KEYWORDS.some((keyword) => normalized.includes(keyword));
 }
 export function evaluateCampaignModelQuality(input = {}) {
     const config = getCampaignModelQualityConfig();
-    const host = normalizeHostFromInput(input.host, input.model);
+    const host = normalizeHost([input.host, input.model].filter(Boolean).join(" "));
     const model = input.model?.trim() || null;
     const reasoningEffort = input.reasoningEffort?.trim() || null;
+    const metadataSource = input.metadataSource?.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;
-    if (!model && !reasoningEffort) {
+    const currentSettings = [
+        model ? `model "${model}"` : "unknown model",
+        reasoningEffort ? `reasoning "${reasoningEffort}"` : "unknown reasoning",
+        metadataSource ? `source "${metadataSource}"` : "unknown source",
+    ].join(", ");
+    const base = {
+        host,
+        model,
+        reasoningEffort,
+        metadataSource,
+        recommendedModel: recommendedHostConfig.minimumModel,
+        recommendedReasoningEffort: recommendedHostConfig.recommendedReasoningEffort,
+        minimumSummary,
+        metadataStale: false,
+    };
+    if (!isTrustedMetadataSource(metadataSource) || !model || !reasoningEffort) {
         return {
+            ...base,
             status: "unknown",
-            host,
-            model,
-            reasoningEffort,
-            recommendedModel,
-            recommendedReasoningEffort,
-            minimumSummary,
-            confirmationRequired: true,
-            metadataStale: false,
-            message: formatCopy(config.warningCopy.unknownSettings, {
-                minimumSummary,
-                currentSettings: "unknown",
-            }),
+            confirmationRequired: false,
+            message: config.warningCopy.skipped,
         };
     }
-    const acceptedHostConfig = findAcceptedHostConfig(host, model, config);
+    const acceptedHostConfig = findHostConfig(host, model, config);
     const ok = Boolean(acceptedHostConfig && acceptsReasoning(reasoningEffort, acceptedHostConfig[1]));
     if (ok) {
         return {
+            ...base,
             status: "ok",
             host: acceptedHostConfig?.[0] ?? host,
-            model,
-            reasoningEffort,
-            recommendedModel: acceptedHostConfig?.[1].minimumModel ?? recommendedModel,
+            recommendedModel: acceptedHostConfig?.[1].minimumModel ?? base.recommendedModel,
             recommendedReasoningEffort: acceptedHostConfig?.[1].recommendedReasoningEffort ??
-                recommendedReasoningEffort,
-            minimumSummary,
+                base.recommendedReasoningEffort,
             confirmationRequired: false,
-            metadataStale: false,
             message: formatCopy(config.warningCopy.ok, {
                 minimumSummary,
-                currentSettings: "current settings",
+                currentSettings,
             }),
         };
     }
-    if (looksLikeCodexStaleMetadata(host, model, reasoningEffort, config)) {
-        return {
-            status: "ok",
-            host,
-            model,
-            reasoningEffort,
-            recommendedModel,
-            recommendedReasoningEffort,
-            minimumSummary,
-            confirmationRequired: false,
-            metadataStale: true,
-            message: formatCopy(config.warningCopy.staleCodexMetadata, {
-                minimumSummary,
-                currentSettings: "stale Codex host metadata",
-            }),
-        };
-    }
-    const currentSettings = [
-        model ? `model "${model}"` : "unknown model",
-        reasoningEffort ? `reasoning "${reasoningEffort}"` : "unknown reasoning",
-    ].join(", ");
     return {
+        ...base,
         status: "warn",
-        host,
-        model,
-        reasoningEffort,
-        recommendedModel,
-        recommendedReasoningEffort,
-        minimumSummary,
         confirmationRequired: true,
-        metadataStale: false,
         message: formatCopy(config.warningCopy.belowMinimum, {
             minimumSummary,
             currentSettings,

package/dist/tools/registry.d.ts

@@ -407,6 +407,10 @@ export declare const allTools: ({
                 type: string;
                 description: string;
             };
+            modelMetadataSource: {
+                type: string;
+                description: string;
+            };
         };
         additionalProperties: boolean;
     };

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -179,17 +179,11 @@ 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"` and
-`bootstrap_create_campaign.modelQuality.metadataStale !== true`, 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 `metadataStale === true`, continue
-normally and do not ask the user to switch.
-
-If `bootstrap_create_campaign.modelQuality.metadataStale === true`, continue
-normally. Do not ask the user to switch models; this is an accepted Codex host
-metadata mismatch.
+Exception: if `bootstrap_create_campaign.modelQuality.status === "warn"`, the
+first visible campaign message must be the model-quality warning from
+`modelQuality.message`. Only trust that warning when bootstrap received active
+turn/runtime metadata or an explicit user-confirmed model. Do not warn from
+config defaults, stale host labels, or inferred model names.
 
 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,
@@ -207,6 +201,55 @@ clear business decisions, tradeoffs, and approval gates. Use product language:
 - "I can create a draft shell for you to watch with approval gates before
   sourcing", not mutation jargon
 
+## Active Model Metadata
+
+Before calling `bootstrap_create_campaign`, collect the active host model data
+only from a source that can describe this turn:
+
+- Codex: if `mcp__node_repl__js` is available, inspect only
+  `nodeRepl.requestMeta["x-codex-turn-metadata"].model` and
+  `nodeRepl.requestMeta["x-codex-turn-metadata"].reasoning_effort`. Pass those
+  values as `model` and `reasoningEffort`, with
+  `modelMetadataSource: "codex_turn_metadata"`.
+- Codex fallback/cross-check: if active turn metadata is unavailable, you may
+  inspect `~/.codex/config.toml` for `model` and `model_reasoning_effort`, but
+  pass `modelMetadataSource: "codex_config_fallback"` and do not treat it as a
+  reason to ask the user to switch models. Active turn metadata wins if it
+  differs from config.
+- Claude Code / Opus: use active Claude runtime metadata only if the current
+  host exposes model and effort for this same session, with
+  `modelMetadataSource: "claude_runtime_metadata"`. Current Claude Code MCP
+  tool calls may not include model or effort metadata; when they do not, omit
+  `model`, `reasoningEffort`, and `modelMetadataSource`.
+- Claude Code session-context self-report: if your current Claude session
+  context explicitly states both the exact model ID and effort/thinking level,
+  report it internally in this shape and pass it to bootstrap with
+  `modelMetadataSource: "claude_session_context"`:
+
+  ```text
+  - Model (name): ...
+  - Model (ID): ...
+  - Reasoning effort: ...
+  - Source: active Claude Code session context
+  ```
+
+  Use this only when the values are explicitly present in the current session
+  context. Do not infer an ID from the friendly name, do not infer effort from
+  `alwaysThinkingEnabled`, and do not show this self-report to the user during
+  normal campaign setup.
+- Do not run a nested `claude -p`, inspect `~/.claude/settings.json`, or read
+  Claude CLI defaults as proof of the user's active Claude Code session. Those
+  checks can validate a new child session or saved defaults, but not this
+  session's actual model and effort.
+- If the user explicitly provides active Claude `/status` or `/model` output
+  that includes both model and effort, pass it with
+  `modelMetadataSource: "user_confirmed"`. If it is missing either model or
+  effort, treat the metadata as unknown and continue.
+
+Never invent the model or reasoning effort. Never pass config defaults as active
+metadata. If bootstrap returns `modelQuality.status === "unknown"`, continue
+without asking the user to switch models.
+
 Approval and safety copy should be tasteful. State what the current approval
 covers once, in one short sentence, then move on. Do not append repeated
 "nothing starts / no leads import / no sending" disclaimers to routine progress
@@ -775,10 +818,9 @@ messages, and wait for final launch approval.
 What's your LinkedIn profile URL or handle?
 ```
 
-Codex only: do not silently ask intake or approval questions as plain chat when
-`request_user_input` is unavailable in an interactive Codex session. Claude Code
-uses `AskUserQuestion`; do not apply this Codex setup blocker in Claude Code.
-In Codex, stop and tell the user:
+Do not silently ask Codex intake or approval questions as plain chat when
+`request_user_input` is unavailable in an interactive session. Stop and tell
+the user:
 
 ```text
 I need Codex’s quick question panel to collect campaign inputs and approvals cleanly.
@@ -817,18 +859,17 @@ there.
 ## Bootstrap
 
 MCP tool access is required. First call `mcp__sellable__get_auth_status({})`
-directly. If that tool is unavailable, stop and say this is a Sellable
-install/reload problem for the current host, not a campaign problem. Tell the
-user to run `curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh` so
-the packaged MCP server and the current host integration are installed. If they
-want an agent-readable checklist, tell them:
+directly. If that tool is unavailable, stop and say this is a Codex
+install/reload problem, not a campaign problem. Tell the user to
+run `curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh` so the
+packaged MCP server, Codex Desktop plugin, and Sellable skill bundle are
+installed. If they want an agent-readable checklist, tell them:
 `Install Sellable CLI and skills using https://app.sellable.dev/agent-install.txt`.
 For CLI verification, tell them to run
 `sellable --verify-only --host all --json --artifact "$HOME/.local/sellable/app-sellable-dev/installer/.last-verify.json"`.
-After that, they must fully quit and reopen the current host app before starting
-a new thread. In Codex, say Codex Desktop. In Claude Code, say Claude Code. Do
-not use `scripts/mcp/sellable-tool-call.mjs`, `npm run`, `node`, or any local
-harness as a fallback for this interactive skill.
+After that, they must fully quit and reopen Codex Desktop before starting a new
+thread. Do not use `scripts/mcp/sellable-tool-call.mjs`, `npm run`, `node`, or
+any local harness as a fallback for this interactive skill.
 Do not mention prompt loading, local skill files, missing linked versions,
 plugin cache paths, MCP namespaces, or runbooks in customer-facing progress
 updates.
@@ -940,15 +981,19 @@ 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?, host, model?, reasoningEffort? })`.
-   Pass the explicit current host label: `host: "Codex"` from Codex and
-   `host: "Claude Code"` from Claude Code. Also pass the current model and
-   reasoning when the host exposes them.
+6. Call `mcp__sellable__bootstrap_create_campaign({ flowVersion: "v2", campaignId?, host?, model?, reasoningEffort?, modelMetadataSource? })`.
+   Pass model metadata only when collected by the Active Model Metadata rules
+   above. For Codex active turn metadata, pass
+   `modelMetadataSource: "codex_turn_metadata"`. For explicit Claude session
+   context, pass `modelMetadataSource: "claude_session_context"`. For explicit
+   user-confirmed Claude `/status` or `/model` output, pass
+   `modelMetadataSource: "user_confirmed"` only when it includes both model and
+   effort.
 7. If `safeToProceed !== true`, stop and show `blockingErrors` + `nextStep`.
-8. If `modelQuality.status === "warn"` and `modelQuality.metadataStale !== true`,
-   show `modelQuality.message` before any setup/research and wait for the user
-   to switch or explicitly continue. If `metadataStale === true`, continue
-   normally and do not tell the user to switch.
+8. If `modelQuality.status === "warn"`, show `modelQuality.message` before any
+   setup/research and wait for the user to switch or explicitly continue. If
+   `modelQuality.status === "unknown"`, continue; do not tell the user to
+   switch models.
 
 ## Execute Workflow
 

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

@@ -1,5 +1,5 @@
 {
-  "version": 1,
+  "version": 2,
   "hosts": {
     "claude": {
       "label": "Claude Code",
@@ -21,9 +21,8 @@
     }
   },
   "warningCopy": {
-    "ok": "Campaign model settings meet the configured minimum: {minimumSummary}.",
-    "staleCodexMetadata": "Codex host metadata appears stale: it can report GPT-5/default or GPT-5/high even when the UI is set to GPT 5.5 Extra High. Treating this as acceptable; continue without asking the user to switch.",
-    "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."
+    "ok": "Active host model metadata meets the configured campaign floor: {currentSettings}.",
+    "skipped": "Active host model metadata was not available from a trusted runtime source. Continue without asking the user to switch models.",
+    "belowMinimum": "Active host metadata reports {currentSettings}, which is below the configured campaign floor: {minimumSummary}. Ask the user to switch before continuing, or explicitly say to continue anyway."
   }
 }

package/skills/create-campaign-v2/references/approval-gate-framing.md

@@ -296,7 +296,12 @@ atomic-mint step:
 
 0. **verify workspace/sender invariant** (see §Preconditions) — if the
    invariant fails, abort BEFORE `bootstrap_create_campaign`
-1. `bootstrap_create_campaign({ flowVersion: "v2", host?, model?, reasoningEffort? })`
+1. `bootstrap_create_campaign({ flowVersion: "v2", host?, model?, reasoningEffort?, modelMetadataSource? })`
+   Pass model metadata only when it comes from active turn/runtime metadata or
+   explicit user confirmation that includes both model and effort. Use
+   `modelMetadataSource: "claude_session_context"` only when the current Claude
+   session context explicitly states both values. Never use inferred config
+   defaults, nested Claude sessions, or saved settings files.
 2. If `campaign-shell.json` exists, call `create_campaign({ campaignId })` to
    resume/recover `{ campaignId, watchUrl }`, then
    `update_campaign({ campaignId, campaignBrief, leadSourceType,