sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/release-runtime-truth-matrix-check.js

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist, root, readJson } from './sks-1-18-gate-lib.js';
-const releaseVersion = readJson('package.json').version;
-const mod = await importDist('core/proof/runtime-truth-matrix.js');
-const matrix = await mod.buildRuntimeTruthMatrix({ root, releaseVersion });
-await mod.writeRuntimeTruthMatrix(root, matrix);
-const requiredRows = [
-    'zellij_pane',
-    'codex_dynamic',
-    'cleanup',
-    'intelligent_work_graph',
-    'source_intelligence',
-    'goal_mode',
-    'route_blackbox',
-    'dynamic_scheduler',
-    'warp_mad_lanes',
-    'codex_0_134',
-    'mcp_0_134',
-    'parallel_write',
-    'patch_proof',
-    'native_cli_session_swarm',
-    'real_codex_parallel_workers',
-    'native_worker_backend_router',
-    'codex_child_overlap',
-    'model_authored_patch_envelopes',
-    'fast_mode_child_propagation',
-    'cleanup_v4',
-    'ast_type_work_graph',
-    'warp_mad_right_lanes'
-];
-assertGate(matrix.schema === 'sks.runtime-truth-matrix.v1', 'runtime truth matrix schema mismatch', matrix);
-for (const subsystem of requiredRows) {
-    const row = matrix.rows.find((item) => item.subsystem === subsystem);
-    assertGate(Boolean(row), `runtime truth matrix missing subsystem ${subsystem}`, matrix);
-    assertGate(typeof row.proof_level === 'string', `runtime truth row missing proof level: ${subsystem}`, row);
-    assertGate(Array.isArray(row.evidence_artifacts), `runtime truth row missing evidence artifacts: ${subsystem}`, row);
-    assertGate(Array.isArray(row.blockers), `runtime truth row missing blockers: ${subsystem}`, row);
-    assertGate(typeof row.next_action === 'string', `runtime truth row missing next action: ${subsystem}`, row);
-    assertGate(typeof row.required_mode === 'boolean', `runtime truth row missing required mode: ${subsystem}`, row);
-}
-for (const priority of ['P0', 'P1', 'P2', 'P3', 'P4', 'P5', 'P6']) {
-    assertGate(['closed', 'blocked', 'not_applicable_with_proof'].includes(matrix.priorities[priority]?.status), `runtime truth matrix missing ${priority}`, matrix);
-}
-assertGate(matrix.ok === true, 'runtime truth matrix has required blockers', matrix);
-emitGate('release:runtime-truth-matrix', { subsystems: matrix.rows.length, version: releaseVersion });
-//# sourceMappingURL=release-runtime-truth-matrix-check.js.map

package/dist/scripts/release-stability-report-check.js

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
-const manifest = readJson('release-gates.v2.json');
-const currentRunDir = process.env.SKS_REPORT_DIR ? path.dirname(process.env.SKS_REPORT_DIR) : null;
-const latestReleaseRun = currentRunDir || latestDir(path.join(root, '.sneakoscope', 'reports', 'release-gates'));
-const latestSummary = currentRunDir ? summarizeCurrentRun(currentRunDir) : latestReleaseRun ? readJsonIfExists(path.join(latestReleaseRun, 'summary.json')) : null;
-const zellijReportPath = path.join(root, '.sneakoscope', 'reports', 'zellij-worker-pane-real-ui-blackbox.json');
-const zellij = fs.existsSync(zellijReportPath) ? JSON.parse(fs.readFileSync(zellijReportPath, 'utf8')) : null;
-const requiredGateIds = [
-    'release:dag-runner',
-    'release:parallel-speed-budget',
-    'git:worktree-manifest-append',
-    'git:worktree-dirty-main-detection',
-    'git:worktree-untracked-diff',
-    'git:worktree-diff-envelope',
-    'git:worktree-integration-primary',
-    'git:worktree-dirty-lock',
-    'naruto:worktree-coding:blackbox',
-    'release:version-truth'
-];
-const manifestIds = new Set(manifest.gates.map((gate) => gate.id));
-const missing = requiredGateIds.filter((id) => !manifestIds.has(id));
-const score = computeScore({ missing, latestSummary, zellij });
-const report = {
-    schema: 'sks.release-stability-report.v1',
-    ok: score >= 9.5 && missing.length === 0 && latestSummary?.ok === true && zellij?.ok === true,
-    target_score: 9.5,
-    score,
-    manifest_gate_count: manifest.gates.length,
-    latest_release_summary: latestSummary ? path.relative(root, path.join(latestReleaseRun, 'summary.json')) : null,
-    release_check_ok: latestSummary?.ok === true,
-    release_check_passed: latestSummary?.completed || 0,
-    release_check_failed: latestSummary?.failed || 0,
-    zellij_real_worker_panes_ok: zellij?.ok === true,
-    zellij_real_worker_panes: zellij?.real_pane_ids || 0,
-    missing_required_gates: missing,
-    blockers: []
-};
-if (!report.ok) {
-    report.blockers = [
-        ...(score >= 9.5 ? [] : ['stability_score_below_target']),
-        ...(missing.length ? ['required_release_gate_missing'] : []),
-        ...(latestSummary?.ok === true ? [] : ['latest_release_check_not_green']),
-        ...(zellij?.ok === true ? [] : ['zellij_real_worker_panes_not_green'])
-    ];
-}
-fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'release-stability-report.json'), `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.ok, 'release stability report must meet 9.5+ target', report);
-emitGate('release:stability-report', report);
-function computeScore({ missing, latestSummary, zellij }) {
-    let score = 10;
-    score -= missing.length * 0.25;
-    if (latestSummary?.ok !== true)
-        score -= 1.5;
-    if ((latestSummary?.failed || 0) > 0)
-        score -= 1;
-    if (zellij?.ok !== true)
-        score -= 1;
-    return Number(Math.max(0, score).toFixed(2));
-}
-function latestDir(dir) {
-    if (!fs.existsSync(dir))
-        return null;
-    const dirs = fs.readdirSync(dir)
-        .map((name) => path.join(dir, name))
-        .filter((candidate) => fs.statSync(candidate).isDirectory())
-        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-    return dirs[0] || null;
-}
-function summarizeCurrentRun(runDir) {
-    const results = [];
-    for (const entry of fs.readdirSync(runDir)) {
-        const result = readJsonIfExists(path.join(runDir, entry, 'result.json'));
-        if (result && result.id !== 'release:stability-report')
-            results.push(result);
-    }
-    if (!results.length)
-        return null;
-    const failed = results.filter((result) => result.ok !== true);
-    return {
-        schema: 'sks.release-gate-current-run-summary.v1',
-        ok: failed.length === 0,
-        completed: results.filter((result) => result.ok === true).length,
-        failed: failed.length
-    };
-}
-function readJsonIfExists(file) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=release-stability-report-check.js.map

package/dist/scripts/release-version-truth-check.js

@@ -1,134 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const pkg = readJson('package.json');
-const expected = String(pkg.version || '');
-const mismatches = [];
-const warnings = [];
-checkJson('package.json', 'version', pkg.version);
-const lock = readJson('package-lock.json');
-checkJson('package-lock.json', 'version', lock.version);
-checkJson('package-lock.json', 'packages[""].version', lock.packages?.['']?.version);
-checkRegex('src/core/version.ts', /PACKAGE_VERSION\s*=\s*['"]([^'"]+)['"]/, 'PACKAGE_VERSION');
-checkRegex('src/core/fsx.ts', /PACKAGE_VERSION\s*=\s*['"]([^'"]+)['"]/, 'PACKAGE_VERSION');
-checkRegex('src/bin/sks.ts', /FAST_PACKAGE_VERSION\s*=\s*['"]([^'"]+)['"]/, 'FAST_PACKAGE_VERSION');
-checkRegex('crates/sks-core/Cargo.toml', /^version\s*=\s*"([^"]+)"/m, 'package.version');
-checkCargoLock('crates/sks-core/Cargo.lock', 'sks-core');
-const dist = readJson('dist/build-manifest.json', null);
-checkJson('dist/build-manifest.json', 'package_version', dist?.package_version);
-checkJson('dist/build-manifest.json', 'version', dist?.version);
-checkChangelog();
-checkReadme();
-checkReleaseMetadataScript();
-checkCargoMetadata();
-const ok = mismatches.length === 0;
-const report = {
-    schema: 'sks.release-version-truth.v1',
-    ok,
-    expected,
-    mismatches,
-    warnings,
-    generated_at: new Date().toISOString()
-};
-const out = path.join(root, '.sneakoscope', 'reports', 'release-version-truth.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(ok, 'release version truth mismatch', { expected, mismatches });
-emitGate('release:version-truth', { version: expected, checked: 13, warnings: warnings.length });
-function checkJson(file, field, actual) {
-    if (actual !== expected)
-        mismatch(file, field, actual);
-}
-function checkRegex(file, re, field) {
-    const text = readText(file);
-    const match = text.match(re);
-    if (!match)
-        mismatch(file, field, null);
-    else if (match[1] !== expected)
-        mismatch(file, field, match[1]);
-}
-function checkCargoLock(file, name) {
-    const text = readText(file);
-    const block = text.split(/\n\[\[package\]\]\n/).find((part) => new RegExp(`name\\s*=\\s*"${escapeRe(name)}"`).test(part));
-    const match = block?.match(/version\s*=\s*"([^"]+)"/);
-    if (!match)
-        mismatch(file, `${name}.version`, null);
-    else if (match[1] !== expected)
-        mismatch(file, `${name}.version`, match[1]);
-}
-function checkChangelog() {
-    const text = readText('CHANGELOG.md');
-    const latest = latestVersionedChangelogSection(text);
-    if (latest !== expected)
-        mismatch('CHANGELOG.md', 'latest release section', latest);
-}
-function checkReadme() {
-    const text = readText('README.md');
-    const displayed = text.match(/SKS \*\*([0-9]+\.[0-9]+\.[0-9]+)\*\*/)?.[1] || null;
-    if (displayed && displayed !== expected)
-        mismatch('README.md', 'displayed current version', displayed);
-}
-function checkReleaseMetadataScript() {
-    const script = String(pkg.scripts?.['release:metadata'] || '');
-    if (!script.includes('dist/scripts/release-metadata-check.js')) {
-        mismatch('package.json', 'scripts.release:metadata', script || null, 'node ./dist/scripts/release-metadata-check.js');
-    }
-    const text = readText('src/scripts/release-metadata-check.ts');
-    if (!text.includes('release-metadata-1-19-check.js')) {
-        warnings.push({ file: 'src/scripts/release-metadata-check.ts', message: 'generic entrypoint does not reference historical implementation wrapper' });
-    }
-}
-function checkCargoMetadata() {
-    const res = spawnSync('cargo', ['metadata', '--no-deps', '--manifest-path', path.join(root, 'crates/sks-core/Cargo.toml'), '--format-version', '1'], {
-        cwd: root,
-        encoding: 'utf8',
-        timeout: 30000
-    });
-    if (res.status !== 0) {
-        warnings.push({ file: 'crates/sks-core/Cargo.toml', message: 'cargo metadata unavailable', stderr_tail: tail(res.stderr) });
-        return;
-    }
-    try {
-        const metadata = JSON.parse(res.stdout);
-        const crate = metadata.packages?.find((row) => row.name === 'sks-core');
-        if (crate?.version !== expected)
-            mismatch('cargo metadata', 'sks-core.version', crate?.version || null);
-    }
-    catch (err) {
-        warnings.push({ file: 'cargo metadata', message: `unparseable:${err instanceof Error ? err.message : String(err)}` });
-    }
-}
-function mismatch(file, field, actual, wanted = expected) {
-    mismatches.push({ file, field, expected: wanted, actual: actual ?? null });
-}
-function readJson(rel, fallback) {
-    try {
-        return JSON.parse(readText(rel));
-    }
-    catch (err) {
-        if (arguments.length > 1)
-            return fallback;
-        throw err;
-    }
-}
-function readText(rel) {
-    return fs.readFileSync(path.join(root, rel), 'utf8');
-}
-function escapeRe(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function latestVersionedChangelogSection(text) {
-    for (const match of text.matchAll(/^## \[([^\]]+)\]/gm)) {
-        if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(match[1]))
-            return match[1];
-    }
-    return null;
-}
-function tail(value, limit = 1000) {
-    const text = String(value || '');
-    return text.length > limit ? text.slice(-limit) : text;
-}
-//# sourceMappingURL=release-version-truth-check.js.map

package/dist/scripts/research-actual-route-backfill-check.js

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

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

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

package/dist/scripts/research-quality-gate-check.js

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
-const mode = process.argv[2] || 'all';
-const checks = {
-    'quality-contract': () => {
-        assertFileIncludes('src/core/research/research-quality-contract.ts', [
-            'min_sources_total: 12',
-            'min_source_layers_covered: 5',
-            'min_counterevidence_sources: 2',
-            'min_trianguled_claims: 6',
-            'min_key_claims: 8',
-            'min_report_words: 2200'
-        ]);
-        assertFileIncludes('src/core/research.ts', ['quality_contract', 'writeResearchQualityContract', 'research_report_too_short']);
-    },
-    'claim-matrix': () => {
-        assertFileIncludes('src/core/research/claim-evidence-matrix.ts', ['CLAIM_EVIDENCE_MATRIX_ARTIFACT', 'validateClaimEvidenceMatrix', 'buildClaimEvidenceMatrixFromLedgers']);
-        assertFileIncludes('src/core/research.ts', ['claim_evidence_matrix_missing', 'key_claims_below_contract', 'triangulated_claims_below_contract']);
-    },
-    'source-quality-report': () => {
-        assertFileIncludes('src/core/research/source-quality-report.ts', ['SOURCE_QUALITY_REPORT_ARTIFACT', 'buildSourceQualityReport', 'claim_ids']);
-        assertFileIncludes('src/core/research.ts', ['source_quality_report_missing', 'writeSourceQualityReport']);
-    },
-    'implementation-blueprint': () => {
-        assertFileIncludes('src/core/research/implementation-blueprint.ts', ['IMPLEMENTATION_BLUEPRINT_ARTIFACT', 'validateImplementationBlueprint']);
-        assertFileIncludes('src/core/research.ts', ['implementation_blueprint_missing', 'renderImplementationBlueprintMarkdown']);
-    },
-    'experiment-plan': () => {
-        assertFileIncludes('src/core/research/experiment-plan.ts', ['EXPERIMENT_PLAN_JSON_ARTIFACT', 'min_experiment_steps', 'validateExperimentPlan']);
-        assertFileIncludes('src/core/research/experiment-plan.ts', ['experiment_plan_missing', 'experiment_plan_too_thin']);
-        assertFileIncludes('src/core/research.ts', ['experiment_plan_missing', 'validateExperimentPlan']);
-    },
-    'replication-pack': () => {
-        assertFileIncludes('src/core/research/replication-pack.ts', ['REPLICATION_PACK_ARTIFACT', 'validateReplicationPack']);
-        assertFileIncludes('src/core/research.ts', ['replication_pack_missing']);
-    },
-    'final-reviewer': () => {
-        assertFileIncludes('src/core/research/research-final-reviewer.ts', ['RESEARCH_FINAL_REVIEW_ARTIFACT', 'approved', 'runResearchFinalReviewer']);
-        assertFileIncludes('src/core/research.ts', ['research_final_review_not_approved']);
-    },
-    'work-graph': () => {
-        assertFileIncludes('src/core/research/research-work-graph.ts', ['RESEARCH_WORK_GRAPH_ARTIFACT', 'buildResearchWorkGraph', 'sks.naruto-work-graph.v1']);
-        assertFileIncludes('src/core/commands/research-command.ts', ['narutoWorkGraph: researchWorkGraph', 'readonly: true', 'runResearchCycle']);
-    },
-    'prompt-contract': () => {
-        assertFileIncludes('src/core/research/research-prompt-contract.ts', ['researchPromptContractText', 'validateResearchPromptContract']);
-        assertFileIncludes('src/core/research.ts', ['QUALITY CONTRACT:', 'researchPromptContractText()']);
-    },
-    'gate-thresholds': () => {
-        assertFileIncludes('src/core/research.ts', [
-            'source_entries_below_research_quality_contract',
-            'source_layer_coverage_below_contract',
-            'counterevidence_below_contract',
-            'required_artifact_missing'
-        ]);
-        assertFileIncludes('src/core/research/falsification.ts', ['falsification_cases_below_contract']);
-    },
-    'schemas': () => {
-        for (const file of [
-            'schemas/research/research-quality-contract.schema.json',
-            'schemas/research/claim-evidence-matrix.schema.json',
-            'schemas/research/source-quality-report.schema.json',
-            'schemas/research/implementation-blueprint.schema.json',
-            'schemas/research/experiment-plan.schema.json',
-            'schemas/research/replication-pack.schema.json',
-            'schemas/research/research-final-review.schema.json'
-        ])
-            assertGate(readText(file).includes('"$schema"'), `${file} missing JSON Schema header`);
-    }
-};
-if (mode === 'all') {
-    for (const check of Object.values(checks))
-        check();
-}
-else {
-    assertGate(Boolean(checks[mode]), `unknown research quality check: ${mode}`);
-    checks[mode]();
-}
-emitGate(`research:${mode}`, { mode });
-function assertFileIncludes(file, tokens) {
-    const text = readText(file);
-    for (const token of tokens)
-        assertGate(text.includes(token), `${file} missing token ${token}`);
-}
-//# sourceMappingURL=research-quality-gate-check.js.map

package/dist/scripts/responses-retry-policy-centralized-check.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'responses-retry-policy.js')).href);
-const policy = mod.DEFAULT_RESPONSES_RETRY_POLICY;
-const ok = policy.adapters.includes('source-intelligence') && policy.adapters.includes('codex-web') && policy.adapters.includes('mcp')
-    && mod.shouldRetryResponsesError({ status: 429, attempt: 1 }) === true
-    && mod.shouldRetryResponsesError({ status: 429, attempt: policy.max_attempts }) === false
-    && mod.responsesRetryDelayMs(3) > mod.responsesRetryDelayMs(1);
-emit({ schema: 'sks.responses-retry-policy-centralized-check.v1', ok, policy });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.responses-retry-policy-centralized-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=responses-retry-policy-centralized-check.js.map

package/dist/scripts/retention-cleanup-safety-check.js

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { assertGate, emitGate, root } from './sks-1-11-gate-lib.js';
-const retentionPath = path.join(root, 'dist', 'core', 'retention.js');
-assertGate(fs.existsSync(retentionPath), 'dist retention module missing; run npm run build first', { retentionPath });
-const { enforceRetention } = await import(pathToFileURL(retentionPath).href);
-const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-retention-cleanup-'));
-try {
-    const applyRoot = path.join(tmp, 'apply');
-    const dryRoot = path.join(tmp, 'dry');
-    await writeFixture(applyRoot);
-    await writeFixture(dryRoot);
-    const applied = await enforceRetention(applyRoot, {
-        pruneReportLogs: true,
-        policy: { max_tmp_age_hours: 0, max_mission_age_days: 0, max_missions: 999 }
-    });
-    const dry = await enforceRetention(dryRoot, {
-        dryRun: true,
-        pruneReportLogs: true,
-        policy: { max_tmp_age_hours: 0, max_mission_age_days: 0, max_missions: 999 }
-    });
-    for (const rel of [
-        '.sneakoscope/memory/q2_facts/post-route-reflection.md',
-        '.sneakoscope/wiki/context-pack.json',
-        '.sneakoscope/wiki/records/learning.json',
-        '.sneakoscope/missions/M-done/completion-proof.json',
-        '.sneakoscope/missions/M-done/route-completion-contract.json',
-        '.sneakoscope/missions/M-done/evidence-index.json',
-        '.sneakoscope/missions/M-done/trust-report.json',
-        '.sneakoscope/missions/M-done/reflection.md',
-        '.sneakoscope/missions/M-done/reflection-gate.json',
-        '.sneakoscope/missions/M-done/agents/agent-proof-evidence.json',
-        '.sneakoscope/missions/M-old/completion-proof.json',
-        '.sneakoscope/missions/M-old/trust-report.json',
-        '.sneakoscope/missions/M-old/reflection.md',
-        '.sneakoscope/missions/M-done/sessions/terminal-transcript.log',
-        '.sneakoscope/missions/M-done/agents/sessions/session-1/terminal-transcript.log',
-        '.sneakoscope/missions/M-active/team-inbox/active.md',
-        '.sneakoscope/missions/M-blocked/team-inbox/blocked.md',
-        '.sneakoscope/missions/M-blocked/scout.stderr.log'
-    ]) {
-        assertGate(exists(path.join(applyRoot, rel)), `durable or active artifact was removed: ${rel}`, { rel, actions: applied.actions });
-    }
-    for (const rel of [
-        '.sneakoscope/tmp/scratch.txt',
-        '.sneakoscope/missions/M-done/team-inbox/worker.md',
-        '.sneakoscope/missions/M-done/bus/event.jsonl',
-        '.sneakoscope/missions/M-done/agents/lanes/lane-1.json',
-        '.sneakoscope/missions/M-done/scout.stdout.log',
-        '.sneakoscope/missions/M-done/scout.stderr.log',
-        '.sneakoscope/missions/M-old/team-inbox/worker.md',
-        '.sneakoscope/missions/M-old/scout.stdout.log',
-        '.sneakoscope/reports/release-parallel-logs/build.stdout.log'
-    ]) {
-        assertGate(!exists(path.join(applyRoot, rel)), `disposable artifact survived cleanup: ${rel}`, { rel, actions: applied.actions });
-        assertGate(exists(path.join(dryRoot, rel)), `dry-run removed artifact unexpectedly: ${rel}`, { rel, actions: dry.actions });
-    }
-    const actionKinds = new Set(applied.actions.map((row) => row.action));
-    for (const kind of ['remove_tmp', 'remove_closed_mission_raw_log', 'remove_disposable_report_log_dir']) {
-        assertGate(actionKinds.has(kind), `retention cleanup did not report action kind: ${kind}`, { actions: applied.actions });
-    }
-    assertGate(actionKinds.has('remove_closed_mission_workdir') || actionKinds.has('remove_old_mission_workdir'), 'retention cleanup did not report mission workdir cleanup', { actions: applied.actions });
-    assertGate(actionKinds.has('retain_mission_durable_context'), 'retention cleanup did not preserve old durable mission context', { actions: applied.actions });
-    assertGate(dry.actions.length >= applied.actions.length, 'dry-run should plan cleanup actions without deleting files', { applied: applied.actions.length, dry: dry.actions.length });
-    const report = {
-        schema: 'sks.retention-cleanup-safety.v1',
-        ok: true,
-        applied_actions: applied.actions.length,
-        dry_run_actions: dry.actions.length,
-        preserved_durable_context: applied.cleanup?.protected_durable_context || [],
-        removed_action_kinds: [...actionKinds].sort(),
-        generated_at: new Date().toISOString()
-    };
-    await fsp.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-    await fsp.writeFile(path.join(root, '.sneakoscope', 'reports', 'retention-cleanup-safety.json'), `${JSON.stringify(report, null, 2)}\n`);
-    emitGate('retention:cleanup-safety', report);
-}
-finally {
-    await fsp.rm(tmp, { recursive: true, force: true }).catch(() => { });
-}
-async function writeFixture(projectRoot) {
-    await write(path.join(projectRoot, '.sneakoscope', 'policy.json'), { retention: { max_tmp_age_hours: 0 } });
-    await write(path.join(projectRoot, '.sneakoscope', 'state', 'current.json'), { mission_id: 'M-active' });
-    await writeText(path.join(projectRoot, '.sneakoscope', 'tmp', 'scratch.txt'), 'temporary scratch\n');
-    await old(path.join(projectRoot, '.sneakoscope', 'tmp', 'scratch.txt'));
-    await writeText(path.join(projectRoot, '.sneakoscope', 'memory', 'q2_facts', 'post-route-reflection.md'), '# durable reflection\n');
-    await write(path.join(projectRoot, '.sneakoscope', 'wiki', 'context-pack.json'), { schema: 'sks.context-pack.v1', anchors: [] });
-    await write(path.join(projectRoot, '.sneakoscope', 'wiki', 'records', 'learning.json'), { schema: 'sks.triwiki-record.v1', durable: true });
-    await writeMission(projectRoot, 'M-done', true);
-    await writeMission(projectRoot, 'M-active', false);
-    await writeOldDurableMission(projectRoot);
-    await writeBlockedMission(projectRoot);
-    await writeText(path.join(projectRoot, '.sneakoscope', 'reports', 'release-parallel-logs', 'build.stdout.log'), 'summarized release log\n');
-}
-async function writeMission(projectRoot, missionId, closed) {
-    const dir = path.join(projectRoot, '.sneakoscope', 'missions', missionId);
-    await write(path.join(dir, 'mission.json'), { id: missionId, prompt: 'fixture' });
-    if (closed) {
-        await write(path.join(dir, 'completion-proof.json'), { schema: 'sks.completion-proof.v1', status: 'verified_partial', ok: true });
-        await write(path.join(dir, 'route-completion-contract.json'), { mission_id: missionId });
-        await write(path.join(dir, 'evidence-index.json'), { mission_id: missionId, evidence: [] });
-        await write(path.join(dir, 'trust-report.json'), { mission_id: missionId, status: 'verified_partial' });
-        await writeText(path.join(dir, 'reflection.md'), '# retained reflection\n');
-        await write(path.join(dir, 'reflection-gate.json'), { passed: true });
-        await write(path.join(dir, 'team-gate.json'), { passed: true });
-        await write(path.join(dir, 'team-session-cleanup.json'), { passed: true, all_sessions_closed: true });
-        await write(path.join(dir, 'agents', 'agent-proof-evidence.json'), { ok: true, all_sessions_closed: true });
-        await writeText(path.join(dir, 'sessions', 'terminal-transcript.log'), 'transcript stays\n');
-        await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'terminal-transcript.log'), 'agent transcript stays\n');
-        await writeText(path.join(dir, 'scout.stdout.log'), 'raw stdout\n');
-        await writeText(path.join(dir, 'scout.stderr.log'), 'raw stderr\n');
-        await writeText(path.join(dir, 'team-inbox', 'worker.md'), 'temporary inbox\n');
-    }
-    else {
-        await writeText(path.join(dir, 'team-inbox', 'active.md'), 'active mission scratch stays\n');
-    }
-    await writeText(path.join(dir, 'bus', 'event.jsonl'), '{"event":"temporary"}\n');
-    await writeText(path.join(dir, 'agents', 'lanes', 'lane-1.json'), '{"lane":"temporary"}\n');
-}
-async function writeOldDurableMission(projectRoot) {
-    const dir = path.join(projectRoot, '.sneakoscope', 'missions', 'M-old');
-    await write(path.join(dir, 'completion-proof.json'), { schema: 'sks.completion-proof.v1', status: 'verified', blockers: [] });
-    await write(path.join(dir, 'trust-report.json'), { status: 'verified' });
-    await write(path.join(dir, 'evidence-index.json'), { evidence: [] });
-    await writeText(path.join(dir, 'reflection.md'), '# old retained reflection\n');
-    await writeText(path.join(dir, 'team-inbox', 'worker.md'), 'old scratch\n');
-    await writeText(path.join(dir, 'scout.stdout.log'), 'old raw log\n');
-    await old(dir);
-}
-async function writeBlockedMission(projectRoot) {
-    const dir = path.join(projectRoot, '.sneakoscope', 'missions', 'M-blocked');
-    await write(path.join(dir, 'completion-proof.json'), { schema: 'sks.completion-proof.v1', status: 'blocked', blockers: ['fixture_blocker'] });
-    await writeText(path.join(dir, 'team-inbox', 'blocked.md'), 'diagnostic scratch\n');
-    await writeText(path.join(dir, 'scout.stderr.log'), 'diagnostic raw log\n');
-}
-async function write(file, data) {
-    await writeText(file, `${JSON.stringify(data, null, 2)}\n`);
-}
-async function writeText(file, text) {
-    await fsp.mkdir(path.dirname(file), { recursive: true });
-    await fsp.writeFile(file, text, 'utf8');
-}
-async function old(file) {
-    const past = new Date(Date.now() - 60_000);
-    await fsp.utimes(file, past, past);
-}
-function exists(file) {
-    return fs.existsSync(file);
-}
-//# sourceMappingURL=retention-cleanup-safety-check.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