sneakoscope 4.2.1 → 4.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.2.1",
+  "version": "4.3.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",
@@ -19,7 +19,7 @@
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/",
-    "tag": "latest"
+    "tag": "backfill-4-3"
   },
   "files": [
     "dist",
@@ -68,6 +68,21 @@
     "typescript:migration-report": "node ./dist/scripts/typescript-migration-report.js",
     "typecheck:contracts": "node ./dist/scripts/check-ts-contracts.js",
     "schema:check": "node ./dist/scripts/check-runtime-schemas.js",
+    "seo:cli-blackbox": "node ./dist/scripts/seo-cli-blackbox-check.js",
+    "seo:audit-fixture": "node ./dist/scripts/seo-audit-fixture-check.js",
+    "seo:no-mutation-by-default": "node ./dist/scripts/seo-no-mutation-by-default-check.js",
+    "seo:mutation-rollback": "node ./dist/scripts/seo-mutation-rollback-check.js",
+    "seo:canonical-sitemap-locale": "node ./dist/scripts/seo-canonical-locale-check.js",
+    "seo:structured-data-visible-content": "node ./dist/scripts/seo-structured-data-visible-content-check.js",
+    "geo:cli-blackbox": "node ./dist/scripts/geo-cli-blackbox-check.js",
+    "geo:claim-evidence": "node ./dist/scripts/geo-claim-evidence-check.js",
+    "geo:crawler-purpose-policy": "node ./dist/scripts/geo-crawler-policy-check.js",
+    "geo:llms-txt-optional": "node ./dist/scripts/geo-llms-txt-optional-check.js",
+    "seo-geo:route-identity": "node ./dist/scripts/seo-geo-route-identity-check.js",
+    "seo-geo:geo-disambiguation": "node ./dist/scripts/seo-geo-geo-disambiguation-check.js",
+    "seo-geo:skill-rich-content": "node ./dist/scripts/seo-geo-skill-rich-content-check.js",
+    "seo-geo:no-unsupported-ranking-claims": "node ./dist/scripts/seo-geo-no-unsupported-ranking-claims-check.js",
+    "seo-geo:feature-fixture-quality": "node ./dist/scripts/seo-geo-feature-fixture-quality-check.js",
     "package-boundary:check": "node ./dist/scripts/check-package-boundary.js",
     "blackbox:command-import-smoke": "node ./dist/scripts/blackbox-command-import-smoke.js",
     "repo-audit": "node ./dist/scripts/repo-audit.js",
@@ -476,12 +491,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",
@@ -1082,6 +1097,9 @@
     "goal",
     "research",
     "autoresearch",
+    "seo",
+    "search-visibility",
+    "generative-engine-optimization",
     "honest-mode",
     "update-check",
     "llm-wiki",

package/schemas/search-visibility/finding-ledger.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/search-visibility/finding-ledger.schema.json",
+  "title": "SKS Search Visibility Finding Ledger",
+  "type": "object",
+  "required": ["schema", "mission_id", "route", "findings", "counts"],
+  "properties": {
+    "schema": { "enum": ["sks.search-visibility.seo-findings.v1", "sks.search-visibility.geo-findings.v1"] },
+    "mission_id": { "type": "string" },
+    "route": { "const": "$SEO-GEO-OPTIMIZER" },
+    "findings": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "ruleId", "domain", "category", "severity", "confidence", "blocking", "summary", "evidence", "affected", "remediation", "autoFixable"],
+        "properties": {
+          "id": { "type": "string" },
+          "ruleId": { "type": "string" },
+          "domain": { "enum": ["seo", "geo", "shared"] },
+          "category": { "type": "string" },
+          "severity": { "enum": ["info", "low", "medium", "high", "critical"] },
+          "confidence": { "type": "number" },
+          "blocking": { "type": "boolean" },
+          "summary": { "type": "string" },
+          "evidence": { "type": "array", "minItems": 1 },
+          "affected": { "type": "array" },
+          "remediation": { "type": "string" },
+          "autoFixable": { "type": "boolean" }
+        },
+        "additionalProperties": true
+      }
+    },
+    "counts": { "type": "object" }
+  },
+  "additionalProperties": true
+}

package/schemas/search-visibility/gate.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/search-visibility/gate.schema.json",
+  "title": "SKS Search Visibility Gate",
+  "type": "object",
+  "required": ["schema", "mission_id", "route", "ok", "passed", "status", "command_identity", "required_artifacts", "unsupported_claims", "blockers", "unverified", "completion_proof"],
+  "properties": {
+    "schema": { "const": "sks.search-visibility.gate.v1" },
+    "mission_id": { "type": "string" },
+    "route": { "const": "$SEO-GEO-OPTIMIZER" },
+    "ok": { "type": "boolean" },
+    "passed": { "type": "boolean" },
+    "status": { "enum": ["verified_partial", "blocked", "locally_verified", "production_verified"] },
+    "command_identity": { "type": "boolean" },
+    "required_artifacts": { "type": "array" },
+    "unsupported_claims": { "type": "array" },
+    "blockers": { "type": "array" },
+    "unverified": { "type": "array" },
+    "completion_proof": { "type": "string" }
+  },
+  "additionalProperties": true
+}

package/schemas/search-visibility/mutation-plan.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/search-visibility/mutation-plan.schema.json",
+  "title": "SKS Search Visibility Mutation Plan",
+  "type": "object",
+  "required": ["schema", "mission_id", "route", "mode", "adapter", "detection_confidence", "status", "operations", "blockers", "unverified"],
+  "properties": {
+    "schema": { "const": "sks.search-visibility.mutation-plan.v1" },
+    "mission_id": { "type": "string" },
+    "route": { "const": "$SEO-GEO-OPTIMIZER" },
+    "mode": { "enum": ["seo", "geo"] },
+    "adapter": { "type": "string" },
+    "detection_confidence": { "type": "number" },
+    "status": { "enum": ["planned", "blocked"] },
+    "operations": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "path", "baseSha256", "proposedSha256", "kind", "owner", "findingIds", "reversible", "preview", "risk", "requiredVerification", "scopeAuthorization", "ownershipStrategy"],
+        "additionalProperties": true
+      }
+    },
+    "blockers": { "type": "array" },
+    "unverified": { "type": "array" }
+  },
+  "additionalProperties": true
+}

package/schemas/search-visibility/site-inventory.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/search-visibility/site-inventory.schema.json",
+  "title": "SKS Search Visibility Site Inventory",
+  "type": "object",
+  "required": ["schema", "mission_id", "route", "root", "target", "detected_adapter", "package", "routes", "policy_files"],
+  "properties": {
+    "schema": { "const": "sks.search-visibility.site-inventory.v1" },
+    "mission_id": { "type": "string" },
+    "route": { "const": "$SEO-GEO-OPTIMIZER" },
+    "root": { "type": "string" },
+    "target": { "enum": ["website", "docs", "package"] },
+    "detected_adapter": { "type": "object" },
+    "package": { "type": "object" },
+    "routes": { "type": "array" },
+    "policy_files": { "type": "array" },
+    "blockers": { "type": "array" },
+    "unverified": { "type": "array" }
+  },
+  "additionalProperties": true
+}

package/schemas/search-visibility/verification-report.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/search-visibility/verification-report.schema.json",
+  "title": "SKS Search Visibility Verification Report",
+  "type": "object",
+  "required": ["schema", "mission_id", "route", "status", "source_verified", "build_verified", "http_verified", "browser_verified", "production_verified", "measured_outcome", "checked_artifacts", "blockers", "unverified"],
+  "properties": {
+    "schema": { "const": "sks.search-visibility.verification-report.v1" },
+    "mission_id": { "type": "string" },
+    "route": { "const": "$SEO-GEO-OPTIMIZER" },
+    "status": { "enum": ["verified_partial", "blocked", "locally_verified", "production_verified", "measured_outcome_pending", "measured_outcome_recorded"] },
+    "source_verified": { "type": "boolean" },
+    "build_verified": { "type": "boolean" },
+    "http_verified": { "type": "boolean" },
+    "browser_verified": { "type": "boolean" },
+    "production_verified": { "type": "boolean" },
+    "measured_outcome": { "enum": ["pending", "recorded", "not_applicable"] },
+    "checked_artifacts": { "type": "array" },
+    "blockers": { "type": "array" },
+    "unverified": { "type": "array" }
+  },
+  "additionalProperties": true
+}

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