sneakoscope 4.2.1 → 4.4.0

package/dist/scripts/source-intelligence-policy-check.js

@@ -3,11 +3,11 @@
 import { assertFiles, assertGate, emitGate, importDist, SOURCE_INTELLIGENCE_FILES } from './sks-1-18-gate-lib.js';
 assertFiles(SOURCE_INTELLIGENCE_FILES);
 const mod = await importDist('core/source-intelligence/source-intelligence-policy.js');
-const base = mod.buildSourceIntelligencePolicy({ context7Available: true, codexWebCapability: { available: true, status: 'available', reason: 'fixture' }, xaiDetection: { configured: false, search_capable: false, configured_but_unverified: false, status: 'missing' } });
-const xai = mod.buildSourceIntelligencePolicy({ context7Available: true, codexWebCapability: { available: true, status: 'available', reason: 'fixture' }, xaiDetection: { configured: true, search_capable: true, configured_but_unverified: false, status: 'search_capable' } });
-const blocked = mod.buildSourceIntelligencePolicy({ context7Available: false });
-assertGate(base.mode === 'context7_codex_web', 'default mode must be context7_codex_web', base);
-assertGate(xai.mode === 'context7_codex_web_xai' && xai.xai_mcp.required === true, 'X AI available mode must require X evidence', xai);
+const base = mod.buildSourceIntelligencePolicy({ query: 'current release notes', context7Available: true, codexWebCapability: { available: true, status: 'available', reason: 'fixture' } });
+const xSearch = mod.buildSourceIntelligencePolicy({ query: 'site:x.com product launch', context7Available: true, codexWebCapability: { available: true, status: 'available', reason: 'fixture' }, xaiDetection: { configured: true, search_capable: true } });
+const blocked = mod.buildSourceIntelligencePolicy({ query: 'npm package docs', context7Available: false });
+assertGate(base.mode === 'ultra_balanced', 'default mode must be ultra_balanced', base);
+assertGate(xSearch.mode === 'x_search' && xSearch.selected_providers.includes('x_public') && !Object.hasOwn(xSearch, ['xai', 'mcp'].join('_')), 'X-search mode must be provider-independent and ignore xAI detection', xSearch);
 assertGate(blocked.mode === 'blocked' && blocked.blockers.includes('docs_context_missing'), 'Context7 missing must block docs context');
-emitGate('source-intelligence:policy', { modes: [base.mode, xai.mode, blocked.mode] });
+emitGate('source-intelligence:policy', { modes: [base.mode, xSearch.mode, blocked.mode] });
 //# sourceMappingURL=source-intelligence-policy-check.js.map

package/dist/scripts/ultra-search-provider-interface-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/ultra-search/index.js');
+const missionDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-ultra-search-'));
+const result = await mod.runUltraSearch({
+    missionDir,
+    query: 'npm package docs',
+    mode: 'balanced',
+    context7: async () => [{ title: 'npm docs', url: 'https://docs.npmjs.com', snippet: 'official docs' }],
+    codexWebSearch: async () => [{ title: 'npm registry', url: 'https://www.npmjs.com/package/npm', snippet: 'registry' }],
+    env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' }
+});
+assertGate(result.proof.provider_independent === true, 'UltraSearch proof must be provider-independent', result.proof);
+assertGate(result.proof.xai_runtime_dependency === false, 'UltraSearch must not require xAI runtime', result.proof);
+assertGate(result.sources.some((source) => source.acquisition_verdict === 'verified_content'), 'UltraSearch must normalize verified source evidence', result.sources);
+assertGate(result.convergence.schema === 'sks.ultra-search-convergence.v1', 'UltraSearch convergence artifact must be typed', result.convergence);
+emitGate('ultra-search:provider-interface', {
+    mode: result.mode,
+    sources: result.sources.length,
+    verified: result.proof.verified_source_count,
+    xai_runtime_dependency: result.proof.xai_runtime_dependency
+});
+//# sourceMappingURL=ultra-search-provider-interface-check.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.2.1",
+  "version": "4.4.0",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -476,12 +476,12 @@
     "qa:native-agent-backend": "node ./dist/scripts/agent-native-release-gate.js qa-native-agent-backend",
     "agent:non-recursive-pipeline-report": "node ./dist/scripts/non-recursive-pipeline-check.js --json",
     "agent:legacy-multiagent-removed": "node ./dist/scripts/legacy-multiagent-removal-check.js",
-    "xai-mcp:capability": "node ./dist/scripts/xai-mcp-capability-check.js",
     "mcp:0.134-modernization": "node ./dist/scripts/mcp-0-134-modernization-check.js",
     "mcp:readonly-concurrency": "node ./dist/scripts/mcp-readonly-concurrency-check.js",
     "mcp:readonly-runtime-scheduler": "node ./dist/scripts/mcp-readonly-runtime-scheduler-check.js",
     "codex:0.134-runner-truth": "node ./dist/scripts/codex-0-134-runner-truth-check.js",
     "source-intelligence:policy": "node ./dist/scripts/source-intelligence-policy-check.js",
+    "ultra-search:provider-interface": "node ./dist/scripts/ultra-search-provider-interface-check.js",
     "context7:evidence-dedupe": "node ./dist/scripts/context7-evidence-dedupe-check.js",
     "source-intelligence:codex-history-search": "node ./dist/scripts/codex-history-search-check.js",
     "source-intelligence:all-modes": "node ./dist/scripts/source-intelligence-all-modes-check.js",

package/dist/core/mcp/xai-mcp-detector.js

@@ -1,157 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { exists, nowIso, readText } from '../fsx.js';
-export const XAI_MCP_DETECTION_SCHEMA = 'sks.xai-mcp-detection.v1';
-const XAI_SERVER_RE = /(?:^|[-_\s.])(xai|x-ai|x_ai|grok|x\.ai)(?:$|[-_\s.])/i;
-const SEARCH_TOOL_RE = /(?:search|query|web|retrieve|retrieval|news|grok)/i;
-export function isXaiServerName(name) {
-    return XAI_SERVER_RE.test(normalizeName(name));
-}
-export function isSearchToolName(name) {
-    return SEARCH_TOOL_RE.test(normalizeName(name));
-}
-export async function detectXaiMcp(opts = {}) {
-    const root = path.resolve(opts.root || process.cwd());
-    const home = opts.home || os.homedir();
-    const configPaths = [
-        { path: path.join(home, '.codex', 'config.toml'), source: 'user' },
-        { path: path.join(root, '.codex', 'config.toml'), source: 'project' },
-        { path: path.join(root, '.codex', 'config.json'), source: 'project' }
-    ];
-    const provided = opts.configSources || [];
-    const discovered = [...provided];
-    for (const entry of configPaths) {
-        if (provided.some((source) => path.resolve(source.path) === path.resolve(entry.path)))
-            continue;
-        if (await exists(entry.path)) {
-            discovered.push({ path: entry.path, source: entry.source, text: String(await readText(entry.path, '')) });
-        }
-    }
-    return detectXaiMcpFromConfig(discovered, {
-        checked: configPaths.map((entry) => entry.path),
-        toolLists: opts.toolLists || {}
-    });
-}
-export function detectXaiMcpFromConfig(sources = [], opts = {}) {
-    try {
-        const servers = sources.flatMap((source) => detectServersInSource(source, opts.toolLists || {}));
-        const configured = servers.length > 0;
-        const searchCapable = servers.some((server) => server.search_capable);
-        const configuredButUnverified = configured && !searchCapable && servers.some((server) => server.configured_but_unverified);
-        const status = !configured
-            ? 'missing'
-            : searchCapable
-                ? 'search_capable'
-                : configuredButUnverified
-                    ? 'configured_but_unverified'
-                    : 'configured_no_search';
-        return {
-            schema: XAI_MCP_DETECTION_SCHEMA,
-            generated_at: nowIso(),
-            ok: true,
-            status,
-            configured,
-            search_capable: searchCapable,
-            configured_but_unverified: configuredButUnverified,
-            servers,
-            config_paths_checked: [...new Set([...(opts.checked || []), ...sources.map((source) => source.path)])],
-            config_paths_found: sources.map((source) => source.path),
-            blockers: [],
-            warnings: configuredButUnverified ? ['xai_mcp_configured_but_tool_list_unverified'] : []
-        };
-    }
-    catch (err) {
-        return {
-            schema: XAI_MCP_DETECTION_SCHEMA,
-            generated_at: nowIso(),
-            ok: false,
-            status: 'error',
-            configured: false,
-            search_capable: false,
-            configured_but_unverified: false,
-            servers: [],
-            config_paths_checked: opts.checked || [],
-            config_paths_found: sources.map((source) => source.path),
-            blockers: [`xai_mcp_detection_error:${err instanceof Error ? err.message : String(err)}`],
-            warnings: []
-        };
-    }
-}
-function detectServersInSource(source, toolLists) {
-    const jsonServers = parseJsonServers(source);
-    const tomlServers = jsonServers.length ? [] : parseTomlServerNames(source.text);
-    const names = [...jsonServers, ...tomlServers].filter((server) => isXaiServerName(server.name));
-    return names.map((server) => {
-        const configuredTools = [...server.tools, ...(toolLists[server.name] || []), ...(toolLists[normalizeName(server.name)] || [])];
-        const uniqueTools = [...new Set(configuredTools.map(String).filter(Boolean))];
-        const searchCapable = uniqueTools.some(isSearchToolName);
-        return {
-            name: normalizeName(server.name),
-            source: `${source.source}:${source.path}`,
-            configured: true,
-            search_capable: searchCapable,
-            configured_but_unverified: !searchCapable && uniqueTools.length === 0,
-            tools: uniqueTools,
-            raw_name: server.name
-        };
-    });
-}
-function parseJsonServers(source) {
-    const text = source.text.trim();
-    if (!text.startsWith('{'))
-        return [];
-    try {
-        const parsed = JSON.parse(text);
-        const servers = parsed?.mcp_servers || parsed?.mcpServers || {};
-        return Object.entries(servers).map(([name, value]) => ({
-            name,
-            tools: extractToolNames(value)
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-function parseTomlServerNames(text) {
-    const rows = [];
-    const tableRe = /^\s*\[(?:mcp_servers|mcpServers)\.([^\]]+)\]\s*$/gm;
-    let match;
-    while ((match = tableRe.exec(text)) !== null) {
-        const name = unquote(match[1] || '');
-        const bodyStart = match.index + match[0].length;
-        const nextTable = text.slice(bodyStart).search(/^\s*\[/m);
-        const body = nextTable >= 0 ? text.slice(bodyStart, bodyStart + nextTable) : text.slice(bodyStart);
-        rows.push({ name, tools: extractToolNamesFromText(body) });
-    }
-    return rows;
-}
-function extractToolNames(value) {
-    if (!value || typeof value !== 'object')
-        return [];
-    const possible = [
-        value.tools,
-        value.tool_names,
-        value.capabilities,
-        value.search_tools
-    ];
-    return possible.flatMap((entry) => Array.isArray(entry) ? entry.map(String) : []);
-}
-function extractToolNamesFromText(text) {
-    const tools = [];
-    const arrayRe = /(?:tools|tool_names|capabilities|search_tools)\s*=\s*\[([^\]]*)\]/g;
-    let match;
-    while ((match = arrayRe.exec(text)) !== null) {
-        tools.push(...String(match[1] || '').split(',').map((part) => unquote(part.trim())).filter(Boolean));
-    }
-    const keyRe = /^\s*(search|query|web|retrieve|news|grok)\s*=/gmi;
-    while ((match = keyRe.exec(text)) !== null)
-        tools.push(match[1] || '');
-    return tools;
-}
-function normalizeName(name) {
-    return String(name || '').trim().replace(/^["']|["']$/g, '').toLowerCase();
-}
-function unquote(value) {
-    return String(value || '').trim().replace(/^["']|["']$/g, '');
-}
-//# sourceMappingURL=xai-mcp-detector.js.map

package/dist/core/mcp/xai-search-adapter.js

@@ -1,100 +0,0 @@
-import path from 'node:path';
-import { ensureDir, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
-export const XAI_SEARCH_EVIDENCE_SCHEMA = 'sks.xai-search-evidence.v1';
-export async function runXaiSearch(query, opts = {}) {
-    const timeoutMs = opts.timeoutMs || 10_000;
-    if (opts.configured === false)
-        return blockedEvidence(query, timeoutMs, 'not_configured', ['xai_mcp_missing']);
-    if (!opts.search)
-        return blockedEvidence(query, timeoutMs, 'blocked', ['xai_search_adapter_missing']);
-    try {
-        const raw = await withTimeout(opts.search(query), timeoutMs);
-        const results = normalizeXaiSearchResults(raw);
-        let rawArtifact = null;
-        if (opts.artifactDir) {
-            await ensureDir(opts.artifactDir);
-            rawArtifact = path.join(opts.artifactDir, `xai-search-raw-${sha256(JSON.stringify({ query, raw })).slice(0, 12)}.json`);
-            await writeJsonAtomic(rawArtifact, { schema: 'sks.xai-search-raw-local-only.v1', generated_at: nowIso(), local_only: true, query, raw });
-        }
-        return {
-            schema: XAI_SEARCH_EVIDENCE_SCHEMA,
-            generated_at: nowIso(),
-            ok: true,
-            query,
-            status: 'completed',
-            timeout_ms: timeoutMs,
-            results: results.map((record) => ({ ...record, local_only_raw_artifact: rawArtifact })),
-            raw_response_artifact: rawArtifact,
-            redacted_summary: {
-                result_count: results.length,
-                urls: results.map((record) => record.url)
-            },
-            blockers: []
-        };
-    }
-    catch (err) {
-        const timeout = err instanceof Error && err.message === 'xai_search_timeout';
-        return blockedEvidence(query, timeoutMs, timeout ? 'timeout' : 'blocked', [
-            timeout ? 'xai_search_timeout' : `xai_search_failure:${err instanceof Error ? err.message : String(err)}`
-        ]);
-    }
-}
-export function normalizeXaiSearchResults(raw) {
-    const rows = Array.isArray(raw)
-        ? raw
-        : Array.isArray(raw?.results)
-            ? raw.results
-            : Array.isArray(raw?.data)
-                ? raw.data
-                : [];
-    return rows.map((row, index) => ({
-        provider: 'xai',
-        id: String(row.id || row.url || row.link || `xai-${index + 1}`),
-        title: String(row.title || row.name || row.heading || `X AI result ${index + 1}`),
-        url: row.url || row.link || null,
-        snippet: String(row.snippet || row.summary || row.text || ''),
-        published_at: row.published_at || row.publishedAt || row.date || null,
-        local_only_raw_artifact: null
-    }));
-}
-export function redactXaiRawResponse(raw) {
-    const results = normalizeXaiSearchResults(raw);
-    return {
-        provider: 'xai',
-        result_count: results.length,
-        results: results.map((result) => ({
-            title: result.title,
-            url: result.url,
-            snippet: result.snippet.slice(0, 240),
-            published_at: result.published_at
-        }))
-    };
-}
-function blockedEvidence(query, timeoutMs, status, blockers) {
-    return {
-        schema: XAI_SEARCH_EVIDENCE_SCHEMA,
-        generated_at: nowIso(),
-        ok: false,
-        query,
-        status,
-        timeout_ms: timeoutMs,
-        results: [],
-        raw_response_artifact: null,
-        redacted_summary: { result_count: 0, urls: [] },
-        blockers
-    };
-}
-function withTimeout(promise, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error('xai_search_timeout')), timeoutMs);
-        timer.unref?.();
-        promise.then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        }, (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-//# sourceMappingURL=xai-search-adapter.js.map

package/dist/scripts/xai-mcp-capability-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const detector = await importDist('core/mcp/xai-mcp-detector.js');
-const detection = detector.detectXaiMcpFromConfig([
-    { path: 'fixture.toml', source: 'provided', text: '[mcp_servers.grok]\ntools = ["search", "query"]\n' }
-]);
-assertGate(detection.ok === true, 'X AI detector must not fail');
-assertGate(detection.configured === true, 'X AI detector must detect configured Grok MCP');
-assertGate(detection.search_capable === true, 'X AI detector must detect search-capable tools');
-const missing = detector.detectXaiMcpFromConfig([]);
-assertGate(missing.ok === true && missing.status === 'missing', 'missing X AI MCP must be ok fallback');
-emitGate('xai-mcp:capability', { configured_status: detection.status, missing_status: missing.status });
-//# sourceMappingURL=xai-mcp-capability-check.js.map