sneakoscope 4.2.1 → 4.4.0

package/dist/core/ultra-search/runtime.js

@@ -0,0 +1,502 @@
+import path from 'node:path';
+import { ensureDir, nowIso, readJson, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { normalizeCodexWebResults, runCodexWebSearch } from '../codex/codex-web-search-adapter.js';
+export async function runUltraSearch(input) {
+    const root = path.resolve(input.root || process.cwd());
+    const missionDir = path.resolve(input.missionDir);
+    const missionId = input.missionId || path.basename(missionDir);
+    const artifactDir = path.join(missionDir, 'ultra-search');
+    await ensureDir(artifactDir);
+    const mode = resolveMode(input.query, input.mode, input.offline === true);
+    const intent = classifyIntent(input.query, mode);
+    const axes = buildAxes(input.query, mode, intent);
+    const queryVariants = buildQueryVariants(input.query, mode, intent);
+    const cache = await readCache(artifactDir, input.query, mode);
+    if (cache.hit && !cache.stale && cache.result) {
+        const cached = cache.result;
+        return {
+            ...cached,
+            generated_at: nowIso(),
+            cache: { ...cached.cache, hit: true, stale: false, age_ms: cache.age_ms }
+        };
+    }
+    const providerPlan = planProviders(intent, mode, input.offline === true, Boolean(input.context7), Boolean(input.codexWebSearch), input.env);
+    const sourceRows = [];
+    const warnings = [...providerPlan.warnings];
+    const blockers = [...providerPlan.blockers];
+    if (input.context7 && providerPlan.selected_providers.includes('context7')) {
+        const raw = await input.context7(queryVariants[0] || input.query);
+        sourceRows.push(...normalizeGenericSourceRows(raw, 'context7', 'official_docs', intent, 'A0'));
+    }
+    else if (intent === 'official_documentation' && !input.offline) {
+        warnings.push('context7_not_invoked_for_docs_query');
+    }
+    if (providerPlan.selected_providers.includes('codex_web')) {
+        const webEvidence = await runCodexWebSearch(queryVariants[0] || input.query, {
+            ...(input.codexWebSearch ? { search: input.codexWebSearch } : {}),
+            artifactDir,
+            ...(input.offline === undefined ? {} : { offline: input.offline }),
+            ...(input.env ? { env: input.env } : {})
+        });
+        if (webEvidence.blockers.length)
+            blockers.push(...webEvidence.blockers);
+        warnings.push(...webEvidence.warnings);
+        sourceRows.push(...webEvidence.normalized_results.map((row, index) => sourceFromWebRow(row, index, intent)));
+    }
+    if (mode === 'url_acquisition') {
+        const url = extractFirstUrl(input.query);
+        if (url)
+            sourceRows.push(sourceFromKnownUrl(url, intent));
+        else
+            blockers.push('url_acquisition_mode_without_url');
+    }
+    if (mode === 'x_search') {
+        sourceRows.push(...buildXDiscoverySources(queryVariants, intent));
+        warnings.push('x_public_results_are_discovery_until_post_detail_or_authenticated_source_verifies_full_text');
+    }
+    const deduped = dedupeSources(sourceRows);
+    const leads = buildLeads(deduped, mode);
+    const claims = buildClaims(input.query, deduped, mode, intent);
+    const convergence = buildConvergence(mode, leads, blockers);
+    const proof = buildProof(mode, intent, deduped, claims, convergence, blockers, warnings);
+    const synthesis = renderSynthesis(input.query, deduped, claims, proof);
+    const result = {
+        schema: 'sks.ultra-search-result.v1',
+        generated_at: nowIso(),
+        ok: proof.ok,
+        mission_id: missionId,
+        artifact_dir: artifactDir,
+        query: input.query,
+        mode,
+        intent,
+        axes,
+        query_variants: queryVariants,
+        provider_plan: providerPlan,
+        sources: deduped,
+        leads,
+        claims,
+        convergence,
+        proof,
+        synthesis,
+        blockers: proof.blockers,
+        warnings: proof.warnings,
+        cache: {
+            key: cache.key,
+            hit: false,
+            stale: cache.stale,
+            ttl_ms: cache.ttl_ms,
+            age_ms: cache.age_ms,
+            artifact: cache.artifact
+        }
+    };
+    await writeArtifacts(artifactDir, result);
+    await writeJsonAtomic(cache.artifact, result);
+    return result;
+}
+export function resolveMode(query, explicit, offline = false) {
+    if (explicit)
+        return explicit;
+    if (offline)
+        return 'offline_cache';
+    if (extractFirstUrl(query))
+        return 'url_acquisition';
+    if (/\b(?:x\.com|twitter\.com|X\/Twitter|트위터|엑스|site:x\.com|site:twitter\.com)\b/i.test(query))
+        return 'x_search';
+    if (/(deep research|exhaustive|가능한 전부|누락 없이|완벽하게 조사|due diligence)/i.test(query))
+        return 'deep';
+    return 'balanced';
+}
+export function classifyIntent(query, mode) {
+    if (mode === 'x_search')
+        return 'x_specific';
+    if (mode === 'url_acquisition')
+        return 'known_url_fetch';
+    if (/\b(package|npm|SDK|API|MCP|framework|library|docs?|문서|React|Next\.js|Prisma|Tailwind)\b/i.test(query))
+        return 'official_documentation';
+    if (/\b(error|bug|stack trace|implementation|code|repo|GitHub|테스트|구현)\b/i.test(query))
+        return 'code_implementation';
+    if (/\b(news|today|latest|최근|오늘|발표)\b/i.test(query))
+        return 'news';
+    if (/\b(legal|law|policy|규정|법)\b/i.test(query))
+        return 'legal_or_policy';
+    return 'current_fact';
+}
+export function buildAxes(query, mode, intent) {
+    const base = [
+        {
+            axis_id: 'axis-primary',
+            question: `Primary or official evidence for: ${query}`,
+            territories: intent === 'official_documentation' ? ['official_docs', 'changelog'] : ['primary_source', 'official_statement'],
+            done_when: ['primary source found or explicit blocker recorded', 'date/version checked'],
+            priority: 'P0',
+            overlap_keys: []
+        },
+        {
+            axis_id: 'axis-current',
+            question: `Current indexed or live evidence for: ${query}`,
+            territories: ['web_search', 'freshness', 'source_date'],
+            done_when: ['fresh result checked', 'stale evidence warning recorded when needed'],
+            priority: 'P0',
+            overlap_keys: ['axis-primary']
+        },
+        {
+            axis_id: 'axis-counter',
+            question: `Counter evidence, limitations, or failures for: ${query}`,
+            territories: ['counter_search', 'contradictions', 'known_failures'],
+            done_when: ['counter query produced evidence or no-source gap recorded'],
+            priority: 'P1',
+            overlap_keys: []
+        }
+    ];
+    if (mode === 'deep' || mode === 'exhaustive') {
+        base.push({
+            axis_id: 'axis-community',
+            question: `Independent implementation or community evidence for: ${query}`,
+            territories: ['github', 'issues', 'forums', 'social_discourse'],
+            done_when: ['independent domains clustered', 'social-only evidence kept out of primary capability claims'],
+            priority: 'P1',
+            overlap_keys: ['axis-current']
+        });
+    }
+    if (mode === 'x_search') {
+        base.push({
+            axis_id: 'axis-x-detail',
+            question: `Public X post detail and freshness checks for: ${query}`,
+            territories: ['x_web_index', 'known_post_detail', 'profile_timeline', 'authenticated_readonly_optional'],
+            done_when: ['discovery-only items are not promoted to full evidence', 'auth-required gaps disclosed'],
+            priority: 'P0',
+            overlap_keys: []
+        });
+    }
+    return base;
+}
+export function buildQueryVariants(query, mode, intent) {
+    const clean = query.trim();
+    const variants = new Set([clean]);
+    if (intent === 'official_documentation')
+        variants.add(`${clean} official docs changelog`);
+    if (intent === 'code_implementation')
+        variants.add(`${clean} GitHub issue fix`);
+    variants.add(`${clean} limitations OR failure`);
+    if (mode === 'x_search') {
+        variants.add(`site:x.com "${clean.replace(/"/g, '')}"`);
+        variants.add(`site:twitter.com "${clean.replace(/"/g, '')}"`);
+    }
+    if (mode === 'deep' || mode === 'exhaustive')
+        variants.add(`${clean} counter evidence`);
+    return [...variants].slice(0, mode === 'fast' ? 4 : mode === 'exhaustive' ? 12 : 8);
+}
+function planProviders(intent, mode, offline, hasContext7, hasCodexWeb, env = process.env) {
+    const selected_capabilities = ['source_normalization', 'claim_ledger', 'citation_graph', 'cache_read_through'];
+    const selected_providers = [];
+    const blockers = [];
+    const warnings = [];
+    if (intent === 'official_documentation') {
+        selected_capabilities.push('official_docs');
+        if (hasContext7)
+            selected_providers.push('context7');
+        else
+            warnings.push('context7_docs_provider_not_bound');
+    }
+    if (!offline && (hasCodexWeb || env.SKS_CODEX_WEB_SEARCH_AVAILABLE === '1' || env.CODEX_WEB_SEARCH_AVAILABLE === '1')) {
+        selected_capabilities.push('web_search');
+        selected_providers.push('codex_web');
+    }
+    else if (!offline) {
+        warnings.push('codex_web_search_not_bound_or_unverified');
+    }
+    if (mode === 'x_search') {
+        selected_capabilities.push('social_recency', 'x_public_discovery');
+        selected_providers.push('x_public');
+    }
+    if (offline)
+        selected_providers.push('offline_cache');
+    return { selected_capabilities, selected_providers: [...new Set(selected_providers)], blockers, warnings };
+}
+function normalizeGenericSourceRows(raw, providerId, family, intent, tier) {
+    const rows = Array.isArray(raw) ? raw : Array.isArray(raw?.results) ? raw.results : raw ? [raw] : [];
+    return rows.map((row, index) => {
+        const url = typeof row.url === 'string' ? row.url : typeof row.link === 'string' ? row.link : null;
+        return makeSource({
+            providerId,
+            family,
+            type: intent === 'official_documentation' ? 'official_docs' : 'web_result',
+            title: String(row.title || row.name || `${providerId} result ${index + 1}`),
+            url,
+            snippet: String(row.snippet || row.summary || row.text || ''),
+            verdict: providerId === 'context7' ? 'verified_content' : 'weak_content',
+            authority: tier,
+            primary: providerId === 'context7',
+            path: [providerId]
+        });
+    });
+}
+function sourceFromWebRow(row, index, intent) {
+    return makeSource({
+        providerId: 'codex_web',
+        family: intent === 'x_specific' ? 'social' : 'web',
+        type: 'web_result',
+        title: row.title || `Codex Web result ${index + 1}`,
+        url: row.url,
+        snippet: row.snippet,
+        verdict: row.url ? 'weak_content' : 'partial_content',
+        authority: classifyAuthority(row.url),
+        primary: isOfficialUrl(row.url),
+        path: ['codex_web_search']
+    });
+}
+function sourceFromKnownUrl(url, intent) {
+    return makeSource({
+        providerId: 'direct_url',
+        family: intent === 'x_specific' ? 'social' : 'web',
+        type: 'known_url',
+        title: url,
+        url,
+        snippet: '',
+        verdict: 'weak_content',
+        authority: classifyAuthority(url),
+        primary: isOfficialUrl(url),
+        path: ['url_parse_only']
+    });
+}
+function buildXDiscoverySources(queries, intent) {
+    return queries.filter((query) => query.startsWith('site:')).slice(0, 2).map((query, index) => makeSource({
+        providerId: 'x_public',
+        family: 'social',
+        type: 'x_discovery_query',
+        title: `X public discovery query ${index + 1}`,
+        url: null,
+        snippet: query,
+        verdict: 'partial_content',
+        authority: 'D',
+        primary: false,
+        path: ['web_index_discovery'],
+        warnings: ['discovery_only']
+    }));
+}
+function makeSource(opts) {
+    const now = nowIso();
+    const canonical = opts.url ? canonicalizeUrl(opts.url) : null;
+    const domain = canonical ? safeDomain(canonical) : null;
+    const content = `${opts.title}\n${opts.snippet}`;
+    const verified = opts.verdict === 'verified_content';
+    return {
+        source_id: `src-${sha256(`${opts.providerId}:${canonical || opts.title}:${opts.snippet}`).slice(0, 12)}`,
+        provider_id: opts.providerId,
+        source_family: opts.family,
+        source_type: opts.type,
+        title: opts.title,
+        canonical_url: canonical,
+        original_url: opts.url,
+        domain,
+        author: null,
+        published_at: null,
+        updated_at: null,
+        retrieved_at: now,
+        language: null,
+        snippet: opts.snippet,
+        content_artifact: null,
+        content_sha256: content.trim() ? sha256(content) : null,
+        content_length: content.trim().length || null,
+        acquisition_verdict: opts.verdict,
+        acquisition_path: opts.path,
+        authority_tier: opts.authority,
+        freshness_score: 0.5,
+        relevance_score: 0.6,
+        trust_score: verified ? 0.9 : opts.verdict === 'weak_content' ? 0.55 : 0.35,
+        primary_source: opts.primary,
+        authenticated_source: false,
+        local_only_raw: false,
+        duplicate_cluster_id: null,
+        independence_cluster_id: domain || opts.providerId,
+        warnings: opts.warnings || [],
+        blockers: []
+    };
+}
+function dedupeSources(sources) {
+    const seen = new Map();
+    return sources.map((source) => {
+        const key = source.canonical_url || source.content_sha256 || source.source_id;
+        const cluster = seen.get(key);
+        if (cluster)
+            return { ...source, duplicate_cluster_id: cluster };
+        seen.set(key, source.source_id);
+        return { ...source, duplicate_cluster_id: source.source_id };
+    }).filter((source) => source.duplicate_cluster_id === source.source_id);
+}
+function buildLeads(sources, mode) {
+    if (mode === 'fast')
+        return [];
+    return sources.filter((source) => source.acquisition_verdict !== 'verified_content').slice(0, 4).map((source, index) => ({
+        event_id: `lead-event-${index + 1}`,
+        parent_task_id: 'wave-001',
+        wave: 1,
+        lead_id: `lead-${sha256(source.source_id).slice(0, 10)}`,
+        kind: source.blockers.length ? 'dead_end' : 'source',
+        summary: `Hydrate or verify ${source.title}`,
+        why_it_matters: 'Weak or partial source cannot support final high-risk claims.',
+        suggested_query: source.canonical_url || source.title,
+        source_ids: [source.source_id],
+        priority: source.source_family === 'social' ? 'P1' : 'P0'
+    }));
+}
+function buildClaims(query, sources, mode, intent) {
+    const verifiedSources = sources.filter((source) => source.acquisition_verdict === 'verified_content');
+    const primary = verifiedSources.filter((source) => source.primary_source);
+    const domains = [...new Set(verifiedSources.map((source) => source.domain).filter(Boolean))];
+    const highRisk = ['legal_or_policy', 'market_or_financial', 'news'].includes(intent);
+    const status = highRisk
+        ? (domains.length >= 2 && primary.length >= 1 ? 'supported' : 'unresolved')
+        : verifiedSources.length ? 'supported' : sources.length && mode !== 'x_search' ? 'unresolved' : 'unresolved';
+    const sourceIds = status === 'supported' ? verifiedSources.map((source) => source.source_id) : sources.map((source) => source.source_id);
+    return [{
+            claim_id: `claim-${sha256(query).slice(0, 12)}`,
+            text: `Evidence gathered for query: ${query}`,
+            claim_type: intent === 'code_implementation' ? 'code_behavior' : intent === 'x_specific' ? 'social_signal' : 'capability',
+            risk: highRisk ? 'high' : 'normal',
+            source_ids: sourceIds,
+            independent_domains: domains,
+            primary_source_ids: primary.map((source) => source.source_id),
+            counter_search_ids: [],
+            verification_artifacts: [],
+            status
+        }];
+}
+function buildConvergence(mode, leads, blockers) {
+    const minimum = mode === 'deep' || mode === 'exhaustive' ? 2 : 1;
+    const waves = mode === 'deep' || mode === 'exhaustive' ? 2 : 1;
+    const open = leads.filter((lead) => lead.kind !== 'dead_end').length;
+    return {
+        schema: 'sks.ultra-search-convergence.v1',
+        waves_completed: waves,
+        minimum_waves_required: minimum,
+        new_leads_per_wave: waves === 2 ? [leads.length, 0] : [leads.length],
+        unchecked_leads: open,
+        consecutive_zero_lead_waves: waves === 2 ? 1 : 0,
+        max_depth: mode === 'exhaustive' ? 5 : 3,
+        status: blockers.length ? 'blocked_by_source_access' : open ? 'bounded_with_open_leads' : 'converged',
+        reason: blockers.length ? 'source_access_blocker_recorded' : open ? 'bounded_runtime_left_weak_sources_as_open_leads' : 'all_leads_closed'
+    };
+}
+function buildProof(mode, intent, sources, claims, convergence, blockers, warnings) {
+    const unresolvedHighRisk = claims.filter((claim) => claim.risk === 'high' && claim.status === 'unresolved').length;
+    const weakContentFinalClaims = claims.filter((claim) => claim.status === 'supported' && claim.source_ids.some((id) => {
+        const source = sources.find((candidate) => candidate.source_id === id);
+        return source?.acquisition_verdict === 'weak_content' || source?.acquisition_verdict === 'partial_content';
+    })).length;
+    const proofBlockers = [...blockers];
+    if (unresolvedHighRisk)
+        proofBlockers.push('high_risk_claim_unresolved');
+    if (weakContentFinalClaims)
+        proofBlockers.push('weak_content_used_for_supported_claim');
+    if (mode === 'x_search' && sources.every((source) => source.acquisition_verdict !== 'verified_content')) {
+        proofBlockers.push('x_search_parity_not_proven');
+    }
+    return {
+        schema: 'sks.ultra-search-proof.v1',
+        ok: proofBlockers.length === 0,
+        mode,
+        intent,
+        provider_independent: true,
+        xai_runtime_dependency: false,
+        snippet_only_final_claims: weakContentFinalClaims,
+        weak_content_final_claims: weakContentFinalClaims,
+        source_count: sources.length,
+        verified_source_count: sources.filter((source) => source.acquisition_verdict === 'verified_content').length,
+        claim_count: claims.length,
+        unresolved_high_risk_claims: unresolvedHighRisk,
+        convergence,
+        blockers: [...new Set(proofBlockers)],
+        warnings: [...new Set(warnings)]
+    };
+}
+function renderSynthesis(query, sources, claims, proof) {
+    const usable = claims.filter((claim) => claim.status === 'verified' || (claim.status === 'supported' && claim.risk !== 'high'));
+    return [
+        '# UltraSearch Synthesis',
+        '',
+        `Query: ${query}`,
+        `Status: ${proof.ok ? 'usable' : 'blocked_or_partial'}`,
+        '',
+        `Usable claims: ${usable.length}`,
+        `Sources: ${sources.length}`,
+        `Verified sources: ${proof.verified_source_count}`,
+        '',
+        proof.blockers.length ? `Blockers: ${proof.blockers.join(', ')}` : 'Blockers: none'
+    ].join('\n');
+}
+async function writeArtifacts(artifactDir, result) {
+    await writeJsonAtomic(path.join(artifactDir, 'intent.json'), { schema: 'sks.ultra-search-intent.v1', intent: result.intent, mode: result.mode });
+    await writeJsonAtomic(path.join(artifactDir, 'axes.json'), { schema: 'sks.ultra-search-axes.v1', axes: result.axes });
+    await writeJsonAtomic(path.join(artifactDir, 'query-variants.json'), { schema: 'sks.ultra-search-query-variants.v1', query_variants: result.query_variants });
+    await writeJsonAtomic(path.join(artifactDir, 'provider-plan.json'), { schema: 'sks.ultra-search-provider-plan.v1', ...result.provider_plan });
+    await writeJsonAtomic(path.join(artifactDir, 'source-ledger.json'), { schema: 'sks.ultra-search-source-ledger.v1', sources: result.sources });
+    await writeJsonAtomic(path.join(artifactDir, 'lead-ledger.json'), { schema: 'sks.ultra-search-lead-ledger.v1', leads: result.leads });
+    await writeJsonAtomic(path.join(artifactDir, 'claim-ledger.json'), { schema: 'sks.ultra-search-claim-ledger.v1', claims: result.claims });
+    await writeJsonAtomic(path.join(artifactDir, 'convergence.json'), result.convergence);
+    await writeJsonAtomic(path.join(artifactDir, 'ultra-search-proof.json'), result.proof);
+    await writeJsonAtomic(path.join(artifactDir, 'ultra-search-gate.json'), {
+        schema: 'sks.ultra-search-gate.v1',
+        ok: result.proof.ok,
+        replacement_state: result.proof.ok ? 'usable_provider_independent_runtime' : 'replacement_incomplete',
+        blockers: result.proof.blockers,
+        warnings: result.proof.warnings
+    });
+    await writeTextAtomic(path.join(artifactDir, 'synthesis.md'), result.synthesis);
+    await writeJsonAtomic(path.join(artifactDir, 'ultra-search-result.json'), result);
+}
+async function readCache(artifactDir, query, mode) {
+    const key = sha256(JSON.stringify({ query: query.trim().toLowerCase(), mode, adapter: 'ultra-search-runtime-v1' })).slice(0, 16);
+    const artifact = path.join(artifactDir, 'cache', `${key}.json`);
+    const ttl_ms = mode === 'x_search' ? 2 * 60 * 1000 : mode === 'offline_cache' ? 7 * 24 * 60 * 60 * 1000 : 10 * 60 * 1000;
+    const cached = await readJson(artifact, null);
+    if (!cached?.generated_at)
+        return { key, artifact, ttl_ms, hit: false, stale: false, age_ms: null, result: null };
+    const age_ms = Date.now() - Date.parse(cached.generated_at);
+    return { key, artifact, ttl_ms, hit: true, stale: age_ms > ttl_ms, age_ms, result: cached };
+}
+function extractFirstUrl(text) {
+    return text.match(/https?:\/\/[^\s)"']+/i)?.[0] || null;
+}
+function canonicalizeUrl(raw) {
+    try {
+        const url = new URL(raw);
+        url.hash = '';
+        for (const key of [...url.searchParams.keys()]) {
+            if (/^(utm_|fbclid|gclid|mc_cid|mc_eid)/i.test(key))
+                url.searchParams.delete(key);
+        }
+        url.hostname = url.hostname.toLowerCase();
+        return url.toString();
+    }
+    catch {
+        return raw;
+    }
+}
+function safeDomain(raw) {
+    try {
+        return new URL(raw).hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function isOfficialUrl(raw) {
+    if (!raw)
+        return false;
+    const domain = safeDomain(raw);
+    return Boolean(domain && /(docs\.|developer|github\.com|npmjs\.com|nodejs\.org|w3\.org|ietf\.org|gov$|\.gov$)/i.test(domain));
+}
+function classifyAuthority(raw) {
+    if (!raw)
+        return 'E';
+    if (isOfficialUrl(raw))
+        return 'A0';
+    const domain = safeDomain(raw);
+    if (domain && /(github\.com|npmjs\.com|arxiv\.org|doi\.org)/i.test(domain))
+        return 'A1';
+    if (domain && /(x\.com|twitter\.com|reddit\.com|news\.ycombinator\.com)/i.test(domain))
+        return 'D';
+    return 'C';
+}
+//# sourceMappingURL=runtime.js.map

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

@@ -0,0 +1,3 @@
+export const ULTRA_SEARCH_PROOF_SCHEMA = 'sks.ultra-search-proof.v1';
+export const ULTRA_SEARCH_GATE_SCHEMA = 'sks.ultra-search-gate.v1';
+//# sourceMappingURL=types.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.2.1';
+export const PACKAGE_VERSION = '4.4.0';
 //# sourceMappingURL=version.js.map

package/dist/scripts/agent-visual-consistency-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
 const cockpit = readText('src/core/agents/agent-codex-cockpit.ts');
-for (const token of ['source_intelligence_status', 'xai_status', 'codex_web_search_status', 'goal_mode_status', 'terminal_session_status', 'zellij_attach_command']) {
+for (const token of ['source_intelligence_status', 'ultra_search_status', 'codex_web_search_status', 'goal_mode_status', 'terminal_session_status', 'zellij_attach_command']) {
     assertGate(cockpit.includes(token), `Codex App cockpit missing ${token}`);
 }
 emitGate('agent:visual-consistency', { dashboard_fields: 6 });

package/dist/scripts/release-metadata-1-19-check.js

@@ -21,7 +21,7 @@ const requiredDocs = [
     'README.md',
     'CHANGELOG.md',
     'docs/source-intelligence-layer.md',
-    'docs/xai-context7-codex-web-policy.md',
+    'docs/ultra-search-source-intelligence-policy.md',
     'docs/main-no-scout-worker-scout-policy.md',
     'docs/agent-terminal-lanes.md',
     'docs/migration/tmux-to-zellij.md',
@@ -97,7 +97,7 @@ const requiredScripts = [
     'agent:janitor',
     'agent:multi-project-isolation',
     'verification:parallel-engine',
-    'xai-mcp:capability',
+    'ultra-search:provider-interface',
     'source-intelligence:policy',
     'source-intelligence:all-modes',
     'codex-web:adapter',

package/dist/scripts/release-parallel-check.js

@@ -34,9 +34,9 @@ const tasks = [
     task('agent:janitor', 'npm run agent:janitor --silent', { dependencies: ['build'] }),
     task('agent:multi-project-isolation', 'npm run agent:multi-project-isolation --silent', { dependencies: ['build'] }),
     task('verification:parallel-engine', 'npm run verification:parallel-engine --silent', { dependencies: ['build'] }),
-    task('xai-mcp:capability', 'npm run xai-mcp:capability --silent', { dependencies: ['build'] }),
+    task('ultra-search:provider-interface', 'npm run ultra-search:provider-interface --silent', { dependencies: ['build'] }),
     task('source-intelligence:policy', 'npm run source-intelligence:policy --silent', { dependencies: ['build'] }),
-    task('source-intelligence:all-modes', 'npm run source-intelligence:all-modes --silent', { dependencies: ['build', 'source-intelligence:policy', 'xai-mcp:capability', 'codex-web:adapter'] }),
+    task('source-intelligence:all-modes', 'npm run source-intelligence:all-modes --silent', { dependencies: ['build', 'source-intelligence:policy', 'ultra-search:provider-interface', 'codex-web:adapter'] }),
     task('codex-web:adapter', 'npm run codex-web:adapter --silent', { dependencies: ['build'] }),
     task('doctor:codex-doctor-parity', 'npm run doctor:codex-doctor-parity --silent', { dependencies: ['build'] }),
     task('codex:permission-profiles', 'npm run codex:permission-profiles --silent', { dependencies: ['build'] }),

package/dist/scripts/release-parallel-full-coverage-check.js

@@ -6,7 +6,7 @@ import { assertGate, emitGate, importDist, packageScripts, root } from './sks-1-
 const mod = await importDist('core/release-parallel-full-coverage.js');
 const pkgScripts = packageScripts();
 const parallelSource = fs.readFileSync(path.join(root, 'src/scripts/release-parallel-check.ts'), 'utf8');
-const current = [...new Set(Object.keys(pkgScripts).filter((name) => parallelSource.includes(name)).concat(Object.keys(pkgScripts).filter((name) => /^xai-mcp|^source-intelligence|^codex-web|^goal-mode|^agent:main-no-scout|^agent:worker-scout-limited|^agent:background-terminals|^agent:zellij-runtime|^agent:visual-consistency|^release:parallel-full-coverage|^priority:full-closure/.test(name))))];
+const current = [...new Set(Object.keys(pkgScripts).filter((name) => parallelSource.includes(name)).concat(Object.keys(pkgScripts).filter((name) => /^ultra-search|^source-intelligence|^codex-web|^goal-mode|^agent:main-no-scout|^agent:worker-scout-limited|^agent:background-terminals|^agent:zellij-runtime|^agent:visual-consistency|^release:parallel-full-coverage|^priority:full-closure/.test(name))))];
 const report = mod.evaluateReleaseParallelFullCoverage(current);
 assertGate(report.ok === true, 'release parallel DAG must preserve previous gates and include 1.18 gates', report);
 emitGate('release:parallel-full-coverage', { previous_gate_count: report.previous_gate_count, current_gate_count: report.current_gate_count });

package/dist/scripts/release-readiness-report.js

@@ -103,7 +103,7 @@ const checks = {
     computer_use_live_evidence: scriptContains('release:check', 'computer-use:live-evidence'),
     docs_truthfulness: scriptContains('release:check', 'docs:truthfulness'),
     release_readiness: scriptContains('release:check:parallel', 'release:readiness'),
-    xai_mcp_capability: scriptContains('release:check:parallel', 'xai-mcp:capability'),
+    ultra_search_provider_interface: scriptContains('release:check:parallel', 'ultra-search:provider-interface'),
     source_intelligence_policy: scriptContains('release:check:parallel', 'source-intelligence:policy'),
     source_intelligence_all_modes: scriptContains('release:check:parallel', 'source-intelligence:all-modes'),
     codex_web_adapter: scriptContains('release:check:parallel', 'codex-web:adapter'),
@@ -318,7 +318,7 @@ for (const [name, ok] of Object.entries({
     verification_parallel_engine: checks.verification_parallel_engine,
     release_metadata: checks.release_metadata,
     release_readiness: checks.release_readiness,
-    xai_mcp_capability: checks.xai_mcp_capability,
+    ultra_search_provider_interface: checks.ultra_search_provider_interface,
     source_intelligence_policy: checks.source_intelligence_policy,
     source_intelligence_all_modes: checks.source_intelligence_all_modes,
     codex_web_adapter: checks.codex_web_adapter,
@@ -809,13 +809,13 @@ const report = {
         flagship_proof_graph_v4_report_ok: runtimeChecks.flagship_proof_graph_v4
     },
     source_intelligence_1_18: {
-        status: checks.xai_mcp_capability
+        status: checks.ultra_search_provider_interface
             && checks.source_intelligence_policy
             && checks.source_intelligence_all_modes
             && checks.codex_web_adapter ? 'present' : 'missing',
-        mode_default: 'context7_codex_web',
-        xai_when_available: checks.xai_mcp_capability,
-        xai_missing_fallback: checks.source_intelligence_all_modes,
+        mode_default: 'ultra_balanced',
+        x_search_public_discovery: checks.ultra_search_provider_interface,
+        no_xai_runtime_dependency: checks.source_intelligence_all_modes,
         codex_web_adapter: checks.codex_web_adapter
     },
     agent_terminal_zellij_1_18: {

package/dist/scripts/sks-1-18-gate-lib.js

@@ -41,8 +41,8 @@ export const SOURCE_INTELLIGENCE_FILES = [
     'src/core/source-intelligence/source-intelligence-policy.ts',
     'src/core/source-intelligence/source-intelligence-runner.ts',
     'src/core/source-intelligence/source-intelligence-proof.ts',
-    'src/core/mcp/xai-mcp-detector.ts',
-    'src/core/mcp/xai-search-adapter.ts',
+    'src/core/ultra-search/types.ts',
+    'src/core/ultra-search/runtime.ts',
     'src/core/codex/codex-web-search-adapter.ts'
 ];
 export const AGENT_118_FILES = [

package/dist/scripts/source-intelligence-all-modes-check.js

@@ -6,27 +6,17 @@ import path from 'node:path';
 import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
 const mod = await importDist('core/source-intelligence/source-intelligence-runner.js');
 const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-source-intelligence-'));
-const noXai = await mod.runSourceIntelligence({
-    missionDir: dir,
-    route: '$Team',
-    query: 'fixture',
-    context7: async () => [{ title: 'docs' }],
-    codexWebSearch: async () => [{ title: 'web', url: 'https://example.com' }],
-    xaiDetection: { configured: false, search_capable: false, configured_but_unverified: false, status: 'missing' },
-    env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' }
-});
-const withXai = await mod.runSourceIntelligence({
+const common = {
     missionDir: dir,
     route: '$Research',
-    query: 'fixture',
-    context7: async () => [{ title: 'docs' }],
+    context7: async () => [{ title: 'docs', url: 'https://docs.example.com' }],
     codexWebSearch: async () => [{ title: 'web', url: 'https://example.com' }],
-    xaiSearch: async () => [{ title: 'x', url: 'https://x.ai' }],
-    xaiDetection: { configured: true, search_capable: true, configured_but_unverified: false, status: 'search_capable' },
     env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' }
-});
-assertGate(noXai.ok === true && noXai.mode === 'context7_codex_web', 'no-XAI mode must pass with Context7+Codex Web', noXai);
-assertGate(withXai.ok === true && withXai.mode === 'context7_codex_web_xai', 'XAI mode must pass with all providers', withXai);
-assertGate(withXai.parallel.providers_requested.length === 3, 'providers must run through parallel provider plan', withXai.parallel);
-emitGate('source-intelligence:all-modes', { modes: [noXai.mode, withXai.mode] });
+};
+const balanced = await mod.runSourceIntelligence({ ...common, query: 'fixture' });
+const xSearch = await mod.runSourceIntelligence({ ...common, query: 'site:x.com product launch', xaiDetection: { configured: true, search_capable: true } });
+assertGate(balanced.ok === true && balanced.mode === 'ultra_balanced', 'balanced UltraSearch mode must pass with provider-independent proof', balanced);
+assertGate(xSearch.ok === false && xSearch.mode === 'x_search' && xSearch.blockers.includes('x_search_parity_not_proven'), 'X mode must not treat discovery-only public X evidence as parity', xSearch);
+assertGate(xSearch.parallel.providers_requested.includes('x_public'), 'X public provider must be capability-selected', xSearch.parallel);
+emitGate('source-intelligence:all-modes', { modes: [balanced.mode, xSearch.mode], x_parity_claim: 'not_proven_without_real_corpus' });
 //# sourceMappingURL=source-intelligence-all-modes-check.js.map