sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/research-source-ledger-merge-check.js

@@ -0,0 +1,26 @@
+#!/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 shards = await importDist('core/research/research-source-shards.js');
+const merge = await importDist('core/research/research-source-ledger-merge.js');
+const fsx = await importDist('core/fsx.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-source-merge-'));
+const plan = await research.writeResearchPlan(dir, 'source ledger merge blackbox', { missionId: 'M-SOURCE-MERGE' });
+const shardDir = path.join(dir, 'research', 'cycle-1', 'source-shards');
+await fsx.ensureDir(shardDir);
+for (const layer of shards.RESEARCH_SOURCE_LAYERS) {
+    await fsx.writeJsonAtomic(path.join(shardDir, `${layer.id}.json`), shards.defaultResearchSourceShardOutput(plan, layer, 1));
+}
+const result = await merge.mergeResearchSourceShards({ dir, cycle: 1, plan });
+const ledger = JSON.parse(fs.readFileSync(path.join(dir, 'source-ledger.json'), 'utf8'));
+assertGate(result.ok === true, 'source shard merge must pass', result);
+assertGate(result.source_count >= 12, 'source merge must preserve enough source rows', result);
+assertGate(result.layer_count >= 8, 'source merge must cover source shard layers', result);
+assertGate(ledger.citation_coverage?.all_key_claims_cited === true, 'source merge must update citation coverage', ledger.citation_coverage);
+assertGate(fs.existsSync(path.join(dir, 'source-quality-report.json')), 'source-quality-report must be updated');
+emitGate('research:source-ledger-merge', { dir, source_count: result.source_count, layer_count: result.layer_count });
+//# sourceMappingURL=research-source-ledger-merge-check.js.map

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

@@ -0,0 +1,40 @@
+#!/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-prompt-contract-check.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const prompt = await importDist('core/research/research-synthesis-prompt.js');
+const text = prompt.buildResearchSynthesisPrompt({
+    plan: { mission_id: 'M-SYNTHESIS-PROMPT', prompt: 'prompt contract check' },
+    cycle: 1,
+    sourceLedger: {
+        sources: [{ id: 'source-1', layer: 'academic_literature', title: 'Source one', stance: 'supports', claim_ids: ['claim-1'] }],
+        counterevidence_sources: [{ id: 'counter-1', layer: 'counterevidence_factcheck', title: 'Counter one', stance: 'undermines', claim_ids: ['claim-1'] }]
+    },
+    claimMatrix: { claims: [{ id: 'claim-1', claim: 'claim one', source_ids: ['source-1'], counterevidence_ids: ['counter-1'], test_or_probe: 'probe' }] },
+    falsificationLedger: { cases: [{ id: 'falsification-1', target_claim: 'claim-1' }] },
+    implementationBlueprint: { sections: [{ id: 'execution_plan', title: 'Execution Plan', target_paths: ['src/core/research/research-synthesis-writer.ts'], acceptance_checks: ['test'] }] },
+    experimentPlan: { steps: [{ id: 'E1', action: 'run test' }] },
+    replicationPack: { commands: ['npm run research:synthesis-writer'] }
+});
+for (const token of [
+    'You are writing the final SKS Research synthesis.',
+    'Do not write a short summary.',
+    'Do not pad with repeated paragraphs.',
+    'Every key claim must cite source-ledger ids.',
+    'Every recommendation must point to implementation-blueprint sections.',
+    'Every limitation must point to falsification-ledger cases or source blockers.',
+    'Return JSON only matching sks.research-synthesis-output.v1.',
+    'Do not modify repository source.',
+    'If evidence is insufficient, return blockers rather than confident prose.',
+    'source-1',
+    'counter-1',
+    'claim-1',
+    'execution_plan',
+    'npm run research:synthesis-writer'
+])
+    assertGate(text.includes(token), `synthesis prompt missing token: ${token}`);
+emitGate('research:synthesis-prompt-contract', { chars: text.length });
+//# sourceMappingURL=research-synthesis-prompt-contract-check.js.map

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

@@ -0,0 +1,24 @@
+#!/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/research-synthesis-writer-check.js

@@ -0,0 +1,26 @@
+#!/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 writer = await importDist('core/research/research-synthesis-writer.js');
+const quality = await importDist('core/research/research-report-quality.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-synthesis-writer-'));
+const plan = await research.writeResearchPlan(dir, 'synthesis writer check', { missionId: 'M-SYNTHESIS-WRITER' });
+await research.writeMockResearchResult(dir, plan);
+const output = await writer.runResearchCodexSynthesisWriter({ root: process.cwd(), dir, plan, cycle: 1, mock: true });
+const sourceLedger = JSON.parse(fs.readFileSync(path.join(dir, 'source-ledger.json'), 'utf8'));
+const claimMatrix = JSON.parse(fs.readFileSync(path.join(dir, 'claim-evidence-matrix.json'), 'utf8'));
+const contract = JSON.parse(fs.readFileSync(path.join(dir, 'research-quality-contract.json'), 'utf8'));
+const validation = writer.validateResearchSynthesisOutput(output, contract, claimMatrix, sourceLedger);
+const reportQuality = quality.analyzeResearchReportQuality(output.report_markdown);
+assertGate(output.schema === 'sks.research-synthesis-output.v1', 'synthesis output schema mismatch', output);
+assertGate(validation.ok === true, 'mock synthesis writer output must validate', validation);
+assertGate(fs.existsSync(path.join(dir, 'research-synthesis-output.json')), 'research-synthesis-output.json missing');
+assertGate(fs.existsSync(path.join(dir, 'research-report.md')), 'research-report.md missing');
+assertGate(fs.existsSync(path.join(dir, research.researchPaperArtifactForPlan(plan))), 'research paper artifact missing');
+assertGate(reportQuality.ok === true, 'synthesis report quality must pass', reportQuality);
+emitGate('research:synthesis-writer', { dir, quality: reportQuality, validation });
+//# sourceMappingURL=research-synthesis-writer-check.js.map

package/dist/scripts/research-template-report-rejection-check.js

@@ -0,0 +1,56 @@
+#!/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 fsx = await importDist('core/fsx.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-template-rejection-'));
+const plan = await research.writeResearchPlan(dir, 'template report rejection blackbox', { missionId: 'M-TEMPLATE-REJECTION' });
+await research.writeMockResearchResult(dir, plan);
+const repeated = [
+    '# 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.',
+    '',
+    '## Evidence Matrix Summary',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## 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',
+    Array.from({ length: 40 }, () => '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'),
+    '',
+    '## 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.writeTextAtomic(path.join(dir, 'research-report.md'), `${repeated}\n`);
+await fsx.rmrf(path.join(dir, 'research-final-review.codex.json'));
+const gate = await research.evaluateResearchGate(dir);
+const reasons = new Set(gate.reasons || []);
+assertGate(gate.passed === false, 'template-like repeated report must be blocked', gate);
+assertGate(reasons.has('research_report_repeated_paragraphs') || [...reasons].some((reason) => String(reason).startsWith('research_report_template_phrase_hit:Runtime evidence note')), 'missing repetition/template rejection reason', gate);
+emitGate('research:template-report-rejection', { dir, reasons: gate.reasons });
+//# sourceMappingURL=research-template-report-rejection-check.js.map

package/dist/scripts/research-ultra-stability-report.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readJson, readText } from './sks-1-18-gate-lib.js';
+const scripts = readJson('package.json').scripts || {};
+const gates = readJson('release-gates.v2.json').gates || [];
+const gateIds = new Set(gates.map((gate) => gate.id));
+const requiredScripts = [
+    'research:synthesis-writer',
+    'research:synthesis-prompt-contract',
+    'research:synthesis-writer-blackbox',
+    'research:repetition-detector',
+    'research:template-report-rejection',
+    'research:real-synthesis-no-deterministic-renderer',
+    'research:handoff-consumability'
+];
+const requiredDocs = [
+    'Evidence-bound',
+    'Template-like prose',
+    'Research handoff'
+];
+const docs = [
+    readText('README.md'),
+    readText('docs/research-pipeline.md'),
+    readText('docs/research-artifacts.md'),
+    readText('docs/research-implementation-handoff.md')
+].join('\n');
+const missingScripts = requiredScripts.filter((id) => !scripts[id]);
+const missingGates = requiredScripts.filter((id) => !gateIds.has(id));
+const missingDocs = requiredDocs.filter((token) => !docs.toLowerCase().includes(token.toLowerCase()));
+const report = {
+    schema: 'sks.research-ultra-stability-report.v1',
+    ok: missingScripts.length === 0 && missingGates.length === 0 && missingDocs.length === 0,
+    required_scripts: requiredScripts,
+    missing_scripts: missingScripts,
+    missing_release_gates: missingGates,
+    missing_docs: missingDocs,
+    coverage: {
+        evidence_bound_synthesis: scripts['research:synthesis-writer'] && gateIds.has('research:synthesis-writer'),
+        anti_template_rejection: scripts['research:template-report-rejection'] && gateIds.has('research:template-report-rejection'),
+        handoff_consumability: scripts['research:handoff-consumability'] && gateIds.has('research:handoff-consumability')
+    }
+};
+assertGate(report.ok, 'research ultra-stability release coverage incomplete', report);
+emitGate('research:ultra-stability-report', report);
+//# sourceMappingURL=research-ultra-stability-report.js.map

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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,155 @@
+#!/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

@@ -0,0 +1,21 @@
+#!/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/route-proof-artifact-structure-check.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const issues = [];
+for (const rel of [
+    'src/core/proof/route-proof-gate.ts',
+    'src/core/agents/agent-proof-evidence.ts',
+    'src/core/agents/agent-gate.ts',
+    'src/core/agents/agent-ledger-schemas.ts'
+]) {
+    if (!fs.existsSync(path.join(root, rel)))
+        issues.push(`missing:${rel}`);
+}
+const gateText = read('src/core/proof/route-proof-gate.ts');
+for (const token of [
+    "agents.status !== 'passed' || agents.ok !== true",
+    'agent_no_overlap_not_ok',
+    'agent_ledger_hash_chain_not_ok',
+    'agent_consensus_not_ok',
+    'agent_blockers_present',
+    'agent_proof_evidence_missing',
+    'agent_count_below_5',
+    'agent_count_above_20'
+]) {
+    if (!gateText.includes(token))
+        issues.push(`route_gate_missing:${token}`);
+}
+const agentGateText = read('src/core/agents/agent-gate.ts');
+for (const token of ['agent_proof_not_ok', 'agent_proof_status_not_passed', 'agent_count_below_5', 'agent_janitor_missing_or_not_ok']) {
+    if (!agentGateText.includes(token))
+        issues.push(`agent_gate_missing:${token}`);
+}
+await runNegativeFixture();
+const result = {
+    schema: 'sks.route-proof-artifact-structure-check.v1',
+    ok: issues.length === 0,
+    issues
+};
+console.log(JSON.stringify(result, null, 2));
+if (!result.ok)
+    process.exitCode = 1;
+function read(rel) {
+    try {
+        return fs.readFileSync(path.join(root, rel), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+async function runNegativeFixture() {
+    const built = path.join(root, 'dist', 'core', 'proof', 'route-proof-gate.js');
+    if (!fs.existsSync(built)) {
+        issues.push('runtime_gate_import_missing');
+        return;
+    }
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-route-proof-'));
+    const mission = 'M-fixture';
+    const missionDir = path.join(tmp, '.sneakoscope', 'missions', mission);
+    fs.mkdirSync(missionDir, { recursive: true });
+    const proofPath = path.join(missionDir, 'completion-proof.json');
+    const baseProof = {
+        schema: 'sks.completion-proof.v1',
+        version: 'fixture',
+        generated_at: '2026-05-25T00:00:00.000Z',
+        mission_id: mission,
+        status: 'verified',
+        route: '$Team',
+        summary: { files_changed: 0, commands_run: 0, tests_passed: 0, tests_failed: 0, manual_review_required: false },
+        evidence: {
+            agents: {
+                schema: 'sks.agent-proof-evidence.v1',
+                ok: true,
+                status: 'blocked',
+                agent_count: 5,
+                all_sessions_closed: true,
+                no_overlap_ok: true,
+                ledger_hash_chain_ok: true,
+                consensus_ok: true,
+                janitor_ok: true,
+                blockers: []
+            }
+        },
+        claims: [],
+        unverified: [],
+        blockers: [],
+        next_human_actions: []
+    };
+    fs.writeFileSync(proofPath, JSON.stringify(baseProof, null, 2));
+    const { validateRouteCompletionProof } = await import(pathToFileURL(built).href);
+    const result = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team', state: { agents_required: true } });
+    if (result.ok || !result.issues.includes('agent_gate_not_passed'))
+        issues.push('negative_fixture_false_passed_agent_status');
+    fs.writeFileSync(proofPath, JSON.stringify({ ...baseProof, evidence: {} }, null, 2));
+    const missingAgents = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team' });
+    if (missingAgents.ok || !missingAgents.issues.includes('agent_proof_evidence_missing'))
+        issues.push('negative_fixture_false_passed_missing_agents');
+    fs.writeFileSync(proofPath, JSON.stringify({
+        ...baseProof,
+        evidence: {
+            agents: {
+                schema: 'sks.agent-proof-evidence.v1',
+                ok: true,
+                status: 'passed',
+                agent_count: 8,
+                all_sessions_closed: true,
+                no_overlap_ok: true,
+                ledger_hash_chain_ok: true,
+                consensus_ok: true,
+                janitor_ok: true,
+                blockers: []
+            }
+        }
+    }, null, 2));
+    const scaledAgents = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team' });
+    if (!scaledAgents.ok || scaledAgents.issues.includes('agent_count_not_5'))
+        issues.push('positive_fixture_scaled_agents_failed');
+    fs.writeFileSync(proofPath, JSON.stringify({
+        ...baseProof,
+        evidence: {
+            agents: {
+                schema: 'sks.agent-proof-evidence.v1',
+                ok: true,
+                status: 'passed',
+                agent_count: 5,
+                all_sessions_closed: true,
+                no_overlap_ok: true,
+                ledger_hash_chain_ok: true,
+                consensus_ok: true,
+                blockers: []
+            }
+        }
+    }, null, 2));
+    const missingJanitor = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team' });
+    if (missingJanitor.ok || !missingJanitor.issues.includes('agent_janitor_missing_or_not_ok'))
+        issues.push('negative_fixture_missing_janitor_false_passed');
+    fs.writeFileSync(proofPath, JSON.stringify({ ...baseProof, route: '$Release-Review', evidence: {} }, null, 2));
+    const releaseReview = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Release-Review' });
+    if (releaseReview.ok || !releaseReview.issues.includes('agent_proof_evidence_missing'))
+        issues.push('negative_fixture_release_review_missing_agents_false_passed');
+}
+//# sourceMappingURL=route-proof-artifact-structure-check.js.map