sneakoscope 4.2.1 → 4.3.0

package/dist/core/codex-control/codex-fake-sdk-adapter.js

@@ -27,22 +27,44 @@ export async function runFakeCodexSdkTask(input) {
 }
 function fakeStructuredOutput(input) {
     if (input.outputSchemaId === GPT_FINAL_ARBITER_RESULT_SCHEMA_ID) {
-        const unsafe = /\b(truncate|delete all|drop table|credential)\b/i.test(input.prompt || '');
+        const prompt = String(input.prompt || '');
+        const leanEnabled = /\b(Lean review|Lean Engineering Policy|sks\.lean-engineering-policy)\b/i.test(prompt);
+        const unsafe = /\b(truncate|delete all|drop table|credential|delete validation|validation removed|path traversal|sql injection|secret leak)\b/i.test(prompt);
+        const overbuild = leanEnabled ? classifyLeanOverbuild(prompt) : null;
+        const status = unsafe ? 'rejected' : overbuild ? 'needs_more_work' : 'approved';
+        const leanStatus = unsafe ? 'rejected' : overbuild ? 'needs_more_work' : 'pass';
+        const blockers = unsafe ? ['unsafe_candidate_patch'] : overbuild?.blockers || [];
+        const findings = unsafe
+            ? [{ id: 'unsafe-candidate', severity: 'high', summary: 'unsafe candidate rejected' }]
+            : overbuild ? overbuild.findings : [];
         return {
             schema: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
-            status: unsafe ? 'rejected' : 'approved',
+            status,
             summary: unsafe
                 ? 'Fake Codex SDK GPT final arbiter rejected an unsafe candidate for hermetic verification.'
-                : 'Fake Codex SDK GPT final arbiter approved the candidate for hermetic verification.',
-            gpt_review_findings: unsafe ? [{ id: 'unsafe-candidate', severity: 'high', summary: 'unsafe candidate rejected' }] : [],
-            accepted_patch_envelopes: unsafe ? [] : [],
+                : overbuild
+                    ? 'Fake Codex SDK GPT final arbiter requested a leaner candidate for hermetic verification.'
+                    : 'Fake Codex SDK GPT final arbiter approved the candidate for hermetic verification.',
+            gpt_review_findings: findings,
+            accepted_patch_envelopes: status === 'approved' ? [] : [],
             modified_patch_envelopes: [],
-            rejected_patch_envelopes: unsafe ? [{ id: 'unsafe-candidate', summary: 'unsafe candidate', patch_envelope_json: '{}' }] : [],
-            required_followup_work: unsafe ? [{ id: 'unsafe_candidate_patch', severity: 'high', summary: 'unsafe_candidate_patch' }] : [],
+            rejected_patch_envelopes: status === 'rejected' ? [{ id: blockers[0] || 'rejected-candidate', summary: blockers[0] || 'rejected candidate', patch_envelope_json: '{}' }] : [],
+            required_followup_work: blockers.map((blocker) => ({ id: blocker, severity: unsafe ? 'high' : 'medium', summary: blocker })),
             verification_plan: ['schema validation', 'local collaboration final gate'],
             rollback_notes: [],
-            blockers: unsafe ? ['unsafe_candidate_patch'] : [],
-            confidence: unsafe ? 'medium' : 'high'
+            blockers,
+            lean_review: {
+                status: leanStatus,
+                selected_rung: unsafe ? 'unknown' : overbuild?.selected_rung || 'minimal-custom',
+                unnecessary_files: [],
+                unnecessary_dependencies: overbuild?.unnecessary_dependencies || [],
+                unnecessary_abstractions: overbuild?.unnecessary_abstractions || [],
+                fallback_findings: unsafe ? ['unsafe_candidate_patch'] : overbuild?.fallback_findings || [],
+                root_cause_review: overbuild?.root_cause_review || [],
+                verification_minimum_present: !unsafe && !/\b(missing runnable check|no runnable check)\b/i.test(prompt),
+                net_lines: null
+            },
+            confidence: unsafe || overbuild ? 'medium' : 'high'
         };
     }
     return {
@@ -56,4 +78,40 @@ function fakeStructuredOutput(input) {
         blockers: []
     };
 }
+function classifyLeanOverbuild(prompt) {
+    if (/\b(existing helper reimplementation|same helper reimplementation|reimplement existing helper)\b/i.test(prompt)) {
+        return leanFinding('reuse_existing_helper', 'reuse-existing', 'Candidate reimplements an existing helper instead of reusing the repository authority.', {
+            root_cause_review: ['reuse existing helper or fix the common helper once']
+        });
+    }
+    if (/\b(new dependency|dependency bloat|native platform instead of dependency)\b/i.test(prompt)) {
+        return leanFinding('unnecessary_dependency', 'stdlib', 'Candidate adds a dependency where stdlib or platform support is sufficient.', {
+            unnecessary_dependencies: ['unjustified dependency']
+        });
+    }
+    if (/\b(one implementation factory|single implementation factory|one implementation interface)\b/i.test(prompt)) {
+        return leanFinding('single_impl_abstraction', 'minimal-custom', 'Candidate adds an abstraction without a second implementation or real variation axis.', {
+            unnecessary_abstractions: ['single implementation factory/interface']
+        });
+    }
+    if (/\b(hidden mock fallback|silent mock fallback|fixture fallback)\b/i.test(prompt)) {
+        return leanFinding('hidden_fallback', 'minimal-custom', 'Candidate hides a production failure behind a mock or fixture fallback.', {
+            fallback_findings: ['hidden mock fallback']
+        });
+    }
+    if (/\b(caller duplicate guard|duplicate caller guard|symptom patch)\b/i.test(prompt)) {
+        return leanFinding('root_cause_missing', 'minimal-custom', 'Candidate patches a caller symptom instead of the shared root cause.', {
+            root_cause_review: ['move duplicated guard to the shared root-cause helper']
+        });
+    }
+    return null;
+}
+function leanFinding(id, selectedRung, summary, extra = {}) {
+    return {
+        selected_rung: selectedRung,
+        blockers: [id],
+        findings: [{ id, severity: 'medium', summary }],
+        ...extra
+    };
+}
 //# sourceMappingURL=codex-fake-sdk-adapter.js.map

package/dist/core/codex-control/gpt-final-arbiter.js

@@ -5,6 +5,7 @@ import { evaluateLocalCollaborationFinalGate, resolveLocalCollaborationPolicy }
 import { runCodexTask } from './codex-control-plane.js';
 import { GPT_FINAL_ARBITER_INPUT_SCHEMA, GPT_FINAL_ARBITER_RESULT_SCHEMA_ID, gptFinalArbiterResultSchema, normalizeGptFinalArbiterResult } from './gpt-final-review-schema.js';
 import { compressGptFinalContext } from './gpt-final-context-compressor.js';
+import { leanEngineeringCompactText } from '../lean-engineering-policy.js';
 export const GPT_FINAL_ARBITER_RUN_SCHEMA = 'sks.gpt-final-arbiter-run.v1';
 export async function runGptFinalArbiter(input, opts = {}) {
     const started = Date.now();
@@ -145,7 +146,9 @@ function buildArbiterPrompt(input, compressed) {
     return [
         'You are the GPT Final Arbiter for an SKS local collaboration run.',
         'Local model outputs are drafts only. Review the proof pack, candidate diff, patch envelopes, verification results, side effects, mutation ledger, and rollback plan.',
-        'Approve or modify only when the candidate is safe and supported. Reject unsafe local patches. Return only the requested structured JSON schema.',
+        leanEngineeringCompactText(),
+        'Lean review: check for reused helpers before reimplementation, unjustified dependencies, one-implementation factories/interfaces, hidden mock or provider fallbacks, duplicated caller guards instead of root-cause fixes, forwarding-only files, missing runnable checks for non-trivial logic, and safety/validation removal disguised as simplification.',
+        'Approve or modify only when the candidate is safe, supported, and no more complex than the request requires. Reject unsafe local patches. Return only the requested structured JSON schema.',
         JSON.stringify({
             route: input.route,
             mission_id: input.mission_id,

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/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'),