sneakoscope 6.1.0 → 6.2.0

package/dist/core/release/release-gate-cache-v2.js

@@ -5,6 +5,7 @@ import { normalizeReleaseCacheInputForBehavior } from './release-cache-key.js';
 import { computeTriWikiCacheKey } from '../triwiki/triwiki-cache-key.js';
 import { createTriWikiProofCard } from '../triwiki/triwiki-proof-card.js';
 import { readReusableTriWikiProofCard, writeTriWikiProofCard } from '../triwiki/triwiki-proof-bank.js';
+import { readCurrentNpmPackGateArtifacts } from './npm-pack-proof.js';
 export const RELEASE_GATE_CACHE_V2_SCHEMA = 'sks.release-gate-cache.v2';
 export function releaseGateCacheFile(root) {
     return path.join(root, '.sneakoscope', 'reports', 'release-gates', 'cache-v2.json');
@@ -139,6 +140,18 @@ export function readReleaseGateCacheRecord(root, gate) {
     const key = releaseGateCacheKey(root, gate);
     const proof = readReusableTriWikiProofCard({ root, subjectId: gate.id, cacheKey: key });
     if (proof.hit && proof.card) {
+        const artifactBlockers = releaseGateCacheArtifactBlockers(root, gate);
+        if (artifactBlockers.length) {
+            writeReleaseCacheBridgeReport(root, {
+                gate_id: gate.id,
+                cache_key: key,
+                bridge: 'triwiki-to-release-v2',
+                source: proof.path || null,
+                duration_ms: Math.max(0, Math.floor(Number(proof.card.duration_ms) || 0)),
+                disagreement: `required_artifact_invalid:${artifactBlockers.join(',')}`
+            });
+            return null;
+        }
         writeReleaseCacheBridgeReport(root, {
             gate_id: gate.id,
             cache_key: key,
@@ -161,6 +174,18 @@ export function readReleaseGateCacheRecord(root, gate) {
         const record = readCacheRecord(file, key);
         if (!record || record.ok !== true)
             continue;
+        const artifactBlockers = releaseGateCacheArtifactBlockers(root, gate);
+        if (artifactBlockers.length) {
+            writeReleaseCacheBridgeReport(root, {
+                gate_id: gate.id,
+                cache_key: key,
+                bridge: 'release-v2-to-triwiki',
+                source: file,
+                duration_ms: Math.max(0, Math.floor(Number(record.duration_ms) || 0)),
+                disagreement: `required_artifact_invalid:${artifactBlockers.join(',')}`
+            });
+            return null;
+        }
         writeTriWikiProofFromReleaseCacheRecord(root, gate, key, record, file);
         writeReleaseCacheBridgeReport(root, {
             gate_id: gate.id,
@@ -182,6 +207,11 @@ export function readReleaseGateCacheRecord(root, gate) {
     }
     return null;
 }
+function releaseGateCacheArtifactBlockers(root, gate) {
+    if (!['publish:packlist-performance', 'package:published-contract'].includes(gate.id))
+        return [];
+    return readCurrentNpmPackGateArtifacts(root).blockers;
+}
 export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
     const key = releaseGateCacheKey(root, gate);
     const record = {

package/dist/core/release/release-gate-contract.js

@@ -0,0 +1,161 @@
+import crypto from 'node:crypto';
+export const RELEASE_GATE_CONTRACT_SCHEMA = 'sks.release-gate-contract.v1';
+export const RELEASE_GATE_CONTRACT_IDS = Object.freeze([
+    'agent:message-bus-reader',
+    'all-features:deep-completion',
+    'appshots:thread-attachment-discovery',
+    'architecture:guard',
+    'certificate:sla',
+    'codex-app:agent-role-comprehensive',
+    'codex-app:execution-profile',
+    'codex-app:fast-ui-preservation',
+    'codex-app:handoff',
+    'codex-control:all-pipelines',
+    'codex-control:event-stream-ledger',
+    'codex-lb:comprehensive',
+    'codex-native:agent-role-content',
+    'codex-native:feature-broker-comprehensive',
+    'codex-native:hook-lifecycle-proof',
+    'codex-plugin:app-template-policy',
+    'codex-sdk:all-pipelines',
+    'codex-sdk:integration-comprehensive',
+    'codex:0.134-runner-truth',
+    'codex:0.137-compat',
+    'codex:0138-capability-comprehensive',
+    'codex:0138-doctor',
+    'codex:0144:app-server-v2',
+    'codex:0144:binary-identity',
+    'codex:0144:capability',
+    'codex:0144:manifest',
+    'codex:0144:policy',
+    'codex:0144:thread-store',
+    'codex:app-handoff-comprehensive',
+    'codex:product-design-plugin-routing',
+    'config:managed-merge',
+    'context7:evidence-dedupe',
+    'core-skill:card-schema-deployment-snapshot',
+    'core-skill:heldout-validation',
+    'core-skill:no-inference-optimizer',
+    'core-skill:patch',
+    'core-skill:route-runtime-integration',
+    'dfix:fixture',
+    'dfix:patch-handoff',
+    'dfix:patch-swarm-route-blackbox',
+    'dfix:verification',
+    'dfix:verification-recommendation',
+    'docs:truthfulness',
+    'doctor:codex-app-harness',
+    'doctor:fix-proves-codex-read',
+    'doctor:fixes-codex-app-fast-ui',
+    'evidence:flagship-coverage',
+    'fast:codex-service-tier-proof',
+    'geo:comprehensive',
+    'git-collaboration:e2e',
+    'git:worktree-checkpoint-rebase-sync',
+    'git:worktree-diff-apply-pipeline',
+    'git:worktree-diff-envelope',
+    'git:worktree-dirty-lock',
+    'git:worktree-dirty-main-detection',
+    'git:worktree-manifest-append',
+    'goal:artifact-compat',
+    'hook:latency-budget',
+    'hooks:concurrent-session-collision',
+    'image:artifact-path-contract',
+    'init-deep:backup-retention',
+    'legacy:gate-inventory',
+    'legacy:gate-purge',
+    'legacy:strong-inventory',
+    'legacy:update-e2e',
+    'local-collab:all-pipelines-final-gpt',
+    'loop-integration-finalizer-check',
+    'mad-db:capability',
+    'mad-db:command',
+    'mad-db:mad-command',
+    'mad-db:operation-lifecycle',
+    'mad-sks:app-ui-no-mutation',
+    'mad:preflight-blocks-unreadable-config',
+    'mcp:plugin-inventory',
+    'migration:upgrade-safety',
+    'model-call:concurrency',
+    'naruto:canonical-stop-gate',
+    'naruto:worktree-coding:blackbox',
+    'native-capability:repair-matrix',
+    'native:image-generation-repair',
+    'package:published-contract',
+    'pipeline:codex-native-routing-comprehensive',
+    'policy:gate-audit',
+    'ppt:full-e2e-blackbox',
+    'ppt:real-export-adapter',
+    'ppt:real-imagegen-wiring',
+    'ppt:reexport-rereview',
+    'probes:memoization',
+    'prompt:placeholder-guard',
+    'proof:root-cause-policy',
+    'provider:badge-context',
+    'publish:packlist-performance',
+    'python-sdk:all-pipelines',
+    'qa-loop:comprehensive-verification',
+    'release:aggressive-resource-governor',
+    'release:batch-runner-comprehensive',
+    'release:cache-key-comprehensive',
+    'release:dag-runner',
+    'release:gate-budget',
+    'release:gate-selection-comprehensive',
+    'release:metadata-current',
+    'release:parallel-speed-budget',
+    'release:proof-truth',
+    'release:provenance',
+    'release:runtime-truth-matrix',
+    'research:claim-builder-blueprint-comprehensive',
+    'research:complete-package-final-review-comprehensive',
+    'research:execution-profile-routing',
+    'responses:retry-policy-centralized',
+    'runtime:proof-summary',
+    'safety:mutation-callsite-coverage',
+    'scheduler:comprehensive',
+    'schema:check',
+    'secret:preservation',
+    'seo-geo:route-identity-comprehensive',
+    'seo-geo:skill-rich-content',
+    'seo:comprehensive',
+    'shared-memory:check',
+    'side-effect:runtime-report',
+    'skill:name-canonicalizer',
+    'sksd:daemon',
+    'super-search:provider-interface',
+    'test:code-index-agent-bridge-regression',
+    'test:codex-runtime-recovery',
+    'test:commands-regression',
+    'test:core-root-regression',
+    'test:dfix-ppt-gate',
+    'test:mad-sks-regression',
+    'test:menubar-doctor',
+    'test:official-subagent-policy',
+    'test:proof-stop-gate',
+    'test:triwiki-voxel-integrity',
+    'triwiki:cache-key',
+    'triwiki:proof-comprehensive',
+    'trust:check',
+    'type-surface:codex-app',
+    'typecheck',
+    'ultra-router:auto-router',
+    'ux-review:extract-wires-real-extractor',
+    'ux-review:imagegen-blackbox',
+    'ux-review:patch-diff-recheck',
+    'ux-review:run-wires-imagegen',
+    'wrongness:check'
+]);
+export function releaseGateContractSnapshot() {
+    const ids = [...RELEASE_GATE_CONTRACT_IDS];
+    const sha256 = crypto
+        .createHash('sha256')
+        .update(`${RELEASE_GATE_CONTRACT_SCHEMA}\n${ids.join('\n')}\n`)
+        .digest('hex');
+    return {
+        schema: RELEASE_GATE_CONTRACT_SCHEMA,
+        ids,
+        count: ids.length,
+        sha256
+    };
+}
+//# sourceMappingURL=release-gate-contract.js.map

package/dist/core/release/release-gate-dag.js

@@ -168,6 +168,7 @@ export async function runReleaseGateDag(input) {
             failures,
             affected_graph: affectedGraph,
             completion_certificate: completionCertificate,
+            release_authorization_snapshot: input.releaseAuthorizationSnapshot || null,
             triwiki_affected_graph: triwikiGraph,
             triwiki_selection_used: triwikiSelectionUsed,
             triwiki_selected_gates: triwikiGraph ? selected.map((gate) => gate.id) : [],

package/dist/core/release/release-real-contract.js

@@ -1,6 +1,33 @@
+import { RELEASE_AUTHORIZATION_SNAPSHOT_KEYS, sameReleaseAuthorizationSnapshot } from './release-authorization-snapshot.js';
 export const RELEASE_REAL_RESULT_CONTRACT_SCHEMA = 'sks.release-real-result-contract.v1';
 export const RELEASE_REAL_LIVE_COVERAGE_SCHEMA = 'sks.release-real-live-coverage.v1';
 export const RELEASE_REAL_SKIP_PROOF_SCHEMA = 'sks.release-real-skip-proof.v1';
+export const RELEASE_REAL_REQUIRED_CHECK_IDS = Object.freeze([
+    'codex:actual-config-load-probe',
+    'codex:0144-core-real-probes:require-real',
+    'codex:0144:app-server-v2:real',
+    'codex:0144:capability:real',
+    'doctor:actual',
+    'publish:dry-run-performance',
+    'zellij:capability',
+    'zellij:layout-valid',
+    'zellij:real-session-launch',
+    'zellij:pane-proof',
+    'zellij:screen-proof',
+    'zellij:real-session-cleanup',
+    'naruto:worktree-coding:blackbox',
+    'codex-sdk:real-smoke'
+]);
+export const RELEASE_REAL_OPTIONAL_CHECK_IDS = Object.freeze([
+    'agent:real-codex-parallel-workers-5',
+    'imagegen:real-smoke',
+    'ux-review:real-imagegen-smoke',
+    'ppt:real-imagegen-smoke'
+]);
+export const RELEASE_REAL_CHECK_IDS = Object.freeze([
+    ...RELEASE_REAL_REQUIRED_CHECK_IDS,
+    ...RELEASE_REAL_OPTIONAL_CHECK_IDS
+]);
 const SKIPPED_STATUSES = new Set(['skipped', 'not_run', 'not_requested']);
 const OPTIONAL_STATUSES = new Set(['integration_optional', 'optional', 'not_required', 'skipped_optional_unavailable']);
 const FAILED_STATUSES = new Set(['failed', 'blocked', 'error', 'unavailable', 'real_required_missing']);
@@ -161,6 +188,8 @@ export function validateReleaseRealSkipProof(input) {
     const blockers = [];
     const summary = input.summary;
     const stamp = input.distStamp;
+    const authorization = input.authorizationSnapshot;
+    const summaryAuthorization = summary?.release_authorization_snapshot;
     if (!input.summaryPath || !summary)
         blockers.push('release_real_skip_full_summary_missing');
     if (summary?.schema !== 'sks.release-gate-dag-run.v1')
@@ -181,22 +210,53 @@ export function validateReleaseRealSkipProof(input) {
         blockers.push('release_real_skip_full_summary_empty');
     if (!Array.isArray(summary?.selected_gate_ids) || summary.selected_gate_ids.length !== summary?.selected_gates)
         blockers.push('release_real_skip_full_summary_gate_ids_incomplete');
+    const expectedReleaseGateIds = unique((input.expectedReleaseGateIds || []).map(String).filter(Boolean)).sort();
+    const selectedReleaseGateIds = unique((Array.isArray(summary?.selected_gate_ids) ? summary.selected_gate_ids : []).map(String).filter(Boolean)).sort();
+    if (!expectedReleaseGateIds.length)
+        blockers.push('release_real_skip_expected_release_gate_ids_missing');
+    if (expectedReleaseGateIds.length && !sameStringList(expectedReleaseGateIds, selectedReleaseGateIds))
+        blockers.push('release_real_skip_full_summary_gate_ids_mismatch');
     if (summary?.failed !== 0 || summary?.completed !== summary?.selected_gates)
         blockers.push('release_real_skip_full_summary_incomplete');
     if (!/^[a-f0-9]{64}$/i.test(String(input.summarySha256 || '')))
         blockers.push('release_real_skip_full_summary_hash_missing');
-    if (!/^[a-f0-9]{64}$/i.test(String(input.currentSourceDigest || '')))
+    if (!/^[a-f0-9]{40,64}$/i.test(String(authorization?.git_commit || '')))
+        blockers.push('release_real_skip_git_commit_missing');
+    if (!/^[a-f0-9]{64}$/i.test(String(authorization?.source_digest || '')))
         blockers.push('release_real_skip_current_source_digest_missing');
+    if (!Number.isInteger(authorization?.source_file_count) || Number(authorization?.source_file_count) <= 0)
+        blockers.push('release_real_skip_source_file_count_missing');
+    if (!/^[a-f0-9]{64}$/i.test(String(authorization?.package_files_sha256 || '')))
+        blockers.push('release_real_skip_package_files_digest_missing');
+    if (!Number.isInteger(authorization?.package_file_count) || Number(authorization?.package_file_count) <= 0)
+        blockers.push('release_real_skip_package_file_count_missing');
+    if (!/^[a-f0-9]{64}$/i.test(String(authorization?.release_gate_sha256 || '')))
+        blockers.push('release_real_skip_release_gate_digest_missing');
+    if (!/^[a-f0-9]{64}$/i.test(String(authorization?.dist_build_sha256 || '')))
+        blockers.push('release_real_skip_dist_digest_missing');
+    if (!Number.isInteger(authorization?.dist_file_count) || Number(authorization?.dist_file_count) <= 0)
+        blockers.push('release_real_skip_dist_file_count_missing');
+    if (!summaryAuthorization || typeof summaryAuthorization !== 'object') {
+        blockers.push('release_real_skip_full_summary_authorization_snapshot_missing');
+    }
+    else if (!sameReleaseAuthorizationSnapshot(summaryAuthorization, authorization)) {
+        for (const key of RELEASE_AUTHORIZATION_SNAPSHOT_KEYS) {
+            if (summaryAuthorization[key] !== authorization?.[key])
+                blockers.push(`release_real_skip_full_summary_authorization_mismatch:${key}`);
+        }
+    }
+    if (!/^[a-f0-9]{64}$/i.test(String(input.currentDistSourceDigest || '')))
+        blockers.push('release_real_skip_dist_source_digest_missing');
     if (!stamp || !stamp.source_digest)
         blockers.push('release_real_skip_dist_source_stamp_missing');
     if (stamp && !['sks.dist-build-stamp.v1', 'sks.dist-build.v2'].includes(String(stamp.schema || '')))
         blockers.push('release_real_skip_dist_source_stamp_schema_invalid');
-    if (stamp?.source_digest && input.currentSourceDigest && stamp.source_digest !== input.currentSourceDigest)
-        blockers.push('release_real_skip_source_digest_mismatch');
-    if (!Number.isInteger(input.currentSourceFileCount) || !Number.isInteger(stamp?.source_file_count))
-        blockers.push('release_real_skip_source_file_count_missing');
-    if (Number.isInteger(input.currentSourceFileCount) && Number.isInteger(stamp?.source_file_count) && stamp.source_file_count !== input.currentSourceFileCount)
-        blockers.push('release_real_skip_source_file_count_mismatch');
+    if (stamp?.source_digest && input.currentDistSourceDigest && stamp.source_digest !== input.currentDistSourceDigest)
+        blockers.push('release_real_skip_dist_source_digest_mismatch');
+    if (!Number.isInteger(input.currentDistSourceFileCount) || !Number.isInteger(stamp?.source_file_count))
+        blockers.push('release_real_skip_dist_source_file_count_missing');
+    if (Number.isInteger(input.currentDistSourceFileCount) && Number.isInteger(stamp?.source_file_count) && stamp.source_file_count !== input.currentDistSourceFileCount)
+        blockers.push('release_real_skip_dist_source_file_count_mismatch');
     if (!Number.isFinite(input.summaryMtimeMs) || !Number.isFinite(input.distStampMtimeMs))
         blockers.push('release_real_skip_proof_mtime_missing');
     if (Number.isFinite(input.summaryMtimeMs) && Number.isFinite(input.distStampMtimeMs) && Number(input.summaryMtimeMs) < Number(input.distStampMtimeMs))
@@ -207,15 +267,16 @@ export function validateReleaseRealSkipProof(input) {
     return {
         schema: RELEASE_REAL_SKIP_PROOF_SCHEMA,
         ok: blockers.length === 0,
-        proof_source: 'latest_full_dag_receipt+current_dist_source_stamp',
+        proof_source: 'latest_full_dag_receipt+release_authorization_snapshot+current_dist_source_stamp',
         latest_summary_path: input.summaryPath,
         latest_summary_sha256: input.summarySha256,
         run_id: summary?.run_id || null,
         selected_gates: summary?.selected_gates ?? null,
         completed: summary?.completed ?? null,
         failed: summary?.failed ?? null,
-        source_digest: input.currentSourceDigest,
-        source_file_count: input.currentSourceFileCount,
+        ...authorization,
+        dist_source_digest: input.currentDistSourceDigest,
+        dist_source_file_count: input.currentDistSourceFileCount,
         dist_stamp_path: input.distStampPath,
         dist_stamp_source_digest: stamp?.source_digest || null,
         summary_mtime_ms: input.summaryMtimeMs,
@@ -225,6 +286,22 @@ export function validateReleaseRealSkipProof(input) {
         blockers: unique(blockers)
     };
 }
+export function validateReleaseRealTaskIds(taskIds) {
+    const raw = taskIds.map(String).filter(Boolean);
+    const actual = unique(raw);
+    const expected = [...RELEASE_REAL_CHECK_IDS];
+    const missing = expected.filter((id) => !actual.includes(id));
+    const unexpected = actual.filter((id) => !expected.includes(id));
+    const duplicates = unique(raw.filter((id, index) => raw.indexOf(id) !== index));
+    return {
+        ok: missing.length === 0 && unexpected.length === 0 && duplicates.length === 0,
+        expected_ids: expected,
+        actual_ids: actual,
+        missing_ids: missing,
+        unexpected_ids: unexpected,
+        duplicate_ids: duplicates
+    };
+}
 export function parseReleaseRealJsonOutput(stdout, stderr) {
     const stdoutEnvelope = bestJsonEnvelope(stdout);
     const stderrEnvelope = bestJsonEnvelope(stderr);
@@ -409,6 +486,9 @@ function countOutcomes(rows) {
 function unique(values) {
     return [...new Set(values)];
 }
+function sameStringList(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
 function tail(value, limit = 4000) {
     const text = String(value || '');
     return text.length <= limit ? text : text.slice(-limit);

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 : []),