sneakoscope 4.2.0 → 4.3.0

package/dist/scripts/seo-geo-skill-rich-content-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-seo-geo-skills-'));
+const init = await importDist('core/init.js');
+await init.installSkills(root);
+for (const name of ['search-visibility-core', 'seo-geo-optimizer']) {
+    const file = path.join(root, '.agents', 'skills', name, 'SKILL.md');
+    assertGate(fs.existsSync(file), `generated skill missing: ${name}`);
+    const text = fs.readFileSync(file, 'utf8');
+    assertGate(/^---\nname:/m.test(text) && /description:/.test(text), `skill frontmatter missing: ${name}`, text);
+    for (const token of ['Purpose:', 'Use when', 'Workflow:', 'Safety:', 'Evidence/artifacts:', 'Failure/recovery:']) {
+        assertGate(text.includes(token), `skill missing rich token ${token}: ${name}`, text);
+    }
+    assertGate(/CLI entrypoint:/i.test(text), `skill missing CLI entrypoint: ${name}`, text);
+    assertGate(/ranking|citation|traffic|guarantee|보장/i.test(text), `skill must name forbidden guarantee boundary: ${name}`, text);
+}
+emitGate('seo-geo:skill-rich-content', { skills_checked: 2 });
+//# sourceMappingURL=seo-geo-skill-rich-content-check.js.map

package/dist/scripts/seo-mutation-rollback-check.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, assertMissionArtifact, emitGate, makeSearchVisibilityFixture, runSksJson } from './search-visibility-gate-lib.js';
+const fixture = makeSearchVisibilityFixture('seo-rollback');
+const audit = runSksJson(['seo-geo-optimizer', 'audit', '--mode', 'seo', '--root', fixture, '--target', 'website', '--framework', 'static', '--url', 'https://example.test', '--offline', '--json']).json;
+const plan = runSksJson(['seo-geo-optimizer', 'plan', audit.mission_id, '--mode', 'seo', '--root', fixture, '--json']).json;
+assertGate(plan.operations >= 2, 'SEO rollback fixture should plan robots and sitemap creation', plan);
+const apply = runSksJson(['seo-geo-optimizer', 'apply', audit.mission_id, '--mode', 'seo', '--root', fixture, '--apply', '--json']).json;
+assertGate(apply.ok === true && apply.applied >= 2, 'SEO apply must create planned managed files', apply);
+assertGate(fs.existsSync(path.join(fixture, 'public', 'robots.txt')) && fs.existsSync(path.join(fixture, 'public', 'sitemap.xml')), 'managed robots and sitemap must exist after apply');
+const second = runSksJson(['seo-geo-optimizer', 'apply', audit.mission_id, '--mode', 'seo', '--root', fixture, '--apply', '--json']).json;
+assertGate(second.ok === true, 'second apply must be idempotent', second);
+const journal = fs.readFileSync(path.join(fixture, '.sneakoscope', 'missions', audit.mission_id, 'search-visibility', 'mutation-journal.jsonl'), 'utf8');
+assertGate(/applied/.test(journal), 'mutation journal must record applied/idempotent events', journal);
+const rollbackManifest = assertMissionArtifact(audit.mission_id, 'rollback-manifest.json', fixture);
+assertGate(rollbackManifest.operations.length >= 2, 'rollback manifest must preserve inverse operations after idempotent apply', rollbackManifest);
+const rollback = runSksJson(['seo-geo-optimizer', 'rollback', audit.mission_id, '--mode', 'seo', '--root', fixture, '--apply', '--json']).json;
+assertGate(rollback.ok === true && rollback.rolled_back >= 2, 'rollback must reverse mission-owned operations', rollback);
+assertGate(!fs.existsSync(path.join(fixture, 'public', 'robots.txt')) && !fs.existsSync(path.join(fixture, 'public', 'sitemap.xml')), 'rollback must remove mission-created files');
+emitGate('seo:mutation-rollback', { mission_id: audit.mission_id, applied: apply.applied, rolled_back: rollback.rolled_back });
+//# sourceMappingURL=seo-mutation-rollback-check.js.map

package/dist/scripts/seo-no-mutation-by-default-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, listSourceFiles, makeSearchVisibilityFixture, runSksJson } from './search-visibility-gate-lib.js';
+const fixture = makeSearchVisibilityFixture('seo-readonly');
+const before = listSourceFiles(fixture);
+const audit = runSksJson(['seo-geo-optimizer', 'audit', '--mode', 'seo', '--root', fixture, '--target', 'website', '--framework', 'static', '--url', 'https://example.test', '--offline', '--json']).json;
+const plan = runSksJson(['seo-geo-optimizer', 'plan', audit.mission_id, '--mode', 'seo', '--root', fixture, '--json']).json;
+const blockedApply = runSksJson(['seo-geo-optimizer', 'apply', audit.mission_id, '--mode', 'seo', '--root', fixture, '--json'], { allowFailure: true }).json;
+const after = listSourceFiles(fixture);
+assertGate(JSON.stringify(before) === JSON.stringify(after), 'audit/plan/apply-without-flag must not mutate project source files', { before, after });
+assertGate(plan.operations > 0, 'readonly fixture should still compile a mutation plan', plan);
+assertGate(blockedApply.ok === false && blockedApply.blockers.includes('apply_requires_explicit_--apply'), 'apply must require explicit --apply', blockedApply);
+assertGate(!fs.existsSync(path.join(fixture, 'public', 'robots.txt')) && !fs.existsSync(path.join(fixture, 'public', 'sitemap.xml')), 'policy files must not be created without --apply');
+emitGate('seo:no-mutation-by-default', { mission_id: audit.mission_id, planned_operations: plan.operations });
+//# sourceMappingURL=seo-no-mutation-by-default-check.js.map

package/dist/scripts/seo-structured-data-visible-content-check.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, assertMissionArtifact, emitGate, makeSearchVisibilityFixture, runSksJson } from './search-visibility-gate-lib.js';
+const html = [
+    '<!doctype html>',
+    '<html lang="en"><head><title>Structured Data Fixture</title>',
+    '<script type="application/ld+json">{"@context":"https://schema.org","@type":"Product","aggregateRating":{"ratingValue":5,}}</script>',
+    '</head><body><h1>Structured Data Fixture</h1><p>Visible source content only.</p></body></html>',
+    '',
+].join('\n');
+const fixture = makeSearchVisibilityFixture('seo-structured', { html });
+const audit = runSksJson(['seo-geo-optimizer', 'audit', '--mode', 'seo', '--root', fixture, '--target', 'website', '--framework', 'static', '--url', 'https://example.test', '--offline', '--json']).json;
+const ledger = assertMissionArtifact(audit.mission_id, 'structured-data-ledger.json', fixture);
+const findings = assertMissionArtifact(audit.mission_id, 'seo-findings.json', fixture);
+assertGate(ledger.policies.some((url) => /structured-data/.test(url)), 'structured data ledger must cite structured-data policy sources', ledger);
+assertGate(ledger.pages.some((page) => page.parse_errors.length > 0), 'invalid JSON-LD must be recorded as parse error', ledger);
+assertGate(findings.findings.some((finding) => finding.ruleId.includes('jsonld-parse') && finding.evidence.length > 0), 'invalid JSON-LD finding must carry evidence', findings);
+emitGate('seo:structured-data-visible-content', { mission_id: audit.mission_id });
+//# sourceMappingURL=seo-structured-data-visible-content-check.js.map

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/sks-3-1-5-directive-check-lib.js

@@ -251,7 +251,16 @@ async function richContentGate(id) {
         const report = await mod.syncCodexSksSkills({ root: rootDir, skillsRoot, apply: true });
         const skill = fs.readFileSync(path.join(skillsRoot, 'loop', 'SKILL.md'), 'utf8');
         assertGate(/Purpose:|Evidence:|Fallback:/.test(skill), 'managed skill must include rich route content', { skill, report });
-        return emitGate(id, { skills: report.created.length });
+        for (const name of ['search-visibility-core', 'seo-geo-optimizer']) {
+            const file = path.join(skillsRoot, name, 'SKILL.md');
+            assertGate(fs.existsSync(file), `managed skill missing: ${name}`, { report });
+            const text = fs.readFileSync(file, 'utf8');
+            assertGate(/Purpose:|Use when:|Workflow:|Safety:|Evidence\/artifacts:|Failure\/recovery:|CLI entrypoint:/i.test(text), `managed skill lacks rich content: ${name}`, { text });
+            assertGate(/ranking|citation|traffic|guarantee|보장/i.test(text), `managed skill must name forbidden guarantee boundary: ${name}`, { text });
+            if (name === 'seo-geo-optimizer')
+                assertGate(text.includes('sks seo-geo-optimizer doctor|audit|plan|apply|verify|status|rollback|fixture') && /not geolocation|GeoIP/i.test(text), 'seo-geo-optimizer skill must expose CLI entrypoint and geolocation disambiguation', { text });
+        }
+        return emitGate(id, { skills: report.created.length, search_visibility_skills_checked: 2 });
     }
     const previous = swapEnv({ SKS_CODEX_AGENT_TYPE_FIXTURE: 'supported' });
     try {

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

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/triwiki-affected-graph-check.js

@@ -1,10 +1,10 @@
 // @ts-nocheck
 import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
 const mod = await importDist('core/triwiki/triwiki-affected-graph.js');
-const graph = mod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/core/triwiki/triwiki-proof-bank.ts'], tier: 'affected' });
+const graph = mod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/core/triwiki/triwiki-proof-bank.ts'], tier: 'affected', includeProofLookup: false });
 assertGate(graph.schema === 'sks.triwiki-affected-graph.v1', 'affected graph schema mismatch', graph);
 assertGate(graph.affected_modules.includes('triwiki') && graph.gate_packs.includes('triwiki') && graph.release_equivalent_within_scope === true, 'triwiki file must select triwiki release-equivalent pack', graph);
-const full = mod.computeTriWikiAffectedGraph({ root, full: true, tier: 'release' });
+const full = mod.computeTriWikiAffectedGraph({ root, full: true, tier: 'release', includeProofLookup: false });
 assertGate(full.gates.length > graph.gates.length && full.gate_packs.length >= graph.gate_packs.length && full.conservative_reason === 'full_release_requested', 'full release graph must select the full gate surface', full);
 emitGate('triwiki:affected-graph', { gates: graph.gates.length, packs: graph.gate_packs, full_gates: full.gates.length });
 //# sourceMappingURL=triwiki-affected-graph-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.0",
+  "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",
@@ -323,6 +338,7 @@
     "codex-control:side-effect-scope": "node ./dist/scripts/codex-control-side-effect-scope-check.js",
     "codex-control:all-pipelines": "node ./dist/scripts/codex-control-all-pipelines-check.js",
     "codex-control:empty-result-retry": "node ./dist/scripts/codex-control-empty-result-retry-check.js",
+    "codex-control:model-capacity-fallback": "node ./dist/scripts/codex-control-model-capacity-fallback-check.js",
     "codex-control:stream-idle-watchdog": "node ./dist/scripts/codex-control-stream-idle-watchdog-check.js",
     "codex-control:tool-call-sequence-repair": "node ./dist/scripts/codex-control-tool-call-sequence-repair-check.js",
     "codex-control:keepalive-no-cot-leak": "node ./dist/scripts/codex-control-keepalive-no-cot-leak-check.js",
@@ -359,9 +375,10 @@
     "coverage": "node --experimental-test-coverage --test \"test/**/*.test.mjs\"",
     "release:check": "npm run release:check:affected",
     "release:real-check": "node ./dist/scripts/release-real-check.js",
-    "release:publish": "npm run publish:npm",
+    "release:publish": "npm run publish:ignore-scripts",
     "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run release:check:full && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && node ./dist/scripts/release-registry-check.js --require-unpublished && npm --cache /tmp/sks-npm-cache publish --dry-run --ignore-scripts --registry https://registry.npmjs.org/ --access public",
-    "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
+    "publish:ignore-scripts": "npm run prepublishOnly && npm --cache /tmp/sks-npm-cache publish --ignore-scripts --registry https://registry.npmjs.org/ --access public",
+    "publish:npm": "npm run publish:ignore-scripts",
     "publish:fast": "node -e \"console.error('publish:fast is quarantined; use publish:dry and publish:npm with the release gates.'); process.exit(1)\"",
     "prepack": "npm run build",
     "prepublishOnly": "npm run release:metadata && npm run release:version-truth && npm run release:dist-freshness && npm run publish:packlist-performance && node ./dist/scripts/prepublish-release-check-or-fast.js && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && node ./dist/scripts/release-registry-check.js --require-unpublished --require-publish-auth",
@@ -474,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",
@@ -619,6 +636,7 @@
     "qa-loop:effort-escalation": "node ./dist/scripts/qa-loop-effort-escalation-check.js",
     "codex:account-usage": "node ./dist/scripts/codex-account-usage-check.js",
     "qa-loop:budget-policy": "node ./dist/scripts/qa-loop-budget-policy-check.js",
+    "qa-loop:surface-router": "node ./dist/scripts/qa-loop-surface-router-check.js",
     "naruto:parallel-gate-consistency": "node ./dist/scripts/naruto-parallel-gate-consistency-check.js",
     "codex:0138-doctor": "node ./dist/scripts/codex-0138-doctor-check.js",
     "doctor:codex-0138-fix": "node ./dist/scripts/doctor-codex-0138-fix-check.js",
@@ -1079,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