sneakoscope 4.4.0 → 4.6.1

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

@@ -0,0 +1,199 @@
+import path from 'node:path';
+import { adapterForDetection } from './adapter-registry.js';
+import { auditGeo, auditSeo } from './analyzers.js';
+import { detectProject, discoverSiteInventory } from './discovery.js';
+import { applyMutationPlan, buildMutationPlan, rollbackMutationPlan } from './mutation.js';
+import { createSearchVisibilityMission, resolveSearchVisibilityMission, routeForMode } from './mission.js';
+import { finalizeSearchVisibility, statusForMission, writeAuditArtifacts, writeGate } from './artifacts.js';
+import { verifySearchVisibility } from './verifier.js';
+import { projectRoot, readJson, writeJsonAtomic } from '../fsx.js';
+export * from './types.js';
+export { createSearchVisibilityMission, resolveSearchVisibilityMission } from './mission.js';
+export async function runSearchVisibilityAudit(mode, options) {
+    const root = await projectRoot(options.root);
+    const ctx = context(mode, root, options);
+    const mission = await createSearchVisibilityMission(mode, `${mode} audit`, options);
+    const detected = await detectProject(ctx);
+    const adapter = adapterForDetection(detected);
+    const inventory = await adapter.discover(ctx, detected);
+    if (mode === 'geo') {
+        const geo = await auditGeo(root, inventory);
+        const result = await writeAuditArtifacts(ctx, mission, inventory, geo.findings, {
+            entityFacts: geo.entityFacts,
+            claims: geo.claims,
+            crawlers: geo.crawlers,
+            answerability: geo.answerability,
+        });
+        return {
+            schema: 'sks.search-visibility.audit-command.v1',
+            ok: result.gate.ok,
+            mission_id: mission.id,
+            route: routeForMode(mode),
+            status: result.gate.status,
+            artifacts_dir: `.sneakoscope/missions/${mission.id}/search-visibility`,
+            findings: geo.findings.length,
+            gate: result.gate,
+            proof: `.sneakoscope/missions/${mission.id}/completion-proof.json`,
+        };
+    }
+    const findings = await auditSeo(root, inventory);
+    const result = await writeAuditArtifacts(ctx, mission, inventory, findings, null);
+    return {
+        schema: 'sks.search-visibility.audit-command.v1',
+        ok: result.gate.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: result.gate.status,
+        artifacts_dir: `.sneakoscope/missions/${mission.id}/search-visibility`,
+        findings: findings.length,
+        gate: result.gate,
+        proof: `.sneakoscope/missions/${mission.id}/completion-proof.json`,
+    };
+}
+export async function runSearchVisibilityPlan(mode, missionRef, options) {
+    const mission = await resolveOrAudit(mode, missionRef, options);
+    const ctx = context(mode, mission.root, options);
+    const inventory = await readJson(path.join(mission.artifactDir, 'site-inventory.json'));
+    const findingsArtifact = await readJson(path.join(mission.artifactDir, mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json'), {});
+    const findings = Array.isArray(findingsArtifact.findings) ? findingsArtifact.findings : [];
+    const entityFacts = mode === 'geo'
+        ? await readJson(path.join(mission.artifactDir, 'entity-facts.json'), null)
+        : null;
+    const plan = await buildMutationPlan(mode, mission.id, mission.artifactDir, inventory, findings, options, entityFacts);
+    return {
+        schema: 'sks.search-visibility.plan-command.v1',
+        ok: plan.status !== 'blocked',
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: plan.status,
+        operations: plan.operations.length,
+        blockers: plan.blockers,
+        mutation_plan: `search-visibility/mutation-plan.json`,
+    };
+}
+export async function runSearchVisibilityApply(mode, missionRef, options) {
+    const mission = await resolveOrAudit(mode, missionRef, options);
+    const planPath = path.join(mission.artifactDir, 'mutation-plan.json');
+    let plan = await readJson(planPath, null);
+    if (!plan) {
+        const planned = await runSearchVisibilityPlan(mode, mission.id, options);
+        plan = await readJson(planPath, null);
+        if (!planned.ok && !plan)
+            return { schema: 'sks.search-visibility.apply-command.v1', ok: false, mission_id: mission.id, route: routeForMode(mode), status: 'blocked', blockers: ['mutation_plan_missing'] };
+    }
+    const applied = await applyMutationPlan(mission.root, mission.id, mission.artifactDir, plan, options);
+    const verify = await runSearchVisibilityVerify(mode, mission.id, options);
+    return {
+        schema: 'sks.search-visibility.apply-command.v1',
+        ok: applied.ok && verify.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: applied.status,
+        applied: applied.applied,
+        blockers: [...applied.blockers, ...(verify.blockers || [])],
+        rollback_manifest: 'search-visibility/rollback-manifest.json',
+        verification: verify,
+    };
+}
+export async function runSearchVisibilityVerify(mode, missionRef, options) {
+    const mission = await resolveOrAudit(mode, missionRef, options);
+    const root = mission.root;
+    const ctx = context(mode, root, options);
+    const inventory = await readJson(path.join(mission.artifactDir, 'site-inventory.json'));
+    const verification = await verifySearchVisibility(ctx, inventory, mission);
+    await writeJsonAtomic(path.join(mission.artifactDir, 'verification-report.json'), verification);
+    const findingsArtifact = await readJson(path.join(mission.artifactDir, mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json'), {});
+    const findings = Array.isArray(findingsArtifact.findings) ? findingsArtifact.findings : [];
+    const gate = await writeGate(ctx, mission, findings, verification, mode === 'geo');
+    await finalizeSearchVisibility(ctx, mission, gate, `sks ${mode} verify ${mission.id} --json`);
+    return {
+        schema: 'sks.search-visibility.verify-command.v1',
+        ok: gate.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: gate.status,
+        blockers: gate.blockers,
+        unverified: gate.unverified,
+        gate,
+    };
+}
+export async function runSearchVisibilityStatus(mode, missionRef, options) {
+    const mission = await resolveSearchVisibilityMission(options.root, missionRef);
+    if (!mission)
+        return { schema: 'sks.search-visibility.status-command.v1', ok: false, status: 'missing_mission', route: routeForMode(mode) };
+    return statusForMission(mission);
+}
+export async function runSearchVisibilityRollback(mode, missionRef, options) {
+    const mission = await resolveSearchVisibilityMission(options.root, missionRef);
+    if (!mission)
+        return { schema: 'sks.search-visibility.rollback-command.v1', ok: false, status: 'missing_mission', route: routeForMode(mode) };
+    const result = await rollbackMutationPlan(mission.root, mission.artifactDir, options.apply);
+    const verify = result.status === 'rolled_back' ? await runSearchVisibilityVerify(mode, mission.id, options) : null;
+    return {
+        schema: 'sks.search-visibility.rollback-command.v1',
+        ok: result.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: result.status,
+        rolled_back: result.rolled_back,
+        blockers: result.blockers,
+        verification: verify,
+    };
+}
+export async function runSearchVisibilityDoctor(mode, options) {
+    const root = await projectRoot(options.root);
+    const ctx = context(mode, root, options);
+    const detected = await detectProject(ctx);
+    return {
+        schema: 'sks.search-visibility.doctor-command.v1',
+        ok: detected.blockers.length === 0,
+        route: routeForMode(mode),
+        root,
+        adapter: detected.adapterId,
+        confidence: detected.confidence,
+        capabilities: detected.capabilities,
+        blockers: detected.blockers,
+        status: detected.blockers.length ? 'blocked' : 'verified_partial',
+    };
+}
+export async function runSearchVisibilityFixture(mode, options) {
+    const root = await projectRoot(options.root);
+    const result = await runSearchVisibilityAudit(mode, {
+        ...options,
+        root,
+        target: mode === 'seo' ? 'package' : 'package',
+        offline: true,
+        strict: true,
+    });
+    const planned = await runSearchVisibilityPlan(mode, result.mission_id, options);
+    return {
+        schema: 'sks.search-visibility.fixture-command.v1',
+        ok: Boolean(result.ok && planned.ok),
+        mission_id: result.mission_id,
+        route: routeForMode(mode),
+        audit: result,
+        plan: planned,
+    };
+}
+function context(mode, root, options) {
+    return {
+        root,
+        mode,
+        target: options.target,
+        framework: options.framework,
+        origin: options.url,
+        offline: options.offline,
+        strict: options.strict,
+    };
+}
+async function resolveOrAudit(mode, missionRef, options) {
+    const mission = await resolveSearchVisibilityMission(options.root, missionRef);
+    if (mission)
+        return mission;
+    const audit = await runSearchVisibilityAudit(mode, options);
+    const created = await resolveSearchVisibilityMission(options.root, audit.mission_id);
+    if (!created)
+        throw new Error('Search visibility audit did not create a mission');
+    return created;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { createMission, findLatestMission, missionDir, setCurrent } from '../mission.js';
+import { ensureDir, projectRoot, readJson, writeJsonAtomic } from '../fsx.js';
+export const SEARCH_VISIBILITY_DIR = 'search-visibility';
+export async function createSearchVisibilityMission(mode, prompt, options) {
+    const root = await projectRoot(options.root);
+    const { id, dir } = await createMission(root, { mode, prompt });
+    const artifactDir = path.join(dir, SEARCH_VISIBILITY_DIR);
+    await ensureDir(artifactDir);
+    const route = routeForMode(mode);
+    await setCurrent(root, {
+        mission_id: id,
+        mode: 'SEO_GEO_OPTIMIZER',
+        route: 'SEO_GEO_OPTIMIZER',
+        route_command: route,
+        search_visibility_mode: mode,
+        phase: `${mode.toUpperCase()}_PREPARED`,
+        implementation_allowed: false,
+    });
+    await writeJsonAtomic(path.join(artifactDir, 'intake.json'), {
+        schema: 'sks.search-visibility.intake.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: id,
+        route,
+        root,
+        target: options.target,
+        url: options.url,
+        framework: options.framework,
+        authorization: {
+            apply: options.apply,
+            include_llms_txt: options.includeLlmsTxt,
+            allow_dirty_touched: options.allowDirtyTouched,
+            scope: options.scope,
+        },
+        network_used: false,
+        browser_used: false,
+        status: 'prepared',
+        blockers: [],
+        unverified: ['external production, browser, Search Console, and analytics outcomes are not verified by default'],
+    });
+    return { id, root, dir, artifactDir };
+}
+export async function resolveSearchVisibilityMission(rootInput, missionRef) {
+    const root = await projectRoot(rootInput);
+    const id = !missionRef || missionRef === 'latest' ? await findLatestMission(root) : missionRef;
+    if (!id)
+        return null;
+    const dir = missionDir(root, id);
+    const artifactDir = path.join(dir, SEARCH_VISIBILITY_DIR);
+    return { id, root, dir, artifactDir };
+}
+export async function readSearchVisibilityState(mission) {
+    return readJson(path.join(mission.artifactDir, 'intake.json'), {});
+}
+export function routeForMode(_mode) {
+    return '$SEO-GEO-OPTIMIZER';
+}
+export function gateFileForMode(mode) {
+    return mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json';
+}
+export function findingsFileForMode(mode) {
+    return mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json';
+}
+export function missionRel(missionId, artifact) {
+    return `.sneakoscope/missions/${missionId}/${SEARCH_VISIBILITY_DIR}/${artifact}`;
+}
+//# sourceMappingURL=mission.js.map

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

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

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

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

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

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

package/dist/core/version.js

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