sneakoscope 6.0.3 → 6.1.2

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

@@ -1,158 +1,46 @@
 import { nowIso } from './fsx.js';
-export const RELEASE_PARALLEL_FULL_COVERAGE_SCHEMA = 'sks.release-parallel-full-coverage.v1';
-export const RELEASE_1_17_GATE_SNAPSHOT = Object.freeze([
-    'build',
-    'runtime:no-src-mjs',
-    'runtime:ts-source-of-truth',
-    'architecture:guard',
-    'runtime:dist-parity',
-    'routes:proof-artifact-structure',
-    'agent:codex-app-cockpit',
-    'agent:janitor',
-    'agent:multi-project-isolation',
-    'verification:parallel-engine',
-    'typecheck',
-    'schema:check',
-    'release:metadata',
-    'release:readiness'
-]);
-export const RELEASE_1_18_REQUIRED_GATES = Object.freeze([
-    'super-search:provider-interface',
-    'source-intelligence:policy',
-    'source-intelligence:all-modes',
-    'codex-web:adapter',
-    'goal-mode:official-default',
-    'agent:main-no-scout',
-    'agent:worker-scout-limited',
-    'agent:background-terminals',
-    'agent:zellij-runtime',
-    'agent:dynamic-pool',
-    'agent:backfill-replenishment',
-    'agent:scheduler-proof',
-    'agent:session-generation',
-    'agent:terminal-generations',
-    'mad-sks:zellij-launch',
-    'agent:dynamic-cockpit',
-    'agent:source-intelligence-propagation',
-    'agent:goal-mode-propagation',
-    'agent:visual-consistency',
-    'release:parallel-full-coverage',
-    'priority:full-closure',
-    'release:native-agent-backend',
-    'agent:legacy-multiagent-removed',
-    'all-features:completion',
-    'all-features:deep-completion',
-    'json-schema:recursive-check',
-    'evidence:flagship-coverage',
-    'image-fidelity:check',
-    'imagegen:capability',
-    'imagegen:gpt-image-2-request-validator',
-    'ux-review:run-wires-imagegen',
-    'ux-review:extract-wires-real-extractor',
-    'ux-review:patch-diff-recheck',
-    'ux-review:imagegen-blackbox',
-    'ux-review:real-loop-fixture',
-    'ux-review:generate-callouts-fixture',
-    'ux-review:extract-real-callouts-fixture',
-    'ux-review:patch-handoff-fixture',
-    'ux-review:recapture-recheck-fixture',
-    'ux-review:no-text-fallback',
-    'ux-review:no-fake-callouts',
-    'ux-review:image-voxel-relations',
-    'ppt:imagegen-review-fixture',
-    'ppt:full-e2e-blackbox',
-    'ppt:full-e2e-artifact-graph',
-    'ppt:real-export-adapter',
-    'ppt:real-imagegen-wiring',
-    'ppt:reexport-rereview',
-    'ppt:imagegen-blackbox',
-    'ux-ppt:structured-extraction',
-    'ppt:slide-export-fixture',
-    'ppt:no-text-fallback',
-    'ppt:no-mock-as-real',
-    'ppt:issue-extraction-fixture',
-    'ppt:image-voxel-relations',
-    'ppt:proof-trust-fixture',
-    'dfix:fixture',
-    'dfix:fast-kernel',
-    'dfix:blackbox-fast',
-    'dfix:performance',
-    'dfix:patch-handoff',
-    'dfix:verification-recommendation',
-    'dfix:verification',
-    'hooks:strict-subset-check',
-    'hooks:latest-schema-check',
-    'hooks:trust-state-check',
-    'hooks:trust-warning-zero',
-    'hooks:subagent-events-check',
-    'hooks:no-unsupported-handlers',
-    'hooks:actual-parity-check',
-    'hooks:actual-parity-v2',
-    'hooks:official-hash-parity',
-    'hooks:official-hash-oracle',
-    'hooks:managed-install-fixture',
-    'hooks:runtime-replay-warning-zero',
-    'hooks:runtime-replay-warning-zero-v2',
-    'codex-lb:persistence-truth',
-    'codex-lb:setup-truthfulness',
-    'computer-use:visual-route-fixture',
-    'computer-use:live-evidence',
-    'codex:0.133-compat',
-    'codex:output-schema-fixture',
-    'codex:exec-syntax-parity',
-    'codex:0.133-official-compat',
-    'flagship:proof-graph-v3',
-    'flagship:proof-graph-v4',
-    'mad-sks:permission-model',
-    'mad-sks:immutable-harness',
-    'mad-sks:write-guard',
-    'mad-sks:audit-proof',
-    'mad-sks:no-harness-modification',
-    'mad-sks:actual-executor',
-    'mad-sks:file-write-executor',
-    'mad-sks:shell-executor',
-    'mad-sks:package-executor',
-    'mad-sks:service-executor',
-    'mad-sks:db-executor',
-    'mad-sks:rollback-apply',
-    'mad-sks:live-guard-smoke',
-    'mad-sks:executor-proof-graph',
-    'memory-summary:rebuild-check',
-    'loop-blocker:check',
-    'docs:truthfulness',
-    'official-docs:compat',
-    'blackbox:matrix:contract',
-    'test:blackbox',
-    'rust:check',
-    'rust:smoke',
-    'release:dist-freshness',
-    'perf:gate'
-]);
+import { RELEASE_GATE_CONTRACT_IDS, releaseGateContractSnapshot } from './release/release-gate-contract.js';
+export const RELEASE_PARALLEL_FULL_COVERAGE_SCHEMA = 'sks.release-parallel-full-coverage.v2';
+// Compatibility export: the independent, versioned contract is now the full
+// release preset, not a self-authorizing critical subset.
+export const RELEASE_DAG_CRITICAL_GATES = RELEASE_GATE_CONTRACT_IDS;
 export function evaluateReleaseParallelFullCoverage(currentGateIds) {
-    const current = [...new Set(currentGateIds)];
-    const previousMissing = RELEASE_1_17_GATE_SNAPSHOT.filter((gate) => !current.includes(gate));
-    const requiredMissing = RELEASE_1_18_REQUIRED_GATES.filter((gate) => !current.includes(gate));
+    const raw = currentGateIds.map(String).filter(Boolean);
+    const current = [...new Set(raw)].sort();
+    const contract = releaseGateContractSnapshot();
+    const missingCritical = contract.ids.filter((gate) => !current.includes(gate));
+    const unexpectedGates = current.filter((gate) => !contract.ids.includes(gate));
+    const duplicateGateIds = [...new Set(raw.filter((id, index) => raw.indexOf(id) !== index))].sort();
     const independentGroups = {
-        source_intelligence: current.filter((gate) => /source-intelligence|xai|codex-web|goal-mode/.test(gate)),
-        agent_runtime: current.filter((gate) => /agent:/.test(gate)),
-        release_readiness: current.filter((gate) => /release:|priority:/.test(gate)),
-        baseline: current.filter((gate) => RELEASE_1_17_GATE_SNAPSHOT.includes(gate))
+        release_integrity: current.filter((gate) => /^(?:architecture:|policy:|release:|typecheck$|schema:check$)/.test(gate)),
+        official_subagents: current.filter((gate) => /official-subagent|native-agent|naruto:/.test(gate)),
+        runtime_recovery: current.filter((gate) => /codex-lb|runtime-recovery|responses:/.test(gate)),
+        feature_closure: current.filter((gate) => /all-features|feature|research:/.test(gate))
     };
     return {
         schema: RELEASE_PARALLEL_FULL_COVERAGE_SCHEMA,
         generated_at: nowIso(),
-        ok: previousMissing.length === 0 && requiredMissing.length === 0,
-        previous_gate_count: RELEASE_1_17_GATE_SNAPSHOT.length,
+        ok: current.length > 0
+            && current.length <= 200
+            && missingCritical.length === 0
+            && unexpectedGates.length === 0
+            && duplicateGateIds.length === 0,
+        authoritative_source: 'src/core/release/release-gate-contract.ts',
+        manifest_source: 'release-gates.v2.json',
+        release_gate_contract: contract,
+        legacy_runner_snapshot_retired: true,
+        critical_gate_count: RELEASE_DAG_CRITICAL_GATES.length,
         current_gate_count: current.length,
-        previous_gate_snapshot: [...RELEASE_1_17_GATE_SNAPSHOT],
         current_gate_list: current,
-        missing_previous_gates: previousMissing,
-        missing_1_18_required_gates: requiredMissing,
-        coverage_regression: previousMissing.length > 0,
+        missing_critical_gates: missingCritical,
+        unexpected_release_gates: unexpectedGates,
+        duplicate_gate_ids: duplicateGateIds,
+        gate_budget_ok: current.length > 0 && current.length <= 200,
+        coverage_regression: missingCritical.length > 0 || unexpectedGates.length > 0,
         independent_groups: independentGroups,
         speedup_summary: {
             parallel_groups: Object.values(independentGroups).filter((rows) => rows.length > 0).length,
-            estimated_speedup: current.length > 1 ? 'parallel DAG preserves baseline coverage and adds independent 1.18 groups' : 'none'
+            execution_model: 'manifest-backed parallel DAG'
         }
     };
 }

package/dist/core/research/claim-evidence-matrix.js

@@ -34,11 +34,6 @@ export function validateClaimEvidenceMatrix(matrix, sourceLedger = null, falsifi
     const normalized = normalizeClaimEvidenceMatrix(matrix);
     const claimIds = new Set(normalized.claims.map((claim) => claim.id));
     const sourceIds = sourceIdSet(sourceLedger);
-    const counterIds = new Set([
-        ...Array.from(sourceIds).filter((id) => /counter/i.test(id)),
-        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources.map((row) => String(row?.id || '')).filter(Boolean) : []),
-        ...(Array.isArray(falsificationLedger?.cases) ? falsificationLedger.cases.flatMap((row) => [row?.id, ...(Array.isArray(row?.counterevidence_source_ids) ? row.counterevidence_source_ids : []), ...(Array.isArray(row?.source_ids) ? row.source_ids : [])]).map(String).filter(Boolean) : [])
-    ]);
     const blockers = [];
     for (const id of normalized.key_claim_ids)
         if (!claimIds.has(id))
@@ -53,8 +48,25 @@ export function validateClaimEvidenceMatrix(matrix, sourceLedger = null, falsifi
             if (!sourceIds.has(sourceId))
                 blockers.push(`claim_source_unknown:${claim.id}:${sourceId}`);
         for (const counterId of claim.counterevidence_ids)
-            if (!counterIds.has(counterId))
+            if (!sourceIds.has(counterId))
                 blockers.push(`claim_counterevidence_unknown:${claim.id}:${counterId}`);
+        const linkedCounterIds = new Set(claim.counterevidence_links
+            .filter((link) => link.target_claim_id === claim.id && link.contradiction_rationale.trim())
+            .map((link) => link.source_id));
+        for (const counterId of claim.counterevidence_ids) {
+            if (!linkedCounterIds.has(counterId))
+                blockers.push(`claim_counterevidence_link_missing:${claim.id}:${counterId}`);
+        }
+        for (const link of claim.counterevidence_links) {
+            if (link.target_claim_id !== claim.id)
+                blockers.push(`claim_counterevidence_target_mismatch:${claim.id}:${link.source_id}`);
+            if (!sourceIds.has(link.source_id))
+                blockers.push(`claim_counterevidence_link_source_unknown:${claim.id}:${link.source_id}`);
+            if (!claim.counterevidence_ids.includes(link.source_id))
+                blockers.push(`claim_counterevidence_link_unlisted:${claim.id}:${link.source_id}`);
+            if (!link.contradiction_rationale.trim())
+                blockers.push(`claim_counterevidence_rationale_missing:${claim.id}:${link.source_id}`);
+        }
         if (claim.claim_type === 'hypothesis' && !claim.test_or_probe.trim())
             blockers.push(`hypothesis_probe_missing:${claim.id}`);
     }
@@ -99,6 +111,11 @@ export function buildClaimEvidenceMatrixFromLedgers(input = {}) {
             importance: index < 2 ? 'critical' : 'high',
             source_ids: sourceIds.length ? sourceIds : fallbackSourceIds.slice(0, 2),
             counterevidence_ids: counterIds.length ? counterIds : fallbackCounterIds.slice(0, 1),
+            counterevidence_links: (counterIds.length ? counterIds : fallbackCounterIds.slice(0, 1)).map((sourceId) => ({
+                source_id: sourceId,
+                target_claim_id: id,
+                contradiction_rationale: `The structured counterevidence row challenges ${id}.`
+            })),
             triangulation: {
                 source_layers: sourceLayersForSourceIds(input.sourceLedger, sourceIds.length ? sourceIds : fallbackSourceIds),
                 independent_confirmation_count: Math.max(1, sourceIds.length || fallbackSourceIds.length),
@@ -131,6 +148,7 @@ function normalizeClaim(value) {
         source_ids: normalizeStringList(value?.source_ids),
         local_evidence_ids: normalizeStringList(value?.local_evidence_ids),
         counterevidence_ids: normalizeStringList(value?.counterevidence_ids),
+        counterevidence_links: normalizeCounterevidenceLinks(value?.counterevidence_links),
         triangulation: {
             source_layers: normalizeStringList(value?.triangulation?.source_layers),
             independent_confirmation_count: Math.max(0, Math.floor(Number(value?.triangulation?.independent_confirmation_count || 0))),
@@ -141,6 +159,23 @@ function normalizeClaim(value) {
         test_or_probe: String(value?.test_or_probe || '').trim()
     };
 }
+function normalizeCounterevidenceLinks(value) {
+    const rows = Array.isArray(value) ? value : [];
+    const seen = new Set();
+    return rows.map((row) => ({
+        source_id: String(row?.source_id || '').trim(),
+        target_claim_id: String(row?.target_claim_id || '').trim(),
+        contradiction_rationale: String(row?.contradiction_rationale || '').trim()
+    })).filter((row) => {
+        if (!row.source_id || !row.target_claim_id || !row.contradiction_rationale)
+            return false;
+        const key = `${row.source_id}\0${row.target_claim_id}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 function sourceIdSet(sourceLedger) {
     return new Set([
         ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),

package/dist/core/research/experiment-plan.js

@@ -2,23 +2,27 @@ import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 export const EXPERIMENT_PLAN_JSON_ARTIFACT = 'experiment-plan.json';
 export const EXPERIMENT_PLAN_MARKDOWN_ARTIFACT = 'experiment-plan.md';
-export function defaultExperimentPlan(plan = null) {
+export function defaultExperimentPlan(plan = null, opts = {}) {
     const prompt = String(plan?.prompt || 'research mission');
+    const claims = Array.isArray(opts.claimMatrix?.claims) ? opts.claimMatrix.claims : [];
+    const primaryClaim = claims.find((claim) => claim.importance === 'critical' || claim.importance === 'high') || claims[0];
+    const hypothesis = String(primaryClaim?.claim || prompt).trim();
+    const primaryClaimId = String(primaryClaim?.id || 'primary-hypothesis');
     return {
         schema: 'sks.research-experiment-plan.v1',
         generated_at: nowIso(),
         prompt,
-        hypothesis: 'The surviving research claim should produce a measurable improvement over a summary-only baseline.',
+        hypothesis: `Under the stated boundary conditions, the evidence-backed claim “${hypothesis}” should produce an observable result that distinguishes it from a simpler alternative explanation.`,
         steps: [
-            { id: 'E1', action: 'Select one baseline output and one research-pipeline output for the same prompt.', expected_evidence: ['research-report.md'] },
-            { id: 'E2', action: 'Score cited key claims, triangulation, counterevidence, and unsupported claims.', expected_evidence: ['claim-evidence-matrix.json'] },
-            { id: 'E3', action: 'Run or design the smallest probe implied by the implementation blueprint.', expected_evidence: ['implementation-blueprint.json'] },
-            { id: 'E4', action: 'Compare failure cases and falsification outcomes.', expected_evidence: ['falsification-ledger.json'] },
-            { id: 'E5', action: 'Record replication commands, artifacts, and acceptance thresholds.', expected_evidence: ['replication-pack.json'] }
+            { id: 'E1', action: `Operationalize ${primaryClaimId}: define the measurable outcome, units or decision rule, population/system boundary, and the observation window.`, expected_evidence: ['claim-evidence-matrix.json'] },
+            { id: 'E2', action: 'Choose a baseline or null explanation that could plausibly produce the same observation, and record confounders before collecting results.', expected_evidence: ['falsification-ledger.json'] },
+            { id: 'E3', action: 'Reproduce the strongest supporting evidence with the same inputs or an explicitly documented equivalent data source.', expected_evidence: ['source-ledger.json'] },
+            { id: 'E4', action: 'Run the cheapest decisive falsification probe and preserve negative, null, or contradictory outcomes instead of filtering them out.', expected_evidence: ['falsification-ledger.json'] },
+            { id: 'E5', action: 'Compare the observation with the acceptance threshold, update confidence, and publish the procedure, artifacts, and unresolved limitations for independent replication.', expected_evidence: ['replication-pack.json', 'research-report.md'] }
         ],
-        metrics: ['key_claims_supported', 'triangulated_claims', 'counterevidence_sources', 'falsification_cases', 'experiment_steps'],
-        controls: ['summary_only_baseline', 'same_prompt_same_context'],
-        acceptance_threshold: 'All quality-contract thresholds are met and the final reviewer approves the run.'
+        metrics: ['primary_outcome', 'effect_or_difference_from_baseline', 'uncertainty_interval_or_decision_margin', 'replication_success', 'falsification_result'],
+        controls: ['explicit_null_or_baseline', 'same_boundary_conditions', 'counterevidence_preserved'],
+        acceptance_threshold: `Retain ${primaryClaimId} only if the decisive observation exceeds the predeclared decision margin, survives the recorded counterevidence, and is independently reproducible; otherwise downgrade or reject it.`
     };
 }
 export function validateExperimentPlan(experimentPlan = null, contract = null) {

package/dist/core/research/falsification.js

@@ -9,10 +9,17 @@ export function validateFalsificationCoverage(falsificationLedger = null, contra
             && entry.source_ids.length > 0
             && String(entry?.next_decisive_test || '').trim();
     });
+    const unresolved = [
+        ...(Array.isArray(falsificationLedger?.unresolved_failures) ? falsificationLedger.unresolved_failures : []),
+        ...cases.filter((entry) => ['weakened', 'refuted', 'inconclusive'].includes(String(entry?.result || ''))).map((entry) => `${entry?.target_claim || entry?.claim_id || entry?.id}:${entry?.result}`)
+    ].map(String).filter(Boolean);
+    const ledgerBlockers = Array.isArray(falsificationLedger?.blockers) ? falsificationLedger.blockers.map(String).filter(Boolean) : [];
     const blockers = [
         ...(cases.length < minCases ? ['falsification_cases_below_contract'] : []),
-        ...(completeCases.length < minCases ? ['falsification_cases_incomplete'] : [])
+        ...(completeCases.length < minCases ? ['falsification_cases_incomplete'] : []),
+        ...unresolved.map((entry) => `falsification_unresolved:${entry}`),
+        ...ledgerBlockers
     ];
-    return { ok: blockers.length === 0, blockers, cases: cases.length, complete_cases: completeCases.length, min_cases: minCases };
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)], cases: cases.length, complete_cases: completeCases.length, min_cases: minCases };
 }
 //# sourceMappingURL=falsification.js.map

package/dist/core/research/implementation-blueprint-densifier.js

@@ -5,19 +5,68 @@ import { defaultImplementationBlueprint } from './implementation-blueprint.js';
 export async function densifyImplementationBlueprint(input) {
     const fileMap = await repositoryFileMap(input.root);
     const likelyFiles = likelyTargetFiles(fileMap, input.plan, input.claimMatrix);
-    const possibleNewFiles = possibleNewResearchFiles(fileMap);
     const base = input.existingBlueprint || defaultImplementationBlueprint(input.plan);
     const claims = Array.isArray(input.claimMatrix?.claims) ? input.claimMatrix.claims : [];
     const keyClaimIds = Array.isArray(input.claimMatrix?.key_claim_ids) ? input.claimMatrix.key_claim_ids : claims.slice(0, 8).map((claim) => claim.id);
+    const prompt = String(input.plan?.prompt || base.prompt || '');
+    const repositoryScoped = likelyFiles.length >= 3 && repositoryIntent(prompt, claims);
+    const evidenceArtifacts = ['research-plan.json', 'source-ledger.json', 'claim-evidence-matrix.json', 'falsification-ledger.json', 'research-report.md', String(input.plan?.artifacts?.research_paper || input.plan?.paper_artifact || 'research-paper.md')];
+    if (!repositoryScoped) {
+        const sections = [
+            section('problem', 'Research Question And Boundary', `The validation handoff addresses “${prompt}” without converting a general scientific or strategic question into an SKS code-maintenance task. It preserves ${keyClaimIds.length} key claim ids, distinguishes facts from hypotheses, and treats missing evidence as a blocker rather than inventing a repository patch.`, keyClaimIds, evidenceArtifacts.slice(0, 4), ['The question, scope boundary, and disallowed overclaims are explicit.']),
+            section('decision', 'Surviving Decision', `Carry forward only claims that remain source-linked after counterevidence and falsification. The handoff is a research-validation plan, not an implementation promise; any claim that lacks independent confirmation is downgraded or removed before the final paper is used.`, keyClaimIds, evidenceArtifacts.slice(1, 5), ['Every retained key claim has known source ids and a decisive probe.']),
+            section('architecture', 'Evidence Structure', `Organize the result as a dependency chain from source ledger to semantic claim matrix, falsification cases, experiment steps, manuscript synthesis, and independent adversarial review. Each downstream conclusion must remain traceable to the upstream source and claim identifiers.`, keyClaimIds, evidenceArtifacts, ['No conclusion bypasses source, claim, and falsification artifacts.']),
+            section('interfaces', 'Inputs And Outputs', `Inputs are the research question, source locators/content notes, claim-evidence links, and explicit counterevidence. Outputs are a dated paper, an experiment plan, a replication pack, and a list of unresolved limitations that another researcher can independently inspect.`, keyClaimIds, evidenceArtifacts, ['Inputs and outputs are named with reproducible artifact paths.']),
+            section('data_contracts', 'Evidence Contracts', `Each source retains locator, publisher or author, date, credibility, hydrated notes or content hash, and semantic claim links. Each claim retains supporting and undermining source ids, confidence, falsifiability, and the next decisive test; context-only sources never count as support.`, keyClaimIds, ['source-ledger.json', 'claim-evidence-matrix.json'], ['High and critical claims cannot pass on titles, snippets, or duplicated identifiers alone.']),
+            section('execution_plan', 'Step By Step Validation', `1. Reproduce the strongest supporting source for each key claim.\n2. Reproduce the strongest counterevidence and check source independence.\n3. Execute or specify the cheapest decisive falsification test.\n4. Compare observed results with the acceptance threshold.\n5. Downgrade, refute, or retain the claim and update the paper with remaining uncertainty.`, keyClaimIds, ['falsification-ledger.json', 'experiment-plan.json', 'replication-pack.json'], ['Every step produces evidence that can change the claim verdict.']),
+            section('verification_plan', 'Independent Verification', `Use three composite reviewers that independently cover source integrity and claim linkage, methodology and formal validity, and falsification and replication feasibility. Verification passes only when every reviewer has a distinct completed official thread outcome and no critical, major, minor, or required revision remains.`, keyClaimIds, ['research-adversarial-review.json', 'research-adversarial-convergence.json'], ['Three distinct evidence-correlated reviewer outcomes approve with zero open objections.']),
+            section('risks_and_rollbacks', 'Risks, Retractions, And Rollback', `Primary risks are false triangulation, topic drift, publication or novelty overclaim, inaccessible evidence, and an experiment that cannot distinguish the proposed mechanism from a simpler explanation. Rollback means withdrawing the affected claim, restoring the previous manuscript snapshot, and recording the failed assumption in the ledger.`, keyClaimIds, ['research-honest-mode.json', 'research-revision-ledger.json'], ['Unsupported claims are withdrawn without weakening evidence gates.'])
+        ];
+        return {
+            ...base,
+            schema: 'sks.research-implementation-blueprint.v1',
+            generated_at: nowIso(),
+            prompt,
+            implementation_allowed_in_research: false,
+            handoff_route: 'research_validation',
+            handoff_type: 'research_validation',
+            repository_aware: false,
+            domain_research: true,
+            existing_files: evidenceArtifacts,
+            possible_new_files: [],
+            validation_targets: keyClaimIds.length ? keyClaimIds : ['supporting evidence', 'counterevidence', 'falsification result', 'replication feasibility'],
+            api_schema_changes: [],
+            test_commands: [
+                'procedure: reproduce supporting evidence from source-ledger.json',
+                'procedure: run the decisive falsification test from experiment-plan.json',
+                'procedure: independently audit claim links and unresolved objections'
+            ],
+            rollback_steps: [
+                'Withdraw or downgrade claims that fail reproduction or falsification.',
+                'Restore the prior source-linked manuscript and record the invalidated assumption.'
+            ],
+            parallel_work_decomposition: [
+                'Lane A supporting-evidence reproduction.',
+                'Lane B counterevidence and alternative explanations.',
+                'Lane C falsification and experiment design.',
+                'Lane D citation, logic, and replication audit.'
+            ],
+            sections,
+            dependencies: ['source-ledger.json', 'claim-evidence-matrix.json', 'falsification-ledger.json'],
+            out_of_scope: ['Repository source mutation during $Research runs.', 'Guaranteed novelty, genius-level quality, or publication acceptance.'],
+            open_questions: []
+        };
+    }
+    const possibleNewFiles = [];
     const sections = [
-        section('problem', 'Problem', `Research currently must prove it executes stage-aware source shard runtime instead of relying on summary-style final.md output. The handoff should preserve ${keyClaimIds.length} key claim ids and all source-ledger evidence before code work begins.`, keyClaimIds, likelyFiles.slice(0, 8), ['Confirm the follow-up route reads claim-evidence-matrix.json and source-ledger.json before implementation.']),
-        section('decision', 'Decision', 'Use a dependency-aware research cycle with source_shard, source_merge, claim_matrix_build, falsification, implementation_blueprint, experiment_plan, synthesis, final_review, and verification stages. Keep Research read-only against repository source and write only mission artifacts.', keyClaimIds, likelyFiles.slice(0, 8), ['Default research run calls runResearchCycle; legacy final.md loop is opt-in only.']),
-        section('architecture', 'Architecture', 'The runtime is split into source shard generation, source-ledger merge, claim builder, blueprint densifier, final reviewer, blackbox scripts, and CLI status output. Each stage writes a ResearchStageResult under research/cycle-N/stages.', keyClaimIds, likelyFiles, ['Stage result artifacts list concrete output_artifacts for every passed stage.']),
-        section('interfaces', 'API And Schema Changes', `Existing files should expose typed contracts for shard outputs, stage results, merged source ledgers, Codex final review outputs, and concrete blueprint fields. Possible new files: ${possibleNewFiles.join(', ')}.`, keyClaimIds, likelyFiles, ['Schemas exist for research-source-shard and research-final-review.']),
-        section('data_contracts', 'Data Contracts', 'Source rows must preserve id, layer, kind, title, locator, publisher_or_author, accessed_at, reliability, credibility, stance, and claim_ids. Claim rows must preserve source_ids, counterevidence_ids, triangulation layers, confidence, and test_or_probe.', keyClaimIds, ['schemas/research/research-source-shard.schema.json', 'schemas/research/claim-evidence-matrix.schema.json'], ['Source quality report returns ok only when source metadata and citation coverage are complete.']),
-        section('execution_plan', 'Step By Step Implementation', implementationSteps(likelyFiles, possibleNewFiles).join('\n'), keyClaimIds, likelyFiles, ['Run research stage runtime blackbox, short-report rejection, complete-package fixture, and codex-sdk research pipeline gates.']),
-        section('verification_plan', 'Verification Plan', 'Run the release truth, research quality, source shard, source merge, claim builder, blueprint densifier, final reviewer, codex-sdk research pipeline, release DAG, and release check commands listed in the directive.', keyClaimIds, ['package.json', 'release-gates.v2.json', 'src/scripts/release-dag-full-coverage-check.ts'], ['All directive final checklist commands either pass or have a documented blocker.']),
-        section('risks_and_rollbacks', 'Risks And Rollbacks', 'The main risk is accepting deterministic fixture text as public-ready proof. Roll back by disabling new release gates only if the gate itself is wrong, not if implementation is incomplete. Research must block when live Codex/GPT final review is unavailable outside mock fixtures.', keyClaimIds, likelyFiles, ['A rollback keeps source mutation outside Research and restores package version metadata consistently.'])
+        section('problem', 'Problem', `The repository-scoped handoff addresses “${prompt}” and preserves ${keyClaimIds.length} source-linked key claims before implementation. It names only files whose paths match the research question or claim language and avoids substituting generic SKS Research internals.`, keyClaimIds, likelyFiles.slice(0, 8), ['Every proposed file is relevant to the stated repository problem.']),
+        section('decision', 'Decision', 'Use the smallest repository change that follows from the surviving evidence, while keeping Research itself read-only. If the evidence does not justify a code change, return a blocked implementation handoff instead of inventing one.', keyClaimIds, likelyFiles.slice(0, 8), ['The decision is traceable to key claim and source ids.']),
+        section('architecture', 'Architecture', `Map the proposed behavior through the relevant current modules: ${likelyFiles.slice(0, 12).join(', ')}. Preserve existing ownership boundaries, remove duplicate paths only when current references prove they are dead, and keep integration parent-owned.`, keyClaimIds, likelyFiles, ['Module ownership and dependency impact are explicit.']),
+        section('interfaces', 'API And Schema Changes', 'List only interfaces, commands, schemas, or configuration fields required by the supported claim. Compatibility shims remain only when an active public caller exists; otherwise the implementation route may remove them with focused tests.', keyClaimIds, likelyFiles, ['Public and internal compatibility effects are enumerated.']),
+        section('data_contracts', 'Data Contracts', 'Carry source and claim identifiers into acceptance criteria so implementation cannot pass on artifact existence alone. State failure, ambiguity, stale evidence, and rollback behavior for every changed contract.', keyClaimIds, likelyFiles, ['Success and failure schemas are both covered.']),
+        section('execution_plan', 'Step By Step Implementation', implementationSteps(likelyFiles).join('\n'), keyClaimIds, likelyFiles, ['Each numbered step has bounded files and a decision-relevant check.']),
+        section('verification_plan', 'Verification Plan', 'Run the smallest affected type, unit, integration, or contract checks that could change the implementation decision. Reserve release-wide checks for the release route and do not repeat clean builds inside a development loop.', keyClaimIds, likelyFiles, ['Verification is scoped, non-duplicative, and tied to changed behavior.']),
+        section('risks_and_rollbacks', 'Risks And Rollbacks', 'Risks include overgeneralizing research evidence, changing unrelated files, preserving dead compatibility code, and claiming success from stale proof. Roll back the bounded implementation patch and restore the prior contract if the affected checks or read-back evidence fail.', keyClaimIds, likelyFiles, ['Rollback paths and invalidation conditions are explicit.'])
     ];
     return {
         ...base,
@@ -26,35 +75,30 @@ export async function densifyImplementationBlueprint(input) {
         prompt: input.plan?.prompt || base.prompt || '',
         implementation_allowed_in_research: false,
         handoff_route: '$Naruto',
+        handoff_type: 'repository_implementation',
         repository_aware: true,
+        domain_research: false,
         existing_files: likelyFiles,
         possible_new_files: possibleNewFiles,
+        validation_targets: keyClaimIds,
         api_schema_changes: [
-            'ResearchStageResult contract for every executed stage.',
-            'ResearchSourceShardOutput contract for source layer partials.',
-            'Codex/GPT final reviewer merged with static review.'
+            'Only evidence-supported public or internal contracts named in the sections above.'
         ],
         test_commands: [
-            'npm run research:stage-cycle-runtime-blackbox',
-            'npm run research:short-report-rejection',
-            'npm run research:complete-package-fixture',
-            'npm run codex-sdk:research-pipeline',
-            'npm run release:check'
+            'affected typecheck for the named files',
+            'focused unit or contract tests for the changed behavior',
+            'one integration or read-back check that exercises the supported claim'
         ],
         rollback_steps: [
             'Revert only the files listed in the follow-up patch plan.',
-            'Restore package version metadata with npm install --package-lock-only if package-lock drift occurs.',
-            'Run npm run release:version-truth and the research blackbox gates after rollback.'
+            'Restore the previous public/internal contract when the affected verification fails.',
+            'Record which research assumption was invalidated before retrying.'
         ],
         parallel_work_decomposition: [
-            'WS-A stage runtime and research run integration.',
-            'WS-B source shards and ledger merge.',
-            'WS-C claim matrix builder.',
-            'WS-D blueprint and handoff densifier.',
-            'WS-E final reviewer.',
-            'WS-F blackbox gates and release DAG.',
-            'WS-G CLI/docs.',
-            'WS-H integration and verification.'
+            'WS-A contract and architecture review.',
+            'WS-B bounded implementation in disjoint files.',
+            'WS-C focused test and failure-path review.',
+            'WS-D parent integration, rollback, and final verification.'
         ],
         sections,
         dependencies: ['claim-evidence-matrix.json', 'source-ledger.json', 'falsification-ledger.json'],
@@ -69,36 +113,15 @@ async function repositoryFileMap(root) {
 function likelyTargetFiles(files, plan, claimMatrix) {
     const promptTerms = new Set(String(plan?.prompt || '').toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 3));
     const guidanceTerms = new Set((Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : []).flatMap((claim) => String(claim?.claim || '').toLowerCase().split(/[^a-z0-9]+/)).filter((term) => term.length > 5));
-    const preferred = [
-        'src/core/research/research-cycle-runner.ts',
-        'src/core/research/research-stage-runner.ts',
-        'src/core/research/research-work-graph.ts',
-        'src/core/commands/research-command.ts',
-        'src/core/research/claim-evidence-matrix.ts',
-        'src/core/research/implementation-blueprint.ts',
-        'src/core/research/research-final-reviewer.ts',
-        'package.json',
-        'release-gates.v2.json',
-        'docs/research-pipeline.md',
-        'docs/research-artifacts.md',
-        'docs/research-implementation-handoff.md'
-    ].filter((file) => files.includes(file));
     const matched = files.filter((file) => {
         const lower = file.toLowerCase();
-        return lower.includes('research') || [...promptTerms, ...guidanceTerms].some((term) => lower.includes(term));
+        return [...promptTerms, ...guidanceTerms].some((term) => lower.includes(term));
     }).slice(0, 30);
-    return [...new Set([...preferred, ...matched])].slice(0, 40);
+    return [...new Set(matched)].slice(0, 40);
 }
-function possibleNewResearchFiles(files) {
-    return [
-        'src/core/research/research-source-shards.ts',
-        'src/core/research/research-source-ledger-merge.ts',
-        'src/core/research/research-claim-builder.ts',
-        'src/core/research/implementation-blueprint-densifier.ts',
-        'src/scripts/research-stage-cycle-runtime-blackbox.ts',
-        'src/scripts/research-short-report-rejection-check.ts',
-        'schemas/research/research-source-shard.schema.json'
-    ].filter((file) => !files.includes(file));
+function repositoryIntent(prompt, claims) {
+    const text = `${prompt}\n${claims.map((claim) => String(claim?.claim || '')).join('\n')}`;
+    return /\b(?:code|repository|repo|package|module|function|class|api|cli|command|config|schema|test|bug|implementation|refactor|migration|release|deploy|typescript|javascript|rust|python)\b|(?:코드|저장소|리포지토리|패키지|모듈|함수|클래스|명령|설정|스키마|테스트|버그|구현|리팩터|마이그레이션|배포)/i.test(text);
 }
 function section(id, title, detail, claimIds, targetPaths, acceptanceChecks) {
     return {
@@ -111,14 +134,13 @@ function section(id, title, detail, claimIds, targetPaths, acceptanceChecks) {
         acceptance_checks: acceptanceChecks
     };
 }
-function implementationSteps(existingFiles, newFiles) {
+function implementationSteps(existingFiles) {
     return [
-        `1. Update runtime files: ${existingFiles.filter((file) => file.includes('research-cycle-runner') || file.includes('research-stage-runner') || file.includes('research-work-graph')).join(', ')}.`,
-        `2. Add or verify source/claim/blueprint helper files: ${newFiles.filter((file) => file.includes('research')).join(', ')}.`,
-        '3. Wire sks research run so default execution uses runResearchCycle and the final.md Codex exec loop is legacy-only.',
-        '4. Add blackbox scripts that create temporary missions and verify rejection/pass/runtime behavior.',
-        '5. Update package scripts, release-gates.v2.json, docs, changelog, and version metadata.',
-        '6. Run the directive final checklist and record any hard blocker instead of claiming completion.'
+        `1. Inspect the current contract and references in: ${existingFiles.slice(0, 8).join(', ')}.`,
+        '2. Seal one bounded change whose behavior is directly supported by the claim-evidence matrix.',
+        '3. Remove or consolidate duplicate code only after current imports, commands, and generated surfaces prove it is unused.',
+        '4. Run affected checks for the changed contract, including a failure-path or ambiguity case.',
+        '5. Integrate parent-owned results, record rollback conditions, and leave unsupported follow-up work blocked.'
     ];
 }
 //# sourceMappingURL=implementation-blueprint-densifier.js.map