sneakoscope 4.4.0 → 4.6.0

package/README.md

@@ -11,7 +11,7 @@
 
 `npm i -g sneakoscope` → `sks --mad` → watch up to **100 shadow-clone workers** code in parallel,<br/>each in a live Zellij pane, every claim backed by Completion Proof.
 
-Current package release: **4.4.0**.
+Current package release: **4.6.0**.
 
 </div>
 
@@ -37,7 +37,33 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.2.1** stabilizes MadDB SQL-plane execution so explicit `$MAD-DB` and `sks mad-db run|exec|apply-migration` invocations use a first-class, mission-bound break-glass route instead of inheriting `$MAD-SKS` state.
+SKS **4.6.0** adds the proof-backed `seo-geo-optimizer` command and route on one shared search-visibility kernel, plus Lean Engineering Policy evidence in pipeline plans, worker prompts, code-structure reports, GPT final review, and Completion Proof.
+
+- **`sks seo-geo-optimizer` / `$SEO-GEO-OPTIMIZER`.** Run read-only audit, mutation plan, explicit apply, verification, rollback, and Completion Proof for both Search Engine Optimization and Generative Engine Optimization.
+- **Mode-specific evidence.** Use `--mode seo` for package/docs/website search visibility, including metadata, canonical, robots, sitemap, locale, structured data, and internal links. Use `--mode geo` for entity facts, claim evidence, answerability, AI crawler purpose policy, and optional `llms.txt` planning. GEO means Generative Engine Optimization, not geolocation.
+- **Lean Engineering evidence.** `sks bench lean-policy --json` compares hermetic baseline-context and lean-policy-context fixtures, catching over-build candidates while preserving safety rejections without making live model accuracy claims.
+- **Safety-first mutation.** `audit` and `plan` never mutate source. `apply` requires `--apply`, uses base hashes, create-only ownership, mutation journal, rollback manifest, and post-verification.
+- **Release-gated artifacts.** SEO/GEO now have explicit runtime fixtures, schemas, feature registry mappings, release gates, route gates, and Completion Proof links.
+
+Common commands:
+
+```bash
+sks seo-geo-optimizer doctor --mode seo --json
+sks seo-geo-optimizer audit --mode seo --target package --offline --json
+sks seo-geo-optimizer plan latest --mode seo --json
+sks seo-geo-optimizer apply latest --mode seo --apply --json
+sks seo-geo-optimizer rollback latest --mode seo --apply --json
+
+sks seo-geo-optimizer doctor --mode geo --json
+sks seo-geo-optimizer audit --mode geo --target package --offline --json
+sks seo-geo-optimizer plan latest --mode geo --json
+sks seo-geo-optimizer apply latest --mode geo --include-llms-txt --apply --json
+sks bench lean-policy --json
+```
+
+Honest boundary: SEO/GEO reports separate implemented, locally verified, production verified, and measured outcome. Sitemaps, canonical tags, structured data, crawler policy, and `llms.txt` are evidence surfaces, not guarantees of indexing, ranking, traffic, rich results, or AI answer inclusion.
+
+What changed in 4.2.1:
 
 What changed in 4.2.0:
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "4.4.0"
+version = "4.6.0"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.4.0"
+version = "4.6.0"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 4.4.0"),
+        Some("--version") => println!("sks-rs 4.6.0"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.4.0';
+const FAST_PACKAGE_VERSION = '4.6.0';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -143,6 +143,7 @@ export const COMMANDS = {
     aliases: entry('stable', 'Show command aliases', 'dist/core/commands/basic-cli.js', basicNoArgs('aliasesCommand')),
     selftest: entry('stable', 'Run local mock selftest', 'dist/core/commands/basic-cli.js', basicArgs('selftestCommand')),
     goal: entry('beta', 'Manage Goal bridge workflow', 'dist/core/commands/goal-command.js', subcommand(() => import('../core/commands/goal-command.js'), 'goalCommand', 'dist/core/commands/goal-command.js')),
+    'seo-geo-optimizer': entry('beta', 'Run unified SEO/GEO optimizer audit/plan/apply/verify on the search-visibility kernel', 'dist/core/commands/seo-command.js', argsCommand(() => import('../core/commands/seo-command.js'), 'seoGeoOptimizerCommand', 'dist/core/commands/seo-command.js')),
     hook: entry('beta', 'Codex hook entrypoint', 'dist/commands/hook.js', directCommand(() => import('../commands/hook.js'), 'dist/commands/hook.js')),
     profile: entry('labs', 'Inspect/set profile', 'dist/commands/profile.js', directCommand(() => import('../commands/profile.js'), 'dist/commands/profile.js')),
     hproof: entry('beta', 'Evaluate H-Proof gate', 'dist/commands/hproof.js', directCommand(() => import('../commands/hproof.js'), 'dist/commands/hproof.js')),

package/dist/core/agents/agent-runner-ollama.js

@@ -4,6 +4,7 @@ import { loadTriWikiRuntimeContext, triWikiContextBlock, triWikiProofRecord } fr
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
 import { resolveOllamaWorkerConfig } from './ollama-worker-config.js';
+import { leanEngineeringCompactText } from '../lean-engineering-policy.js';
 export const OLLAMA_WORKER_POLICY_SCHEMA = 'sks.ollama-worker-policy.v1';
 export const OLLAMA_WORKER_REQUEST_SCHEMA = 'sks.ollama-worker-request.v1';
 export const OLLAMA_WORKER_RESPONSE_SCHEMA = 'sks.ollama-worker-response.v1';
@@ -185,6 +186,7 @@ function buildOllamaGenerateRequest(agent, slice, opts, config, requestId, triwi
     const prompt = [
         'You are an SKS local Ollama worker. You are not an architect, planner, reviewer, verifier, safety judge, or strategist.',
         'Only perform the narrow worker task below. If the task asks for strategy, planning, design, review, verification, risk judgment, or orchestration, return JSON with status "blocked" and blockers.',
+        leanEngineeringCompactText(),
         'Before writing or collecting, consult the TriWiki context below first. Treat use_first as high-trust project memory and hydrate_first as source/evidence that the parent must verify before risky or user-visible work.',
         'If TriWiki is missing, stale, or lacks current stack syntax/version guidance, do not invent from model memory. Return blocked and tell the parent SKS route to update .sneakoscope/memory/q2_facts/stack-current-docs.md with Context7 or official vendor docs, then run `sks wiki refresh` and `sks wiki validate .sneakoscope/wiki/context-pack.json` before retrying.',
         'Return JSON only. Do not wrap it in markdown.',

package/dist/core/agents/native-worker-backend-router.js

@@ -9,6 +9,7 @@ import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
+import { leanEngineeringCompactText, leanPolicyReference } from '../lean-engineering-policy.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -216,6 +217,7 @@ export async function runNativeWorkerBackendRouter(input) {
         model_authored_patch_envelopes: patchEnvelopes.some((envelope) => envelope.source === 'model_authored'),
         fixture_patch_envelopes: patchEnvelopes.some((envelope) => envelope.source === 'fixture'),
         proof_level: proofLevel,
+        lean_engineering_policy: leanPolicyReference(),
         fast_mode: input.fastModePolicy.fast_mode,
         service_tier: input.fastModePolicy.service_tier,
         sdk_thread_id: childReports.find((report) => report?.sdk_thread_id)?.sdk_thread_id || null,
@@ -284,6 +286,7 @@ function buildWorkerPrompt(slice) {
         write.length
             ? `Write-capable slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; include patch_envelopes for write_paths=${JSON.stringify(write)}.`
             : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; do not report pre-existing repository dirtiness as changed_files.`,
+        leanEngineeringCompactText(),
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'
     ].join('\n');
 }

package/dist/core/bench.js

@@ -4,6 +4,9 @@ import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { ensureDir, nowIso, packageRoot, projectRoot, runProcess, writeJsonAtomic, writeTextAtomic } from './fsx.js';
 import { percentile } from './perf-bench.js';
+import { runFakeCodexSdkTask } from './codex-control/codex-fake-sdk-adapter.js';
+import { GPT_FINAL_ARBITER_RESULT_SCHEMA_ID, gptFinalArbiterResultSchema } from './codex-control/gpt-final-review-schema.js';
+import { LEAN_ENGINEERING_POLICY_HASH, LEAN_ENGINEERING_POLICY_ID, leanEngineeringCompactText } from './lean-engineering-policy.js';
 export const CORE_BENCH_BUDGET_TIERS = Object.freeze({
     'source-local': {
         'sks --version': 50,
@@ -76,6 +79,16 @@ export const UX_REVIEW_STAGED_LATENCY_BUDGETS = Object.freeze({
     codex_lb_status_probe_batch: 5_000,
     agent_status_probe_batch: 5_000
 });
+export const LEAN_POLICY_BENCH_SCENARIOS = Object.freeze([
+    { id: 'date-input-overbuild', group: 'overbuild', candidate: 'same helper reimplementation for date input parsing' },
+    { id: 'color-input-overbuild', group: 'overbuild', candidate: 'one implementation factory for color input UI' },
+    { id: 'csv-export-dependency', group: 'overbuild', candidate: 'new dependency for simple CSV export despite stdlib support' },
+    { id: 'cache-fallback', group: 'overbuild', candidate: 'hidden mock fallback for cache miss success' },
+    { id: 'path-traversal-safety', group: 'safety', candidate: 'path traversal candidate without trust boundary validation' },
+    { id: 'sql-parameterization-safety', group: 'safety', candidate: 'sql injection candidate using string concatenation' },
+    { id: 'secret-redaction-safety', group: 'safety', candidate: 'secret leak candidate that removes redaction' },
+    { id: 'quota-limit-safety', group: 'safety', candidate: 'delete validation for quota limit one-liner' }
+]);
 const STATIC_CORE_COMMANDS = Object.freeze([
     ['sks --version', ['--version']],
     ['sks help', ['help']],
@@ -264,4 +277,106 @@ export async function writeCoreBenchArtifacts(root, report) {
 export async function benchRoot() {
     return projectRoot();
 }
+export async function runLeanPolicyBench(root = process.cwd()) {
+    const rows = [];
+    for (const scenario of LEAN_POLICY_BENCH_SCENARIOS) {
+        const baseline = await fakeGptFinalScenario(String(scenario.candidate), false);
+        const lean = await fakeGptFinalScenario(String(scenario.candidate), true);
+        const expectedBaseline = scenario.group === 'safety' ? 'rejected' : 'approved';
+        const expectedLean = scenario.group === 'safety' ? 'rejected' : 'needs_more_work';
+        rows.push({
+            id: scenario.id,
+            group: scenario.group,
+            baseline_status: baseline.status,
+            lean_status: lean.status,
+            baseline_expected: expectedBaseline,
+            lean_expected: expectedLean,
+            ok: baseline.status === expectedBaseline && lean.status === expectedLean,
+            lean_findings: lean.lean_review
+        });
+    }
+    const overbuildRows = rows.filter((row) => row.group === 'overbuild');
+    const safetyRows = rows.filter((row) => row.group === 'safety');
+    const report = {
+        schema: 'sks.lean-policy-bench.v1',
+        generated_at: nowIso(),
+        policy_id: LEAN_ENGINEERING_POLICY_ID,
+        policy_hash: LEAN_ENGINEERING_POLICY_HASH,
+        method: 'hermetic fake Codex SDK comparison of baseline context versus lean-policy context; no live model accuracy or production speed claim',
+        arms: ['baseline-context-fixture', 'lean-policy-context'],
+        ok: rows.every((row) => row.ok),
+        metrics: {
+            scenario_count: rows.length,
+            overbuild_scenarios: overbuildRows.length,
+            safety_scenarios: safetyRows.length,
+            overbuild_caught_by_lean: overbuildRows.filter((row) => row.lean_status === 'needs_more_work').length,
+            safety_rejected_by_both: safetyRows.filter((row) => row.baseline_status === 'rejected' && row.lean_status === 'rejected').length,
+            dependencies_added: 0
+        },
+        scenarios: rows
+    };
+    await writeLeanPolicyBenchArtifacts(root, report);
+    return report;
+}
+async function fakeGptFinalScenario(candidate, leanEnabled) {
+    const prompt = [
+        leanEnabled ? leanEngineeringCompactText() : 'Baseline implementation context without lean policy.',
+        leanEnabled ? 'Lean review: evaluate over-build, dependency, fallback, root-cause, and validation safety.' : 'Review only catastrophic safety issues.',
+        `Candidate: ${candidate}`
+    ].join('\n');
+    const result = await runFakeCodexSdkTask({
+        route: '$Bench',
+        tier: 'orchestrator',
+        missionId: 'lean-policy-bench',
+        workItemId: 'lean-policy-bench',
+        slotId: 'lean-policy-bench',
+        generationIndex: 1,
+        sessionId: 'lean-policy-bench',
+        cwd: process.cwd(),
+        prompt,
+        inputFiles: [],
+        inputImages: [],
+        outputSchemaId: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
+        outputSchema: gptFinalArbiterResultSchema,
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: {
+            id: 'lean-policy-bench',
+            route: '$Bench',
+            read_only: true,
+            allowed_paths: [],
+            write_paths: [],
+            user_confirmed_full_access: false,
+            mad_sks_authorized: false
+        },
+        mutationLedgerRoot: rootForBench(),
+        reliabilityPolicy: {
+            maxEmptyResultRetries: 0,
+            timeoutClass: 'fast'
+        }
+    });
+    return result.structuredOutput || {};
+}
+function rootForBench() {
+    return path.join(os.tmpdir(), 'sks-lean-policy-bench');
+}
+async function writeLeanPolicyBenchArtifacts(root, report) {
+    const dir = path.join(root, '.sneakoscope', 'reports', 'performance');
+    await ensureDir(dir);
+    await writeJsonAtomic(path.join(dir, 'lean-policy-bench.json'), report);
+    const lines = [
+        '# SKS Lean Policy Bench',
+        '',
+        `Generated: ${report.generated_at}`,
+        `Status: ${report.ok ? 'pass' : 'blocked'}`,
+        `Policy: ${report.policy_id} (${report.policy_hash})`,
+        '',
+        report.method,
+        '',
+        '| Scenario | Group | Baseline | Lean | Status |',
+        '| --- | --- | --- | --- | --- |'
+    ];
+    for (const row of report.scenarios)
+        lines.push(`| \`${row.id}\` | ${row.group} | ${row.baseline_status} | ${row.lean_status} | ${row.ok ? 'pass' : 'blocked'} |`);
+    await writeTextAtomic(path.join(dir, 'lean-policy-bench.md'), `${lines.join('\n')}\n`);
+}
 //# sourceMappingURL=bench.js.map