sneakoscope 3.1.14 → 4.0.0

package/dist/core/commands/triwiki-command.js

@@ -0,0 +1,38 @@
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { projectRoot } from '../fsx.js';
+import { computeTriWikiAffectedGraph } from '../triwiki/triwiki-affected-graph.js';
+import { buildTriWikiGateImpactMap } from '../triwiki/triwiki-gate-impact-map.js';
+import { DEFAULT_TRIWIKI_MODULE_CARDS } from '../triwiki/triwiki-module-card.js';
+import { summarizeTriWikiProofBank } from '../triwiki/triwiki-proof-bank.js';
+export async function triwikiCommand(args = []) {
+    const root = await projectRoot();
+    const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'index';
+    const json = flag(args, '--json');
+    let result;
+    if (sub === 'index') {
+        result = {
+            schema: 'sks.triwiki-index.v1',
+            ok: true,
+            modules: DEFAULT_TRIWIKI_MODULE_CARDS,
+            impact_map: buildTriWikiGateImpactMap(root),
+            proof_bank: summarizeTriWikiProofBank(root)
+        };
+    }
+    else if (sub === 'affected') {
+        result = computeTriWikiAffectedGraph({ root, tier: 'affected' });
+    }
+    else if (sub === 'proof-bank') {
+        result = summarizeTriWikiProofBank(root);
+    }
+    else {
+        console.error('Usage: sks triwiki index|affected|proof-bank [--json]');
+        process.exitCode = 1;
+        return null;
+    }
+    if (json)
+        return printJson(result);
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+}
+//# sourceMappingURL=triwiki-command.js.map

package/dist/core/daemon/sksd-client.js

@@ -0,0 +1,9 @@
+import { sksdStatus, sksdStop, sksdWarm } from './sksd.js';
+export function runSksdClient(root, action) {
+    if (action === 'warm')
+        return sksdWarm(root);
+    if (action === 'stop')
+        return sksdStop(root);
+    return sksdStatus(root);
+}
+//# sourceMappingURL=sksd-client.js.map

package/dist/core/daemon/sksd.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const SKSD_STATE_SCHEMA = 'sks.sksd-state.v1';
+export function sksdStatus(root) {
+    const state = readState(root);
+    return state || emptyState();
+}
+export function sksdWarm(root) {
+    const state = {
+        schema: SKSD_STATE_SCHEMA,
+        status: 'warm',
+        pid: process.pid,
+        warmed_at: new Date().toISOString(),
+        proof_bank_ready: true,
+        build_proof_ready: fs.existsSync(path.join(root, 'dist', '.sks-build-proof.json'))
+    };
+    writeState(root, state);
+    return state;
+}
+export function sksdStop(root) {
+    const state = { ...emptyState(), status: 'stopped' };
+    writeState(root, state);
+    return state;
+}
+function readState(root) {
+    const file = statePath(root);
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return json.schema === SKSD_STATE_SCHEMA ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeState(root, state) {
+    const file = statePath(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+}
+function statePath(root) {
+    return path.join(root, '.sneakoscope', 'cache', 'sksd-state.json');
+}
+function emptyState() {
+    return {
+        schema: SKSD_STATE_SCHEMA,
+        status: 'stopped',
+        pid: null,
+        warmed_at: null,
+        proof_bank_ready: false,
+        build_proof_ready: false
+    };
+}
+//# sourceMappingURL=sksd.js.map

package/dist/core/doctor/doctor-dirty-planner.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const DOCTOR_DIRTY_PLAN_SCHEMA = 'sks.doctor-dirty-plan.v1';
+export function planDoctorDirtyRepair(root, phaseIds) {
+    const phases = phaseIds.map((id) => {
+        const marker = markerPath(root, id);
+        if (!fs.existsSync(marker))
+            return { id, status: 'dirty', reason: 'no_clean_marker' };
+        return { id, status: 'clean', reason: 'clean_marker_present' };
+    });
+    return {
+        schema: DOCTOR_DIRTY_PLAN_SCHEMA,
+        root,
+        phases,
+        dirty_count: phases.filter((phase) => phase.status === 'dirty').length,
+        clean_count: phases.filter((phase) => phase.status === 'clean').length
+    };
+}
+export function markDoctorPhaseClean(root, id) {
+    const file = markerPath(root, id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${new Date().toISOString()}\n`);
+}
+export function isDoctorPhaseClean(plan, id) {
+    return plan?.phases.find((phase) => phase.id === id)?.status === 'clean';
+}
+function markerPath(root, id) {
+    return path.join(root, '.sneakoscope', 'cache', 'doctor-dirty', `${id.replace(/[^a-zA-Z0-9._-]+/g, '_')}.clean`);
+}
+//# sourceMappingURL=doctor-dirty-planner.js.map

package/dist/core/doctor/doctor-transaction.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { isDoctorPhaseClean, markDoctorPhaseClean } from './doctor-dirty-planner.js';
 export async function runDoctorFixTransaction(input) {
     const startedAt = nowIso();
     const phases = [];
@@ -18,6 +19,16 @@ export async function runDoctorFixTransaction(input) {
             artifact_path: null,
             started_at: phaseStarted
         };
+        if (isDoctorPhaseClean(input.dirtyPlan, definition.id)) {
+            phases.push({
+                ...phase,
+                ok: true,
+                warnings: ['dirty_plan_skipped_clean_phase'],
+                completed_at: nowIso(),
+                duration_ms: Math.max(0, Date.now() - startedMs)
+            });
+            continue;
+        }
         try {
             const result = await definition.run();
             phase = normalizePhase(definition, result, phase, startedMs);
@@ -48,6 +59,8 @@ export async function runDoctorFixTransaction(input) {
         }
         phase.completed_at = phase.completed_at || nowIso();
         phase.duration_ms = phase.duration_ms ?? Math.max(0, Date.now() - startedMs);
+        if (phase.ok)
+            markDoctorPhaseClean(input.root, definition.id);
         phases.push(phase);
     }
     const writeInput = {

package/dist/core/feature-fixtures.js

@@ -21,6 +21,7 @@ const FIXTURES = Object.freeze({
     'cli-hooks': fixture('mock', 'sks hooks trust-report --json', [], 'pass'),
     'cli-features': fixture('execute', 'sks features check --json', [], 'pass'),
     'cli-commands': fixture('execute', 'sks commands --json', [], 'pass'),
+    'cli-check': fixture('execute', 'sks check --tier confidence --sla 5m --plan --json', [], 'pass'),
     'cli-run': fixture('execute_and_validate_artifacts', 'sks run "fixture" --mock --json', ['run-classification.json', 'completion-proof.json', 'evidence-index.json', 'route-completion-contract.json', 'trust-report.json'], 'pass'),
     'cli-status': fixture('execute', 'sks status --json', [], 'pass'),
     'cli-usage': fixture('execute', 'sks usage overview', [], 'pass'),

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '3.1.14';
+export const PACKAGE_VERSION = '4.0.0';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/init.js

@@ -806,7 +806,13 @@ export async function initProject(root, opts = {}) {
             // Context7 credentials may live directly in this table as args/env/headers/url
             // depending on the user's MCP client setup. Seed the default only when absent;
             // never replace an existing Context7 block during setup/update.
-            { table: 'mcp_servers.context7', text: context7ConfigToml().trim(), preserveExisting: true },
+            // Seed the REMOTE (streamable HTTP `url`) transport, not local stdio: Codex
+            // merges the global ~/.codex/config.toml and the project config per-key, so a
+            // local-stdio `command` here merging with a remote `url` in the global config
+            // yields a stdio server that also carries a `url` — which Codex 0.140 rejects
+            // with `url is not supported for stdio`. Remote is also the transport the doctor
+            // migrates everyone to (local stdio can block interactive Codex launch).
+            { table: 'mcp_servers.context7', text: context7ConfigToml('remote').trim(), preserveExisting: true },
             { table: 'agents.native_agent', text: agentConfigBlock('native_agent', 'Read-only SKS analysis agent.', './agents/native-agent-intake.toml', ['Analysis', 'Mapper']) },
             { table: 'agents.team_consensus', text: agentConfigBlock('team_consensus', 'SKS planning/debate agent.', './agents/team-consensus.toml', ['Consensus', 'Atlas']) },
             { table: 'agents.implementation_worker', text: agentConfigBlock('implementation_worker', 'SKS bounded implementation worker.', './agents/implementation-worker.toml', ['Builder', 'Mason']) },

package/dist/core/probes/probe-memoization.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { hashJson } from '../triwiki/triwiki-cache-key.js';
+export const PROBE_MEMOIZATION_SCHEMA = 'sks.probe-memoization.v1';
+export function memoizeProbe(input) {
+    const key = hashJson({
+        probe_id: input.probeId,
+        version: input.version,
+        env: (input.envAllowlist || []).sort().map((name) => ({ name, present: process.env[name] !== undefined }))
+    });
+    const file = probeCachePath(input.root, key);
+    const existing = readProbeRecord(file);
+    if (existing && new Date(existing.expires_at).getTime() > Date.now())
+        return { value: existing.value, reused: true, key };
+    const value = input.run();
+    const record = {
+        schema: PROBE_MEMOIZATION_SCHEMA,
+        key,
+        probe_id: input.probeId,
+        created_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + input.ttlMs).toISOString(),
+        value
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+    return { value, reused: false, key };
+}
+function readProbeRecord(file) {
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return json.schema === PROBE_MEMOIZATION_SCHEMA ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+function probeCachePath(root, key) {
+    return path.join(root, '.sneakoscope', 'cache', 'probes', `${key}.json`);
+}
+//# sourceMappingURL=probe-memoization.js.map

package/dist/core/release/extreme-parallel-scheduler.js

@@ -0,0 +1,33 @@
+import { buildGatePackManifest } from './gate-pack-manifest.js';
+import { computeResourceClassBudget } from './resource-class-budget.js';
+export const EXTREME_PARALLEL_SCHEDULER_SCHEMA = 'sks.extreme-parallel-scheduler.v1';
+export function planExtremeParallelSchedule(root, graph, budget = computeResourceClassBudget()) {
+    const manifest = buildGatePackManifest(root);
+    const selectedIds = new Set(graph?.gate_packs && graph.gate_packs.length ? graph.gate_packs : manifest.packs.map((pack) => pack.id));
+    const packs = manifest.packs.filter((pack) => selectedIds.has(pack.id)).sort((a, b) => b.estimated_ms - a.estimated_ms);
+    const laneCount = Math.max(1, Math.min(packs.length || 1, Math.max(4, budget.cpu_light)));
+    const lanes = Array.from({ length: laneCount }, () => ({ packs: [], estimated_ms: 0 }));
+    for (const pack of packs) {
+        const target = lanes.reduce((best, lane) => lane.estimated_ms < best.estimated_ms ? lane : best, lanes[0]);
+        target.packs.push(pack.id);
+        target.estimated_ms += pack.estimated_ms;
+    }
+    const batches = lanes
+        .filter((lane) => lane.packs.length > 0)
+        .map((lane, index) => ({ batch: index + 1, packs: lane.packs, estimated_ms: lane.estimated_ms }));
+    const sequential = packs.reduce((sum, pack) => sum + pack.estimated_ms, 0);
+    const critical = batches.reduce((max, batch) => Math.max(max, batch.estimated_ms), 0);
+    const ratio = sequential <= 0 ? 1 : critical / sequential;
+    const blockers = ratio <= 0.3 || packs.length <= 1 ? [] : ['critical_path_reduction_below_70_percent'];
+    return {
+        schema: EXTREME_PARALLEL_SCHEDULER_SCHEMA,
+        ok: blockers.length === 0,
+        batches,
+        sequential_ms: sequential,
+        critical_path_ms: critical,
+        reduction_ratio: Number(ratio.toFixed(4)),
+        budget,
+        blockers
+    };
+}
+//# sourceMappingURL=extreme-parallel-scheduler.js.map

package/dist/core/release/gate-pack-manifest.js

@@ -0,0 +1,118 @@
+import { buildTriWikiGateImpactMap } from '../triwiki/triwiki-gate-impact-map.js';
+export const GATE_PACK_MANIFEST_SCHEMA = 'sks.gate-pack-manifest.v1';
+export const REQUIRED_GATE_PACK_IDS = [
+    'release-parity',
+    'codex-0140',
+    'doctor-production',
+    'startup-mcp',
+    'native-capability',
+    'secret',
+    'core-skill',
+    'skill-dedupe',
+    'zellij',
+    'loop-mesh',
+    'qa-research-image',
+    'triwiki'
+];
+export function buildGatePackManifest(root, gates) {
+    const impactMap = buildTriWikiGateImpactMap(root);
+    const byPack = new Map();
+    for (const pack of REQUIRED_GATE_PACK_IDS)
+        byPack.set(pack, []);
+    for (const impact of impactMap.impacts) {
+        const ids = byPack.get(impact.gate_pack) || [];
+        ids.push(impact.gate_id);
+        byPack.set(impact.gate_pack, ids);
+    }
+    for (const gate of gates || []) {
+        const pack = packForGateId(gate.id);
+        const ids = byPack.get(pack) || [];
+        if (!ids.includes(gate.id))
+            ids.push(gate.id);
+        byPack.set(pack, ids);
+    }
+    return {
+        schema: GATE_PACK_MANIFEST_SCHEMA,
+        root,
+        packs: REQUIRED_GATE_PACK_IDS.map((id) => ({
+            id,
+            description: descriptionForPack(id),
+            max_parallel: maxParallelForPack(id),
+            estimated_ms: estimatedMsForPack(id),
+            resource_classes: resourceClassesForPack(id),
+            gate_ids: [...new Set(byPack.get(id) || [])].sort()
+        }))
+    };
+}
+export function packForGateId(id) {
+    if (id.startsWith('triwiki:'))
+        return 'triwiki';
+    if (id.startsWith('codex:') || id.includes('0140'))
+        return 'codex-0140';
+    if (id.startsWith('doctor:'))
+        return 'doctor-production';
+    if (id.startsWith('sksd:') || id.startsWith('probes:') || id.includes('mcp'))
+        return 'startup-mcp';
+    if (id.includes('native') || id.startsWith('agent:'))
+        return 'native-capability';
+    if (id.startsWith('secret:') || id.includes('secret'))
+        return 'secret';
+    if (id.startsWith('core-skill:'))
+        return 'core-skill';
+    if (id.includes('skill-dedupe') || id.startsWith('skill:'))
+        return 'skill-dedupe';
+    if (id.includes('zellij') || id.startsWith('legacy:') || id.startsWith('orphan:'))
+        return 'zellij';
+    if (id.startsWith('loop:'))
+        return 'loop-mesh';
+    if (id.startsWith('qa-') || id.startsWith('research:') || id.startsWith('image:'))
+        return 'qa-research-image';
+    return 'release-parity';
+}
+function descriptionForPack(id) {
+    const descriptions = {
+        'release-parity': 'Version, DAG, parity, and package release gates.',
+        'codex-0140': 'Codex 0.140 capability and integration checks.',
+        'doctor-production': 'Doctor repair and production safety checks.',
+        'startup-mcp': 'Startup, MCP, daemon, and probe readiness checks.',
+        'native-capability': 'Native agent and desktop capability checks.',
+        secret: 'Secret-preservation and redaction checks.',
+        'core-skill': 'Immutable core skill checks.',
+        'skill-dedupe': 'Skill duplication and inventory checks.',
+        zellij: 'Zellij and removed legacy runtime checks.',
+        'loop-mesh': 'Loop mesh runtime checks.',
+        'qa-research-image': 'QA, research, and image route checks.',
+        triwiki: 'TriWiki proof bank and affected graph checks.'
+    };
+    return descriptions[id] || id;
+}
+function maxParallelForPack(id) {
+    if (id === 'secret' || id === 'zellij')
+        return 1;
+    if (id === 'qa-research-image' || id === 'codex-0140')
+        return 2;
+    return 4;
+}
+function estimatedMsForPack(id) {
+    if (id === 'release-parity')
+        return 25_000;
+    if (id === 'triwiki')
+        return 12_000;
+    if (id === 'doctor-production')
+        return 18_000;
+    if (id === 'qa-research-image')
+        return 30_000;
+    return 15_000;
+}
+function resourceClassesForPack(id) {
+    if (id === 'secret')
+        return ['fs-read'];
+    if (id === 'zellij')
+        return ['zellij-real'];
+    if (id === 'qa-research-image')
+        return ['cpu-heavy', 'io-heavy'];
+    if (id === 'codex-0140')
+        return ['remote-model-real'];
+    return ['cpu-light', 'fs-read'];
+}
+//# sourceMappingURL=gate-pack-manifest.js.map

package/dist/core/release/gate-pack-runner.js

@@ -0,0 +1,113 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+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 { buildGatePackManifest } from './gate-pack-manifest.js';
+import { loadPackageScripts, loadReleaseGateManifest } from '../triwiki/triwiki-gate-impact-map.js';
+export const GATE_PACK_RUNNER_SCHEMA = 'sks.gate-pack-runner.v1';
+export function runGatePack(input) {
+    const manifest = buildGatePackManifest(input.root);
+    const pack = manifest.packs.find((candidate) => candidate.id === input.packId);
+    if (!pack) {
+        return { schema: GATE_PACK_RUNNER_SCHEMA, ok: false, root: input.root, pack_id: input.packId, mode: input.execute ? 'execute' : 'plan', reused: 0, executed: 0, failed: 0, proof_paths: [], blockers: ['pack_missing'] };
+    }
+    const gates = loadReleaseGateManifest(input.root).gates.filter((gate) => pack.gate_ids.includes(gate.id));
+    const scripts = loadPackageScripts(input.root);
+    const blockers = [];
+    const proofPaths = [];
+    let reused = 0;
+    let executed = 0;
+    let failed = 0;
+    for (const gate of gates) {
+        if (!input.execute)
+            continue;
+        const cacheKey = computeTriWikiCacheKey({
+            root: input.root,
+            id: gate.id,
+            inputs: gate.cache.inputs,
+            implementationFiles: [`src/scripts/${scriptFileForCommand(gate.command) || ''}`].filter(Boolean),
+            envAllowlist: ['CI', 'SKS_FAST_MODE', 'SKS_RELEASE_PRESET'],
+            fixtureVersion: 'sks-4.0.0'
+        });
+        const hit = readReusableTriWikiProofCard({ root: input.root, subjectId: gate.id, cacheKey: cacheKey.key });
+        if (hit.hit) {
+            reused += 1;
+            if (hit.path)
+                proofPaths.push(hit.path);
+            continue;
+        }
+        const scriptName = scriptNameForCommand(gate.command);
+        if (!scriptName || !scripts[scriptName]) {
+            failed += 1;
+            blockers.push(`script_missing:${gate.id}`);
+            continue;
+        }
+        const started = Date.now();
+        const run = spawnSync('npm', ['run', scriptName, '--silent'], {
+            cwd: input.root,
+            encoding: 'utf8',
+            maxBuffer: 1024 * 1024 * 10,
+            env: { ...process.env, ...(input.env || {}), CI: process.env.CI || 'true' }
+        });
+        executed += 1;
+        const passed = run.status === 0;
+        if (!passed) {
+            failed += 1;
+            blockers.push(`gate_failed:${gate.id}`);
+        }
+        const card = createTriWikiProofCard({
+            subject_type: 'gate',
+            subject_id: gate.id,
+            cache_key: cacheKey.key,
+            input_hash: cacheKey.input_hash,
+            implementation_hash: cacheKey.implementation_hash,
+            tool_version: cacheKey.tool_version,
+            fixture_version: cacheKey.fixture_version,
+            result: passed ? 'passed' : 'failed',
+            reusable: passed,
+            duration_ms: Math.max(0, Date.now() - started),
+            evidence: {
+                status: run.status,
+                stdout_tail: tail(String(run.stdout || '')),
+                stderr_tail: tail(String(run.stderr || ''))
+            },
+            invalidation_reasons: passed ? [] : ['gate_failed']
+        });
+        proofPaths.push(writeTriWikiProofCard(input.root, card));
+    }
+    const report = {
+        schema: GATE_PACK_RUNNER_SCHEMA,
+        ok: blockers.length === 0,
+        root: input.root,
+        pack_id: input.packId,
+        mode: input.execute ? 'execute' : 'plan',
+        reused,
+        executed,
+        failed,
+        proof_paths: proofPaths,
+        blockers
+    };
+    writeGatePackReport(input.root, report);
+    return report;
+}
+function writeGatePackReport(root, report) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'gate-pack-runner.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`);
+}
+function scriptNameForCommand(command) {
+    const match = command.match(/^npm run ([^ ]+)/);
+    return match?.[1] || null;
+}
+function scriptFileForCommand(command) {
+    const script = scriptNameForCommand(command);
+    if (!script)
+        return null;
+    return `${script.replace(/[:]/g, '-')}${script.includes('blackbox') ? '' : '-check'}.ts`;
+}
+function tail(value, limit = 2000) {
+    return value.length > limit ? value.slice(-limit) : value;
+}
+//# sourceMappingURL=gate-pack-runner.js.map

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

@@ -2,10 +2,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 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';
 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');
 }
+export function releaseGateProofBankFile(root) {
+    return path.join(root, '.sneakoscope', 'proof-bank', 'gates', 'cache-v2.json');
+}
 // Files whose only release-to-release difference is the version literal.
 // Hashing them version-neutrally keeps a pure `sks versioning bump` from
 // invalidating every behavior gate: bumping the version rewrites
@@ -117,11 +123,23 @@ export function readReleaseGateCacheHit(root, gate) {
     return Boolean(readReleaseGateCacheRecord(root, gate));
 }
 export function readReleaseGateCacheRecord(root, gate) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(releaseGateCacheFile(root), 'utf8'));
-        const record = parsed.schema === RELEASE_GATE_CACHE_V2_SCHEMA ? parsed.records?.[releaseGateCacheKey(root, gate)] : null;
-        if (record?.ok !== true)
-            return null;
+    const key = releaseGateCacheKey(root, gate);
+    const proof = readReusableTriWikiProofCard({ root, subjectId: gate.id, cacheKey: key });
+    if (proof.hit && proof.card) {
+        return {
+            ok: true,
+            gate_id: gate.id,
+            command: gate.command,
+            resource: gate.resource,
+            preset: gate.preset,
+            duration_ms: Math.max(0, Math.floor(Number(proof.card.duration_ms) || 0)),
+            recorded_at: proof.card.created_at
+        };
+    }
+    for (const file of [releaseGateProofBankFile(root), releaseGateCacheFile(root)]) {
+        const record = readCacheRecord(file, key);
+        if (!record || record.ok !== true)
+            continue;
         return {
             ok: true,
             gate_id: String(record.gate_id || gate.id),
@@ -132,12 +150,59 @@ export function readReleaseGateCacheRecord(root, gate) {
             recorded_at: String(record.recorded_at || '')
         };
     }
+    return null;
+}
+export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
+    const key = releaseGateCacheKey(root, gate);
+    const record = {
+        ok: true,
+        gate_id: gate.id,
+        command: gate.command,
+        resource: gate.resource,
+        preset: gate.preset,
+        duration_ms: Math.max(0, Math.floor(Number(durationMs) || 0)),
+        recorded_at: new Date().toISOString()
+    };
+    writeCacheRecord(releaseGateCacheFile(root), key, record);
+    writeCacheRecord(releaseGateProofBankFile(root), key, record);
+    const triKey = computeTriWikiCacheKey({
+        root,
+        id: gate.id,
+        inputs: gate.cache.inputs,
+        implementationFiles: ['release-gates.v2.json', `src/scripts/${gate.id.replace(/[:]/g, '-')}-check.ts`],
+        envAllowlist: ['CI', 'SKS_FAST_MODE', 'SKS_RELEASE_PRESET'],
+        fixtureVersion: 'sks-4.0.0',
+        salt: key
+    });
+    writeTriWikiProofCard(root, createTriWikiProofCard({
+        subject_type: 'gate',
+        subject_id: gate.id,
+        cache_key: key,
+        input_hash: triKey.input_hash,
+        implementation_hash: triKey.implementation_hash,
+        tool_version: triKey.tool_version,
+        fixture_version: triKey.fixture_version,
+        result: 'passed',
+        reusable: true,
+        duration_ms: Math.max(0, Math.floor(Number(durationMs) || 0)),
+        evidence: {
+            command: gate.command,
+            cache_key_schema: 'release-cache-v2-compatible',
+            triwiki_key: triKey.key
+        },
+        invalidation_reasons: []
+    }));
+}
+function readCacheRecord(file, key) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return parsed.schema === RELEASE_GATE_CACHE_V2_SCHEMA ? parsed.records?.[key] || null : null;
+    }
     catch {
         return null;
     }
 }
-export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
-    const file = releaseGateCacheFile(root);
+function writeCacheRecord(file, key, record) {
     let parsed = { schema: RELEASE_GATE_CACHE_V2_SCHEMA, records: {} };
     try {
         parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -145,15 +210,7 @@ export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
     catch { }
     parsed.schema = RELEASE_GATE_CACHE_V2_SCHEMA;
     parsed.records ||= {};
-    parsed.records[releaseGateCacheKey(root, gate)] = {
-        ok: true,
-        gate_id: gate.id,
-        command: gate.command,
-        resource: gate.resource,
-        preset: gate.preset,
-        duration_ms: Math.max(0, Math.floor(Number(durationMs) || 0)),
-        recorded_at: new Date().toISOString()
-    };
+    parsed.records[key] = record;
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, `${JSON.stringify(parsed, null, 2)}\n`);
 }