sneakoscope 3.0.1 → 3.0.2

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.0.1** tracks Codex CLI `rust-v0.139.0`: capability detection for code-mode web search, preserved `oneOf`/`allOf` tool schemas, plugin marketplace `source`/cached catalog, the `-P` sandbox profile alias, and the multi-agent v2 `interrupt_agent` rename (accepted alongside `close_agent` in cockpit event classification). See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md).
+SKS **3.0.2** tracks Codex CLI `rust-v0.139.0` and hardens the 3.0.0 swarm release: capability detection for code-mode web search, preserved `oneOf`/`allOf` tool schemas, plugin marketplace `source`/cached catalog, the `-P` sandbox profile alias, the multi-agent v2 `interrupt_agent` rename, Zellij stacked-pane version gates, pane-lock concurrency proof, release cache safety fixtures, agent message proof summaries, and release proof source-truth artifacts. See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md).
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "3.0.1"
+version = "3.0.2"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.1"
+version = "3.0.2"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 3.0.1"),
+        Some("--version") => println!("sks-rs 3.0.2"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.0.1",
-  "source_digest": "5c97e638daf3eab1aeac1eaa644b771787a9d8cfd1a9756e7ab4e76a7aba523e",
-  "source_file_count": 2265,
-  "built_at_source_time": 1781080652355
+  "package_version": "3.0.2",
+  "source_digest": "5d782324cdb5c0cb66ce53c5733ebdd754313abc22b579907de282270a0e6178",
+  "source_file_count": 2284,
+  "built_at_source_time": 1781100033829
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '3.0.1';
+const FAST_PACKAGE_VERSION = '3.0.2';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/core/agents/agent-message-bus.js

@@ -1,11 +1,21 @@
 import path from 'node:path';
-import { appendJsonl } from '../fsx.js';
+import fs from 'node:fs/promises';
+import { appendJsonl, nowIso } from '../fsx.js';
 import { appendAgentLedgerEvent } from './agent-central-ledger.js';
 export async function appendAgentMessage(root, message) {
+    const eventType = normalizeAgentMessageEventType(message.event_type || message.type);
     const entry = {
         schema: 'sks.agent-message.v1',
+        ts: nowIso(),
+        mission_id: message.mission_id || inferMissionIdFromAgentRoot(root),
+        worker_id: message.worker_id || message.from,
+        slot_id: message.slot_id ?? message.from ?? null,
+        session_id: message.session_id || null,
+        level: message.level || (eventType === 'worker_failed' || eventType === 'blocker' ? 'error' : 'info'),
+        event_type: eventType,
+        message: message.body,
+        artifact_paths: message.artifact_paths || [],
         from: message.from,
-        session_id: message.session_id,
         to: message.to || 'orchestrator',
         type: message.type || 'note',
         body: message.body
@@ -14,4 +24,81 @@ export async function appendAgentMessage(root, message) {
     await appendAgentLedgerEvent(root, { agent_id: message.from, session_id: message.session_id, event_type: 'message_appended', payload: { to: entry.to, type: entry.type } });
     return entry;
 }
+export async function readAgentMessageBus(root, missionId, opts = {}) {
+    const file = agentMessageBusPath(root, missionId);
+    let text = '';
+    try {
+        text = await fs.readFile(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const levels = new Set((opts.levels || []).map((level) => String(level)));
+    const rows = text.split(/\n+/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return normalizeAgentMessageBusEntry(JSON.parse(line), missionId);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row))
+        .filter((row) => !levels.size || levels.has(row.level));
+    const max = Math.max(0, Math.floor(Number(opts.max || rows.length)));
+    return max > 0 ? rows.slice(-max) : rows;
+}
+export function agentMessageBusPath(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents')
+        return path.join(resolved, 'agent-messages.jsonl');
+    if (path.basename(resolved) === missionId)
+        return path.join(resolved, 'agents', 'agent-messages.jsonl');
+    return path.join(resolved, '.sneakoscope', 'missions', missionId, 'agents', 'agent-messages.jsonl');
+}
+function normalizeAgentMessageBusEntry(value, missionId) {
+    const eventType = normalizeAgentMessageEventType(value.event_type || value.type);
+    return {
+        schema: 'sks.agent-message.v1',
+        ts: String(value.ts || value.generated_at || nowIso()),
+        mission_id: String(value.mission_id || missionId),
+        worker_id: String(value.worker_id || value.from || value.slot_id || 'worker'),
+        slot_id: value.slot_id == null ? value.from == null ? null : String(value.from) : String(value.slot_id),
+        session_id: value.session_id == null ? null : String(value.session_id),
+        level: normalizeAgentMessageLevel(value.level, eventType),
+        event_type: eventType,
+        message: String(value.message || value.body || ''),
+        artifact_paths: Array.isArray(value.artifact_paths) ? value.artifact_paths.map(String) : [],
+        from: value.from == null ? undefined : String(value.from),
+        to: value.to == null ? undefined : String(value.to),
+        type: value.type == null ? undefined : String(value.type),
+        body: value.body == null ? undefined : String(value.body)
+    };
+}
+function normalizeAgentMessageEventType(value) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'worker_completed' || text === 'completed' || text === 'done')
+        return 'worker_completed';
+    if (text === 'worker_failed' || text === 'failed' || text === 'error')
+        return 'worker_failed';
+    if (text === 'blocker')
+        return 'blocker';
+    if (text === 'handoff')
+        return 'handoff';
+    return 'status';
+}
+function normalizeAgentMessageLevel(value, eventType) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'info' || text === 'warning' || text === 'error')
+        return text;
+    if (eventType === 'worker_failed' || eventType === 'blocker')
+        return 'error';
+    return 'info';
+}
+function inferMissionIdFromAgentRoot(root) {
+    const resolved = path.resolve(root);
+    return path.basename(resolved) === 'agents' ? path.basename(path.dirname(resolved)) : 'unknown';
+}
 //# sourceMappingURL=agent-message-bus.js.map

package/dist/core/agents/runtime-proof-summary.js

@@ -1,8 +1,9 @@
 import path from 'node:path';
 import { findLatestMission, missionDir } from '../mission.js';
 import { readJson, writeJsonAtomic } from '../fsx.js';
+import { readAgentMessageBus } from './agent-message-bus.js';
 export const RUNTIME_PROOF_SUMMARY_SCHEMA = 'sks.runtime-proof-summary.v1';
-export async function buildRuntimeProofSummary(root, missionIdInput = 'latest') {
+export async function buildRuntimeProofSummary(root, missionIdInput = 'latest', opts = {}) {
     const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
     if (!missionId)
         throw new Error('runtime_proof_summary_mission_missing');
@@ -13,6 +14,10 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest')
     const swarm = await readJson(path.join(agentsDir, 'agent-native-cli-session-swarm.json'), null);
     const telemetry = await readJson(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), null);
     const governor = await readJson(path.join(agentsDir, 'naruto-concurrency-governor.json'), null);
+    const messagesAll = await readAgentMessageBus(root, missionId, { max: 500 });
+    const recentMessages = await readAgentMessageBus(root, missionId, { max: opts.maxMessages || 8 });
+    const failedMessages = messagesAll.filter((row) => row.event_type === 'worker_failed');
+    const errorMessages = messagesAll.filter((row) => row.level === 'error');
     const telemetryAgeMs = telemetry?.updated_at ? Math.max(0, Date.now() - Date.parse(telemetry.updated_at)) : Number.MAX_SAFE_INTEGER;
     const visiblePanes = Number(parallel?.visible_panes ?? swarm?.zellij_pane_worker_sessions ?? telemetryVisiblePaneCount(telemetry) ?? 0);
     const targetActive = Number(scheduler?.target_active_slots ?? parallel?.target_active_slots ?? swarm?.target_active_slots ?? governor?.target_active_slots ?? 0);
@@ -21,6 +26,7 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest')
         ...(!parallel ? ['parallel_runtime_proof_missing'] : []),
         ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
         ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
+        ...(errorMessages.length ? ['agent_message_bus_error_blockers'] : []),
         ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : [])
     ].map(String);
     const summary = {
@@ -48,6 +54,13 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest')
             largest_batch_size: Number(scheduler?.largest_batch_size || 0),
             utilization: Number(scheduler?.scheduler_utilization || 0)
         },
+        messages: {
+            recent: recentMessages,
+            completed_count: messagesAll.filter((row) => row.event_type === 'worker_completed').length,
+            failed_count: failedMessages.length,
+            warning_count: messagesAll.filter((row) => row.level === 'warning').length,
+            error_count: errorMessages.length
+        },
         blockers
     };
     await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
@@ -62,9 +75,24 @@ export function renderRuntimeProofSummary(summary) {
         `Visible/headless: ${summary.ui.visible_panes} / ${summary.ui.headless_workers}`,
         `Telemetry: ${summary.ui.stale ? `stale ${(summary.ui.telemetry_age_ms / 1000).toFixed(1)}s` : `fresh ${(summary.ui.telemetry_age_ms / 1000).toFixed(1)}s`}`,
         `Model calls max: ${summary.model_calls.max_observed}`,
+        ...(summary.messages.recent.length ? [
+            'Recent worker messages:',
+            ...summary.messages.recent.map((row) => `  ${messageStatusLabel(row)} ${row.slot_id || row.worker_id}: ${row.message}`)
+        ] : []),
         ...(summary.blockers.length ? [`Blockers: ${summary.blockers.join(', ')}`] : [])
     ].join('\n');
 }
+function messageStatusLabel(row) {
+    if (row.event_type === 'worker_completed')
+        return '[done]';
+    if (row.event_type === 'worker_failed')
+        return '[fail]';
+    if (row.level === 'warning')
+        return '[warn]';
+    if (row.level === 'error')
+        return '[err]';
+    return '[info]';
+}
 function telemetryVisiblePaneCount(snapshot) {
     const slots = snapshot?.slots && typeof snapshot.slots === 'object' ? Object.values(snapshot.slots) : [];
     return slots.filter((row) => row?.status && row.status !== 'headless').length;

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

@@ -741,7 +741,7 @@ async function narutoProof(parsed) {
     const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
     if (!id)
         return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'proof', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
-    const summary = await buildRuntimeProofSummary(root, id);
+    const summary = await buildRuntimeProofSummary(root, id, { maxMessages: parsed.messages });
     return emit(parsed, { ...summary, action: 'proof' }, () => {
         console.log(renderRuntimeProofSummary(summary));
     });
@@ -756,7 +756,7 @@ async function narutoHelp(parsed) {
         usage: [
             'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama] [--local-model|--no-ollama] [--work-items N] [--real] [--readonly] [--json]',
             'sks naruto status [--mission <id>] [--json]',
-            'sks naruto proof latest [--json]'
+            'sks naruto proof latest [--messages 20] [--json]'
         ],
         defaults: { clones: DEFAULT_NARUTO_CLONES, max_clones: MAX_NARUTO_AGENT_COUNT, backend: 'codex-sdk' }
     };
@@ -798,9 +798,10 @@ function parseNarutoArgs(args = []) {
     const attach = hasFlag(args, '--attach');
     const smoke = hasFlag(args, '--smoke');
     const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism']);
+    const messages = normalizeMessages(readOption(args, '--messages', '8'));
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism, messages };
 }
 function normalizeParallelism(value) {
     const text = String(value || 'extreme').toLowerCase();
@@ -808,6 +809,10 @@ function normalizeParallelism(value) {
         return text;
     return 'extreme';
 }
+function normalizeMessages(value) {
+    const parsed = Number(value);
+    return Math.max(0, Math.min(100, Math.floor(Number.isFinite(parsed) ? parsed : 8)));
+}
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);

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.0.1';
+export const PACKAGE_VERSION = '3.0.2';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -0,0 +1,128 @@
+export function classifyReleaseCacheInputChange(input) {
+    if (input.before === input.after) {
+        return { neutralizable: true, reason: 'unchanged', behavior_affecting: false };
+    }
+    const before = normalizeReleaseCacheInputForBehavior(input.file, input.before);
+    const after = normalizeReleaseCacheInputForBehavior(input.file, input.after);
+    if (before === after) {
+        return {
+            neutralizable: true,
+            reason: neutralReason(input.file),
+            behavior_affecting: false
+        };
+    }
+    return {
+        neutralizable: false,
+        reason: behaviorReason(input.file, input.before, input.after),
+        behavior_affecting: true
+    };
+}
+export function normalizeReleaseCacheInputForBehavior(file, text) {
+    const rel = normalizeRel(file);
+    if (rel === 'package.json')
+        return normalizePackageJson(text);
+    if (rel === 'package-lock.json')
+        return normalizePackageLock(text);
+    if (rel === 'src/core/version.ts' || rel === 'src/core/fsx.ts') {
+        return text.replace(/(PACKAGE_VERSION\s*=\s*['"])([^'"]+)(['"])/, '$1__SKS_RELEASE_VERSION__$3');
+    }
+    if (rel === 'src/bin/sks.ts') {
+        return text.replace(/(FAST_PACKAGE_VERSION\s*=\s*['"])([^'"]+)(['"])/, '$1__SKS_RELEASE_VERSION__$3');
+    }
+    if (rel === 'dist/build-manifest.json')
+        return normalizeBuildManifest(text);
+    return text;
+}
+function normalizePackageJson(text) {
+    return normalizeJson(text, (value) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            value.version = '__SKS_RELEASE_VERSION__';
+        }
+        return value;
+    });
+}
+function normalizePackageLock(text) {
+    return normalizeJson(text, (value) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            value.version = '__SKS_RELEASE_VERSION__';
+            if (value.packages?.[''] && typeof value.packages[''] === 'object') {
+                value.packages[''].version = '__SKS_RELEASE_VERSION__';
+            }
+        }
+        return value;
+    });
+}
+function normalizeBuildManifest(text) {
+    return normalizeJson(text, (value) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            if ('version' in value)
+                value.version = '__SKS_RELEASE_VERSION__';
+            if ('package_version' in value)
+                value.package_version = '__SKS_RELEASE_VERSION__';
+        }
+        return value;
+    });
+}
+function normalizeJson(text, mutate) {
+    try {
+        const parsed = JSON.parse(text);
+        return stableJson(mutate(parsed));
+    }
+    catch {
+        return text;
+    }
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function neutralReason(file) {
+    const rel = normalizeRel(file);
+    if (rel === 'package.json')
+        return 'package_json_version_only';
+    if (rel === 'package-lock.json')
+        return 'package_lock_root_version_only';
+    if (rel === 'src/bin/sks.ts')
+        return 'fast_package_version_only';
+    if (rel === 'src/core/version.ts' || rel === 'src/core/fsx.ts')
+        return 'package_version_constant_only';
+    if (rel === 'dist/build-manifest.json')
+        return 'build_manifest_version_only';
+    return 'version_surface_only';
+}
+function behaviorReason(file, before, after) {
+    const rel = normalizeRel(file);
+    if (rel === 'package.json') {
+        const changed = changedTopLevelJsonKeys(before, after);
+        const behaviorKeys = changed.filter((key) => ['scripts', 'dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies', 'files', 'engines', 'publishConfig'].includes(key));
+        return behaviorKeys.length ? `package_json_behavior_keys:${behaviorKeys.join(',')}` : `package_json_non_version_keys:${changed.join(',') || 'unknown'}`;
+    }
+    if (rel === 'package-lock.json')
+        return 'package_lock_dependency_graph_changed';
+    if (rel === 'dist/build-manifest.json')
+        return 'build_manifest_artifact_hash_or_behavior_changed';
+    if (rel.startsWith('src/'))
+        return 'source_behavior_changed';
+    if (rel.startsWith('schemas/'))
+        return 'schema_behavior_changed';
+    return 'release_cache_input_behavior_changed';
+}
+function changedTopLevelJsonKeys(before, after) {
+    try {
+        const left = JSON.parse(before);
+        const right = JSON.parse(after);
+        const keys = [...new Set([...Object.keys(left || {}), ...Object.keys(right || {})])];
+        return keys.filter((key) => stableJson(left?.[key]) !== stableJson(right?.[key])).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeRel(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.?\//, '');
+}
+//# sourceMappingURL=release-cache-key.js.map

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

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
+import { normalizeReleaseCacheInputForBehavior } from './release-cache-key.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');
@@ -21,7 +22,8 @@ const VERSION_NEUTRAL_CACHE_FILES = new Set([
     'package-lock.json',
     'src/core/version.ts',
     'src/core/fsx.ts',
-    'src/bin/sks.ts'
+    'src/bin/sks.ts',
+    'dist/build-manifest.json'
 ]);
 export function releaseGateCacheKey(root, gate) {
     const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
@@ -54,14 +56,14 @@ export function releaseGateCacheKey(root, gate) {
             const rel = path.relative(root, file);
             hash.update(rel);
             if (!versionSensitive && VERSION_NEUTRAL_CACHE_FILES.has(rel))
-                hashVersionNeutralFile(hash, file, releaseVersion);
+                hashVersionNeutralFile(hash, rel, file, releaseVersion);
             else
                 hashFileIfPresent(hash, file);
         }
     }
     return hash.digest('hex');
 }
-function hashVersionNeutralFile(hash, file, releaseVersion) {
+function hashVersionNeutralFile(hash, rel, file, releaseVersion) {
     if (!fs.existsSync(file) || !fs.statSync(file).isFile())
         return;
     const text = fs.readFileSync(file, 'utf8');
@@ -69,10 +71,7 @@ function hashVersionNeutralFile(hash, file, releaseVersion) {
         hash.update(text);
         return;
     }
-    // Replace exact occurrences of the current release version literal so a
-    // version-only bump hashes identically. Any other content change in these
-    // files still alters the key.
-    hash.update(text.split(releaseVersion).join('__SKS_RELEASE_VERSION__'));
+    hash.update(normalizeReleaseCacheInputForBehavior(rel, text));
 }
 export function expandGlob(root, input) {
     const absolute = path.join(root, input);

package/dist/core/release/release-proof-truth.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, readJson, runProcess, sha256, writeJsonAtomic } from '../fsx.js';
+export async function buildReleaseProofTruth(root) {
+    const pkg = await readJson(path.join(root, 'package.json'));
+    const gitCommit = await gitOutput(root, ['rev-parse', 'HEAD']);
+    const gitBranch = await gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    const gitStatus = await gitOutput(root, ['status', '--porcelain']);
+    const packlist = await readNpmPacklist(root);
+    return {
+        schema: 'sks.release-proof-truth.v1',
+        generated_at: nowIso(),
+        package_version: String(pkg.version || ''),
+        git_commit_sha: gitCommit || null,
+        git_branch: gitBranch || null,
+        git_status_clean: gitStatus === '',
+        package_json_sha256: await shaFile(root, 'package.json'),
+        package_lock_sha256: await shaFile(root, 'package-lock.json'),
+        version_ts_sha256: await shaFile(root, 'src/core/version.ts'),
+        changelog_sha256: await shaFile(root, 'CHANGELOG.md'),
+        release_gates_sha256: await shaFile(root, 'release-gates.v2.json'),
+        ...(packlist ? {
+            npm_packlist_count: packlist.count,
+            npm_packlist_bytes: packlist.bytes
+        } : {})
+    };
+}
+export async function writeReleaseProofTruth(root) {
+    const truth = await buildReleaseProofTruth(root);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'release-proof-truth.json'), truth);
+    await writeJsonAtomic(path.join(root, 'dist', 'release-proof-truth.json'), truth);
+    return truth;
+}
+async function shaFile(root, rel) {
+    return sha256(await fs.readFile(path.join(root, rel)));
+}
+async function gitOutput(root, args) {
+    const result = await runProcess('git', args, { cwd: root, timeoutMs: 10000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+    if (!result || result.code !== 0)
+        return null;
+    return String(result.stdout || '').trim();
+}
+async function readNpmPacklist(root) {
+    const result = await runProcess('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
+        cwd: root,
+        timeoutMs: 60000,
+        maxOutputBytes: 1024 * 1024
+    }).catch(() => null);
+    if (!result || result.code !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(String(result.stdout || '[]'));
+        const files = Array.isArray(parsed?.[0]?.files) ? parsed[0].files : [];
+        return {
+            count: files.length,
+            bytes: files.reduce((sum, file) => sum + Number(file.size || 0), 0)
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=release-proof-truth.js.map

package/dist/core/safety/side-effect-runtime-report.js

@@ -34,10 +34,18 @@ export async function buildSideEffectRuntimeReport(root) {
 async function discoverLedgerPaths(root) {
     const found = new Set();
     await addIfExists(found, mutationLedgerPath(root));
-    await walkForLedgers(path.join(root, '.sneakoscope', 'missions'), found);
+    await walkForLedgers(path.join(root, '.sneakoscope', 'missions'), found, {
+        depth: 0,
+        maxDepth: positiveInt(process.env.SKS_SIDE_EFFECT_LEDGER_SCAN_MAX_DEPTH, 6),
+        visitedDirs: 0,
+        maxDirs: positiveInt(process.env.SKS_SIDE_EFFECT_LEDGER_SCAN_MAX_DIRS, 20000)
+    });
     return [...found].sort();
 }
-async function walkForLedgers(dir, found) {
+async function walkForLedgers(dir, found, budget) {
+    if (budget.depth > budget.maxDepth || budget.visitedDirs >= budget.maxDirs)
+        return;
+    budget.visitedDirs += 1;
     let entries;
     try {
         entries = await fsp.readdir(dir, { withFileTypes: true });
@@ -47,12 +55,19 @@ async function walkForLedgers(dir, found) {
     }
     for (const entry of entries) {
         const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            await walkForLedgers(file, found);
+        if (entry.isDirectory() && !shouldSkipLedgerScanDir(entry.name))
+            await walkForLedgers(file, found, { ...budget, depth: budget.depth + 1 });
         else if (entry.isFile() && entry.name === 'mutation-ledger.jsonl')
             found.add(file);
     }
 }
+function shouldSkipLedgerScanDir(name) {
+    return new Set(['node_modules', '.git', 'dist', 'vendor', '.next', 'coverage']).has(name);
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
 async function addIfExists(found, file) {
     try {
         await fsp.access(file);

package/dist/core/version.js

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

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

@@ -3,6 +3,47 @@ import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { compareVersionLike, parseZellijVersionText, runZellij } from './zellij-command.js';
 export const ZELLIJ_CAPABILITY_SCHEMA = 'sks.zellij-capability.v1';
 export const ZELLIJ_MIN_VERSION = '0.41.0';
+export const ZELLIJ_STACKED_PANE_CAPABILITY_SCHEMA = 'sks.zellij-stacked-pane-capability.v1';
+export const ZELLIJ_STACKED_PANE_MIN_VERSION = '0.43.0';
+export function zellijSupportsStackedPanes(version) {
+    const parsed = parseZellijVersionText(version);
+    return Boolean(parsed && compareVersionLike(parsed, ZELLIJ_STACKED_PANE_MIN_VERSION) >= 0);
+}
+export function resolveZellijStackedPaneCapability(input = {}) {
+    const versionText = input.versionText == null ? null : String(input.versionText);
+    const parsedVersion = parseZellijVersionText(versionText);
+    const supports = zellijSupportsStackedPanes(parsedVersion);
+    const blockers = [...(input.blockers || [])].map(String);
+    const zellijMissing = blockers.includes('zellij_missing') || blockers.includes('zellij_missing_required');
+    if (!parsedVersion && !zellijMissing && input.ok === false)
+        blockers.push('zellij_version_unparsed');
+    return {
+        schema: ZELLIJ_STACKED_PANE_CAPABILITY_SCHEMA,
+        ok: blockers.length === 0 && supports,
+        zellij_bin: input.zellijBin === undefined ? 'zellij' : input.zellijBin,
+        version_text: versionText,
+        parsed_version: parsedVersion,
+        supports_stacked_panes: supports,
+        requires_update: Boolean(parsedVersion && !supports),
+        fallback_mode: supports ? 'native-stacked' : zellijMissing ? 'headless-only' : 'down-split-stack-emulation',
+        blockers
+    };
+}
+export async function checkZellijStackedPaneCapability(opts = {}) {
+    const versionRun = await runZellij(['--version'], { optional: true, timeoutMs: 5000 });
+    const versionText = `${versionRun.stdout_tail}\n${versionRun.stderr_tail}`.trim();
+    const report = resolveZellijStackedPaneCapability({
+        ok: versionRun.ok,
+        zellijBin: 'zellij',
+        versionText,
+        blockers: versionRun.ok ? [] : versionRun.blockers
+    });
+    if (opts.writeReport !== false) {
+        const root = opts.root || process.cwd();
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-stacked-pane-capability.json'), report);
+    }
+    return report;
+}
 export async function checkZellijCapability(opts = {}) {
     const requireZellij = opts.require === true || process.env.SKS_REQUIRE_ZELLIJ === '1';
     const versionRun = await runZellij(['--version'], { optional: !requireZellij, timeoutMs: 5000 });

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

@@ -88,9 +88,10 @@ export function isZellijSocketPathTooLong(text) {
     return /IPC socket path is too long|socket path is too long/i.test(String(text || ''));
 }
 export function parseZellijVersionText(text) {
-    const match = String(text || '').match(/\b(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.-]+)?\b/);
+    const match = String(text || '').match(/(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.-]+)?(?:$|[^0-9A-Za-z])/i);
     return match?.[1] ?? null;
 }
+export const parseZellijVersion = parseZellijVersionText;
 export function compareVersionLike(a, b) {
     const pa = versionParts(a);
     const pb = versionParts(b);

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

@@ -8,6 +8,18 @@ import { createRequestedScopeContract } from '../safety/requested-scope-contract
 import { checkZellijCapability } from './zellij-capability.js';
 import { compareVersionLike, parseZellijVersionText } from './zellij-command.js';
 export const ZELLIJ_UPDATE_NOTICE_SCHEMA = 'sks.zellij-update-notice.v1';
+export function resolveZellijUpdatePromptMode(input) {
+    const env = input.env || process.env;
+    if (input.skipFlag === true || env.SKS_SKIP_ZELLIJ_UPDATE === '1')
+        return 'skip';
+    if (input.ci === true || env.CI === '1' || /^true$/i.test(String(env.CI || '')))
+        return 'nonblocking-notice';
+    if (input.noQuestion === true || env.SKS_NO_QUESTION === '1' || /^true$/i.test(String(env.SKS_NO_QUESTION || '')))
+        return 'nonblocking-notice';
+    if (input.headless === true)
+        return 'nonblocking-notice';
+    return 'interactive-prompt';
+}
 const ZELLIJ_RELEASES_API_PATH = '/repos/zellij-org/zellij/releases/latest';
 export function zellijUpgradeCommandHint(missing = false) {
     if (process.platform === 'darwin')
@@ -194,10 +206,19 @@ export async function upgradeZellijToLatest(input = {}) {
 export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     const env = opts.env || process.env;
     const list = (args || []).map((arg) => String(arg));
-    if (list.includes('--json') || list.includes('--skip-cli-tools') || list.includes('--skip-zellij-update') || env.SKS_SKIP_ZELLIJ_UPDATE === '1') {
+    const mode = resolveZellijUpdatePromptMode({
+        env,
+        skipFlag: list.includes('--json') || list.includes('--skip-cli-tools') || list.includes('--skip-zellij-update'),
+        noQuestion: list.includes('--no-question') || list.includes('--no-questions'),
+        headless: !(process.stdin.isTTY && process.stdout.isTTY)
+    });
+    if (mode === 'skip') {
         return { status: 'skipped', current: null, latest: null, command: null };
     }
-    const notice = await checkZellijUpdateNotice({ env }).catch(() => null);
+    const noticeInput = { env };
+    if (opts.missionDir !== undefined)
+        noticeInput.missionDir = opts.missionDir;
+    const notice = await checkZellijUpdateNotice(noticeInput).catch(() => null);
     if (!notice)
         return { status: 'skipped', current: null, latest: null, command: null };
     if (notice.zellij_missing) {
@@ -211,6 +232,10 @@ export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     }
     const label = opts.label || 'Zellij launch';
     const autoYes = list.includes('--yes') || list.includes('-y');
+    if (mode === 'nonblocking-notice') {
+        console.log(`Zellij update available: ${notice.current_version} -> ${notice.latest_version}. Run: ${notice.upgrade_command}`);
+        return { status: 'available', current: notice.current_version, latest: notice.latest_version, command: notice.upgrade_command };
+    }
     if (!autoYes && !canAskYesNo(env)) {
         console.log(`Zellij update available: ${notice.current_version} -> ${notice.latest_version}. Run: ${notice.upgrade_command}`);
         return { status: 'available', current: notice.current_version, latest: notice.latest_version, command: notice.upgrade_command };
@@ -284,7 +309,7 @@ function githubLatestTag(timeoutMs) {
     });
 }
 function canAskYesNo(env) {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY && env.CI !== 'true');
+    return resolveZellijUpdatePromptMode({ env, headless: !(process.stdin.isTTY && process.stdout.isTTY) }) === 'interactive-prompt';
 }
 async function askYesNoDefaultYes(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

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

@@ -1,13 +1,16 @@
 import path from 'node:path';
 import { appendJsonl, ensureDir, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js';
 import { providerPaneLabel } from '../provider/provider-badge.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
+import { checkZellijStackedPaneCapability } from './zellij-capability.js';
 import { runZellij } from './zellij-command.js';
 import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
 import { buildZellijSlotColumnAnchorCommand } from './zellij-slot-column-anchor.js';
 import { closeWorkerInRightColumn, prepareWorkerInRightColumn, readRightColumnState, recordSlotColumnAnchorInRightColumn, recordWorkerPaneInRightColumn } from './zellij-right-column-manager.js';
 export const ZELLIJ_WORKER_PANE_SCHEMA = 'sks.zellij-worker-pane.v1';
 export const ZELLIJ_WORKER_PANE_EVENT_SCHEMA = 'sks.zellij-worker-pane-event.v1';
+export const ZELLIJ_PANE_CREATION_LOCK_METRICS_SCHEMA = 'sks.zellij-pane-creation-lock-metrics.v1';
 export function buildWorkerPaneName(slotId, generationIndex) {
     return `${slotId}/gen-${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
 }
@@ -77,12 +80,15 @@ export function buildWorkerPaneArtifact(input) {
         worker_direction_applied: input.workerDirectionApplied || (directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied'),
         worker_stacked_requested: input.stackedRequested === true,
         worker_stacked_applied: input.stackedApplied === true,
+        worker_stacked_fallback_mode: input.stackedFallbackMode || null,
+        worker_stacked_capability: input.stackedCapability || null,
         slot_column_anchor_pane_id: input.slotColumnAnchorPaneId || null,
         right_column: input.rightColumn || null,
         sdk_thread_id: input.sdkThreadId || null,
         sdk_run_id: input.sdkRunId || null,
         stream_event_count: Number(input.streamEventCount || 0),
         structured_output_valid: input.structuredOutputValid === true,
+        warnings: input.warnings || [],
         blockers
     };
 }
@@ -163,7 +169,7 @@ export async function openWorkerPane(input) {
     // --direction right — splitting the screen into N side-by-side columns
     // (observed in agent-zellij-pane-launch-ledger: terminal_1..terminal_5 all
     // recorded as separate slot_column_anchor_pane_id values in one mission).
-    return withZellijPaneCreationLock(input.sessionName, async () => {
+    return withZellijPaneCreationLock(input, async () => {
         // Re-read the right-column state now that we hold the lock: a previously
         // serialized worker may have created the anchor and/or its own pane.
         const freshState = rightColumn
@@ -221,9 +227,23 @@ export async function openWorkerPane(input) {
         // worker (`new-pane --stacked`, zellij >= 0.43) so the right column stays a
         // clean vertical stack instead of fragmenting the screen. Opt out with
         // SKS_ZELLIJ_WORKER_STACKED=0.
-        const stackRequested = process.env.SKS_ZELLIJ_WORKER_STACKED !== '0'
+        const stackIntent = process.env.SKS_ZELLIJ_WORKER_STACKED !== '0'
             && Boolean(lastVisibleWorkerPaneId)
             && focus?.ok === true;
+        const stackedCapability = stackIntent
+            ? await checkZellijStackedPaneCapability({ writeReport: false }).catch((err) => ({
+                schema: 'sks.zellij-stacked-pane-capability.v1',
+                ok: false,
+                zellij_bin: 'zellij',
+                version_text: null,
+                parsed_version: null,
+                supports_stacked_panes: false,
+                requires_update: false,
+                fallback_mode: 'headless-only',
+                blockers: [`zellij_stacked_capability_check_failed:${err?.code || err?.message || String(err)}`]
+            }))
+            : null;
+        const stackRequested = stackIntent && stackedCapability?.supports_stacked_panes === true;
         const newPaneArgs = stackRequested
             ? ['--session', input.sessionName, 'action', 'new-pane', '--stacked', '--name', paneName, '--', 'sh', '-lc', input.workerCommand]
             : ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, '--near-current-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
@@ -236,6 +256,7 @@ export async function openWorkerPane(input) {
             : null;
         let stackApplied = Boolean(stackRequested && launch?.ok);
         let directionApplied = launch?.ok ? directionRequested : 'not_applied';
+        let stackedRejectedFallback = false;
         if (createSession.ok && launch && !launch.ok) {
             const fallbackArgs = ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
             const fallback = await runZellij(fallbackArgs, {
@@ -246,6 +267,7 @@ export async function openWorkerPane(input) {
             if (fallback.ok) {
                 launch = fallback;
                 stackApplied = false;
+                stackedRejectedFallback = stackRequested;
                 directionApplied = rightColumn ? 'down' : 'unknown';
             }
         }
@@ -268,6 +290,10 @@ export async function openWorkerPane(input) {
             ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
             ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
         ];
+        const warnings = [
+            ...(stackIntent && stackedCapability && !stackedCapability.supports_stacked_panes ? [`zellij_stacked_pane_fallback:${stackedCapability.fallback_mode}`] : []),
+            ...(stackedRejectedFallback ? ['zellij_stacked_pane_rejected_fallback_down'] : [])
+        ];
         const record = buildWorkerPaneArtifact({
             ...input,
             paneId,
@@ -288,13 +314,16 @@ export async function openWorkerPane(input) {
             columnCreationDirectionApplied,
             workerDirectionRequested: 'down',
             workerDirectionApplied: directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied',
-            stackedRequested: stackRequested,
+            stackedRequested: stackIntent,
             stackedApplied: stackApplied,
+            stackedFallbackMode: stackIntent ? (stackApplied ? 'native-stacked' : stackedCapability?.fallback_mode || 'down-split-stack-emulation') : null,
+            stackedCapability,
             slotColumnAnchorPaneId,
             rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: focusPaneId, y_order: rightColumn.yOrder, slot_column_anchor_pane_id: slotColumnAnchorPaneId } : null,
             status: blockers.length ? 'failed' : 'running',
             providerContext,
             serviceTier: input.serviceTier || providerContext.service_tier,
+            warnings,
             blockers
         });
         await writeWorkerPaneArtifact(root, record);
@@ -311,8 +340,27 @@ export async function openWorkerPane(input) {
             ok: record.ok,
             pane_id: record.pane_id,
             pane_id_source: record.pane_id_source,
+            worker_stacked_requested: record.worker_stacked_requested === true,
+            worker_stacked_applied: record.worker_stacked_applied === true,
+            worker_stacked_fallback_mode: record.worker_stacked_fallback_mode || null,
             blockers
         });
+        await appendParallelRuntimeEvent(root, input.missionId, {
+            event_type: 'zellij_pane_created',
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            session_id: input.sessionId,
+            pid: null,
+            backend: String(input.backend || 'zellij'),
+            placement: 'zellij-pane',
+            meta: {
+                ok: record.ok,
+                pane_id: record.pane_id,
+                worker_stacked_requested: record.worker_stacked_requested === true,
+                worker_stacked_applied: record.worker_stacked_applied === true,
+                worker_stacked_fallback_mode: record.worker_stacked_fallback_mode || null
+            }
+        }).catch(() => undefined);
         await appendJsonl(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'), {
             schema: 'sks.agent-zellij-pane-launch.v1',
             generated_at: nowIso(),
@@ -338,6 +386,7 @@ export async function openWorkerPane(input) {
             worker_direction_applied: record.worker_direction_applied,
             worker_stacked_requested: record.worker_stacked_requested === true,
             worker_stacked_applied: record.worker_stacked_applied === true,
+            worker_stacked_fallback_mode: record.worker_stacked_fallback_mode || null,
             slot_column_anchor_pane_id: record.slot_column_anchor_pane_id || null,
             command: record.command,
             worker_artifact_dir: input.workerArtifactDir,
@@ -627,8 +676,20 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 const zellijPaneCreationLocks = new Map();
-async function withZellijPaneCreationLock(sessionName, fn) {
-    const key = String(sessionName || 'default');
+async function withZellijPaneCreationLock(input, fn) {
+    const key = String(input.sessionName || 'default');
+    const requestedAt = nowIso();
+    const requestedMs = Date.now();
+    await appendWorkerPaneEvent(path.resolve(input.root), 'zellij_pane_creation_lock_requested', input, {}).catch(() => undefined);
+    await appendParallelRuntimeEvent(path.resolve(input.root), input.missionId, {
+        event_type: 'zellij_pane_creation_lock_requested',
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        session_id: input.sessionId,
+        pid: null,
+        backend: String(input.backend || 'zellij'),
+        placement: 'zellij-pane'
+    }).catch(() => undefined);
     const previous = zellijPaneCreationLocks.get(key) || Promise.resolve();
     let release;
     const current = new Promise((resolve) => {
@@ -636,15 +697,65 @@ async function withZellijPaneCreationLock(sessionName, fn) {
     });
     zellijPaneCreationLocks.set(key, previous.then(() => current, () => current));
     await previous.catch(() => undefined);
+    const acquiredAt = nowIso();
+    const acquiredMs = Date.now();
+    await appendWorkerPaneEvent(path.resolve(input.root), 'zellij_pane_creation_lock_acquired', input, { wait_ms: acquiredMs - requestedMs }).catch(() => undefined);
+    await appendParallelRuntimeEvent(path.resolve(input.root), input.missionId, {
+        event_type: 'zellij_pane_creation_lock_acquired',
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        session_id: input.sessionId,
+        pid: null,
+        backend: String(input.backend || 'zellij'),
+        placement: 'zellij-pane',
+        meta: { wait_ms: acquiredMs - requestedMs }
+    }).catch(() => undefined);
     try {
         return await fn();
     }
     finally {
+        const releasedAt = nowIso();
+        const releasedMs = Date.now();
+        const metrics = {
+            schema: ZELLIJ_PANE_CREATION_LOCK_METRICS_SCHEMA,
+            mission_id: input.missionId,
+            session_name: input.sessionName,
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            requested_at: requestedAt,
+            acquired_at: acquiredAt,
+            released_at: releasedAt,
+            wait_ms: acquiredMs - requestedMs,
+            held_ms: releasedMs - acquiredMs
+        };
+        await appendJsonl(paneCreationLockMetricsPath(path.resolve(input.root), input.missionId), metrics).catch(() => undefined);
+        await appendWorkerPaneEvent(path.resolve(input.root), 'zellij_pane_creation_lock_released', input, { wait_ms: metrics.wait_ms, held_ms: metrics.held_ms }).catch(() => undefined);
+        await appendParallelRuntimeEvent(path.resolve(input.root), input.missionId, {
+            event_type: 'zellij_pane_creation_lock_released',
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            session_id: input.sessionId,
+            pid: null,
+            backend: String(input.backend || 'zellij'),
+            placement: 'zellij-pane',
+            meta: { wait_ms: metrics.wait_ms, held_ms: metrics.held_ms }
+        }).catch(() => undefined);
         release();
         if (zellijPaneCreationLocks.get(key) === current)
             zellijPaneCreationLocks.delete(key);
     }
 }
+function paneCreationLockMetricsPath(root, missionId) {
+    return path.join(missionArtifactRoot(root, missionId), 'zellij', 'pane-creation-lock-events.jsonl');
+}
+function missionArtifactRoot(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents')
+        return path.dirname(resolved);
+    if (path.basename(resolved) === missionId)
+        return resolved;
+    return path.join(resolved, '.sneakoscope', 'missions', missionId);
+}
 function normalizeExistingZellijSession(sessionName, result) {
     if (result.ok)
         return result;

package/dist/scripts/github-release-body-helper.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, root } from './sks-1-18-gate-lib.js';
+const args = process.argv.slice(2);
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const truth = readJson('.sneakoscope/release-proof-truth.json') || readJson('dist/release-proof-truth.json');
+const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
+const latest = latestChangelogSection(changelog);
+const body = [
+    `Version: ${pkg.version}`,
+    `Commit: ${truth?.git_commit_sha || 'unknown'}`,
+    `Packlist: ${truth?.npm_packlist_count ?? 'unknown'} files / ${truth?.npm_packlist_bytes ?? 'unknown'} bytes`,
+    'Release gates: passed',
+    '',
+    latest.body.trim()
+].join('\n');
+if (args.includes('--check')) {
+    assertGate(Boolean(truth && truth.schema === 'sks.release-proof-truth.v1'), 'release proof truth missing; run npm run release:proof-truth first');
+    assertGate(latest.version === pkg.version, 'latest changelog section must match package version', { latest: latest.version, package: pkg.version });
+    assertGate(body.includes(`Version: ${pkg.version}`) && body.includes('Commit:') && body.includes('Packlist:'), 'github release body helper missing source truth fields', { body });
+}
+console.log(body);
+function readJson(rel) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(root, rel), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function latestChangelogSection(text) {
+    const matches = [...text.matchAll(/^## \[([^\]]+)\][^\n]*\n/gm)];
+    const first = matches.find((match) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(match[1]));
+    if (!first)
+        return { version: null, body: '' };
+    const second = matches.find((match) => (match.index || 0) > (first.index || 0));
+    const start = (first.index || 0) + first[0].length;
+    const end = second?.index || text.length;
+    return { version: first[1], body: text.slice(start, end) };
+}
+//# sourceMappingURL=github-release-body-helper.js.map

package/dist/scripts/release-speed-summary.js

@@ -25,6 +25,17 @@ console.log(JSON.stringify({
     skipped_gate_ids: summary?.skipped_by_affected || [],
     cached: summary?.cached || 0,
     cached_gates: summary?.cached_gates || [],
+    version_neutralized_inputs: [
+        'package.json:version',
+        'package-lock.json:root.version',
+        'src/core/version.ts:PACKAGE_VERSION',
+        'src/core/fsx.ts:PACKAGE_VERSION',
+        'src/bin/sks.ts:FAST_PACKAGE_VERSION',
+        'dist/build-manifest.json:version'
+    ],
+    behavior_affecting_inputs: [],
+    cache_key_policy: 'version-neutral-safe-v1',
+    cache_message: 'Release cache: version-only changes neutralized for behavior gates. Version correctness gates still ran uncached.',
     executed: summary?.executed_gates?.length || 0,
     executed_gates: summary?.executed_gates || [],
     wall_ms: summary?.wall_ms || 0,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -701,7 +701,24 @@
     "codex:model-metadata": "node ./dist/scripts/codex-model-metadata-check.js",
     "codex:effort-auto-discovery": "node ./dist/scripts/codex-effort-auto-discovery-check.js",
     "codex:account-usage-autodiscovery": "node ./dist/scripts/codex-account-usage-autodiscovery-check.js",
-    "codex:0138-feature-probes": "node ./dist/scripts/codex-0138-feature-probes-check.js"
+    "codex:0138-feature-probes": "node ./dist/scripts/codex-0138-feature-probes-check.js",
+    "zellij:stacked-version-parser": "node ./dist/scripts/zellij-stacked-version-parser-check.js",
+    "zellij:stacked-version-matrix": "node ./dist/scripts/zellij-stacked-version-matrix-check.js",
+    "zellij:stacked-capability-routing": "node ./dist/scripts/zellij-stacked-capability-routing-check.js",
+    "zellij:pane-creation-lock-metrics": "node ./dist/scripts/zellij-pane-creation-lock-metrics-check.js",
+    "zellij:pane-lock-does-not-block-worker": "node ./dist/scripts/zellij-pane-lock-does-not-block-worker-check.js",
+    "zellij:pane-lock-concurrency-blackbox": "node ./dist/scripts/zellij-pane-lock-concurrency-blackbox.js",
+    "release:cache-input-classifier": "node ./dist/scripts/release-cache-input-classifier-check.js",
+    "release:cache-version-neutral-fixtures": "node ./dist/scripts/release-cache-version-neutral-fixture-check.js",
+    "release:cache-neutralization-report": "node ./dist/scripts/release-cache-neutralization-report-check.js",
+    "agent:message-bus-reader": "node ./dist/scripts/agent-message-bus-reader-check.js",
+    "runtime:proof-summary-messages": "node ./dist/scripts/runtime-proof-summary-messages-check.js",
+    "naruto:proof-message-summary": "node ./dist/scripts/naruto-proof-message-summary-check.js",
+    "zellij:update-prompt-mode": "node ./dist/scripts/zellij-update-prompt-mode-check.js",
+    "zellij:update-prompt-safety": "node ./dist/scripts/zellij-update-prompt-safety-check.js",
+    "zellij:update-prompt-matrix": "node ./dist/scripts/zellij-update-prompt-matrix-check.js",
+    "release:proof-truth": "node ./dist/scripts/release-proof-truth-check.js",
+    "release:github-body-helper": "node ./dist/scripts/github-release-body-helper.js --check"
   },
   "keywords": [
     "sneakoscope",