sneakoscope 2.0.16 → 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.16** is the real parallelism closure release. It proves Naruto/agent runtime concurrency with PID, launch overlap, wall-clock speedup, active/headless worker, model-call, worktree allocation, and incremental Zellij telemetry evidence while keeping Naruto as the execution SSOT.
+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.16"
+version = "2.0.17"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.16"
+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.16"),
+        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.16",
-  "source_digest": "cafc32cad87d3b6c7aeb0ec0e8e56258f830b35e71fd919440a8c1b95b78432a",
-  "source_file_count": 2187,
-  "built_at_source_time": 1780927200051
+  "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.16';
+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', 'Deprecated Team alias; create redirects to Naruto, observe legacy 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

@@ -476,7 +476,9 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         targetActiveSlots,
         visiblePanes: visualLaneCount,
         expectedWorkerRuntimeMs: targetActiveSlots >= 10 ? 8000 : targetActiveSlots >= 2 ? 2000 : 25,
-        minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount)
+        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, {

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

@@ -21,6 +21,8 @@ export async function runAgentScheduler(input) {
     const active = new Map();
     const results = [];
     const schedulerStartedAt = Date.now();
+    let lastUtilizationUpdateMs = schedulerStartedAt;
+    let activeSlotTimeMs = 0;
     let batchCounter = 0;
     let batchLaunchSpanTotalMs = 0;
     let batchDispatchInProgress = false;
@@ -43,6 +45,7 @@ export async function runAgentScheduler(input) {
         if (!entry)
             continue;
         const activeCountBeforeClose = active.size;
+        accumulateActiveSlotTime();
         active.delete(settled.session_id);
         const resultStatus = settled.result?.status === 'done' ? 'completed' : settled.result?.status === 'blocked' ? 'blocked' : 'failed';
         completeWorkItem(queue, entry.work_item_id, settled.session_id, resultStatus, settled.error || null);
@@ -70,6 +73,7 @@ export async function runAgentScheduler(input) {
         const pendingAfterClose = pendingWorkItems(queue).length;
         if (pendingAfterClose > 0)
             state.expected_backfill_count += 1;
+        updateUtilizationMetrics();
         await writeAll(input.root, state, slots, queue, active, {
             event_type: 'session_completed',
             session_id: settled.session_id,
@@ -85,6 +89,7 @@ export async function runAgentScheduler(input) {
             closed_at_ms: Date.now()
         } : null);
     }
+    updateUtilizationMetrics();
     state.status = 'draining';
     await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_draining' }, input.onSchedulerEvent);
     slots = closeWorkerSlotsAfterDrain(slots);
@@ -204,6 +209,7 @@ export async function runAgentScheduler(input) {
                     error: err instanceof Error ? err.message : String(err),
                     terminal_close_report_path: path.join(generation.artifact_dir, 'agent-terminal-close-report.json')
                 }));
+                accumulateActiveSlotTime();
                 active.set(generation.session_id, { slot_id: slot.slot_id, work_item_id: workItem.id, session_id: generation.session_id, promise });
             }
             await appendAgentWorkQueueEvent(input.root, 'batch_work_items_dispatched', {
@@ -317,11 +323,18 @@ export async function runAgentScheduler(input) {
         return launches;
     }
     function updateUtilizationMetrics() {
+        accumulateActiveSlotTime();
         state.wall_time_ms = Math.max(0, Date.now() - schedulerStartedAt);
-        state.active_slot_time_ms = Math.max(state.active_slot_time_ms, state.completed_count * state.wall_time_ms);
+        state.active_slot_time_ms = activeSlotTimeMs;
         const denominator = Math.max(1, state.wall_time_ms * targetActiveSlots);
         state.scheduler_utilization = Number(Math.min(1, state.active_slot_time_ms / denominator).toFixed(3));
     }
+    function accumulateActiveSlotTime() {
+        const now = Date.now();
+        const delta = Math.max(0, now - lastUtilizationUpdateMs);
+        activeSlotTimeMs += active.size * delta;
+        lastUtilizationUpdateMs = now;
+    }
 }
 export function normalizeTargetActiveSlots(value, maxActiveSlots = MAX_AGENT_COUNT) {
     const cap = Number.isFinite(Number(maxActiveSlots)) && Number(maxActiveSlots) >= 1 ? Math.floor(Number(maxActiveSlots)) : MAX_AGENT_COUNT;

package/dist/core/agents/native-cli-session-swarm.js

@@ -8,7 +8,7 @@ import { closeWorkerPane, openWorkerPane } from '../zellij/zellij-worker-pane-ma
 import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
-import { resolveZellijUiMode } from '../zellij/zellij-ui-mode.js';
+import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
@@ -278,7 +278,8 @@ class NativeCliSessionSwarmRecorder {
             route: this.input.route,
             serviceTier: this.input.fastModePolicy.service_tier
         });
-        const uiMode = resolveZellijUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const uiMode = resolveZellijWorkerPaneUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const liveWorkerPane = uiMode !== 'compact-slots';
         const workerEnv = {
             ...(input.ctx.opts.env || {}),
             ...fastModeEnv(this.input.fastModePolicy),
@@ -300,7 +301,7 @@ class NativeCliSessionSwarmRecorder {
             artifacts: [path.join(input.workerDirRel, 'worker-intake.json'), input.heartbeatRel, input.resultRel],
             logTail: `zellij=${sessionName}`
         });
-        const workerCommand = uiMode === 'full-debug'
+        const workerCommand = liveWorkerPane
             ? buildPaneWorkerCommand({
                 args: input.args,
                 stdoutPath: path.join(this.root, input.stdoutRel),
@@ -332,7 +333,7 @@ class NativeCliSessionSwarmRecorder {
                 mode: uiMode,
                 watch: true
             });
-        const processRun = uiMode === 'full-debug'
+        const processRun = liveWorkerPane
             ? null
             : await this.spawnCompactSlotWorkerProcess({
                 args: input.args,
@@ -405,7 +406,7 @@ class NativeCliSessionSwarmRecorder {
         const zellijRequired = process.env.SKS_REQUIRE_ZELLIJ === '1';
         const launchBlockers = zellijRequired ? paneRecord.blockers || [] : [];
         const launchWarnings = zellijRequired ? [] : paneRecord.blockers || [];
-        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', liveWorkerPane ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
         input.record.zellij_pane_id_source = paneRecord.pane_id_source;
@@ -419,7 +420,7 @@ class NativeCliSessionSwarmRecorder {
         input.record.provider_context = paneRecord.provider_context;
         input.record.worktree = worktree;
         input.record.zellij_ui_mode = uiMode;
-        input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
+        input.record.slot_visualization = liveWorkerPane ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
         input.record.warnings = [...(input.record.warnings || []), ...launchWarnings];
@@ -741,7 +742,10 @@ export function buildPaneWorkerCommand(input) {
     const holdMs = Math.max(0, Number(process.env.SKS_ZELLIJ_WORKER_PANE_HOLD_MS || 1500));
     const hold = holdMs > 0 ? `sleep ${shellQuote(String(Math.min(30, holdMs / 1000)))}` : ':';
     const header = input.header ? `printf '%s\\n' ${shellQuote(input.header)} | tee -a ${shellQuote(input.stdoutPath)};` : '';
-    return `${envPrefix.join(' ')} ${header} ${command} >> ${shellQuote(input.stdoutPath)} 2>> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+    const exitPath = `${input.heartbeatPath}.exit`;
+    const visibleCommand = `(${command}; printf '%s' "$?" > ${shellQuote(exitPath)}) 2>&1 | tee -a ${shellQuote(input.stdoutPath)}`;
+    const readExit = `code=$(cat ${shellQuote(exitPath)} 2>/dev/null || printf '1'); rm -f ${shellQuote(exitPath)}`;
+    return `${envPrefix.join(' ')} ${header} ${visibleCommand}; ${readExit}; ${heartbeat}; ${hold}; exit $code`.trim();
 }
 function buildPaneWorkerHeader(input) {
     return [

package/dist/core/agents/native-cli-worker.js

@@ -126,18 +126,33 @@ export async function runNativeCliWorker(input = {}) {
     });
     await writeJsonAtomic(path.join(workerDir, 'worker-recursion-guard.json'), guard);
     let noPatchReason = null;
-    const routed = await runNativeWorkerBackendRouter({
+    const progressTelemetry = startWorkerProgressTelemetry({
         agentRoot,
-        workerDirRel,
-        resultRel,
-        patchRel,
+        heartbeatRel,
+        intake,
         agent,
         slice,
-        intake: { ...intake, ...input },
         backend,
-        fastModePolicy: policy,
-        guard
+        serviceTier: policy.service_tier
     });
+    let routed;
+    try {
+        routed = await runNativeWorkerBackendRouter({
+            agentRoot,
+            workerDirRel,
+            resultRel,
+            patchRel,
+            agent,
+            slice,
+            intake: { ...intake, ...input },
+            backend,
+            fastModePolicy: policy,
+            guard
+        });
+    }
+    finally {
+        progressTelemetry.stop();
+    }
     const patchEnvelopes = routed.patchEnvelopes;
     if (patchEnvelopes.length) {
         await writeJsonAtomic(path.resolve(agentRoot, patchRel), {
@@ -330,6 +345,39 @@ export async function runNativeCliWorker(input = {}) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function startWorkerProgressTelemetry(input) {
+    const parsed = Number(process.env.SKS_ZELLIJ_WORKER_PROGRESS_MS || 2000);
+    const intervalMs = Math.max(500, Number.isFinite(parsed) ? Math.floor(parsed) : 2000);
+    let tick = 0;
+    const timer = setInterval(() => {
+        tick += 1;
+        const progress = { done: tick, total: 0, label: 'backend running' };
+        appendJsonl(path.resolve(input.agentRoot, input.heartbeatRel), {
+            schema: 'sks.native-cli-worker-heartbeat.v1',
+            ts: nowIso(),
+            event: 'progress',
+            pid: process.pid,
+            session_id: input.agent.session_id,
+            slot_id: input.agent.slot_id || null,
+            generation_index: input.agent.generation_index || null,
+            progress
+        }).catch(() => undefined);
+        workerTelemetry(input.agentRoot, input.intake, input.agent, input.slice, {
+            eventType: 'task_progress',
+            status: 'running',
+            backend: input.backend,
+            serviceTier: input.serviceTier,
+            artifacts: [input.heartbeatRel],
+            progress,
+            logTail: `backend running ${tick}`
+        }).catch(() => undefined);
+    }, intervalMs);
+    return {
+        stop() {
+            clearInterval(timer);
+        }
+    };
+}
 function parseNativeCliWorkerArgs(args) {
     return {
         intake: readOption(args, '--intake', ''),
@@ -389,6 +437,7 @@ async function workerTelemetry(agentRoot, intake, agent, slice, input) {
         worktree_path: agent.worktree?.path || slice.worktree?.path || intake.worktree?.path || null,
         task_title: String(slice.description || slice.title || slice.id || 'worker task'),
         current_file: firstString([slice.write_paths?.[0], slice.readonly_paths?.[0], slice.input_files?.[0]]) || null,
+        ...(input.progress ? { progress: input.progress } : {}),
         artifact_paths: input.artifacts || [],
         log_tail: input.logTail || '',
         blockers: input.blockers || []

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonlBounded, ensureDir, nowIso, readText, writeJsonAtomic } from '../fsx.js';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 export const PARALLEL_RUNTIME_EVENT_SCHEMA = 'sks.parallel-runtime-event.v1';
 export const PARALLEL_RUNTIME_PROOF_SCHEMA = 'sks.parallel-runtime-proof.v1';
 export function parallelRuntimeEventPath(root, missionId) {
@@ -92,6 +92,9 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
     }
     const requestedWorkers = positiveInt(opts.requestedWorkers, workerStarts.size || workerPids.size || maxWorkers);
     const targetActiveSlots = positiveInt(opts.targetActiveSlots, requestedWorkers);
+    const proofMode = opts.proofMode || 'production';
+    const allowMissingPids = proofMode === 'in-process-fixture' && opts.allowMissingPids === true;
+    const requireWorkerPids = opts.requireWorkerPids ?? (proofMode === 'production' && requestedWorkers >= 16);
     const wallMs = Math.max(0, lastMs - firstMs);
     const sequentialEstimateMs = workerDurations.length
         ? workerDurations.reduce((sum, value) => sum + value, 0)
@@ -107,17 +110,33 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
     const launchEvents = sorted.filter((event) => event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned');
     const launchSpanMs = launchEvents.length ? Math.max(...launchEvents.map((event) => event.ms)) - Math.min(...launchEvents.map((event) => event.ms)) : 0;
     const firstBatchLimit = positiveInt(opts.firstBatchLaunchSpanLimitMs, requestedWorkers >= 16 ? 2500 : 30000);
-    const blockers = [
-        ...(sorted.length ? [] : ['parallel_runtime_events_missing']),
-        ...(minActiveWorkers <= 0 || maxWorkers >= minActiveWorkers ? [] : ['max_observed_active_workers_below_target']),
-        ...(requestedWorkers >= 16 && workerPids.size && workerPids.size < minActiveWorkers ? ['unique_worker_pids_below_target'] : []),
-        ...(speedupRatio >= minSpeedup ? [] : ['speedup_ratio_below_target']),
-        ...(firstBatchLaunchSpanMs <= firstBatchLimit ? [] : ['first_batch_launch_span_above_limit'])
-    ];
+    const schedulerState = await readJson(path.join(root, 'agent-scheduler-state.json'), null).catch(() => null);
+    const coalescedOverlapWindows = coalesceOverlapWindows(overlapWindows);
+    const utilizationProofConsistency = buildUtilizationProofConsistency(schedulerState, {
+        proofMaxActive: maxWorkers,
+        proofWallMs: wallMs,
+        proofActiveSlotTimeMs: activeSlotTimeMsFromWindows(coalescedOverlapWindows)
+    });
+    const blockers = [];
+    if (!sorted.length)
+        blockers.push('parallel_runtime_events_missing');
+    if (minActiveWorkers > 0 && maxWorkers < minActiveWorkers)
+        blockers.push('max_observed_active_workers_below_target');
+    if (requireWorkerPids && workerPids.size < minActiveWorkers)
+        blockers.push('unique_worker_pids_below_target');
+    if (requireWorkerPids && workerPids.size === 0)
+        blockers.push('unique_worker_pids_missing_in_production_proof');
+    if (speedupRatio < minSpeedup)
+        blockers.push('speedup_ratio_below_target');
+    if (firstBatchLaunchSpanMs > firstBatchLimit)
+        blockers.push('first_batch_launch_span_above_limit');
     return {
         schema: PARALLEL_RUNTIME_PROOF_SCHEMA,
         mission_id: missionId,
         generated_at: nowIso(),
+        proof_mode: proofMode,
+        require_worker_pids: requireWorkerPids,
+        allow_missing_pids: allowMissingPids,
         requested_workers: requestedWorkers,
         target_active_slots: targetActiveSlots,
         max_observed_active_workers: maxWorkers,
@@ -130,9 +149,10 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
         wall_ms: wallMs,
         sequential_estimate_ms: sequentialEstimateMs,
         speedup_ratio: speedupRatio,
-        overlap_windows: coalesceOverlapWindows(overlapWindows),
+        overlap_windows: coalescedOverlapWindows,
         visible_panes: visiblePanes,
         headless_workers: headlessWorkers,
+        utilization_proof_consistency: utilizationProofConsistency,
         passed: blockers.length === 0,
         blockers
     };
@@ -196,6 +216,45 @@ function nonNegativeInt(value, fallback) {
         return Math.max(0, Math.floor(fallback || 0));
     return Math.floor(parsed);
 }
+function buildUtilizationProofConsistency(state, input) {
+    if (!state || typeof state !== 'object') {
+        return {
+            ok: true,
+            scheduler_max_active: 0,
+            proof_max_active: input.proofMaxActive,
+            wall_ms_delta: 0,
+            scheduler_active_slot_time_ms: 0,
+            proof_active_slot_time_ms: input.proofActiveSlotTimeMs,
+            active_slot_time_ms_delta: 0,
+            scheduler_observation_delay_tolerance_ms: 0
+        };
+    }
+    const schedulerMaxActive = nonNegativeInt(state.max_observed_active_slots, 0);
+    const schedulerWallMs = nonNegativeInt(state.wall_time_ms, 0);
+    const schedulerActiveSlotTimeMs = nonNegativeInt(state.active_slot_time_ms, 0);
+    const wallDelta = Math.abs(schedulerWallMs - input.proofWallMs);
+    const activeSlotDelta = Math.abs(schedulerActiveSlotTimeMs - input.proofActiveSlotTimeMs);
+    const maxActiveDelta = Math.abs(schedulerMaxActive - input.proofMaxActive);
+    const wallToleranceMs = Math.max(500, Math.round(Math.max(schedulerWallMs, input.proofWallMs) * 0.25));
+    const activeSlotToleranceMs = Math.max(500, Math.round(Math.max(schedulerActiveSlotTimeMs, input.proofActiveSlotTimeMs) * 0.25));
+    const observationDelayToleranceMs = Math.max(activeSlotToleranceMs, wallDelta * Math.max(1, schedulerMaxActive));
+    const wallConsistent = wallDelta <= wallToleranceMs;
+    const activeSlotConsistent = schedulerActiveSlotTimeMs > 0 && input.proofActiveSlotTimeMs > 0 && (activeSlotDelta <= activeSlotToleranceMs
+        || (schedulerActiveSlotTimeMs >= input.proofActiveSlotTimeMs && activeSlotDelta <= observationDelayToleranceMs));
+    return {
+        ok: maxActiveDelta <= 1 && (wallConsistent || activeSlotConsistent),
+        scheduler_max_active: schedulerMaxActive,
+        proof_max_active: input.proofMaxActive,
+        wall_ms_delta: wallDelta,
+        scheduler_active_slot_time_ms: schedulerActiveSlotTimeMs,
+        proof_active_slot_time_ms: input.proofActiveSlotTimeMs,
+        active_slot_time_ms_delta: activeSlotDelta,
+        scheduler_observation_delay_tolerance_ms: observationDelayToleranceMs
+    };
+}
+function activeSlotTimeMsFromWindows(windows) {
+    return windows.reduce((sum, window) => sum + Math.max(0, window.end_ms - window.start_ms) * Math.max(0, window.active_workers), 0);
+}
 function coalesceOverlapWindows(windows) {
     return windows
         .filter((window) => window.end_ms > window.start_ms)

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { findLatestMission, missionDir } from '../mission.js';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+export const RUNTIME_PROOF_SUMMARY_SCHEMA = 'sks.runtime-proof-summary.v1';
+export async function buildRuntimeProofSummary(root, missionIdInput = 'latest') {
+    const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
+    if (!missionId)
+        throw new Error('runtime_proof_summary_mission_missing');
+    const dir = missionDir(root, missionId);
+    const agentsDir = path.join(dir, 'agents');
+    const parallel = await readJson(path.join(agentsDir, 'parallel-runtime-proof.json'), null);
+    const scheduler = await readJson(path.join(agentsDir, 'agent-scheduler-state.json'), null);
+    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 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);
+    const headlessWorkers = Number(parallel?.headless_workers ?? swarm?.headless_overflow_worker_count ?? Math.max(0, targetActive - visiblePanes));
+    const blockers = [
+        ...(!parallel ? ['parallel_runtime_proof_missing'] : []),
+        ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
+        ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
+        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : [])
+    ].map(String);
+    const summary = {
+        schema: RUNTIME_PROOF_SUMMARY_SCHEMA,
+        ok: blockers.length === 0,
+        mission_id: missionId,
+        generated_at: new Date().toISOString(),
+        parallel: {
+            max_active_workers: Number(parallel?.max_observed_active_workers || scheduler?.max_observed_active_slots || 0),
+            unique_worker_pids: Number(parallel?.unique_worker_pids || uniqueNumbers(swarm?.process_ids).length || 0),
+            speedup_ratio: Number(parallel?.speedup_ratio || 0),
+            proof_passed: parallel?.passed === true
+        },
+        ui: {
+            visible_panes: visiblePanes,
+            headless_workers: headlessWorkers,
+            telemetry_age_ms: telemetryAgeMs,
+            stale: telemetryAgeMs > 3000
+        },
+        model_calls: {
+            max_observed: Number(parallel?.max_observed_model_calls || 0),
+            unique_model_call_ids: Number(parallel?.unique_model_call_ids || 0)
+        },
+        scheduler: {
+            largest_batch_size: Number(scheduler?.largest_batch_size || 0),
+            utilization: Number(scheduler?.scheduler_utilization || 0)
+        },
+        blockers
+    };
+    await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
+    return summary;
+}
+export function renderRuntimeProofSummary(summary) {
+    return [
+        `Parallel proof: ${summary.parallel.proof_passed ? 'passed' : 'blocked'}`,
+        `Active workers: ${summary.parallel.max_active_workers}`,
+        `Unique PIDs: ${summary.parallel.unique_worker_pids}`,
+        `Speedup: ${summary.parallel.speedup_ratio}x`,
+        `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.blockers.length ? [`Blockers: ${summary.blockers.join(', ')}`] : [])
+    ].join('\n');
+}
+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;
+}
+function uniqueNumbers(values) {
+    return [...new Set((Array.isArray(values) ? values : []).map((value) => Number(value)).filter((value) => Number.isFinite(value)))];
+}
+//# sourceMappingURL=runtime-proof-summary.js.map