@sellable/mcp 0.1.315 → 0.1.319

package/dist/tools/linkedin.js

@@ -47,7 +47,7 @@ export const linkedinToolDefinitions = [
     },
     {
         name: "fetch_linkedin_profile",
-        description: "Fetch LinkedIn profile details. Defaults to the cheaper 'main' payload — same envelope shape with most-recent role, headline, about, location, education, top skills, certifications, languages, projects, etc. Pass full=true ONLY when you need the long-tail experience history (positions 6+) or complete skill list (skills 3+) for deep research. Most personalization, qualification, and outreach use cases work with main; reach for full only when the user explicitly asks for full work history or comprehensive skill audit.",
+        description: "Fetch LinkedIn profile details. Defaults to compact context (fetchMinimal=true) that strips images/media/provider metadata and returns identity, headline, about, current role, company, limited experience, education, skills, certifications, languages, and projects. Pass fetchMinimal=false only when you need raw provider fields or media URLs. Pass full=true ONLY when you need the long-tail experience history (positions 6+) or complete skill list (skills 3+) for deep research; full still returns compact output unless fetchMinimal=false.",
         inputSchema: {
             type: "object",
             properties: {
@@ -60,6 +60,11 @@ export const linkedinToolDefinitions = [
                     description: "Opt into the full payload (~38% more expensive, slightly slower). Set true only when you specifically need the long-tail experience history or full skill list. Default false (main payload).",
                     default: false,
                 },
+                fetchMinimal: {
+                    type: "boolean",
+                    description: "Return compact agent context by stripping images/media/provider metadata and limiting long lists. Default true. Set false only when raw provider fields or media URLs are needed.",
+                    default: true,
+                },
             },
             required: ["linkedinUrl"],
         },
@@ -187,6 +192,348 @@ function collectImageUrls(value, urls = new Set()) {
 function pickString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function pickRecord(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (isRecord(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function pickStringFrom(value, keys, maxLength = 1200) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        const picked = typeof candidate === "string" || typeof candidate === "number"
+            ? compactString(candidate, maxLength)
+            : undefined;
+        if (picked)
+            return picked;
+    }
+    return undefined;
+}
+function pickNumberFrom(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (typeof candidate === "number" && Number.isFinite(candidate)) {
+            return candidate;
+        }
+        if (typeof candidate === "string" && candidate.trim()) {
+            const parsed = Number(candidate.replace(/,/g, ""));
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function pickBooleanFrom(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (typeof candidate === "boolean")
+            return candidate;
+    }
+    return undefined;
+}
+function compactString(value, maxLength = 1200) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return undefined;
+    }
+    const compacted = String(value)
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!compacted)
+        return undefined;
+    return compacted.length > maxLength
+        ? `${compacted.slice(0, maxLength - 3).trim()}...`
+        : compacted;
+}
+function stripEmpty(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => stripEmpty(item))
+            .filter((item) => {
+            if (item == null)
+                return false;
+            if (Array.isArray(item))
+                return item.length > 0;
+            if (isRecord(item))
+                return Object.keys(item).length > 0;
+            return true;
+        });
+    }
+    if (!isRecord(value))
+        return value;
+    const entries = Object.entries(value)
+        .map(([key, item]) => [key, stripEmpty(item)])
+        .filter(([, item]) => {
+        if (item == null || item === "")
+            return false;
+        if (Array.isArray(item))
+            return item.length > 0;
+        if (isRecord(item))
+            return Object.keys(item).length > 0;
+        return true;
+    });
+    return Object.fromEntries(entries);
+}
+function asArray(value) {
+    if (Array.isArray(value))
+        return value;
+    return value == null ? [] : [value];
+}
+function pickProfileArray(profile, keys) {
+    for (const key of keys) {
+        const value = profile[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function datePartText(value) {
+    if (typeof value === "string")
+        return compactString(value, 80);
+    if (!isRecord(value))
+        return undefined;
+    const text = pickStringFrom(value, ["text", "date"], 80);
+    if (text)
+        return text;
+    const year = pickNumberFrom(value, ["year"]);
+    const month = pickStringFrom(value, ["month"], 20) || pickNumberFrom(value, ["month"]);
+    if (!year)
+        return undefined;
+    return month ? `${month} ${year}` : String(year);
+}
+function dateRangeFromItem(item) {
+    const explicit = pickStringFrom(item, ["dateRange", "date_range", "period"], 120);
+    if (explicit)
+        return explicit;
+    const startText = datePartText(item.startDate) ||
+        datePartText(stripEmpty({
+            month: item.start_month ?? item.startMonth,
+            year: item.start_year ?? item.startYear,
+        }));
+    const endText = datePartText(item.endDate) ||
+        datePartText(stripEmpty({
+            month: item.end_month ?? item.endMonth,
+            year: item.end_year ?? item.endYear,
+        }));
+    return [startText, endText].filter(Boolean).join(" - ") || undefined;
+}
+function compactExperienceItem(value) {
+    if (!isRecord(value))
+        return {};
+    const companyRecord = pickRecord(value, ["company"]);
+    return stripEmpty({
+        title: pickStringFrom(value, ["title", "position", "job_title"], 160),
+        companyName: pickStringFrom(value, ["companyName", "company_name", "company"], 160) ||
+            pickStringFrom(companyRecord, ["name"], 160),
+        companyLinkedinUrl: pickStringFrom(value, [
+            "companyLinkedinUrl",
+            "companyLinkedInUrl",
+            "company_linkedin_url",
+            "companyLink",
+            "company_public_url",
+        ], 240),
+        dateRange: dateRangeFromItem(value),
+        duration: pickStringFrom(value, ["duration", "current_job_duration"], 80),
+        location: pickStringFrom(value, ["location"], 180),
+        description: pickStringFrom(value, ["description", "summary"], 700),
+        isCurrent: pickBooleanFrom(value, ["isCurrent", "is_current"]),
+    });
+}
+function compactEducationItem(value) {
+    if (!isRecord(value))
+        return {};
+    return stripEmpty({
+        schoolName: pickStringFrom(value, ["schoolName", "school_name", "school"], 180),
+        schoolLinkedinUrl: pickStringFrom(value, ["schoolLinkedinUrl", "schoolLinkedInUrl", "school_linkedin_url"], 240),
+        degree: pickStringFrom(value, ["degree"], 180),
+        fieldOfStudy: pickStringFrom(value, ["fieldOfStudy", "field_of_study"], 180),
+        dateRange: dateRangeFromItem(value),
+    });
+}
+function compactStringList(value, limit) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string" || typeof item === "number") {
+            return compactString(item, 120);
+        }
+        return pickStringFrom(item, ["name", "title", "skill"], 120);
+    })
+        .filter((item) => Boolean(item))
+        .slice(0, limit);
+}
+function compactLanguages(value) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string")
+            return { name: compactString(item, 80) };
+        if (!isRecord(item))
+            return {};
+        return stripEmpty({
+            name: pickStringFrom(item, ["name", "language"], 80),
+            proficiency: pickStringFrom(item, ["proficiency"], 120),
+        });
+    })
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 10);
+}
+function compactNamedItems(value) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string")
+            return { name: compactString(item, 160) };
+        if (!isRecord(item))
+            return {};
+        return stripEmpty({
+            name: pickStringFrom(item, ["name", "title"], 180),
+            organization: pickStringFrom(item, ["organization", "authority", "issuer", "companyName"], 180),
+            dateRange: dateRangeFromItem(item),
+            description: pickStringFrom(item, ["description"], 500),
+            url: pickStringFrom(item, ["url", "link"], 240),
+        });
+    })
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 5);
+}
+function firstCurrentRole(profile) {
+    const current = pickProfileArray(profile, [
+        "currentPosition",
+        "current_position",
+    ])
+        .map(compactExperienceItem)
+        .find((item) => Object.keys(item).length > 0);
+    if (current)
+        return current;
+    const firstExperience = pickProfileArray(profile, [
+        "experience",
+        "experiences",
+    ])
+        .map(compactExperienceItem)
+        .find((item) => Object.keys(item).length > 0);
+    if (firstExperience)
+        return firstExperience;
+    return stripEmpty({
+        title: pickStringFrom(profile, ["job_title", "jobTitle", "title"], 160),
+        companyName: pickStringFrom(profile, ["company", "companyName"], 160),
+        dateRange: dateRangeFromItem(stripEmpty({
+            start_month: profile.current_company_join_month ?? profile.currentCompanyJoinMonth,
+            start_year: profile.current_company_join_year ?? profile.currentCompanyJoinYear,
+        })),
+        duration: pickStringFrom(profile, ["current_job_duration", "currentJobDuration"], 80),
+    });
+}
+function compactCompanyFromProfile(profile, currentRole) {
+    return stripEmpty({
+        name: pickStringFrom(profile, ["company", "companyName"], 180) ||
+            currentRole.companyName,
+        linkedinUrl: pickStringFrom(profile, [
+            "company_linkedin_url",
+            "companyLinkedinUrl",
+            "companyLinkedInUrl",
+            "currentCompanyLinkedinUrl",
+        ], 240) || currentRole.companyLinkedinUrl,
+        website: pickStringFrom(profile, ["company_website", "companyWebsite", "website"], 240),
+        domain: pickStringFrom(profile, ["company_domain", "companyDomain", "currentCompanyDomain"], 120),
+        industry: pickStringFrom(profile, ["company_industry", "industry"], 160),
+        employeeCount: pickNumberFrom(profile, [
+            "company_employee_count",
+            "companyEmployeeCount",
+            "employeeCount",
+        ]),
+        employeeRange: pickStringFrom(profile, ["company_employee_range", "companyEmployeeRange", "employeeCountRange"], 80),
+        description: pickStringFrom(profile, ["company_description", "companyDescription"], 700),
+        founded: pickStringFrom(profile, ["company_year_founded", "founded"], 80) ||
+            pickNumberFrom(profile, ["company_year_founded", "founded"]),
+    });
+}
+export function compactLinkedInProfile(profile) {
+    if (!isRecord(profile))
+        return {};
+    const currentRole = firstCurrentRole(profile);
+    const experience = pickProfileArray(profile, ["experience", "experiences"])
+        .map(compactExperienceItem)
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 5);
+    const education = pickProfileArray(profile, ["education", "educations"])
+        .map(compactEducationItem)
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 3);
+    const skills = compactStringList(profile.topSkills ?? profile.skills, 12);
+    return stripEmpty({
+        id: pickStringFrom(profile, ["id", "profile_id"], 180),
+        publicIdentifier: pickStringFrom(profile, ["publicIdentifier", "public_id", "publicIdentifier"], 120),
+        linkedinUrl: pickStringFrom(profile, ["linkedinUrl", "linkedin_url", "profile_url"], 240),
+        firstName: pickStringFrom(profile, ["firstName", "first_name"], 120),
+        lastName: pickStringFrom(profile, ["lastName", "last_name"], 120),
+        fullName: pickStringFrom(profile, ["fullName", "full_name", "name"], 180) ||
+            [
+                pickStringFrom(profile, ["firstName", "first_name"], 120),
+                pickStringFrom(profile, ["lastName", "last_name"], 120),
+            ]
+                .filter(Boolean)
+                .join(" "),
+        headline: pickStringFrom(profile, ["headline"], 320),
+        about: pickStringFrom(profile, ["about", "summary"], 1600),
+        location: pickStringFrom(profile, ["location"], 180),
+        followerCount: pickNumberFrom(profile, ["followerCount", "follower_count"]),
+        connectionCount: pickNumberFrom(profile, [
+            "connectionsCount",
+            "connection_count",
+            "connectionCount",
+        ]),
+        isPremium: pickBooleanFrom(profile, ["premium", "is_premium", "isPremium"]),
+        isCreator: pickBooleanFrom(profile, ["is_creator", "isCreator"]),
+        isVerified: pickBooleanFrom(profile, [
+            "verified",
+            "is_verified",
+            "isVerified",
+        ]),
+        currentRole,
+        company: compactCompanyFromProfile(profile, currentRole),
+        experience,
+        education,
+        skills,
+        languages: compactLanguages(profile.languages),
+        certifications: compactNamedItems(profile.certifications),
+        projects: compactNamedItems(profile.projects),
+    });
+}
+function canonicalizeLinkedInProfileResponse(raw) {
+    if (raw &&
+        typeof raw === "object" &&
+        raw.status === "success" &&
+        (raw.data || raw.person || raw.profile?.person)) {
+        const canonical = raw.data ?? raw.person ?? raw.profile?.person;
+        const { status, data, person, profile, ...rest } = raw;
+        return { status, profile: canonical, ...rest };
+    }
+    return raw;
+}
+function compactLinkedInProfileResponse(raw) {
+    const normalized = canonicalizeLinkedInProfileResponse(raw);
+    if (normalized &&
+        typeof normalized === "object" &&
+        normalized.status === "success" &&
+        normalized.profile) {
+        return {
+            status: normalized.status,
+            profile: compactLinkedInProfile(normalized.profile),
+        };
+    }
+    return normalized;
+}
 function serializePostMedia(post) {
     const media = post.media && typeof post.media === "object"
         ? post.media
@@ -295,23 +642,9 @@ export async function fetchLinkedInProfile(linkedinUrl, options = {}) {
         params.set("full", "true");
     }
     const raw = await api.get(`/api/v1/scrape/linkedin/profile?${params.toString()}`);
-    // Server returns the same profile object triplicated as `.data`,
-    // `.person`, AND `.profile.person` for backwards-compat with web
-    // callers (signal-discovery, profile-enrichment, canonical-cache, etc).
-    // For the MCP layer, that ~3xs the JSON size and routinely breaches
-    // Claude Code's max-token cap on tool results — which triggers the
-    // harness's "save to file + read in chunks via python3" overflow
-    // fallback. Strip the duplicates here so the agent gets one clean
-    // copy of the data under a single `profile` key.
-    if (raw &&
-        typeof raw === "object" &&
-        raw.status === "success" &&
-        (raw.data || raw.person || raw.profile?.person)) {
-        const canonical = raw.data ?? raw.person ?? raw.profile?.person;
-        const { status, data, person, profile, ...rest } = raw;
-        return { status, profile: canonical, ...rest };
-    }
-    return raw;
+    return options.fetchMinimal === false
+        ? canonicalizeLinkedInProfileResponse(raw)
+        : compactLinkedInProfileResponse(raw);
 }
 export async function fetchCompany(companyUrl) {
     const api = getApi();

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,