sneakoscope 3.1.13 → 4.0.0

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

@@ -0,0 +1,56 @@
+import { spawnSync } from 'node:child_process';
+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 affectedModules = new Set();
+    let conservativeReason = null;
+    for (const file of changedFiles) {
+        const ids = moduleIdsForPath(file, cards);
+        for (const id of ids)
+            affectedModules.add(id);
+        if (ids.includes('unknown'))
+            conservativeReason = 'unknown_changed_file';
+    }
+    if (!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';
+        for (const card of cards)
+            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 gatePacks = new Set();
+    for (const impact of selected)
+        gatePacks.add(impact.gate_pack);
+    const tier = input.tier || 'affected';
+    return {
+        schema: TRIWIKI_AFFECTED_GRAPH_SCHEMA,
+        root: input.root,
+        tier,
+        changed_files: changedFiles,
+        affected_modules: [...affectedModules].sort(),
+        gate_packs: [...gatePacks].sort(),
+        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
+    };
+}
+function normalizeChangedFiles(files) {
+    return [...new Set(files.map((file) => file.trim().replace(/\\/g, '/')).filter(Boolean))].sort();
+}
+function gitChangedFiles(root) {
+    const result = spawnSync('git', ['status', '--porcelain'], { cwd: root, encoding: 'utf8' });
+    if (result.status !== 0)
+        return [];
+    return String(result.stdout || '')
+        .split('\n')
+        .map((line) => line.slice(3).trim())
+        .filter(Boolean)
+        .map((line) => line.includes(' -> ') ? line.split(' -> ').pop() || line : line);
+}
+//# sourceMappingURL=triwiki-affected-graph.js.map

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

@@ -0,0 +1,221 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+export const TRIWIKI_CACHE_KEY_SCHEMA = 'sks.triwiki-cache-key.v1';
+const DEFAULT_EXCLUDED_DIRS = new Set([
+    '.git',
+    'node_modules',
+    '.sneakoscope/cache',
+    '.sneakoscope/reports',
+    '.sneakoscope/missions',
+    '.sneakoscope/quarantine',
+    'dist'
+]);
+export function computeTriWikiCacheKey(input) {
+    const root = path.resolve(input.root);
+    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 fixtureVersion = input.fixtureVersion || 'fixture-v1';
+    const toolVersion = input.toolVersion || readPackageVersion(root);
+    const inputHash = hashJson(sourceFiles.records);
+    const implementationHash = hashJson(implementationFiles.records);
+    const key = hashJson({
+        schema: TRIWIKI_CACHE_KEY_SCHEMA,
+        id: input.id,
+        input_hash: inputHash,
+        implementation_hash: implementationHash,
+        package_lock_hash: packageLock.hash,
+        env_allowlist_hash: envHash,
+        fixture_version: fixtureVersion,
+        tool_version: toolVersion,
+        salt: input.salt || ''
+    });
+    return {
+        schema: TRIWIKI_CACHE_KEY_SCHEMA,
+        id: input.id,
+        key,
+        input_hash: inputHash,
+        implementation_hash: implementationHash,
+        package_lock_hash: packageLock.hash,
+        env_allowlist_hash: envHash,
+        fixture_version: fixtureVersion,
+        tool_version: toolVersion,
+        file_count: sourceFiles.records.length,
+        missing_inputs: [...sourceFiles.missing, ...packageLock.missing]
+    };
+}
+export function hashText(value) {
+    return crypto.createHash('sha256').update(value).digest('hex');
+}
+export function hashJson(value) {
+    return hashText(JSON.stringify(value, stableJsonReplacer));
+}
+export function collectInputFiles(root, patterns) {
+    const files = new Set();
+    const missing = [];
+    for (const pattern of patterns) {
+        const matches = expandInputPattern(root, pattern);
+        if (!matches.length) {
+            const literal = path.resolve(root, pattern);
+            if (fs.existsSync(literal))
+                files.add(relativeUnix(root, literal));
+            else
+                missing.push(pattern);
+        }
+        else {
+            for (const match of matches)
+                files.add(match);
+        }
+    }
+    const records = [];
+    for (const rel of [...files].sort()) {
+        const hashed = hashPathIfPresent(root, rel);
+        if (hashed.missing.length)
+            missing.push(rel);
+        else if (hashed.record)
+            records.push(hashed.record);
+    }
+    return { records, missing: [...new Set(missing)].sort() };
+}
+function expandInputPattern(root, pattern) {
+    const normalized = normalizePattern(pattern);
+    if (!normalized.includes('*')) {
+        const absolute = path.resolve(root, normalized);
+        if (!fs.existsSync(absolute))
+            return [];
+        return listFiles(root, absolute);
+    }
+    const regex = globToRegex(normalized);
+    return listFiles(root, root).filter((rel) => regex.test(rel));
+}
+function normalizePattern(pattern) {
+    return pattern.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+function globToRegex(pattern) {
+    const escaped = pattern
+        .split('')
+        .map((char) => {
+        if (char === '*')
+            return '*';
+        return /[\\^$+?.()|{}[\]]/.test(char) ? `\\${char}` : char;
+    })
+        .join('');
+    const regex = escaped
+        .replace(/\*\*\//g, '(?:.*/)?')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*');
+    return new RegExp(`^${regex}$`);
+}
+function listFiles(root, start) {
+    const out = [];
+    if (!fs.existsSync(start))
+        return out;
+    const stat = fs.lstatSync(start);
+    if (stat.isSymbolicLink() || stat.isFile())
+        return [relativeUnix(root, start)];
+    if (!stat.isDirectory())
+        return out;
+    const stack = [start];
+    while (stack.length) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        const relDir = relativeUnix(root, dir);
+        if (relDir && isExcluded(relDir))
+            continue;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const absolute = path.join(dir, entry.name);
+            const rel = relativeUnix(root, absolute);
+            if (isExcluded(rel))
+                continue;
+            if (entry.isDirectory())
+                stack.push(absolute);
+            else if (entry.isFile() || entry.isSymbolicLink())
+                out.push(rel);
+        }
+    }
+    return out.sort();
+}
+function isExcluded(rel) {
+    for (const dir of DEFAULT_EXCLUDED_DIRS) {
+        if (rel === dir || rel.startsWith(`${dir}/`))
+            return true;
+    }
+    return false;
+}
+function hashPathIfPresent(root, rel) {
+    const absolute = path.resolve(root, rel);
+    if (!fs.existsSync(absolute))
+        return { hash: 'missing', missing: [rel] };
+    const stat = fs.lstatSync(absolute);
+    const mode = stat.isSymbolicLink() ? 'symlink' : stat.isDirectory() ? 'dir' : 'file';
+    if (stat.isDirectory()) {
+        const files = listFiles(root, absolute).map((file) => hashPathIfPresent(root, file).record).filter((record) => Boolean(record));
+        const hash = hashJson(files);
+        return { hash, missing: [], record: { path: normalizePattern(rel), hash, size: files.length, mode } };
+    }
+    if (stat.isSymbolicLink()) {
+        const target = fs.readlinkSync(absolute);
+        const hash = hashJson({ rel, target, mode });
+        return { hash, missing: [], record: { path: normalizePattern(rel), hash, size: target.length, mode } };
+    }
+    const hash = hashFileChunked(absolute, stat.size);
+    return { hash, missing: [], record: { path: normalizePattern(rel), hash, size: stat.size, mode } };
+}
+function hashFileChunked(file, size) {
+    const h = crypto.createHash('sha256');
+    h.update(`size:${size}:`);
+    const chunk = 256 * 1024;
+    const fd = fs.openSync(file, 'r');
+    try {
+        if (size <= chunk * 3) {
+            h.update(fs.readFileSync(file));
+        }
+        else {
+            for (const offset of [0, Math.max(0, Math.floor(size / 2) - Math.floor(chunk / 2)), Math.max(0, size - chunk)]) {
+                const buffer = Buffer.alloc(chunk);
+                const read = fs.readSync(fd, buffer, 0, chunk, offset);
+                h.update(`@${offset}:`);
+                h.update(buffer.subarray(0, read));
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return h.digest('hex');
+}
+function envFingerprint(keys) {
+    return [...new Set(keys)].sort().map((key) => {
+        const value = process.env[key];
+        return {
+            key,
+            present: value !== undefined,
+            fingerprint: value === undefined ? 'missing' : hashText(`${key}:${value}`)
+        };
+    });
+}
+function readPackageVersion(root) {
+    try {
+        const json = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+        return json.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function relativeUnix(root, absolute) {
+    return path.relative(root, absolute).replace(/\\/g, '/');
+}
+function stableJsonReplacer(_key, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const record = value;
+    return Object.keys(record).sort().reduce((acc, key) => {
+        acc[key] = record[key];
+        return acc;
+    }, {});
+}
+//# sourceMappingURL=triwiki-cache-key.js.map

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

@@ -0,0 +1,79 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateReleaseGateManifest } from '../release/release-gate-node.js';
+import { DEFAULT_TRIWIKI_MODULE_CARDS } from './triwiki-module-card.js';
+export const TRIWIKI_GATE_IMPACT_MAP_SCHEMA = 'sks.triwiki-gate-impact-map.v1';
+export function buildTriWikiGateImpactMap(root, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
+    const manifest = loadReleaseGateManifest(root);
+    const scripts = loadPackageScripts(root);
+    const impacts = manifest.gates.map((gate) => {
+        const modules = modulesForGate(gate, cards);
+        return {
+            gate_id: gate.id,
+            modules,
+            gate_pack: gatePackForGate(gate, modules, cards),
+            cache_inputs: gate.cache.inputs,
+            resources: gate.resource,
+            orphan: !scriptExistsForGateCommand(gate.command, scripts),
+            command: gate.command
+        };
+    });
+    return {
+        schema: TRIWIKI_GATE_IMPACT_MAP_SCHEMA,
+        root,
+        gate_count: impacts.length,
+        orphan_count: impacts.filter((impact) => impact.orphan).length,
+        impacts
+    };
+}
+export function loadReleaseGateManifest(root) {
+    const manifestPath = path.join(root, 'release-gates.v2.json');
+    const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const validated = validateReleaseGateManifest(raw);
+    if (!validated.ok || !validated.manifest)
+        throw new Error(`release-gates.v2.json invalid: ${validated.errors.join(',')}`);
+    return validated.manifest;
+}
+export function loadPackageScripts(root) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    return pkg.scripts || {};
+}
+export function modulesForGate(gate, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
+    const modules = new Set();
+    for (const card of cards) {
+        if (card.owns_gate_prefixes.some((prefix) => gate.id.startsWith(prefix)))
+            modules.add(card.module_id);
+        if (gate.cache.inputs.some((input) => card.paths.some((pattern) => inputMatches(pattern, input))))
+            modules.add(card.module_id);
+    }
+    if (!modules.size)
+        modules.add('release');
+    return [...modules].sort();
+}
+export function gatePackForGate(gate, modules, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
+    if (gate.id.startsWith('triwiki:'))
+        return 'triwiki';
+    if (gate.id.startsWith('gate-pack:') || gate.id.startsWith('release:'))
+        return 'release-parity';
+    if (gate.id.startsWith('doctor:'))
+        return 'doctor-production';
+    if (gate.id.startsWith('sksd:') || gate.id.startsWith('probes:'))
+        return 'startup-mcp';
+    if (gate.id.startsWith('legacy:') || gate.id.startsWith('orphan:') || gate.id.includes('zellij'))
+        return 'zellij';
+    const card = cards.find((candidate) => modules.includes(candidate.module_id) && candidate.gate_packs.length);
+    return card?.gate_packs[0] || 'release-parity';
+}
+export function scriptExistsForGateCommand(command, scripts) {
+    const match = command.match(/^npm run ([^ ]+)/);
+    if (!match)
+        return true;
+    const scriptName = match[1];
+    return scriptName !== undefined && Object.prototype.hasOwnProperty.call(scripts, scriptName);
+}
+function inputMatches(pattern, input) {
+    const cleanPattern = pattern.replace(/\/\*\*$/, '');
+    const cleanInput = input.replace(/\/\*\*.*$/, '');
+    return cleanInput === cleanPattern || cleanInput.startsWith(`${cleanPattern}/`);
+}
+//# sourceMappingURL=triwiki-gate-impact-map.js.map

package/dist/core/triwiki/triwiki-module-card.js

@@ -0,0 +1,37 @@
+export const TRIWIKI_MODULE_CARD_SCHEMA = 'sks.triwiki-module-card.v1';
+export const DEFAULT_TRIWIKI_MODULE_CARDS = [
+    moduleCard('triwiki', ['src/core/triwiki/**', 'src/scripts/triwiki-*.ts'], ['triwiki:'], ['triwiki'], 'high'),
+    moduleCard('release', ['src/core/release/**', 'release-gates.v2.json', 'src/scripts/release-*.ts'], ['release:', 'gate-pack:', 'scheduler:', 'certificate:'], ['release-parity'], 'high'),
+    moduleCard('build', ['src/core/build/**', 'src/scripts/build-once-*.ts', 'tsconfig.json'], ['build-once:'], ['doctor-production'], 'medium'),
+    moduleCard('daemon', ['src/core/daemon/**', 'src/core/probes/**', 'src/scripts/sksd-*.ts', 'src/scripts/probe-*.ts'], ['sksd:', 'probes:'], ['startup-mcp'], 'medium'),
+    moduleCard('doctor', ['src/core/doctor/**', 'src/commands/doctor.ts', 'src/scripts/doctor-*.ts'], ['doctor:'], ['doctor-production'], 'high'),
+    moduleCard('legacy', ['src/scripts/legacy-*.ts', 'src/scripts/orphan-*.ts', 'src/commands/tmux.ts'], ['legacy:', 'orphan:'], ['zellij'], 'medium'),
+    moduleCard('cli', ['src/cli/**', 'src/core/commands/**', 'src/commands/**'], ['cli:', 'sks:'], ['native-capability'], 'high'),
+    moduleCard('codex', ['src/core/codex*/**', 'src/scripts/codex-*.ts'], ['codex:', 'pipeline:codex'], ['codex-0140'], 'medium'),
+    moduleCard('skills', ['.agents/skills/**', 'src/core/skills/**', 'src/scripts/skill-*.ts', 'src/scripts/core-skill-*.ts'], ['skill:', 'core-skill:'], ['core-skill', 'skill-dedupe'], 'medium'),
+    moduleCard('qa-research-image', ['src/core/qa/**', 'src/core/research/**', 'src/core/image/**', 'src/scripts/qa-*.ts', 'src/scripts/research-*.ts', 'src/scripts/image-*.ts'], ['qa-', 'research:', 'image:'], ['qa-research-image'], 'medium')
+];
+export function moduleCard(moduleId, paths, ownsGatePrefixes, gatePacks, risk) {
+    return {
+        schema: TRIWIKI_MODULE_CARD_SCHEMA,
+        module_id: moduleId,
+        paths,
+        owns_gate_prefixes: ownsGatePrefixes,
+        gate_packs: gatePacks,
+        risk
+    };
+}
+export function moduleIdsForPath(file, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
+    const normalized = file.replace(/\\/g, '/');
+    const matches = cards.filter((card) => card.paths.some((pattern) => pathMatches(pattern, normalized))).map((card) => card.module_id);
+    return matches.length ? matches : ['unknown'];
+}
+export function pathMatches(pattern, file) {
+    if (pattern.endsWith('/**'))
+        return file === pattern.slice(0, -3) || file.startsWith(pattern.slice(0, -2));
+    if (!pattern.includes('*'))
+        return file === pattern || file.startsWith(`${pattern}/`);
+    const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*\\\*/g, '.*').replace(/\\\*/g, '[^/]*')}$`);
+    return re.test(file);
+}
+//# sourceMappingURL=triwiki-module-card.js.map

package/dist/core/triwiki/triwiki-proof-bank.js

@@ -0,0 +1,132 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { TRIWIKI_PROOF_CARD_SCHEMA, isReusableTriWikiProofCard } from './triwiki-proof-card.js';
+export const TRIWIKI_PROOF_BANK_SCHEMA = 'sks.triwiki-proof-bank.v1';
+export function triWikiProofBankDir(root) {
+    return path.join(root, '.sneakoscope', 'triwiki', 'proof-bank');
+}
+export function writeTriWikiProofCard(root, card, subjectType = pluralSubject(card.subject_type)) {
+    const dir = path.join(triWikiProofBankDir(root), subjectType, safeId(card.subject_id));
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${safeId(card.proof_id)}.json`);
+    fs.writeFileSync(file, `${JSON.stringify(card, null, 2)}\n`);
+    return file;
+}
+export function readReusableTriWikiProofCard(input) {
+    const dir = path.join(triWikiProofBankDir(input.root), input.subjectType || 'gates', safeId(input.subjectId));
+    if (!fs.existsSync(dir))
+        return { hit: false, card: null, path: null, invalidation_reasons: ['proof_dir_missing'] };
+    const reasons = [];
+    for (const file of fs.readdirSync(dir).filter((name) => name.endsWith('.json')).sort()) {
+        const absolute = path.join(dir, file);
+        const card = readProofCard(absolute);
+        if (!card) {
+            backupCorruptProof(absolute);
+            reasons.push(`corrupt:${file}`);
+            continue;
+        }
+        if (card.cache_key !== input.cacheKey) {
+            reasons.push(`cache_key_mismatch:${file}`);
+            continue;
+        }
+        if (isReusableTriWikiProofCard(card))
+            return { hit: true, card, path: absolute, invalidation_reasons: [] };
+        reasons.push(`not_reusable:${file}`);
+    }
+    return { hit: false, card: null, path: null, invalidation_reasons: reasons.length ? reasons : ['proof_not_found'] };
+}
+export function markTriWikiProofInvalidated(root, subjectId, proofId, reason, subjectType = 'gates') {
+    const file = path.join(triWikiProofBankDir(root), subjectType, safeId(subjectId), `${safeId(proofId)}.json`);
+    const card = readProofCard(file);
+    if (!card)
+        return false;
+    const next = {
+        ...card,
+        reusable: false,
+        invalidation_reasons: [...new Set([...(card.invalidation_reasons || []), reason])]
+    };
+    fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
+    return true;
+}
+export function summarizeTriWikiProofBank(root) {
+    const base = triWikiProofBankDir(root);
+    let proofCount = 0;
+    let reusableCount = 0;
+    let invalidatedCount = 0;
+    let corruptBackups = 0;
+    if (fs.existsSync(base)) {
+        for (const file of walkJson(base)) {
+            if (file.includes('.corrupt-')) {
+                corruptBackups += 1;
+                continue;
+            }
+            const card = readProofCard(file);
+            if (!card) {
+                backupCorruptProof(file);
+                corruptBackups += 1;
+                continue;
+            }
+            proofCount += 1;
+            if (isReusableTriWikiProofCard(card))
+                reusableCount += 1;
+            if (card.reusable !== true || (card.invalidation_reasons || []).length > 0)
+                invalidatedCount += 1;
+        }
+    }
+    return {
+        schema: TRIWIKI_PROOF_BANK_SCHEMA,
+        ok: true,
+        root,
+        proof_count: proofCount,
+        reusable_count: reusableCount,
+        invalidated_count: invalidatedCount,
+        corrupt_backups: corruptBackups
+    };
+}
+function readProofCard(file) {
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return json.schema === TRIWIKI_PROOF_CARD_SCHEMA ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+function backupCorruptProof(file) {
+    if (!fs.existsSync(file))
+        return;
+    const backup = `${file}.corrupt-${Date.now()}.bak`;
+    fs.renameSync(file, backup);
+}
+function walkJson(dir) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory())
+                stack.push(absolute);
+            else if (entry.isFile() && entry.name.endsWith('.json'))
+                out.push(absolute);
+        }
+    }
+    return out.sort();
+}
+function pluralSubject(value) {
+    if (value === 'gate')
+        return 'gates';
+    if (value === 'gate-pack')
+        return 'gate-packs';
+    if (value === 'module')
+        return 'modules';
+    return 'pipelines';
+}
+function safeId(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_');
+}
+//# sourceMappingURL=triwiki-proof-bank.js.map

package/dist/core/triwiki/triwiki-proof-card.js

@@ -0,0 +1,42 @@
+import { hashJson } from './triwiki-cache-key.js';
+export const TRIWIKI_PROOF_CARD_SCHEMA = 'sks.triwiki-proof-card.v1';
+export function createTriWikiProofCard(input) {
+    const base = {
+        schema: TRIWIKI_PROOF_CARD_SCHEMA,
+        subject_type: input.subject_type,
+        subject_id: input.subject_id,
+        cache_key: input.cache_key,
+        input_hash: input.input_hash,
+        implementation_hash: input.implementation_hash,
+        tool_version: input.tool_version,
+        fixture_version: input.fixture_version,
+        result: input.result,
+        reusable: input.reusable,
+        evidence: input.evidence,
+        invalidation_reasons: input.invalidation_reasons || [],
+        expires_at: input.expires_at ?? null,
+        duration_ms: input.duration_ms ?? 0
+    };
+    return {
+        ...base,
+        proof_id: proofIdFor(base),
+        created_at: new Date().toISOString()
+    };
+}
+export function proofIdFor(value) {
+    return `proof-${hashJson(value).slice(0, 24)}`;
+}
+export function isReusableTriWikiProofCard(card, now = new Date()) {
+    if (card.schema !== TRIWIKI_PROOF_CARD_SCHEMA)
+        return false;
+    if (card.reusable !== true)
+        return false;
+    if (card.result !== 'passed')
+        return false;
+    if ((card.invalidation_reasons || []).length > 0)
+        return false;
+    if (card.expires_at && new Date(card.expires_at).getTime() <= now.getTime())
+        return false;
+    return true;
+}
+//# sourceMappingURL=triwiki-proof-card.js.map

package/dist/core/triwiki/triwiki-sla-certificate.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const TRIWIKI_SLA_CERTIFICATE_SCHEMA = 'sks.triwiki-sla-certificate.v1';
+export function buildTriWikiSlaCertificate(input) {
+    const reductionRatio = input.estimatedSequentialMs <= 0 ? 1 : input.estimatedCriticalPathMs / input.estimatedSequentialMs;
+    const blockers = input.blockers || [];
+    if (input.estimatedCriticalPathMs > input.slaMs)
+        blockers.push('sla_estimate_exceeds_budget');
+    return {
+        schema: TRIWIKI_SLA_CERTIFICATE_SCHEMA,
+        ok: blockers.length === 0,
+        created_at: new Date().toISOString(),
+        tier: input.graph.tier,
+        sla_ms: input.slaMs,
+        estimated_critical_path_ms: input.estimatedCriticalPathMs,
+        estimated_sequential_ms: input.estimatedSequentialMs,
+        reduction_ratio: Number(reductionRatio.toFixed(4)),
+        release_equivalent_within_scope: input.graph.release_equivalent_within_scope,
+        gates: input.graph.gates.length,
+        gate_packs: input.graph.gate_packs,
+        blockers
+    };
+}
+export function writeTriWikiSlaCertificate(root, certificate) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'triwiki-sla-certificate.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(certificate, null, 2)}\n`);
+    return file;
+}
+//# sourceMappingURL=triwiki-sla-certificate.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '3.1.13';
+export const PACKAGE_VERSION = '4.0.0';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -459,7 +459,8 @@ export async function closeWorkerPane(input) {
     const root = path.resolve(input.root);
     const success = (input.status || 'closed') === 'closed' && !(input.blockers || []).length;
     const closeSuccess = process.env.SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0';
-    const closeFailed = process.env.SKS_ZELLIJ_CLOSE_FAILED_PANE === '1' || process.env.SKS_ZELLIJ_KEEP_FAILED_PANE === '0';
+    const keepFailed = process.env.SKS_ZELLIJ_KEEP_FAILED_PANE === '1';
+    const closeFailed = !keepFailed && process.env.SKS_ZELLIJ_CLOSE_FAILED_PANE !== '0';
     const paneId = input.paneRecord.pane_id;
     const shouldClose = Boolean(paneId) && (success ? closeSuccess : closeFailed);
     const close = shouldClose
@@ -700,7 +701,7 @@ async function focusZellijPaneById(sessionName, paneId, cwd) {
     }
     return last;
 }
-async function closeZellijPaneById(sessionName, paneId, cwd) {
+export async function closeZellijPaneById(sessionName, paneId, cwd) {
     const candidates = zellijPaneIdCandidates(paneId);
     let last = null;
     for (const candidate of candidates) {

package/dist/scripts/fixtures/fake-codex-config-loader.js

@@ -5,8 +5,9 @@ import path from 'node:path';
 const args = process.argv.slice(2);
 const configPath = path.join(process.cwd(), '.codex', 'config.toml');
 const outputLastMessage = readOption('--output-last-message', '');
+let configText = '';
 try {
-    fs.readFileSync(configPath, 'utf8');
+    configText = fs.readFileSync(configPath, 'utf8');
 }
 catch (err) {
     emitConfigError(`Failed to read project config file ${configPath}: ${err.message}`);
@@ -14,6 +15,16 @@ catch (err) {
 if (process.env.SKS_FAKE_CODEX_CONFIG_EPERM === '1') {
     emitConfigError(`Failed to read project config file ${configPath}: Operation not permitted (os error 1)`);
 }
+// Simulate the Codex 0.140 stdio/url merge conflict: when the project config still
+// defines Context7 as a local stdio server (a `command`), Codex merges it with the
+// remote `url` in the global config and rejects the result. Once the doctor migrates
+// Context7 to the remote `url` transport (no `command`), the load succeeds.
+if (process.env.SKS_FAKE_CODEX_CONFIG_CONTEXT7_STDIO_CONFLICT === '1') {
+    const context7 = configText.match(/\[mcp_servers\.context7\][^[]*/)?.[0] || '';
+    if (/^\s*command\s*=/m.test(context7) || /@upstash\/context7-mcp/.test(context7)) {
+        emitConfigError('url is not supported for stdio\nin `mcp_servers.context7`');
+    }
+}
 if (process.env.SKS_FAKE_CODEX_CONFIG_TOML_ERROR === '1') {
     emitConfigError(`TOML parse error in project config file ${configPath}: invalid string`);
 }