sneakoscope 5.7.0 → 5.9.0

package/dist/core/perf/perf-budget.js

@@ -0,0 +1,145 @@
+import { performance } from 'node:perf_hooks';
+import path from 'node:path';
+import { runProcess, writeJsonAtomic } from '../fsx.js';
+export async function runPerfBudgets(root, budgets, opts = {}) {
+    const warmupRuns = opts.warmupRuns ?? Number(process.env.SKS_PERF_WARMUP_RUNS || 2);
+    const measuredRuns = opts.measuredRuns ?? Number(process.env.SKS_PERF_MEASURED_RUNS || 15);
+    const timeoutMs = opts.timeoutMs ?? 30_000;
+    const timingRetries = Math.max(0, Number(process.env.SKS_PERF_TIMING_RETRIES || 2));
+    const retryCooldownMs = Math.max(0, Number(process.env.SKS_PERF_RETRY_COOLDOWN_MS || 3000));
+    const commands = [];
+    const blockers = [];
+    for (const budget of budgets) {
+        for (let index = 0; index < warmupRuns; index++) {
+            await runTimed(root, budget.argv, timeoutMs);
+        }
+        const attempts = [];
+        let measurement = await measureCommand(root, budget, measuredRuns, timeoutMs);
+        attempts.push(commandAttempt(1, measurement));
+        let selectedAttempt = 1;
+        for (let retry = 1; retry <= timingRetries && !measurement.ok && measurement.exitOk; retry++) {
+            if (retryCooldownMs)
+                await delay(retryCooldownMs);
+            await runTimed(root, budget.argv, timeoutMs);
+            const next = await measureCommand(root, budget, measuredRuns, timeoutMs);
+            attempts.push(commandAttempt(retry + 1, next));
+            if (isBetterMeasurement(next, measurement, budget)) {
+                measurement = next;
+                selectedAttempt = retry + 1;
+            }
+            if (measurement.ok)
+                break;
+        }
+        const { p50, p95, exitCodes, ok } = measurement;
+        blockers.push(...measurement.blockers.map((blocker) => `${budget.name}:${blocker}`));
+        commands.push({
+            name: budget.name,
+            argv: budget.argv,
+            runs: measuredRuns,
+            p50_ms: p50,
+            p95_ms: p95,
+            ...(budget.budget_p50_ms !== undefined ? { budget_p50_ms: budget.budget_p50_ms } : {}),
+            budget_p95_ms: budget.budget_p95_ms,
+            ok,
+            exit_codes: exitCodes,
+            ...(attempts.length > 1 ? { retry_count: attempts.length - 1, selected_attempt: selectedAttempt, attempts } : {})
+        });
+    }
+    return {
+        schema: 'sks.perf-budget.v1',
+        ok: blockers.length === 0,
+        generated_at: new Date().toISOString(),
+        warmup_runs: warmupRuns,
+        measured_runs: measuredRuns,
+        commands,
+        blockers: [...new Set(blockers)]
+    };
+}
+export async function writePerfBudgetReport(root, budgets, opts = {}) {
+    const report = await runPerfBudgets(root, budgets, opts);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'perf-budget.json'), report);
+    return report;
+}
+async function measureCommand(root, budget, measuredRuns, timeoutMs) {
+    const durations = [];
+    const exitCodes = [];
+    const blockers = [];
+    for (let index = 0; index < measuredRuns; index++) {
+        const result = await runTimed(root, budget.argv, timeoutMs);
+        durations.push(result.duration_ms);
+        exitCodes.push(result.code);
+        if (result.code !== 0)
+            blockers.push(`exit_${result.code}`);
+    }
+    durations.sort((a, b) => a - b);
+    const p50 = percentile(durations, 0.5);
+    const p95 = percentile(durations, 0.95);
+    const p50Ok = budget.budget_p50_ms === undefined || p50 <= budget.budget_p50_ms;
+    const p95Ok = p95 <= budget.budget_p95_ms;
+    const exitOk = exitCodes.every((code) => code === 0);
+    const ok = p50Ok && p95Ok && exitOk;
+    if (!p50Ok)
+        blockers.push('p50_budget_exceeded');
+    if (!p95Ok)
+        blockers.push('p95_budget_exceeded');
+    if (!exitOk)
+        blockers.push('process_failed');
+    return { p50, p95, p50Ok, p95Ok, exitOk, ok, exitCodes, blockers: [...new Set(blockers)] };
+}
+function commandAttempt(attempt, measurement) {
+    return {
+        attempt,
+        p50_ms: measurement.p50,
+        p95_ms: measurement.p95,
+        ok: measurement.ok,
+        exit_codes: measurement.exitCodes,
+        blockers: measurement.blockers
+    };
+}
+function isBetterMeasurement(next, current, budget) {
+    if (next.ok !== current.ok)
+        return next.ok;
+    if (next.exitOk !== current.exitOk)
+        return next.exitOk;
+    if (next.blockers.length !== current.blockers.length)
+        return next.blockers.length < current.blockers.length;
+    const nextOverage = timingOverage(next, budget);
+    const currentOverage = timingOverage(current, budget);
+    if (nextOverage !== currentOverage)
+        return nextOverage < currentOverage;
+    if (next.p95 !== current.p95)
+        return next.p95 < current.p95;
+    return next.p50 < current.p50;
+}
+function timingOverage(measurement, budget) {
+    const p50Overage = budget.budget_p50_ms === undefined ? 0 : Math.max(0, measurement.p50 - budget.budget_p50_ms);
+    const p95Overage = Math.max(0, measurement.p95 - budget.budget_p95_ms);
+    return p50Overage + p95Overage;
+}
+async function runTimed(root, argv, timeoutMs) {
+    const [command, ...args] = argv;
+    if (!command)
+        return { code: -1, duration_ms: 0 };
+    const started = performance.now();
+    const result = await runProcess(command, args, {
+        cwd: root,
+        timeoutMs,
+        maxOutputBytes: 64 * 1024,
+        env: {
+            SKS_DISABLE_NETWORK: '1',
+            SKS_PERF_MEASURE: '1',
+            SKS_DISABLE_UPDATE_CHECK: '1'
+        }
+    });
+    return { code: result.code, duration_ms: Math.round(performance.now() - started) };
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function percentile(values, pct) {
+    if (!values.length)
+        return 0;
+    const index = Math.min(values.length - 1, Math.max(0, Math.ceil(values.length * pct) - 1));
+    return values[index] ?? 0;
+}
+//# sourceMappingURL=perf-budget.js.map

package/dist/core/quality/competitor-scorecard.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJson } from '../fsx.js';
+const scoreCategories = [
+    'code_stability',
+    'test_release_gates',
+    'parallel_isolation',
+    'speed_performance',
+    'install_operations',
+    'maintainability'
+];
+export async function generateCompetitorScorecard(root, baseline) {
+    const pkg = await readJson(path.join(root, 'package.json'), {});
+    const evidence = Object.fromEntries(await Promise.all(scoreCategories.map(async (category) => {
+        const entries = baseline.categories[category] || [];
+        return [category, await Promise.all(entries.map((entry) => scoreEvidence(root, entry)))];
+    })));
+    const scores = Object.fromEntries(scoreCategories.map((category) => {
+        const results = evidence[category];
+        const totalPoints = results.reduce((sum, item) => sum + (item.points ?? 1), 0);
+        const earned = results.reduce((sum, item) => sum + item.score, 0);
+        return [category, totalPoints > 0 ? Math.round((earned / totalPoints) * 100) : 0];
+    }));
+    const total = Math.round(scoreCategories.reduce((sum, category) => sum + scores[category], 0) / scoreCategories.length);
+    const blockers = scoreCategories.flatMap((category) => evidence[category]
+        .filter((item) => item.status !== 'passed')
+        .map((item) => `${category}:${item.id}:${item.status}`));
+    for (const category of scoreCategories) {
+        if (scores[category] < baseline.target.each_min)
+            blockers.push(`${category}_below_${baseline.target.each_min}`);
+    }
+    if (total < baseline.target.total_min)
+        blockers.push(`total_below_${baseline.target.total_min}`);
+    const scorecard = {
+        schema: 'sks.competitor-scorecard.v1',
+        version: pkg.version || 'unknown',
+        generated_at: new Date().toISOString(),
+        scores: {
+            ...scores,
+            total
+        },
+        target: baseline.target,
+        blockers
+    };
+    return {
+        scorecard,
+        evidence,
+        ok: blockers.length === 0
+    };
+}
+async function scoreEvidence(root, entry) {
+    if (entry.path) {
+        const fullPath = path.isAbsolute(entry.path) ? entry.path : path.join(root, entry.path);
+        let data;
+        try {
+            data = await readJson(fullPath);
+        }
+        catch {
+            return { ...entry, score: 0, status: 'missing', blockers: ['artifact_missing_or_invalid_json'] };
+        }
+        const passed = artifactLooksPassing(data);
+        return {
+            ...entry,
+            score: passed ? (entry.points ?? 1) : 0,
+            status: passed ? 'passed' : 'failed',
+            blockers: passed ? [] : ['artifact_not_passing']
+        };
+    }
+    if (entry.command) {
+        return commandEvidence(root, entry);
+    }
+    return { ...entry, score: 0, status: 'unreadable', blockers: ['evidence_has_no_path_or_command'] };
+}
+function commandEvidence(root, entry) {
+    const pkgPath = path.join(root, 'package.json');
+    let scripts;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        scripts = pkg.scripts || {};
+    }
+    catch {
+        return { ...entry, score: 0, status: 'unreadable', blockers: ['package_json_unreadable'] };
+    }
+    const ok = Boolean(scripts[entry.command || '']);
+    return {
+        ...entry,
+        score: ok ? (entry.points ?? 1) : 0,
+        status: ok ? 'passed' : 'missing',
+        blockers: ok ? [] : ['package_script_missing']
+    };
+}
+function artifactLooksPassing(data) {
+    if (!data || typeof data !== 'object')
+        return false;
+    const record = data;
+    if (record.ok === true || record.passed === true || record.success === true)
+        return noFailureSignals(record);
+    if (record.status === 'passed' || record.status === 'pass' || record.status === 'ok')
+        return noFailureSignals(record);
+    if (record.status === 'blocked' || record.ok === false || record.passed === false || record.success === false)
+        return false;
+    if (Array.isArray(record.failures) && record.failures.length > 0)
+        return false;
+    if (Array.isArray(record.errors) && record.errors.length > 0)
+        return false;
+    if (Array.isArray(record.blockers) && record.blockers.length > 0)
+        return false;
+    return false;
+}
+function noFailureSignals(record) {
+    return !((Array.isArray(record.failures) && record.failures.length > 0)
+        || (Array.isArray(record.errors) && record.errors.length > 0)
+        || (Array.isArray(record.blockers) && record.blockers.length > 0)
+        || record.status === 'blocked');
+}
+//# sourceMappingURL=competitor-scorecard.js.map

package/dist/core/release/gate-timing.js

@@ -0,0 +1,103 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { runProcess, writeJsonAtomic } from '../fsx.js';
+export async function runGateTiming(root) {
+    const started = Date.now();
+    const res = await runProcess(process.execPath, ['./dist/scripts/release-gate-dag-runner.js', '--preset', 'affected', '--changed-since', 'auto', '--sla', '5m'], {
+        cwd: root,
+        timeoutMs: 5 * 60 * 1000,
+        maxOutputBytes: 512 * 1024,
+        env: {
+            SKS_RELEASE_GATE_CACHE_MEMOIZE: '1',
+            SKS_DISABLE_NETWORK: '1'
+        }
+    });
+    const totalMs = Date.now() - started;
+    const blockers = [];
+    if (res.code !== 0)
+        blockers.push(`release_gate_dag_exit_${res.code}`);
+    if (res.timedOut)
+        blockers.push('release_gate_timing_timeout');
+    const summary = latestReleaseSummary(root);
+    const slowest = parseSlowestGates(summary, res.stdout);
+    const redundantGateGroups = findRedundantBuildGroups(root);
+    if (redundantGateGroups.length > 0)
+        blockers.push('duplicate_builds_detected');
+    return {
+        schema: 'sks.gate-timing.v1',
+        ok: blockers.length === 0,
+        generated_at: new Date().toISOString(),
+        total_ms: totalMs,
+        slowest_gates: slowest,
+        duplicate_builds_detected: redundantGateGroups.length > 0,
+        redundant_gate_groups: redundantGateGroups,
+        blockers,
+        ...(res.code !== 0 || res.timedOut ? { failure_tail: { stdout: tail(res.stdout), stderr: tail(res.stderr) } } : {})
+    };
+}
+export async function writeGateTiming(root) {
+    const report = await runGateTiming(root);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'gate-timing.json'), report);
+    return report;
+}
+function parseSlowestGates(summary, stdout) {
+    if (Array.isArray(summary?.slowest_gates)) {
+        return summary.slowest_gates.slice(0, 10).map((row) => ({
+            id: String(row.id || row.gate_id || 'unknown'),
+            duration_ms: Math.round(Number(row.duration_ms || 0)),
+            cache_hit: Boolean(row.cached ?? row.cache_hit)
+        }));
+    }
+    const rows = [];
+    const text = String(stdout || '');
+    for (const match of text.matchAll(/\b([a-z0-9:_-]+)\b[^\n]*?(\d+(?:\.\d+)?)s/gi)) {
+        rows.push({ id: match[1] || 'unknown', duration_ms: Math.round(Number(match[2]) * 1000), cache_hit: /cache/i.test(match[0]) });
+    }
+    return rows.sort((a, b) => b.duration_ms - a.duration_ms).slice(0, 10);
+}
+function latestReleaseSummary(root) {
+    const dir = path.join(root, '.sneakoscope', 'reports', 'release-gates');
+    if (!fs.existsSync(dir))
+        return null;
+    const latest = fs.readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(dir, entry.name, 'summary.json'))
+        .filter((file) => fs.existsSync(file))
+        .map((file) => ({ file, mtimeMs: fs.statSync(file).mtimeMs }))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.file;
+    if (!latest)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(latest, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function findRedundantBuildGroups(root) {
+    const manifestFile = path.join(root, 'release-gates.v2.json');
+    if (!fs.existsSync(manifestFile))
+        return [];
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const groups = new Map();
+    for (const gate of Array.isArray(manifest?.gates) ? manifest.gates : []) {
+        const command = String(gate.command || '').trim().replace(/\s+/g, ' ');
+        if (!/\b(?:npm run build(?::clean|:incremental)?|tsc -p tsconfig\.json)\b/.test(command))
+            continue;
+        const ids = groups.get(command) || [];
+        ids.push(String(gate.id || 'unknown'));
+        groups.set(command, ids);
+    }
+    return [...groups.entries()].filter(([, ids]) => ids.length > 1).map(([command, gate_ids]) => ({ command, gate_ids }));
+}
+function tail(value) {
+    const text = String(value || '');
+    return text.length > 4000 ? text.slice(text.length - 4000) : text;
+}
+//# sourceMappingURL=gate-timing.js.map

package/dist/core/release-parallel-full-coverage.js

@@ -17,7 +17,7 @@ export const RELEASE_1_17_GATE_SNAPSHOT = Object.freeze([
     'release:readiness'
 ]);
 export const RELEASE_1_18_REQUIRED_GATES = Object.freeze([
-    'insane-search:provider-interface',
+    'super-search:provider-interface',
     'source-intelligence:policy',
     'source-intelligence:all-modes',
     'codex-web:adapter',

package/dist/core/retention/retention-budget.js

@@ -0,0 +1,62 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+const DEFAULT_BUDGETS = [
+    { path: '.sneakoscope/state', max_bytes: 50 * 1024 * 1024 },
+    { path: '.sneakoscope/cache', max_bytes: 250 * 1024 * 1024 },
+    { path: '.sneakoscope/cache/super-search', max_bytes: 100 * 1024 * 1024 }
+];
+export async function runRetentionBudget(root) {
+    const budgets = [];
+    const blockers = [];
+    for (const budget of DEFAULT_BUDGETS) {
+        const bytes = await sizeOf(path.join(root, budget.path));
+        const ok = bytes <= budget.max_bytes;
+        budgets.push({ path: budget.path, bytes, max_bytes: budget.max_bytes, ok });
+        if (!ok)
+            blockers.push(`retention_budget_exceeded:${budget.path}`);
+    }
+    const oversizedJsonl = await findOversizedJsonl(path.join(root, '.sneakoscope', 'missions'), 10 * 1024 * 1024);
+    for (const row of oversizedJsonl)
+        blockers.push(`jsonl_budget_exceeded:${row.path}`);
+    const report = {
+        schema: 'sks.retention-budget.v1',
+        ok: blockers.length === 0,
+        generated_at: new Date().toISOString(),
+        budgets,
+        oversized_jsonl: oversizedJsonl,
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'retention-budget.json'), report);
+    return report;
+}
+async function sizeOf(file) {
+    const stat = await fs.stat(file).catch(() => null);
+    if (!stat)
+        return 0;
+    if (stat.isFile())
+        return stat.size;
+    if (!stat.isDirectory())
+        return 0;
+    const entries = await fs.readdir(file, { withFileTypes: true }).catch(() => []);
+    let total = 0;
+    for (const entry of entries)
+        total += await sizeOf(path.join(file, entry.name));
+    return total;
+}
+async function findOversizedJsonl(dir, maxBytes) {
+    const out = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const child = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...await findOversizedJsonl(child, maxBytes));
+        else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+            const stat = await fs.stat(child).catch(() => null);
+            if (stat && stat.size > maxBytes)
+                out.push({ path: child, bytes: stat.size, max_bytes: maxBytes });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=retention-budget.js.map

package/dist/core/retention.js

@@ -109,7 +109,7 @@ export async function storageReport(root) {
     report.total_human = formatBytes(report.total_bytes);
     return report;
 }
-async function lightweightStorageReport(root) {
+export async function lightweightStorageReport(root) {
     const sks = path.join(root, '.sneakoscope');
     const report = {
         root,

package/dist/core/routes/constants.js

@@ -9,7 +9,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|review|ui|research|seo-geo-optimizer|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|insane-search|ultra-search|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|memory|wrongness|code-structure|proof-field|skill-dream|rust';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|review|ui|research|seo-geo-optimizer|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|super-search|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|memory|wrongness|code-structure|proof-field|skill-dream|rust';
 export const RECOMMENDED_MCP_SERVERS = [
     {
         id: 'context7',
@@ -30,7 +30,7 @@ export const RECOMMENDED_SKILLS = [
     'pipeline-runner',
     'solution-scout',
     'context7-docs',
-    'ultra-search',
+    'super-search',
     'search-visibility-core',
     'seo-geo-optimizer',
     'autoresearch-loop',