sneakoscope 4.0.0 → 4.0.1

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

@@ -1,10 +1,11 @@
-import { spawnSync } from 'node:child_process';
+import { spawn, 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 { prepareGatePackFixture } from './gate-pack-fixture-cache.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) {
@@ -63,6 +64,11 @@ export function runGatePack(input) {
             cache_key: cacheKey.key,
             input_hash: cacheKey.input_hash,
             implementation_hash: cacheKey.implementation_hash,
+            gate_impl_hash: cacheKey.implementation_hash,
+            package_lock_hash: cacheKey.package_lock_hash,
+            release_gates_hash: cacheKey.release_gates_hash,
+            env_allowlist_hash: cacheKey.env_allowlist_hash,
+            tool_versions: cacheKey.tool_versions,
             tool_version: cacheKey.tool_version,
             fixture_version: cacheKey.fixture_version,
             result: passed ? 'passed' : 'failed',
@@ -92,6 +98,130 @@ export function runGatePack(input) {
     writeGatePackReport(input.root, report);
     return report;
 }
+export async function executeGatePack(input) {
+    const mode = input.mode || 'execute';
+    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: mode === 'plan' ? 'plan' : 'execute', 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));
+    if (mode === 'plan') {
+        return { schema: GATE_PACK_RUNNER_SCHEMA, ok: true, root: input.root, pack_id: input.packId, mode: 'plan', reused: 0, executed: 0, failed: 0, proof_paths: [], blockers: [], shared_setup_count: 0, parallelism_gain: 1, critical_path_ms: pack.estimated_ms, reused_proof_count: 0, executed_gate_count: 0 };
+    }
+    const fixture = await prepareGatePackFixture({ root: input.root, packId: input.packId, fixtureVersion: 'sks-4.0.1' });
+    const scripts = loadPackageScripts(input.root);
+    const blockers = [];
+    const proofPaths = [];
+    let reused = 0;
+    let executed = 0;
+    let failed = 0;
+    let sumMs = 0;
+    let criticalPathMs = 0;
+    const pending = gates.slice();
+    const maxParallel = Math.max(1, Math.min(input.maxParallel || 4, pending.length || 1));
+    const workers = Array.from({ length: maxParallel }, async () => {
+        while (pending.length) {
+            const gate = pending.shift();
+            if (!gate)
+                return;
+            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: fixture.fixture_version
+            });
+            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;
+            }
+            if (mode === 'assert-only') {
+                failed += 1;
+                blockers.push(`proof_missing:${gate.id}`);
+                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 = await spawnNpmScript(input.root, scriptName, input.env);
+            const duration = Math.max(0, Date.now() - started);
+            sumMs += duration;
+            criticalPathMs = Math.max(criticalPathMs, duration);
+            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,
+                gate_impl_hash: cacheKey.implementation_hash,
+                package_lock_hash: cacheKey.package_lock_hash,
+                release_gates_hash: cacheKey.release_gates_hash,
+                env_allowlist_hash: cacheKey.env_allowlist_hash,
+                tool_versions: cacheKey.tool_versions,
+                tool_version: cacheKey.tool_version,
+                fixture_version: cacheKey.fixture_version,
+                result: passed ? 'passed' : 'failed',
+                reusable: passed,
+                duration_ms: duration,
+                evidence: { status: run.status, stdout_tail: tail(run.stdout), stderr_tail: tail(run.stderr), fixture_path: fixture.run_path },
+                invalidation_reasons: passed ? [] : ['gate_failed']
+            });
+            proofPaths.push(writeTriWikiProofCard(input.root, card));
+        }
+    });
+    await Promise.all(workers);
+    const packCard = createTriWikiProofCard({
+        subject_type: 'gate-pack',
+        subject_id: input.packId,
+        cache_key: `pack:${input.packId}:${gates.map((gate) => gate.id).sort().join(',')}`,
+        input_hash: computeTriWikiCacheKey({ root: input.root, id: `pack:${input.packId}`, inputs: gates.flatMap((gate) => gate.cache.inputs), fixtureVersion: fixture.fixture_version }).input_hash,
+        gate_impl_hash: `pack-runner:${GATE_PACK_RUNNER_SCHEMA}`,
+        package_lock_hash: computeTriWikiCacheKey({ root: input.root, id: `pack:${input.packId}:meta`, inputs: [] }).package_lock_hash,
+        release_gates_hash: computeTriWikiCacheKey({ root: input.root, id: `pack:${input.packId}:meta`, inputs: [] }).release_gates_hash,
+        env_allowlist_hash: computeTriWikiCacheKey({ root: input.root, id: `pack:${input.packId}:meta`, inputs: [], envAllowlist: ['CI', 'SKS_FAST_MODE'] }).env_allowlist_hash,
+        tool_versions: { sks: computeTriWikiCacheKey({ root: input.root, id: `pack:${input.packId}:meta`, inputs: [] }).tool_version },
+        fixture_version: fixture.fixture_version,
+        result: failed === 0 ? 'passed' : 'failed',
+        reusable: failed === 0,
+        evidence: { gate_count: gates.length, reused, executed, failed },
+        invalidation_reasons: failed === 0 ? [] : ['pack_gate_failed']
+    });
+    proofPaths.push(writeTriWikiProofCard(input.root, packCard));
+    const report = {
+        schema: GATE_PACK_RUNNER_SCHEMA,
+        ok: blockers.length === 0,
+        root: input.root,
+        pack_id: input.packId,
+        mode: 'execute',
+        reused,
+        executed,
+        failed,
+        proof_paths: proofPaths,
+        blockers,
+        shared_setup_count: fixture.setup_count,
+        parallelism_gain: criticalPathMs > 0 ? Number((sumMs / criticalPathMs).toFixed(2)) : 1,
+        critical_path_ms: criticalPathMs,
+        reused_proof_count: reused,
+        executed_gate_count: executed
+    };
+    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 });
@@ -110,4 +240,18 @@ function scriptFileForCommand(command) {
 function tail(value, limit = 2000) {
     return value.length > limit ? value.slice(-limit) : value;
 }
+function spawnNpmScript(root, scriptName, env) {
+    return new Promise((resolve) => {
+        const child = spawn('npm', ['run', scriptName, '--silent'], {
+            cwd: root,
+            env: { ...process.env, ...(env || {}), CI: process.env.CI || 'true' },
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => { stdout = tail(stdout + String(chunk)); });
+        child.stderr?.on('data', (chunk) => { stderr = tail(stderr + String(chunk)); });
+        child.on('close', (status) => resolve({ status, stdout, stderr }));
+    });
+}
 //# sourceMappingURL=gate-pack-runner.js.map

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

@@ -171,7 +171,7 @@ export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
         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',
+        fixtureVersion: 'sks-4.0.1',
         salt: key
     });
     writeTriWikiProofCard(root, createTriWikiProofCard({
@@ -180,6 +180,11 @@ export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
         cache_key: key,
         input_hash: triKey.input_hash,
         implementation_hash: triKey.implementation_hash,
+        gate_impl_hash: triKey.implementation_hash,
+        package_lock_hash: triKey.package_lock_hash,
+        release_gates_hash: triKey.release_gates_hash,
+        env_allowlist_hash: triKey.env_allowlist_hash,
+        tool_versions: triKey.tool_versions,
         tool_version: triKey.tool_version,
         fixture_version: triKey.fixture_version,
         result: 'passed',

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

@@ -8,6 +8,7 @@ import { readReleaseGateCacheRecord, releaseGateProofBankFile, writeReleaseGateC
 import { RELEASE_GATE_NODE_SCHEMA, validateReleaseGateManifest } from './release-gate-node.js';
 import { countReleaseGateResources, defaultReleaseGateBudget, summarizeReleaseGateBudget } from './release-gate-resource-governor.js';
 import { selectAffectedReleaseGates } from './release-gate-affected-selector.js';
+import { computeTriWikiAffectedGraph } from '../triwiki/triwiki-affected-graph.js';
 import { guardedProcessKill, guardContextForRoute } from '../safety/mutation-guard.js';
 import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
 import { rmrf } from '../fsx.js';
@@ -25,7 +26,10 @@ export async function runReleaseGateDag(input) {
     const preset = input.preset || 'release';
     const manifest = loadReleaseGateManifest(root);
     const presetGates = selectReleaseGatePreset(manifest, preset);
-    const affected = (preset === 'affected' || preset === 'fast') && input.full !== true
+    const triwikiGraph = input.triwiki !== false && (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
+        ? computeTriWikiAffectedGraph({ root, tier: preset === 'fast' ? 'affected' : 'confidence', changedSince: input.changedSince || 'auto' })
+        : null;
+    const affected = (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
         ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', preset })
         : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
     const selected = affected.gates;
@@ -105,7 +109,8 @@ export async function runReleaseGateDag(input) {
             report_dir: reportDir,
             failures,
             affected_graph: affectedGraph,
-            completion_certificate: completionCertificate
+            completion_certificate: completionCertificate,
+            triwiki_affected_graph: triwikiGraph
         };
         if (!finished) {
             snapshot.in_progress = true;
@@ -114,6 +119,8 @@ export async function runReleaseGateDag(input) {
         }
         writeReleaseGateJson(path.join(reportDir, 'summary.json'), snapshot);
         writeReleaseGateJson(affectedGraphFile, affectedGraph);
+        if (triwikiGraph)
+            writeReleaseGateJson(path.join(reportDir, 'triwiki-affected-graph.json'), triwikiGraph);
         writeReleaseGateJson(completionCertificateFile, completionCertificate);
         if (finished) {
             writeReleaseGateJson(path.join(root, '.sneakoscope', 'reports', 'affected-gate-graph.json'), affectedGraph);

package/dist/core/triwiki/triwiki-affected-graph.js

@@ -1,20 +1,27 @@
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { DEFAULT_TRIWIKI_MODULE_CARDS, moduleIdsForPath } from './triwiki-module-card.js';
 import { buildTriWikiGateImpactMap } from './triwiki-gate-impact-map.js';
 export const TRIWIKI_AFFECTED_GRAPH_SCHEMA = 'sks.triwiki-affected-graph.v1';
 export function computeTriWikiAffectedGraph(input) {
     const cards = input.cards || DEFAULT_TRIWIKI_MODULE_CARDS;
-    const changedFiles = normalizeChangedFiles(input.changedFiles && input.changedFiles.length ? input.changedFiles : gitChangedFiles(input.root));
+    const changedFiles = normalizeChangedFiles(resolveChangedFiles(input));
     const affectedModules = new Set();
     let conservativeReason = null;
+    if (input.full) {
+        for (const card of cards)
+            affectedModules.add(card.module_id);
+        conservativeReason = 'full_release_requested';
+    }
     for (const file of changedFiles) {
         const ids = moduleIdsForPath(file, cards);
         for (const id of ids)
             affectedModules.add(id);
-        if (ids.includes('unknown'))
+        if (!input.full && ids.includes('unknown'))
             conservativeReason = 'unknown_changed_file';
     }
-    if (!changedFiles.length)
+    if (!input.full && !changedFiles.length)
         affectedModules.add('release');
     if (changedFiles.some((file) => file === 'package.json' || file === 'package-lock.json' || file === 'release-gates.v2.json')) {
         conservativeReason = conservativeReason || 'root_release_surface_changed';
@@ -22,7 +29,7 @@ export function computeTriWikiAffectedGraph(input) {
             affectedModules.add(card.module_id);
     }
     const impactMap = buildTriWikiGateImpactMap(input.root, cards);
-    const selected = impactMap.impacts.filter((impact) => impact.modules.some((moduleId) => affectedModules.has(moduleId)) || conservativeReason === 'root_release_surface_changed');
+    const selected = impactMap.impacts.filter((impact) => input.full || impact.modules.some((moduleId) => affectedModules.has(moduleId)) || conservativeReason === 'root_release_surface_changed');
     const gatePacks = new Set();
     for (const impact of selected)
         gatePacks.add(impact.gate_pack);
@@ -37,9 +44,30 @@ export function computeTriWikiAffectedGraph(input) {
         gates: selected.map((impact) => impact.gate_id).sort(),
         release_equivalent_within_scope: tier !== 'instant',
         confidence: tier === 'release' ? 'full-release' : tier === 'instant' ? 'instant' : 'affected-release-equivalent',
-        conservative_reason: conservativeReason
+        conservative_reason: conservativeReason,
+        reused_proofs: [],
+        invalidated_proofs: selected.map((impact) => impact.gate_id).sort(),
+        required_new_proofs: selected.map((impact) => impact.gate_id).sort()
     };
 }
+function resolveChangedFiles(input) {
+    if (input.full)
+        return ['*full-release*'];
+    if (input.changedFiles && input.changedFiles.length)
+        return input.changedFiles;
+    if (input.baseRef && input.headRef) {
+        const diff = gitDiffNameStatus(input.root, input.baseRef, input.headRef);
+        if (diff.length)
+            return diff;
+    }
+    if (input.changedSince && input.changedSince !== 'auto') {
+        const diff = gitDiffNameStatus(input.root, input.changedSince, 'HEAD');
+        if (diff.length)
+            return diff;
+    }
+    const status = gitChangedFiles(input.root);
+    return status.length ? status : [];
+}
 function normalizeChangedFiles(files) {
     return [...new Set(files.map((file) => file.trim().replace(/\\/g, '/')).filter(Boolean))].sort();
 }
@@ -49,8 +77,36 @@ function gitChangedFiles(root) {
         return [];
     return String(result.stdout || '')
         .split('\n')
-        .map((line) => line.slice(3).trim())
+        .flatMap((line) => parseGitStatusPathLine(line.slice(3).trim()))
         .filter(Boolean)
-        .map((line) => line.includes(' -> ') ? line.split(' -> ').pop() || line : line);
+        .filter((file) => file !== '*full-release*');
+}
+function gitDiffNameStatus(root, base, head) {
+    const result = spawnSync('git', ['diff', '--name-status', '--find-renames', base, head], { cwd: root, encoding: 'utf8' });
+    if (result.status !== 0)
+        return [];
+    return String(result.stdout || '').split('\n').flatMap((line) => {
+        const parts = line.trim().split(/\t+/).filter(Boolean);
+        if (!parts.length)
+            return [];
+        const status = parts[0] || '';
+        if (status.startsWith('R') && parts.length >= 3)
+            return [parts[1], parts[2]];
+        if (status === 'D' && parts[1])
+            return [previousPathOrConservative(root, parts[1])];
+        return parts[1] ? [parts[1]] : [];
+    }).filter(Boolean);
+}
+function parseGitStatusPathLine(line) {
+    if (!line)
+        return [];
+    if (line.includes(' -> ')) {
+        const [oldPath, newPath] = line.split(' -> ');
+        return [oldPath, newPath].filter((value) => Boolean(value));
+    }
+    return [line];
+}
+function previousPathOrConservative(root, file) {
+    return fs.existsSync(path.join(root, file)) ? file : file;
 }
 //# sourceMappingURL=triwiki-affected-graph.js.map

package/dist/core/triwiki/triwiki-cache-key.js

@@ -16,9 +16,12 @@ export function computeTriWikiCacheKey(input) {
     const sourceFiles = collectInputFiles(root, input.inputs);
     const implementationFiles = collectInputFiles(root, input.implementationFiles || []);
     const packageLock = hashPathIfPresent(root, 'package-lock.json');
-    const envHash = hashJson(envFingerprint(input.envAllowlist || []));
+    const releaseGates = hashPathIfPresent(root, 'release-gates.v2.json');
+    const env = envFingerprint(input.envAllowlist || []);
+    const envHash = hashJson(env.records);
     const fixtureVersion = input.fixtureVersion || 'fixture-v1';
     const toolVersion = input.toolVersion || readPackageVersion(root);
+    const toolVersions = { sks: toolVersion, ...(input.toolVersions || {}) };
     const inputHash = hashJson(sourceFiles.records);
     const implementationHash = hashJson(implementationFiles.records);
     const key = hashJson({
@@ -27,9 +30,10 @@ export function computeTriWikiCacheKey(input) {
         input_hash: inputHash,
         implementation_hash: implementationHash,
         package_lock_hash: packageLock.hash,
+        release_gates_hash: releaseGates.hash,
         env_allowlist_hash: envHash,
         fixture_version: fixtureVersion,
-        tool_version: toolVersion,
+        tool_versions: toolVersions,
         salt: input.salt || ''
     });
     return {
@@ -39,11 +43,15 @@ export function computeTriWikiCacheKey(input) {
         input_hash: inputHash,
         implementation_hash: implementationHash,
         package_lock_hash: packageLock.hash,
+        release_gates_hash: releaseGates.hash,
         env_allowlist_hash: envHash,
         fixture_version: fixtureVersion,
         tool_version: toolVersion,
+        tool_versions: toolVersions,
         file_count: sourceFiles.records.length,
-        missing_inputs: [...sourceFiles.missing, ...packageLock.missing]
+        missing_inputs: [...sourceFiles.missing, ...packageLock.missing, ...releaseGates.missing],
+        redacted_env_keys: env.redacted_keys,
+        unsupported_globs: [...sourceFiles.unsupported, ...implementationFiles.unsupported]
     };
 }
 export function hashText(value) {
@@ -55,7 +63,12 @@ export function hashJson(value) {
 export function collectInputFiles(root, patterns) {
     const files = new Set();
     const missing = [];
+    const unsupported = [];
     for (const pattern of patterns) {
+        if (/[{}]/.test(pattern)) {
+            unsupported.push(`unsupported_brace_glob:${pattern}`);
+            continue;
+        }
         const matches = expandInputPattern(root, pattern);
         if (!matches.length) {
             const literal = path.resolve(root, pattern);
@@ -77,7 +90,7 @@ export function collectInputFiles(root, patterns) {
         else if (hashed.record)
             records.push(hashed.record);
     }
-    return { records, missing: [...new Set(missing)].sort() };
+    return { records, missing: [...new Set(missing)].sort(), unsupported: [...new Set(unsupported)].sort() };
 }
 function expandInputPattern(root, pattern) {
     const normalized = normalizePattern(pattern);
@@ -158,7 +171,9 @@ function hashPathIfPresent(root, rel) {
     }
     if (stat.isSymbolicLink()) {
         const target = fs.readlinkSync(absolute);
-        const hash = hashJson({ rel, target, mode });
+        const resolved = path.resolve(path.dirname(absolute), target);
+        const outsideRoot = !resolved.startsWith(path.resolve(root) + path.sep);
+        const hash = hashJson({ rel, target, mode, outside_root: outsideRoot });
         return { hash, missing: [], record: { path: normalizePattern(rel), hash, size: target.length, mode } };
     }
     const hash = hashFileChunked(absolute, stat.size);
@@ -188,14 +203,19 @@ function hashFileChunked(file, size) {
     return h.digest('hex');
 }
 function envFingerprint(keys) {
-    return [...new Set(keys)].sort().map((key) => {
+    const redacted = [];
+    const records = [...new Set(keys)].sort().map((key) => {
         const value = process.env[key];
+        const secret = /SECRET|TOKEN|PASSWORD|KEY|CREDENTIAL/i.test(key);
+        if (secret)
+            redacted.push(key);
         return {
             key,
             present: value !== undefined,
-            fingerprint: value === undefined ? 'missing' : hashText(`${key}:${value}`)
+            fingerprint: value === undefined ? 'missing' : secret ? 'redacted-secret' : hashText(`${key}:${hashText(value)}`)
         };
     });
+    return { records, redacted_keys: redacted };
 }
 function readPackageVersion(root) {
     try {

package/dist/core/triwiki/triwiki-gate-impact-map.js

@@ -14,17 +14,27 @@ export function buildTriWikiGateImpactMap(root, cards = DEFAULT_TRIWIKI_MODULE_C
             gate_pack: gatePackForGate(gate, modules, cards),
             cache_inputs: gate.cache.inputs,
             resources: gate.resource,
+            semantic_dependencies: semanticDependenciesForGate(gate),
+            fixture_dependencies: fixtureDependenciesForGate(gate),
+            resource_class: gate.resource,
+            expected_duration_ms_p50: expectedDurationForGate(gate, 0.5),
+            expected_duration_ms_p95: expectedDurationForGate(gate, 0.95),
             orphan: !scriptExistsForGateCommand(gate.command, scripts),
             command: gate.command
         };
     });
-    return {
+    const packageScriptOrphans = findPackageScriptOrphans(manifest, scripts);
+    const map = {
         schema: TRIWIKI_GATE_IMPACT_MAP_SCHEMA,
         root,
         gate_count: impacts.length,
         orphan_count: impacts.filter((impact) => impact.orphan).length,
-        impacts
+        package_script_orphan_count: packageScriptOrphans.length,
+        impacts,
+        package_script_orphans: packageScriptOrphans
     };
+    writeImpactMap(root, map);
+    return map;
 }
 export function loadReleaseGateManifest(root) {
     const manifestPath = path.join(root, 'release-gates.v2.json');
@@ -51,6 +61,9 @@ export function modulesForGate(gate, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
     return [...modules].sort();
 }
 export function gatePackForGate(gate, modules, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
+    const explicitPack = gate.x_sks_pack;
+    if (explicitPack)
+        return explicitPack;
     if (gate.id.startsWith('triwiki:'))
         return 'triwiki';
     if (gate.id.startsWith('gate-pack:') || gate.id.startsWith('release:'))
@@ -76,4 +89,36 @@ function inputMatches(pattern, input) {
     const cleanInput = input.replace(/\/\*\*.*$/, '');
     return cleanInput === cleanPattern || cleanInput.startsWith(`${cleanPattern}/`);
 }
+function semanticDependenciesForGate(gate) {
+    const deps = new Set(gate.deps || []);
+    for (const input of gate.cache.inputs || []) {
+        if (input.includes('package'))
+            deps.add('package-metadata');
+        if (input.includes('release-gates'))
+            deps.add('release-gate-manifest');
+        if (input.includes('src/core/triwiki'))
+            deps.add('triwiki-runtime');
+    }
+    return [...deps].sort();
+}
+function fixtureDependenciesForGate(gate) {
+    return (gate.cache.inputs || []).filter((input) => input.includes('fixture') || input.includes('test/')).sort();
+}
+function expectedDurationForGate(gate, quantile) {
+    const resources = new Set(gate.resource || []);
+    const base = resources.has('cpu-heavy') ? 45_000 : resources.has('remote-model-real') ? 90_000 : 12_000;
+    return quantile === 0.95 ? Math.round(base * 2.5) : base;
+}
+function findPackageScriptOrphans(manifest, scripts) {
+    const releaseScripts = new Set(manifest.gates.map((gate) => gate.command.match(/^npm run ([^ ]+)/)?.[1]).filter((value) => Boolean(value)));
+    return Object.keys(scripts)
+        .filter((name) => /^(triwiki|gate-pack|scheduler|release|doctor|legacy|orphan|sks:401|certificate|build-once|sksd|probes):/.test(name))
+        .filter((name) => !releaseScripts.has(name))
+        .sort();
+}
+function writeImpactMap(root, map) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'triwiki-gate-impact-map.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(map, null, 2)}\n`);
+}
 //# sourceMappingURL=triwiki-gate-impact-map.js.map

package/dist/core/triwiki/triwiki-invalidation.js

@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { markTriWikiProofInvalidated, triWikiProofBankDir } from './triwiki-proof-bank.js';
+export const TRIWIKI_PROOF_INVALIDATION_SCHEMA = 'sks.triwiki-proof-invalidation.v1';
+export async function invalidateTriWikiProofsForChange(input) {
+    const broad = input.changedFiles.some((file) => ['package.json', 'package-lock.json', 'release-gates.v2.json'].includes(file));
+    const affectedGates = new Set(input.affectedGates);
+    const affectedPacks = new Set();
+    const invalidated = [];
+    let unaffected = 0;
+    for (const file of walkProofs(input.root)) {
+        const parsed = readProofIdentity(file);
+        if (!parsed)
+            continue;
+        const hit = broad || affectedGates.has(parsed.subject_id) || input.affectedModules.includes(parsed.subject_id);
+        if (!hit) {
+            unaffected += 1;
+            continue;
+        }
+        if (parsed.subject_type === 'gate-pack')
+            affectedPacks.add(parsed.subject_id);
+        if (markTriWikiProofInvalidated(input.root, parsed.subject_id, parsed.proof_id, input.reason, pluralSubject(parsed.subject_type))) {
+            invalidated.push(parsed.proof_id);
+        }
+    }
+    const report = {
+        schema: TRIWIKI_PROOF_INVALIDATION_SCHEMA,
+        root: input.root,
+        reason: input.reason,
+        broad,
+        affected_gates: [...affectedGates].sort(),
+        affected_packs: [...affectedPacks].sort(),
+        invalidated_proofs: invalidated.sort(),
+        unaffected_proofs: unaffected
+    };
+    const out = path.join(input.root, '.sneakoscope', 'reports', 'triwiki-proof-invalidation.json');
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+    return report;
+}
+function walkProofs(root) {
+    const base = triWikiProofBankDir(root);
+    if (!fs.existsSync(base))
+        return [];
+    const out = [];
+    const stack = [base];
+    while (stack.length) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const absolute = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                stack.push(absolute);
+            else if (entry.isFile() && entry.name.endsWith('.json'))
+                out.push(absolute);
+        }
+    }
+    return out;
+}
+function readProofIdentity(file) {
+    try {
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!json.subject_type || !json.subject_id || !json.proof_id)
+            return null;
+        return { subject_type: json.subject_type, subject_id: json.subject_id, proof_id: json.proof_id };
+    }
+    catch {
+        return null;
+    }
+}
+function pluralSubject(value) {
+    if (value === 'gate')
+        return 'gates';
+    if (value === 'gate-pack')
+        return 'gate-packs';
+    if (value === 'module')
+        return 'modules';
+    return 'pipelines';
+}
+//# sourceMappingURL=triwiki-invalidation.js.map