sneakoscope 4.0.0 → 4.0.1

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

@@ -1,15 +1,32 @@
 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')
+    moduleCard('release-parity', ['package.json', 'package-lock.json', 'release-gates.v2.json'], ['release:'], ['release-parity'], 'high'),
+    moduleCard('release-dag', ['src/core/release/release-gate-*.ts', 'src/scripts/release-*.ts'], ['release:'], ['release-parity'], 'high'),
+    moduleCard('triwiki-proof-bank', ['src/core/triwiki/triwiki-proof-*.ts', 'src/core/triwiki/triwiki-cache-key.ts', 'src/core/triwiki/triwiki-invalidation.ts', 'src/scripts/triwiki-proof-*.ts', 'src/scripts/triwiki-cache-*.ts', 'src/scripts/triwiki-stale-*.ts'], ['triwiki:proof', 'triwiki:cache', 'triwiki:stale'], ['triwiki'], 'high'),
+    moduleCard('triwiki-affected-graph', ['src/core/triwiki/triwiki-module-card.ts', 'src/core/triwiki/triwiki-gate-impact-map.ts', 'src/core/triwiki/triwiki-affected-graph.ts', 'src/scripts/triwiki-affected-*.ts', 'src/scripts/triwiki-module-*.ts'], ['triwiki:affected', 'triwiki:module', 'triwiki:gate-impact'], ['triwiki'], 'high'),
+    moduleCard('gate-pack-runner', ['src/core/release/gate-pack-*.ts', 'src/scripts/gate-pack-*.ts'], ['gate-pack:'], ['release-parity'], 'high'),
+    moduleCard('extreme-scheduler', ['src/core/release/*scheduler.ts', 'src/core/release/resource-class-budget.ts', 'src/core/release/critical-path-ledger.ts', 'src/scripts/scheduler-*.ts'], ['scheduler:'], ['release-parity'], 'high'),
+    moduleCard('build-once', ['src/core/build/**', 'src/scripts/build-once-*.ts', 'tsconfig.json'], ['build-once:'], ['doctor-production'], 'medium'),
+    moduleCard('sksd-daemon', ['src/core/daemon/**', 'src/scripts/sksd-*.ts'], ['sksd:'], ['startup-mcp'], 'medium'),
+    moduleCard('probe-memoization', ['src/core/probes/**', 'src/scripts/probe-*.ts'], ['probes:'], ['startup-mcp'], 'medium'),
+    moduleCard('doctor-transaction', ['src/core/doctor/doctor-transaction.ts', 'src/commands/doctor.ts', 'src/scripts/doctor-transaction-*.ts'], ['doctor:transaction'], ['doctor-production'], 'high'),
+    moduleCard('doctor-dirty-repair', ['src/core/doctor/doctor-dirty-planner.ts', 'src/core/doctor/doctor-repair-postcheck.ts', 'src/scripts/doctor-dirty-*.ts'], ['doctor:dirty'], ['doctor-production'], 'high'),
+    moduleCard('startup-config-repair', ['src/core/doctor/*startup*.ts', 'src/scripts/doctor-startup-*.ts'], ['doctor:startup'], ['doctor-production'], 'high'),
+    moduleCard('context7-mcp', ['src/core/doctor/*context7*.ts', 'src/commands/context7.ts'], ['doctor:context7', 'context7:'], ['startup-mcp'], 'critical'),
+    moduleCard('supabase-mcp', ['src/core/doctor/*supabase*.ts', 'src/commands/db.ts'], ['doctor:supabase', 'db:'], ['startup-mcp'], 'critical'),
+    moduleCard('native-capability', ['src/core/codex-native/**', 'src/scripts/native-*.ts'], ['native:', 'codex-native:'], ['native-capability'], 'high'),
+    moduleCard('secret-preservation', ['src/core/**/secret*.ts', 'src/scripts/secret-*.ts', 'safety-mutation-allowlist.json'], ['secret:', 'supabase-secret'], ['doctor-production'], 'critical'),
+    moduleCard('core-skill', ['.agents/skills/**', 'src/scripts/core-skill-*.ts'], ['core-skill:'], ['core-skill'], 'high'),
+    moduleCard('skill-dedupe', ['src/scripts/skill-*.ts', '.sneakoscope/skills/**'], ['skill:'], ['skill-dedupe'], 'medium'),
+    moduleCard('zellij-runtime', ['src/core/zellij/**', 'src/commands/zellij*.ts', 'templates/zellij/**'], ['zellij:'], ['zellij'], 'high'),
+    moduleCard('codex-0140', ['src/scripts/codex-0140-*.ts', 'src/vendor/openai-codex/**'], ['codex:0140'], ['codex-0140'], 'medium'),
+    moduleCard('loop-mesh', ['src/core/loops/**', 'src/scripts/loop-*.ts'], ['loop:'], ['loop-mesh'], 'medium'),
+    moduleCard('qa-loop', ['src/commands/qa-loop.ts', 'src/scripts/qa-*.ts'], ['qa-', 'qa:'], ['qa-research-image'], 'medium'),
+    moduleCard('research', ['src/commands/research.ts', 'src/scripts/research-*.ts'], ['research:'], ['qa-research-image'], 'medium'),
+    moduleCard('image-path', ['src/commands/image-ux-review.ts', 'src/scripts/*image*.ts', 'src/scripts/ux-review-*.ts'], ['image:', 'ux-review:'], ['qa-research-image'], 'medium'),
+    moduleCard('legacy-purge', ['src/scripts/legacy-*.ts', 'src/scripts/orphan-*.ts', 'docs/sks-4-migration.md'], ['legacy:', 'orphan:'], ['zellij'], 'high'),
+    moduleCard('cli-check', ['src/core/commands/check-command.ts', 'src/commands/**/*.ts', 'src/cli/**'], ['cli:', 'sks:', 'check:'], ['native-capability'], 'high')
 ];
 export function moduleCard(moduleId, paths, ownsGatePrefixes, gatePacks, risk) {
     return {
@@ -18,7 +35,9 @@ export function moduleCard(moduleId, paths, ownsGatePrefixes, gatePacks, risk) {
         paths,
         owns_gate_prefixes: ownsGatePrefixes,
         gate_packs: gatePacks,
-        risk
+        risk,
+        invariants: [`${moduleId}:release-equivalent-proof-required`],
+        required_proof_type: risk === 'critical' ? 'real-postcheck-plus-release-gate' : 'release-gate'
     };
 }
 export function moduleIdsForPath(file, cards = DEFAULT_TRIWIKI_MODULE_CARDS) {
@@ -31,7 +50,25 @@ export function pathMatches(pattern, file) {
         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, '[^/]*')}$`);
+    const re = new RegExp(`^${globToRegexSource(pattern)}$`);
     return re.test(file);
 }
+function globToRegexSource(pattern) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const char = pattern[i];
+        if (char === '*') {
+            if (pattern[i + 1] === '*') {
+                out += '.*';
+                i += 1;
+            }
+            else {
+                out += '[^/]*';
+            }
+            continue;
+        }
+        out += /[\\^$+?.()|{}[\]]/.test(char || '') ? `\\${char}` : char;
+    }
+    return out;
+}
 //# sourceMappingURL=triwiki-module-card.js.map

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { TRIWIKI_PROOF_CARD_SCHEMA, isReusableTriWikiProofCard } from './triwiki-proof-card.js';
+import { TRIWIKI_PROOF_CARD_SCHEMA, classifyTriWikiProofCardSchema, 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');
@@ -9,8 +9,10 @@ export function writeTriWikiProofCard(root, card, subjectType = pluralSubject(ca
     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;
+    return withSubjectLock(root, subjectType, card.subject_id, () => {
+        atomicWriteJson(file, card);
+        return file;
+    });
 }
 export function readReusableTriWikiProofCard(input) {
     const dir = path.join(triWikiProofBankDir(input.root), input.subjectType || 'gates', safeId(input.subjectId));
@@ -25,6 +27,11 @@ export function readReusableTriWikiProofCard(input) {
             reasons.push(`corrupt:${file}`);
             continue;
         }
+        const schemaClass = classifyTriWikiProofCardSchema(card);
+        if (schemaClass === 'legacy_proof_card_schema') {
+            reasons.push(`legacy_proof_card_schema:${file}`);
+            continue;
+        }
         if (card.cache_key !== input.cacheKey) {
             reasons.push(`cache_key_mismatch:${file}`);
             continue;
@@ -45,7 +52,7 @@ export function markTriWikiProofInvalidated(root, subjectId, proofId, reason, su
         reusable: false,
         invalidation_reasons: [...new Set([...(card.invalidation_reasons || []), reason])]
     };
-    fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
+    atomicWriteJson(file, next);
     return true;
 }
 export function summarizeTriWikiProofBank(root) {
@@ -100,6 +107,77 @@ function backupCorruptProof(file) {
     const backup = `${file}.corrupt-${Date.now()}.bak`;
     fs.renameSync(file, backup);
 }
+function atomicWriteJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
+    const fd = fs.openSync(temp, 'w');
+    try {
+        fs.writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`);
+        try {
+            fs.fsyncSync(fd);
+        }
+        catch {
+            // fsync can be unavailable on some virtual filesystems; rename remains atomic.
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.renameSync(temp, file);
+}
+function withSubjectLock(root, subjectType, subjectId, fn) {
+    const lockDir = path.join(triWikiProofBankDir(root), '.locks', subjectType);
+    fs.mkdirSync(lockDir, { recursive: true });
+    const lockFile = path.join(lockDir, `${safeId(subjectId)}.lock`);
+    const staleAfterMs = 30_000;
+    const started = Date.now();
+    while (true) {
+        try {
+            const fd = fs.openSync(lockFile, 'wx');
+            fs.writeFileSync(fd, `${JSON.stringify({ schema: 'sks.triwiki-proof-bank-lock.v1', pid: process.pid, acquired_at: new Date().toISOString(), stale_after_ms: staleAfterMs }, null, 2)}\n`);
+            fs.closeSync(fd);
+            break;
+        }
+        catch (err) {
+            if (isLockStale(lockFile, staleAfterMs)) {
+                try {
+                    fs.rmSync(lockFile, { force: true });
+                }
+                catch { }
+                continue;
+            }
+            if (Date.now() - started > staleAfterMs * 2)
+                throw err;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            fs.rmSync(lockFile, { force: true });
+        }
+        catch { }
+    }
+}
+function isLockStale(file, staleAfterMs) {
+    try {
+        const stat = fs.statSync(file);
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const pidAlive = typeof raw.pid === 'number' && process.kill(raw.pid, 0) !== undefined;
+        return !pidAlive || Date.now() - stat.mtimeMs > staleAfterMs;
+    }
+    catch {
+        try {
+            const stat = fs.statSync(file);
+            return Date.now() - stat.mtimeMs > staleAfterMs;
+        }
+        catch {
+            return true;
+        }
+    }
+}
 function walkJson(dir) {
     const out = [];
     const stack = [dir];

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

@@ -7,8 +7,13 @@ export function createTriWikiProofCard(input) {
         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,
+        implementation_hash: input.implementation_hash || input.gate_impl_hash || 'unknown',
+        gate_impl_hash: input.gate_impl_hash || input.implementation_hash || 'unknown',
+        package_lock_hash: input.package_lock_hash || 'legacy-missing',
+        release_gates_hash: input.release_gates_hash || 'legacy-missing',
+        env_allowlist_hash: input.env_allowlist_hash || 'legacy-missing',
+        tool_versions: input.tool_versions || (input.tool_version ? { sks: input.tool_version } : {}),
+        tool_version: input.tool_version || input.tool_versions?.sks || 'unknown',
         fixture_version: input.fixture_version,
         result: input.result,
         reusable: input.reusable,
@@ -24,11 +29,24 @@ export function createTriWikiProofCard(input) {
     };
 }
 export function proofIdFor(value) {
-    return `proof-${hashJson(value).slice(0, 24)}`;
+    return `proof-${hashJson({
+        subject_type: value.subject_type,
+        subject_id: value.subject_id,
+        cache_key: value.cache_key,
+        input_hash: value.input_hash,
+        gate_impl_hash: value.gate_impl_hash || value.implementation_hash,
+        package_lock_hash: value.package_lock_hash,
+        release_gates_hash: value.release_gates_hash,
+        env_allowlist_hash: value.env_allowlist_hash,
+        tool_versions: value.tool_versions,
+        fixture_version: value.fixture_version
+    }).slice(0, 24)}`;
 }
 export function isReusableTriWikiProofCard(card, now = new Date()) {
     if (card.schema !== TRIWIKI_PROOF_CARD_SCHEMA)
         return false;
+    if (!hasV401InvalidationMaterial(card))
+        return false;
     if (card.reusable !== true)
         return false;
     if (card.result !== 'passed')
@@ -39,4 +57,17 @@ export function isReusableTriWikiProofCard(card, now = new Date()) {
         return false;
     return true;
 }
+export function classifyTriWikiProofCardSchema(card) {
+    if (card.schema !== TRIWIKI_PROOF_CARD_SCHEMA)
+        return 'invalid';
+    return hasV401InvalidationMaterial(card) ? 'current' : 'legacy_proof_card_schema';
+}
+function hasV401InvalidationMaterial(card) {
+    return Boolean(card.gate_impl_hash &&
+        card.package_lock_hash &&
+        card.release_gates_hash &&
+        card.env_allowlist_hash &&
+        card.tool_versions &&
+        Object.keys(card.tool_versions).length > 0);
+}
 //# sourceMappingURL=triwiki-proof-card.js.map

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

@@ -4,9 +4,12 @@ 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 || [];
+    const mode = input.mode || 'plan';
     if (input.estimatedCriticalPathMs > input.slaMs)
         blockers.push('sla_estimate_exceeds_budget');
-    return {
+    if (mode === 'actual' && input.actualDurationMs === undefined)
+        blockers.push('actual_mode_missing_execution_stats');
+    const certificate = {
         schema: TRIWIKI_SLA_CERTIFICATE_SCHEMA,
         ok: blockers.length === 0,
         created_at: new Date().toISOString(),
@@ -18,8 +21,28 @@ export function buildTriWikiSlaCertificate(input) {
         release_equivalent_within_scope: input.graph.release_equivalent_within_scope,
         gates: input.graph.gates.length,
         gate_packs: input.graph.gate_packs,
-        blockers
+        blockers,
+        mode
     };
+    if (input.actualDurationMs !== undefined)
+        certificate.actual_duration_ms = input.actualDurationMs;
+    if (input.executedGates !== undefined)
+        certificate.executed_gates = input.executedGates;
+    if (input.executedPacks !== undefined)
+        certificate.executed_packs = input.executedPacks;
+    if (input.reusedProofs !== undefined)
+        certificate.reused_proofs = input.reusedProofs;
+    if (input.invalidatedProofs !== undefined)
+        certificate.invalidated_proofs = input.invalidatedProofs;
+    if (input.newProofs !== undefined)
+        certificate.new_proofs = input.newProofs;
+    if (input.skippedAsValidCache !== undefined)
+        certificate.skipped_as_valid_cache = input.skippedAsValidCache;
+    if (input.skippedAsUnaffected !== undefined)
+        certificate.skipped_as_unaffected = input.skippedAsUnaffected;
+    if (input.backgroundFullRelease !== undefined)
+        certificate.background_full_release = input.backgroundFullRelease;
+    return certificate;
 }
 export function writeTriWikiSlaCertificate(root, certificate) {
     const file = path.join(root, '.sneakoscope', 'reports', 'triwiki-sla-certificate.json');

package/dist/core/version.js

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

package/dist/core/zellij/zellij-launcher.js

@@ -37,6 +37,18 @@ export async function launchZellijLayout(opts = {}) {
     const createCommand = ['attach', '--create-background', sessionName, 'options', '--default-layout', layout.layout_path, ...clipboard.optionFlags];
     const attachCommand = ['attach', sessionName];
     const zellijEnv = resolveZellijProcessEnvMeta();
+    // Reset a stale same-named session before recreating it so the launch starts
+    // main-only. `attach --create-background` is idempotent and otherwise reuses an
+    // existing session, causing each run to pile another right-split SLOTS column
+    // onto leftover panes from prior missions. Skipped on dry-run, when zellij is
+    // unavailable, or when the user opts out with SKS_ZELLIJ_KEEP_SESSION=1.
+    const resetSession = opts.freshSession === true
+        && opts.dryRun !== true
+        && capability.status === 'ok'
+        && process.env.SKS_ZELLIJ_KEEP_SESSION !== '1';
+    const sessionReset = resetSession
+        ? await runZellij(['kill-session', sessionName], { cwd: opts.cwd || root, timeoutMs: 5000, optional: true })
+        : null;
     const launch = opts.dryRun === true || capability.status !== 'ok'
         ? null
         : {
@@ -104,6 +116,7 @@ export async function launchZellijLayout(opts = {}) {
         dry_run: opts.dryRun === true,
         capability,
         launch,
+        session_reset: sessionReset,
         blockers,
         warnings: [
             ...capability.warnings,

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

@@ -227,24 +227,19 @@ export async function openWorkerPane(input) {
         let columnCreationDirectionRequested = null;
         let columnCreationDirectionApplied = null;
         if (rightColumn && !freshFocusCandidate) {
-            columnCreationDirectionRequested = 'right';
-            const anchorCommand = buildZellijSlotColumnAnchorCommand({
-                cliPath: path.join(packageRoot(), 'dist', 'bin', 'sks.js'),
-                missionId: input.missionId,
-                mode: input.uiMode || 'compact-slots',
-                artifactRoot: root,
-                watch: true
-            });
-            anchorLaunch = createSession.ok
-                ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', 'SLOTS', '--', 'sh', '-lc', anchorCommand], {
-                    cwd,
-                    timeoutMs: 5000,
-                    optional: false
-                })
+            // Single right-column invariant: if this zellij session was reused (stable
+            // per-cwd name) and already carries a SLOTS anchor from a prior mission, adopt
+            // it and stack workers underneath instead of splitting ANOTHER `--direction
+            // right` column — repeated right-splits are exactly what fragments the screen
+            // into side-by-side columns. A fresh column is only split when none exists yet.
+            const adoptedAnchorPaneId = createSession.ok
+                ? await findExistingSlotsAnchorPaneId(input.sessionName, cwd).catch(() => null)
                 : null;
-            slotColumnAnchorPaneId = anchorLaunch?.ok ? extractZellijPaneIdFromOutput(anchorLaunch.stdout_tail) : null;
-            columnCreationDirectionApplied = anchorLaunch?.ok ? (slotColumnAnchorPaneId ? 'right' : 'unknown') : 'not_applied';
-            if (slotColumnAnchorPaneId) {
+            if (adoptedAnchorPaneId) {
+                // Adopted an existing column: no creation was requested, so leave the
+                // column-creation direction fields null (avoids a false
+                // `zellij_worker_slot_column_anchor_not_created` blocker).
+                slotColumnAnchorPaneId = adoptedAnchorPaneId;
                 await recordSlotColumnAnchorInRightColumn({
                     root,
                     ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
@@ -253,6 +248,34 @@ export async function openWorkerPane(input) {
                     paneId: slotColumnAnchorPaneId
                 });
             }
+            else {
+                columnCreationDirectionRequested = 'right';
+                const anchorCommand = buildZellijSlotColumnAnchorCommand({
+                    cliPath: path.join(packageRoot(), 'dist', 'bin', 'sks.js'),
+                    missionId: input.missionId,
+                    mode: input.uiMode || 'compact-slots',
+                    artifactRoot: root,
+                    watch: true
+                });
+                anchorLaunch = createSession.ok
+                    ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', 'SLOTS', '--', 'sh', '-lc', anchorCommand], {
+                        cwd,
+                        timeoutMs: 5000,
+                        optional: false
+                    })
+                    : null;
+                slotColumnAnchorPaneId = anchorLaunch?.ok ? extractZellijPaneIdFromOutput(anchorLaunch.stdout_tail) : null;
+                columnCreationDirectionApplied = anchorLaunch?.ok ? (slotColumnAnchorPaneId ? 'right' : 'unknown') : 'not_applied';
+                if (slotColumnAnchorPaneId) {
+                    await recordSlotColumnAnchorInRightColumn({
+                        root,
+                        ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+                        missionId: input.missionId,
+                        sessionName: input.sessionName,
+                        paneId: slotColumnAnchorPaneId
+                    });
+                }
+            }
         }
         const focusPaneId = lastVisibleWorkerPaneId || slotColumnAnchorPaneId || freshFocusCandidate || null;
         const directionRequested = 'down';
@@ -595,6 +618,34 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         blockers: paneId == null ? ['zellij_worker_pane_id_not_reconciled'] : []
     };
 }
+// Look up an already-open SLOTS anchor pane in a (possibly reused) session so a
+// new mission can stack its workers under the existing right column instead of
+// splitting another one. Returns the live pane id (terminal_<n>) or null.
+async function findExistingSlotsAnchorPaneId(sessionName, cwd) {
+    const listed = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], {
+        cwd,
+        timeoutMs: 5000,
+        optional: true
+    });
+    if (!listed.ok)
+        return null;
+    const rows = parsePaneRows(listed.stdout_tail);
+    const pane = rows.find((row) => {
+        if (row?.is_plugin === true)
+            return false;
+        const exited = row?.exited === true || row?.is_exited === true || row?.exit_status != null;
+        if (exited)
+            return false;
+        const title = String(row?.title || row?.name || row?.pane_name || '');
+        return title === 'SLOTS';
+    });
+    if (!pane)
+        return null;
+    const rawPaneId = pane.pane_id ?? pane.paneId;
+    if (rawPaneId != null && String(rawPaneId).trim())
+        return String(rawPaneId).trim();
+    return pane.id == null ? null : `terminal_${pane.id}`;
+}
 function normalizePaneProviderContext(context, serviceTier) {
     const tier = normalizeServiceTier(serviceTier || context?.service_tier);
     return context

package/dist/scripts/release-4001-required-gates.js

@@ -0,0 +1,13 @@
+export const REQUIRED_4001_RELEASE_IDS = [
+    'triwiki:stale-proof-rejection',
+    'gate-pack:fixture-cache',
+    'release:triwiki-first-runner',
+    'release:cache-bridge',
+    'doctor:dirty-semantic',
+    'legacy:strong-inventory',
+    'orphan:strong-detection',
+    'sks:401-five-minute-actual-blackbox',
+    'sks:401-all-feature-regression'
+];
+export const REQUIRED_4001_REAL_CHECK_IDS = [];
+//# sourceMappingURL=release-4001-required-gates.js.map

package/dist/scripts/sizecheck.js

@@ -8,13 +8,15 @@ import { fileURLToPath } from 'node:url';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const limits = {
     packedBytes: Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024),
-    unpackedBytes: Number(process.env.SKS_MAX_UNPACKED_BYTES || 6 * 1024 * 1024),
+    unpackedBytes: Number(process.env.SKS_MAX_UNPACKED_BYTES || 6400 * 1024),
     packFiles: Number(process.env.SKS_MAX_PACK_FILES || 1200),
     trackedFileBytes: Number(process.env.SKS_MAX_TRACKED_FILE_BYTES || 384 * 1024)
 };
 const trackedFileSizeAllowlist = new Set([
     // Historical source documentation export; not included in the npm package payload.
-    'docs/sks-local-llm-mode/exports/sks-local-llm-mode-deck.pdf'
+    'docs/sks-local-llm-mode/exports/sks-local-llm-mode-deck.pdf',
+    // Central release DAG manifest; package footprint limits still apply below.
+    'release-gates.v2.json'
 ]);
 const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 function fail(message, detail = '') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -994,7 +994,16 @@
     "cli:check-tiers": "node ./dist/scripts/cli-check-tiers-check.js",
     "cli:five-minute-task": "node ./dist/scripts/cli-five-minute-task-check.js",
     "certificate:sla": "node ./dist/scripts/certificate-sla-check.js",
-    "sks:400-all-feature-regression": "node ./dist/scripts/sks-400-all-feature-regression-blackbox.js"
+    "sks:400-all-feature-regression": "node ./dist/scripts/sks-400-all-feature-regression-blackbox.js",
+    "triwiki:stale-proof-rejection": "node ./dist/scripts/triwiki-stale-proof-rejection-check.js",
+    "gate-pack:fixture-cache": "node ./dist/scripts/gate-pack-fixture-cache-check.js",
+    "release:triwiki-first-runner": "node ./dist/scripts/release-triwiki-first-runner-check.js",
+    "release:cache-bridge": "node ./dist/scripts/release-cache-bridge-check.js",
+    "doctor:dirty-semantic": "node ./dist/scripts/doctor-dirty-semantic-check.js",
+    "legacy:strong-inventory": "node ./dist/scripts/legacy-strong-inventory-check.js",
+    "orphan:strong-detection": "node ./dist/scripts/orphan-strong-detection-check.js",
+    "sks:401-five-minute-actual-blackbox": "node ./dist/scripts/sks-401-five-minute-actual-blackbox.js",
+    "sks:401-all-feature-regression": "node ./dist/scripts/sks-401-all-feature-regression-blackbox.js"
   },
   "keywords": [
     "sneakoscope",