sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,134 @@
+#!/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/release-wiring-3110-blackbox.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { assertGate, emitGate, readText, root } from './sks-1-18-gate-lib.js';
+import { REQUIRED_3110_RELEASE_IDS, buildReleaseGateScriptParityReport } from './release-gate-script-parity-check.js';
+import { writeJsonAtomic } from '../core/fsx.js';
+const required = REQUIRED_3110_RELEASE_IDS;
+const parity = buildReleaseGateScriptParityReport();
+const dag = readText('src/scripts/release-dag-full-coverage-check.ts');
+const missingDag = required.filter((id) => !dag.includes(`'${id}'`));
+const report = {
+    schema: 'sks.release-wiring-3110-blackbox.v1',
+    ok: parity.ok && missingDag.length === 0,
+    required_count: required.length,
+    missing_scripts: parity.missing_scripts,
+    missing_gates: parity.missing_gates,
+    missing_release_preset: parity.missing_release_preset,
+    missing_required_ids: missingDag,
+    wrong_commands: parity.wrong_commands,
+    missing_sources: parity.missing_source_targets,
+    missing_dist_targets: parity.missing_dist_targets,
+    generated_at: new Date().toISOString()
+};
+const out = path.join(root, '.sneakoscope', 'reports', 'release-wiring-3110-blackbox.json');
+await writeJsonAtomic(out, report);
+assertGate(report.ok, '3.1.10 release wiring blackbox failed', report);
+emitGate('release:wiring-3110-blackbox', { required_count: required.length });
+//# sourceMappingURL=release-wiring-3110-blackbox.js.map

package/dist/scripts/release-wiring-3112-blackbox.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { assertGate, emitGate, readJson } from './sks-1-18-gate-lib.js';
+import { REQUIRED_3112_REAL_CHECK_IDS, REQUIRED_3112_RELEASE_IDS } from './release-3112-required-gates.js';
+const scripts = readJson('package.json').scripts || {};
+const gates = readJson('release-gates.v2.json').gates || [];
+const gateIds = new Set(gates.map((gate) => gate.id));
+for (const id of REQUIRED_3112_RELEASE_IDS) {
+    assertGate(Boolean(scripts[id]), `3.1.12 release script missing: ${id}`);
+    assertGate(gateIds.has(id), `3.1.12 release gate missing: ${id}`);
+}
+for (const id of REQUIRED_3112_REAL_CHECK_IDS) {
+    const gate = gates.find((entry) => entry.id === id);
+    assertGate(Boolean(scripts[id]), `3.1.12 real-check script missing: ${id}`);
+    assertGate(Boolean(gate) && gate.preset.includes('real-check'), `3.1.12 real-check gate missing real-check preset: ${id}`, gate);
+}
+emitGate('release:wiring-3112-blackbox', { release_ids: REQUIRED_3112_RELEASE_IDS.length, real_check_ids: REQUIRED_3112_REAL_CHECK_IDS.length });
+//# sourceMappingURL=release-wiring-3112-blackbox.js.map

package/dist/scripts/release-wiring-3113-blackbox.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { assertGate, emitGate, readJson } from './sks-1-18-gate-lib.js';
+import { REQUIRED_3113_REAL_CHECK_IDS, REQUIRED_3113_RELEASE_IDS } from './release-3113-required-gates.js';
+const scripts = readJson('package.json').scripts || {};
+const gates = readJson('release-gates.v2.json').gates || [];
+const gateIds = new Set(gates.map((gate) => gate.id));
+for (const id of REQUIRED_3113_RELEASE_IDS) {
+    assertGate(Boolean(scripts[id]), `3.1.13 release script missing: ${id}`);
+    assertGate(gateIds.has(id), `3.1.13 release gate missing: ${id}`);
+}
+for (const id of REQUIRED_3113_REAL_CHECK_IDS) {
+    const gate = gates.find((entry) => entry.id === id);
+    assertGate(Boolean(scripts[id]), `3.1.13 real-check script missing: ${id}`);
+    assertGate(Boolean(gate) && gate.preset.includes('real-check'), `3.1.13 real-check gate missing real-check preset: ${id}`, gate);
+}
+emitGate('release:wiring-3113-blackbox', { release_ids: REQUIRED_3113_RELEASE_IDS.length, real_check_ids: REQUIRED_3113_REAL_CHECK_IDS.length });
+//# sourceMappingURL=release-wiring-3113-blackbox.js.map

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

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

@@ -0,0 +1,5 @@
+#!/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-blueprint-densifier-check.js

@@ -0,0 +1,21 @@
+#!/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 dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-blueprint-'));
+const plan = await research.writeResearchPlan(dir, 'blueprint densifier blackbox', { missionId: 'M-BLUEPRINT' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const blueprint = JSON.parse(fs.readFileSync(path.join(dir, 'implementation-blueprint.json'), 'utf8'));
+assertGate(blueprint.repository_aware === true, 'blueprint must be repository-aware', blueprint);
+assertGate((blueprint.existing_files || []).length > 0, 'blueprint must list concrete existing files', blueprint);
+assertGate((blueprint.sections || []).length >= 8, 'blueprint must keep required sections', blueprint);
+assertGate((blueprint.test_commands || []).some((cmd) => String(cmd).includes('research:stage-cycle-runtime-blackbox')), 'blueprint must include concrete test commands', blueprint);
+assertGate(fs.existsSync(path.join(dir, 'team-handoff-goal.md')), 'team handoff goal must exist');
+emitGate('research:blueprint-densifier', { dir, sections: blueprint.sections.length, files: blueprint.existing_files.length });
+//# sourceMappingURL=research-blueprint-densifier-check.js.map

package/dist/scripts/research-claim-builder-check.js

@@ -0,0 +1,19 @@
+#!/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 dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-claim-builder-'));
+const plan = await research.writeResearchPlan(dir, 'claim builder blackbox', { missionId: 'M-CLAIM-BUILDER' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const matrix = JSON.parse(fs.readFileSync(path.join(dir, 'claim-evidence-matrix.json'), 'utf8'));
+assertGate(matrix.key_claim_ids.length >= 8, 'claim builder must produce key claims', matrix);
+assertGate(matrix.triangulated_claim_count >= 6, 'claim builder must triangulate claims', matrix);
+assertGate((matrix.unsupported_claims || []).length === 0, 'claim builder must not leave important claims unsupported in complete fixture', matrix);
+emitGate('research:claim-builder', { dir, key_claims: matrix.key_claim_ids.length, triangulated: matrix.triangulated_claim_count });
+//# sourceMappingURL=research-claim-builder-check.js.map

package/dist/scripts/research-complete-package-fixture-check.js

@@ -0,0 +1,29 @@
+#!/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 quality = await importDist('core/research/research-report-quality.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-complete-package-'));
+const plan = await research.writeResearchPlan(dir, 'complete package fixture blackbox', { missionId: 'M-COMPLETE-PACKAGE' });
+const gate = await research.writeMockResearchResult(dir, plan);
+const metrics = gate.metrics || {};
+const reportQuality = quality.analyzeResearchReportQuality(fs.readFileSync(path.join(dir, 'research-report.md'), 'utf8'));
+assertGate(gate.passed === true, 'complete mock research package must pass', gate);
+assertGate(metrics.report_word_count >= 2200, 'report must satisfy word floor', metrics);
+assertGate(fs.existsSync(path.join(dir, 'research-synthesis-output.json')), 'synthesis output must exist');
+assertGate(metrics.source_entries_total_with_counterevidence >= 12, 'source count must satisfy contract', metrics);
+assertGate(metrics.source_layers_covered >= 5, 'source layer coverage must satisfy contract', metrics);
+assertGate(metrics.key_claims >= 8, 'key claims must satisfy contract', metrics);
+assertGate(metrics.counterevidence_sources >= 2, 'counterevidence count must satisfy contract', metrics);
+assertGate(metrics.final_review_approved === true, 'static plus mock Codex final review must approve', metrics);
+assertGate(metrics.implementation_blueprint_validation?.ok === true, 'blueprint must validate', metrics);
+assertGate(metrics.experiment_plan_validation?.ok === true, 'experiment plan must validate', metrics);
+assertGate(metrics.replication_pack_validation?.ok === true, 'replication pack must validate', metrics);
+assertGate(reportQuality.ok === true, 'complete package report must pass anti-template quality checks', reportQuality);
+assertGate(reportQuality.repetition.repeated_paragraph_ratio <= 0.18, 'complete package must not rely on repeated paragraphs', reportQuality.repetition);
+assertGate(reportQuality.repetition.template_phrase_hits.length === 0, 'complete package must not contain template phrases', reportQuality.repetition);
+emitGate('research:complete-package-fixture', { dir, metrics, report_quality: reportQuality });
+//# sourceMappingURL=research-complete-package-fixture-check.js.map

package/dist/scripts/research-execution-profile-routing-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
+await runDirective315Gate('research:execution-profile-routing');
+//# sourceMappingURL=research-execution-profile-routing-check.js.map

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

@@ -0,0 +1,70 @@
+#!/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-handoff-consumability-check.js

@@ -0,0 +1,23 @@
+#!/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 dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-handoff-'));
+const plan = await research.writeResearchPlan(dir, 'handoff consumability blackbox', { missionId: 'M-HANDOFF-CONSUMABILITY' });
+await research.writeMockResearchResult(dir, plan);
+const handoff = fs.readFileSync(path.join(dir, 'team-handoff-goal.md'), 'utf8');
+for (const heading of ['Context', 'Key Claims', 'Evidence Summary', 'Implementation Blueprint', 'Parallel Work Items', 'Acceptance Tests', 'Rollback Plan', 'Source Appendix']) {
+    assertGate(handoff.includes(`## ${heading}`), `handoff missing section: ${heading}`, handoff);
+}
+const workItems = handoff.match(/^\d+\. .+$/gm) || [];
+assertGate(workItems.length >= 4, 'handoff must include at least 4 parallel work items', { workItems });
+for (const item of workItems) {
+    assertGate(/Files: (?!explicit blocker: file list missing).+/.test(item) || item.includes('explicit blocker:'), 'work item must include files or explicit blocker', item);
+}
+assertGate(handoff.includes('$Team') || handoff.includes('$Naruto'), 'handoff must name Team or Naruto route', handoff);
+assertGate(!handoff.includes('Sources: explicit blocker: source ids missing'), 'mock handoff must not include unsupported claims without source ids', handoff);
+emitGate('research:handoff-consumability', { dir, work_item_count: workItems.length });
+//# sourceMappingURL=research-handoff-consumability-check.js.map

package/dist/scripts/research-parallel-source-shards-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraph = await importDist('core/research/research-work-graph.js');
+const graph = workGraph.buildResearchWorkGraph({ mission_id: 'M-PARALLEL-SHARDS' });
+const shards = graph.work_items.filter((item) => item.stage_kind === 'source_shard');
+const shardIds = new Set(shards.map((item) => item.id));
+const claim = graph.work_items.find((item) => item.id === 'claim_matrix_build');
+const merge = graph.work_items.find((item) => item.id === 'source_ledger_merge');
+assertGate(shards.length >= 8, 'work graph must create source layer shards', { count: shards.length });
+assertGate(shards.some((item) => item.id === 'source_shard_academic_literature'), 'academic source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_official_government_data'), 'official government source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_standards_primary_docs'), 'standards source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_news_current_events'), 'news source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_public_discourse'), 'public discourse source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_developer_practitioner'), 'developer practitioner source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_counterevidence_factcheck'), 'counterevidence source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_local_project_evidence'), 'local project evidence source shard missing');
+assertGate(merge && merge.dependencies.every((id) => shardIds.has(id)), 'source merge must depend on every source shard', merge);
+assertGate(claim && [...shardIds].every((id) => claim.dependencies.includes(id)), 'claim matrix must depend on source shards', claim);
+emitGate('research:parallel-source-shards', { shard_count: shards.length });
+//# sourceMappingURL=research-parallel-source-shards-check.js.map

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

@@ -0,0 +1,112 @@
+#!/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', 'runResearchStaticFinalReview', 'runResearchCodexFinalReviewer', 'template_like_prose', 'source_density_ok', 'implementation_concreteness_ok', 'evidence_bound_synthesis_ok']);
+        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', 'RESEARCH_SOURCE_LAYERS', 'source_shard_local_project_evidence']);
+        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']);
+    },
+    'report-quality': () => {
+        assertFileIncludes('src/core/research/research-report-quality.ts', ['analyzeResearchReportQuality', 'REQUIRED_RESEARCH_REPORT_HEADINGS', 'research_report_references_missing_source_ids', 'source_density_per_1000_words', 'claim_density_per_1000_words', 'analyzeResearchRepetition']);
+        assertFileIncludes('src/core/research.ts', ['report_word_count', 'report_quality', 'research_report_too_short', 'report_repetition']);
+    },
+    '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',
+            'schemas/research/research-source-shard.schema.json',
+            'schemas/research/research-synthesis-output.schema.json'
+        ])
+            assertGate(readText(file).includes('"$schema"'), `${file} missing JSON Schema header`);
+    },
+    'stage-cycle-runner': () => {
+        assertFileIncludes('src/core/research/research-cycle-runner.ts', ['readyStages', 'Promise.race', 'max_observed_parallel', 'critical_path_length']);
+        assertFileIncludes('src/core/research/research-stage-runner.ts', ['ResearchStageResult', 'runSourceShardStage', 'runFinalReviewStage', 'cycle-${input.cycle}', 'stages']);
+    },
+    'parallel-source-shards': () => {
+        assertFileIncludes('src/core/research/research-work-graph.ts', ['source_shard_academic_literature', 'source_shard_official_government_data', 'source_shard_counterevidence_factcheck', 'source_shard_local_project_evidence']);
+        assertFileIncludes('src/core/research/research-source-shards.ts', ['ResearchSourceShardOutput', 'validateResearchSourceShardOutput', 'source_shard_empty_without_blocker']);
+    },
+    'source-ledger-merge': () => {
+        assertFileIncludes('src/core/research/research-source-ledger-merge.ts', ['mergeResearchSourceShards', 'source-ledger.json', 'source-quality-report.json', 'dedupeSources']);
+    },
+    'claim-builder': () => {
+        assertFileIncludes('src/core/research/research-claim-builder.ts', ['buildClaimEvidenceMatrixFromSourceShards', 'unsupported_important_claim', 'counterevidence_ids']);
+    },
+    'blueprint-densifier': () => {
+        assertFileIncludes('src/core/research/implementation-blueprint-densifier.ts', ['densifyImplementationBlueprint', 'git', 'ls-files', 'existing_files', 'parallel_work_decomposition']);
+    },
+    'real-cycle-no-legacy-final-md': () => {
+        assertFileIncludes('src/core/commands/research-command.ts', ['--legacy-research-cycle', 'SKS_RESEARCH_LEGACY_CYCLE', 'const cycleResult = await runResearchCycle({', 'legacy_final_md_loop']);
+    }
+};
+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/research-real-cycle-no-legacy-final-md-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const source = readText('src/core/commands/research-command.ts');
+const defaultIndex = source.indexOf('const cycleResult = await runResearchCycle({');
+const legacyIndex = source.indexOf('const legacyResearchCycle');
+const legacyExecIndex = source.indexOf('runCodexExec({');
+assertGate(defaultIndex > 0, 'default research run must call runResearchCycle with object input');
+assertGate(source.includes('--legacy-research-cycle'), 'legacy research cycle flag must exist');
+assertGate(source.includes('SKS_RESEARCH_LEGACY_CYCLE'), 'legacy research cycle env flag must exist');
+assertGate(source.includes('legacy_final_md_loop'), 'legacy final.md loop must be explicitly marked');
+assertGate(legacyExecIndex > legacyIndex, 'runCodexExec final.md path must live after legacy gate');
+emitGate('research:real-cycle-no-legacy-final-md', { defaultIndex, legacyIndex, legacyExecIndex });
+//# sourceMappingURL=research-real-cycle-no-legacy-final-md-check.js.map

package/dist/scripts/research-real-synthesis-no-deterministic-renderer-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const source = readText('src/core/research/research-stage-runner.ts');
+const start = source.indexOf('async function runSynthesisStage');
+const end = source.indexOf('async function runDeterministicMockSynthesisStage');
+const runSynthesisStage = source.slice(start, end);
+assertGate(start >= 0 && end > start, 'runSynthesisStage and mock branch must exist');
+assertGate(runSynthesisStage.includes("input.backend === 'mock'") && runSynthesisStage.includes("input.backend === 'deterministic'"), 'synthesis stage must branch mock/deterministic explicitly', runSynthesisStage);
+assertGate(runSynthesisStage.includes('runResearchCodexSynthesisWriter'), 'non-mock synthesis must call runResearchCodexSynthesisWriter', runSynthesisStage);
+assertGate(!runSynthesisStage.includes('buildDeterministicMockResearchReport'), 'non-mock branch must not call deterministic report builder', runSynthesisStage);
+assertGate(source.includes('synthesis_writer'), 'synthesis stage result metrics must include synthesis_writer', source);
+emitGate('research:real-synthesis-no-deterministic-renderer', { ok: true });
+//# sourceMappingURL=research-real-synthesis-no-deterministic-renderer-check.js.map

package/dist/scripts/research-repetition-detector-check.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const detector = await importDist('core/research/research-repetition-detector.js');
+const realistic = await importDist('core/research/research-realistic-report.js');
+const repeated = Array.from({ length: 30 }, (_unused, index) => `Runtime evidence note ${index + 1}: This paragraph exists to make report quality measurable while a deterministic fixture repeats the same claim with source-${index % 2}.`).join('\n\n');
+const bad = detector.analyzeResearchRepetition(repeated);
+assertGate(bad.ok === false, 'repeated template prose must fail', bad);
+assertGate(bad.blockers.some((reason) => reason.startsWith('research_report_template_phrase_hit:')), 'template phrase blocker missing', bad);
+const goodText = realistic.buildRealisticResearchReport({
+    plan: { mission_id: 'M-REPETITION-GOOD', prompt: 'repetition detector check' },
+    sourceIds: Array.from({ length: 14 }, (_unused, index) => `source-${index + 1}`),
+    counterevidenceIds: ['counter-1', 'counter-2']
+});
+const good = detector.analyzeResearchRepetition(goodText);
+assertGate(good.ok === true, 'realistic varied report should pass repetition detector', good);
+assertGate(good.repeated_paragraph_ratio <= 0.18, 'realistic report repeated paragraph ratio too high', good);
+emitGate('research:repetition-detector', { bad, good });
+//# sourceMappingURL=research-repetition-detector-check.js.map

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

@@ -0,0 +1,46 @@
+#!/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-short-report-'));
+const plan = await research.writeResearchPlan(dir, 'short report rejection blackbox', { missionId: 'M-SHORT-REPORT' });
+await fsx.writeTextAtomic(path.join(dir, 'research-report.md'), `# Short Report\n\n${Array.from({ length: 300 }, (_unused, index) => `word${index}`).join(' ')}\n`);
+await fsx.writeJsonAtomic(path.join(dir, 'source-ledger.json'), {
+    schema_version: 1,
+    web_search_passes: 1,
+    source_layers: [{ id: 'academic_literature', label: 'Academic literature', required: true, status: 'covered', source_ids: ['short-source-1'], counterevidence_ids: [] }],
+    sources: [{
+            id: 'short-source-1',
+            layer: 'academic_literature',
+            kind: 'fixture',
+            title: 'One source',
+            locator: 'fixture://one',
+            publisher_or_author: 'fixture',
+            accessed_at: new Date().toISOString(),
+            reliability: 'low',
+            credibility: 'thin',
+            stance: 'supports',
+            claim_ids: ['short-claim-1'],
+            notes: 'Only one source should not satisfy the research quality contract.'
+        }],
+    counterevidence_sources: [],
+    triangulation: { cross_layer_checks: [], conflicts: [], synthesis_notes: [] },
+    citation_coverage: { all_key_claims_cited: false, key_claim_ids: ['short-claim-1'], cited_claim_ids: ['short-claim-1'], uncited_claim_ids: [], source_claim_map: { 'short-source-1': ['short-claim-1'] } },
+    blockers: []
+});
+await fsx.writeJsonAtomic(path.join(dir, 'claim-evidence-matrix.json'), { schema: 'sks.claim-evidence-matrix.v1', mission_id: plan.mission_id, claims: [], key_claim_ids: [], unsupported_claims: [], triangulated_claim_count: 0, blockers: [] });
+await fsx.writeJsonAtomic(path.join(dir, 'implementation-blueprint.json'), { schema: 'sks.research-implementation-blueprint.v1', sections: [] });
+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, 'summary-only package must be blocked', gate);
+for (const reason of ['research_report_too_short', 'source_entries_below_research_quality_contract', 'key_claims_below_contract', 'research_final_review_not_approved']) {
+    assertGate(reasons.has(reason), `missing rejection reason: ${reason}`, gate);
+}
+assertGate(reasons.has('implementation_blueprint_incomplete_sections') || reasons.has('implementation_blueprint_missing') || reasons.has('implementation_blueprint_sections_below_contract'), 'missing blueprint rejection reason', gate);
+emitGate('research:short-report-rejection', { dir, reasons: gate.reasons });
+//# sourceMappingURL=research-short-report-rejection-check.js.map