sneakoscope 2.0.15 → 2.0.17

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.15** is the ultra-stabilized Research synthesis release. It keeps the 2.0.14 stage-aware runtime, then hardens final synthesis so non-mock Research uses an evidence-bound Codex/GPT writer, rejects repeated or template-like reports, records source/claim density, and produces handoffs that Team or Naruto can consume directly.
+SKS **2.0.17** is the micro-hardening release for strict production PID proof, true scheduler active-time utilization, live Zellij slot telemetry freshness, Mad-DB result lifecycle audit, and unified runtime/release proof summaries.
 
 What changed:
 
@@ -613,7 +613,9 @@ SKS_HERMES=1 sks status --json
 
 Use these inside Codex App or another agent prompt. They are prompt commands, not terminal commands.
 
-Common prompts: `$Team`, `$From-Chat-IMG`, `$with-local-llm-on`, `$with-local-llm-off`, `$DFix`, `$Answer`, `$SKS`, `$QA-LOOP`, `$PPT`, `$Computer-Use`/`$CU`, `$Goal`, `$Research`, `$AutoResearch`, `$DB`, `$MAD-SKS`, `$GX`, `$Wiki`, and `$Help`.
+Common prompts: `$Team`, `$From-Chat-IMG`, `$with-local-llm-on`, `$with-local-llm-off`, `$DFix`, `$Answer`, `$SKS`, `$QA-LOOP`, `$PPT`, `$Computer-Use`/`$CU`, `$Goal`, `$Research`, `$AutoResearch`, `$DB`, `$MAD-SKS`, `$MAD-DB`, `$GX`, `$Wiki`, and `$Help`.
+
+`$MAD-DB` is the prompt-visible Mad-DB alias for one-cycle DB break-glass work. It maps to the same guarded MAD-SKS permission route, while the terminal lifecycle remains `sks mad-db status|enable|revoke`; it is not a permanent DB unlock and catastrophic DB safeguards remain active.
 
 ## Common Workflows
 
@@ -759,7 +761,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` and `npm run publish:dry` both run `release:check:full`, verify the fresh stamp, and then run provenance/registry checks before the real or dry-run publish step.
+`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. `npm run publish:dry` runs `release:check:full`, verifies the fresh stamp, and then performs provenance/registry and npm dry-run checks. npm's `prepublishOnly` uses `prepublish-release-check-or-fast` to accept that current stamp before the real publish; if the stamp is missing or stale, it runs `release:check:full` once before continuing.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.15"
+version = "2.0.17"
 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 2.0.15"),
+        Some("--version") => println!("sks-rs 2.0.17"),
         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": "2.0.15",
-  "source_digest": "18f7432c59dd0bbd8090697c2cd4e0c4681d05923e3086f4a96cdc4e0b420280",
-  "source_file_count": 2160,
-  "built_at_source_time": 1780893056447
+  "package_version": "2.0.17",
+  "source_digest": "1c6ef84350a97acdfd592ae544ec9054e2ee0a997076e725bc99b771c4693cf2",
+  "source_file_count": 2201,
+  "built_at_source_time": 1780974441836
 }

package/dist/bin/sks.js

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

package/dist/cli/command-registry.js

@@ -119,7 +119,7 @@ export const COMMANDS = {
     commit: entry('stable', 'Create a simple git commit', 'dist/commands/commit.js', directCommand(() => import('../commands/commit.js'), 'dist/commands/commit.js')),
     'commit-and-push': entry('stable', 'Create a simple git commit and push', 'dist/commands/commit-and-push.js', directCommand(() => import('../commands/commit-and-push.js'), 'dist/commands/commit-and-push.js')),
     dfix: entry('stable', 'Run DFix diagnose/plan/patch/verify loop', 'dist/core/commands/dfix-command.js', commandArgsCommand(() => import('../core/commands/dfix-command.js'), 'dfixCommand', 'dist/core/commands/dfix-command.js')),
-    team: entry('beta', 'Create and observe Team missions', 'dist/core/commands/team-command.js', argsCommand(() => import('../core/commands/team-command.js'), 'team', 'dist/core/commands/team-command.js')),
+    team: entry('beta', 'Deprecated alias. New execution redirects to Naruto; legacy observe/watch remains.', 'dist/core/commands/team-command.js', argsCommand(() => import('../core/commands/team-command.js'), 'team', 'dist/core/commands/team-command.js')),
     agent: entry('beta', 'Run native multi-session agent missions', 'dist/core/commands/agent-command.js', argsCommand(() => import('../core/commands/agent-command.js'), 'agentCommand', 'dist/core/commands/agent-command.js')),
     'with-local-llm': entry('beta', 'Enable or inspect local Ollama worker backend', 'dist/core/commands/local-model-command.js', argsCommand(() => import('../core/commands/local-model-command.js'), 'localModelCommand', 'dist/core/commands/local-model-command.js')),
     naruto: entry('labs', 'Run $Naruto shadow-clone swarm (up to 100 parallel sessions)', 'dist/core/commands/naruto-command.js', argsCommand(() => import('../core/commands/naruto-command.js'), 'narutoCommand', 'dist/core/commands/naruto-command.js')),

package/dist/commands/proof.js

@@ -8,10 +8,20 @@ import { writeRouteCompletionProof } from '../core/proof/route-adapter.js';
 import { finalizeRouteWithProof } from '../core/proof/route-finalizer.js';
 import { renderProofMarkdown, writeCompletionProof } from '../core/proof/proof-writer.js';
 import { validateCompletionProof } from '../core/proof/validation.js';
+import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../core/agents/runtime-proof-summary.js';
 export async function run(_command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'show';
     const rest = args.slice(1);
+    if (action === 'latest' && !flag(args, '--completion')) {
+        const runtime = await tryRuntimeProofSummary(root);
+        if (runtime) {
+            if (flag(args, '--json'))
+                return printJson(runtime);
+            console.log(renderRuntimeProofSummary(runtime));
+            return;
+        }
+    }
     if (action === 'show' || action === 'latest') {
         const proof = await withFreshSummaries(root, await readLatestProof(root));
         if (flag(args, '--json') || action === 'latest')
@@ -122,6 +132,17 @@ export async function run(_command, args = []) {
     console.error('Usage: sks proof show|latest|validate|route <mission-id|latest>|finalize <mission-id|latest> [--route route] [--strict] [--mock] [--json]|export --md|repair latest|smoke [--json]');
     process.exitCode = 1;
 }
+async function tryRuntimeProofSummary(root) {
+    try {
+        const summary = await buildRuntimeProofSummary(root, 'latest');
+        if (summary.blockers.includes('parallel_runtime_proof_missing') && summary.blockers.includes('agent_scheduler_state_missing'))
+            return null;
+        return summary;
+    }
+    catch {
+        return null;
+    }
+}
 async function withFreshSummaries(root, proof) {
     const evidence = await collectProofEvidence(root);
     return {

package/dist/commands/zellij-slot-pane.js

@@ -1,4 +1,4 @@
-import { renderZellijSlotPaneFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
+import { renderZellijSlotPaneFromArtifacts, renderZellijSlotPaneStatusFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
 export async function run(_command = 'zellij-slot-pane', args = []) {
     const artifactDir = readOption(args, '--artifact-dir', process.cwd()) || process.cwd();
     const artifactRoot = readOption(args, '--artifact-root', artifactDir) || artifactDir;
@@ -9,7 +9,13 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
     const role = readOption(args, '--role', null);
     const mode = readOption(args, '--mode', 'compact-slots');
     const watch = hasFlag(args, '--watch');
+    const json = hasFlag(args, '--json');
     const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000') || 1000));
+    if (json) {
+        const status = await renderZellijSlotPaneStatusFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex });
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
     for (;;) {
         const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
         process.stdout.write('\x1Bc' + text + '\n');

package/dist/core/agents/agent-orchestrator.js

@@ -54,7 +54,7 @@ import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } fro
 import { resolveLocalCollaborationPolicy, localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
 import { runFinalGptReviewStage } from '../pipeline/final-gpt-review-stage.js';
 import { selectFinalGptPatchSource } from '../pipeline/final-gpt-patch-stage.js';
-import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { allocateWorkerWorktree, allocateWorkerWorktreesBatch } from '../git/git-worktree-manager.js';
 import { exportGitWorktreeDiff } from '../git/git-worktree-diff.js';
 import { buildGitWorktreePatchEnvelope } from '../git/git-worktree-patch-envelope.js';
 import { checkpointWorkerWorktree } from '../git/git-worktree-checkpoint.js';
@@ -63,6 +63,7 @@ import { createGitIntegrationWorktree } from '../git/git-integration-worktree.js
 import { applyGitWorktreeMergeQueue } from '../git/git-worktree-merge-queue.js';
 import { crossRebaseIdleWorktrees } from '../git/git-worktree-cross-rebase.js';
 import { gitOutputLine, runGitCommand } from '../git/git-worktree-runner.js';
+import { writeParallelRuntimeProof } from './parallel-runtime-proof.js';
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const prompt = String(opts.prompt || 'Native agent run');
@@ -289,9 +290,46 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         diffs: [],
         checkpoints: [],
         cleanup: [],
+        prewarmed_allocations: [],
         blockers: []
     };
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-git-worktree-runtime.json'), gitWorktreeRuntime);
+    const preparedWorktreeAllocations = new Map();
+    if (gitWorktreePolicy?.mode === 'git-worktree') {
+        const writeSlices = uniqueWritableSlicesForWorktrees(partition.slices, Math.max(1, targetActiveSlots));
+        if (writeSlices.length) {
+            const prewarmed = await allocateWorkerWorktreesBatch({
+                root: gitWorktreePolicy.main_repo_root || root,
+                missionId,
+                workers: writeSlices.map((slice, index) => ({
+                    workerId: String(slice.owner_agent_id || slice.owner || `worker-${index + 1}`),
+                    slotId: String(slice.owner_agent_id || slice.owner || `slot-${index + 1}`),
+                    generationIndex: 1
+                })),
+                maxParallel: Math.min(targetActiveSlots, Number(process.env.SKS_NARUTO_GIT_WORKTREE_CAP || targetActiveSlots))
+            }).catch((err) => {
+                gitWorktreeRuntime.blockers.push('git_worktree_batch_prewarm_failed:' + (err instanceof Error ? err.message : String(err)));
+                gitWorktreeRuntime.ok = false;
+                return [];
+            });
+            gitWorktreeRuntime.prewarmed_allocations = prewarmed.map((allocation) => ({
+                worker_id: allocation.worker_id,
+                slot_id: allocation.slot_id,
+                ok: allocation.ok,
+                worktree_path: allocation.worktree_path,
+                branch: allocation.branch,
+                blockers: allocation.blockers
+            }));
+            for (const allocation of prewarmed) {
+                if (allocation.ok)
+                    preparedWorktreeAllocations.set(String(allocation.worker_id), allocation);
+                else
+                    gitWorktreeRuntime.blockers.push(...allocation.blockers);
+            }
+            gitWorktreeRuntime.ok = gitWorktreeRuntime.blockers.length === 0;
+            await writeJsonAtomic(path.join(ledgerRoot, 'agent-git-worktree-runtime.json'), gitWorktreeRuntime);
+        }
+    }
     const nativeCliSwarm = createNativeCliSessionSwarmRecorder(ledgerRoot, {
         missionId,
         requestedAgents: Number(opts.agents || roster.agent_count || targetActiveSlots),
@@ -329,7 +367,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
                 agent,
                 slice,
                 policy: gitWorktreePolicy,
-                runtime: gitWorktreeRuntime
+                runtime: gitWorktreeRuntime,
+                preparedAllocation: preparedWorktreeAllocations.get(String(agent.id || '')) || null
             });
             const runtimeAgent = workerWorktree ? { ...agent, worktree: workerWorktree.context } : agent;
             const runtimeSlice = workerWorktree ? { ...slice, worktree: workerWorktree.context } : slice;
@@ -432,6 +471,15 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         }
     });
     await nativeCliSwarm.finalize();
+    const parallelRuntimeProof = await writeParallelRuntimeProof(ledgerRoot, missionId, {
+        requestedWorkers: Number(opts.agents || roster.agent_count || targetActiveSlots),
+        targetActiveSlots,
+        visiblePanes: visualLaneCount,
+        expectedWorkerRuntimeMs: targetActiveSlots >= 10 ? 8000 : targetActiveSlots >= 2 ? 2000 : 25,
+        minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount),
+        proofMode: opts.mock === true ? 'mock-process' : 'production',
+        requireWorkerPids: opts.nativeCliSwarm !== false && targetActiveSlots >= 16
+    });
     const results = scheduler.results;
     const nativeCliSessionProof = await writeNativeCliSessionProof(ledgerRoot, {
         requestedAgents: Number(opts.agents || roster.agent_count || targetActiveSlots),
@@ -600,6 +648,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         gpt_final_arbiter: gptFinalArbiter,
         final_gpt_patch_stage: finalGptPatchStage,
         patch_swarm: patchSwarm,
+        parallel_runtime_proof: parallelRuntimeProof,
         proof
     };
 }
@@ -620,6 +669,22 @@ function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
         next[0] = { ...next[0], patch_envelopes: patchEnvelopes };
     return next;
 }
+function uniqueWritableSlicesForWorktrees(slices = [], limit) {
+    const selected = [];
+    const seenOwners = new Set();
+    for (const slice of Array.isArray(slices) ? slices : []) {
+        if (!Array.isArray(slice?.write_paths) || slice.write_paths.length === 0)
+            continue;
+        const owner = String(slice.owner_agent_id || slice.owner || slice.id || '');
+        if (!owner || seenOwners.has(owner))
+            continue;
+        seenOwners.add(owner);
+        selected.push(slice);
+        if (selected.length >= Math.max(1, limit))
+            break;
+    }
+    return selected;
+}
 function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveSlots, parentPrompt = '') {
     const activeRoster = (Array.isArray(roster?.roster) ? roster.roster : []).slice(0, Math.max(1, targetActiveSlots));
     const activeAgentIds = new Set(activeRoster.map((row) => String(row.id || '')).filter(Boolean));
@@ -873,7 +938,7 @@ async function prepareWorkerGitWorktree(input) {
     if (!sliceHasWritePaths && !agentWriteCapable)
         return null;
     const generationIndex = Math.max(1, Math.floor(Number(input.agent.generation_index || 1)));
-    const allocation = await allocateWorkerWorktree({
+    const allocation = input.preparedAllocation || await allocateWorkerWorktree({
         repoRoot: input.policy.main_repo_root || input.root,
         missionId: input.missionId,
         workerId: String(input.agent.id || input.slice.id || 'worker'),