sneakoscope 4.2.0 → 4.3.0

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

@@ -0,0 +1,314 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { appendJsonl, ensureDir, exists, readJson, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { routeForMode } from './mission.js';
+export async function buildMutationPlan(mode, missionId, artifactDir, inventory, findings, options, entityFacts) {
+    const operations = [];
+    const blockers = [];
+    if (inventory.detected_adapter.confidence < 0.6)
+        blockers.push('adapter_detection_confidence_too_low_for_mutation');
+    if (inventory.detected_adapter.adapterId === 'unsupported')
+        blockers.push('unsupported_framework_mutation_blocked');
+    if (!blockers.length && mode === 'seo') {
+        operations.push(...await seoOperations(inventory, findings, options));
+    }
+    if (!blockers.length && mode === 'geo') {
+        operations.push(...await geoOperations(inventory, findings, options, entityFacts));
+    }
+    const plan = {
+        schema: 'sks.search-visibility.mutation-plan.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: missionId,
+        route: routeForMode(mode),
+        mode,
+        adapter: inventory.detected_adapter.adapterId,
+        detection_confidence: inventory.detected_adapter.confidence,
+        status: blockers.length ? 'blocked' : 'planned',
+        operations: operations.filter((op) => scopeAllowed(op, options.scope)),
+        blockers,
+        unverified: ['production deployment and measured outcomes are outside mutation apply'],
+    };
+    await writeJsonAtomic(path.join(artifactDir, 'mutation-plan.json'), plan);
+    return plan;
+}
+export async function applyMutationPlan(root, missionId, artifactDir, plan, options) {
+    const blockers = [...plan.blockers];
+    if (!options.apply)
+        blockers.push('apply_requires_explicit_--apply');
+    const previousRollback = await readJson(path.join(artifactDir, 'rollback-manifest.json'), null);
+    const rollback = {
+        schema: 'sks.search-visibility.rollback-manifest.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: missionId,
+        route: plan.route,
+        operations: previousRollback?.operations || [],
+        blockers,
+    };
+    if (blockers.length) {
+        await writeJsonAtomic(path.join(artifactDir, 'rollback-manifest.json'), rollback);
+        await appendJournal(artifactDir, blockedEvent(plan.operations[0] || null, 'mutation preconditions failed'));
+        return { ok: false, status: 'blocked', applied: 0, rollback, blockers };
+    }
+    await ensureDir(path.join(artifactDir, 'backups'));
+    let applied = 0;
+    let idempotent = 0;
+    for (const op of plan.operations) {
+        const full = path.resolve(root, op.path);
+        if (!full.startsWith(path.resolve(root) + path.sep) && full !== path.resolve(root)) {
+            blockers.push(`path_outside_root:${op.path}`);
+            await appendJournal(artifactDir, blockedEvent(op, 'path outside root'));
+            continue;
+        }
+        const beforeExists = await exists(full);
+        const before = beforeExists ? await readText(full, '') : null;
+        const beforeSha = before == null ? null : sha256(before);
+        if (op.baseSha256 !== beforeSha) {
+            if (op.kind === 'create' && beforeExists && beforeSha === op.proposedSha256) {
+                idempotent += 1;
+                await appendJournal(artifactDir, {
+                    schema: 'sks.search-visibility.mutation-journal-event.v1',
+                    ts: new Date().toISOString(),
+                    operation_id: op.id,
+                    event: 'applied',
+                    path: op.path,
+                    before_sha256: beforeSha,
+                    after_sha256: beforeSha,
+                    message: 'operation already applied; idempotent no-op preserved existing rollback manifest',
+                });
+                continue;
+            }
+            blockers.push(`base_hash_mismatch:${op.path}`);
+            await appendJournal(artifactDir, blockedEvent(op, 'base hash mismatch'));
+            continue;
+        }
+        const dirty = await gitDirtyStatus(root, op.path);
+        if (dirty && !options.allowDirtyTouched) {
+            blockers.push(`dirty_touched_path:${op.path}`);
+            await appendJournal(artifactDir, blockedEvent(op, `dirty touched path blocked: ${dirty}`));
+            continue;
+        }
+        if (op.kind === 'create' && beforeExists) {
+            blockers.push(`create_would_overwrite_existing:${op.path}`);
+            await appendJournal(artifactDir, blockedEvent(op, 'existing user-authored path'));
+            continue;
+        }
+        const backupPath = before == null ? null : path.join('backups', `${op.id}-${path.basename(op.path)}.bak`);
+        if (backupPath && before != null)
+            await writeTextAtomic(path.join(artifactDir, backupPath), before);
+        if (op.content == null) {
+            blockers.push(`operation_content_missing:${op.id}`);
+            await appendJournal(artifactDir, blockedEvent(op, 'operation content missing'));
+            continue;
+        }
+        await writeTextAtomic(full, op.content);
+        const after = await readText(full, '');
+        const afterSha = sha256(after);
+        rollback.operations.push({
+            operation_id: op.id,
+            path: op.path,
+            inverse: before == null ? 'delete-created' : 'restore-content',
+            before_sha256: beforeSha,
+            after_sha256: afterSha,
+            backup_path: backupPath,
+        });
+        applied += 1;
+        await appendJournal(artifactDir, {
+            schema: 'sks.search-visibility.mutation-journal-event.v1',
+            ts: new Date().toISOString(),
+            operation_id: op.id,
+            event: 'applied',
+            path: op.path,
+            before_sha256: beforeSha,
+            after_sha256: afterSha,
+            message: 'operation applied with base hash verification',
+        });
+    }
+    rollback.blockers = blockers;
+    await writeJsonAtomic(path.join(artifactDir, 'rollback-manifest.json'), rollback);
+    const completed = applied + idempotent;
+    return { ok: blockers.length === 0 && completed === plan.operations.length, status: blockers.length ? 'blocked' : 'applied', applied, rollback, blockers };
+}
+export async function rollbackMutationPlan(root, artifactDir, apply) {
+    const manifest = await readJson(path.join(artifactDir, 'rollback-manifest.json'), {
+        schema: 'sks.search-visibility.rollback-manifest.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: 'unknown',
+        route: '$SEO-GEO-OPTIMIZER',
+        operations: [],
+        blockers: ['rollback_manifest_missing'],
+    });
+    const blockers = [...(manifest.blockers || [])].filter((blocker) => blocker !== 'apply_requires_explicit_--apply');
+    if (!apply)
+        return { ok: true, status: 'planned', rolled_back: 0, blockers: ['rollback_requires_explicit_--apply'] };
+    let rolledBack = 0;
+    for (const op of [...manifest.operations].reverse()) {
+        const full = path.resolve(root, op.path);
+        const current = await exists(full) ? await readText(full, '') : null;
+        const currentSha = current == null ? null : sha256(current);
+        if (op.after_sha256 !== currentSha) {
+            blockers.push(`rollback_hash_mismatch:${op.path}`);
+            await appendJournal(artifactDir, {
+                schema: 'sks.search-visibility.mutation-journal-event.v1',
+                ts: new Date().toISOString(),
+                operation_id: op.operation_id,
+                event: 'blocked',
+                path: op.path,
+                before_sha256: currentSha,
+                after_sha256: null,
+                message: 'rollback blocked because current hash differs from manifest',
+            });
+            continue;
+        }
+        if (op.inverse === 'delete-created') {
+            await fs.rm(full, { force: true });
+        }
+        else if (op.inverse === 'restore-content' && op.backup_path) {
+            const backup = await readText(path.join(artifactDir, op.backup_path), null);
+            if (backup == null) {
+                blockers.push(`rollback_backup_missing:${op.path}`);
+                continue;
+            }
+            await writeTextAtomic(full, backup);
+        }
+        rolledBack += 1;
+        await appendJournal(artifactDir, {
+            schema: 'sks.search-visibility.mutation-journal-event.v1',
+            ts: new Date().toISOString(),
+            operation_id: op.operation_id,
+            event: 'rolled_back',
+            path: op.path,
+            before_sha256: op.after_sha256,
+            after_sha256: op.before_sha256,
+            message: 'operation rolled back from manifest',
+        });
+    }
+    return { ok: blockers.length === 0, status: blockers.length ? 'blocked' : 'rolled_back', rolled_back: rolledBack, blockers };
+}
+async function seoOperations(inventory, findings, options) {
+    const operations = [];
+    const robotsMissing = findings.some((finding) => finding.ruleId === 'seo-robots-missing');
+    const sitemapMissing = findings.some((finding) => finding.ruleId === 'seo-sitemap-missing');
+    if (robotsMissing && inventory.detected_adapter.capabilities.robotsMutation) {
+        const rel = await preferredPolicyPath(options.root, 'robots.txt');
+        const content = managedHeader('robots.txt') + [
+            'User-agent: *',
+            'Allow: /',
+            '',
+            inventory.origin ? `Sitemap: ${trimSlash(inventory.origin)}/sitemap.xml` : '# Sitemap: add verified origin before publishing sitemap directive',
+            '',
+        ].join('\n');
+        operations.push(createOperation('seo-create-robots', rel, content, ['F-seo-robots-missing'], ['sks seo-geo-optimizer verify <mission> --mode seo --strict']));
+    }
+    if (sitemapMissing && inventory.detected_adapter.capabilities.sitemapMutation && inventory.origin) {
+        const rel = await preferredPolicyPath(options.root, 'sitemap.xml');
+        const urls = (inventory.routes.length ? inventory.routes : [{ path: '/', source: 'fallback', kind: 'static', locale: null }]).filter((route) => route.kind === 'static').slice(0, 500);
+        const content = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<!-- sks-search-visibility managed sitemap; sitemap is discovery evidence, not an indexing guarantee. -->',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            ...urls.map((route) => `  <url><loc>${xmlEscape(trimSlash(inventory.origin || '') + (route.path === '/' ? '/' : route.path))}</loc></url>`),
+            '</urlset>',
+            '',
+        ].join('\n');
+        operations.push(createOperation('seo-create-sitemap', rel, content, ['F-seo-sitemap-missing'], ['sks seo-geo-optimizer verify <mission> --mode seo --strict']));
+    }
+    return operations;
+}
+async function geoOperations(inventory, findings, options, entityFacts) {
+    if (!options.includeLlmsTxt)
+        return [];
+    const existing = inventory.policy_files.find((file) => file.kind === 'llms' && file.exists);
+    if (existing && !existing.managed)
+        return [];
+    if (existing)
+        return [];
+    const facts = entityFacts?.facts || [];
+    const rel = await preferredRootPath(options.root, 'llms.txt');
+    const factLines = facts.slice(0, 20).map((fact) => `- ${fact.key}: ${fact.value} (source: ${fact.source})`);
+    const content = managedHeader('llms.txt') + [
+        `# ${entityFacts?.canonical_name || inventory.package.name || 'Project'} llms.txt`,
+        '',
+        '> Optional experimental assistant surface generated from source-backed facts. It does not guarantee AI search visibility, citation, ranking, or traffic.',
+        '',
+        '## Official Sources',
+        ...(inventory.package.repository ? [`- Repository: ${inventory.package.repository}`] : []),
+        ...(inventory.package.homepage ? [`- Homepage: ${inventory.package.homepage}`] : []),
+        '',
+        '## Source-Backed Facts',
+        ...(factLines.length ? factLines : ['- No publish-safe facts were available.']),
+        '',
+    ].join('\n');
+    return [createOperation('geo-create-llms-txt', rel, content, findings.filter((finding) => finding.ruleId === 'geo-llms-txt-optional-missing').map((finding) => finding.id), ['sks seo-geo-optimizer verify <mission> --mode geo --strict'])];
+}
+function createOperation(id, rel, content, findingIds, requiredVerification) {
+    return {
+        id,
+        path: rel,
+        baseSha256: null,
+        proposedSha256: sha256(content),
+        kind: 'create',
+        owner: 'sks-search-visibility',
+        findingIds,
+        reversible: true,
+        preview: `Create ${rel} with SKS managed search-visibility content.`,
+        content,
+        risk: 'low',
+        requiredVerification,
+        scopeAuthorization: [id, rel],
+        ownershipStrategy: 'create-only; never overwrite user-authored files',
+    };
+}
+async function preferredPolicyPath(root, file) {
+    return await exists(path.join(root, 'public')) ? `public/${file}` : file;
+}
+async function preferredRootPath(_root, file) {
+    return file;
+}
+function scopeAllowed(op, scope) {
+    if (!scope.length)
+        return true;
+    return scope.some((item) => op.scopeAuthorization.includes(item) || op.path === item || op.id === item);
+}
+function managedHeader(label) {
+    return [
+        `# sks-search-visibility managed ${label}`,
+        '# owner: sks-search-visibility',
+        '# edit policy: generated only after explicit --apply; safe to remove through sks seo-geo-optimizer rollback',
+        '',
+    ].join('\n');
+}
+function trimSlash(value) {
+    return value.replace(/\/+$/, '');
+}
+function xmlEscape(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+async function appendJournal(artifactDir, event) {
+    await appendJsonl(path.join(artifactDir, 'mutation-journal.jsonl'), event);
+}
+function blockedEvent(op, message) {
+    return {
+        schema: 'sks.search-visibility.mutation-journal-event.v1',
+        ts: new Date().toISOString(),
+        operation_id: op?.id || 'none',
+        event: 'blocked',
+        path: op?.path || '',
+        before_sha256: null,
+        after_sha256: null,
+        message,
+    };
+}
+async function gitDirtyStatus(root, rel) {
+    if (!(await exists(path.join(root, '.git'))))
+        return '';
+    const result = spawnSync('git', ['status', '--porcelain', '--', rel], {
+        cwd: root,
+        encoding: 'utf8',
+        stdio: 'pipe',
+    });
+    if (result.status !== 0)
+        return '';
+    return String(result.stdout || '').trim();
+}
+//# sourceMappingURL=mutation.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { exists } from '../fsx.js';
+import { SEARCH_VISIBILITY_DIR, routeForMode } from './mission.js';
+const COMMON_REQUIRED = [
+    'intake.json',
+    'adapter-detection.json',
+    'site-inventory.json',
+    'route-graph.json',
+    'robots-policy.json',
+    'structured-data-ledger.json',
+];
+export async function verifySearchVisibility(ctx, inventory, mission) {
+    const route = routeForMode(ctx.mode);
+    const required = [
+        ...COMMON_REQUIRED,
+        ctx.mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json',
+    ];
+    const checked = mission
+        ? await Promise.all(required.map(async (artifact) => {
+            const file = path.join(mission.artifactDir, artifact);
+            const present = await exists(file);
+            return { path: path.relative(mission.dir, file).split(path.sep).join('/'), ok: present, message: present ? 'present' : 'missing' };
+        }))
+        : [];
+    const blockers = checked.filter((item) => !item.ok).map((item) => `missing_artifact:${item.path}`);
+    const productionVerified = Boolean(ctx.origin && !ctx.offline);
+    const unverified = [
+        ...(ctx.origin && !ctx.offline ? [] : ['production_http_not_verified']),
+        ...(ctx.framework === 'unsupported' ? ['framework_specific_mutation_not_verified'] : []),
+        ...(ctx.mode === 'geo' ? ['external_ai_answer_observation_not_verified', 'measured_outcome_pending'] : ['search_ranking_or_traffic_outcome_not_measured']),
+        ...(!ctx.strict ? ['strict_mode_not_requested'] : []),
+    ];
+    const status = blockers.length
+        ? 'blocked'
+        : productionVerified
+            ? 'production_verified'
+            : 'verified_partial';
+    return {
+        schema: 'sks.search-visibility.verification-report.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: mission?.id || 'ad-hoc',
+        route,
+        status,
+        source_verified: inventory.detected_adapter.capabilities.sourceAudit,
+        build_verified: false,
+        http_verified: productionVerified,
+        browser_verified: false,
+        production_verified: productionVerified,
+        measured_outcome: 'pending',
+        checked_artifacts: checked,
+        blockers,
+        unverified,
+    };
+}
+export function expectedArtifactPath(missionId, artifact) {
+    if (artifact.endsWith('-gate.json') || artifact === 'completion-proof.json')
+        return `.sneakoscope/missions/${missionId}/${artifact}`;
+    return `.sneakoscope/missions/${missionId}/${SEARCH_VISIBILITY_DIR}/${artifact}`;
+}
+//# sourceMappingURL=verifier.js.map

package/dist/core/source-intelligence/source-intelligence-policy.js

@@ -1,9 +1,13 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
-export const SOURCE_INTELLIGENCE_POLICY_SCHEMA = 'sks.source-intelligence-policy.v1';
+export const SOURCE_INTELLIGENCE_POLICY_SCHEMA = 'sks.source-intelligence-policy.v2';
 export function buildSourceIntelligencePolicy(input = {}) {
     const route = input.route || 'unknown';
     const offline = input.offline === true;
+    const query = input.query || '';
+    const docsIntent = /\b(package|npm|SDK|API|MCP|framework|library|docs?|문서|React|Next\.js|Prisma|Tailwind)\b/i.test(query);
+    const xIntent = /\b(?:x\.com|twitter\.com|X\/Twitter|트위터|엑스|site:x\.com|site:twitter\.com)\b/i.test(query);
+    const urlIntent = /https?:\/\/[^\s)"']+/i.test(query);
     const context7Available = input.context7Available !== false;
     const codex = input.codexWebCapability || {
         schema: 'sks.codex-web-search-capability.v1',
@@ -11,43 +15,65 @@ export function buildSourceIntelligencePolicy(input = {}) {
         status: 'degraded_unverified',
         reason: 'capability_not_checked'
     };
-    const xai = input.xaiDetection;
-    const xaiSearchCapable = xai?.search_capable === true;
-    const xaiConfigured = xai?.configured === true;
     const blockers = [];
     const warnings = [];
     const wrongnessKinds = [];
-    if (!context7Available) {
+    if (docsIntent && !context7Available) {
         blockers.push('docs_context_missing');
         wrongnessKinds.push('context7_missing');
     }
     if (!offline && codex.status === 'unavailable') {
-        warnings.push('codex_web_search_unavailable_degraded_to_context7_only');
+        warnings.push('codex_web_search_unavailable_degraded_to_ultra_cache_or_docs');
         wrongnessKinds.push('codex_web_search_missing');
     }
-    if (xaiSearchCapable)
-        warnings.push('xai_search_evidence_required_for_verified_current_claims');
-    if (xaiConfigured && !xaiSearchCapable && xai?.configured_but_unverified)
-        warnings.push('xai_mcp_configured_but_search_capability_unverified');
-    const mode = !context7Available
+    if (input.xaiDetection)
+        warnings.push('xai_detection_input_ignored_by_source_intelligence_v2');
+    const mode = input.mode || (!context7Available && docsIntent
         ? 'blocked'
         : offline
-            ? 'offline_context7_only'
-            : xaiSearchCapable
-                ? 'context7_codex_web_xai'
-                : codex.status === 'unavailable'
-                    ? 'context7_only_degraded'
-                    : 'context7_codex_web';
+            ? 'offline_cache'
+            : urlIntent
+                ? 'url_acquisition'
+                : xIntent
+                    ? 'x_search'
+                    : /deep|exhaustive|가능한 전부|누락 없이|완벽하게 조사/i.test(query)
+                        ? 'ultra_deep'
+                        : 'ultra_balanced');
+    const selected = new Set();
+    if (docsIntent && context7Available)
+        selected.add('context7');
+    if (!offline && codex.status !== 'unavailable')
+        selected.add('codex_web');
+    if (xIntent || mode === 'x_search')
+        selected.add('x_public');
+    if (offline)
+        selected.add('offline_cache');
     return {
         schema: SOURCE_INTELLIGENCE_POLICY_SCHEMA,
         generated_at: nowIso(),
         ok: blockers.length === 0,
         route,
         mode,
+        requirements: {
+            official_sources: docsIntent,
+            full_content: mode !== 'ultra_fast',
+            counter_search: mode === 'ultra_deep' || mode === 'ultra_exhaustive',
+            claim_ledger: true,
+            social_recency: xIntent || mode === 'x_search',
+            code_execution_verification: /\b(code|implementation|test|runtime|구현)\b/i.test(query)
+        },
+        capabilities: {
+            docs: context7Available ? ['context7', 'official_web'] : ['official_web'],
+            web_search: !offline ? ['codex_web'] : [],
+            repo_search: ['github'],
+            social: xIntent || mode === 'x_search' ? ['x_public', 'authenticated_chrome_optional', 'official_x_api_optional'] : [],
+            browser: ['codex_browser_optional', 'codex_chrome_optional']
+        },
+        selected_providers: [...selected],
         context7: {
-            required: true,
+            required: docsIntent,
             available: context7Available,
-            status: context7Available ? (offline ? 'offline_only' : 'available') : 'missing'
+            status: docsIntent ? (context7Available ? (offline ? 'offline_only' : 'available') : 'missing') : 'not_required'
         },
         codex_web_search: {
             required: !offline,
@@ -55,13 +81,6 @@ export function buildSourceIntelligencePolicy(input = {}) {
             status: codex.status,
             reason: codex.reason
         },
-        xai_mcp: {
-            required: xaiSearchCapable,
-            configured: xaiConfigured,
-            search_capable: xaiSearchCapable,
-            configured_but_unverified: xai?.configured_but_unverified === true,
-            status: xai?.status || 'not_checked'
-        },
         wrongness_kinds: wrongnessKinds,
         blockers,
         warnings

package/dist/core/source-intelligence/source-intelligence-proof.js

@@ -1,25 +1,21 @@
-export const SOURCE_INTELLIGENCE_PROOF_SCHEMA = 'sks.source-intelligence-proof.v1';
+export const SOURCE_INTELLIGENCE_PROOF_SCHEMA = 'sks.source-intelligence-proof.v2';
 export function buildSourceIntelligenceProof(policy, evidence) {
     const blockers = [...policy.blockers];
     const wrongnessKinds = [...policy.wrongness_kinds];
-    const context7Ok = evidence.context7?.ok === true;
-    const codexWebOk = policy.codex_web_search.required ? evidence.codex_web_search?.ok === true : true;
-    const xaiOk = policy.xai_mcp.required ? evidence.xai_search?.ok === true : true;
-    const xaiMissingIsBlocker = policy.xai_mcp.required && !xaiOk;
+    const context7Ok = policy.context7.required ? evidence.context7?.ok === true : true;
+    const ultraOk = evidence.ultra_search?.proof.provider_independent === true && evidence.ultra_search?.proof.xai_runtime_dependency === false;
     const appshotsRequired = evidence.appshots?.capability.visual_required === true;
     const appshotsOk = appshotsRequired ? evidence.appshots?.ok === true : true;
     if (policy.context7.required && !context7Ok) {
         blockers.push('context7_missing');
         wrongnessKinds.push('context7_missing');
     }
-    if (policy.codex_web_search.required && !codexWebOk && policy.mode !== 'context7_only_degraded') {
-        blockers.push('codex_web_search_missing');
-        wrongnessKinds.push('codex_web_search_missing');
-    }
-    if (policy.xai_mcp.required && !xaiOk) {
-        blockers.push('xai_available_not_used');
-        wrongnessKinds.push('xai_available_not_used');
+    if (!ultraOk) {
+        blockers.push('ultra_search_provider_independent_proof_missing');
+        wrongnessKinds.push('ultra_search_provider_independent_proof_missing');
     }
+    if (evidence.ultra_search?.proof.blockers.length)
+        blockers.push(...evidence.ultra_search.proof.blockers);
     if (appshotsRequired && !appshotsOk) {
         blockers.push('appshots_operator_action_missing');
         wrongnessKinds.push('appshots_operator_action_missing');
@@ -32,10 +28,8 @@ export function buildSourceIntelligenceProof(policy, evidence) {
             context7_required: policy.context7.required,
             context7_ok: context7Ok,
             codex_web_required: policy.codex_web_search.required,
-            codex_web_ok: codexWebOk,
-            xai_required: policy.xai_mcp.required,
-            xai_ok: xaiOk,
-            xai_missing_is_blocker: xaiMissingIsBlocker,
+            ultra_search_ok: ultraOk,
+            provider_independent: evidence.ultra_search?.proof.provider_independent === true,
             appshots_required: appshotsRequired,
             appshots_ok: appshotsOk
         },