sneakoscope 4.8.7 → 5.3.0

package/dist/scripts/research-final-reviewer-blackbox.js

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const research = await importDist('core/research.js');
-const reviewer = await importDist('core/research/research-final-reviewer.js');
-const fsx = await importDist('core/fsx.js');
-const badDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-bad-'));
-await research.writeResearchPlan(badDir, 'bad final reviewer fixture', { missionId: 'M-FINAL-BAD' });
-await fsx.writeTextAtomic(path.join(badDir, 'research-report.md'), '# Bad\n\nToo short.\n');
-const bad = await reviewer.runResearchFinalReviewer(badDir, { codexRequired: true });
-assertGate(bad.approved === false, 'static failure must not approve final review', bad);
-const templateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-template-'));
-const templatePlan = await research.writeResearchPlan(templateDir, 'template final reviewer fixture', { missionId: 'M-FINAL-TEMPLATE' });
-await research.writeMockResearchResult(templateDir, templatePlan);
-await fsx.writeTextAtomic(path.join(templateDir, 'research-report.md'), [
-    '# SKS Research Report',
-    '',
-    '## Question',
-    'Runtime evidence note: This paragraph exists to make report quality measurable.',
-    '',
-    '## Methodology',
-    'Runtime evidence note: This paragraph exists to make report quality measurable.',
-    '',
-    '## Source Map',
-    'mock-source-1 mock-source-2 mock-source-3 mock-source-4 mock-source-5 mock-source-6 mock-source-7 mock-source-8.',
-    '',
-    '## Key Claims',
-    '- mock-claim-1 cites mock-source-1 and mock-counter-1.',
-    '',
-    '## Evidence Matrix Summary',
-    Array.from({ length: 36 }, () => 'Runtime evidence note: This paragraph exists to make report quality measurable while deterministic fixture text repeats the same sentence for mock-claim-1 using mock-source-1 and mock-counter-1.').join('\n\n'),
-    '',
-    '## Counterevidence',
-    'mock-counter-1 and mock-counter-2 challenge the report.',
-    '',
-    '## Falsification',
-    'Runtime evidence note: This paragraph exists to make report quality measurable.',
-    '',
-    '## Implementation Blueprint',
-    'Runtime evidence note: This paragraph exists to make report quality measurable.',
-    '',
-    '## Experiment / Validation Plan',
-    'Runtime evidence note: This paragraph exists to make report quality measurable.',
-    '',
-    '## Limitations',
-    'Runtime evidence note: This paragraph exists to make report quality measurable.',
-    '',
-    '## References',
-    '- mock-source-1',
-    '- mock-counter-1'
-].join('\n\n'));
-await fsx.rmrf(path.join(templateDir, 'research-final-review.codex.json'));
-const template = await reviewer.runResearchFinalReviewer(templateDir, { codexRequired: true });
-assertGate(template.approved === false, 'template/repeated report must not approve final review', template);
-assertGate((template.blockers || []).some((reason) => String(reason).includes('research_report_repeated_paragraphs') || String(reason).includes('research_report_template_phrase_hit')), 'template blockers must include repetition/template reasons', template);
-const goodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-good-'));
-const plan = await research.writeResearchPlan(goodDir, 'good final reviewer fixture', { missionId: 'M-FINAL-GOOD' });
-await research.writeMockResearchResult(goodDir, plan);
-const good = JSON.parse(fs.readFileSync(path.join(goodDir, 'research-final-review.json'), 'utf8'));
-assertGate(good.approved === true, 'complete package must approve final review with mock Codex reviewer', good);
-assertGate(good.codex_review?.verdict === 'approve', 'merged final review must include Codex/mock approval', good);
-assertGate(good.codex_review?.template_like_prose === false, 'mock Codex review must preserve template_like_prose=false', good);
-assertGate(good.codex_review?.source_density_ok === true, 'mock Codex review must preserve source_density_ok=true', good);
-assertGate(good.codex_review?.implementation_concreteness_ok === true, 'mock Codex review must preserve implementation_concreteness_ok=true', good);
-assertGate(good.codex_review?.evidence_bound_synthesis_ok === true, 'mock Codex review must preserve evidence_bound_synthesis_ok=true', good);
-emitGate('research:final-reviewer-blackbox', { bad_dir: badDir, template_dir: templateDir, good_dir: goodDir });
-//# sourceMappingURL=research-final-reviewer-blackbox.js.map

package/dist/scripts/research-stage-cycle-runtime-blackbox.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const research = await importDist('core/research.js');
-const workGraph = await importDist('core/research/research-work-graph.js');
-const cycleRunner = await importDist('core/research/research-cycle-runner.js');
-const quality = await importDist('core/research/research-report-quality.js');
-const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-stage-cycle-'));
-const plan = await research.writeResearchPlan(dir, 'stage cycle runtime blackbox', { missionId: 'M-STAGE-RUNTIME' });
-const graph = workGraph.buildResearchWorkGraph(plan);
-const result = await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
-const shardDir = path.join(dir, 'research', 'cycle-1', 'source-shards');
-const shardFiles = fs.readdirSync(shardDir).filter((file) => file.endsWith('.json'));
-const sourceLedger = JSON.parse(fs.readFileSync(path.join(dir, 'source-ledger.json'), 'utf8'));
-const sourceQuality = JSON.parse(fs.readFileSync(path.join(dir, 'source-quality-report.json'), 'utf8'));
-const claimMatrix = JSON.parse(fs.readFileSync(path.join(dir, 'claim-evidence-matrix.json'), 'utf8'));
-const blueprint = JSON.parse(fs.readFileSync(path.join(dir, 'implementation-blueprint.json'), 'utf8'));
-const finalReview = JSON.parse(fs.readFileSync(path.join(dir, 'research-final-review.json'), 'utf8'));
-const reportQuality = quality.analyzeResearchReportQuality(fs.readFileSync(path.join(dir, 'research-report.md'), 'utf8'));
-const cycleRecord = JSON.parse(fs.readFileSync(path.join(dir, 'research-cycle-runner.json'), 'utf8'));
-assertGate(result.status === 'passed', 'mock stage cycle must pass', result);
-assertGate(shardFiles.length >= 8, 'source shard outputs must exist', { shardFiles });
-assertGate(fs.existsSync(path.join(dir, 'source-ledger.json')), 'source-ledger merge must exist');
-assertGate(sourceLedger.sources.length + sourceLedger.counterevidence_sources.length >= 12, 'source-ledger must include at least 12 sources', sourceLedger);
-assertGate(sourceQuality.ok === true, 'source-quality-report must pass', sourceQuality);
-assertGate(fs.existsSync(path.join(dir, 'claim-evidence-matrix.json')), 'claim matrix must exist');
-assertGate(claimMatrix.key_claim_ids.length >= 8, 'claim matrix must include at least 8 key claims', claimMatrix);
-assertGate(fs.existsSync(path.join(dir, 'implementation-blueprint.json')), 'blueprint must exist');
-assertGate(blueprint.repository_aware === true, 'blueprint must be repository aware', blueprint);
-assertGate(fs.existsSync(path.join(dir, 'research-synthesis-output.json')), 'synthesis output must exist');
-assertGate(reportQuality.ok === true, 'research report must pass repetition detector and density checks', reportQuality);
-assertGate(fs.existsSync(path.join(dir, 'research-final-review.json')), 'final review must exist');
-assertGate(finalReview.approved === true, 'final review must approve complete mock cycle', finalReview);
-assertGate(result.parallelism?.max_observed_parallel >= 2, 'source shards must execute with observed parallelism', result.parallelism);
-assertGate(cycleRecord.legacy_final_md_loop === false, 'stage cycle must not use legacy final.md loop', cycleRecord);
-emitGate('research:stage-cycle-runtime-blackbox', { dir, parallelism: result.parallelism, shard_count: shardFiles.length, report_quality: reportQuality });
-//# sourceMappingURL=research-stage-cycle-runtime-blackbox.js.map

package/dist/scripts/research-synthesis-writer-blackbox.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const research = await importDist('core/research.js');
-const workGraph = await importDist('core/research/research-work-graph.js');
-const cycleRunner = await importDist('core/research/research-cycle-runner.js');
-const quality = await importDist('core/research/research-report-quality.js');
-const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-synthesis-blackbox-'));
-const plan = await research.writeResearchPlan(dir, 'synthesis writer blackbox', { missionId: 'M-SYNTHESIS-BLACKBOX' });
-const graph = workGraph.buildResearchWorkGraph(plan);
-const result = await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 6, mock: true });
-const synthesis = JSON.parse(fs.readFileSync(path.join(dir, 'research-synthesis-output.json'), 'utf8'));
-const reportText = fs.readFileSync(path.join(dir, 'research-report.md'), 'utf8');
-const reportQuality = quality.analyzeResearchReportQuality(reportText);
-assertGate(result.status === 'passed', 'mock research cycle must pass synthesis blackbox', result);
-assertGate(synthesis.schema === 'sks.research-synthesis-output.v1', 'synthesis output artifact must use v1 schema', synthesis);
-assertGate(synthesis.quality_signals.report_word_count >= 2200, 'synthesis output must meet report word floor', synthesis.quality_signals);
-assertGate(synthesis.quality_signals.unique_source_ids_cited >= 8, 'synthesis output must cite at least 8 unique source ids', synthesis.quality_signals);
-assertGate(reportQuality.ok === true, 'blackbox report must pass report quality', reportQuality);
-emitGate('research:synthesis-writer-blackbox', { dir, synthesis: synthesis.quality_signals, parallelism: result.parallelism });
-//# sourceMappingURL=research-synthesis-writer-blackbox.js.map

package/dist/scripts/route-blackbox-realism-check.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-import path from 'node:path';
-const lib = fs.readFileSync(path.join(root, 'src', 'scripts', 'agent-route-blackbox-lib.ts'), 'utf8');
-const proof = fs.readFileSync(path.join(root, 'src', 'core', 'agents', 'agent-proof-evidence.ts'), 'utf8');
-const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-for (const token of ['runActualAgentBackfillBlackbox', 'runActualTeamBackfillBlackbox', 'runActualResearchBackfillBlackbox', 'runActualQaBackfillBlackbox']) {
-    assertGate(lib.includes(token), `route blackbox helper missing ${token}`);
-}
-for (const token of ['actual_agent_command', 'actual_team_command', 'actual_research_command', 'actual_qa_command']) {
-    assertGate(lib.includes(token), `route blackbox helper missing exact kind ${token}`);
-}
-assertGate(proof.includes('non_agent_route_used_generic_agent_run_route_standin'), 'proof must block non-agent route stand-ins');
-assertGate(proof.includes('real_route_command_used'), 'proof must record real_route_command_used');
-assertGate(Boolean(packageJson.scripts['dfix:fixture']), 'DFix route fixture gate must exist');
-assertGate(Boolean(packageJson.scripts['ppt:full-e2e-blackbox']), 'PPT route blackbox gate must exist');
-assertGate(Boolean(packageJson.scripts['ux-review:imagegen-blackbox']), 'UX route blackbox gate must exist');
-emitGate('route:blackbox-realism', { actual_route_helpers: 4, standin_blocker: true });
-//# sourceMappingURL=route-blackbox-realism-check.js.map

package/dist/scripts/scheduler-resource-claim-blackbox.js

@@ -1,24 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
-import { importDist } from './sks-1-18-gate-lib.js';
-const tmp = await makeTempRoot('sks-scheduler-claim-');
-await writeText(path.join(tmp, 'package.json'), JSON.stringify({ version: '4.0.2', scripts: { 'secret:one': 'node -e "setTimeout(()=>process.exit(0),20)"', 'zellij:one': 'node -e "setTimeout(()=>process.exit(0),20)"' } }, null, 2));
-await writeText(path.join(tmp, 'package-lock.json'), JSON.stringify({ lockfileVersion: 3 }, null, 2));
-await writeText(path.join(tmp, 'release-gates.v2.json'), JSON.stringify({ schema: 'sks.release-gates.v2', gates: [gate('secret:one', ['secret-sensitive']), gate('zellij:one', ['zellij-real'])] }, null, 2));
-const scheduler = await importDist('core/release/extreme-parallel-scheduler.js');
-const report = await scheduler.executeExtremeSchedule({
-    root: tmp,
-    graph: { schema: 'sks.triwiki-affected-graph.v1', root: tmp, tier: 'confidence', changed_files: [], affected_modules: [], gate_packs: ['secret', 'zellij'], gates: ['secret:one', 'zellij:one'], release_equivalent_within_scope: true, confidence: 'affected-release-equivalent', conservative_reason: null, reused_proofs: [], invalidated_proofs: [], required_new_proofs: [] },
-    slaMs: 30_000,
-    budget: { schema: 'sks.resource-class-budget.v1', cpu_light: 4, cpu_heavy: 1, io_light: 4, io_heavy: 1, fs_read: 4, network: 1, remote_model_real: 1, zellij_real: 1, browser_real: 1, secret_sensitive: 1 },
-    useProofBank: false
-});
-const timeline = JSON.parse(await fs.readFile(report.resource_claim_timeline, 'utf8'));
-assertGate(report.ok === true && report.executed_packs.length === 2, 'scheduler must execute selected packs', report);
-assertGate(timeline.events.some((event) => event.event === 'claim') && timeline.events.some((event) => event.event === 'release'), 'scheduler must write claim/release timeline', timeline);
-emitGate('scheduler:resource-claim-blackbox', { packs: report.executed_packs.length, timeline: timeline.events.length });
-function gate(id, resource) {
-    return { id, command: `npm run ${id} --silent`, deps: [], resource, side_effect: 'hermetic', timeout_ms: 5000, cache: { enabled: false, inputs: ['package.json'] }, isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' }, preset: ['release'] };
-}
-//# sourceMappingURL=scheduler-resource-claim-blackbox.js.map

package/dist/scripts/seo-cli-blackbox-check.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, runSks, runSksJson } from './search-visibility-gate-lib.js';
-const commands = runSksJson(['commands', '--json']).json;
-assertGate(commands.commands.some((row) => row.name === 'seo-geo-optimizer' && /unified SEO\/GEO optimizer/i.test(row.description)), 'commands --json must expose seo-geo-optimizer');
-assertGate(!commands.commands.some((row) => row.name === 'seo' || row.name === 'geo'), 'commands --json must not expose split seo/geo command surfaces');
-const optimizerUsage = runSks(['usage', 'seo-geo-optimizer']);
-assertGate(/sks seo-geo-optimizer \[seo\|geo\] doctor\|audit\|plan\|apply\|verify\|status\|rollback\|fixture/.test(optimizerUsage.stdout), 'usage seo-geo-optimizer must expose unified lifecycle');
-const doctor = runSksJson(['seo-geo-optimizer', 'doctor', '--mode', 'seo', '--json']).json;
-assertGate(doctor.route === '$SEO-GEO-OPTIMIZER' && doctor.schema === 'sks.search-visibility.doctor-command.v1', 'optimizer seo doctor must preserve unified route identity', doctor);
-const invalid = runSks(['seo-geo-optimizer', 'nonsense-subcommand'], { allowFailure: true });
-assertGate(invalid.status === 2 && /Usage: sks seo-geo-optimizer/.test(invalid.stderr), 'invalid optimizer subcommand must exit 2 with usage', {
-    status: invalid.status,
-    stdout: invalid.stdout,
-    stderr: invalid.stderr,
-});
-emitGate('seo:cli-blackbox', { adapter: doctor.adapter, confidence: doctor.confidence });
-//# sourceMappingURL=seo-cli-blackbox-check.js.map

package/dist/scripts/sks-3110-all-feature-regression-blackbox.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { root as repoRoot } from './sks-1-18-gate-lib.js';
-import { assertGate, emitGate, makeTempRoot, writeManagedCoreSkill, writeText, writeUserSkill } from './sks-3-1-8-check-lib.js';
-import { syncCoreSkillsIntegrity } from '../core/codex-native/core-skill-integrity.js';
-import { dedupeProjectSkills } from '../core/codex-native/project-skill-dedupe.js';
-import { repairNativeCapabilities } from '../core/codex-native/native-capability-repair.js';
-import { withSecretPreservationGuard } from '../core/config/secret-preservation.js';
-import { runProcess } from '../core/fsx.js';
-import { buildReleaseGateScriptParityReport } from './release-gate-script-parity-check.js';
-const root = await makeTempRoot('sks-3110-all-feature-');
-process.env.CODEX_HOME = path.join(root, 'codex-home');
-const parity = buildReleaseGateScriptParityReport();
-const coreA = await syncCoreSkillsIntegrity({ root, apply: true });
-const coreB = await syncCoreSkillsIntegrity({ root, apply: true });
-const loopPath = path.join(root, '.agents', 'skills', 'loop', 'SKILL.md');
-await fs.appendFile(loopPath, '\ncorruption\n', 'utf8');
-const coreC = await syncCoreSkillsIntegrity({ root, apply: true });
-await writeManagedCoreSkill(root, '.codex/skills', 'loop');
-const dedupeA = await dedupeProjectSkills({ root, fix: true, yes: true });
-await writeUserSkill(root, '.agents/skills', 'user-loop-a', 'Loop');
-await writeUserSkill(root, '.codex/skills', 'user-loop-b', 'loop');
-const dedupeB = await dedupeProjectSkills({ root, fix: true, yes: false });
-const dedupeC = await dedupeProjectSkills({ root, fix: true, yes: true, quarantineUserDuplicates: true });
-process.env.SKS_CHROME_EXTENSION_READY = '1';
-process.env.SKS_COMPUTER_USE_CAPABILITY = 'verified';
-const repairable = await repairNativeCapabilities({ root, fix: true, yes: true, fixture: 'all-repairable' });
-delete process.env.SKS_CHROME_EXTENSION_READY;
-delete process.env.SKS_COMPUTER_USE_CAPABILITY;
-const manual = await repairNativeCapabilities({ root, fix: true, yes: true, fixture: 'manual-required' });
-const envFile = path.join(root, '.env.local');
-await writeText(envFile, 'NEXT_PUBLIC_SUPABASE_ANON_KEY=all-feature-secret\nSUPABASE_SERVICE_ROLE_KEY=service-secret\n');
-const deleteSecretGuard = await expectSecretGuardRestored('delete-secret-fixture', async () => {
-    await fs.writeFile(envFile, 'NEXT_PUBLIC_SUPABASE_ANON_KEY=all-feature-secret\n', 'utf8');
-});
-let text = await fs.readFile(envFile, 'utf8');
-assertGate(text.includes('SUPABASE_SERVICE_ROLE_KEY=service-secret'), 'delete fixture must restore missing Supabase service key', text);
-assertGate(deleteSecretGuard.includes('SUPABASE_SERVICE_ROLE_KEY:missing'), 'delete fixture must report restored missing service key', deleteSecretGuard);
-const changeSecretGuard = await expectSecretGuardRestored('change-secret-fixture', async () => {
-    await fs.writeFile(envFile, 'NEXT_PUBLIC_SUPABASE_ANON_KEY=changed\nSUPABASE_SERVICE_ROLE_KEY=service-secret\n', 'utf8');
-});
-text = await fs.readFile(envFile, 'utf8');
-assertGate(text.includes('NEXT_PUBLIC_SUPABASE_ANON_KEY=all-feature-secret'), 'change fixture must rollback Supabase anon key mutation', text);
-assertGate(changeSecretGuard.includes('NEXT_PUBLIC_SUPABASE_ANON_KEY:changed'), 'change fixture must report restored changed anon key', changeSecretGuard);
-const doctorRoot = await makeTempRoot('sks-3110-doctor-fix-');
-await writeText(path.join(doctorRoot, 'package.json'), '{"name":"sks-3110-doctor-fixture","private":true}\n');
-await writeText(path.join(doctorRoot, '.env.local'), 'NEXT_PUBLIC_SUPABASE_ANON_KEY=doctor-secret\n');
-const fixtureBin = path.join(doctorRoot, 'codex-fixture');
-await writeText(fixtureBin, '#!/usr/bin/env node\nconsole.log(JSON.stringify({ checks: { fixture: { category: "runtime", status: "ok" } } }));\n');
-await fs.chmod(fixtureBin, 0o755);
-const doctor = await runProcess(process.execPath, [
-    path.join(repoRoot, 'dist', 'bin', 'sks.js'),
-    'doctor',
-    '--fix',
-    '--local-only',
-    '--yes',
-    '--json',
-    '--codex-bin',
-    fixtureBin
-], {
-    cwd: doctorRoot,
-    env: {
-        HOME: path.join(doctorRoot, 'home'),
-        CODEX_HOME: path.join(doctorRoot, 'codex-home'),
-        SKS_GLOBAL_ROOT: path.join(doctorRoot, 'global-sks'),
-        SKS_CHROME_EXTENSION_READY: '1',
-        SKS_COMPUTER_USE_CAPABILITY: 'verified'
-    },
-    timeoutMs: 120_000,
-    maxOutputBytes: 512 * 1024
-});
-const doctorGuardReport = JSON.parse(await fs.readFile(path.join(doctorRoot, '.sneakoscope', 'reports', 'secret-preservation-guard.json'), 'utf8'));
-const guardReport = JSON.parse(await fs.readFile(path.join(root, '.sneakoscope', 'reports', 'secret-preservation-guard.json'), 'utf8'));
-const reportText = JSON.stringify(await readReports(path.join(root, '.sneakoscope', 'reports')));
-assertGate(parity.ok === true, 'release gate/script/dist parity must pass inside all-feature regression', parity);
-assertGate(coreA.installed_count > 0, 'core skills must install in temp root', coreA);
-assertGate(coreB.installed_count === 0 && coreB.restored_count === 0, 'second core sync must be idempotent', coreB);
-assertGate(coreC.restored_count > 0, 'corrupt managed core skill must restore', coreC);
-assertGate(dedupeA.actions.some((action) => action.action === 'quarantined'), 'managed duplicate must quarantine', dedupeA);
-assertGate(dedupeB.blockers.some((blocker) => blocker.includes('user_duplicate_requires_confirmation')), 'unconfirmed user duplicate must be manual_required', dedupeB);
-assertGate(dedupeC.active_unique_by_canonical_name === true, 'confirmed user duplicate quarantine must restore active uniqueness', dedupeC);
-assertGate(repairable.ok === true, 'all-repairable native fixture must pass postcheck', repairable);
-assertGate(manual.capabilities.some((state) => state.repairability === 'manual-required' && state.after !== 'verified'), 'manual native fixture must not false-verify', manual);
-assertGate(guardReport.rollback_attempted === true && guardReport.rollback_ok === true, 'secret guard must record rollback success', guardReport);
-assertGate(!reportText.includes('all-feature-secret') && !reportText.includes('service-secret'), 'reports must not contain raw secret literals');
-assertGate(doctor.code === 0 || doctor.code === 1, 'doctor --fix fixture must complete with a bounded readiness exit code under secret guard', { code: doctor.code, stdout: doctor.stdout.slice(-2000), stderr: doctor.stderr.slice(-2000) });
-assertGate(doctor.stdout.includes('"schema"') && doctor.stdout.includes('"command_aliases"'), 'doctor --fix fixture must emit structured doctor output', doctor.stdout.slice(-2000));
-assertGate(doctorGuardReport.ok === true && doctorGuardReport.raw_values_recorded === false, 'doctor --fix guard report must be sanitized and successful', doctorGuardReport);
-emitGate('sks:3110-all-feature-regression', {
-    core_installed: coreA.installed_count,
-    manual_native_count: manual.capabilities.filter((state) => state.repairability === 'manual-required' && state.after !== 'verified').length
-});
-async function readReports(dir) {
-    const out = {};
-    const rows = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-    for (const row of rows) {
-        if (!row.isFile() || !row.name.endsWith('.json'))
-            continue;
-        out[row.name] = await fs.readFile(path.join(dir, row.name), 'utf8');
-    }
-    return out;
-}
-async function expectSecretGuardRestored(operation, fn) {
-    try {
-        await withSecretPreservationGuard(root, operation, fn);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        assertGate(message.startsWith('secret_preservation_restored:'), `${operation} must be restored and reported by secret guard`, message);
-        return message;
-    }
-    assertGate(false, `${operation} must throw after restoring protected secret mutation`, {});
-    return '';
-}
-//# sourceMappingURL=sks-3110-all-feature-regression-blackbox.js.map

package/dist/scripts/sks-3112-all-feature-regression-blackbox.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, exists, readJson } from './sks-1-18-gate-lib.js';
-const scripts = readJson('package.json').scripts || {};
-const required = [
-    'release:gate-script-parity',
-    'codex:0140-capability',
-    'codex:0140-feature-probes',
-    'doctor:fix-production-blackbox',
-    'doctor:startup-config-repair-blackbox',
-    'doctor:context7-mcp-repair-blackbox',
-    'doctor:supabase-mcp-repair-blackbox',
-    'native-capability:postcheck',
-    'secret:preservation-guard',
-    'secret:supabase-preservation-blackbox',
-    'update:preserves-supabase-keys',
-    'core-skill:no-drift',
-    'skill:dedupe-blackbox',
-    'release:dag-full-coverage'
-];
-for (const id of required)
-    assertGate(Boolean(scripts[id]), `3.1.12 regression required script missing: ${id}`);
-for (const file of [
-    'src/core/doctor/doctor-transaction.ts',
-    'src/core/codex-control/codex-0140-capability.ts',
-    'src/core/config/secret-preservation.ts'
-])
-    assertGate(exists(file), `3.1.12 regression required file missing: ${file}`);
-emitGate('sks:3112-all-feature-regression', { scenarios: required.length });
-//# sourceMappingURL=sks-3112-all-feature-regression-blackbox.js.map

package/dist/scripts/sks-3113-all-feature-regression-blackbox.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, exists, readJson } from './sks-1-18-gate-lib.js';
-import { REQUIRED_3113_RELEASE_IDS } from './release-3113-required-gates.js';
-const scripts = readJson('package.json').scripts || {};
-for (const id of REQUIRED_3113_RELEASE_IDS)
-    assertGate(Boolean(scripts[id]), `3.1.13 regression required script missing: ${id}`);
-for (const file of [
-    'src/core/codex-control/codex-0140-usage-parser.ts',
-    'src/core/doctor/doctor-transaction.ts',
-    'src/core/codex/agent-config-file-repair.ts',
-    'src/core/mcp/mcp-config-preservation.ts',
-    'src/core/config/secret-preservation.ts',
-    'src/core/codex-native/native-capability-postcheck.ts'
-])
-    assertGate(exists(file), `3.1.13 regression required file missing: ${file}`);
-emitGate('sks:3113-all-feature-regression', { scenarios: REQUIRED_3113_RELEASE_IDS.length });
-//# sourceMappingURL=sks-3113-all-feature-regression-blackbox.js.map

package/dist/scripts/sks-400-all-feature-regression-blackbox.js

@@ -1,21 +0,0 @@
-// @ts-nocheck
-import { assertGate, emitGate, packageScripts, readText } from './sks-1-18-gate-lib.js';
-const scripts = packageScripts();
-const required = [
-    'triwiki:proof-bank',
-    'triwiki:affected-graph',
-    'gate-pack:runner',
-    'scheduler:extreme-parallel',
-    'pipeline:five-minute-sla',
-    'build-once:runner',
-    'probes:memoization',
-    'doctor:dirty-repair',
-    'legacy:gate-inventory',
-    'certificate:sla'
-];
-for (const id of required)
-    assertGate(Boolean(scripts[id]), `4.0.0 script missing: ${id}`);
-const changelog = readText('CHANGELOG.md');
-assertGate(changelog.includes('[4.0.0]'), 'CHANGELOG must include 4.0.0 entry');
-emitGate('sks:400-all-feature-regression', { scripts: required.length });
-//# sourceMappingURL=sks-400-all-feature-regression-blackbox.js.map

package/dist/scripts/sks-400-extreme-parallel-blackbox.js

@@ -1,8 +0,0 @@
-// @ts-nocheck
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const scheduler = await importDist('core/release/extreme-parallel-scheduler.js');
-const schedule = scheduler.planExtremeParallelSchedule(root);
-assertGate(schedule.sequential_ms > 0 && schedule.critical_path_ms > 0, 'extreme scheduler blackbox must estimate work', schedule);
-assertGate(schedule.critical_path_ms <= schedule.sequential_ms, 'critical path must not exceed sequential path', schedule);
-emitGate('scheduler:extreme-parallel-blackbox', { reduction_ratio: schedule.reduction_ratio, batches: schedule.batches.length });
-//# sourceMappingURL=sks-400-extreme-parallel-blackbox.js.map

package/dist/scripts/sks-400-five-minute-blackbox.js

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const graphMod = await importDist('core/triwiki/triwiki-affected-graph.js');
-const sla = await importDist('core/release/sla-scheduler.js');
-const graph = graphMod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/core/triwiki/triwiki-proof-bank.ts'], tier: 'affected' });
-const plan = sla.planFiveMinuteSla(root, graph);
-assertGate(plan.certificate.sla_ms === 300000 && plan.graph.release_equivalent_within_scope === true, 'five-minute TriWiki blackbox must produce release-equivalent certificate', plan);
-emitGate('pipeline:five-minute-triwiki-blackbox', { gates: plan.graph.gates.length, ok: plan.ok });
-//# sourceMappingURL=sks-400-five-minute-blackbox.js.map

package/dist/scripts/sks-400-legacy-purge-blackbox.js

@@ -1,8 +0,0 @@
-// @ts-nocheck
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const registry = readText('src/cli/command-registry.ts');
-const migration = readText('docs/sks-4-migration.md');
-assertGate(!registry.includes('LEGACY_COMMAND_ALIASES = {\\n  auth'), 'legacy alias block must be destructive-purged');
-assertGate(migration.includes('No silent legacy fallback'), 'migration doc must explain no silent fallback');
-emitGate('legacy:purge-blackbox');
-//# sourceMappingURL=sks-400-legacy-purge-blackbox.js.map

package/dist/scripts/sks-401-all-feature-regression-blackbox.js

@@ -1,46 +0,0 @@
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-import { REQUIRED_4001_RELEASE_IDS } from './release-4001-required-gates.js';
-import { REQUIRED_4002_RELEASE_IDS } from './release-4002-required-gates.js';
-import fs from 'node:fs';
-import path from 'node:path';
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const manifest = JSON.parse(fs.readFileSync(path.join(root, 'release-gates.v2.json'), 'utf8'));
-const ids = new Set(manifest.gates.map((gate) => gate.id));
-const required = [...REQUIRED_4001_RELEASE_IDS, ...REQUIRED_4002_RELEASE_IDS];
-const missing = required.filter((id) => !pkg.scripts?.[id] || !ids.has(id));
-assertGate(compareSemver(pkg.version || '0.0.0', '4.0.2') >= 0, 'package version must be at least 4.0.2 after production completion bump', pkg.version);
-assertGate(missing.length === 0, '4.0.1/4.0.2 required scripts/gates missing', missing);
-const graphMod = await importDist('core/triwiki/triwiki-affected-graph.js');
-const schedulerMod = await importDist('core/release/extreme-parallel-scheduler.js');
-const dirtyMod = await importDist('core/doctor/doctor-dirty-planner.js');
-const certificateMod = await importDist('core/triwiki/triwiki-sla-certificate.js');
-const graph = graphMod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/core/triwiki/triwiki-proof-card.ts'], tier: 'confidence' });
-const plan = schedulerMod.planExtremeParallelSchedule(root, graph);
-const dirty = dirtyMod.planDoctorDirtyRepair(root, ['context7']);
-const certificate = certificateMod.buildTriWikiSlaCertificate({
-    graph,
-    mode: 'actual',
-    slaMs: 300_000,
-    estimatedCriticalPathMs: Math.max(1, plan.critical_path_ms || 1),
-    estimatedSequentialMs: Math.max(1, plan.sequential_ms || plan.critical_path_ms || 1),
-    actualDurationMs: 1,
-    executedPacks: Math.max(1, graph.gate_packs.length),
-    reusedProofs: graph.reused_proofs.length,
-    invalidatedProofs: graph.invalidated_proofs.length
-});
-assertGate(graph.gate_packs.length > 0, 'regression must compute affected graph gate packs', graph);
-assertGate(plan.schema === 'sks.extreme-parallel-scheduler.v1', 'regression must exercise scheduler planning', plan);
-assertGate(dirty.schema === 'sks.doctor-dirty-plan.v2', 'regression must exercise semantic dirty doctor', dirty);
-assertGate(certificate.mode === 'actual' && certificate.sla_met === true, 'regression must create actual SLA certificate', certificate);
-emitGate('sks:401-all-feature-regression', { required: required.length, packs: graph.gate_packs.length });
-function compareSemver(left, right) {
-    const a = left.split('.').map((part) => Number.parseInt(part, 10) || 0);
-    const b = right.split('.').map((part) => Number.parseInt(part, 10) || 0);
-    for (let i = 0; i < 3; i += 1) {
-        const diff = (a[i] || 0) - (b[i] || 0);
-        if (diff !== 0)
-            return diff;
-    }
-    return 0;
-}
-//# sourceMappingURL=sks-401-all-feature-regression-blackbox.js.map

package/dist/scripts/sks-401-five-minute-actual-blackbox.js

@@ -1,23 +0,0 @@
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const graphMod = await importDist('core/triwiki/triwiki-affected-graph.js');
-const certMod = await importDist('core/triwiki/triwiki-sla-certificate.js');
-const graph = graphMod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/core/triwiki/triwiki-sla-certificate.ts'], tier: 'confidence' });
-const cert = certMod.buildTriWikiSlaCertificate({
-    graph,
-    slaMs: 300000,
-    estimatedCriticalPathMs: 1000,
-    estimatedSequentialMs: 2000,
-    mode: 'actual',
-    actualDurationMs: 1000,
-    executedGates: 1,
-    executedPacks: 1,
-    reusedProofs: 0,
-    invalidatedProofs: graph.invalidated_proofs.length,
-    newProofs: 1,
-    skippedAsValidCache: 0,
-    skippedAsUnaffected: 0,
-    backgroundFullRelease: true
-});
-assertGate(cert.mode === 'actual' && cert.ok === true && cert.actual_duration_ms === 1000, 'actual SLA certificate must include execution stats', cert);
-emitGate('sks:401-five-minute-actual-blackbox', { mode: cert.mode, actual_duration_ms: cert.actual_duration_ms });
-//# sourceMappingURL=sks-401-five-minute-actual-blackbox.js.map

package/dist/scripts/sks-402-all-feature-regression-blackbox.js

@@ -1,9 +0,0 @@
-import { assertGate, emitGate, packageScripts, readJson } from './sks-1-18-gate-lib.js';
-import { REQUIRED_4002_RELEASE_IDS } from './release-4002-required-gates.js';
-const scripts = packageScripts();
-const manifest = readJson('release-gates.v2.json');
-const gateIds = new Set(manifest.gates.map((gate) => gate.id));
-const missing = REQUIRED_4002_RELEASE_IDS.filter((id) => !scripts[id] || !gateIds.has(id));
-assertGate(missing.length === 0, '4.0.2 required scripts/gates missing', missing);
-emitGate('sks:402-all-feature-regression', { required: REQUIRED_4002_RELEASE_IDS.length });
-//# sourceMappingURL=sks-402-all-feature-regression-blackbox.js.map

package/dist/scripts/sks-402-five-minute-real-blackbox.js

@@ -1,22 +0,0 @@
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const graphMod = await importDist('core/triwiki/triwiki-affected-graph.js');
-const schedulerMod = await importDist('core/release/extreme-parallel-scheduler.js');
-const certificateMod = await importDist('core/triwiki/triwiki-sla-certificate.js');
-const graph = graphMod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/core/triwiki/triwiki-proof-card.ts'], tier: 'confidence' });
-const plan = schedulerMod.planExtremeParallelSchedule(root, graph);
-const certificate = certificateMod.buildTriWikiSlaCertificate({
-    graph,
-    mode: 'actual',
-    slaMs: 300_000,
-    estimatedCriticalPathMs: Math.max(1, plan.critical_path_ms || 1),
-    estimatedSequentialMs: Math.max(1, plan.sequential_ms || plan.critical_path_ms || 1),
-    actualDurationMs: Math.max(1, Math.min(299_000, plan.critical_path_ms || 1)),
-    executedPacks: Math.max(1, graph.gate_packs.length),
-    reusedProofs: graph.reused_proofs.length,
-    invalidatedProofs: graph.invalidated_proofs.length,
-    skippedAsUnaffected: Math.max(1, plan.batches.length)
-});
-assertGate(certificate.mode === 'actual' && certificate.sla_met === true, '4.0.2 five-minute blackbox must create actual SLA certificate', certificate);
-assertGate(graph.gate_packs.length > 0 && graph.required_new_proofs.length >= 0, '4.0.2 five-minute blackbox must compute affected packs', graph);
-emitGate('sks:402-five-minute-real-blackbox', { packs: graph.gate_packs.length, sla_met: certificate.sla_met });
-//# sourceMappingURL=sks-402-five-minute-real-blackbox.js.map

package/dist/scripts/sksd-warm-cache-blackbox.js

@@ -1,12 +0,0 @@
-// @ts-nocheck
-import { assertGate, emitGate, makeTempRoot } from './sks-3-1-8-check-lib.js';
-import { importDist } from './sks-1-18-gate-lib.js';
-const tmp = await makeTempRoot('sksd-warm-');
-const mod = await importDist('core/daemon/sksd-client.js');
-const warm = mod.runSksdClient(tmp, 'warm');
-const status = mod.runSksdClient(tmp, 'status');
-const proofBank = mod.handleSksdRequest(tmp, { type: 'proof-bank-status', root: tmp });
-assertGate(warm.status === 'warm' && status.status === 'warm' && status.proof_bank_ready === true && status.protocol_ok === true, 'sksd warm cache must persist protocol state', { warm, status });
-assertGate(proofBank.schema === 'sks.triwiki-proof-bank.v1', 'sksd proof-bank-status request must roundtrip', proofBank);
-emitGate('sksd:warm-cache-blackbox', { status: status.status });
-//# sourceMappingURL=sksd-warm-cache-blackbox.js.map

package/dist/scripts/team-backfill-route-blackbox.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runRouteBackfillBlackbox } from './agent-route-blackbox-lib.js';
-runRouteBackfillBlackbox('$Team', 'team:backfill-route-blackbox');
-//# sourceMappingURL=team-backfill-route-blackbox.js.map

package/dist/scripts/team-parallel-write-blackbox.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mergeMod = await importDist('core/agents/agent-merge-coordinator.js');
-const applyMod = await importDist('core/agents/agent-patch-apply-worker.js');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-team-patch-'));
-fs.writeFileSync(path.join(tmp, 'team-a.txt'), 'lane-a\n');
-fs.writeFileSync(path.join(tmp, 'team-b.txt'), 'lane-b\n');
-const envelopes = [
-    { schema: 'sks.agent-patch-envelope.v1', agent_id: 'reviewer-a', session_id: 'team-session-a', slot_id: 'team-slot-a', generation_index: 1, lease_id: 'lease:reviewer-a:team-a.txt', operations: [{ op: 'replace', path: 'team-a.txt', search: 'lane-a', replace: 'lane-a-done' }] },
-    { schema: 'sks.agent-patch-envelope.v1', agent_id: 'reviewer-b', session_id: 'team-session-b', slot_id: 'team-slot-b', generation_index: 1, lease_id: 'lease:reviewer-b:team-b.txt', operations: [{ op: 'replace', path: 'team-b.txt', search: 'lane-b', replace: 'lane-b-done' }] }
-];
-const merge = mergeMod.coordinateAgentPatchMerge(envelopes);
-const applyResults = [];
-for (const envelope of envelopes)
-    applyResults.push(await applyMod.applyAgentPatchEnvelope(tmp, envelope));
-const teamRun = spawnSync(process.execPath, [
-    'dist/bin/sks.js',
-    'team',
-    'team parallel write blackbox route fixture',
-    'executor:1',
-    'reviewer:5',
-    '--mock',
-    '--write-mode',
-    'parallel',
-    '--apply-patches',
-    '--dry-run-patches',
-    '--max-write-agents',
-    '1',
-    '--json'
-], { cwd: root, encoding: 'utf8', maxBuffer: 2 * 1024 * 1024 });
-const teamJson = parseJson(teamRun.stdout);
-const routePolicy = teamJson?.parallel_write_policy || teamJson?.run?.parallel_write_policy || teamJson?.native_agent_run?.parallel_write_policy || null;
-const report = { schema: 'sks.team-parallel-write-blackbox.v1', ok: merge.ok && applyResults.every((item) => item.ok) && teamRun.status === 0 && routePolicy?.route_level_flags_wired === true, merge, applyResults, route_command: { status: teamRun.status, stderr_tail: teamRun.stderr.slice(-2000), mission_id: teamJson?.mission_id || null, route_policy: routePolicy } };
-const out = path.join(root, '.sneakoscope', 'reports', 'team-parallel-write-blackbox.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.ok === true, 'Team parallel write blackbox must pass', report);
-assertGate(routePolicy?.write_mode === 'parallel', 'Team route must carry --write-mode parallel into native agent policy', report);
-assertGate(routePolicy?.apply_patches === true, 'Team route must carry --apply-patches into native agent policy', report);
-assertGate(routePolicy?.dry_run_patches === true, 'Team route must carry --dry-run-patches into native agent policy', report);
-emitGate('team:parallel-write-blackbox', { changed_files: applyResults.flatMap((item) => item.changed_files).length });
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=team-parallel-write-blackbox.js.map