sneakoscope 4.4.0 → 4.6.1

package/dist/core/codex-control/gpt-final-review-schema.js

@@ -1,3 +1,4 @@
+import { LEAN_SOLUTION_RUNGS } from '../lean-engineering-policy.js';
 export const GPT_FINAL_ARBITER_RESULT_SCHEMA_ID = 'sks.gpt-final-arbiter-result.v1';
 export const GPT_FINAL_ARBITER_INPUT_SCHEMA = 'sks.gpt-final-arbiter-input.v1';
 const reviewItemSchema = {
@@ -20,6 +21,32 @@ const patchDecisionSchema = {
     },
     additionalProperties: false
 };
+const leanReviewSchema = {
+    type: 'object',
+    required: [
+        'status',
+        'selected_rung',
+        'unnecessary_files',
+        'unnecessary_dependencies',
+        'unnecessary_abstractions',
+        'fallback_findings',
+        'root_cause_review',
+        'verification_minimum_present',
+        'net_lines'
+    ],
+    properties: {
+        status: { enum: ['pass', 'modified', 'rejected', 'needs_more_work'] },
+        selected_rung: { enum: [...LEAN_SOLUTION_RUNGS, 'unknown'] },
+        unnecessary_files: { type: 'array', items: { type: 'string' } },
+        unnecessary_dependencies: { type: 'array', items: { type: 'string' } },
+        unnecessary_abstractions: { type: 'array', items: { type: 'string' } },
+        fallback_findings: { type: 'array', items: { type: 'string' } },
+        root_cause_review: { type: 'array', items: { type: 'string' } },
+        verification_minimum_present: { type: 'boolean' },
+        net_lines: { type: ['number', 'null'] }
+    },
+    additionalProperties: false
+};
 export const gptFinalArbiterResultSchema = {
     type: 'object',
     required: [
@@ -34,6 +61,7 @@ export const gptFinalArbiterResultSchema = {
         'verification_plan',
         'rollback_notes',
         'blockers',
+        'lean_review',
         'confidence'
     ],
     properties: {
@@ -48,6 +76,7 @@ export const gptFinalArbiterResultSchema = {
         verification_plan: { type: 'array', items: { type: 'string' } },
         rollback_notes: { type: 'array', items: { type: 'string' } },
         blockers: { type: 'array', items: { type: 'string' } },
+        lean_review: leanReviewSchema,
         confidence: { enum: ['low', 'medium', 'high'] }
     },
     additionalProperties: false
@@ -66,6 +95,7 @@ export function normalizeGptFinalArbiterResult(value) {
         verification_plan: stringArray(value?.verification_plan),
         rollback_notes: stringArray(value?.rollback_notes),
         blockers: stringArray(value?.blockers),
+        lean_review: normalizeLeanReview(value?.lean_review, status),
         confidence: normalizeConfidence(value?.confidence)
     };
 }
@@ -107,6 +137,34 @@ function patchDecisionItems(value) {
 function stringArray(value) {
     return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
 }
+function normalizeLeanReview(value, arbiterStatus) {
+    const raw = typeof value === 'object' && value !== null ? value : {};
+    return {
+        status: normalizeLeanReviewStatus(raw.status, arbiterStatus),
+        selected_rung: normalizeLeanRung(raw.selected_rung),
+        unnecessary_files: stringArray(raw.unnecessary_files),
+        unnecessary_dependencies: stringArray(raw.unnecessary_dependencies),
+        unnecessary_abstractions: stringArray(raw.unnecessary_abstractions),
+        fallback_findings: stringArray(raw.fallback_findings),
+        root_cause_review: stringArray(raw.root_cause_review),
+        verification_minimum_present: typeof raw.verification_minimum_present === 'boolean' ? raw.verification_minimum_present : arbiterStatus === 'approved' || arbiterStatus === 'modified',
+        net_lines: Number.isFinite(Number(raw.net_lines)) ? Number(raw.net_lines) : null
+    };
+}
+function normalizeLeanReviewStatus(value, arbiterStatus) {
+    if (value === 'pass' || value === 'modified' || value === 'rejected' || value === 'needs_more_work')
+        return value;
+    if (arbiterStatus === 'approved')
+        return 'pass';
+    if (arbiterStatus === 'modified')
+        return 'modified';
+    if (arbiterStatus === 'rejected')
+        return 'rejected';
+    return 'needs_more_work';
+}
+function normalizeLeanRung(value) {
+    return typeof value === 'string' && [...LEAN_SOLUTION_RUNGS, 'unknown'].includes(value) ? value : 'unknown';
+}
 function normalizeSeverity(value) {
     return value === 'low' || value === 'medium' || value === 'high' ? value : 'medium';
 }

package/dist/core/codex-native/core-skill-manifest.js

@@ -1,4 +1,5 @@
 import { PACKAGE_VERSION, nowIso, sha256 } from '../fsx.js';
+import { leanPolicyReference } from '../lean-engineering-policy.js';
 import { canonicalSkillName } from './skill-name-canonicalizer.js';
 export const CORE_SKILL_TEMPLATE_VERSION = 'sks-core-skill-template.v1';
 export const CORE_SKILL_MANAGED_BEGIN = '<!-- BEGIN SKS IMMUTABLE CORE SKILL -->';
@@ -83,6 +84,26 @@ const CORE_SKILL_DEFINITIONS = [
         when: 'Use when deeper local context or directory-specific recall is required.',
         evidence: '.sneakoscope/context/AGENTS.generated.md and managed memory artifacts.',
         fallback: 'Preserve user content and skip directories that cannot be safely updated.'
+    },
+    {
+        id: 'sks-core-search-visibility-core',
+        canonical_name: 'search-visibility-core',
+        display_name: 'search-visibility-core',
+        route: '$SEO-GEO-OPTIMIZER',
+        purpose: 'provide the shared search-visibility kernel for SEO and GEO audit, plan, explicit apply, verify, rollback, and Completion Proof without ranking, traffic, or citation guarantees.',
+        when: 'Use when $SEO-GEO-OPTIMIZER or sks seo-geo-optimizer needs typed mode-specific evidence, gates, artifacts, or safe mutation planning.',
+        evidence: 'search-visibility artifacts, seo-gate.json or geo-gate.json, mutation-plan.json, rollback-manifest.json, verification-report.json, and completion-proof.json.',
+        fallback: 'Keep unsupported frameworks plan-only, record unverified production/browser/Search Console/AI citation outcomes, and never invent guarantee evidence.'
+    },
+    {
+        id: 'sks-core-seo-geo-optimizer',
+        canonical_name: 'seo-geo-optimizer',
+        display_name: 'seo-geo-optimizer',
+        route: '$SEO-GEO-OPTIMIZER',
+        purpose: 'run the unified SEO/GEO optimizer route for Search Engine Optimization and Generative Engine Optimization, not geolocation or GeoIP, with no ranking, traffic, indexing, rich-result, answer inclusion, or AI citation guarantee.',
+        when: 'Use the CLI entrypoint: sks seo-geo-optimizer doctor|audit|plan|apply|verify|status|rollback|fixture --mode seo|geo for SEO and GEO visibility work.',
+        evidence: 'site inventory, route graph, seo-findings.json or geo-findings.json, claim-evidence-ledger.json, ai-crawler-policy.json, llms-txt-plan.json, verification report, route gate, and Completion Proof.',
+        fallback: 'Do not auto-allow training crawlers or fabricate AI answer visibility; mark missing live outcomes unverified and keep recovery on the unified optimizer route.'
     }
 ];
 export function coreSkillDefinitions() {
@@ -97,6 +118,7 @@ export function renderCoreSkillTemplate(name) {
     const skill = CORE_SKILL_DEFINITIONS.find((entry) => entry.canonical_name === canonical);
     if (!skill)
         throw new Error(`Unknown SKS core skill: ${name}`);
+    const lean = leanPolicyReference();
     return [
         '---',
         `name: ${skill.display_name}`,
@@ -117,6 +139,7 @@ export function renderCoreSkillTemplate(name) {
         `Command: ${skill.route}`,
         `Purpose: ${skill.purpose}`,
         `Use when: ${skill.when}`,
+        `Lean policy: ${lean.policy_id}/${lean.policy_hash}`,
         `Proof paths: ${skill.evidence}`,
         'Safety rules: preserve user-authored skills, keep route state bounded, and stop on hard blockers instead of fabricating fallback behavior.',
         `Failure recovery: ${skill.fallback}`,

package/dist/core/commands/bench-command.js

@@ -1,4 +1,4 @@
-import { TRUST_VALIDATE_BENCH_COMMAND, benchRoot, runCoreBench } from '../bench.js';
+import { TRUST_VALIDATE_BENCH_COMMAND, benchRoot, runCoreBench, runLeanPolicyBench } from '../bench.js';
 import { runProcess } from '../fsx.js';
 import { flag, readFlagValue } from './command-utils.js';
 export async function benchCommand(args = []) {
@@ -18,9 +18,18 @@ export async function benchCommand(args = []) {
     }
     if (action === 'route-fixtures')
         return commandBench('sks.route-fixture-bench.v1', ['all-features', 'selftest', '--mock', '--execute-fixtures', '--strict-artifacts', '--json'], args);
+    if (action === 'lean-policy') {
+        const report = await runLeanPolicyBench(root);
+        if (!report.ok)
+            process.exitCode = 1;
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(report, null, 2));
+        console.log(`lean-policy: ${report.ok ? 'pass' : 'blocked'}`);
+        return report;
+    }
     if (action === 'blackbox')
         return commandBench('sks.blackbox-bench.v1', ['blackbox-matrix-placeholder'], args);
-    console.error('Usage: sks bench core|route-fixtures|blackbox|trust-kernel [--json] [--iterations N]');
+    console.error('Usage: sks bench core|route-fixtures|lean-policy|blackbox|trust-kernel [--json] [--iterations N]');
     process.exitCode = 2;
 }
 async function commandBench(schema, commandArgs, args = []) {

package/dist/core/commands/code-structure-command.js

@@ -4,18 +4,50 @@ import { flag } from './command-utils.js';
 export async function codeStructureCommand(sub, args = []) {
     const action = sub || 'scan';
     if (action !== 'scan') {
-        console.error('Usage: sks code-structure scan [--json]');
+        console.error('Usage: sks code-structure scan [--json] [--all] [--changed [ref|file[,file]]] [--changed-since <ref>]');
         process.exitCode = 1;
         return;
     }
     const root = await sksRoot();
-    const report = await scanCodeStructure(root, { includeOk: flag(args, '--all') });
+    const changedArg = valueAfter(args, '--changed');
+    const changedSince = valueAfter(args, '--changed-since');
+    const changedArgLooksLikeFiles = Boolean(changedArg && (changedArg.includes(',')
+        || changedArg.includes('/')
+        || changedArg.includes('\\')
+        || /\.(js|ts|tsx|jsx|mjs|cjs|json|md|rs|toml)$/i.test(changedArg)));
+    const changedFiles = changedArg && changedArgLooksLikeFiles
+        ? changedArg.split(',').map((file) => file.trim()).filter(Boolean)
+        : [];
+    const report = await scanCodeStructure(root, {
+        includeOk: flag(args, '--all'),
+        changed: flag(args, '--changed') ? (changedFiles.length ? true : changedArg || true) : false,
+        changedSince,
+        changedFiles
+    });
     if (flag(args, '--json'))
         return console.log(JSON.stringify(report, null, 2));
     console.log('SKS Code Structure');
+    if (report.changed_scope?.mode !== 'full') {
+        console.log(`Changed scope: ${report.changed_scope.changed_files.length} files, ${report.changed_scope.net_lines} net lines`);
+        console.log(`Lean semantic review: ${report.semantic_review?.status || 'unknown'}`);
+    }
     for (const file of report.files.slice(0, 20))
         console.log(`${file.status} ${file.line_count} ${file.path}`);
     if (report.remaining_risks.length)
         console.log(`Risks: ${report.remaining_risks.join(', ')}`);
+    if (report.semantic_review?.findings?.length) {
+        for (const finding of report.semantic_review.findings.slice(0, 8)) {
+            console.log(`Lean ${finding.severity}: ${finding.file ? `${finding.file}: ` : ''}${finding.summary}`);
+        }
+    }
+}
+function valueAfter(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return null;
+    const value = args[index + 1];
+    if (!value || String(value).startsWith('--'))
+        return null;
+    return String(value);
 }
 //# sourceMappingURL=code-structure-command.js.map

package/dist/core/commands/run-command.js

@@ -4,6 +4,7 @@ import { createMission, missionDir, setCurrent } from '../mission.js';
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { routePrompt } from '../routes.js';
 import { latestTrustReport } from '../trust-kernel/trust-report.js';
+import { normalizeTrustStatus, TRUST_REPORT_SCHEMA, trustKernelMetadata } from '../trust-kernel/trust-kernel-schema.js';
 import { flag, positionalArgs } from './command-utils.js';
 export async function runCommand(args = []) {
     const root = await projectRoot();
@@ -135,8 +136,11 @@ async function executeRunRoute(root, context) {
         blockers: execution.ok ? [] : execution.blockers,
         unverified: execution.unverified,
         command: { cmd: execution.command || `sks run "${prompt}" --execute`, status: execution.exit_code ?? (execution.ok ? 0 : 2) },
+        lightweightEvidence: execution.execution_kind === 'safe_deterministic',
     });
-    const trust = await loadTrustReport(root, id);
+    const trust = execution.execution_kind === 'safe_deterministic'
+        ? await writeLightweightTrustReport(root, id, route.command, statusHint, proof.ok)
+        : await loadTrustReport(root, id);
     const autoVerification = auto ? await runAutoVerification(root, id) : null;
     const autoOk = autoVerification?.ok ?? true;
     await setCurrent(root, {
@@ -231,7 +235,7 @@ async function executeRouteCommand(root, route, prompt, { auto = false } = {}) {
     return routeExecutionResult(route, ['sks', ...commandArgs].join(' '), result, {
         okStatus: 'completed',
         trustStatus: 'verified_partial',
-        executionKind: route.command === '$DB' || route.command === '$Wiki' || route.command === '$Fast-Mode' || route.command === '$with-local-llm-on' || route.command === '$Commit' || route.command === '$Commit-And-Push' ? 'safe_deterministic' : 'mock_safe',
+        executionKind: route.command === '$DB' || route.command === '$Wiki' || route.command === '$Fast-Mode' || route.command === '$with-local-llm-on' || route.command === '$Commit' || route.command === '$Commit-And-Push' || route.command === '$Ultra-Search' || route.command === '$SEO-GEO-OPTIMIZER' ? 'safe_deterministic' : 'mock_safe',
     });
 }
 async function runAutoVerification(root, missionId) {
@@ -342,6 +346,10 @@ function runNextAction(route, id, args) {
 function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
     if (route.command === '$DB')
         return ['db', 'check', '--sql', 'SELECT 1', '--json'];
+    if (route.command === '$Ultra-Search')
+        return ultraSearchExecutionArgs(prompt);
+    if (route.command === '$SEO-GEO-OPTIMIZER')
+        return ['seo-geo-optimizer', searchVisibilityActionFromPrompt(prompt), '--mode', searchVisibilityModeFromPrompt(prompt), '--target', searchVisibilityTargetFromPrompt(prompt), '--offline', '--json'];
     if (route.command === '$Wiki')
         return ['wiki', 'refresh', '--json'];
     if (route.command === '$Fast-Mode')
@@ -354,6 +362,58 @@ function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
         return ['commit-and-push', '--json'];
     return ['team', prompt, '--mock', '--json', ...(auto ? ['--no-open-zellij'] : [])];
 }
+function ultraSearchExecutionArgs(prompt = '') {
+    const stripped = stripUltraSearchPrompt(prompt);
+    const lower = stripped.toLowerCase();
+    if (!stripped || /^(?:doctor|check|status)\b/.test(lower))
+        return ['ultra-search', 'doctor', '--json'];
+    if (/^(?:x|x-search|x_search)\b/.test(lower)) {
+        const query = stripped.replace(/^(?:x|x-search|x_search)\b[:\s-]*/i, '').trim() || 'source intelligence fixture';
+        return ['ultra-search', 'x', query, '--json'];
+    }
+    const url = stripped.match(/\bhttps?:\/\/\S+/)?.[0];
+    if (/^(?:fetch|url)\b/.test(lower) || url)
+        return ['ultra-search', 'fetch', url || stripped.replace(/^(?:fetch|url)\b[:\s-]*/i, '').trim() || 'https://example.com', '--json'];
+    const query = stripped.replace(/^run\b[:\s-]*/i, '').trim() || 'source intelligence fixture';
+    return ['ultra-search', 'run', query, '--mode', 'balanced', '--json'];
+}
+function stripUltraSearchPrompt(prompt = '') {
+    return String(prompt || '')
+        .trim()
+        .replace(/^\[\$Ultra-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
+        .replace(/^\[\$UltraSearch\]\([^)]+\)(?:\s|:)?\s*/i, '')
+        .replace(/^\$Ultra-Search(?:\s|:)?\s*/i, '')
+        .replace(/^\$UltraSearch(?:\s|:)?\s*/i, '')
+        .trim();
+}
+function searchVisibilityActionFromPrompt(prompt = '') {
+    const text = String(prompt || '').toLowerCase();
+    if (/\bdoctor\b|진단/.test(text))
+        return 'doctor';
+    if (/\bverify\b|검증/.test(text))
+        return 'fixture';
+    if (/\bplan\b|계획/.test(text))
+        return 'audit';
+    if (/\bapply\b|--apply\b|적용/.test(text))
+        return 'audit';
+    return 'audit';
+}
+function searchVisibilityTargetFromPrompt(prompt = '') {
+    const text = String(prompt || '').toLowerCase();
+    if (/\bpackage\b|npm|readme|github/.test(text))
+        return 'package';
+    if (/\bdocs?\b|documentation/.test(text))
+        return 'docs';
+    if (/\bwebsite\b|site\b|페이지|사이트/.test(text))
+        return 'website';
+    return 'auto';
+}
+function searchVisibilityModeFromPrompt(prompt = '') {
+    const text = String(prompt || '');
+    if (/generative\s+engine\s+optimization|AI\s+(?:answer|search)\s+(?:visibility|discoverability)|LLM\s+(?:citation|answer|visibility|discoverability)|answerability|entity\s+(?:facts?|clarity)|claim\s+evidence|crawler\s+policy|OAI-SearchBot|GPTBot|ChatGPT-User|Claude-SearchBot|ClaudeBot|Claude-User|llms\.txt|AI\s*검색\s*가시성|AI\s*답변\s*가시성|생성형\s*엔진\s*최적화/i.test(text))
+        return 'geo';
+    return 'seo';
+}
 function fastModeActionFromPrompt(prompt = '') {
     const text = String(prompt || '');
     const lower = text.toLowerCase();
@@ -468,4 +528,34 @@ async function loadTrustReport(root, missionId) {
         return report;
     return { status: 'not_verified', ok: false, issues: ['trust_report_invalid'] };
 }
+async function writeLightweightTrustReport(root, missionId, route, statusHint, proofOk) {
+    const status = normalizeTrustStatus(statusHint);
+    const issues = proofOk ? [] : ['completion_proof_not_ok'];
+    const report = {
+        schema: TRUST_REPORT_SCHEMA,
+        ...trustKernelMetadata(),
+        ok: proofOk && !['blocked', 'failed', 'not_verified'].includes(status),
+        mission_id: missionId,
+        route,
+        status,
+        proof_status: status,
+        evidence_status: 'verified_partial',
+        route_contract_status: 'verified_partial',
+        issues,
+        route_state_machine: {
+            state: 'trust_report',
+            lightweight: true,
+            reason: 'safe_deterministic_run_wrapper'
+        },
+        evidence: {
+            completion_proof: `.sneakoscope/missions/${missionId}/completion-proof.json`,
+            route_contract: null,
+            evidence_index: null,
+            evidence_records: 0,
+            lightweight: true
+        }
+    };
+    await writeJsonAtomic(path.join(missionDir(root, missionId), 'trust-report.json'), report);
+    return report;
+}
 //# sourceMappingURL=run-command.js.map

package/dist/core/commands/seo-command.js

@@ -0,0 +1,130 @@
+import path from 'node:path';
+import { printJson } from '../../cli/output.js';
+import { projectRoot } from '../fsx.js';
+import { flag, readOption } from './command-utils.js';
+import { runSearchVisibilityApply, runSearchVisibilityAudit, runSearchVisibilityDoctor, runSearchVisibilityFixture, runSearchVisibilityPlan, runSearchVisibilityRollback, runSearchVisibilityStatus, runSearchVisibilityVerify, } from '../search-visibility/index.js';
+export async function seoCommand(args = []) {
+    return runSearchVisibilityCommand('seo', args, 'seo');
+}
+export async function seoGeoOptimizerCommand(args = []) {
+    const normalized = normalizeOptimizerArgs(args);
+    return runSearchVisibilityCommand(normalized.mode, normalized.args, 'seo-geo-optimizer');
+}
+export async function runSearchVisibilityCommand(mode, args = [], displayCommand = mode) {
+    const action = args[0] || 'doctor';
+    const rest = args.slice(1);
+    const options = await parseOptions(rest);
+    let result;
+    if (action === 'doctor')
+        result = await runSearchVisibilityDoctor(mode, options);
+    else if (action === 'audit')
+        result = await runSearchVisibilityAudit(mode, options);
+    else if (action === 'plan')
+        result = await runSearchVisibilityPlan(mode, firstPositional(rest) || 'latest', options);
+    else if (action === 'apply')
+        result = await runSearchVisibilityApply(mode, firstPositional(rest) || 'latest', options);
+    else if (action === 'verify')
+        result = await runSearchVisibilityVerify(mode, firstPositional(rest) || 'latest', options);
+    else if (action === 'status')
+        result = await runSearchVisibilityStatus(mode, firstPositional(rest) || 'latest', options);
+    else if (action === 'rollback')
+        result = await runSearchVisibilityRollback(mode, firstPositional(rest) || 'latest', options);
+    else if (action === 'fixture')
+        result = await runSearchVisibilityFixture(mode, options);
+    else
+        return usage(mode, 2, displayCommand);
+    if (isBlocked(result))
+        process.exitCode = 1;
+    if (options.json) {
+        printJson(result);
+        return result;
+    }
+    printHuman(mode, action, result);
+    return result;
+}
+function normalizeOptimizerArgs(args) {
+    const out = [...args];
+    const first = String(out[0] || '').toLowerCase();
+    if (first === 'seo' || first === 'geo')
+        return { mode: first, args: out.slice(1) };
+    const modeIndex = out.findIndex((item) => item === '--mode');
+    if (modeIndex >= 0) {
+        const value = String(out[modeIndex + 1] || '').toLowerCase();
+        out.splice(modeIndex, value ? 2 : 1);
+        return { mode: value === 'geo' ? 'geo' : 'seo', args: out };
+    }
+    if (out.includes('--include-llms-txt') || out.includes('--observe-queries') || out.includes('--query-file'))
+        return { mode: 'geo', args: out };
+    return { mode: 'seo', args: out };
+}
+async function parseOptions(args) {
+    const root = path.resolve(readOption(args, '--root', await projectRoot()));
+    return {
+        root,
+        url: readOption(args, '--url', null),
+        target: targetOption(readOption(args, '--target', 'auto')),
+        framework: frameworkOption(readOption(args, '--framework', 'auto')),
+        offline: flag(args, '--offline'),
+        strict: flag(args, '--strict'),
+        json: flag(args, '--json'),
+        apply: flag(args, '--apply'),
+        yes: flag(args, '--yes'),
+        allowDirtyTouched: flag(args, '--allow-dirty-touched'),
+        browser: flag(args, '--browser'),
+        includeLlmsTxt: flag(args, '--include-llms-txt'),
+        observeQueries: flag(args, '--observe-queries'),
+        queryFile: readOption(args, '--query-file', null),
+        scope: String(readOption(args, '--scope', '') || '').split(',').map((item) => item.trim()).filter(Boolean),
+    };
+}
+function targetOption(value) {
+    return ['auto', 'website', 'docs', 'package'].includes(value) ? value : 'auto';
+}
+function frameworkOption(value) {
+    return ['auto', 'next-app', 'next-pages', 'static', 'package', 'unsupported'].includes(value) ? value : 'auto';
+}
+function firstPositional(args) {
+    const valueFlags = new Set(['--root', '--url', '--target', '--framework', '--scope', '--query-file']);
+    for (let i = 0; i < args.length; i += 1) {
+        const value = args[i] || '';
+        if (valueFlags.has(value)) {
+            i += 1;
+            continue;
+        }
+        if (!value.startsWith('--'))
+            return value;
+    }
+    return null;
+}
+function usage(mode, exitCode, displayCommand = mode) {
+    if (displayCommand === 'seo-geo-optimizer') {
+        console.error('Usage: sks seo-geo-optimizer [seo|geo] doctor|audit|plan|apply|verify|status|rollback|fixture [mission|latest] [--mode seo|geo] [--root <path>] [--url <origin>] [--target auto|website|docs|package] [--framework auto|next-app|next-pages|static] [--offline] [--strict] [--json]');
+        console.error('       sks seo-geo-optimizer apply <mission|latest> --mode seo|geo --apply [--include-llms-txt] [--scope <rule-or-path,...>] [--yes] [--json]');
+        console.error('       sks seo-geo-optimizer rollback <mission|latest> --mode seo|geo --apply [--yes] [--json]');
+        process.exitCode = exitCode;
+        return { schema: 'sks.search-visibility.usage.v1', ok: false, status: 'blocked', mode, command: displayCommand, reason: 'invalid_subcommand' };
+    }
+    const applyFlag = mode === 'geo' ? ' [--include-llms-txt]' : '';
+    console.error(`Usage: sks ${mode} doctor|audit|plan|apply|verify|status|rollback|fixture [mission|latest] [--root <path>] [--url <origin>] [--target auto|website|docs|package] [--framework auto|next-app|next-pages|static] [--offline] [--strict] [--json]`);
+    console.error(`       sks ${mode} apply <mission|latest> --apply${applyFlag} [--scope <rule-or-path,...>] [--yes] [--json]`);
+    console.error(`       sks ${mode} rollback <mission|latest> --apply [--yes] [--json]`);
+    process.exitCode = exitCode;
+    return { schema: 'sks.search-visibility.usage.v1', ok: false, status: 'blocked', mode, reason: 'invalid_subcommand' };
+}
+function isBlocked(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const rec = value;
+    return rec.ok === false || rec.status === 'blocked';
+}
+function printHuman(mode, action, value) {
+    const rec = value && typeof value === 'object' ? value : {};
+    console.log(`SKS ${mode.toUpperCase()} ${action}: ${rec.status || (rec.ok === false ? 'blocked' : 'ok')}`);
+    if (rec.mission_id)
+        console.log(`Mission: ${rec.mission_id}`);
+    if (rec.artifacts_dir)
+        console.log(`Artifacts: ${rec.artifacts_dir}`);
+    if (Array.isArray(rec.blockers) && rec.blockers.length)
+        console.log(`Blockers: ${rec.blockers.join(', ')}`);
+}
+//# sourceMappingURL=seo-command.js.map

package/dist/core/db-safety.js

@@ -510,15 +510,16 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     const contract = await loadMissionContract(root, state);
     const classification = classifyToolPayload(payload);
     const madDb = await resolveMadDbMutationPolicy(root, state, classification);
-    if (madDb.allowed === true && state?.mission_id) {
+    if (madDb.allowed === true && madDb.mission_id) {
         const madDbDecision = madDb;
+        const madDbMissionId = String(madDbDecision.mission_id);
         const sqlText = classification.sql?.statements?.length ? String(classification.sql.statements.join('\n')) : null;
         const sqlHash = sqlText ? sha256(sqlText) : null;
         const toolCallId = extractCanonicalToolCallId(payload) || `payload-${sha256(JSON.stringify({ tool: classification.toolName || '', sqlHash, level: classification.level })).slice(0, 16)}`;
         const operationClasses = madDbDecision.operation_classes?.length ? madDbDecision.operation_classes : madDbOperationClassesFromClassification(classification);
         const reservation = await reserveMadDbOperation({
             root,
-            missionId: String(state.mission_id),
+            missionId: madDbMissionId,
             capability: madDbDecision.capability,
             toolCallId,
             toolName: classification.toolName || 'unknown_database_tool',
@@ -527,12 +528,12 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
         });
         await transitionMadDbOperation({
             root,
-            missionId: String(state.mission_id),
+            missionId: madDbMissionId,
             toolCallId,
             state: 'started'
         });
         const lifecycleHook = {
-            mission_id: String(state.mission_id),
+            mission_id: madDbMissionId,
             operation_id: reservation.operation.operation_id,
             tool_call_id: toolCallId,
             cycle_id: madDbDecision.cycle_id || null,
@@ -560,12 +561,13 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
                 lifecycle_result_pending: true,
                 ledger_result_hook: lifecycleHook,
                 operation_classes: operationClasses,
+                state_source: madDbDecision.state_source || 'hook_state',
                 counters: reservation.capability.counters,
                 idempotent_reservation_reused: reservation.reused
             }
         };
-        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification, operation_id: reservation.operation.operation_id, tool_call_id: toolCallId });
-        await appendJsonlBounded(path.join(missionDir(root, state.mission_id), 'db-safety.jsonl'), { ts: nowIso(), decision });
+        await appendMadDbLedgerEvent(root, madDbMissionId, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification, operation_id: reservation.operation.operation_id, tool_call_id: toolCallId });
+        await appendJsonlBounded(path.join(missionDir(root, madDbMissionId), 'db-safety.jsonl'), { ts: nowIso(), decision });
         return decision;
     }
     const madSks = await madSksOverrideState(root, state);

package/dist/core/feature-fixtures.js

@@ -36,6 +36,7 @@ const FIXTURES = Object.freeze({
     'cli-selftest': fixture('execute', 'sks selftest --mock', [], 'pass'),
     'cli-git': fixture('execute', 'sks git policy --json', [], 'pass'),
     'cli-goal': fixture('mock', 'sks goal status latest --json', ['goal-workflow.json'], 'pass'),
+    'cli-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode seo --json', ['search-visibility/site-inventory.json', 'search-visibility/seo-findings.json', 'search-visibility/verification-report.json', 'seo-gate.json', 'completion-proof.json'], 'pass'),
     'cli-research': fixture('mock', 'sks research status latest --json', ['research-gate.json', 'completion-proof.json'], 'pass'),
     'cli-qa-loop': fixture('mock', 'sks qa-loop status latest --json', ['qa-loop-proof.json', 'completion-proof.json'], 'pass'),
     'cli-ppt': fixture('mock', 'sks ppt fixture --mock --json', ['ppt-imagegen-review-gate.json', 'completion-proof.json'], 'pass'),
@@ -75,6 +76,7 @@ const FIXTURES = Object.freeze({
     'cli-commit': fixture('mock', 'sks commit --dry-run', [], 'pass'),
     'cli-commit-and-push': fixture('mock', 'sks commit-and-push --dry-run', [], 'pass'),
     'cli-context7': fixture('real_optional', 'sks context7 check --json', [], 'pass'),
+    'cli-ultra-search': fixture('execute', 'sks ultra-search doctor --json', [], 'pass'),
     'cli-xai': fixture('real_optional', 'sks xai check --json', [], 'pass'),
     'cli-all-features': fixture('mock', 'sks all-features complete --json', [`.sneakoscope/reports/all-feature-completion-${PACKAGE_VERSION}.json`], 'pass'),
     'cli-init': fixture('mock', 'sks init --local-only --dry-run', [], 'pass'),
@@ -88,6 +90,7 @@ const FIXTURES = Object.freeze({
     'skill-imagegen': fixture('mock', 'sks image-ux-review fixture --mock --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
     'skill-gx-visual-validate': fixture('mock', 'sks gx validate fixture --mock --json', ['gx-validation.json'], 'pass'),
     'skill-context7-docs': fixture('real_optional', 'sks context7 check --json', [], 'pass'),
+    'skill-seo-geo-optimizer': fixture('mock', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),
     'cli-proof': fixture('execute_and_validate_artifacts', 'sks proof smoke --json', ['.sneakoscope/proof/latest.json'], 'pass'),
     'cli-trust': fixture('execute_and_validate_artifacts', 'sks trust report latest --json', ['trust-report.json'], 'pass'),
     'cli-wrongness': fixture('execute_and_validate_artifacts', 'sks wrongness add --kind missing_evidence --claim "fixture wrongness" --json', ['.sneakoscope/wiki/wrongness-ledger.json'], 'pass'),
@@ -104,6 +107,9 @@ const FIXTURES = Object.freeze({
     'route-dfix': fixture('execute_and_validate_artifacts', 'sks dfix fixture --json', ['completion-proof.json', 'dfix-gate.json', 'dfix-verification.json'], 'pass'),
     'route-answer': fixture('mock', '$Answer answer-only route policy', [], 'pass'),
     'route-goal': fixture('mock', '$Goal bridge route', ['goal-workflow.json', 'completion-proof.json'], 'pass'),
+    'route-ultra-search': fixture('execute', 'sks run "$Ultra-Search source intelligence fixture" --execute --json', [], 'pass'),
+    'route-ultrasearch': fixture('execute', 'sks run "$UltraSearch source intelligence fixture" --execute --json', [], 'pass'),
+    'route-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'search-visibility/verification-report.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),
     'route-autoresearch': fixture('mock', '$AutoResearch fixture route', ['research-gate.json', 'completion-proof.json'], 'pass'),
     'route-mad-sks': fixture('mock', '$MAD-SKS permission gate route', ['mad-sks-gate.json', 'completion-proof.json'], 'pass'),
     'route-from-chat-img': fixture('mock', '$From-Chat-IMG visual work order route', ['from-chat-img-work-order.md', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass'),

package/dist/core/feature-registry.js

@@ -461,6 +461,7 @@ const SAFE_EXECUTABLE_FIXTURE_ARGS = Object.freeze({
     'cli-fix-path': ['fix-path', '--json'],
     'cli-selftest': ['selftest', '--mock'],
     'cli-git': ['git', 'policy', '--json'],
+    'cli-seo-geo-optimizer': ['seo-geo-optimizer', 'fixture', '--mode', 'seo', '--json'],
     'cli-paths': ['paths', 'managed', '--json'],
     'cli-rollback': ['rollback', 'list', '--json'],
     'cli-proof-field': ['proof-field', 'scan', '--json', '--intent', 'fixture'],
@@ -493,6 +494,7 @@ const SAFE_EXECUTABLE_FIXTURE_ARGS = Object.freeze({
     'route-image-ux-review': ['image-ux-review', 'fixture', '--mock', '--json'],
     'route-computer-use': ['computer-use', 'import-fixture', '--mock', '--json'],
     'route-dfix': ['dfix', 'fixture', '--json'],
+    'route-seo-geo-optimizer': ['seo-geo-optimizer', 'fixture', '--mode', 'geo', '--json'],
     'route-fast-mode': ['fast-mode', 'status', '--json'],
     'route-db': ['db', 'check', '--sql', 'SELECT 1', '--json'],
     'route-wiki': ['wiki', 'image-ingest', 'test/fixtures/images/one-by-one.png', '--json'],
@@ -826,7 +828,7 @@ function commandCategory(name) {
 function commandMaturity(name) {
     if (['help', 'version', 'commands', 'usage', 'root', 'quickstart', 'setup', 'doctor', 'selftest', 'update-check', 'fast-mode'].includes(name))
         return 'stable';
-    if (['codex', 'codex-app', 'codex-native', 'codex-lb', 'hooks', 'features', 'all-features', 'wiki', 'wrongness', 'team', 'pipeline', 'goal', 'db', 'guard', 'computer-use', 'mad-sks'].includes(name))
+    if (['codex', 'codex-app', 'codex-native', 'codex-lb', 'hooks', 'features', 'all-features', 'wiki', 'wrongness', 'team', 'pipeline', 'goal', 'db', 'guard', 'computer-use', 'mad-sks', 'seo-geo-optimizer'].includes(name))
         return 'beta';
     return 'labs';
 }

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.4.0';
+export const PACKAGE_VERSION = '4.6.1';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/hooks-runtime.js

@@ -12,6 +12,7 @@ import { localizedFinalizationReason } from './language-preference.js';
 import { classifyToolError } from './evaluation.js';
 import { REQUIRED_CODEX_MODEL, isForbiddenCodexModel } from './codex-model-guard.js';
 import { dollarCommand, routeRequiresSubagents, stripVisibleDecisionAnswerBlocks } from './routes.js';
+import { leanEngineeringCompactText } from './lean-engineering-policy.js';
 import { appendMissionStatus } from './recallpulse.js';
 import { scanAgentTextForRecursion } from './agents/agent-recursion-guard.js';
 import { evaluateLoopContinuation } from './loops/loop-continuation-enforcer.js';
@@ -194,8 +195,15 @@ export async function evaluateHookPayload(name, payload = {}, opts = {}) {
         return hookPermission(root, state, payload, noQuestion);
     if (name === 'stop')
         return hookStop(root, state, payload, noQuestion);
+    if (name === 'subagent-start')
+        return hookSubagentStart(root, state);
     return { continue: true };
 }
+async function hookSubagentStart(root, state) {
+    const active = await activeRouteContext(root, state).catch(() => '');
+    const additionalContext = [leanEngineeringCompactText(), active].filter(Boolean).join('\n\n');
+    return { continue: true, additionalContext };
+}
 function blockForbiddenClientModel(payload = {}) {
     const model = forbiddenClientModelFromPayload(payload);
     if (!model || !isForbiddenCodexModel(model))