sneakoscope 10.6.2 → 10.7.0

package/dist/core/search-visibility/marketing.js

@@ -3,51 +3,38 @@ import { exists, readJson, readText, sha256, writeJsonAtomic } from '../fsx.js';
 import { detectProject, discoverSiteInventory } from './discovery.js';
 import { createSearchVisibilityMission, resolveSearchVisibilityMission, routeForMode } from './mission.js';
 import { runSuperSearch } from '../super-search/index.js';
-import { evaluateMarketingTruthfulness } from './marketing-truthfulness.js';
-const INTERNAL_SOURCE_CANDIDATES = [
-    'package.json',
-    'README.md',
-    'CHANGELOG.md',
-    'src/core/routes.ts',
-    'src/core/routes/dollar-manifest-lite.ts',
-    'src/core/agents/agent-orchestrator.ts',
-    'src/cli/command-manifest-lite.ts',
-    'config/perf-budgets.v1.json',
-    '.sneakoscope/reports/perf-budget.json',
-    '.sneakoscope/reports/super-search-local-http-smoke.json',
-    '.sneakoscope/reports/installed-package-smoke.json',
-];
-const EXTERNAL_SOURCE_URLS = [
-    'https://github.com/mandarange/Sneakoscope-Codex',
-    'https://www.npmjs.com/package/sneakoscope',
-];
-const COMPETITOR_SOURCE_URLS = [
-    'https://github.com/Yeachan-Heo/oh-my-codex',
-    'https://github.com/code-yeongyu/lazycodex',
-    'https://www.npmjs.com/package/oh-my-codex',
-    'https://www.npmjs.com/package/lazycodex-ai',
-];
+import { classifyClaim, evaluateMarketingTruthfulness } from './marketing-truthfulness.js';
+const INTERNAL_SOURCE_FILES = ['package.json', 'CHANGELOG.md'];
+const NON_POSITIONING_SECTION = /^(?:install(?:ation|ing)?|usage|getting started|quick ?start|setup|requirements|prerequisites|configuration|development|contributing|contributors|license|changelog|faq|support|credits|acknowledg(?:e)?ments|table of contents|contents|testing|tests?|build(?:ing)?|scripts|roadmap|security|code of conduct|authors?|sponsors?|related|see also|links|api|reference|examples?|demo|screenshots?)\b/i;
+const MAX_MESSAGE_PILLARS = 4;
+const MAX_KEYWORDS = 20;
 export async function runMarketingResearch(mode, missionRef, options) {
     const mission = await resolveOrCreateMarketingMission(mode, missionRef, options, 'marketing research');
     const ctx = context(mode, mission.root, options);
     const detected = await detectProject(ctx);
     const inventory = await discoverSiteInventory(ctx, detected);
     await writeJsonAtomic(path.join(mission.artifactDir, 'site-inventory.json'), inventory);
-    const internalSources = await collectInternalSources(mission.root);
+    const internalSources = await collectInternalSources(mission.root, inventory);
+    const projectUrls = await projectSourceUrls(mission.root, inventory, options);
+    const competitorUrls = unique(options.competitorUrls || []);
     const externalSources = options.offline
         ? []
-        : await collectSuperSearchSources(mission, EXTERNAL_SOURCE_URLS, 'external', options.maxMarketingSources);
-    const competitorSources = !options.offline && options.includeCompetitors
-        ? await collectSuperSearchSources(mission, COMPETITOR_SOURCE_URLS, 'competitor', options.maxMarketingSources)
+        : await collectSuperSearchSources(mission, projectUrls, 'external', options.maxMarketingSources);
+    const competitorSources = !options.offline && options.includeCompetitors && competitorUrls.length
+        ? await collectSuperSearchSources(mission, competitorUrls, 'competitor', options.maxMarketingSources)
         : [];
-    const claims = buildMarketingClaims(inventory, internalSources, externalSources);
+    const claims = buildMarketingClaims(inventory, internalSources);
     const truth = evaluateMarketingTruthfulness({ claims });
     const blockedClaims = claims.filter((claim) => !claim.publishable || claim.blockers.length || truth.unsupported_claims.includes(claim.id));
-    const blockers = [...truth.blockers];
+    const blockers = [];
     if (!internalSources.length)
         blockers.push('marketing_internal_sources_missing');
-    if (!options.offline && !externalSources.some((source) => source.verified))
+    if (!options.offline && !projectUrls.length)
+        blockers.push('marketing_project_urls_missing');
+    else if (!options.offline && !externalSources.some((source) => source.verified))
         blockers.push('marketing_external_sources_unverified');
+    if (options.includeCompetitors && !competitorUrls.length)
+        blockers.push('marketing_competitor_urls_required');
     const research = {
         schema: 'sks.search-visibility.marketing-research.v1',
         ok: blockers.length === 0,
@@ -63,6 +50,8 @@ export async function runMarketingResearch(mode, missionRef, options) {
     await writeJsonAtomic(path.join(mission.artifactDir, 'marketing-source-ledger.json'), {
         schema: 'sks.search-visibility.marketing-source-ledger.v1',
         mission_id: mission.id,
+        project_urls: projectUrls,
+        competitor_urls: competitorUrls,
         sources: [...internalSources, ...externalSources, ...competitorSources],
     });
     await writeJsonAtomic(path.join(mission.artifactDir, 'marketing-claim-ledger.json'), {
@@ -87,6 +76,7 @@ export async function runMarketingResearch(mode, missionRef, options) {
         route: routeForMode(mode),
         status: research.ok ? 'verified_partial' : 'blocked',
         artifacts_dir: `.sneakoscope/missions/${mission.id}/search-visibility`,
+        project_urls: projectUrls,
         internal_sources: internalSources.length,
         external_sources: externalSources.length,
         competitor_sources: competitorSources.length,
@@ -107,7 +97,11 @@ export async function runMarketingStrategy(mode, missionRef, options) {
     const inventory = await readJson(path.join(mission.artifactDir, 'site-inventory.json'), null);
     if (!inventory)
         return blockedStrategy(mission, ['site_inventory_required_for_strategy']);
-    const strategy = buildMarketingStrategy(mission.id, inventory, research);
+    const readmeSource = research.internal_sources.find((source) => Boolean(source.path) && source.path === inventory.readme.path);
+    const readmeText = readmeSource?.path ? await readText(path.join(mission.root, readmeSource.path), '') : '';
+    if (readmeSource?.sha256 && sha256(readmeText) !== readmeSource.sha256)
+        return blockedStrategy(mission, ['marketing_readme_changed_since_research']);
+    const strategy = buildMarketingStrategy(mission.id, inventory, research, readmeText);
     const truth = evaluateMarketingTruthfulness({ strategy });
     const strategy_quality = scoreMarketingStrategy(strategy, truth);
     const blockers = [...strategy.blockers, ...truth.blockers, ...strategy_quality.blockers];
@@ -137,101 +131,109 @@ export async function runMarketingStrategy(mode, missionRef, options) {
         blockers,
     };
 }
-function buildMarketingStrategy(missionId, inventory, research) {
-    const sources = [...research.internal_sources, ...research.external_sources];
-    const sourceIds = sources.filter((source) => source.verified).map((source) => source.id);
-    const packageSource = sourceIds.find((id) => id.includes('package-json')) || sourceIds[0] || '';
-    const readmeSource = sourceIds.find((id) => id.includes('readme')) || packageSource;
-    const perfSource = sourceIds.find((id) => id.includes('perf-budget') || id.includes('perf'));
-    const parallelSource = sourceIds.find((id) => id.includes('agent-orchestrator') || id.includes('naruto'));
-    const superSearchSource = sourceIds.find((id) => id.includes('super-search'));
-    const oneLiner = `${inventory.package.name || 'Sneakoscope'} is a proof-first Codex trust layer for bounded agent workflows, search visibility, and evidence-backed release gates.`;
-    const strategySources = unique([packageSource, readmeSource, superSearchSource, parallelSource, perfSource].filter(Boolean));
-    const competitorContrast = buildCompetitorContrast(research, strategySources);
-    const keywords = unique([
-        'sneakoscope',
-        'codex',
-        'sks',
-        'codex-cli',
-        'codex-app',
-        'agent-orchestration',
-        'proof-gates',
-        ...(superSearchSource ? ['super-search'] : []),
-        'seo',
-        'generative-engine-optimization',
-        'bounded-memory',
-        'rollback',
-        'release-integrity',
-    ]).slice(0, 20);
-    const messagePillars = [
-        { title: 'Proof-first route gates', claim: 'SKS records route artifacts, blockers, and release gates so Codex workflows can separate verified work from unverified claims.', source_ids: [readmeSource || packageSource].filter(Boolean) },
-        ...(superSearchSource ? [{ title: 'Source-backed search visibility', claim: 'Super-Search and SEO/GEO artifacts keep source ledgers and claim ledgers attached to search visibility work.', source_ids: [superSearchSource] }] : []),
-        ...(parallelSource ? [{ title: 'Bounded parallel implementation', claim: 'The Naruto agent orchestrator runs bounded multi-agent coding workflows.', source_ids: [parallelSource] }] : []),
-        ...(perfSource ? [{ title: 'Measured fast paths', claim: 'Performance budget reports define p95 budgets for selected SKS fast-path commands.', source_ids: [perfSource] }] : []),
+function buildMarketingStrategy(missionId, inventory, research, readmeText) {
+    const verifiedId = (source) => (source?.verified ? source.id : null);
+    const packageSource = verifiedId(research.internal_sources.find((source) => Boolean(source.path) && source.path === inventory.package.path));
+    const readmeSource = verifiedId(research.internal_sources.find((source) => Boolean(source.path) && source.path === inventory.readme.path));
+    const projectName = inventory.package.name || inventory.readme.h1 || 'This project';
+    const excluded = [];
+    const passes = (id, text, claimType, sourceIds) => {
+        const gate = evaluateMarketingTruthfulness({
+            claims: [{ id, text, claim_type: claimType, source_ids: sourceIds, publishable: true, blockers: sourceIds.length ? [] : ['source_ids_required'] }],
+        });
+        if (!gate.ok)
+            excluded.push(...gate.blockers);
+        return gate.ok;
+    };
+    const candidates = [
+        { id: 'positioning-package-description', text: (inventory.package.description || '').trim(), source: packageSource },
+        { id: 'positioning-readme-lead', text: readmeLead(readmeText), source: readmeSource },
     ];
+    const positioning = candidates.find((candidate) => Boolean(candidate.text && candidate.source)
+        && passes(candidate.id, candidate.text, 'positioning', [candidate.source])) || null;
+    const positioningSource = positioning?.source || null;
+    const oneLiner = positioning?.text || '';
+    const messagePillars = readmeSections(readmeText)
+        .filter((section) => !NON_POSITIONING_SECTION.test(section.title))
+        .map((section) => ({ title: section.title, claim: section.lead, source_ids: readmeSource ? [readmeSource] : [] }))
+        .filter((pillar, index) => Boolean(pillar.claim)
+        && passes(`pillar-${index + 1}`, `${pillar.title}: ${pillar.claim}`, classifyClaim(`${pillar.title}: ${pillar.claim}`), pillar.source_ids))
+        .slice(0, MAX_MESSAGE_PILLARS);
+    const existingKeywords = unique(inventory.package.keywords.map((keyword) => keyword.trim()));
+    const identityKeywords = unique([bareName(inventory.package.name), ...frameworkKeywords(inventory)])
+        .filter((keyword) => !existingKeywords.includes(keyword));
+    const keywords = [...existingKeywords, ...identityKeywords].slice(0, MAX_KEYWORDS);
+    const keywordClusters = packageSource
+        ? [
+            { name: 'package keywords', keywords: existingKeywords, source_ids: [packageSource] },
+            { name: 'project identity', keywords: identityKeywords, source_ids: [packageSource] },
+        ].filter((cluster) => cluster.keywords.length)
+        : [];
+    const competitorContrast = research.competitor_sources
+        .filter((source) => source.verified && oneLiner)
+        .map((source) => ({
+        competitor: source.title,
+        their_claim: source.summary,
+        project_contrast: `${projectName}: ${oneLiner}`,
+        source_ids: unique([source.id, positioningSource || '']),
+        safe_to_publish: true,
+    }))
+        .filter((contrast, index) => passes(`competitor-contrast-${index + 1}`, `${contrast.competitor}: ${contrast.their_claim} ${contrast.project_contrast}`, 'competitor', contrast.source_ids));
+    const readmePlan = positioningSource ? [{
+            operation: 'readme-positioning-block-update',
+            text: [
+                '<!-- BEGIN SKS MARKETING POSITIONING -->',
+                oneLiner,
+                ...(messagePillars.length ? ['', ...messagePillars.map((pillar) => `- **${pillar.title}:** ${pillar.claim}`)] : []),
+                '<!-- END SKS MARKETING POSITIONING -->',
+                '',
+            ].join('\n'),
+            source_ids: unique([positioningSource, ...messagePillars.flatMap((pillar) => pillar.source_ids)]),
+        }] : [];
+    const packagePlan = [];
+    if (packageSource && positioningSource && !inventory.package.description) {
+        packagePlan.push({ operation: 'package-description-update', description: oneLiner, source_ids: [positioningSource] });
+    }
+    if (packageSource && identityKeywords.length && passes('package-keywords', keywords.join(', '), 'positioning', [packageSource])) {
+        packagePlan.push({ operation: 'package-keywords-update', keywords, source_ids: [packageSource] });
+    }
     const strategy = {
         schema: 'sks.search-visibility.marketing-strategy.v1',
         ok: true,
         mission_id: missionId,
         positioning: {
             one_liner: oneLiner,
-            source_ids: [packageSource || readmeSource].filter(Boolean),
+            source_ids: positioningSource ? [positioningSource] : [],
         },
         message_pillars: messagePillars,
-        keyword_clusters: [
-            { name: 'codex trust layer', keywords: keywords.slice(0, 7), source_ids: [packageSource || readmeSource].filter(Boolean) },
-            { name: 'agent release integrity', keywords: keywords.slice(7, 14), source_ids: [readmeSource || packageSource].filter(Boolean) },
-            { name: 'search visibility', keywords: keywords.slice(7, 11), source_ids: [superSearchSource || packageSource].filter(Boolean) },
-        ],
+        keyword_clusters: keywordClusters,
         strategy_quality: {
             score: 0,
             source_backed_claims: 0,
             unsupported_claims: 0,
             competitor_contrast_count: competitorContrast.length,
-            keyword_cluster_count: 3,
+            keyword_cluster_count: keywordClusters.length,
             blockers: [],
         },
         competitor_contrast: competitorContrast,
-        readme_plan: [{
-                operation: 'readme-positioning-block-update',
-                text: [
-                    '<!-- BEGIN SKS MARKETING POSITIONING -->',
-                    '## Search Visibility Positioning',
-                    '',
-                    oneLiner,
-                    '',
-                    '- Source-ledger claims are kept in SKS marketing research and strategy artifacts.',
-                    '- SEO/GEO mutation plans update only package metadata and this managed README block in this release.',
-                    '- External visibility outcomes require separate measured evidence.',
-                    '<!-- END SKS MARKETING POSITIONING -->',
-                    '',
-                ].join('\n'),
-                source_ids: strategySources,
-            }],
-        package_plan: [
-            {
-                operation: 'package-description-update',
-                description: 'Proof-first Codex trust layer for bounded agent workflows, search visibility evidence, and release integrity gates.',
-                source_ids: strategySources,
-            },
-            {
-                operation: 'package-keywords-update',
-                keywords,
-                source_ids: strategySources,
-            },
-        ],
+        readme_plan: readmePlan,
+        package_plan: packagePlan,
         docs_plan: [
-            { title: 'Document marketing claim sources and prohibited guarantees in release notes.', source_ids: [readmeSource || packageSource].filter(Boolean), auto_apply: false },
+            { title: 'Document marketing claim sources and prohibited guarantees in release notes.', source_ids: [positioningSource || packageSource || readmeSource].filter(Boolean), auto_apply: false },
         ],
         do_not_claim: [
             'guaranteed ranking',
             'guaranteed traffic',
             'guaranteed AI citation',
-            'best or fastest Codex tool',
+            'best or fastest in its category without a measurement',
             'competitor disparagement',
         ],
+        excluded_claims: unique(excluded),
         blockers: [],
     };
+    if (!positioningSource) {
+        strategy.blockers.push(candidates.some((candidate) => candidate.text && candidate.source) ? 'positioning_claim_unsupported' : 'positioning_source_missing');
+    }
     for (const pillar of strategy.message_pillars) {
         if (!pillar.source_ids.length)
             strategy.blockers.push(`pillar_source_missing:${pillar.title}`);
@@ -240,53 +242,34 @@ function buildMarketingStrategy(missionId, inventory, research) {
         if (!plan.source_ids.length)
             strategy.blockers.push(`package_plan_source_missing:${plan.operation}`);
     }
-    if (strategy.positioning.source_ids.length === 0)
-        strategy.blockers.push('positioning_source_missing');
     return strategy;
 }
-function buildCompetitorContrast(research, strategySources) {
-    return research.competitor_sources
-        .filter((source) => source.verified)
-        .map((source) => ({
-        competitor: source.title,
-        their_claim: source.summary,
-        sks_contrast: 'SKS positions itself around proof-first release integrity and source-backed search visibility, while workflow-first Codex layers emphasize orchestration convenience.',
-        source_ids: unique([source.id, ...strategySources]),
-        safe_to_publish: true,
-    }));
-}
 function scoreMarketingStrategy(strategy, truth) {
     const blockers = [];
     let score = 0;
     const sourceBackedClaims = countSourceBackedStrategyClaims(strategy);
     if (strategy.positioning.source_ids.length)
-        score += 20;
+        score += 25;
     else
         blockers.push('strategy_quality_source_backed_positioning_missing');
-    if (strategy.message_pillars.length >= 3 && strategy.message_pillars.every((pillar) => pillar.source_ids.length))
-        score += 20;
+    if (strategy.message_pillars.length >= 2 && strategy.message_pillars.every((pillar) => pillar.source_ids.length))
+        score += 25;
     else
         blockers.push('strategy_quality_message_pillars_below_threshold');
-    if (strategy.keyword_clusters.length >= 2 && strategy.keyword_clusters.every((cluster) => cluster.source_ids.length))
+    if (strategy.keyword_clusters.length >= 1 && strategy.keyword_clusters.every((cluster) => cluster.source_ids.length))
         score += 15;
     else
-        blockers.push('strategy_quality_keyword_clusters_below_threshold');
+        blockers.push('strategy_quality_keyword_clusters_missing');
     if (strategy.competitor_contrast.every((contrast) => contrast.safe_to_publish && contrast.source_ids.length))
-        score += 15;
+        score += 10;
     else
         blockers.push('strategy_quality_competitor_contrast_unsafe');
     if (truth.forbidden_phrases.length === 0)
         score += 15;
     else
         blockers.push('strategy_quality_forbidden_phrases_present');
-    if (hasSupportedSpecialClaim(strategy, /p95|latency|performance|fast/i, /perf|budget|report/i)
-        && hasSupportedSpecialClaim(strategy, /parallel|worker|naruto/i, /parallel|naruto|agent|report|routes/i)
-        && hasSupportedSpecialClaim(strategy, /super-search|source-backed|source backed/i, /super-search|source|report/i)) {
-        score += 15;
-    }
-    else {
-        blockers.push('strategy_quality_special_claim_sources_missing');
-    }
+    if (truth.unsupported_claims.length === 0)
+        score += 10;
     if (score < 80)
         blockers.push('strategy_quality_score_below_80');
     if (truth.unsupported_claims.length)
@@ -313,16 +296,84 @@ function countSourceBackedStrategyClaims(strategy) {
         ...strategy.competitor_contrast,
     ].filter((item) => item.source_ids.length > 0).length;
 }
-function hasSupportedSpecialClaim(strategy, textPattern, sourcePattern) {
-    const candidates = [
-        ...strategy.message_pillars.map((pillar) => ({ text: pillar.claim, source_ids: pillar.source_ids })),
-        ...strategy.readme_plan.map((plan) => ({ text: plan.text, source_ids: plan.source_ids })),
-        ...strategy.package_plan.map((plan) => ({
-            text: plan.operation === 'package-description-update' ? plan.description : plan.keywords.join(', '),
-            source_ids: plan.source_ids,
-        })),
-    ];
-    return candidates.some((candidate) => textPattern.test(candidate.text) && candidate.source_ids.some((id) => sourcePattern.test(id)));
+function readmeLead(text) {
+    for (const paragraph of paragraphs(stripFencedCode(text))) {
+        if (/^(?:#|<|!\[|\[!\[|>|[-*+] |\d+\. |\||<!--)/.test(paragraph))
+            continue;
+        const plain = plainMarkdown(paragraph);
+        if (plain.length >= 20)
+            return firstSentences(plain);
+    }
+    return '';
+}
+function readmeSections(text) {
+    const out = [];
+    const body = stripFencedCode(text);
+    const matches = [...body.matchAll(/^##[ \t]+(.+?)[ \t]*#*[ \t]*$/gm)];
+    for (const [index, match] of matches.entries()) {
+        const start = (match.index || 0) + match[0].length;
+        const end = index + 1 < matches.length ? matches[index + 1].index || body.length : body.length;
+        const section = body.slice(start, end).split(/^#{1,6}[ \t]/m)[0] || '';
+        const lead = paragraphs(section)
+            .filter((paragraph) => !/^(?:<|!\[|\[!\[|\||<!--)/.test(paragraph))
+            .map((paragraph) => plainMarkdown(paragraph.replace(/^(?:[-*+]|\d+\.)\s+/, '')))
+            .find((paragraph) => paragraph.length >= 12) || '';
+        out.push({ title: plainMarkdown(match[1] || ''), lead: lead ? firstSentences(lead, 1) : '' });
+    }
+    return out.filter((section) => section.title);
+}
+function stripFencedCode(text) {
+    return String(text || '').replace(/^(```|~~~)[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, '');
+}
+function paragraphs(text) {
+    return String(text || '').split(/\r?\n[ \t]*\r?\n/).map((paragraph) => paragraph.trim()).filter(Boolean);
+}
+function plainMarkdown(text) {
+    return String(text || '')
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, '')
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/(\*\*|__|\*|_)(.+?)\1/g, '$2')
+        .replace(/<[^>]+>/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function firstSentences(text, count = 2) {
+    const sentences = text.match(/[^.!?]+[.!?]+(?=\s|$)/g);
+    const picked = sentences ? sentences.slice(0, count).join(' ').trim() : text;
+    return picked.length > 280 ? `${picked.slice(0, 277).trimEnd()}...` : picked;
+}
+function bareName(name) {
+    return String(name || '').replace(/^@[^/]+\//, '').trim().toLowerCase();
+}
+function frameworkKeywords(inventory) {
+    const names = { next: 'nextjs', react: 'react', astro: 'astro', nuxt: 'nuxt', svelte: 'svelte' };
+    return Object.keys(inventory.package.framework_versions || {}).map((dependency) => names[dependency] || '').filter(Boolean);
+}
+async function projectSourceUrls(root, inventory, options) {
+    const pkg = await readJson(path.join(root, 'package.json'), null);
+    const published = Boolean(inventory.package.name) && pkg?.private !== true;
+    return unique([
+        options.url || '',
+        inventory.package.homepage || '',
+        httpsRepositoryUrl(inventory.package.repository) || '',
+        published ? `https://www.npmjs.com/package/${inventory.package.name}` : '',
+    ].filter((url) => /^https?:\/\//i.test(url)));
+}
+function httpsRepositoryUrl(value) {
+    const raw = String(value || '').trim();
+    if (!raw)
+        return null;
+    const shorthand = raw.match(/^(?:(github|gitlab|bitbucket):)?([\w.-]+\/[\w.-]+)$/i);
+    if (shorthand) {
+        const hosts = { github: 'github.com', gitlab: 'gitlab.com', bitbucket: 'bitbucket.org' };
+        return `https://${hosts[(shorthand[1] || 'github').toLowerCase()]}/${shorthand[2].replace(/\.git$/i, '')}`;
+    }
+    const ssh = raw.match(/^git@([^:]+):(.+?)(?:\.git)?$/i);
+    if (ssh)
+        return `https://${ssh[1]}/${ssh[2]}`;
+    const url = raw.replace(/^git\+/i, '').replace(/^git:\/\//i, 'https://').replace(/\.git$/i, '');
+    return /^https?:\/\//i.test(url) ? url : null;
 }
 async function resolveOrCreateMarketingMission(mode, missionRef, options, prompt) {
     const explicit = missionRef && missionRef !== 'latest' ? await resolveSearchVisibilityMission(options.root, missionRef, mode) : null;
@@ -335,9 +386,9 @@ async function resolveOrCreateMarketingMission(mode, missionRef, options, prompt
     }
     return createSearchVisibilityMission(mode, prompt, options);
 }
-async function collectInternalSources(root) {
+async function collectInternalSources(root, inventory) {
     const out = [];
-    for (const rel of INTERNAL_SOURCE_CANDIDATES) {
+    for (const rel of unique([inventory.package.path || '', inventory.readme.path || '', ...INTERNAL_SOURCE_FILES])) {
         const full = path.join(root, rel);
         if (!(await exists(full)))
             continue;
@@ -387,22 +438,16 @@ async function collectSuperSearchSources(mission, urls, kind, maxSources) {
     }
     return out;
 }
-function buildMarketingClaims(inventory, internalSources, externalSources) {
-    const packageSource = internalSources.find((source) => source.path === 'package.json');
-    const readmeSource = internalSources.find((source) => source.path === 'README.md');
-    const perfSource = internalSources.find((source) => source.path?.includes('perf-budget'));
-    const superSearchSource = internalSources.find((source) => source.path?.includes('super-search-local-http-smoke')) || externalSources.find((source) => source.verified);
+function buildMarketingClaims(inventory, internalSources) {
+    const packageSource = internalSources.find((source) => Boolean(source.path) && source.path === inventory.package.path);
+    const readmeSource = internalSources.find((source) => Boolean(source.path) && source.path === inventory.readme.path);
     const claims = [];
     if (inventory.package.name)
         claims.push(publishableClaim('pkg-name', `${inventory.package.name} is the package name published in package metadata.`, 'identity', [packageSource?.id]));
     if (inventory.package.description)
         claims.push(publishableClaim('pkg-description', inventory.package.description, 'capability', [packageSource?.id]));
     if (readmeSource)
-        claims.push(publishableClaim('readme-positioning', `README describes ${inventory.readme.h1 || inventory.package.name || 'the project'} and its SKS command surfaces.`, 'positioning', [readmeSource.id]));
-    if (perfSource)
-        claims.push(publishableClaim('perf-budget-source', 'Performance budget artifacts define command p95 budgets for release gates.', 'performance', [perfSource.id]));
-    if (superSearchSource)
-        claims.push(publishableClaim('super-search-source-backed', 'Super-Search artifacts provide source ledgers for search visibility evidence.', 'super_search', [superSearchSource.id]));
+        claims.push(publishableClaim('readme-positioning', `README describes ${inventory.readme.h1 || inventory.package.name || 'the project'}.`, 'positioning', [readmeSource.id]));
     return claims;
 }
 function publishableClaim(id, text, claimType, sourceIds) {